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"

                        )

                    );

                }

            }

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