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

    Fork(ForkStatement),

    EndFork(EndForkStatement),

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

            Statement::EndBlock(_) | Statement::EndIf(_) | Statement::EndWhile(_) | Statement::EndSynchronous(_) | Statement::EndFork(_) => unreachable!(),

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

            | Statement::Fork(_)

#[derive(Debug, Clone)]

pub struct ForkStatement {

    pub this: ForkStatementId,

    // Phase 1: parser

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

    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,

}

                    this,

                    start_sync: id,

                    next: StatementId::new_invalid()

            } else if ident == KW_STMT_FORK {

                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;

    fn consume_fork_statement(

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

    ) -> Result<ForkStatementId, ParseError> {

        let fork_span = consume_exact_ident(&module.source, iter, KW_STMT_FORK)?;

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

        let right_body = if has_ident(&module.source, iter, KW_STMT_OR) {

            iter.consume();

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

            Some(right_body)

        } else {

            None

        };

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

            this,

            span: fork_span,

            left_body,

            right_body,

            end_fork: EndForkStatementId::new_invalid(),

        }))

    }

    fn visit_fork_stmt(&mut self, ctx: &mut Ctx, id: ForkStatementId) -> VisitorResult {

        let fork_stmt = &ctx.heap[id];

        let left_body_id = fork_stmt.left_body;

        let right_body_id = fork_stmt.right_body;

        self.visit_block_stmt(ctx, left_body_id)?;

        if let Some(right_body_id) = right_body_id {

            self.visit_block_stmt(ctx, right_body_id)?;

        }

        Ok(())

    }

/*

 * pass_validation_linking.rs

 *

 * The pass that will validate properties of the AST statements (one is not

 * allowed to nest synchronous statements, instantiating components occurs in

 * the right places, etc.) and expressions (assignments may not occur in

 * arbitrary expressions).

 *

 * Furthermore, this pass will also perform "linking", in the sense of: some AST

 * nodes have something to do with one another, so we link them up in this pass

 * (e.g. setting the parents of expressions, linking the control flow statements

 * like `continue` and `break` up to the respective loop statement, etc.).

 *

 * There are several "confusing" parts about this pass:

 *

 * Setting expression parents: this is the simplest one. The pass struct acts

 * like a little state machine. When visiting an expression it will set the

 * "parent expression" field of the pass to itself, then visit its child. The

 * child will look at this "parent expression" field to determine its parent.

 *

 * Setting the `next` statement: the AST is a tree, but during execution we walk

 * a linear path through all statements. So where appropriate a statement may

 * set the "previous statement" field of the pass to itself. When visiting the

 * subsequent statement it will check this "previous statement", and if set, it

 * will link this previous statement up to itself. Not every statement has a

 * previous statement. Hence there are two patterns that occur: assigning the

 * `next` value, then clearing the "previous statement" field. And assigning the

 * `next` value, and then putting the current statement's ID in the "previous

 * statement" field. Because it is so common, this file contain two macros that

 * perform that operation.

 *

 * To make storing types for polymorphic procedures simpler and more efficient,

 * we assign to each expression in the procedure a unique ID. This is what the

 * "next expression index" field achieves. Each expression simply takes the

 * current value, and then increments this counter.

 */

        // test expression, not on if-statement itself. Hence the if statement

        // does not have a static subsequent statement.

    fn visit_fork_stmt(&mut self, ctx: &mut Ctx, id: ForkStatementId) -> VisitorResult {

        let fork_stmt = &ctx.heap[id];

        let end_fork_id = fork_stmt.end_fork;

        let left_body_id = fork_stmt.left_body;

        let right_body_id = fork_stmt.right_body;

        // Visit the respective bodies. Like the if statement, a fork statement

        // does not have a single static subsequent statement. It forks and then

        // each fork has a different next statement.

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

        self.visit_block_stmt(ctx, left_body_id)?;

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

        if let Some(right_body_id) = right_body_id {

            self.visit_block_stmt(ctx, right_body_id)?;

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

        }

        self.prev_stmt = end_fork_id.upcast();

        Ok(())

    }

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

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

        KW_STMT_SYNC | KW_STMT_FORK | KW_STMT_NEW => true,

            Statement::Fork(stmt) => {

                let this = stmt.this;

                self.visit_fork_stmt(ctx, this)

            },

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

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