pub this: VariableId,

    // Parsing

    pub kind: VariableKind,

    pub parser_type: ParserType,

    pub identifier: Identifier,

    // Validator/linker

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

}

#[derive(Debug, Clone)]

pub enum Definition {

    Struct(StructDefinition),

    pub statements: Vec<StatementId>,

    pub end_block: EndBlockStatementId,

    // Phase 2: linker

    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,

}

#[derive(Debug, Clone)]

#[derive(Debug, Clone)]

pub struct MemoryStatement {

    pub this: MemoryStatementId,

    // Phase 1: parser

    pub span: InputSpan,

    pub variable: VariableId,

    // Phase 2: linker

    pub next: StatementId,

}

/// ChannelStatement is the declaration of an input and output port associated

/// with the same channel. Note that the polarity of the ports are from the

    pub this: ChannelStatementId,

    // Phase 1: parser

    pub span: InputSpan, // of the "channel" keyword

    pub from: VariableId, // output

    pub to: VariableId,   // input

    // Phase 2: linker

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct LabeledStatement {

    pub this: LabeledStatementId,

    // Phase 1: parser

    pub label: Identifier,

    pub body: StatementId,

    // Phase 2: linker

    pub in_sync: SynchronousStatementId, // may be invalid

}

#[derive(Debug, Clone)]

pub struct IfStatement {

    pub this: IfStatementId,

    pub cases: Vec<SelectCase>,

    pub end_select: EndSelectStatementId,

}

#[derive(Debug, Clone)]

pub struct SelectCase {

    pub block: BlockStatementId,

}

#[derive(Debug, Clone)]

pub struct EndSelectStatement {

    pub this: EndSelectStatementId,

    pub next: StatementId,

}

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

pub enum ExpressionParent {

    None, // only set during initial parsing

    If(IfStatementId),

    While(WhileStatementId),

    Return(ReturnStatementId),

    New(NewStatementId),

    ExpressionStmt(ExpressionStatementId),

    Expression(ExpressionId, u32) // index within expression (e.g LHS or RHS of expression)

                    LocalStatement::Memory(stmt) => {

                        self.kv(indent).with_id(PREFIX_MEM_STMT_ID, stmt.this.0.0.index)

                            .with_s_key("LocalMemory");

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

                    }

                }

            },

            Statement::Labeled(stmt) => {

                self.kv(indent).with_id(PREFIX_LABELED_STMT_ID, stmt.this.0.index)

                    .with_s_key("Select");

                self.kv(indent2).with_s_key("EndSelect").with_disp_val(&stmt.end_select.0.index);

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

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

                }

            },

            Statement::EndSelect(stmt) => {

fn write_expression_parent(target: &mut String, parent: &ExpressionParent) {

    use ExpressionParent as EP;

    *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),

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

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

        EP::Expression(id, idx) => format!("Expr({}, {})", id.index, idx)

                Ok(EvalContinuation::Stepping)

            },

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Memory(stmt) => {

                            let variable = &heap[stmt.variable];

                        cur_frame.position = stmt.next;

                        Ok(EvalContinuation::Stepping)

                    },

                    LocalStatement::Channel(stmt) => {

                        // Need to create a new channel by requesting it from

        // stack in the next loop, then evaluate the statement using the result

        // from the expression evaluation.

        if !cur_frame.position.is_invalid() {

            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) => {

                    debug_assert_eq!(stmt.expressions.len(), 1); // TODO: @ReturnValues

                    cur_frame.prepare_single_expression(heap, stmt.expressions[0]);

                },

            } else if iter.peek() == Some(TokenKind::Colon) {

                self.consume_labeled_statement(module, iter, ctx, section)?;

            } else {

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

            }

        } else {

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

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

        let mut cases = Vec::new();

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

        }

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

            }

        }

        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 iter_state = iter.save();

        let definition_id = self.cur_definition;

        let poly_vars = ctx.heap[definition_id].poly_vars();

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

                // Assume this is a proper memory statement

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

                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,

                    identifier: identifier.clone(),

                    parser_type,

                    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,

                });

                let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{

                    this,

                    left: variable_expr_id.upcast(),

                    operation: AssignmentOperator::Set,

                    right: initial_expr_id,

                    parent: ExpressionParent::None,

                    unique_id_in_definition: -1,

                });

                    this,

                });

            }

        }

        // If here then one of the preconditions for a memory statement was not

        // met. So recover the iterator and return

        iter.load(iter_state);

        Ok(())

    }

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

    }

    fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {

        let channel_stmt = &ctx.heap[id];

        let expr = &ctx.heap[expr_id];

        let inference_type = match expr.parent() {

            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) => {

                // If we are the test expression of a conditional expression,

                // then we must resolve to a boolean

                let is_conditional = if let Expression::Conditional(_) = &ctx.heap[*parent_id] {

    expr_parent: ExpressionParent,

    // Set by parent to indicate that child expression must be assignable. The

    // child will throw an error if it is not assignable. The stored span is

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

    // members but not the AST container.

    variable_buffer: ScopedBuffer<VariableId>,

    definition_buffer: ScopedBuffer<DefinitionId>,

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

        self.visit_block_stmt_with_hint(ctx, id, None)

    }

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

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

        Ok(())

    }

    fn visit_local_channel_stmt(&mut self, ctx: &mut Ctx, id: ChannelStatementId) -> VisitorResult {

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

        Ok(())

                &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 num_cases = select_stmt.cases.len();

        for case in &select_stmt.cases {

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

        }

        assign_then_erase_next_stmt!(self, ctx, id.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());

        }

        self.prev_stmt = end_select_id.upcast();

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

        // Although we call assignment an expression to simplify the compiler's

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

                return Err(ParseError::new_error_str_at_span(

                    &ctx.module().source, assignment_span,

                    "assignments are statements, and cannot be used in expressions"

        Ok(())

    }

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

        let var_expr = &ctx.heap[id];

            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"

                ));

            }

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

                Statement::If(stmt) => stmt.true_body,

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

                _ => unreachable!(),

            };

            let body_scope = Scope::Regular(body_stmt_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;

        let statement_section = self.statement_buffer.start_section_initialized(&body.statements);

        // Perform the breadth-first pass. Its main purpose is to find labeled

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

        self.cur_scope = old_scope;

        self.relative_pos_in_block = old_relative_pos;

        statement_section.forget();

        Ok(())

    }

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

        match statement {

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Memory(local) => {

                        let variable_id = local.variable;

        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 {

            };

            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

            // the variable should be treated first

            if relative_var_pos <= relative_scope_pos {

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

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

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

        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

            // in the call at the end. Likewise for checking the symbol table.

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

    }

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

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

        Ok(())

    }

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

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

                }

            }

            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 {

                            }

                        }

                    },

                    _ => unreachable!(),

                }

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

        // parent scope.

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

        label.relative_pos_in_block = relative_pos;

    Tester::new_single_source_expect_err(

        "inside tuple",

        "func f(u32 a) -> u32 { auto b = (a += 2, a /= 2); return 0; }"

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

}

#[test]

fn test_correct_select_statement() {

    Tester::new_single_source_expect_ok(

        "correct single-use", "

        primitive f() {

            channel unused_output -> input;

            u32 outer_value = 0;

            sync select {

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

                auto new_value = get(input) -> {

                    outer_value = new_value;

                }

                get(input) + get(input) ->

                    outer_value = 8;

                get(input) ->

                    {}

                false

            }

        );

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

                if var.identifier.value.as_str() == name {

                    found_local_id = Some(*local_id);

                }

}

fn seek_expr_in_stmt<F: Fn(&Expression) -> bool>(heap: &Heap, start: StatementId, f: &F) -> Option<ExpressionId> {

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

                    return Some(id)

                }

            }