/// Adds a local variable to the current scope. It will also annotate the

    /// `Local` in the AST with its relative position in the block.

    fn checked_add_local(&mut self, ctx: &mut Ctx, target_scope: Scope, target_relative_pos: i32, id: VariableId) -> Result<(), ParseError> {

        debug_assert!(target_scope.is_block());

        let local = &ctx.heap[id];

        // We immediately go to the parent scope. We check the target scope

        // in the call at the end. That is also where we check for collisions

        // with symbols.

        let block = &ctx.heap[target_scope.to_block()];

        let mut scope = block.scope_node.parent;

        Ok(())

    }

    /// Finds a variable in the visitor's scope that must appear before the

    /// specified relative position within that block.

    fn find_variable(&self, ctx: &Ctx, mut relative_pos: i32, identifier: &Identifier) -> Option<VariableId> {

        debug_assert!(self.cur_scope.is_block());

        // No need to use iterator over namespaces if here

        let mut scope = &self.cur_scope;

        loop {

            debug_assert!(scope.is_block());

            let block = &ctx.heap[scope.to_block()];

            for local_id in &block.locals {

                let local = &ctx.heap[*local_id];

                if local.relative_pos_in_block < relative_pos && identifier == &local.identifier {

                    return Some(*local_id);

                }

            }

            scope = &block.scope_node.parent;

            if !scope.is_block() {