[dependencies]

# convenience macros

maplit = "1.0.2"

derive_more = "0.99.2"

# runtime

bincode = "1.3.1"

serde = { version = "1.0.114", features = ["derive"] }

getrandom = "0.1.14" # tiny crate. used to guess controller-id

# network

mio = { version = "0.7.0", package = "mio", features = ["udp", "tcp", "os-poll"] }

socket2 = { version = "0.3.12", optional = true }

# protocol

backtrace = "0.3"

lazy_static = "1.4.0"

# ffi

# socket ffi

libc = { version = "^0.2", optional = true }

os_socketaddr = { version = "0.1.0", optional = true }

rand = "0.8.4"

rand_pcg = "0.3.1"

[lib]

crate-type = [

	"rlib", # for use as a Rust dependency.

]

#[macro_use]

mod macros;

// mod common;

mod protocol;

pub mod runtime;

pub mod runtime2;

mod collections;

pub use protocol::{ProtocolDescription, ProtocolDescriptionBuilder, ComponentCreationError};

                                    if !value.as_bool() {

                                        return Ok(EvalContinuation::BranchInconsistent)

                                    }

                                },

                                Method::Print => {

                                    // Convert the runtime-variant of a string

                                    // into an actual string.

                                    let value = cur_frame.expr_values.pop_front().unwrap();

                                    let value_heap_pos = value.as_string();

                                    let elements = &self.store.heap_regions[value_heap_pos as usize].values;

                                    let mut message = String::with_capacity(elements.len());

                                    for element in elements {

                                        message.push(element.as_char());

                                    }

                                    // Drop the heap-allocated value from the

                                    // store

                                    self.store.drop_heap_pos(value_heap_pos);

                                    println!("{}", message);

                                },

                                Method::SelectStart => {

                                    let num_cases = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let num_ports = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                },

                                Method::SelectRegisterCasePort => {

                                    let case_index = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let port_index = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_uint32();

                                    let port_value = self.store.maybe_read_ref(&cur_frame.expr_values.pop_front().unwrap()).as_port_id();

                                },

                                Method::SelectWait => {

                                    match ctx.performed_select_wait() {

                                        Some(select_index) => {

                                            cur_frame.expr_values.push_back(Value::UInt32(select_index));

                                        },

                                    }

                                },

                                Method::UserComponent => {

                                    // This is actually handled by the evaluation

                                    // of the statement.

                                    debug_assert_eq!(heap[expr.procedure].parameters.len(), cur_frame.expr_values.len());

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

                                },

                                Method::UserFunction => {

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

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

                                    // of the definition.

                                    let num_args = expr.arguments.len();

                                    // Determine stack boundaries

                                    let cur_stack_boundary = self.store.cur_stack_boundary;

                                    let new_stack_boundary = self.store.stack.len();

                                    // Push new boundary and function arguments for new frame

                                    self.store.stack.push(Value::PrevStackBoundary(cur_stack_boundary as isize));

                                    for _ in 0..num_args {

                                        let argument = self.store.read_take_ownership(cur_frame.expr_values.pop_front().unwrap());

                                        self.store.stack.push(argument);

                                    }

                let definition = self.types.get_base_definition(definition_id).unwrap();

                match &definition.definition {

                    DefinedTypeVariant::Enum(definition) => {

                        if let Value::Enum(variant_value) = argument {

                            let is_valid = definition.variants.iter()

                                .any(|v| v.value == *variant_value);

                            return is_valid;

                        }

                    },

                    _ => todo!("implement full type checking on user-supplied arguments"),

                }

                return false;

            },

        }

    }

}

pub trait RunContext {

    fn performed_put(&mut self, port: PortId) -> bool;

    fn performed_get(&mut self, port: PortId) -> Option<ValueGroup>; // None if still waiting on message

    fn fires(&mut self, port: PortId) -> Option<Value>; // None if not yet branched

    fn performed_fork(&mut self) -> Option<bool>; // None if not yet forked

    fn created_channel(&mut self) -> Option<(Value, Value)>; // None if not yet prepared

    fn performed_select_wait(&mut self) -> Option<u32>; // None if not yet notified runtime of select blocker

}

pub struct ProtocolDescriptionBuilder {

    parser: Parser,

}

impl ProtocolDescriptionBuilder {

    pub fn new() -> Self {

        return Self{

            parser: Parser::new(),

        }

    }

    pub fn add(&mut self, filename: String, buffer: Vec<u8>) -> Result<(), ParseError> {

        let input = InputSource::new(filename, buffer);

        self.parser.feed(input)?;

        return Ok(())

    }

    pub fn compile(mut self) -> Result<ProtocolDescription, ParseError> {

        self.parser.parse()?;

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

        let while_stmt = &ctx.heap[id];

        let body_id = while_stmt.body;

        self.current_scope = while_stmt.scope;

        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;

        self.current_scope = sync_stmt.scope;

        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, containing_procedure_id: ProcedureDefinitionId,

            select_id: SelectStatementId, case_index: usize,

            select_var_id: VariableId, select_var_type_id: TypeIdReference

            // Retrieve statement IDs associated with case

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

            let case_guard_id = case.guard;

            let case_body_id = case.body;

            let case_scope_id = case.scope;

            // Create the if-statement for the result of the select statement

            let compare_expr_id = create_ast_equality_comparison_expr(ctx, containing_procedure_id, select_var_id, select_var_type_id, case_index as u64);

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

        }

        // Precreate the block that will end up containing all of the

        // transformed statements. Also precreate the scope associated with it

        let (outer_block_id, outer_end_block_id, outer_scope_id) =

            create_ast_block_stmt(ctx, Vec::new());

        // The "select" and the "end select" statement will act like trampolines

        // that jump to the replacement block. So set the child/parent

        // relationship already.

        // --- for the statements

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

        select_stmt.next = outer_block_id.upcast();

        let end_select_stmt_id = select_stmt.end_select;

        let select_stmt_relative_pos = select_stmt.relative_pos_in_parent;

        let outer_end_block_stmt = &mut ctx.heap[outer_end_block_id];

        outer_end_block_stmt.next = end_select_stmt_id.upcast();

        // --- for the scopes

        link_new_child_to_existing_parent_scope(ctx, &mut self.scope_buffer, self.current_scope, outer_scope_id, select_stmt_relative_pos);

        // Create statements that will create temporary variables for all of the

        // ports passed to the "get" calls in the select case guards.

            let get_call_expr_id = call_id_section[port_var_idx];

            let port_expr_id = expr_id_section[port_var_idx];

            let port_type_index = ctx.heap[port_expr_id].type_index();

            let port_type_ref = TypeIdReference::IndirectSameAsExpr(port_type_index);

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

            let variable_id = create_ast_variable(ctx, outer_scope_id);

            let variable_decl_stmt_id = create_ast_variable_declaration_stmt(ctx, self.current_procedure_id, variable_id, port_type_ref, 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, self.current_procedure_id, variable_id, port_type_ref);

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

        }

        // Insert runtime calls that facilitate the semantics of the select

        // block.

        // Create the call that indicates the start of the select block

        {

            let arguments = vec![

                num_cases_expression_id.upcast(),

                num_ports_expression_id.upcast()

            ];

            let call_expression_id = create_ast_call_expr(ctx, self.current_procedure_id, Method::SelectStart, &mut self.expression_buffer, arguments);

            let call_statement_id = create_ast_expression_stmt(ctx, call_expression_id.upcast());

            transformed_stmts.push(call_statement_id.upcast());

        }

        // Create calls for each select case that will register the ports that

        // we are waiting on at the runtime.

        {

            let mut total_port_index = 0;

            for case_index in 0..total_num_cases {

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

                let case_num_ports = case.involved_ports.len();

                for case_port_index in 0..case_num_ports {

                    // Arguments to runtime call

                    let (port_variable_id, port_variable_type) = locals[total_port_index]; // so far this variable contains the temporary variables for the port expressions

                    let port_variable_expr_id = create_ast_variable_expr(ctx, self.current_procedure_id, port_variable_id, port_variable_type);

                    let runtime_call_arguments = vec![

                        case_index_expr_id.upcast(),

                        port_index_expr_id.upcast(),

                        port_variable_expr_id.upcast()

                    ];

                    // Create runtime call, then store it

                    let runtime_call_expr_id = create_ast_call_expr(ctx, self.current_procedure_id, 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

        let select_variable_id = create_ast_variable(ctx, outer_scope_id);

        let select_variable_type = TypeIdReference::DirectTypeId(ctx.arch.uint32_type_id);

        locals.push((select_variable_id, select_variable_type));

        {

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

            let variable_stmt_id = create_ast_variable_declaration_stmt(ctx, self.current_procedure_id, select_variable_id, select_variable_type, 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 first_end_if_stmt = &mut ctx.heap[end_if_stmt_id];

            first_end_if_stmt.next = outer_end_block_id.upcast();

            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 false_case_scope_id = ctx.heap.alloc_scope(|this| Scope::new(this, ScopeAssociation::If(last_if_stmt_id, false)));

                set_ast_if_statement_false_body(ctx, last_if_stmt_id, last_end_if_stmt_id, IfStatementCase{ body: if_stmt_id.upcast(), scope: false_case_scope_id });

                let end_if_stmt = &mut ctx.heap[end_if_stmt_id];

                end_if_stmt.next = last_end_if_stmt_id.upcast();

                last_if_stmt_id = if_stmt_id;

                last_end_if_stmt_id = end_if_stmt_id;

            }

        }

        // Final steps: set the statements of the replacement block statement,

        let first_stmt_id = transformed_stmts[0];

        let mut last_stmt_id = transformed_stmts[0];

        for stmt_id in transformed_stmts.iter().skip(1).copied() {

            set_ast_statement_next(ctx, last_stmt_id, stmt_id);

            last_stmt_id = stmt_id;

        }

        let outer_block_stmt = &mut ctx.heap[outer_block_id];

        outer_block_stmt.next = first_stmt_id;

        outer_block_stmt.statements = transformed_stmts;

        return Ok(())

    }

}

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

// Utilities to create compiler-generated AST nodes

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

#[derive(Clone, Copy)]

enum TypeIdReference {

    DirectTypeId(TypeId),

    IndirectSameAsExpr(i32), // by type index

}

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

        func_span: InputSpan::new(),

        this,

        full_span: InputSpan::new(),

        parser_type: ParserType{

            elements: Vec::new(),

            full_span: InputSpan::new(),

        },

        method,

        arguments,

        procedure: ProcedureDefinitionId::new_invalid(),

        parent: ExpressionParent::None,

        type_index: call_type_index,

    });

    for argument_index in 0..expression_ids.len() {

        let argument_id = expression_ids[argument_index];

        let argument_expr = &mut ctx.heap[argument_id];

        *argument_expr.parent_mut() = ExpressionParent::Expression(call_expression_id.upcast(), argument_index as u32);

    }

    return call_expression_id;

}

    return ctx.heap.alloc_literal_expression(|this| LiteralExpression{

        this,

        span: InputSpan::new(),

        value: Literal::Integer(LiteralInteger{

            unsigned_value,

            negated: false,

        }),

        parent: ExpressionParent::None,

        type_index: literal_type_index,

    });

}

fn create_ast_equality_comparison_expr(

    ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId,

    variable_id: VariableId, variable_type: TypeIdReference, value: u64

) -> BinaryExpressionId {

    let var_expr_id = create_ast_variable_expr(ctx, containing_procedure_id, variable_id, variable_type);

    let cmp_type_index = add_new_procedure_expression_type(ctx, containing_procedure_id, TypeIdReference::DirectTypeId(ctx.arch.bool_type_id));

    let cmp_expr_id = ctx.heap.alloc_binary_expression(|this| BinaryExpression{

        this,

        operator_span: InputSpan::new(),

        full_span: InputSpan::new(),

        left: var_expr_id.upcast(),

        operation: BinaryOperator::Equality,

        right: int_expr_id.upcast(),

        parent: ExpressionParent::None,

        type_index: cmp_type_index,

    });

    let var_expr = &mut ctx.heap[var_expr_id];

    var_expr.parent = ExpressionParent::Expression(cmp_expr_id.upcast(), 0);

    let int_expr = &mut ctx.heap[int_expr_id];

    int_expr.parent = ExpressionParent::Expression(cmp_expr_id.upcast(), 1);

    return cmp_expr_id;

}

fn create_ast_expression_stmt(ctx: &mut Ctx, expression_id: ExpressionId) -> ExpressionStatementId {

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

        this,

        span: InputSpan::new(),

        expression: expression_id,

        next: StatementId::new_invalid(),

    });

    let expression = &mut ctx.heap[expression_id];

    *expression.parent_mut() = ExpressionParent::ExpressionStmt(statement_id);

    return statement_id;

}

fn create_ast_variable_declaration_stmt(

    ctx: &mut Ctx, containing_procedure_id: ProcedureDefinitionId,

    variable_id: VariableId, variable_type: TypeIdReference, initial_value_expr_id: ExpressionId

) -> MemoryStatementId {

    // Create the assignment expression, assigning the initial value to the variable

    let variable_expr_id = create_ast_variable_expr(ctx, containing_procedure_id, variable_id, variable_type);

    let assignment_expr_id = ctx.heap.alloc_assignment_expression(|this| AssignmentExpression{

        this,

        operator_span: InputSpan::new(),

        full_span: InputSpan::new(),

        left: variable_expr_id.upcast(),

        operation: AssignmentOperator::Set,

        right: initial_value_expr_id,

        parent: ExpressionParent::None,

    });

    // Create the memory statement

    let memory_stmt_id = ctx.heap.alloc_memory_statement(|this| MemoryStatement{

        this,

        span: InputSpan::new(),

        variable: variable_id,

        initial_expr: assignment_expr_id,

        next: StatementId::new_invalid(),

    });

    // 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_block_stmt(ctx: &mut Ctx, statements: Vec<StatementId>) -> (BlockStatementId, EndBlockStatementId, ScopeId) {

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

    add_child_scope_to_parent(ctx, scope_buffer, parent_scope_id, child_scope_id, relative_pos_hint);

}

/// Relinks an existing scope to a new scope as its child. Will also break the

/// link of the child scope's old parent.

fn link_existing_child_to_new_parent_scope(ctx: &mut Ctx, scope_buffer: &mut ScopedBuffer<ScopeId>, new_parent_scope_id: ScopeId, child_scope_id: ScopeId, new_relative_pos_in_parent: i32) {

    let child_scope = &mut ctx.heap[child_scope_id];

    let old_parent_scope_id = child_scope.parent.unwrap();

    child_scope.parent = Some(new_parent_scope_id);

    child_scope.relative_pos_in_parent = new_relative_pos_in_parent;

    // Remove from old parent

    let old_parent = &mut ctx.heap[old_parent_scope_id];

    let scope_index = old_parent.nested.iter()

        .position(|v| *v == child_scope_id)

        .unwrap();

    old_parent.nested.remove(scope_index);

    // Add to new parent

    add_child_scope_to_parent(ctx, scope_buffer, new_parent_scope_id, child_scope_id, new_relative_pos_in_parent);

}

/// Will add a child scope to a parent scope using the relative position hint.

fn add_child_scope_to_parent(ctx: &mut Ctx, scope_buffer: &mut ScopedBuffer<ScopeId>, parent_scope_id: ScopeId, child_scope_id: ScopeId, relative_pos_hint: i32) {

    let mut insert_pos = existing_scope_ids.len();

    for index in 0..existing_scope_ids.len() {

        let existing_scope_id = existing_scope_ids[index];

        let existing_scope = &ctx.heap[existing_scope_id];

        if relative_pos_hint <= existing_scope.relative_pos_in_parent {

            insert_pos = index;

            break;

        }

    }

    existing_scope_ids.forget();

    let parent_scope = &mut ctx.heap[parent_scope_id];

    parent_scope.nested.insert(insert_pos, child_scope_id);

}

fn add_new_procedure_expression_type(ctx: &mut Ctx, procedure_id: ProcedureDefinitionId, type_id: TypeIdReference) -> i32 {

    let procedure = &mut ctx.heap[procedure_id];

    let type_index = procedure.monomorphs[0].expr_info.len();

    match type_id {

        TypeIdReference::DirectTypeId(type_id) => {

            for monomorph in procedure.monomorphs.iter_mut() {

                debug_assert_eq!(monomorph.expr_info.len(), type_index);

                monomorph.expr_info.push(ExpressionInfo{

                    type_id,

                    variant: ExpressionInfoVariant::Generic

                });

            }

        },

        TypeIdReference::IndirectSameAsExpr(source_type_index) => {

            for monomorph in procedure.monomorphs.iter_mut() {

                debug_assert_eq!(monomorph.expr_info.len(), type_index);

                let copied_expr_info = monomorph.expr_info[source_type_index as usize];

                monomorph.expr_info.push(copied_expr_info)

            }

        }

    }

    return type_index as i32;

                    (type_id, monomorph_index)

                };

                ExpressionInfoVariant::Procedure(type_id, monomorph_index)

            } else if let Expression::Select(_expr) = expr {

                ExpressionInfoVariant::Select(infer_node.field_index)

            } else {

                ExpressionInfoVariant::Generic

            };

            infer_node.info_type_id = info_type_id;

            infer_node.info_variant = info_variant;

        }

        // Write the types of the arguments

        let procedure = &ctx.heap[self.procedure_id];

        for parameter_id in procedure.parameters.iter().copied() {

            let mut concrete = ConcreteType::default();

            let var_data = self.var_data.iter().find(|v| v.var_id == parameter_id).unwrap();

            var_data.var_type.write_concrete_type(&mut concrete);

            let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, concrete)?;

            monomorph.argument_types.push(type_id)

        }

        // Determine if we have already assigned type indices to the expressions

        // before (the indices that, for a monomorph, can retrieve the type of

        // the expression).

        let has_type_indices = self.reserved_monomorph_index > 0;

        if has_type_indices {

            // already have indices, so resize and then index into it

            debug_assert!(monomorph.expr_info.is_empty());

            monomorph.expr_info.resize(num_infer_nodes, ExpressionInfo::new_invalid());

            for infer_node in self.infer_nodes.iter() {

                let type_index = ctx.heap[infer_node.expr_id].type_index();

                monomorph.expr_info[type_index as usize] = infer_node.as_expression_info();

            }

        } else {

            // no indices yet, need to be assigned in AST

            for infer_node in self.infer_nodes.iter() {

                let type_index = monomorph.expr_info.len();

                monomorph.expr_info.push(infer_node.as_expression_info());

                *ctx.heap[infer_node.expr_id].type_index_mut() = type_index as i32;

            }

        }

        // Push the information into the AST

        let procedure = &mut ctx.heap[self.procedure_id];

        procedure.monomorphs[self.reserved_monomorph_index as usize] = monomorph;

        }

        return index;

    }

}

impl Hash for MonoSearchKey {

    fn hash<H: Hasher>(&self, state: &mut H) {

        for index in 0..self.parts.len() {

            let (_flags, part) = self.parts[index];

            // if flags & Self::KEY_IN_USE != 0 { @Deduplication

            part.hash(state);

            // }

        }

    }

}

impl PartialEq for MonoSearchKey {

    fn eq(&self, other: &Self) -> bool {

        let mut self_index = 0;

        let mut other_index = 0;

        while self_index < self.parts.len() && other_index < other.parts.len() {

            // Retrieve part and flags

            let self_in_use = true; // (self_bits & Self::KEY_IN_USE) != 0; @Deduplication

            let other_in_use = true; // (other_bits & Self::KEY_IN_USE) != 0; @Deduplication

            // Determine ending indices

            let self_end_index = self.find_end_index(self_index);

            let other_end_index = other.find_end_index(other_index);

            if self_in_use == other_in_use {

                if self_in_use {

                    // Both are in use, so both parts should be equal

                    let delta_self = self_end_index - self_index;

                    let delta_other = other_end_index - other_index;

                    if delta_self != delta_other {

                        // Both in use, but not of equal length, so the types

                        // cannot match

                        return false;

                    }

                    for _ in 0..delta_self {

                        let (_, self_part) = self.parts[self_index];

                        let (_, other_part) = other.parts[other_index];

                        if self_part != other_part {

                            return false;

                // Insert the entry for the builtin type, we should be able to

                // immediately "steal" the size from the preinserted builtins.

                let base_type_id = match &concrete_type.parts[0] {

                    CTP::Void => arch.void_type_id,

                    CTP::Message => arch.message_type_id,

                    CTP::Bool => arch.bool_type_id,

                    CTP::UInt8 => arch.uint8_type_id,

                    CTP::UInt16 => arch.uint16_type_id,

                    CTP::UInt32 => arch.uint32_type_id,

                    CTP::UInt64 => arch.uint64_type_id,

                    CTP::SInt8 => arch.sint8_type_id,

                    CTP::SInt16 => arch.sint16_type_id,

                    CTP::SInt32 => arch.sint32_type_id,

                    CTP::SInt64 => arch.sint64_type_id,

                    CTP::Character => arch.char_type_id,

                    CTP::String => arch.string_type_id,

                    CTP::Array => arch.array_type_id,

                    CTP::Slice => arch.slice_type_id,

                    CTP::Input => arch.input_type_id,

                    CTP::Output => arch.output_type_id,

                    CTP::Pointer => arch.pointer_type_id,

                    _ => unreachable!(),

                };

                let base_type = &self.mono_types[base_type_id.0 as usize];

                let type_id = TypeId(self.mono_types.len() as i64);

                Self::set_search_key_to_type(&mut self.mono_search_key, &self.definition_lookup, &concrete_type.parts);

                self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);

                self.mono_types.push(MonoType{

                    type_id,

                    concrete_type,

                    variant: MonoTypeVariant::Builtin

                });

                type_id

            },

            // User-defined types

            CTP::Tuple(num_embedded) => {

                debug_assert!(definition_id.is_invalid()); // because tuples do not have an associated `DefinitionId`

                let mut members = Vec::with_capacity(*num_embedded as usize);

                for section in ConcreteTypeIter::new(&concrete_type.parts, 0) {

                    members.push(TupleMonomorphMember{

                        type_id: TypeId::new_invalid(),

                        concrete_type: ConcreteType{ parts: Vec::from(section) },

                        size: 0,

                        alignment: 0,

                        offset: 0

                    });

                }

                let type_id = TypeId(self.mono_types.len() as i64);

                Self::set_search_key_to_tuple(&mut self.mono_search_key, &self.definition_lookup, &concrete_type.parts);

                self.mono_type_lookup.insert(self.mono_search_key.clone(), type_id);

                self.mono_types.push(MonoType::new_empty(type_id, concrete_type, MonoTypeVariant::Tuple(TupleMonomorph{ members })));

            for expr_id in &stmt.expressions {

                if let Some(id) = seek_expr_in_expr(heap, *expr_id, f) {

                    return Some(id);

                }

            }

            None

        },

        Statement::New(stmt) => {

            seek_expr_in_expr(heap, stmt.expression.upcast(), f)

        },

        Statement::Expression(stmt) => {

            seek_expr_in_expr(heap, stmt.expression, f)

        },

        _ => None

    }

}

struct FakeRunContext{}

impl RunContext for FakeRunContext {

    fn performed_put(&mut self, _port: PortId) -> bool { unreachable!() }

    fn performed_get(&mut self, _port: PortId) -> Option<ValueGroup> { unreachable!() }

    fn fires(&mut self, _port: PortId) -> Option<Value> { unreachable!() }

    fn performed_fork(&mut self) -> Option<bool> { unreachable!() }

    fn created_channel(&mut self) -> Option<(Value, Value)> { unreachable!() }

    fn performed_select_wait(&mut self) -> Option<u32> { unreachable!() }

}