| Statement::While(_)

            | Statement::Labeled(_)

            | Statement::If(_) => unreachable!(),

        }

    }

}

#[derive(Debug, Clone)]

pub struct BlockStatement {

    pub this: BlockStatementId,

    // Phase 1: parser

    pub span: InputSpan, // of the complete block

    pub statements: Vec<StatementId>,

    pub end_block: EndBlockStatementId,

    // Phase 2: linker

    pub scope: ScopeId,

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct EndBlockStatement {

    pub this: EndBlockStatementId,

    // Parser

pub struct EndForkStatement {

    pub this: EndForkStatementId,

    pub start_fork: ForkStatementId,

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct SelectStatement {

    pub this: SelectStatementId,

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

    pub cases: Vec<SelectCase>,

    pub end_select: EndSelectStatementId,

}

#[derive(Debug, Clone)]

pub struct SelectCase {

    // The guard statement of a `select` is either a MemoryStatement or an

    // ExpressionStatement. Nothing else is allowed by the initial parsing

    pub guard: StatementId,

    pub body: StatementId,

    pub scope: ScopeId,

    // Phase 2: Validation and Linking

    pub involved_ports: Vec<(CallExpressionId, ExpressionId)>, // call to `get` and its port argument

}

            }

            let stmt_id = self.consume_statement(module, iter, ctx)?;

            stmt_section.push(stmt_id);

            next = iter.next();

        }

        let statements = stmt_section.into_vec();

        let mut block_span = consume_token(&module.source, iter, TokenKind::CloseCurly)?;

        block_span.begin = open_curly_span.begin;

        let block_id = ctx.heap.alloc_block_statement(|this| BlockStatement{

            this,

            span: block_span,

            statements,

            end_block: EndBlockStatementId::new_invalid(),

            scope: ScopeId::new_invalid(),

            next: StatementId::new_invalid(),

        });

        let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::Block(block_id)));

        let end_block_id = ctx.heap.alloc_end_block_statement(|this| EndBlockStatement{

            this, start_block: block_id, next: StatementId::new_invalid()

        });

            next = iter.next();

        }

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

        let num_cases = cases.len();

        let select_stmt_id = ctx.heap.alloc_select_statement(|this| SelectStatement{

            this,

            span: select_span,

            cases,

            end_select: EndSelectStatementId::new_invalid(),

        });

        let end_select_stmt_id = ctx.heap.alloc_end_select_statement(|this| EndSelectStatement{

            this,

            start_select: select_stmt_id,

            next: StatementId::new_invalid(),

        });

        let select_stmt = &mut ctx.heap[select_stmt_id];

        select_stmt.end_select = end_select_stmt_id;

        for case_index in 0..num_cases {

            let scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::SelectCase(select_stmt_id, case_index as u32)));

            let select_stmt = &mut ctx.heap[select_stmt_id];

use crate::collections::*;

use crate::protocol::*;

use super::visitor::*;

pub(crate) struct PassRewriting {

    statement_buffer: ScopedBuffer<StatementId>,

    call_expr_buffer: ScopedBuffer<CallExpressionId>,

    expression_buffer: ScopedBuffer<ExpressionId>,

}

impl PassRewriting {

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

        Self{

        }

    }

}

impl Visitor for PassRewriting {

    // --- Visiting procedures

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

        let def = &ctx.heap[id];

        let body_id = def.body;

        return self.visit_block_stmt(ctx, body_id);

    }

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

        let def = &ctx.heap[id];

        let body_id = def.body;

        return self.visit_block_stmt(ctx, body_id);

    }

    // --- Visiting statements (that are not the select statement)

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

        let block_stmt = &ctx.heap[id];

        let stmt_section = self.statement_buffer.start_section_initialized(&block_stmt.statements);

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

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

        }

        stmt_section.forget();

        return Ok(())

    }

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

        let labeled_stmt = &ctx.heap[id];

        let body_id = labeled_stmt.body;

        return self.visit_stmt(ctx, body_id);

    }

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

        let if_stmt = &ctx.heap[id];

        }

        return Ok(())

    }

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

        let while_stmt = &ctx.heap[id];

        let body_id = while_stmt.body;

        return self.visit_stmt(ctx, body_id);

    }

    fn visit_synchronous_stmt(&mut self, ctx: &mut Ctx, id: SynchronousStatementId) -> VisitorResult {

        let sync_stmt = &ctx.heap[id];

        let body_id = sync_stmt.body;

        return self.visit_stmt(ctx, body_id);

    }

    // --- Visiting the select statement

    fn visit_select_stmt(&mut self, ctx: &mut Ctx, id: SelectStatementId) -> VisitorResult {

        // Utility for the last stage of rewriting process. Note that caller

        // still needs to point the end of the if-statement to the end of the

        // replacement statement of the select statement.

        fn transform_select_case_code(ctx: &mut Ctx, select_id: SelectStatementId, case_index: usize, select_var_id: VariableId) -> (IfStatementId, EndIfStatementId) {

            // Retrieve statement IDs associated with case

            let case = &ctx.heap[select_id].cases[case_index];

            let true_case = IfStatementCase{

                body: case_guard_id, // which is linked up to the body

                scope: case_scope_id,

            };

            let (if_stmt_id, end_if_stmt_id) = create_ast_if_stmt(ctx, compare_expr_id.upcast(), true_case, None);

            // Link up body statement to end-if

            set_ast_statement_next(ctx, case_body_id, end_if_stmt_id.upcast());

            return (if_stmt_id, end_if_stmt_id)

        }

        let select_stmt = &ctx.heap[id];

        let total_num_cases = select_stmt.cases.len();

        let mut total_num_ports = 0;

        let end_select_stmt_id = select_stmt.end_select;

        let end_select = &ctx.heap[end_select_stmt_id];

        let stmt_id_after_select_stmt = end_select.next;

        // Put heap IDs into temporary buffers to handle borrowing rules

        let mut call_id_section = self.call_expr_buffer.start_section();

        let mut expr_id_section = self.expression_buffer.start_section();

        for case in select_stmt.cases.iter() {

        }

        // Transform all of the call expressions by takings its argument (the

        // port from which we `get`) and turning it into a temporary variable.

        let mut transformed_stmts = Vec::with_capacity(total_num_ports); // TODO: Recompute this preallocated length, put assert at the end

        let mut locals = Vec::with_capacity(total_num_ports);

        for port_var_idx in 0..call_id_section.len() {

            let get_call_expr_id = call_id_section[port_var_idx];

            let port_expr_id = expr_id_section[port_var_idx];

            // Move the port expression such that it gets assigned to a temporary variable

            let variable_decl_stmt_id = create_ast_variable_declaration_stmt(ctx, variable_id, port_expr_id);

            // Replace the original port expression in the call with a reference

            // to the replacement variable

            let variable_expr_id = create_ast_variable_expr(ctx, variable_id);

            let call_expr = &mut ctx.heap[get_call_expr_id];

            call_expr.arguments[0] = variable_expr_id.upcast();

            transformed_stmts.push(variable_decl_stmt_id.upcast().upcast());

            locals.push(variable_id);

        }

                    let runtime_call_expr_id = create_ast_call_expr(ctx, Method::SelectRegisterCasePort, &mut self.expression_buffer, runtime_call_arguments);

                    let runtime_call_stmt_id = create_ast_expression_stmt(ctx, runtime_call_expr_id.upcast());

                    transformed_stmts.push(runtime_call_stmt_id.upcast());

                    total_port_index += 1;

                }

            }

        }

        // Create the variable that will hold the result of a completed select

        // block. Then create the runtime call that will produce this result

        locals.push(select_variable_id);

        {

            let runtime_call_expr_id = create_ast_call_expr(ctx, Method::SelectWait, &mut self.expression_buffer, Vec::new());

            let variable_stmt_id = create_ast_variable_declaration_stmt(ctx, select_variable_id, runtime_call_expr_id.upcast());

            transformed_stmts.push(variable_stmt_id.upcast().upcast());

        }

        call_id_section.forget();

        expr_id_section.forget();

        // Now we transform each of the select block case's guard and code into

        // a chained if-else statement.

        if total_num_cases > 0 {

            let (if_stmt_id, end_if_stmt_id) = transform_select_case_code(ctx, id, 0, select_variable_id);

            let mut last_if_stmt_id = if_stmt_id;

            let mut last_end_if_stmt_id = end_if_stmt_id;

            transformed_stmts.push(last_if_stmt_id.upcast());

            for case_index in 1..total_num_cases {

                let (if_stmt_id, end_if_stmt_id) = transform_select_case_code(ctx, id, case_index, select_variable_id);

        return Ok(())

    }

}

impl PassRewriting {

    fn create_runtime_call_statement(&self, ctx: &mut Ctx, method: Method, arguments: Vec<ExpressionId>) -> (CallExpressionId, ExpressionStatementId) {

        let call_expr_id = ctx.heap.alloc_call_expression(|this| CallExpression{

            this,

            func_span: InputSpan::new(),

            full_span: InputSpan::new(),

            parser_type: ParserType{

        let call_stmt_id = ctx.heap.alloc_expression_statement(|this| ExpressionStatement{

            this,

            span: InputSpan::new(),

            expression: call_expr_id.upcast(),

            next: StatementId::new_invalid(),

        });

        let call_expr = &mut ctx.heap[call_expr_id];

        call_expr.parent = ExpressionParent::ExpressionStmt(call_stmt_id);

        return (call_expr_id, call_stmt_id);

    }

}

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

// Utilities to create compiler-generated AST nodes

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

        this,

        kind: VariableKind::Local,

        parser_type: ParserType{

            elements: Vec::new(),

            full_span: InputSpan::new(),

        },

        identifier: Identifier::new_empty(InputSpan::new()),

        relative_pos_in_parent: -1,

        unique_id_in_scope: -1,

    });

}

fn create_ast_variable_expr(ctx: &mut Ctx, variable_id: VariableId) -> VariableExpressionId {

    return ctx.heap.alloc_variable_expression(|this| VariableExpression{

        this,

        identifier: Identifier::new_empty(InputSpan::new()),

        declaration: Some(variable_id),

        used_as_binding_target: false,

        parent: ExpressionParent::None,

        unique_id_in_definition: -1

    });

}

    // Set all parents which we can access

    let variable_expr = &mut ctx.heap[variable_expr_id];

    variable_expr.parent = ExpressionParent::Expression(assignment_expr_id.upcast(), 0);

    let value_expr = &mut ctx.heap[initial_value_expr_id];

    *value_expr.parent_mut() = ExpressionParent::Expression(assignment_expr_id.upcast(), 1);

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

    assignment_expr.parent = ExpressionParent::Memory(memory_stmt_id);

    return memory_stmt_id;

}

fn create_ast_if_stmt(ctx: &mut Ctx, condition_expression_id: ExpressionId, true_case: IfStatementCase, false_case: Option<IfStatementCase>) -> (IfStatementId, EndIfStatementId) {

    // Create if statement and the end-if statement

    let if_stmt_id = ctx.heap.alloc_if_statement(|this| IfStatement{

        this,

        span: InputSpan::new(),

        test: condition_expression_id,

        true_case,

        false_case,

        end_if: EndIfStatementId::new_invalid()

    });

    let end_if_stmt_id = ctx.heap.alloc_end_if_statement(|this| EndIfStatement{

        this,

        start_if: if_stmt_id,

        next: StatementId::new_invalid(),

    });

    // Link the statements up as much as we can

    let if_stmt = &mut ctx.heap[if_stmt_id];

    if_stmt.end_if = end_if_stmt_id;

    let condition_expr = &mut ctx.heap[condition_expression_id];

    *condition_expr.parent_mut() = ExpressionParent::If(if_stmt_id);

    return (if_stmt_id, end_if_stmt_id);

}

    // Point if-statement to "false body"

    let if_stmt = &mut ctx.heap[if_statement_id];

    debug_assert!(if_stmt.false_case.is_none()); // simplifies logic, not necessary

    // Point end of false body to the end of the if statement

}

/// Sets the specified AST statement's control flow such that it will be

/// followed by the target statement. This may seem obvious, but may imply that

/// a statement associated with, but different from, the source statement is

/// modified.

fn set_ast_statement_next(ctx: &mut Ctx, source_stmt_id: StatementId, target_stmt_id: StatementId) {

    let source_stmt = &mut ctx.heap[source_stmt_id];

    match source_stmt {

        Statement::Block(stmt) => {

            let end_id = stmt.end_block;

            ctx.heap[end_id].next = target_stmt_id

        },

        Statement::Select(stmt) => {

            let end_id = stmt.end_select;

            ctx.heap[end_id].next = target_stmt_id;

        },

        Statement::EndSelect(stmt) => stmt.next = target_stmt_id,

        Statement::Return(_stmt) => {},

        Statement::Goto(_stmt) => {},

        Statement::New(stmt) => stmt.next = target_stmt_id,

        Statement::Expression(stmt) => stmt.next = target_stmt_id,

    }

}

        statement_section.forget();

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

        self.pop_scope(old_scope);

        Ok(())

    }

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

        let stmt = &ctx.heap[id];

        let expr_id = stmt.initial_expr;

        let variable_id = stmt.variable;

        self.checked_add_local(ctx, self.cur_scope, self.relative_pos_in_parent, variable_id)?;

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

        debug_assert_eq!(self.expr_parent, ExpressionParent::None);

        self.expr_parent = ExpressionParent::Memory(id);

        self.visit_assignment_expr(ctx, expr_id)?;

        self.expr_parent = ExpressionParent::None;

        Ok(())

    }

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

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

        if let Some(right_body_id) = right_body_id {

            self.visit_stmt(ctx, right_body_id)?;

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

        }

        self.prev_stmt = end_fork_id.upcast();

        Ok(())

    }

    fn visit_select_stmt(&mut self, ctx: &mut Ctx, id: SelectStatementId) -> VisitorResult {

        let select_stmt = &ctx.heap[id];

        let end_select_id = select_stmt.end_select;

        // Select statements may only occur inside sync blocks

        if self.in_sync.is_invalid() {

            return Err(ParseError::new_error_str_at_span(

                &ctx.module().source, select_stmt.span,

                "select statements may only occur inside sync blocks"

            ));

        }

        if !self.def_type.is_primitive() {

    }

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

        let var_expr = &ctx.heap[id];

        // Check if declaration was already resolved (this occurs for the

        // variable expr that is on the LHS of the assignment expr that is

        // associated with a variable declaration)

        let mut variable_id = var_expr.declaration;

        let mut is_binding_target = false;

        // Otherwise try to find it

        if variable_id.is_none() {

            variable_id = self.find_variable(ctx, self.relative_pos_in_parent, &var_expr.identifier);

        }

        // Otherwise try to see if is a variable introduced by a binding expr

        let variable_id = if let Some(variable_id) = variable_id {

            variable_id

        } else {

            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"

                ));