let (_, layout) = self.current_layout();

            unsafe {

                dealloc(self.base as *mut u8, layout);

            }

        }

    }

#[derive(Debug, Clone)]

pub(crate) struct Frame {

    pub(crate) definition: DefinitionId,

    pub(crate) position: StatementId,

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

    pub(crate) expr_values: VecDeque<Value>, // hack for expression results, evaluated by popping from front/back

impl Frame {

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

        let definition = &heap[definition_id];

        let (outer_scope_id, first_statement_id) = match definition {

            Definition::Component(definition) => (definition.scope, definition.body),

        Frame{

            definition: definition_id,

            position: first_statement_id.upcast(),

            expr_stack: VecDeque::with_capacity(128),

            expr_values: VecDeque::with_capacity(128),

    // Returned only in non-sync mode

    ComponentTerminated,

    SyncBlockStart,

    NewChannel,

}

}

impl Prompt {

        let mut prompt = Self{

            frames: Vec::new(),

            store: Store::new(),

        };

        // Maybe do typechecking in the future?

        let max_stack_size = new_frame.max_stack_size;

        prompt.frames.push(new_frame);

        args.into_store(&mut prompt.store);

                        },

                        Expression::Select(expr) => {

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

                            let field_idx = mono_data.expr_data[expr.unique_id_in_definition as usize].field_or_monomorph_idx as u32;

                            // Note: same as above: clone if value lives on expr stack, simply

                                }

                                Literal::Integer(lit_value) => {

                                    use ConcreteTypePart as CTP;

                                    let concrete_type = &def_types.expr_data[expr.unique_id_in_definition as usize].expr_type;

                                    debug_assert_eq!(concrete_type.parts.len(), 1);

                            cur_frame.expr_values.push_back(value);

                        },

                        Expression::Cast(expr) => {

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

                            // Typechecking reduced this to two cases: either we

                                    }

                                    // Determine the monomorph index of the function we're calling

                                    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;

            Statement::Local(stmt) => {

                match stmt {

                    LocalStatement::Memory(stmt) => {

                            let variable = &heap[stmt.variable];

                            debug_assert!(match self.store.read_ref(ValueId::Stack(variable.unique_id_in_scope as u32)) {

                                Value::Unassigned => false,

                                _ => true,

                            });

                        cur_frame.position = stmt.next;

                        Ok(EvalContinuation::Stepping)

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

                );

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

                // Note that due to expression value evaluation they exist in

                cur_frame.position = stmt.next;

            },

            Statement::Expression(stmt) => {

                // The expression has just been completely evaluated. Some

use crate::protocol::parser::*;

use crate::protocol::type_table::*;

/// A protocol description module

pub struct Module {

    pub(crate) source: InputSource,

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

        //   monomorph

        let concrete_type = ConcreteType{ parts: vec![ConcreteTypePart::Component(definition_id, 0)] };

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

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

            return Err(ComponentCreationError::InvalidNumArguments);

                scope: ScopeId::new_invalid(),

            };

            Some(false_body)

        } else {

            None

    /// Generates a new InferenceType. The two boolean flags will be checked in

    /// debug mode.

    fn new(has_marker: bool, is_done: bool, parts: Vec<InferenceTypePart>) -> Self {

            debug_assert!(!parts.is_empty());

            let parts_body_marker = parts.iter().any(|v| v.is_marker());

            debug_assert_eq!(has_marker, parts_body_marker);

            let parts_done = parts.iter().all(|v| v.is_concrete());

            debug_assert_eq!(is_done, parts_done, "{:?}", parts);

        Self{ has_marker, is_done, parts }

    }

    // the polymorphic arguments to the procedure.

    pub(crate) root_id: RootId,

    pub(crate) definition_id: DefinitionId,

}

pub(crate) type ResolveQueue = Vec<ResolveQueueElement>;

struct InferenceExpression {

    expr_type: InferenceType,       // result type from expression

    expr_id: ExpressionId,          // expression that is evaluated

    extra_data_idx: i32,            // index of extra data needed for inference

}

impl Default for InferenceExpression {

            expr_id: ExpressionId::new_invalid(),

            field_or_monomorph_idx: -1,

            extra_data_idx: -1,

        }

    }

}

/// that all expressions have the appropriate types.

pub(crate) struct PassTyping {

    // Current definition we're typechecking.

    definition_type: DefinitionType,

    poly_vars: Vec<ConcreteType>,

    // Buffers for iteration over various types

impl PassTyping {

    pub(crate) fn new() -> Self {

        PassTyping {

            definition_type: DefinitionType::Function(FunctionDefinitionId::new_invalid()),

            poly_vars: Vec::new(),

            var_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),

            if let Some(first_concrete_part) = first_concrete_part {

                let concrete_type = ConcreteType{ parts: vec![first_concrete_part] };

                queue.push(ResolveQueueElement{

                    root_id,

                    definition_id: *definition_id,

                })

            }

        }

        debug_assert!(self.poly_vars.is_empty());

        // Prepare for visiting the definition

        let proc_base = ctx.types.get_base_definition(&element.definition_id).unwrap();

        if proc_base.is_polymorph {

            for poly_arg in monomorph.concrete_type.embedded_iter(0) {

                self.poly_vars.push(ConcreteType{ parts: Vec::from(poly_arg) });

            }

    }

    fn reset(&mut self) {

        self.definition_type = DefinitionType::Function(FunctionDefinitionId::new_invalid());

        self.poly_vars.clear();

        self.var_types.clear();

                        ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part

                    )?;

                            // Already typechecked, or already put into the resolve queue

                        },

                        None => {

                            // Not typechecked yet, so add an entry in the queue

                            queue.push(ResolveQueueElement {

                                root_id: ctx.heap[definition_id].defined_in(),

                                definition_id,

                            });

                        }

                    }

                    let concrete_type = inference_type_to_concrete_type(

                        ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part

                    )?;

                },

                Expression::Select(_) => {

                    debug_assert!(infer_expr.field_or_monomorph_idx >= 0);

            },

        };

        debug_assert!(target.arg_types.is_empty()); // makes sure we never queue a procedure's type inferencing twice

        debug_assert!(target.expr_data.is_empty());

            infer_expr.expr_type.write_concrete_type(&mut concrete);

            target.expr_data.push(MonomorphExpression{

                expr_type: concrete,

            });

        }

                        Expression::Literal(lit_expr) => {

                            // Only struct, unions, tuples and arrays can

                            // have subexpressions, so we're always fine

                                match lit_expr.value {

                                    Literal::Struct(_) | Literal::Union(_) | Literal::Array(_) | Literal::Tuple(_) => {},

                                    _ => unreachable!(),

                                }

                            true

                        },

use std::fmt::{Formatter, Result as FmtResult};

use std::collections::HashMap;

use crate::protocol::ast::*;

use crate::protocol::parser::symbol_table::SymbolScope;

    // monomorph index for polymorphic function calls or literals. Negative

    // values are never used, but used to catch programming errors.

    pub(crate) field_or_monomorph_idx: i32,

}

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

// Type monomorph storage

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

    Enum, // no extra data

    Struct(StructMonomorph),

    Union(UnionMonomorph),

    Tuple(TupleMonomorph),

}

    fn as_struct_mut(&mut self) -> &mut StructMonomorph {

        match self {

            _ => unreachable!(),

        }

    }

    pub(crate) fn as_union(&self) -> &UnionMonomorph {

        match self {

            _ => unreachable!(),

        }

    }

    fn as_union_mut(&mut self) -> &mut UnionMonomorph {

        match self {

            _ => unreachable!(),

        }

    }

    fn as_tuple_mut(&mut self) -> &mut TupleMonomorph {

        match self {

            _ => unreachable!(),

        }

    }

    fn as_procedure(&self) -> &ProcedureMonomorph {

        match self {

            _ => unreachable!(),

        }

    }

    fn as_procedure_mut(&mut self) -> &mut ProcedureMonomorph {

        match self {

            _ => unreachable!(),

        }

    }

}

pub struct StructMonomorphField {

    pub size: usize,

    pub alignment: usize,

    pub offset: usize,

}

pub struct UnionMonomorphEmbedded {

    // Note that the meaning of the offset (and alignment) depend on whether or

    // not the variant lives on the stack/heap. If it lives on the stack then

    // they refer to the offset from the start of the union value (so the first

}

pub struct TupleMonomorphMember {

    pub size: usize,

    pub alignment: usize,

    pub offset: usize,

}

    }

}

}

        }

    }

        }

    }

}

}

        };

    }

        }

    }

    }

        }

    }

        }

    }

}

impl Hash for MonoSearchKey {

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

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

            let (other_in_use, other_part) = &other.parts[self_index];

            if self_in_use == other_in_use {

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

                    if self_part != other_part {

                        return false;

                    }

                } // else: both not in use, so we don't care

            } else {

                // No agreement on importance of parts. This is practically

                unreachable!();

            }

            other_index += 1;

        }

    }

}

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

// Type table

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

// Programmer note: keep this struct free of dynamically allocated memory

#[derive(Clone)]

struct TypeLoopBreadcrumb {

    next_member: u32,

    next_embedded: u32, // for unions, the index into the variant's embedded types

}

// Programmer note: keep this struct free of dynamically allocated memory

#[derive(Clone)]

struct MemoryBreadcrumb {

    next_member: u32,

    next_embedded: u32,

    first_size_alignment_idx: u32,

// TODO: @Optimize, initial memory-unoptimized implementation

struct TypeLoopEntry {

    is_union: bool,

}

struct TypeLoop {

}

pub struct TypeTable {

    // Lookup from AST DefinitionId to a defined type. Also lookups for

    // concrete type to monomorphs

    // Breadcrumbs left behind while trying to find type loops. Also used to

    // determine sizes of types when all type loops are detected.

    type_loop_breadcrumbs: Vec<TypeLoopBreadcrumb>,

            definition_lookup: HashMap::with_capacity(128),

            mono_type_lookup: HashMap::with_capacity(128),

            mono_types: Vec::with_capacity(128),

            type_loop_breadcrumbs: Vec::with_capacity(32),

            type_loops: Vec::with_capacity(8),

            encountered_types: Vec::with_capacity(32),

        debug_assert!(modules.iter().all(|m| m.phase >= ModuleCompilationPhase::DefinitionsParsed));

        debug_assert!(self.definition_lookup.is_empty());

            for (index, module) in modules.iter().enumerate() {

                debug_assert_eq!(index, module.root_id.index as usize);

            }

        // Use context to guess hashmap size of the base types

        let reserve_size = ctx.heap.definitions.len();

            }

        }

        for module in modules.iter_mut() {

            module.phase = ModuleCompilationPhase::TypesAddedToTable;

        }

        // Go through all types again, lay out all types that are not

        for definition_idx in 0..ctx.heap.definitions.len() {

            let definition_id = ctx.heap.definitions.get_id(definition_idx);

            let poly_type = self.definition_lookup.get(&definition_id).unwrap();

            // If here then the type is a data type without polymorphic

            // variables, but we might have instantiated it already, so:

            let concrete_parts = [ConcreteTypePart::Instance(definition_id, 0)];