define_new_ast_id!(ChannelStatementId, LocalStatementId);

define_new_ast_id!(LabeledStatementId, StatementId, index(LabeledStatement, Statement::Labeled, statements), alloc(alloc_labeled_statement));

define_new_ast_id!(IfStatementId, StatementId, index(IfStatement, Statement::If, statements), alloc(alloc_if_statement));

define_new_ast_id!(EndIfStatementId, StatementId, index(EndIfStatement, Statement::EndIf, statements), alloc(alloc_end_if_statement));

define_new_ast_id!(WhileStatementId, StatementId, index(WhileStatement, Statement::While, statements), alloc(alloc_while_statement));

define_new_ast_id!(EndWhileStatementId, StatementId, index(EndWhileStatement, Statement::EndWhile, statements), alloc(alloc_end_while_statement));

define_new_ast_id!(BreakStatementId, StatementId, index(BreakStatement, Statement::Break, statements), alloc(alloc_break_statement));

define_new_ast_id!(ContinueStatementId, StatementId, index(ContinueStatement, Statement::Continue, statements), alloc(alloc_continue_statement));

define_new_ast_id!(SynchronousStatementId, StatementId, index(SynchronousStatement, Statement::Synchronous, statements), alloc(alloc_synchronous_statement));

define_new_ast_id!(EndSynchronousStatementId, StatementId, index(EndSynchronousStatement, Statement::EndSynchronous, statements), alloc(alloc_end_synchronous_statement));

define_new_ast_id!(ForkStatementId, StatementId, index(ForkStatement, Statement::Fork, statements), alloc(alloc_fork_statement));

define_new_ast_id!(EndForkStatementId, StatementId, index(EndForkStatement, Statement::EndFork, statements), alloc(alloc_end_fork_statement));

define_new_ast_id!(ReturnStatementId, StatementId, index(ReturnStatement, Statement::Return, statements), alloc(alloc_return_statement));

define_new_ast_id!(GotoStatementId, StatementId, index(GotoStatement, Statement::Goto, statements), alloc(alloc_goto_statement));

define_new_ast_id!(NewStatementId, StatementId, index(NewStatement, Statement::New, statements), alloc(alloc_new_statement));

define_new_ast_id!(ExpressionStatementId, StatementId, index(ExpressionStatement, Statement::Expression, statements), alloc(alloc_expression_statement));

define_aliased_ast_id!(ExpressionId, Id<Expression>, index(Expression, expressions));

define_new_ast_id!(AssignmentExpressionId, ExpressionId, index(AssignmentExpression, Expression::Assignment, expressions), alloc(alloc_assignment_expression));

define_new_ast_id!(BindingExpressionId, ExpressionId, index(BindingExpression, Expression::Binding, expressions), alloc(alloc_binding_expression));

define_new_ast_id!(ConditionalExpressionId, ExpressionId, index(ConditionalExpression, Expression::Conditional, expressions), alloc(alloc_conditional_expression));

define_new_ast_id!(BinaryExpressionId, ExpressionId, index(BinaryExpression, Expression::Binary, expressions), alloc(alloc_binary_expression));

define_new_ast_id!(UnaryExpressionId, ExpressionId, index(UnaryExpression, Expression::Unary, expressions), alloc(alloc_unary_expression));

define_new_ast_id!(IndexingExpressionId, ExpressionId, index(IndexingExpression, Expression::Indexing, expressions), alloc(alloc_indexing_expression));

    Local(LocalStatement),

    Labeled(LabeledStatement),

    If(IfStatement),

    EndIf(EndIfStatement),

    While(WhileStatement),

    EndWhile(EndWhileStatement),

    Break(BreakStatement),

    Continue(ContinueStatement),

    Synchronous(SynchronousStatement),

    EndSynchronous(EndSynchronousStatement),

    Fork(ForkStatement),

    EndFork(EndForkStatement),

    Return(ReturnStatement),

    Goto(GotoStatement),

    New(NewStatement),

    Expression(ExpressionStatement),

}

impl Statement {

    pub fn as_block(&self) -> &BlockStatement {

        match self {

            Statement::Block(result) => result,

            _ => panic!("Unable to cast `Statement` to `BlockStatement`"),

        }

    pub fn span(&self) -> InputSpan {

        match self {

            Statement::Block(v) => v.span,

            Statement::Local(v) => v.span(),

            Statement::Labeled(v) => v.label.span,

            Statement::If(v) => v.span,

            Statement::While(v) => v.span,

            Statement::Break(v) => v.span,

            Statement::Continue(v) => v.span,

            Statement::Synchronous(v) => v.span,

            Statement::Fork(v) => v.span,

            Statement::Return(v) => v.span,

            Statement::Goto(v) => v.span,

            Statement::New(v) => v.span,

            Statement::Expression(v) => v.span,

        }

    }

    pub fn link_next(&mut self, next: StatementId) {

        match self {

            Statement::Block(stmt) => stmt.next = next,

            Statement::EndBlock(stmt) => stmt.next = next,

            Statement::Local(stmt) => match stmt {

                LocalStatement::Channel(stmt) => stmt.next = next,

                LocalStatement::Memory(stmt) => stmt.next = next,

            },

            Statement::EndIf(stmt) => stmt.next = next,

            Statement::EndWhile(stmt) => stmt.next = next,

            Statement::EndSynchronous(stmt) => stmt.next = next,

            Statement::EndFork(stmt) => stmt.next = next,

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

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

            Statement::Return(_)

            | Statement::Break(_)

            | Statement::Continue(_)

            | Statement::Synchronous(_)

            | Statement::Fork(_)

            | Statement::Goto(_)

            | Statement::While(_)

            | Statement::Labeled(_)

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

        }

    }

}

#[derive(Debug, Clone)]

pub struct BlockStatement {

    pub this: BlockStatementId,

    // Phase 1: parser

    pub left_body: BlockStatementId,

    pub right_body: Option<BlockStatementId>,

    pub end_fork: EndForkStatementId,

}

#[derive(Debug, Clone)]

pub struct EndForkStatement {

    pub this: EndForkStatementId,

    pub start_fork: ForkStatementId,

    pub next: StatementId,

}

#[derive(Debug, Clone)]

pub struct ReturnStatement {

    pub this: ReturnStatementId,

    // Phase 1: parser

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

    pub expressions: Vec<ExpressionId>,

}

#[derive(Debug, Clone)]

pub struct GotoStatement {

    pub this: GotoStatementId,

    // Phase 1: parser

const PREFIX_SKIP_STMT_ID: &'static str = "SSki";

const PREFIX_LABELED_STMT_ID: &'static str = "SLab";

const PREFIX_IF_STMT_ID: &'static str = "SIf ";

const PREFIX_ENDIF_STMT_ID: &'static str = "SEIf";

const PREFIX_WHILE_STMT_ID: &'static str = "SWhi";

const PREFIX_ENDWHILE_STMT_ID: &'static str = "SEWh";

const PREFIX_BREAK_STMT_ID: &'static str = "SBre";

const PREFIX_CONTINUE_STMT_ID: &'static str = "SCon";

const PREFIX_SYNC_STMT_ID: &'static str = "SSyn";

const PREFIX_ENDSYNC_STMT_ID: &'static str = "SESy";

const PREFIX_FORK_STMT_ID: &'static str = "SFrk";

const PREFIX_END_FORK_STMT_ID: &'static str = "SEFk";

const PREFIX_RETURN_STMT_ID: &'static str = "SRet";

const PREFIX_ASSERT_STMT_ID: &'static str = "SAsr";

const PREFIX_GOTO_STMT_ID: &'static str = "SGot";

const PREFIX_NEW_STMT_ID: &'static str = "SNew";

const PREFIX_PUT_STMT_ID: &'static str = "SPut";

const PREFIX_EXPR_STMT_ID: &'static str = "SExp";

const PREFIX_ASSIGNMENT_EXPR_ID: &'static str = "EAsi";

const PREFIX_BINDING_EXPR_ID: &'static str = "EBnd";

const PREFIX_CONDITIONAL_EXPR_ID: &'static str = "ECnd";

const PREFIX_BINARY_EXPR_ID: &'static str = "EBin";

const PREFIX_UNARY_EXPR_ID: &'static str = "EUna";

const PREFIX_INDEXING_EXPR_ID: &'static str = "EIdx";

                self.write_stmt(heap, stmt.left_body.upcast(), indent3);

                if let Some(right_body_id) = stmt.right_body {

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

                    self.write_stmt(heap, right_body_id.upcast(), indent3);

                }

            },

            Statement::EndFork(stmt) => {

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

                    .with_s_key("EndFork");

                self.kv(indent2).with_s_key("StartFork").with_disp_val(&stmt.start_fork.0.index);

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

            }

            Statement::Return(stmt) => {

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

                    .with_s_key("Return");

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

                for expr_id in &stmt.expressions {

                    self.write_expr(heap, *expr_id, indent3);

                }

            },

            Statement::Goto(stmt) => {

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

                    .with_s_key("Goto");

                        // Request the runtime to create a fork of the current

                        // branch

                        return Ok(EvalContinuation::NewFork);

                    }

                }

                Ok(EvalContinuation::Stepping)

            },

            Statement::EndFork(stmt) => {

                cur_frame.position = stmt.next;

                Ok(EvalContinuation::Stepping)

            Statement::Return(_stmt) => {

                debug_assert!(heap[cur_frame.definition].is_function());

                debug_assert_eq!(cur_frame.expr_values.len(), 1, "expected one expr value for return statement");

                // The preceding frame has executed a call, so is expecting the

                // return expression on its expression value stack. Note that

                // we may be returning a reference to something on our stack,

                // so we need to read that value and clone it.

                let return_value = cur_frame.expr_values.pop_back().unwrap();

                let return_value = match return_value {

                    Value::Ref(value_id) => self.store.read_copy(value_id),

                    _ => return_value,

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

                section.push(id.upcast());

                let end_fork = ctx.heap.alloc_end_fork_statement(|this| EndForkStatement {

                    this,

                    start_fork: id,

                    next: StatementId::new_invalid(),

                });

                section.push(end_fork.upcast());

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

                fork_stmt.end_fork = end_fork;

            } else if ident == KW_STMT_RETURN {

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

                section.push(id.upcast());

            } else if ident == KW_STMT_GOTO {

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

                section.push(id.upcast());

            } else if ident == KW_STMT_NEW {

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

                section.push(id.upcast());

            } else if ident == KW_STMT_CHANNEL {

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

                section.push(id.upcast().upcast());

            None

        };

        Ok(ctx.heap.alloc_fork_statement(|this| ForkStatement{

            this,

            span: fork_span,

            left_body,

            right_body,

            end_fork: EndForkStatementId::new_invalid(),

        }))

    }

    fn consume_return_statement(

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

    ) -> Result<ReturnStatementId, ParseError> {

        let return_span = consume_exact_ident(&module.source, iter, KW_STMT_RETURN)?;

        let mut scoped_section = self.expressions.start_section();

        consume_comma_separated_until(

            TokenKind::SemiColon, &module.source, iter, ctx,

            |_source, iter, ctx| self.consume_expression(module, iter, ctx),

            &mut scoped_section, "an expression", None

        )?;

        let expressions = scoped_section.into_vec();

// Keywords - statements

pub(crate) const KW_STMT_CHANNEL:  &'static [u8] = b"channel";

pub(crate) const KW_STMT_IF:       &'static [u8] = b"if";

pub(crate) const KW_STMT_ELSE:     &'static [u8] = b"else";

pub(crate) const KW_STMT_WHILE:    &'static [u8] = b"while";

pub(crate) const KW_STMT_BREAK:    &'static [u8] = b"break";

pub(crate) const KW_STMT_CONTINUE: &'static [u8] = b"continue";

pub(crate) const KW_STMT_GOTO:     &'static [u8] = b"goto";

pub(crate) const KW_STMT_RETURN:   &'static [u8] = b"return";

pub(crate) const KW_STMT_SYNC:     &'static [u8] = b"sync";

pub(crate) const KW_STMT_FORK:     &'static [u8] = b"fork";

pub(crate) const KW_STMT_OR:       &'static [u8] = b"or";

pub(crate) const KW_STMT_NEW:      &'static [u8] = b"new";

// Keywords - types

// Since types are needed for returning diagnostic information to the user, the

// string variants are put here as well.

pub(crate) const KW_TYPE_IN_PORT_STR:  &'static str = "in";

pub(crate) const KW_TYPE_OUT_PORT_STR: &'static str = "out";

pub(crate) const KW_TYPE_MESSAGE_STR:  &'static str = "msg";

pub(crate) const KW_TYPE_BOOL_STR:     &'static str = "bool";

pub(crate) const KW_TYPE_UINT8_STR:    &'static str = "u8";

pub(crate) const KW_TYPE_UINT16_STR:   &'static str = "u16";

                self.visit_continue_stmt(ctx, this)

            },

            Statement::Synchronous(stmt) => {

                let this = stmt.this;

                self.visit_synchronous_stmt(ctx, this)

            },

            Statement::EndSynchronous(_stmt) => Ok(()),

            Statement::Fork(stmt) => {

                let this = stmt.this;

                self.visit_fork_stmt(ctx, this)

            },

            Statement::EndFork(_stmt) => Ok(()),

            Statement::Return(stmt) => {

                let this = stmt.this;

                self.visit_return_stmt(ctx, this)

            },

            Statement::Goto(stmt) => {

                let this = stmt.this;

                self.visit_goto_stmt(ctx, this)

            },

            Statement::New(stmt) => {

                let this = stmt.this;

                self.visit_new_stmt(ctx, this)

            },

    // --- enum variant handling

    fn visit_block_stmt(&mut self, _ctx: &mut Ctx, _id: BlockStatementId) -> VisitorResult { Ok(()) }

    fn visit_local_memory_stmt(&mut self, _ctx: &mut Ctx, _id: MemoryStatementId) -> VisitorResult { Ok(()) }

    fn visit_local_channel_stmt(&mut self, _ctx: &mut Ctx, _id: ChannelStatementId) -> VisitorResult { Ok(()) }

    fn visit_labeled_stmt(&mut self, _ctx: &mut Ctx, _id: LabeledStatementId) -> VisitorResult { Ok(()) }

    fn visit_if_stmt(&mut self, _ctx: &mut Ctx, _id: IfStatementId) -> VisitorResult { Ok(()) }

    fn visit_while_stmt(&mut self, _ctx: &mut Ctx, _id: WhileStatementId) -> VisitorResult { Ok(()) }

    fn visit_break_stmt(&mut self, _ctx: &mut Ctx, _id: BreakStatementId) -> VisitorResult { Ok(()) }

    fn visit_continue_stmt(&mut self, _ctx: &mut Ctx, _id: ContinueStatementId) -> VisitorResult { Ok(()) }

    fn visit_synchronous_stmt(&mut self, _ctx: &mut Ctx, _id: SynchronousStatementId) -> VisitorResult { Ok(()) }

    fn visit_fork_stmt(&mut self, _ctx: &mut Ctx, _id: ForkStatementId) -> VisitorResult { Ok(()) }

    fn visit_return_stmt(&mut self, _ctx: &mut Ctx, _id: ReturnStatementId) -> VisitorResult { Ok(()) }

    fn visit_goto_stmt(&mut self, _ctx: &mut Ctx, _id: GotoStatementId) -> VisitorResult { Ok(()) }

    fn visit_new_stmt(&mut self, _ctx: &mut Ctx, _id: NewStatementId) -> VisitorResult { Ok(()) }

    fn visit_expr_stmt(&mut self, _ctx: &mut Ctx, _id: ExpressionStatementId) -> VisitorResult { Ok(()) }

    // Expressions

    // --- enum matching

    fn visit_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> VisitorResult {

        match &ctx.heap[id] {

            Expression::Assignment(expr) => {

                let this = expr.this;

                self.visit_assignment_expr(ctx, this)