define_new_ast_id!(CallExpressionId, ExpressionId, index(CallExpression, Expression::Call, expressions), alloc(alloc_call_expression));

define_new_ast_id!(VariableExpressionId, ExpressionId, index(VariableExpression, Expression::Variable, expressions), alloc(alloc_variable_expression));

#[derive(Debug)]

pub struct Heap {

    // Root arena, contains the entry point for different modules. Each root

    pub(crate) definitions: Arena<Definition>,

    pub(crate) statements: Arena<Statement>,

    pub(crate) expressions: Arena<Expression>,

}

impl Heap {

            definitions: Arena::new(),

            statements: Arena::new(),

            expressions: Arena::new(),

        }

    }

    pub fn alloc_memory_statement(

}

#[derive(Debug, Clone, Copy)]

    Definition(DefinitionId),

}

/// `ScopeNode` is a helper that links scopes in two directions. It doesn't

/// actually contain any information associated with the scope, this may be

/// found on the AST elements that `Scope` points to.

#[derive(Debug, Clone)]

    pub relative_pos_in_parent: i32,

}

            nested: Vec::new(),

            relative_pos_in_parent: -1,

    }

}

    pub parser_type: ParserType,

    pub identifier: Identifier,

    // Validator/linker

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

}

    pub poly_vars: Vec<Identifier>,

    // Parsing

    pub parameters: Vec<VariableId>,

    pub body: BlockStatementId,

    // Validation/linking

    pub num_expressions_in_body: i32,

        Self{ 

            this, defined_in, span, variant, identifier, poly_vars,

            parameters: Vec::new(),

            body: BlockStatementId::new_invalid(),

            num_expressions_in_body: -1,

        }

    pub identifier: Identifier,

    pub poly_vars: Vec<Identifier>,

    // Parser

    pub parameters: Vec<VariableId>,

    pub body: BlockStatementId,

    // Validation/linking

    pub num_expressions_in_body: i32,

            this, defined_in,

            builtin: false,

            span, identifier, poly_vars,

            parameters: Vec::new(),

            body: BlockStatementId::new_invalid(),

            num_expressions_in_body: -1,

        }

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

        }

    }

}

#[derive(Debug, Clone)]

    pub statements: Vec<StatementId>,

    pub end_block: EndBlockStatementId,

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

}

    // Phase 1: parser

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

    pub test: ExpressionId,

    pub end_if: EndIfStatementId,

}

#[derive(Debug, Clone)]

pub struct EndIfStatement {

    pub this: EndIfStatementId,

    // Phase 1: parser

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

    pub test: ExpressionId,

    pub end_while: EndWhileStatementId,

    pub in_sync: SynchronousStatementId, // may be invalid

}

    pub this: SynchronousStatementId,

    // Phase 1: parser

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

    pub end_sync: EndSynchronousStatementId,

}

    pub this: ForkStatementId,

    // Phase 1: parser

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

    pub end_fork: EndForkStatementId,

}

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

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

    pub guard: StatementId,

    // Phase 2: Validation and Linking

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

}

                    self.kv(indent3).with_s_key("PolyVar").with_identifier_val(&poly_var_id);

                }

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

                for variable_id in &def.parameters {

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

                    .with_s_key("Block");

                self.kv(indent2).with_s_key("EndBlockID").with_disp_val(&stmt.end_block.0.index);

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

                for stmt_id in &stmt.statements {

                self.write_expr(heap, stmt.test, indent3);

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

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

                }

            },

            Statement::EndIf(stmt) => {

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

                self.write_expr(heap, stmt.test, indent3);

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

            },

            Statement::EndWhile(stmt) => {

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

                    .with_s_key("Synchronous");

                self.kv(indent2).with_s_key("EndSync").with_disp_val(&stmt.end_sync.0.index);

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

            },

            Statement::EndSynchronous(stmt) => {

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

                    .with_s_key("Fork");

                self.kv(indent2).with_s_key("EndFork").with_disp_val(&stmt.end_fork.0.index);

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

                if let Some(right_body_id) = stmt.right_body {

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

                }

            },

            Statement::EndFork(stmt) => {

                    self.write_stmt(heap, case.guard, indent4);

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

                }

            },

            Statement::EndSelect(stmt) => {

        self.kv(indent2).with_s_key("Kind").with_debug_val(&var.kind);

        self.kv(indent2).with_s_key("ParserType")

            .with_custom_val(|w| write_parser_type(w, heap, &var.parser_type));

        self.kv(indent2).with_s_key("UniqueScopeID").with_disp_val(&var.unique_id_in_scope);

    }

    /// Creates a new execution frame. Does not modify the stack in any way.

    pub fn new(heap: &Heap, definition_id: DefinitionId, monomorph_idx: i32) -> Self {

        let definition = &heap[definition_id];

            _ => unreachable!("initializing frame with {:?} instead of a function/component", definition),

        };

        // Another not-so-pretty thing that has to be replaced somewhere in the

        // future...

            // Check current block

            if cur_size > *max_size { *max_size = cur_size; }

            // And child blocks

            }

        }

        let mut max_stack_size = 0;

        Frame{

            definition: definition_id,

            monomorph_idx,

            expr_stack: VecDeque::with_capacity(128),

            expr_values: VecDeque::with_capacity(128),

            max_stack_size,

            },

            Statement::EndBlock(stmt) => {

                let block = &heap[stmt.start_block];

                cur_frame.position = stmt.next;

                Ok(EvalContinuation::Stepping)

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

                let test_value = self.store.maybe_read_ref(&test_value).as_bool();

                if test_value {

                } else {

                    // Not true, and no false body

                    cur_frame.position = stmt.end_if.upcast();

            },

            Statement::EndIf(stmt) => {

                cur_frame.position = stmt.next;

                Ok(EvalContinuation::Stepping)

            },

            Statement::While(stmt) => {

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

                let test_value = self.store.maybe_read_ref(&test_value).as_bool();

                if test_value {

                } else {

                    cur_frame.position = stmt.end_while.upcast();

                }

            },

            Statement::EndWhile(stmt) => {

                cur_frame.position = stmt.next;

                Ok(EvalContinuation::Stepping)

            },

            Statement::Break(stmt) => {

                Ok(EvalContinuation::Stepping)

            },

            Statement::Synchronous(stmt) => {

                Ok(EvalContinuation::SyncBlockStart)

            },

            Statement::EndSynchronous(stmt) => {

                cur_frame.position = stmt.next;

                Ok(EvalContinuation::SyncBlockEnd)

            },

            Statement::Fork(stmt) => {

                if stmt.right_body.is_none() {

                    // No reason to fork

                } else {

                    // Need to fork

                    if let Some(go_left) = ctx.performed_fork() {

                        // Runtime has created a fork

                        if go_left {

                        } else {

                        }

                    } else {

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

            },

            Statement::EndSelect(stmt) => {

                cur_frame.position = stmt.next;

                Ok(EvalContinuation::Stepping)

            },

                Value::SInt32(v) => Value::SInt32($apply *v),

                Value::SInt64(v) => Value::SInt64($apply *v),

                _ => unreachable!("apply_unary_operator {:?} on value {:?}", $op, $value),

        }

    }

                _ => unreachable!("apply_unary_operator {:?} on value {:?}", op, value),

            }

        },

        UO::LogicalNot => { return Value::Bool(!value.as_bool()); },

    }

}

        span: InputSpan::new(),

        identifier: Identifier{ span: InputSpan::new(), value: func_ident_ref.clone() },

        poly_vars,

        parameters: Vec::new(),

        body: BlockStatementId::new_invalid(),

        num_expressions_in_body: -1,

    });

        let identifier = Identifier{ span: InputSpan::new(), value: p.string_pool.intern(arg_name.as_bytes()) };

        let param_id = p.heap.alloc_variable(|this| Variable{

            this,

            kind: VariableKind::Parameter,

            parser_type: arg_type.clone(),

            identifier,

            unique_id_in_scope: 0

        });

        parameters.push(param_id);

    let func = &mut p.heap[func_id];

    func.parameters = parameters;

    p.symbol_table.insert_symbol(SymbolScope::Global, Symbol{

        name: func_ident_ref,

        // Consume return types

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

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

            module_scope, false, None

        )?;

        // Assign everything in the preallocated AST node

        let function = ctx.heap[definition_id].as_function_mut();

        function.parameters = parameters;

        function.body = body;

        Ok(())

    }

    /// Consumes a statement and returns a boolean indicating whether it was a

    /// block or not.

        let next = iter.next().expect("consume_statement has a next token");

        if next == TokenKind::OpenCurly {

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

        } else if next == TokenKind::Ident {

            let ident = peek_ident(&module.source, iter).unwrap();

            if ident == KW_STMT_IF {

                // Consume if statement and place end-if statement directly

                // after it.

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

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

                    this,

                    start_if: id,

                    next: StatementId::new_invalid()

                });

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

                if_stmt.end_if = end_if;

            } else if ident == KW_STMT_WHILE {

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

                let end_while = ctx.heap.alloc_end_while_statement(|this| EndWhileStatement {

                    this,

                    start_while: id,

                    next: StatementId::new_invalid()

                });

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

                while_stmt.end_while = end_while;

            } else if ident == KW_STMT_BREAK {

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

            } else if ident == KW_STMT_CONTINUE {

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

            } else if ident == KW_STMT_SYNC {

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

                let end_sync = ctx.heap.alloc_end_synchronous_statement(|this| EndSynchronousStatement {

                    this,

                    start_sync: id,

                    next: StatementId::new_invalid()

                });

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

                sync_stmt.end_sync = end_sync;

            } else if ident == KW_STMT_FORK {

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

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

                    this,

                    start_fork: id,

                    next: StatementId::new_invalid(),

                });

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

                fork_stmt.end_fork = end_fork;

            } else if ident == KW_STMT_SELECT {

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

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

                    this,

                    start_select: id,

                    next: StatementId::new_invalid(),

                });

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

                select_stmt.end_select = end_select;

            } else if ident == KW_STMT_RETURN {

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

            } else if ident == KW_STMT_GOTO {

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

            } else if ident == KW_STMT_NEW {

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

            } else if ident == KW_STMT_CHANNEL {

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

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

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

                if let Some(memory_stmt_id) = self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {

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

                } else {

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

                }

            }

        } else if next == TokenKind::OpenParen {

            // Same as above: memory statement or normal expression

            if let Some(memory_stmt_id) = self.maybe_consume_memory_statement_without_semicolon(module, iter, ctx)? {

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

            } else {

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

            }

        } else {

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

        }

    }

    fn consume_block_statement(

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

    ) -> Result<BlockStatementId, ParseError> {

        let mut stmt_section = self.statements.start_section();

        let mut next = iter.next();

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

                    &module.source, iter.last_valid_pos(), "expected a statement or '}'"

                ));

            }

            next = iter.next();

        }

        let statements = stmt_section.into_vec();

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

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

            this,

            span: block_span,

            statements,

            end_block: EndBlockStatementId::new_invalid(),

            next: StatementId::new_invalid(),

        });

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

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

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

            iter.consume();