}

    }

    pub fn len(&self) -> usize {

        return self.len;

    }

define_new_ast_id!(StructDefinitionId, DefinitionId, index(StructDefinition, Definition::Struct, definitions), alloc(alloc_struct_definition));

define_new_ast_id!(EnumDefinitionId, DefinitionId, index(EnumDefinition, Definition::Enum, definitions), alloc(alloc_enum_definition));

define_new_ast_id!(UnionDefinitionId, DefinitionId, index(UnionDefinition, Definition::Union, definitions), alloc(alloc_union_definition));

define_aliased_ast_id!(StatementId, Id<Statement>, index(Statement, statements));

define_new_ast_id!(BlockStatementId, StatementId, index(BlockStatement, Statement::Block, statements), alloc(alloc_block_statement));

impl Index<MemoryStatementId> for Heap {

    type Output = MemoryStatement;

    fn index(&self, index: MemoryStatementId) -> &Self::Output {

    }

}

impl Index<ChannelStatementId> for Heap {

    type Output = ChannelStatement;

    fn index(&self, index: ChannelStatementId) -> &Self::Output {

    }

}

    Tuple(u32),

    // User defined type with any number of nested types

    Instance(DefinitionId, u32),    // instance of data type

}

impl ConcreteTypePart {

                }

                target.push(')');

            },

            CTP::Function(definition_id, num_poly_args) |

            CTP::Component(definition_id, num_poly_args) => {

            }

        }

        idx

    }

}

#[derive(Debug)]

    Struct(StructDefinition),

    Enum(EnumDefinition),

    Union(UnionDefinition),

}

impl Definition {

            _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),

        }

    }

    pub(crate) fn as_union_mut(&mut self) -> &mut UnionDefinition {

        match self {

            Definition::Union(result) => result,

            _ => panic!("Unable to cast 'Definition' to 'UnionDefinition'"),

        }

    }

        match self {

            _ => false,

        }

    }

        match self {

            _ => panic!("Unable to cast `Definition` to `Function`"),

        }

    }

        match self {

            _ => panic!("Unable to cast `Definition` to `Function`"),

        }

    }

    pub fn defined_in(&self) -> RootId {

        match self {

            Definition::Struct(def) => def.defined_in,

            Definition::Enum(def) => def.defined_in,

            Definition::Union(def) => def.defined_in,

        }

    }

    pub fn identifier(&self) -> &Identifier {

        match self {

            Definition::Struct(def) => &def.identifier,

            Definition::Enum(def) => &def.identifier,

            Definition::Union(def) => &def.identifier,

        }

    }

    pub fn poly_vars(&self) -> &Vec<Identifier> {

            Definition::Struct(def) => &def.poly_vars,

            Definition::Enum(def) => &def.poly_vars,

            Definition::Union(def) => &def.poly_vars,

        }

    }

}

    }

}

    Composite,

}

// Note that we will have function definitions for builtin functions as well. In

// that case the span, the identifier span and the body are all invalid.

#[derive(Debug, Clone)]

    pub defined_in: RootId,

    // Symbol scanning

    pub builtin: bool,

    pub span: InputSpan,

    pub identifier: Identifier,

    pub poly_vars: Vec<Identifier>,

    // Parser

    pub parameters: Vec<VariableId>,

    pub scope: ScopeId,

    pub body: BlockStatementId,

    // Validation/linking

    pub num_expressions_in_body: i32,

}

    pub(crate) fn new_empty(

    ) -> Self {

        Self {

            this, defined_in,

            builtin: false,

            parameters: Vec::new(),

            scope: ScopeId::new_invalid(),

            body: BlockStatementId::new_invalid(),

}

impl Statement {

    pub fn as_new(&self) -> &NewStatement {

        match self {

            Statement::New(result) => result,

            LocalStatement::Channel(stmt) => stmt.this.upcast(),

        }

    }

    pub fn span(&self) -> InputSpan {

        match self {

            LocalStatement::Channel(v) => v.span,

    pub parser_type: ParserType, // of the function call, not the return type

    pub method: Method,

    pub arguments: Vec<ExpressionId>,

    // Validator/Linker

    pub parent: ExpressionParent,

    pub unique_id_in_definition: i32,

    SelectRegisterCasePort, // SelectRegisterCasePort(case_index, port_index, port_id)

    SelectWait, // SelectWait() -> u32

    // User-defined

    UserComponent,

}

                    }

                }

            }

                self.kv(indent).with_id(PREFIX_FUNCTION_ID, def.this.0.index)

                    .with_s_key("DefinitionFunction");

                    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(indent2).with_s_key("Body");

                self.write_stmt(heap, def.body.upcast(), indent3);

            },

        }

    }

                    .with_s_key("CallExpr");

                self.kv(indent2).with_s_key("UniqueId").with_disp_val(&expr.unique_id_in_definition);

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

                    .with_custom_val(|t| write_parser_type(t, heap, &expr.parser_type));

            let statement = &heap[frame.position];

            let statement_span = statement.span();

            // Lookup module name, if it has one

            let module_name = if let Some(name) = &module.name {

                name.as_str().to_string()

            } else {

            frames.push(EvalFrame{

                line: statement_span.begin.line,

                module_name,

            });

        }

#[derive(Debug, Clone)]

pub(crate) struct Frame {

    pub(crate) monomorph_type_id: TypeId,

    pub(crate) position: StatementId,

    pub(crate) expr_stack: VecDeque<ExprInstruction>, // hack for expression evaluation, evaluated by popping from back

impl Frame {

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

        let definition = &heap[definition_id];

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

        // future...

    // Returned only in non-sync mode

    ComponentTerminated,

    SyncBlockStart,

    NewChannel,

}

}

impl Prompt {

        let mut prompt = Self{

            frames: Vec::new(),

            store: Store::new(),

        // Checking if we're at the end of execution

        let cur_frame = self.frames.last_mut().unwrap();

        if cur_frame.position.is_invalid() {

                todo!("End of function without return, return an evaluation error");

            }

            return Ok(EvalContinuation::ComponentTerminated);

                                Method::UserComponent => {

                                    // This is actually handled by the evaluation

                                    // of the statement.

                                    debug_assert_eq!(heap[cur_frame.position].as_new().expression, expr.this)

                                },

                                    // Push a new frame. Note that all expressions have

                                    // been pushed to the front, so they're in the order

                                    // of the definition.

                                    let call_data = &mono_data.expr_data[expr.unique_id_in_definition as usize];

                                    // Push the new frame and reserve its stack size

                                    let new_stack_size = new_frame.max_stack_size;

                                    self.frames.push(new_frame);

                                    self.store.cur_stack_boundary = new_stack_boundary;

                                    // To simplify the logic a little bit we will now

                                    // return and ask our caller to call us again

                                    return Ok(EvalContinuation::Stepping);

                            }

                        },

                        Expression::Variable(expr) => {

                Ok(EvalContinuation::Stepping)

            },

            Statement::Return(_stmt) => {

                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

            },

            Statement::New(stmt) => {

                let call_expr = &heap[stmt.expression];

                debug_assert_eq!(

                    "mismatch in expr stack size and number of arguments for new statement"

                );

                cur_frame.position = stmt.next;

            },

            Statement::Expression(stmt) => {

                // The expression has just been completely evaluated. Some

        let definition_id = definition_id.unwrap();

        let ast_definition = &self.heap[definition_id];

            return Err(ComponentCreationError::DefinitionNotComponent);

        }

        // Make sure that the types of the provided value group matches that of

        // the expected types.

            return Err(ComponentCreationError::DefinitionNotComponent);

        }

        // - check number of arguments by retrieving the one instantiated

        //   monomorph

        let mono_index = self.types.get_procedure_monomorph_type_id(&definition_id, &concrete_type.parts).unwrap();

        let mono_type = self.types.get_procedure_monomorph(mono_index);

        if mono_type.arg_types.len() != arguments.values.len() {

        // By now we're sure that all of the arguments are correct. So create

        // the connector.

    }

    fn lookup_module_root(&self, module_name: &[u8]) -> Option<RootId> {

                types: &mut self.type_table,

                arch: &self.arch,

            };

        }

        // Write out desired information

}

// Note: args and return type need to be a function because we need to know the function ID.

    p: &mut Parser, func_name: &str, polymorphic: &[&str], arg_and_return_fn: T

) {

    let mut poly_vars = Vec::with_capacity(polymorphic.len());

    }

    let func_ident_ref = p.string_pool.intern(func_name.as_bytes());

        this,

        defined_in: RootId::new_invalid(),

        builtin: true,

        span: InputSpan::new(),

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

        poly_vars,

        parameters: Vec::new(),

        scope: ScopeId::new_invalid(),

        body: BlockStatementId::new_invalid(),

        num_expressions_in_body: -1,

    });

    let mut parameters = Vec::with_capacity(arguments.len());

    for (arg_name, arg_type) in arguments {

        parameters.push(param_id);

    }

    func.parameters = parameters;

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

        name: func_ident_ref,

            identifier_span: InputSpan::new(),

            imported_at: None,

            class: DefinitionClass::Function,

        })

    }).unwrap();

}

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

        // Assign everything in the preallocated AST node

        function.parameters = parameters;

        function.scope = scope_id;

        function.body = body_id;

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

        // Assign everything in the AST node

        component.parameters = parameters;

        component.scope = scope_id;

        component.body = body_id;

        if let Expression::Call(expression) = expression {

            // Allow both components and functions, as it makes more sense to

            // check their correct use in the validation and linking pass

                call_id = expression.this;

                valid = true;

            }

                                    unique_id_in_definition: -1,

                                }).upcast()

                            },

                                // Check whether it is a builtin function

                                        KW_FUNC_GET => Method::Get,

                                        KW_FUNC_PUT => Method::Put,

                                        KW_FUNC_FIRES => Method::Fires,

                                        KW_FUNC_PRINT => Method::Print,

                                        _ => unreachable!(),

                                    }

                                } else {

                                };

                                // Function call: consume the arguments

                                ctx.heap.alloc_call_expression(|this| CallExpression{

                                    this, func_span, full_span, parser_type, method, arguments,

                                    parent: ExpressionParent::None,

                                    unique_id_in_definition: -1,

                                }).upcast()

    // --- Visiting procedures

        return self.visit_block_stmt(ctx, body_id);

    }

        let total_num_cases = select_stmt.cases.len();

        let mut total_num_ports = 0;

        let end_select_stmt_id = select_stmt.end_select;

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

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

            },

            method,

            arguments,

            parent: ExpressionParent::None,

            unique_id_in_definition: -1,

        });

        },

        method,

        arguments,

        parent: ExpressionParent::None,

        unique_id_in_definition: -1,

    });

        return Ok(())

    }

        let definition = &ctx.heap[id];

        let scope_id = definition.scope;

        self.visit_scope_and_assign_local_ids(ctx, scope_id, 0);