// Retrieve preallocated DefinitionId

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        self.cur_definition = definition_id;

        consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;

        // Parse function's argument list

        let mut parameter_section = self.variables.start_section();

        consume_parameter_list(

            &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id

        )?;

        let parameters = parameter_section.into_vec();

        // Consume return types

        consume_token(&module.source, iter, TokenKind::ArrowRight)?;

        let poly_vars = ctx.heap[definition_id].poly_vars();

        let parser_type = self.type_parser.consume_parser_type(

            iter, &ctx.heap, &module.source, &ctx.symbols, poly_vars, definition_id,

            module_scope, false, None

        )?;

        // Consume block and the definition's scope

        // Assign everything in the preallocated AST node

        let function = ctx.heap[definition_id].as_function_mut();

        function.return_type = parser_type;

        function.parameters = parameters;

        Ok(())

    }

    fn visit_component_definition(

        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

    ) -> Result<(), ParseError> {

        // Consume component variant and name

        let (_variant_text, _) = consume_any_ident(&module.source, iter)?;

        debug_assert!(_variant_text == KW_PRIMITIVE || _variant_text == KW_COMPOSITE);

        let (ident_text, _) = consume_ident(&module.source, iter)?;

        // Retrieve preallocated definition

        let module_scope = SymbolScope::Module(module.root_id);

        let definition_id = ctx.symbols.get_symbol_by_name_defined_in_scope(module_scope, ident_text)

            .unwrap().variant.as_definition().definition_id;

        self.cur_definition = definition_id;

        consume_polymorphic_vars_spilled(&module.source, iter, ctx)?;

        // Parse component's argument list

        let mut parameter_section = self.variables.start_section();

        consume_parameter_list(

            &mut self.type_parser, &module.source, iter, ctx, &mut parameter_section, module_scope, definition_id

        )?;

        let parameters = parameter_section.into_vec();

        // Consume block

        // Assign everything in the AST node

        let component = ctx.heap[definition_id].as_component_mut();

        component.parameters = parameters;

        Ok(())

    }

    /// Consumes a statement and returns a boolean indicating whether it was a

    /// block or not.

    fn consume_statement(&mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx) -> Result<StatementId, ParseError> {

        let next = iter.next().expect("consume_statement has a next token");

        if next == TokenKind::OpenCurly {

            let id = self.consume_block_statement(module, iter, ctx)?;

            return Ok(id.upcast());

        } else if next == TokenKind::Ident {

            let ident = peek_ident(&module.source, iter).unwrap();

            if ident == KW_STMT_IF {

                // Consume if statement and place end-if statement directly

                // after it.

                let id = self.consume_if_statement(module, iter, ctx)?;

                return Ok(id.upcast());

            } else if ident == KW_STMT_WHILE {

                let id = self.consume_while_statement(module, iter, ctx)?;

                return Ok(id.upcast());

            } else if ident == KW_STMT_BREAK {

                let id = self.consume_break_statement(module, iter, ctx)?;

            this, start_block: block_id, next: StatementId::new_invalid()

        });

        let block_stmt = &mut ctx.heap[block_id];

        block_stmt.end_block = end_block_id;

        block_stmt.scope = scope_id;

        Ok(block_id)

    }

    fn consume_if_statement(

        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

    ) -> Result<IfStatementId, ParseError> {

        let if_span = consume_exact_ident(&module.source, iter, KW_STMT_IF)?;

        consume_token(&module.source, iter, TokenKind::OpenParen)?;

        let test = self.consume_expression(module, iter, ctx)?;

        consume_token(&module.source, iter, TokenKind::CloseParen)?;

        // Consume bodies of if-statement

        let true_body = IfStatementCase{

            body: self.consume_statement(module, iter, ctx)?,

            scope: ScopeId::new_invalid(),

        };

            iter.consume();

            let false_body = IfStatementCase{

                body: self.consume_statement(module, iter, ctx)?,

                scope: ScopeId::new_invalid(),

            };

            let false_body_scope_id = false_body.scope;

        } else {

        };

        // Construct AST elements

        let if_stmt_id = ctx.heap.alloc_if_statement(|this| IfStatement{

            this,

            span: if_span,

            test,

            true_case: true_body,

            false_case: false_body,

            end_if: EndIfStatementId::new_invalid(),

        });

        let end_if_stmt_id = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{

            this,

            start_if: if_stmt_id,

            next: StatementId::new_invalid(),

        });

        let true_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(if_stmt_id, true)));

        let if_stmt = &mut ctx.heap[if_stmt_id];

        if_stmt.end_if = end_if_stmt_id;

        if_stmt.true_case.scope = true_scope_id;

        if let Some(false_case) = &mut if_stmt.false_case {

        }

        return Ok(if_stmt_id);

    }

    fn consume_while_statement(

        &mut self, module: &Module, iter: &mut TokenIter, ctx: &mut PassCtx

    ) -> Result<WhileStatementId, ParseError> {

        let while_span = consume_exact_ident(&module.source, iter, KW_STMT_WHILE)?;

        consume_token(&module.source, iter, TokenKind::OpenParen)?;

        let test = self.consume_expression(module, iter, ctx)?;

        consume_token(&module.source, iter, TokenKind::CloseParen)?;

        let body = self.consume_statement(module, iter, ctx)?;

        let while_stmt_id = ctx.heap.alloc_while_statement(|this| WhileStatement{

            this,

            span: while_span,

            test,

            scope: ScopeId::new_invalid(),

            body,

            end_while: EndWhileStatementId::new_invalid(),

            in_sync: SynchronousStatementId::new_invalid(),

        });

        let end_while_stmt_id = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement{

    }

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

    // Definition visitors

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

    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {

        self.reset_state();

        let definition = &ctx.heap[id];

        self.def_type = match &definition.variant {

            ComponentVariant::Primitive => DefinitionType::Primitive(id),

            ComponentVariant::Composite => DefinitionType::Composite(id),

        };

        self.expr_parent = ExpressionParent::None;

        // Visit parameters and assign a unique scope ID

        let definition_scope_id = definition.scope;

        let old_scope = self.push_scope(ctx, true, definition_scope_id);

        let definition = &ctx.heap[id];

        let body_id = definition.body;

        let section = self.variable_buffer.start_section_initialized(&definition.parameters);

        for variable_idx in 0..section.len() {

            let variable_id = section[variable_idx];

        }

        self.relative_pos_in_parent = section.len() as i32;

        section.forget();

        // Visit statements in component body

        self.visit_block_stmt(ctx, body_id)?;

        self.pop_scope(old_scope);

        // Assign total number of expressions and assign an in-block unique ID

        // to each of the locals in the procedure.

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

        let definition_scope = definition.scope;

        definition.num_expressions_in_body = self.next_expr_index;

        self.visit_scope_and_assign_local_ids(ctx, definition_scope, 0);

        self.resolve_pending_control_flow_targets(ctx)?;

        Ok(())

    }

    fn visit_function_definition(&mut self, ctx: &mut Ctx, id: FunctionDefinitionId) -> VisitorResult {

        self.reset_state();

        // Set internal statement indices

        self.def_type = DefinitionType::Function(id);

        self.expr_parent = ExpressionParent::None;

        // Visit parameters and assign a unique scope ID

        let definition = &ctx.heap[id];

        let definition_scope_id = definition.scope;

        let old_scope = self.push_scope(ctx, true, definition_scope_id);

        let definition = &ctx.heap[id];

        let body_id = definition.body;

        let section = self.variable_buffer.start_section_initialized(&definition.parameters);

        for variable_idx in 0..section.len() {

            let variable_id = section[variable_idx];

        }

        section.forget();

        // Visit statements in function body

        self.visit_block_stmt(ctx, body_id)?;

        self.pop_scope(old_scope);

        // Assign total number of expressions and assign an in-block unique ID

        // to each of the locals in the procedure.

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

        let definition_scope = definition.scope;

        definition.num_expressions_in_body = self.next_expr_index;

        self.visit_scope_and_assign_local_ids(ctx, definition_scope, 0);

        self.resolve_pending_control_flow_targets(ctx)?;

        Ok(())

    }

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

    // Statement visitors

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

    fn visit_block_stmt(&mut self, ctx: &mut Ctx, id: BlockStatementId) -> VisitorResult {

        // Get end of block

        let scope_id = block_stmt.scope;

        // Traverse statements in block

        let statement_section = self.statement_buffer.start_section_initialized(&block_stmt.statements);

        let old_scope = self.push_scope(ctx, false, scope_id);

        assign_and_replace_next_stmt!(self, ctx, id.upcast());

        for stmt_idx in 0..statement_section.len() {

            self.relative_pos_in_parent = stmt_idx as i32;

            self.visit_stmt(ctx, statement_section[stmt_idx])?;

        }

        statement_section.forget();

        assign_and_replace_next_stmt!(self, ctx, end_block_id.upcast());

        self.pop_scope(old_scope);

        Ok(())

    }

    fn visit_local_memory_stmt(&mut self, ctx: &mut Ctx, id: MemoryStatementId) -> VisitorResult {

        let stmt = &ctx.heap[id];

        let expr_id = stmt.initial_expr;

        let variable_id = stmt.variable;

        self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_parent, variable_id)?;

        assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());

        debug_assert_eq!(self.expr_parent, ExpressionParent::None);

        self.expr_parent = ExpressionParent::Memory(id);

        self.visit_assignment_expr(ctx, expr_id)?;

        self.expr_parent = ExpressionParent::None;

        Ok(())

    }

    fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {

        let stmt = &ctx.heap[id];

        let from_id = stmt.from;

        let to_id = stmt.to;

        self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_parent, from_id)?;

        self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_parent, to_id)?;

        assign_and_replace_next_stmt!(self, ctx, id.upcast().upcast());

        Ok(())

    }

    fn visit_labeled_stmt(&mut self, ctx: &mut Ctx, id: LabeledStatementId) -> VisitorResult {

            case_scope_ids.push(case.scope);

        }

        assign_then_erase_next_stmt!(self, ctx, id.upcast());

        for index in 0..num_cases {

            let base_index = 2 * index;

            let guard_id     = case_stmt_ids[base_index];

            let case_body_id = case_stmt_ids[base_index + 1];

            let case_scope_id = case_scope_ids[index];

            // The guard statement ends up belonging to the block statement

            // following the arm. The reason we parse it separately is to

            // extract all of the "get" calls.

            let old_scope = self.push_scope(ctx, false, case_scope_id);

            // Visit the guard of this arm

            debug_assert!(self.in_select_guard.is_invalid());

            self.in_select_guard = id;

            self.in_select_arm = index as u32;

            self.visit_stmt(ctx, guard_id)?;

            self.in_select_guard = SelectStatementId::new_invalid();

            // Visit the code associated with the guard

            self.visit_stmt(ctx, case_body_id)?;

            self.pop_scope(old_scope);

            // Link up last statement in block to EndSelect

            assign_then_erase_next_stmt!(self, ctx, end_select_id.upcast());

        }

        self.in_select_guard = SelectStatementId::new_invalid();

        self.prev_stmt = end_select_id.upcast();

        Ok(())

    }

    fn visit_return_stmt(&mut self, ctx: &mut Ctx, id: ReturnStatementId) -> VisitorResult {

        // Check if "return" occurs within a function

        let stmt = &ctx.heap[id];

        if !self.def_type.is_function() {

            return Err(ParseError::new_error_str_at_span(

                &ctx.module().source, stmt.span,

                "return statements may only appear in function bodies"

            ));

        }

        // If here then we are within a function

        assign_then_erase_next_stmt!(self, ctx, id.upcast());

        self.next_expr_index += 1;

        for arg_expr_idx in 0..section.len() {

            let arg_expr_id = section[arg_expr_idx];

            self.expr_parent = ExpressionParent::Expression(upcast_id, arg_expr_idx as u32);

            self.visit_expr(ctx, arg_expr_id)?;

        }

        section.forget();

        self.expr_parent = old_expr_parent;

        Ok(())

    }

    fn visit_variable_expr(&mut self, ctx: &mut Ctx, id: VariableExpressionId) -> VisitorResult {

        let var_expr = &ctx.heap[id];

        // Check if declaration was already resolved (this occurs for the

        // variable expr that is on the LHS of the assignment expr that is

        // associated with a variable declaration)

        let mut variable_id = var_expr.declaration;

        let mut is_binding_target = false;

        // Otherwise try to find it

        if variable_id.is_none() {

            variable_id = self.find_variable(ctx, self.relative_pos_in_parent, &var_expr.identifier);

        }

        // Otherwise try to see if is a variable introduced by a binding expr

        let variable_id = if let Some(variable_id) = variable_id {

            variable_id

        } else {

            if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module().source, var_expr.identifier.span, "unresolved variable"

                ));

            }

            // This is a binding variable, but it may only appear in very

            // specific locations.

            let is_valid_binding = match self.expr_parent {

                ExpressionParent::Expression(expr_id, idx) => {

                    match &ctx.heap[expr_id] {

                        Expression::Binding(_binding_expr) => {

                            // Nested binding is disallowed, and because of

                            // the check above we know we're directly at the

                            // LHS of the binding expression

                            debug_assert_eq!(_binding_expr.this, self.in_binding_expr);

        var_expr.unique_id_in_definition = self.next_expr_index;

        self.next_expr_index += 1;

        Ok(())

    }

}

impl PassValidationLinking {

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

    // Special traversal

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

    /// Pushes a new scope associated with a particular statement. If that

    /// statement already has an associated scope (i.e. scope associated with

    /// sync statement or select statement's arm) then we won't do anything.

    /// In all cases the caller must call `pop_statement_scope` with the scope

    /// and relative scope position returned by this function.

    fn push_scope(&mut self, ctx: &mut Ctx, is_top_level_scope: bool, pushed_scope_id: ScopeId) -> (ScopeId, i32) {

        // Set the properties of the pushed scope (it is already created during

        // AST construction, but most values are not yet set to their correct

        // values)

        let old_scope_id = self.cur_scope;

        let scope = &mut ctx.heap[pushed_scope_id];

            scope.parent = Some(old_scope_id);

        }

        scope.relative_pos_in_parent = self.relative_pos_in_parent;

        let old_relative_pos = self.relative_pos_in_parent;

        self.relative_pos_in_parent = 0;

        // Link up scopes

        if !is_top_level_scope {

            let old_scope = &mut ctx.heap[old_scope_id];

            old_scope.nested.push(pushed_scope_id);

        }

        // Set as current traversal scope, then return old scope

        self.cur_scope = pushed_scope_id;

        return (old_scope_id, old_relative_pos)

    }

    fn pop_scope(&mut self, scope_to_restore: (ScopeId, i32)) {

        self.cur_scope = scope_to_restore.0;

        self.relative_pos_in_parent = scope_to_restore.1;

    }

    fn visit_scope_and_assign_local_ids(&mut self, ctx: &mut Ctx, scope_id: ScopeId, mut variable_counter: i32) {

                        let sync_stmt = &ctx.heap[entry.in_sync];

                        return Err(

                            ParseError::new_error_str_at_span(&ctx.module().source, goto_stmt.span, "goto may not escape the surrounding synchronous block")

                            .with_info_str_at_span(&ctx.module().source, target_stmt.label.span, "this is the target of the goto statement")

                            .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "which will jump past this statement")

                        );

                    }

                    let goto_stmt = &mut ctx.heap[stmt_id];

                    goto_stmt.target = target_id;

                },

                _ => unreachable!("cannot resolve control flow target for {:?}", stmt),

            }

        }

        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.

        // 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 mut scope = &ctx.heap[target_scope_id];

        let mut cur_relative_pos = scope.relative_pos_in_parent;

        while let Some(scope_parent_id) = scope.parent {

            scope = &ctx.heap[scope_parent_id];

            // Check for collisions

            for variable_id in scope.variables.iter().copied() {

                    return Err(

                        ParseError::new_error_str_at_span(

                        ).with_info_str_at_span(

                        )

                    );

                }

            }

            cur_relative_pos = scope.relative_pos_in_parent;

        }

        // No collisions in any of the parent scope, attempt to add to scope

    }

    /// Adds a local variable to the specified scope. Will check the specified

    /// scope for variable conflicts and the symbol table for global conflicts.

    /// Will NOT check parent scopes of the specified scope.

    fn checked_at_single_scope_add_local(

        &mut self, ctx: &mut Ctx, scope_id: ScopeId, relative_pos: i32, new_variable_id: VariableId

    ) -> Result<(), ParseError> {

        // Check the symbol table for conflicts

        {

            let cur_scope = SymbolScope::Definition(self.def_type.definition_id());

            let ident = &ctx.heap[new_variable_id].identifier;

            if let Some(symbol) = ctx.symbols.get_symbol_by_name(cur_scope, &ident.value.as_bytes()) {

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module().source, ident.span,

                    "local variable declaration conflicts with symbol"

                ).with_info_str_at_span(

                    &ctx.module().source, symbol.variant.span_of_introduction(&ctx.heap), "the conflicting symbol is introduced here"

                ));

            }

        }

        // Check the specified scope for conflicts

        let new_variable = &ctx.heap[new_variable_id];