pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut T> {

        self.store.iter_mut()

    }

    pub(crate) type_annotations: Arena<TypeAnnotation>,

    pub(crate) variables: Arena<Variable>,

    pub(crate) statements: Arena<Statement>,

    pub(crate) expressions: Arena<Expression>,

pub enum ScopeVariant {

    Regular(BlockStatementId),

    Synchronous((SynchronousStatementId, BlockStatementId)),

}

#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]

pub struct Scope {

    pub variant: ScopeVariant,

    pub parent: Option<Scope>,

    pub fn is_block(&self) -> bool {

        match &self.variant {

            ScopeVariant::Definition(_) => false,

            ScopeVariant::Regular(_) => true,

            ScopeVariant::Synchronous(_) => true,

        }

    }

        match &self.variant {

            ScopeVariant::Regular(id) => *id,

            ScopeVariant::Synchronous((_, id)) => *id,

            _ => panic!("unable to get BlockStatement from Scope")

    // Phase 2: linker

    pub relative_pos_in_block: u32,

    pub relative_pos_in_parent: u32,

    pub relative_pos_in_block: u32,

    pub relative_pos_in_block: u32,

    // Phase 2: linker

    pub end_if: Option<EndIfStatementId>,

    pub start_if: IfStatementId,

    pub end_while: Option<EndWhileStatementId>,

    pub start_while: Option<WhileStatementId>,

use crate::protocol::parser::{type_table::*, symbol_table::*, LexedModule};

use crate::protocol::inputsource::*;

use crate::protocol::ast::*;

type FnResult = Result<(), ParseError2>;

pub(crate) struct Ctx<'a> {

    module: &'a LexedModule,

    heap: &'a mut Heap,

    types: &'a TypeTable,

    symbols: &'a SymbolTable,

}

pub(crate) struct FunctionParser {

}

impl FunctionParser {

    pub(crate) fn new() -> Self {

        Self{}

    }

    pub(crate) fn visit_function_definition(&mut self, ctx: &mut Ctx, id: DefinitionId) -> FnResult {

        let body_id = ctx.heap[id].as_function().body;

        // Three passes:

        // 1. first pass: breadth first parsing of elements

        // 2. second pass: insert any new statments that we queued in the first pass

        // 3. third pass: traverse children

        for stmt_id in ctx.heap[body_id].as_block().statements.iter() {

            let stmt = &ctx.heap[*stmt_id];

            match stmt {

                Statement::Block(block) => {

                    // Mark for later traversal

                },

                Statement::Local(LocalStatement::Channel(stmt)) => {

                    return Err(ParseError2::new_error(&ctx.module.source, stmt.position, "Illegal channel instantiation in function"));

                },

                Statement::Local(LocalStatement::Memory(stmt)) => {

                    // Resolve type, add to locals

                },

                Statement::Skip(skip) => {},

                Statement::Labeled(label) => {

                    // Add label, then parse statement

                },

                Statement::If(stmt) => {

                    // Mark for later traversal,

                    // Mark for insertion of "EndIf"

                },

                Statement::EndIf(_) => {},

                Statement::While(stmt) => {

                    // Mark for later traversal

                    // Mark for insertion of "EndWhile"

                },

                Statement::EndWhile(_) => {},

                Statement::Break(stmt) => {

                    // Perform "break" resolving if labeled. If not labeled then

                    // use end-while statment

                },

                Statement::Continue(stmt) => {

                    // Perform "continue" resolving if labeled. If not labeled

                    // then use end-while statement

                },

                Statement::Synchronous(stmt) => {

                    // Illegal!

                },

                Statement::EndSynchronous(stmt) => {

                    // Illegal, but can't possibly be encountered here

                },

                Statement::Return(stmt) => {

                    // Return statement, should be used in control flow analysis

                    // somehow. Because we need every branch to have a "return"

                    // call in the language.

                },

                Statement::Assert(stmt) => {

                    // Not allowed in functions? Is allowed in functions?

                },

                Statement::Goto(stmt) => {

                    // Goto label resolving, may not skip definition of

                    // variables.

                },

                Statement::New(stmt) => {

                    // Illegal in functions?

                },

                Statement::Put(stmt) => {

                    // This really needs to be a builtin call...

                },

                Statement::Expression(expr) => {

                    // Bare expression, we must traverse in order to determine

                    // if all variables are properly resolved.

                }

            }

        }

        Ok(())

    }

}

mod visitor;

mod functions;

use type_table::TypeTable;

        let type_table = TypeTable::new(&symbol_table, &self.heap, &self.modules)?;

        // We should now be able to resolve all definitions and statements

        // using those definitions.

        // Temporary personal notes

        //  memory declaration = Statement::Local(Local::Memory(...))

        //      -> VariableId

        //      -> TypeAnnotationId

        //      -> PrimitiveType::Symbolic variant

        //      -> Option<DefinitionId> field

        //  method call = Expression::Call

        //      -> Method::Symbolic field

        //      -> Option<DefinitionId> field

        // TODO: I might not actually want to do this here

        module_index = 0;

        let mut definition_index = 0;

        let mut statement_index = 0;

        loop {

            if module_index >= self.modules.len() {

                break;

            }

            let module_root_id = self.modules[module_index].root_id;

            let statement_id = {

                let root = &self.heap[module_root_id];

                if statement_index >= root.

            }

        }

    return_type: TypeAnnotationId,

    pub(crate) fn new(

        // Helper to handle the return value from lookup_type_definition. If

        // resolved/builtin we return `true`, if an error we complete the error

        // and return it. If unresolved then we check for cyclic types and

        // return an error if cyclic, otherwise return false (indicating we need

        // to continue in the breadcrumb-based resolving loop)

        let handle_lookup_result = |

            heap: &Heap, all_modules: &[LexedModule], cur_module: &LexedModule,

            breadcrumbs: &mut Vec<Breadcrumb>, result: LookupResult

        | -> Result<bool, ParseError2> {

            return match result {

                LookupResult::BuiltIn | LookupResult::Resolved(_) => Ok(true),

                LookupResult::Unresolved((new_root_id, new_definition_id)) => {

                    // Check for cyclic dependencies

                    let mut is_cyclic = false;

                    for breadcrumb in breadcrumbs.iter() {

                        let (root_id, definition_id) = match breadcrumb {

                            Breadcrumb::Linear((root_index, definition_index)) => {

                                let root_id = all_modules[*root_index].root_id;

                                let definition_id = heap[root_id].definitions[*definition_index];

                                (root_id, definition_id)

                            },

                            Breadcrumb::Jumping(root_id_and_definition_id) => *root_id_and_definition_id

                        };

                        if root_id == new_root_id && definition_id == new_definition_id {

                            // Oh noes!

                            is_cyclic = true;

                            break;

                        }

                    }

                    if is_cyclic {

                        let mut error = ParseError2::new_error(

                            &all_modules[new_root_id.0.index as usize].source,

                            heap[new_definition_id].position(),

                            "Evaluating this definition results in a a cyclic dependency"

                        );

                        for (index, breadcrumb) in breadcrumbs.iter().enumerate() {

                            match breadcrumb {

                                Breadcrumb::Linear((root_index, definition_index)) => {

                                    debug_assert_eq!(index, 0);

                                    error = error.with_postfixed_info(

                                        &all_modules[*root_index].source,

                                        heap[heap[all_modules[*root_index].root_id].definitions[*definition_index]].position(),

                                        "The cycle started with this definition"

                                    )

                                },

                                Breadcrumb::Jumping((root_id, definition_id)) => {

                                    debug_assert!(index > 0);

                                    error = error.with_postfixed_info(

                                        &all_modules[root_id.0.index as usize].source,

                                        heap[*definition_id].position(),

                                        "Which depends on this definition"

                                    )

                                }

                            }

                        }

                        Err(error)

                    } else {

                        breadcrumbs.push(Breadcrumb::Jumping((new_root_id, new_definition_id)));

                        Ok(false)

                    }

                },

                LookupResult::Error((position, message)) => {

                    Err(ParseError2::new_error(&cur_module.source, position, &message))

                }

            }

        };

                                    let lookup_result = lookup_type_definition(

                                    );

                                    if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {

                                        continue 'resolve_loop;

                            let lookup_result = lookup_type_definition(

                            );

                            if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {

                                continue 'resolve_loop;

                            let lookup_result = lookup_type_definition(

                            );

                            if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {

                                continue 'resolve_loop;

                        // Handle checking the return type

                        let lookup_result = lookup_type_definition(

                            heap, &table, symbols, module.root_id,

                            &heap[definition.return_type].the_type.primitive

                        );

                        if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {

                            continue 'resolve_loop;

                        }

                        for parameter_id in &definition.parameters {

                            let parameter = &heap[*parameter_id];

                            let type_definition = &heap[parameter.type_annotation];

                            let lookup_result = lookup_type_definition(

                                heap, &table, symbols, module.root_id,

                                &type_definition.the_type.primitive

                            );

                            if !handle_lookup_result(heap, modules, module, &mut breadcrumbs, lookup_result)? {

                                continue 'resolve_loop;

                            }

                        }

                        // Resolve function's types

                        let mut parameters = Vec::with_capacity(definition.parameters.len());

                        for parameter_id in &definition.parameters {

                            let parameter = &heap[*parameter_id];

                            let type_definition = &heap[parameter.type_annotation];

                            if cfg!(debug_assertions) {

                                ensure_type_definition(heap, &table, symbols, module.root_id, &type_definition.the_type.primitive);

                            }

                            parameters.push(FunctionArgument{

                                identifier: parameter.identifier.clone(),

                                argument_type: parameter.type_annotation

                            });

                        }

                        table.add_definition(definition_id, DefinedType::Function(FunctionType{

                            return_type: definition.return_type.clone(),

                            arguments: parameters,

                        }));

use crate::protocol::ast::*;

use crate::protocol::inputsource::*;

use crate::protocol::library;

use crate::protocol::parser::{symbol_table::*, type_table::*, LexedModule};

type Unit = ();

pub(crate) type VisitorResult = Result<Unit, ParseError2>;

pub(crate) struct Ctx<'p> {

    heap: &'p mut Heap,

    module: &'p LexedModule,

    symbols: &'p mut SymbolTable,

    types: &'p mut TypeTable,

}

pub(crate) trait Visitor2 {

    // Entry point

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

        let mut def_index = 0;

        loop {

            let definition_id = {

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

                if def_index >= root.definitions.len() {

                    return Ok(())

                }

                root.definitions[def_index]

            };

            self.visit_definition(ctx, definition_id)

        }

    }

    // Definitions

    // --- enum matching

    fn visit_definition(&mut self, ctx: &mut Ctx, id: DefinitionId) -> VisitorResult {

        match &ctx.heap[id] {

            Definition::Enum(def) => self.visit_enum_definition(ctx, def.this),

            Definition::Struct(def) => self.visit_struct_definition(ctx, def.this),

            Definition::Component(def) => self.visit_component_definition(ctx, def.this),

            Definition::Function(def) => self.visit_function_definition(ctx, def.this)

        }

    }

    // --- enum variant handling

    fn visit_enum_definition(&mut self, _ctx: &mut Ctx, id: EnumId) -> VisitorResult { Ok(()) }

    fn visit_struct_definition(&mut self, _ctx: &mut Ctx, id: StructId) -> VisitorResult { Ok(()) }

    fn visit_component_definition(&mut self, _ctx: &mut Ctx, id: ComponentId) -> VisitorResult { Ok(()) }

    fn visit_function_definition(&mut self, _ctx: &mut Ctx, id: FunctionId) -> VisitorResult { Ok(()) }

    // Statements

    // --- enum matching

    fn visit_stmt(&mut self, ctx: &mut Ctx, id: StatementId) -> VisitorResult {

        match &ctx.heap[id] {

            Statement::Block(stmt) => self.visit_block_stmt(ctx, stmt.this),

            Statement::Local(stmt) => self.visit_local_stmt(ctx, stmt.this),

            Statement::Skip(stmt) => self.visit_skip_stmt(ctx, stmt.this),

            Statement::Labeled(stmt) => self.visit_labeled_stmt(ctx, stmt.this),

            Statement::If(stmt) => self.visit_if_stmt(ctx, stmt.this),

            Statement::EndIf(_stmt) => Ok(()),

            Statement::While(stmt) => self.visit_while_stmt(ctx, stmt.this),

            Statement::EndWhile(_stmt) => Ok(()),

            Statement::Break(stmt) => self.visit_break_stmt(ctx, stmt.this),

            Statement::Continue(stmt) => self.visit_continue_stmt(ctx, stmt.this),

            Statement::Synchronous(stmt) => self.visit_synchronous_stmt(ctx, stmt.this),

            Statement::EndSynchronous(_stmt) => Ok(()),

            Statement::Return(stmt) => self.visit_return_stmt(ctx, stmt.this),

            Statement::Assert(stmt) => self.visit_assert_stmt(ctx, stmt.this),

            Statement::Goto(stmt) => self.visit_goto_stmt(ctx, stmt.this),

            Statement::New(stmt) => self.visit_new_stmt(ctx, stmt.this),

            Statement::Put(stmt) => self.visit_put_stmt(ctx, stmt.this),

            Statement::Expression(stmt) => self.visit_expr_stmt(ctx, stmt.this),

        }

    }

    fn visit_local_stmt(&mut self, ctx: &mut Ctx, id: LocalStatementId) -> VisitorResult {

        match &ctx.heap[id] {

            LocalStatement::Channel(stmt) => self.visit_local_channel_stmt(ctx, stmt.this),

            LocalStatement::Memory(stmt) => self.visit_local_memory_stmt(ctx, stmt.this),

        }

    }

    // --- enum variant handling

    fn visit_block_stmt(&mut self, _ctx: &mut Ctx, _id: BlockStatementId) -> VisitorResult { Ok(()) }

    fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult { Ok(()) }

    fn visit_local_channel_stmt(&mut self, _ctx: &mut Ctx, _id: ChannelStatementId) -> VisitorResult { Ok(()) }

    fn visit_skip_stmt(&mut self, _ctx: &mut Ctx, _id: SkipStatementId) -> VisitorResult { Ok(()) }

    fn visit_labeled_stmt(&mut self, _ctx: &mut Ctx, _id: LabeledStatementId) -> VisitorResult { Ok(()) }

    fn visit_if_stmt(&mut self, _ctx: &mut Ctx, _id: IfStatementId) -> VisitorResult { Ok(()) }

    fn visit_while_stmt(&mut self, _ctx: &mut Ctx, _id: WhileStatementId) -> VisitorResult { Ok(()) }

    fn visit_break_stmt(&mut self, _ctx: &mut Ctx, _id: BreakStatementId) -> VisitorResult { Ok(()) }

    fn visit_continue_stmt(&mut self, _ctx: &mut Ctx, _id: ContinueStatementId) -> VisitorResult { Ok(()) }

    fn visit_synchronous_stmt(&mut self, _ctx: &mut Ctx, _id: SynchronousStatementId) -> VisitorResult { Ok(()) }

    fn visit_return_stmt(&mut self, _ctx: &mut Ctx, _id: ReturnStatementId) -> VisitorResult { Ok(()) }

    fn visit_assert_stmt(&mut self, _ctx: &mut Ctx, _id: AssertStatementId) -> VisitorResult { Ok(()) }

    fn visit_goto_stmt(&mut self, _ctx: &mut Ctx, _id: GotoStatementId) -> VisitorResult { Ok(()) }

    fn visit_new_stmt(&mut self, _ctx: &mut Ctx, _id: NewStatementId) -> VisitorResult { Ok(()) }

    fn visit_put_stmt(&mut self, _ctx: &mut Ctx, _id: PutStatementId) -> VisitorResult { Ok(()) }

    fn visit_expr_stmt(&mut self, _ctx: &mut Ctx, _id: ExpressionStatementId) -> VisitorResult { Ok(()) }

    // Expressions

    // --- enum matching

    fn visit_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> VisitorResult {

        match &ctx.heap[id] {

            Expression::Assignment(expr) => self.visit_assignment_expr(ctx, expr.this),

            Expression::Conditional(expr) => self.visit_conditional_expr(ctx, expr.this),

            Expression::Binary(expr) => self.visit_binary_expr(ctx, expr.this),

            Expression::Unary(expr) => self.visit_unary_expr(ctx, expr.this),

            Expression::Indexing(expr) => self.visit_indexing_expr(ctx, expr.this),

            Expression::Slicing(expr) => self.visit_slicing_expr(ctx, expr.this),

            Expression::Select(expr) => self.visit_select_expr(ctx, expr.this),

            Expression::Array(expr) => self.visit_array_expr(ctx, expr.this),

            Expression::Constant(expr) => self.visit_constant_expr(ctx, expr.this),

            Expression::Call(expr) => self.visit_call_expr(ctx, expr.this),

            Expression::Variable(expr) => self.visit_variable_expr(ctx, expr.this),

        }

    }

    fn visit_assignment_expr(&mut self, _ctx: &mut Ctx, _id: AssignmentExpressionId) -> VisitorResult { Ok(()) }

    fn visit_conditional_expr(&mut self, _ctx: &mut Ctx, _id: ConditionalExpressionId) -> VisitorResult { Ok(()) }

    fn visit_binary_expr(&mut self, _ctx: &mut Ctx, _id: BinaryExpressionId) -> VisitorResult { Ok(()) }

    fn visit_unary_expr(&mut self, _ctx: &mut Ctx, _id: UnaryExpressionId) -> VisitorResult { Ok(()) }

    fn visit_indexing_expr(&mut self, _ctx: &mut Ctx, _id: IndexingExpressionId) -> VisitorResult { Ok(()) }

    fn visit_slicing_expr(&mut self, _ctx: &mut Ctx, _id: SlicingExpressionId) -> VisitorResult { Ok(()) }

    fn visit_select_expr(&mut self, _ctx: &mut Ctx, _id: SelectExpressionId) -> VisitorResult { Ok(()) }

    fn visit_array_expr(&mut self, _ctx: &mut Ctx, _id: ArrayExpressionId) -> VisitorResult { Ok(()) }

    fn visit_constant_expr(&mut self, _ctx: &mut Ctx, _id: ConstantExpressionId) -> VisitorResult { Ok(()) }

    fn visit_call_expr(&mut self, _ctx: &mut Ctx, _id: CallExpressionId) -> VisitorResult { Ok(()) }

    fn visit_variable_expr(&mut self, _ctx: &mut Ctx, _id: VariableExpressionId) -> VisitorResult { Ok(()) }

}

enum DefinitionType {

    Primitive,

    Composite,

    Function

}

struct NoNameYet {

    in_sync: Option<SynchronousStatementId>,

    in_while: Option<WhileStatementId>,

    cur_scope: Option<Scope>,

    def_type: DefinitionType,

    performing_breadth_pass: bool,

    // Keeping track of relative position in block in the breadth-first pass.

    // May not correspond to block.statement[index] if any statements are

    // inserted after the breadth-pass

    relative_pos_in_block: u32,

    // Single buffer of statement IDs that we want to traverse in a block.

    // Required to work around Rust borrowing rules

    // TODO: Maybe remove this in the future

    statement_buffer: Vec<StatementId>,

    // Statements to insert after the breadth pass in a single block

    insert_buffer: Vec<(u32, StatementId)>,

}

impl NoNameYet {

    fn new() -> Self {

        Self{

            in_sync: None,

            in_while: None,

            cur_scope: None,

            def_type: DefinitionType::Primitive,

            performing_breadth_pass: false,

            relative_pos_in_block: 0,

            statement_buffer: Vec::with_capacity(256),

            insert_buffer: Vec::with_capacity(32),

        }

    }

    fn reset_state(&mut self) {

        self.in_sync = None;

        self.in_while = None;

        self.cur_scope = None;

        self.def_type = DefinitionType::Primitive;

        self.relative_pos_in_block = 0;

        self.performing_breadth_pass = false;

        self.statement_buffer.clear();

        self.insert_buffer.clear();

    }

}

impl Visitor2 for NoNameYet {

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

    // Definition visitors

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

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

        self.reset_state();

        let block_id = {

            let def = &ctx.heap[id];

            match def.variant {

                ComponentVariant::Primitive => self.def_type = DefinitionType::Primitive,

                ComponentVariant::Composite => self.def_type = DefinitionType::Composite,

            }

            let body = ctx.heap[def.body].as_block_mut();

            self.statement_buffer.extend_from_slice(&body.statements);

            self.statement_stack_indices.push(0);

            body.this

        };

        self.cur_scope = Some(Scope {

            variant: ScopeVariant::Definition(id.upcast()),

            parent: None,

        });

        self.performing_breadth_pass = true;

        self.visit_block_stmt(ctx, block_id)?;

        self.performing_breadth_pass = false;

        self.visit_block_stmt(ctx, block_id)

    }

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

        self.reset_state();

        // Set internal statement indices

        let block_id = {

            let def = &ctx.heap[id];

            self.def_type = DefinitionType::Function;

            let body = ctx.heap[def.body].as_block_mut();

            self.statement_buffer.extend_from_slice(&body.statements);

            self.statement_stack_indices.push(0);

            body.this

        };

        self.cur_scope = Some(Scope {

            variant: ScopeVariant::Definition(id.upcast()),

            parent: None,

        });

        self.performing_breadth_pass = true;

        self.visit_block_stmt(ctx, block_id)?;

        self.performing_breadth_pass = false;

        self.visit_block_stmt(ctx, block_id)

    }

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

    // Statement visitors

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

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

        if self.performing_breadth_pass {

            // Our parent is performing a breadth-pass. We do this simple stuff

            // here

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

            body.parent_scope = self.cur_scope.clone();

            body.relative_pos_in_parent = self.relative_pos_in_block;

            return Ok(())

        }

        // We may descend into children of this block. However, this is

        // where we first perform a breadth-first pass

        self.performing_breadth_pass = true;

        self.cur_scope = Some(Scope::Block(id));

        let first_statement_index = self.statement_buffer.len();

        {

            let body = &ctx.heap[id];

            self.statement_buffer.extend_from_slice(&body.statements);

        }

        let mut stmt_index = first_statement_index;

        while stmt_index < self.statement_buffer.len() {

            self.relative_pos_in_block = (stmt_index - first_statement_index) as u32;

            self.visit_stmt(ctx, self.statement_buffer[stmt_index])?;

            stmt_index += 1;

        }

        if !self.insert_buffer.is_empty() {

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

            for (pos, stmt) in self.insert_buffer.drain(..) {

                body.statements.insert(pos as usize, stmt);

            }

        }

        // And the depth pass

        self.performing_breadth_pass = false;

        stmt_index = first_statement_index;

        while stmt_index < self.statement_buffer.len() {

            self.visit_stmt(ctx, self.statement_buffer[stmt_index])?;

            stmt_index += 1;

        }

        // Pop statement buffer

        debug_assert!(self.insert_buffer.is_empty(), "insert buffer not empty after depth pass");

        self.statement_buffer.truncate(first_statement_index);

        Ok(())

    }

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

        if self.performing_breadth_pass {

            let stmt = &ctx.heap[id];

            stmt.relative_pos_in_block = self.relative_pos_in_block;

            self.checked_local_add(ctx, stmt.variable)?;

        }

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

        Ok(())

    }

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

        if self.performing_breadth_pass {

            // Retrieve scope

            let scope = self.cur_scope.as_ref().unwrap();

            debug_assert!(scope.statement.is_some(), "expected scope statement at labeled stmt");

            debug_assert_eq!(

                scope.variant == ScopeVariant::Synchronous,

                self.in_sync.is_some(),

                "in synchronous scope variant, but 'in_sync' not set"

            );

            // Add label to block lookup

            self.checked_label_add(ctx, id)?;

            // Modify labeled statement itself

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

            labeled.relative_pos_in_block = self.relative_pos_in_block;

            labeled.in_sync = if scope.variant == ScopeVariant::Synchronous {

                self.in_sync.clone()

            } else {

                None

            };

        }

        let body_id = ctx.heap[id].body;

        self.visit_stmt(ctx, body_id)?;

        Ok(())

    }

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

        if self.performing_breadth_pass {

            let position = ctx.heap[id].position;

            let end_if_id = ctx.heap.alloc_end_if_statement(|this| {

                EndIfStatement {

                    this,

                    start_if: id,

                    position,

                    next: None,

                }

            });

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

            stmt.end_if = Some(end_if_id);

            self.insert_buffer.push((self.relative_pos_in_block + 1, end_if_id.upcast()));

        }

        // Traverse expression and bodies

        let (test_id, true_id, false_id) = {

            let stmt = &ctx.heap[id];

            (stmt.test, stmt.true_body, stmt.false_body)

        };

        self.visit_expr(ctx, test_id)?;

        self.visit_stmt(ctx, true_id)?;

        self.visit_stmt(ctx, false_id)?;

        Ok(())

    }

    fn visit_while_stmt(&mut self, ctx: &mut Ctx, id: WhileStatementId) -> VisitorResult {

        if self.performing_breadth_pass {

            let scope = self.cur_scope.as_ref().unwrap();

            let position = ctx.heap[id].position;

            debug_assert_eq!(

                scope.variant == ScopeVariant::Synchronous,