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_statement_scope(&mut self, ctx: &mut Ctx, new_scope: Scope) -> (Scope, i32) {

        let old_scope = self.cur_scope.clone();

        debug_assert!(new_scope.is_block()); // never call for Definition scope

        let is_new_block = if old_scope.is_block() {

            old_scope.to_block() != new_scope.to_block()

        } else {

            true

        };

        if !is_new_block {

            // No need to push, but still return old scope, we pretend like we

            // replaced it.

            debug_assert!(!ctx.heap[new_scope.to_block()].scope_node.parent.is_invalid());

            return (old_scope, self.relative_pos_in_block);

        }

        // This is a new block, so link it up

        if old_scope.is_block() {

            let parent_block = &mut ctx.heap[old_scope.to_block()];

            parent_block.scope_node.nested.push(new_scope);

        }

        self.cur_scope = new_scope;

        let cur_block = &mut ctx.heap[new_scope.to_block()];

        cur_block.scope_node.parent = old_scope;

        cur_block.scope_node.relative_pos_in_parent = self.relative_pos_in_block;

        let old_relative_pos = self.relative_pos_in_block;

        self.relative_pos_in_block = -1;

        return (old_scope, old_relative_pos)

    }

    fn pop_statement_scope(&mut self, scope_to_restore: (Scope, i32)) {

        self.cur_scope = scope_to_restore.0;

        self.relative_pos_in_block = scope_to_restore.1;

    }

    fn visit_definition_and_assign_local_ids(&mut self, ctx: &mut Ctx, definition_id: DefinitionId) {

        let mut var_counter = 0;

        // Set IDs on parameters

        let (param_section, body_id) = match &ctx.heap[definition_id] {

            Definition::Function(func_def) => (

                self.variable_buffer.start_section_initialized(&func_def.parameters),

                func_def.body

            ),

            Definition::Component(comp_def) => (

                self.variable_buffer.start_section_initialized(&comp_def.parameters),

                comp_def.body

            ),

            _ => unreachable!(),

        } ;

        for var_id in param_section.iter_copied() {

            let var = &mut ctx.heap[var_id];

            var.unique_id_in_scope = var_counter;

            var_counter += 1;

        }

        param_section.forget();

        // Recurse into body

        self.visit_block_and_assign_local_ids(ctx, body_id, var_counter);

    }

    fn visit_block_and_assign_local_ids(&mut self, ctx: &mut Ctx, block_id: BlockStatementId, mut var_counter: i32) {

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

        block_stmt.first_unique_id_in_scope = var_counter;

        let var_section = self.variable_buffer.start_section_initialized(&block_stmt.locals);

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

        for child_scope in &block_stmt.scope_node.nested {

            debug_assert!(child_scope.is_block(), "found a child scope that is not a block statement");

            scope_section.push(child_scope.to_block().upcast());

        }

        let mut var_idx = 0;

        let mut scope_idx = 0;

        while var_idx < var_section.len() || scope_idx < scope_section.len() {

            let relative_var_pos = if var_idx < var_section.len() {

                ctx.heap[var_section[var_idx]].relative_pos_in_block

            } else {

                i32::MAX

            };

            let relative_scope_pos = if scope_idx < scope_section.len() {

                ctx.heap[scope_section[scope_idx]].as_block().scope_node.relative_pos_in_parent

            } else {

                i32::MAX

            };

            debug_assert!(!(relative_var_pos == i32::MAX && relative_scope_pos == i32::MAX));

            // In certain cases the relative variable position is the same as

            // the scope position (insertion of binding variables). In that case

            // the variable should be treated first

            if relative_var_pos <= relative_scope_pos {

                let var = &mut ctx.heap[var_section[var_idx]];

                var.unique_id_in_scope = var_counter;

                var_counter += 1;

                var_idx += 1;

            } else {

                // Boy oh boy

                let block_id = ctx.heap[scope_section[scope_idx]].as_block().this;

                self.visit_block_and_assign_local_ids(ctx, block_id, var_counter);

                scope_idx += 1;

            }

        }

        var_section.forget();

        scope_section.forget();

        // Done assigning all IDs, assign the last ID to the block statement scope

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

        block_stmt.next_unique_id_in_scope = var_counter;

    }

    fn resolve_pending_control_flow_targets(&mut self, ctx: &mut Ctx) -> Result<(), ParseError> {

        for entry in &self.control_flow_stmts {

            let stmt = &ctx.heap[entry.statement];

            match stmt {

                Statement::Break(stmt) => {

                    let stmt_id = stmt.this;

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

                    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.

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

                    if local.identifier == parameter.identifier {

                        return Err(

                            ParseError::new_error_str_at_span(

                                &ctx.module().source, local.identifier.span, "Local variable name conflicts with parameter"

                            ).with_info_str_at_span(

                                &ctx.module().source, parameter.identifier.span, "Parameter definition is found here"

                            )

                        );

                    }

                }

                // No collisions

                break;

            }

            // If here then the parent scope is a block scope

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

            for other_local_id in &block.locals {

                let other_local = &ctx.heap[*other_local_id];

                // Position check in case another variable with the same name

                // is defined in a higher-level scope, but later than the scope

                // in which the current variable resides.

                if local.this != *other_local_id &&

                    cur_relative_pos >= other_local.relative_pos_in_block &&

                    local.identifier == other_local.identifier {

                    // Collision within this scope

                    return Err(

                        ParseError::new_error_str_at_span(

                            &ctx.module().source, local.identifier.span, "Local variable name conflicts with another variable"

                        ).with_info_str_at_span(

                            &ctx.module().source, other_local.identifier.span, "Previous variable is found here"

                        )

                    );

                }

            }

            scope = block.scope_node.parent;

            cur_relative_pos = block.scope_node.relative_pos_in_parent;

        }

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

        self.checked_at_single_scope_add_local(ctx, target_scope, target_relative_pos, id)

    }

    /// 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: Scope, relative_pos: i32, id: VariableId

    ) -> Result<(), ParseError> {

        // Check the symbol table for conflicts

        {

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

            let ident = &ctx.heap[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 local = &ctx.heap[id];

        debug_assert!(scope.is_block());

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

        for other_local_id in &block.locals {

            let other_local = &ctx.heap[*other_local_id];

            if local.this != other_local.this &&

                // relative_pos >= other_local.relative_pos_in_block &&

                local.identifier == other_local.identifier {

                // Collision

                return Err(

                    ParseError::new_error_str_at_span(

                        &ctx.module().source, local.identifier.span, "Local variable name conflicts with another variable"

                    ).with_info_str_at_span(

                        &ctx.module().source, other_local.identifier.span, "Previous variable is found here"

                    )

                );

            }

        }

        // No collisions

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

                            if identifier == &parameter.identifier {

                                return Some(*parameter_id);

                            }

                        }

                    },

                    _ => unreachable!(),

                }

                // Variable could not be found

                return None

            } else {

                relative_pos = block.scope_node.relative_pos_in_parent;

            }

        }

    }

    /// Adds a particular label to the current scope. Will return an error if

    /// there is another label with the same name visible in the current scope.

    fn checked_add_label(&mut self, ctx: &mut Ctx, relative_pos: i32, in_sync: SynchronousStatementId, id: LabeledStatementId) -> Result<(), ParseError> {

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

        // Make sure label is not defined within the current scope or any of the

        // parent scope.

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

        label.relative_pos_in_block = relative_pos;

        label.in_sync = in_sync;

        let label = &ctx.heap[id];

        let mut scope = &self.cur_scope;

        loop {

            debug_assert!(scope.is_block(), "scope is not a block");

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

            for other_label_id in &block.labels {

                let other_label = &ctx.heap[*other_label_id];

                if other_label.label == label.label {

                    // Collision

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module().source, label.label.span, "label name is used more than once"

                    ).with_info_str_at_span(

                        &ctx.module().source, other_label.label.span, "the other label is found here"

                    ));

                }

            }

            scope = &block.scope_node.parent;

            if !scope.is_block() {

                break;

            }

        }

        // No collisions

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

        block.labels.push(id);

        Ok(())

    }

    /// Finds a particular labeled statement by its identifier. Once found it

    /// will make sure that the target label does not skip over any variable

    /// declarations within the scope in which the label was found.

    fn find_label(mut scope: Scope, ctx: &Ctx, identifier: &Identifier) -> Result<LabeledStatementId, ParseError> {

        debug_assert!(scope.is_block());

        loop {

            debug_assert!(scope.is_block(), "scope is not a block");

            let relative_scope_pos = ctx.heap[scope.to_block()].scope_node.relative_pos_in_parent;

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

            for label_id in &block.labels {

                let label = &ctx.heap[*label_id];

                if label.label == *identifier {

                    for local_id in &block.locals {

                        // TODO: Better to do this in control flow analysis, it

                        //  is legal to skip over a variable declaration if it

                        //  is not actually being used. I might be missing

                        //  something here when laying out the bytecode...

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

                        if local.relative_pos_in_block > relative_scope_pos && local.relative_pos_in_block < label.relative_pos_in_block {

                            return Err(

                                ParseError::new_error_str_at_span(&ctx.module().source, identifier.span, "this target label skips over a variable declaration")

                                .with_info_str_at_span(&ctx.module().source, label.label.span, "because it jumps to this label")

                                .with_info_str_at_span(&ctx.module().source, local.identifier.span, "which skips over this variable")

                            );

                        }

                    }

                    return Ok(*label_id);

                }

            }

            scope = block.scope_node.parent;

            if !scope.is_block() {

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module().source, identifier.span, "could not find this label"

                ));

            }

        }

    }

    /// This function will check if the provided while statement ID has a block

    /// statement that is one of our current parents.

    fn has_parent_while_scope(mut scope: Scope, ctx: &Ctx, id: WhileStatementId) -> bool {

        let while_stmt = &ctx.heap[id];

        loop {

            debug_assert!(scope.is_block());

            let block = scope.to_block();

            if while_stmt.body == block {

                return true;

            }

            let block = &ctx.heap[block];

            scope = block.scope_node.parent;

            if !scope.is_block() {

                return false;

            }

        }

    }

    /// This function should be called while dealing with break/continue

    /// statements. It will try to find the targeted while statement, using the

    /// target label if provided. If a valid target is found then the loop's

    /// ID will be returned, otherwise a parsing error is constructed.

    /// The provided input position should be the position of the break/continue

    /// statement.

    fn resolve_break_or_continue_target(ctx: &Ctx, control_flow: &ControlFlowStatement, span: InputSpan, label: &Option<Identifier>) -> Result<WhileStatementId, ParseError> {

        let target = match label {

            Some(label) => {

                let target_id = Self::find_label(control_flow.in_scope, ctx, label)?;

                // Make sure break target is a while statement

                let target = &ctx.heap[target_id];

                if let Statement::While(target_stmt) = &ctx.heap[target.body] {

                    // Even though we have a target while statement, the break might not be

                    // present underneath this particular labeled while statement

                    if !Self::has_parent_while_scope(control_flow.in_scope, ctx, target_stmt.this) {

                        return Err(ParseError::new_error_str_at_span(

                            &ctx.module().source, label.span, "break statement is not nested under the target label's while statement"

                        ).with_info_str_at_span(

                            &ctx.module().source, target.label.span, "the targeted label is found here"

                        ));

                    }

                    target_stmt.this

                } else {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module().source, label.span, "incorrect break target label, it must target a while loop"

                    ).with_info_str_at_span(

                        &ctx.module().source, target.label.span, "The targeted label is found here"

                    ));

                }

            },

            None => {

                // Use the enclosing while statement, the break must be

                // nested within that while statement

                if control_flow.in_while.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        &ctx.module().source, span, "Break statement is not nested under a while loop"

                    ));

                }

                control_flow.in_while

            }

        };

        // We have a valid target for the break statement. But we need to

        // make sure we will not break out of a synchronous block

        {

            let target_while = &ctx.heap[target];

            if target_while.in_sync != control_flow.in_sync {

                // Break is nested under while statement, so can only escape a

                // sync block if the sync is nested inside the while statement.

                debug_assert!(!control_flow.in_sync.is_invalid());

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

                return Err(

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

                        .with_info_str_at_span(&ctx.module().source, target_while.span, "the break escapes out of this loop")

                        .with_info_str_at_span(&ctx.module().source, sync_stmt.span, "And would therefore escape this synchronous block")

                );

            }