fn display_empty_string_ref() {

        // Makes sure that null pointer inside StringRef will not cause issues

        let v = StringRef::new_empty();

    }

    #[test]

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

}

pub enum Definition {

    Struct(StructDefinition),

    Enum(EnumDefinition),

/// Monomorphed instantiation of a procedure (or the sole instantiation of a

/// non-polymorphic procedure).

pub struct ProcedureDefinitionMonomorph {

    pub argument_types: Vec<TypeId>,

    pub expr_info: Vec<ExpressionInfo>

    }

}

pub struct ExpressionInfo {

    pub type_id: TypeId,

    pub variant: ExpressionInfoVariant,

    }

}

pub enum ExpressionInfoVariant {

    Generic,

    Procedure(TypeId, u32), // procedure TypeID and its monomorph index

/// components.

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

pub struct ProcedureDefinition {

    pub this: ProcedureDefinitionId,

    pub defined_in: RootId,

    pub body: BlockStatementId,

    // Monomorphization of typed procedures

    pub monomorphs: Vec<ProcedureDefinitionMonomorph>,

}

impl ProcedureDefinition {

            scope: ScopeId::new_invalid(),

            body: BlockStatementId::new_invalid(),

            monomorphs: Vec::new(),

        }

    }

}

impl Frame {

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

        let definition = &heap[definition_id];

        let outer_scope_id = definition.scope;

        let first_statement_id = definition.body;

        Frame{

            definition: definition_id,

            monomorph_type_id,

            position: first_statement_id.upcast(),

            expr_stack: VecDeque::with_capacity(128),

            expr_values: VecDeque::with_capacity(128),

}

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

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

                                    let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];

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

                );

                let mono_data = &heap[cur_frame.definition].monomorphs[cur_frame.monomorph_index];

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

                // reverse order on the stack.

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

        //   monomorph

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

            return Err(ComponentCreationError::InvalidNumArguments);

        }

        // - for each argument try to make sure the types match

        for arg_idx in 0..arguments.values.len() {

            let provided_value = &arguments.values[arg_idx];

            if !self.verify_same_type(expected_type, 0, &arguments, provided_value) {

                return Err(ComponentCreationError::InvalidArgumentType(arg_idx));

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

            };

        };

        while !queue.is_empty() {

            let top = queue.pop().unwrap();

        &[]

    };

}

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

fn insert_builtin_function<T: Fn(ProcedureDefinitionId) -> (Vec<(&'static str, ParserType)>, ParserType)> (

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

) {

    for poly_var in polymorphic {

    }

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

        kind: ProcedureKind::Function,

        span: InputSpan::new(),

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

        return_type: None,

        parameters: Vec::new(),

        scope: ScopeId::new_invalid(),

        body: BlockStatementId::new_invalid(),

    });

    let (arguments, return_type) = arg_and_return_fn(procedure_id);

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

    func.parameters = parameters;

    func.return_type = Some(return_type);

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

        name: func_ident_ref,

        variant: SymbolVariant::Definition(SymbolDefinition{

            definition_id: procedure_id.upcast(),

        })

    }).unwrap();

}

    }

}

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

// Utilities to create compiler-generated AST nodes

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

    stmt_buffer: ScopedBuffer<StatementId>,

    bool_buffer: ScopedBuffer<bool>,

    index_buffer: ScopedBuffer<usize>,

    poly_progress_buffer: ScopedBuffer<u32>,

    // Mapping from parser type to inferred type. We attempt to continue to

    // specify these types until we're stuck or we've fully determined the type.

            stmt_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_LARGE),

            bool_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

            index_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

            poly_progress_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

            infer_nodes: Vec::with_capacity(BUFFER_INIT_CAP_LARGE),

            poly_data: Vec::with_capacity(BUFFER_INIT_CAP_SMALL),

        }

    }

        debug_assert_eq!(ctx.module().phase, ModuleCompilationPhase::ValidatedAndLinked);

        let root_id = ctx.module().root_id;

        let root = &ctx.heap.protocol_descriptions[root_id];

            let first_concrete_part_and_procedure_id = match definition {

                Definition::Procedure(definition) => {

                procedure.monomorphs.push(ProcedureDefinitionMonomorph::new_invalid());

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

                queue.push(ResolveQueueElement{

                    root_id,

                    reserved_type_id: type_id,

                    reserved_monomorph_index: monomorph_index,

                })

            }

        }

    }

    pub(crate) fn handle_module_definition(

        // expression information to the AST. If this is the first time we're

        // visiting this procedure then we assign expression indices as well.

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

        let mut monomorph = ProcedureDefinitionMonomorph{

            argument_types: Vec::with_capacity(procedure.parameters.len()),

            expr_info: Vec::with_capacity(num_infer_nodes),

        for infer_node in self.infer_nodes.iter_mut() {

            // Determine type ID

            let expr = &ctx.heap[infer_node.expr_id];

            // TODO: Maybe optimize? Split insertion up into lookup, then clone

            //  if needed?

            let info_variant = if let Expression::Call(expr) = expr {

                // Construct full function type. If not yet typechecked then

                // queue it for typechecking.

                debug_assert!(expr.method.is_user_defined() || expr.method.is_public_builtin());

                let num_poly_vars = poly_data.poly_vars.len() as u32;

                let first_part = match expr.method {

                };

                let signature_type = poly_data_type_to_concrete_type(

                    ctx, infer_node.expr_id, &poly_data.poly_vars, first_part

                )?;

                    (type_id, monomorph_index)

                } else {

                    // Procedure is not yet typechecked, reserve a TypeID and a monomorph index

                    let monomorph_index = procedure_to_check.monomorphs.len() as u32;

                    procedure_to_check.monomorphs.push(ProcedureDefinitionMonomorph::new_invalid());

                    let type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, signature_type, monomorph_index);

                };

                ExpressionInfoVariant::Procedure(type_id, monomorph_index)

                ExpressionInfoVariant::Select(infer_node.field_index)

            } else {

                ExpressionInfoVariant::Generic

        }

        // Write the types of the arguments

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

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

        if has_type_indices {

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

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

        let someone_is_str = expr_is_str || arg1_is_str || arg2_is_str;

        let someone_is_not_str = expr_is_not_str || arg1_is_not_str || arg2_is_not_str;

        // Note: this statement is an expression returning the progression bools

        let (node_progress, arg1_progress, arg2_progress) = if someone_is_str {

            // One of the arguments is a string, then all must be strings

        // Same as array indexing: result depends on whether subject is string

        // or array

        let (is_string, is_not_string) = self.type_is_certainly_or_certainly_not_string(node_index);

        let (node_progress, subject_progress) = if is_string {

            // Certainly a string

            (

    /// not a string (false, true), or still unknown (false, false).

    fn type_is_certainly_or_certainly_not_string(&self, node_index: InferNodeIndex) -> (bool, bool) {

        let expr_type = &self.infer_nodes[node_index].expr_type;

        let mut part_index = 0;

        while part_index < expr_type.parts.len() {

            let part = &expr_type.parts[part_index];

            proc_kind: ProcedureKind::Function,

            must_be_assignable: None,

            relative_pos_in_parent: 0,

            control_flow_stmts: Vec::with_capacity(BUFFER_INIT_CAP_SMALL),

            variable_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

            definition_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

        self.expr_parent = ExpressionParent::None;

        self.must_be_assignable = None;

        self.relative_pos_in_parent = 0;

        self.control_flow_stmts.clear();

    }

}

        self.visit_block_stmt(ctx, body_id)?;

        self.pop_scope(old_scope);

        self.resolve_pending_control_flow_targets(ctx)?;

        Ok(())

        let right_expr_id = assignment_expr.right;

        let old_expr_parent = self.expr_parent;

        assignment_expr.parent = old_expr_parent;

        self.expr_parent = ExpressionParent::Expression(upcast_id, 0);

        self.must_be_assignable = Some(assignment_expr.operator_span);

/// stores the expression type data from the typechecking/inferencing pass.

pub struct ProcedureMonomorph {

    pub monomorph_index: u32,

}

/// Tuple monomorph. Again a kind of exception because one cannot define a named

// Type table

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

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

#[derive(Clone)]

struct TypeLoopBreadcrumb {

            let type_id = self.mono_type_lookup.get(&self.mono_search_key);

            if type_id.is_none() {

                self.detect_and_resolve_type_loops_for(

                    ConcreteType{

                        parts: vec![ConcreteTypePart::Instance(definition_id, 0)]

                    },

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

        self.mono_types.push(MonoType::new_empty(type_id, concrete_type, MonoTypeVariant::Procedure(ProcedureMonomorph{

            monomorph_index,

        })));

        return type_id;

    /// Adds a builtin type to the type table. As this is only called by the

    /// compiler during setup we assume it cannot fail.

        self.mono_search_key.set(&concrete_type.parts, poly_vars);

        debug_assert!(!self.mono_type_lookup.contains_key(&self.mono_search_key));

        debug_assert_ne!(alignment, 0);

        return type_id;

    }

    /// Adds a monomorphed type to the type table. If it already exists then the

    /// previous entry will be used.

    pub(crate) fn add_monomorphed_type(

        &mut self, modules: &[Module], heap: &Heap, arch: &TargetArch, concrete_type: ConcreteType

    ) -> Result<TypeId, ParseError> {

        // Check if the concrete type was already added

        if let Some(type_id) = self.mono_type_lookup.get(&self.mono_search_key) {

            return Ok(*type_id);

        }

        // Concrete type needs to be added

        let type_id = self.encountered_types[0].type_id;

        self.lay_out_memory_for_encountered_types(arch);

    /// Internal function that will detect type loops and check if they're

    /// resolvable. If so then the appropriate union variants will be marked as

    /// "living on heap". If not then a `ParseError` will be returned

        // Programmer notes: what happens here is the we call

        // `check_member_for_type_loops` for a particular type's member, and

        // then take action using the return value:

            &self.type_loop_breadcrumbs, &self.definition_lookup, &self.mono_type_lookup,

            &mut self.mono_search_key, &concrete_type

        );

        if let TypeLoopResult::PushBreadcrumb(definition_id, concrete_type) = initial_breadcrumb {

        } else {

        // Enter into the main resolving loop

        while !self.type_loop_breadcrumbs.is_empty() {

                TypeLoopResult::PushBreadcrumb(definition_id, concrete_type) => {

                    // We recurse into the member type.

                    self.type_loop_breadcrumbs[breadcrumb_idx] = breadcrumb;

                },

                TypeLoopResult::TypeLoop(first_idx) => {

                    // Because we will be modifying breadcrumbs within the

        // (i.e. either already has its memory layed out, or is part of a type

        // loop because we've already visited the type)

        debug_assert!(!concrete_type.parts.is_empty());

        };

            for (breadcrumb_idx, breadcrumb) in breadcrumbs.iter().enumerate() {

                if breadcrumb.type_id == type_id {

                    return TypeLoopResult::TypeLoop(breadcrumb_idx);

    /// Handles the `PushBreadcrumb` result for a `check_member_for_type_loops`

    /// call. Will preallocate entries in the monomorphed type storage (with

    /// all memory properties zeroed).

        use DefinedTypeVariant as DTV;

        use ConcreteTypePart as CTP;

        let mut is_union = false;

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

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

                type_id

            },

        };

        self.encountered_types.push(TypeLoopEntry{ type_id, is_union });

        // optimization, we're working around borrowing rules here.

        // Just finished type loop detection, so we're left with the encountered

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

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

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

        }

    }

        match type_parts[0] {

                Self::set_search_key_to_tuple(search_key, definition_map, type_parts);

            },

                let definition_type = definition_map.get(&definition_id).unwrap();

                search_key.set(type_parts, &definition_type.poly_vars);

            },

                todo!("implement function pointers")

            },

        }

    }

        let mono_proc = get_procedure_monomorph(&self.ctx.heap, &self.ctx.types, self.definition_id);

        let mono_index = mono_proc.monomorph_index;

        let mono_data = &self.ctx.heap[self.definition_id].as_procedure().monomorphs[mono_index as usize];

        let concrete_type = &self.ctx.types.get_monomorph(expr_info.type_id).concrete_type;

        // Serialize and check type

    };

    let mono_index = types.get_procedure_monomorph_type_id(&definition_id, &func_type).unwrap();

    mono_data

}

                            } else {

                                // Must destroy

                                let stored_index = new_value as usize % stored.len();

                                store.destroy(el_index);

                            }

                        }

    ").expect("compilation");

    let rt = Runtime::new(1, true, pd);

        create_component(&rt, "", "nothing_at_all", no_args());

    }

}