pub parser_type: ParserType,

    pub identifier: Identifier,

    // Validator/linker

    pub unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated

}

    pub scope_node: ScopeNode,

    pub first_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated

    pub next_unique_id_in_scope: i32, // Temporary fix until proper bytecode/asm is generated

    pub locals: Vec<VariableId>,

    pub labels: Vec<LabeledStatementId>,

    pub next: StatementId,

    // Phase 1: parser

    pub span: InputSpan,

    pub variable: VariableId,

    // Phase 2: linker

    pub next: StatementId,

}

    pub from: VariableId, // output

    pub to: VariableId,   // input

    // Phase 2: linker

    pub next: StatementId,

}

    pub label: Identifier,

    pub body: StatementId,

    // Phase 2: linker

    pub in_sync: SynchronousStatementId, // may be invalid

}

#[derive(Debug, Clone)]

pub struct SelectCase {

    pub block: BlockStatementId,

}

#[derive(Debug, PartialEq, Eq, Clone, Copy)]

pub enum ExpressionParent {

    None, // only set during initial parsing

    If(IfStatementId),

    While(WhileStatementId),

    Return(ReturnStatementId),

                        self.kv(indent2).with_s_key("Variable");

                        self.write_variable(heap, stmt.variable, indent3);

                        self.kv(indent2).with_s_key("Next").with_disp_val(&stmt.next.index);

                    }

                }

                let indent3 = indent2 + 1;

                let indent4 = indent3 + 1;

                for case in &stmt.cases {

                    self.kv(indent3).with_s_key("Block");

                    self.write_stmt(heap, case.block.upcast(), indent4);

    *target = match parent {

        EP::None => String::from("None"),

        EP::If(id) => format!("IfStmt({})", id.0.index),

        EP::While(id) => format!("WhileStmt({})", id.0.index),

        EP::Return(id) => format!("ReturnStmt({})", id.0.index),

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Memory(stmt) => {

                        cur_frame.position = stmt.next;

                        Ok(EvalContinuation::Stepping)

            let stmt = &heap[cur_frame.position];

            match stmt {

                Statement::If(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),

                Statement::While(stmt) => cur_frame.prepare_single_expression(heap, stmt.test),

                Statement::Return(stmt) => {

                // Two fallback possibilities: the first one is a memory

                // declaration, the other one is to parse it as a normal

                // expression. This is a bit ugly.

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

                    section.push(memory_stmt_id.upcast().upcast());

                } else {

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

                    section.push(id.upcast());

            }

        } else if next == TokenKind::OpenParen {

            // Same as above: memory statement or normal expression

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

                section.push(memory_stmt_id.upcast().upcast());

            } else {

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

                section.push(id.upcast());

        let mut next = iter.next();

        while Some(TokenKind::CloseCurly) != next {

                None => {

                    let start_pos = iter.last_valid_pos();

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

                    let end_pos = iter.last_valid_pos();

                        this,

                        span: InputSpan::from_positions(start_pos, end_pos),

                        expression: expr,

                        next: StatementId::new_invalid(),

                    });

                },

            };

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

            let block = self.consume_block_or_wrapped_statement(module, iter, ctx)?;

            next = iter.next();

        }

        Ok(())

    }

    fn maybe_consume_memory_statement_without_semicolon(

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

        // This is a bit ugly. It would be nicer if we could somehow

        // consume the expression with a type hint if we do get a valid

        // type, but we don't get an identifier following it

                let memory_span = InputSpan::from_positions(parser_type.full_span.begin, identifier.span.end);

                let assign_span = consume_token(&module.source, iter, TokenKind::Equal)?;

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

                let initial_expr_end_pos = iter.last_valid_pos();

                let local_id = ctx.heap.alloc_variable(|this| Variable{

                    this,

                    kind: VariableKind::Local,

                    relative_pos_in_block: 0,

                    unique_id_in_scope: -1,

                });

                let variable_expr_id = ctx.heap.alloc_variable_expression(|this| VariableExpression{

                    this,

                    identifier,

                    used_as_binding_target: false,

                    parent: ExpressionParent::None,

                    unique_id_in_definition: -1,

                    parent: ExpressionParent::None,

                    unique_id_in_definition: -1,

                });

                    this,

                });

            }

        }

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

        let memory_stmt = &ctx.heap[id];

        let local = &ctx.heap[memory_stmt.variable];

        let var_type = self.determine_inference_type_from_parser_type_elements(&local.parser_type.elements, true);

        self.var_types.insert(memory_stmt.variable, VarData::new_local(var_type));

        Ok(())

    }

            EP::None =>

                // Should have been set by linker

                unreachable!(),

                // Determined during type inference

                InferenceType::new(false, false, vec![ITP::Unknown]),

            EP::Expression(parent_id, idx_in_parent) => {

    // used for the error's position

    must_be_assignable: Option<InputSpan>,

    // Keeping track of relative positions and unique IDs.

    next_expr_index: i32, // to arrive at a unique ID for all expressions within a definition

    // Various temporary buffers for traversal. Essentially working around

    // Rust's borrowing rules since it cannot understand we're modifying AST

    }

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

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

        Ok(())

    }

        }

        // Visit the various arms in the select block

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

        let num_cases = select_stmt.cases.len();

        for case in &select_stmt.cases {

            case_stmt_ids.push(case.block.upcast());

        }

        // Link up the "Select" with the "EndSelect". If there are no cases then

        // runtime will pick the "EndSelect" immediately.

        for idx in 0..num_cases {

            self.visit_stmt(ctx, arm_block_id)?;

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

        // code (mainly typechecking), we disallow nested use in expressions

        match self.expr_parent {

            // Look at us: lying through our teeth while providing error messages.

            ExpressionParent::ExpressionStmt(_) => {},

            _ => {

                let assignment_span = assignment_expr.full_span;

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

        let var_expr = &ctx.heap[id];

                        }

                }

        };

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

        // statements such that we can find the `goto`-targets immediately when

        // performing the depth pass

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

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

        }

        // Perform the depth-first traversal

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

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

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

        }

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

        Ok(())

    }

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

        match statement {

            Statement::Local(stmt) => {

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

                ctx.heap[var_section[var_idx]].relative_pos_in_block

            } else {

            };

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

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

            } else {

            };

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

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

    /// Adds a local variable to the current scope. It will also annotate the

    /// `Local` in the AST with its relative position in the block.

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

        let local = &ctx.heap[id];

        let mut scope = &self.cur_scope;

        loop {

            // We immediately go to the parent scope. We check the current scope

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

    ) -> Result<(), ParseError> {

        // Check the symbol table for conflicts

        {

    /// Finds a variable in the visitor's scope that must appear before the

    /// specified relative position within that block.

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

        // No need to use iterator over namespaces if here

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

                }

            }

                        for parameter_id in definition.parameters() {

                            let parameter = &ctx.heap[*parameter_id];

                            if identifier == &parameter.identifier {

                            }

                        }

                    },

                }

                // Variable could not be found

            } else {

                relative_pos = block.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.

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

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

    ).error(|e| { e.assert_msg_has(0, "assignments are statements"); });

}

#[test]

fn test_correct_select_statement() {

    Tester::new_single_source_expect_ok(

            sync select {

                outer_value = get(input) -> outer_value = 0;

                auto new_value = get(input) -> {

                    outer_value = new_value;

                }

                get(input) + get(input) ->

        let mut found_local_id = None;

        if let Some(block_id) = wrapping_block_id {

            let block_stmt = self.ctx.heap[block_id].as_block();

            for local_id in &block_stmt.locals {

                let var = &self.ctx.heap[*local_id];

    let stmt = &heap[start];

    match stmt {

        Statement::Block(stmt) => {

            for stmt_id in &stmt.statements {

                if let Some(id) = seek_expr_in_stmt(heap, *stmt_id, f) {