return Ok(())

    }

    //--------------------------------------------------------------------------

    // Utilities

    //--------------------------------------------------------------------------

    /// 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;

        let mut cur_relative_pos = block.scope_node.relative_pos_in_parent;

        loop {

            if let Scope::Definition(definition_id) = scope {

                // At outer scope, check parameters of function/component

                for parameter_id in ctx.heap[definition_id].parameters() {

                    let parameter = &ctx.heap[*parameter_id];

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

        block.locals.push(id);

        let local = &mut ctx.heap[id];

        local.relative_pos_in_block = relative_pos;

        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() {

                // Definition scope, need to check arguments to definition

                match scope {

                    Scope::Definition(definition_id) => {

                        let definition = &ctx.heap[*definition_id];

                        for parameter_id in definition.parameters() {

                            let parameter = &ctx.heap[*parameter_id];