Ok(UnionVariantDefinition{

                    span: InputSpan::from_positions(identifier.span.begin, close_pos),

                    identifier,

                    value

                })

            },

            &mut variants_section, "a union variant", "a list of union variants", None

        )?;

        // Transfer to AST

        let union_def = ctx.heap[definition_id].as_union_mut();

        union_def.variants = variants_section.into_vec();

        Ok(())

    }

    fn visit_function_definition(

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

    ) -> Result<(), ParseError> {

        // Retrieve function name

        consume_exact_ident(&module.source, iter, KW_FUNCTION)?;

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

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

                return Ok(id.upcast());

            } else if ident == KW_STMT_CONTINUE {

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

                return Ok(id.upcast());

            } else if ident == KW_STMT_SYNC {

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

                return Ok(id.upcast());

            } else if ident == KW_STMT_FORK {

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

                let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement {

                    this,

                    start_fork: id,

                    next: StatementId::new_invalid(),

                });

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

                fork_stmt.end_fork = end_fork;

                return Ok(id.upcast());

            } else if ident == KW_STMT_SELECT {

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

                return Ok(id.upcast());

            } else if ident == KW_STMT_RETURN {

                    &module.source, iter.last_valid_pos(), "expected a statement or '}'"

                ));

            }

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

            stmt_section.push(stmt_id);

            next = iter.next();

        }

        let statements = stmt_section.into_vec();

        let mut block_span = consume_token(&module.source, iter, TokenKind::CloseCurly)?;

        block_span.begin = open_curly_span.begin;

        let block_id = ctx.heap.alloc_block_statement(|this| BlockStatement{

            this,

            is_implicit: false,

            span: block_span,

            statements,

            end_block: EndBlockStatementId::new_invalid(),

            scope: ScopeId::new_invalid(),

            next: StatementId::new_invalid(),

        });

        let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Block(block_id)));

        let end_block_id = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{

            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{

            this,

            start_while: while_stmt_id,

            next: StatementId::new_invalid(),

        });

        let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::While(while_stmt_id)));

        let while_stmt = &mut ctx.heap[while_stmt_id];

        while_stmt.scope = scope_id;

        while_stmt.end_while = end_while_stmt_id;

        Ok(while_stmt_id)

    }

    fn consume_break_statement(

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

    ) -> Result<BreakStatementId, ParseError> {

        let break_span = consume_exact_ident(&module.source, iter, KW_STMT_BREAK)?;

        let label = if Some(TokenKind::Ident) == iter.next() {

            let label = consume_ident_interned(&module.source, iter, ctx)?;

            Some(label)

        } else {

            None

        };

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

}

macro_rules! assign_and_replace_next_stmt {

    ($self:ident, $ctx:ident, $stmt_id:expr) => {

        if !$self.prev_stmt.is_invalid() {

            $ctx.heap[$self.prev_stmt].link_next($stmt_id);

        }

        $self.prev_stmt = $stmt_id;

    }

}

impl Visitor for PassValidationLinking {

    fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {

        debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::TypesAddedToTable);

        let root = &ctx.heap[ctx.module().root_id];

        let section = self.definition_buffer.start_section_initialized(&root.definitions);

        for definition_id in section.iter_copied() {

            self.visit_definition(ctx, definition_id)?;

        }

        section.forget();

        ctx.module_mut().phase = ModuleCompilationPhase::ValidatedAndLinked;

        Ok(())

    }

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

    // 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 block_stmt = &ctx.heap[id];

        let end_block_id = block_stmt.end_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 {

        let stmt = &ctx.heap[id];

        let body_id = stmt.body;

        self.checked_add_label(ctx, self.relative_pos_in_parent, self.in_sync, id)?;

        self.visit_stmt(ctx, body_id)?;

        Ok(())

    }

    fn visit_if_stmt(&mut self, ctx: &mut Ctx, id: IfStatementId) -> VisitorResult {

        let if_stmt = &ctx.heap[id];

        let end_if_id = if_stmt.end_if;

        let test_expr_id = if_stmt.test;

        let true_case = if_stmt.true_case;

        let false_case = if_stmt.false_case;

        // Visit test expression

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

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

        self.in_test_expr = id.upcast();

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

        self.visit_expr(ctx, test_expr_id)?;

        self.in_test_expr = StatementId::new_invalid();

        // Select statements may only occur inside sync blocks

        if self.in_sync.is_invalid() {

            return Err(ParseError::new_error_str_at_span(

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

                "select statements may only occur inside sync blocks"

            ));

        }

        if !self.def_type.is_primitive() {

            return Err(ParseError::new_error_str_at_span(

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

                "select statements may only be used in primitive components"

            ));

        }

        // Visit the various arms in the select block

        let mut case_stmt_ids = self.statement_buffer.start_section();

        let mut case_scope_ids = self.scope_buffer.start_section();

        let num_cases = select_stmt.cases.len();

        for case in &select_stmt.cases {

            // We add them in pairs, so the subsequent for-loop retrieves in pairs

            case_stmt_ids.push(case.guard);

            case_stmt_ids.push(case.body);

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

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

        debug_assert_eq!(ctx.heap[id].expressions.len(), 1);

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

        self.visit_expr(ctx, ctx.heap[id].expressions[0])?;

        self.expr_parent = ExpressionParent::None;

        Ok(())

    }

    fn visit_goto_stmt(&mut self, ctx: &mut Ctx, id: GotoStatementId) -> VisitorResult {

        self.control_flow_stmts.push(ControlFlowStatement{

            in_sync: self.in_sync,

            in_while: self.in_while,

            in_scope: self.cur_scope,

            statement: id.upcast(),

        });

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

        Ok(())

    }

    fn visit_new_stmt(&mut self, ctx: &mut Ctx, id: NewStatementId) -> VisitorResult {

        // Make sure the new statement occurs inside a composite component

        if !self.def_type.is_composite() {

            DefinedTypeVariant::Function(definition) => definition.arguments.len(),

            DefinedTypeVariant::Component(definition) => definition.arguments.len(),

            v => unreachable!("encountered {} type in call expression", v.type_class()),

        };

        let num_provided_args = call_expr.arguments.len();

        if num_provided_args != num_expected_args {

            let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };

            let call_span = call_expr.full_span;

            return Err(ParseError::new_error_at_span(

                &ctx.module().source, call_span, format!(

                    "expected {} {}, but {} were provided",

                    num_expected_args, argument_text, num_provided_args

                )

            ));

        }

        // Recurse into all of the arguments and set the expression's parent

        let upcast_id = id.upcast();

        let section = self.expression_buffer.start_section_initialized(&call_expr.arguments);

        let old_expr_parent = self.expr_parent;

        call_expr.parent = old_expr_parent;

        call_expr.unique_id_in_definition = self.next_expr_index;

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

                            debug_assert_eq!(idx, 0);

                            true

                        }

                        Expression::Literal(lit_expr) => {

                            // Only struct, unions, tuples and arrays can

                            // have subexpressions, so we're always fine

                            if cfg!(debug_assertions) {

                                match lit_expr.value {

                                    Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) | Literal::Tuple(_) => {},

                                    _ => unreachable!(),

                                }

                            }

                            true

                        },

                        _ => false,

                    }

                },

                _ => {

                    false

                }

            };

            if !is_valid_binding {

                    }],

                    full_span: bound_identifier.span

                },

                identifier: bound_identifier,

                relative_pos_in_parent: 0,

                unique_id_in_scope: -1,

            });

            let scope_id = match &ctx.heap[self.in_test_expr] {

                Statement::If(stmt) => stmt.true_case.scope,

                Statement::While(stmt) => stmt.scope,

                _ => unreachable!(),

            };

            self.checked_at_single_scope_add_local(ctx, scope_id, -1, bound_variable_id)?; // add at -1 such that first statement can find the variable if needed

            is_binding_target = true;

            bound_variable_id

        };

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

        var_expr.declaration = Some(variable_id);

        var_expr.used_as_binding_target = is_binding_target;

        var_expr.parent = self.expr_parent;

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

        scope.first_unique_id_in_scope = variable_counter;

        let variable_section = self.variable_buffer.start_section_initialized(&scope.variables);

        let child_scope_section = self.scope_buffer.start_section_initialized(&scope.nested);

        let mut variable_index = 0;

        let mut child_scope_index = 0;

        loop {

            // Determine relative positions of variable and scope to determine

            // which one occurs first within the current scope.

            let variable_relative_pos;

            if variable_index < variable_section.len() {

                let variable_id = variable_section[variable_index];

                let variable = &ctx.heap[variable_id];

                variable_relative_pos = variable.relative_pos_in_parent;

            } else {

                variable_relative_pos = i32::MAX;

            }

            let child_scope_relative_pos;

            if child_scope_index < child_scope_section.len() {

                let child_scope_id = child_scope_section[child_scope_index];

                    let target_while_stmt = &ctx.heap[target_while_id];

                    let target_end_while_id = target_while_stmt.end_while;

                    debug_assert!(!target_end_while_id.is_invalid());

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

                    break_stmt.target = target_end_while_id;

                },

                Statement::Continue(stmt) => {

                    let stmt_id = stmt.this;

                    let target_while_id = Self::resolve_break_or_continue_target(ctx, entry, stmt.span, &stmt.label)?;

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

                    continue_stmt.target = target_while_id;

                },

                Statement::Goto(stmt) => {

                    let stmt_id = stmt.this;

                    let target_id = Self::find_label(entry.in_scope, ctx, &stmt.label)?;

                    let target_stmt = &ctx.heap[target_id];

                    if entry.in_sync != target_stmt.in_sync {

                        // Nested sync not allowed. And goto can only go to

                        // outer scopes, so we must be escaping from a sync.

                        debug_assert!(target_stmt.in_sync.is_invalid());    // target not in sync

                        debug_assert!(!entry.in_sync.is_invalid()); // but the goto is in sync

                        let goto_stmt = &ctx.heap[stmt_id];

                        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