pub struct FunctionArgument {

    identifier: Identifier,

    parser_type: ParserType,

}

/// Represents the data associated with a single expression after type inference

/// for a monomorph (or just the normal expression types, if dealing with a

/// non-polymorphic function/component).

pub struct MonomorphExpression {

    // The output type of the expression. Note that for a function it is not the

    // function's signature but its return type

    pub(crate) expr_type: ConcreteType,

    // Has multiple meanings: the field index for select expressions, the

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

    pub(crate) type_id: TypeId,

}

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

// Type monomorph storage

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

pub(crate) enum MonoTypeVariant {

    Enum, // no extra data

    Struct(StructMonomorph),

    Union(UnionMonomorph),

    Procedure(ProcedureMonomorph), // functions, components

    Tuple(TupleMonomorph),

}

impl MonoTypeVariant {

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

        match self {

            MonoTypeVariant::Struct(v) => v,

            _ => unreachable!(),

        }

    }

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

        match self {

            MonoTypeVariant::Union(v) => v,

            _ => unreachable!(),

        }

    }

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

        match self {

        let mono_type = &self.mono_types[type_id.0 as usize];

        return mono_type.variant.as_procedure();

    }

    /// Reserves space for a monomorph of a polymorphic procedure. The index

    /// will point into a (reserved) slot of the array of expression types. The

    /// monomorph may NOT exist yet (because the reservation implies that we're

    /// going to be performing typechecking on it, and we don't want to

    /// check the same monomorph twice)

    pub(crate) fn reserve_procedure_monomorph_type_id(&mut self, definition_id: &DefinitionId, concrete_type: ConcreteType) -> TypeId {

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

        let base_type = self.definition_lookup.get_mut(definition_id).unwrap();

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

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

        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{

            arg_types: Vec::new(),

            expr_data: Vec::new(),

        })));

        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,

        definition_id: DefinitionId, concrete_type: ConcreteType

    ) -> Result<TypeId, ParseError> {

        debug_assert_eq!(definition_id, get_concrete_type_definition(&concrete_type.parts).unwrap());

        // Check if the concrete type was already added

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

        let poly_var_in_use = &definition.poly_vars;

        self.mono_search_key.set(&concrete_type.parts, poly_var_in_use.as_slice());

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

            return Ok(*type_id);

        }

        // Concrete type needs to be added

        self.detect_and_resolve_type_loops_for(modules, heap, concrete_type)?;

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

        self.lay_out_memory_for_encountered_types(arch);

        return Ok(type_id);

    }

        // are then used by `lay_out_memory_for_encountered_types`.

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

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

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

        // Push the initial breadcrumb

        let initial_breadcrumb = Self::check_member_for_type_loops(

            &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 {

            self.handle_new_breadcrumb_for_type_loops(definition_id, concrete_type);

        } else {

            unreachable!();

        }

        // Enter into the main resolving loop

        while !self.type_loop_breadcrumbs.is_empty() {

            // Because we might be modifying the breadcrumb array we need to

            let breadcrumb_idx = self.type_loop_breadcrumbs.len() - 1;

            let mut breadcrumb = self.type_loop_breadcrumbs[breadcrumb_idx].clone();

            let mono_type = &self.mono_types[breadcrumb.type_id.0 as usize];

            let resolve_result = match &mono_type.variant {

                MonoTypeVariant::Enum => {

                    TypeLoopResult::TypeExists

                },

                MonoTypeVariant::Union(monomorph) => {

                    let num_variants = monomorph.variants.len() as u32;

                    let mut union_result = TypeLoopResult::TypeExists;

                    'member_loop: while breadcrumb.next_member < num_variants {

                        let mono_variant = &monomorph.variants[breadcrumb.next_member as usize];

                        let num_embedded = mono_variant.embedded.len() as u32;

                        while breadcrumb.next_embedded < num_embedded {

                            let mono_embedded = &mono_variant.embedded[breadcrumb.next_embedded as usize];

                            union_result = Self::check_member_for_type_loops(

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

                                &mut self.mono_search_key, &mono_embedded.concrete_type

                            );

                            if union_result != TypeLoopResult::TypeExists {

                                // In type loop or new breadcrumb pushed, so

                                // break out of the resolving loop

                                break 'member_loop;

                            }

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

        // types only

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

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

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

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

        // Push the first entry (the type we originally started with when we

        // were detecting type loops)

        let first_entry = &self.encountered_types[0];

        self.memory_layout_breadcrumbs.push(MemoryBreadcrumb{

            type_id: first_entry.type_id,

            next_member: 0,

            next_embedded: 0,

            first_size_alignment_idx: 0,

        });

        // Enter the main resolving loop

        'breadcrumb_loop: while !self.memory_layout_breadcrumbs.is_empty() {

            let cur_breadcrumb_idx = self.memory_layout_breadcrumbs.len() - 1;

            let mut breadcrumb = self.memory_layout_breadcrumbs[cur_breadcrumb_idx].clone();

            let mono_type = &self.mono_types[breadcrumb.type_id.0 as usize];

            match &mono_type.variant {

                    // Size should already be computed

                    dbg_code!({

                        let mono_type = &self.mono_types[breadcrumb.type_id.0 as usize];

                        debug_assert!(mono_type.size != 0 && mono_type.alignment != 0);

                    });

                },

                MonoTypeVariant::Union(mono_type) => {

                    // Retrieve size/alignment of each embedded type. We do not

                    // compute the offsets or total type sizes yet.

                    let num_variants = mono_type.variants.len() as u32;

                    while breadcrumb.next_member < num_variants {

                        let mono_variant = &mono_type.variants[breadcrumb.next_member as usize];

                        if mono_variant.lives_on_heap {

                            // To prevent type loops we made this a heap-

                            // allocated variant. This implies we cannot

                            // compute sizes of members at this point.

                        } else {

                            let num_embedded = mono_variant.embedded.len() as u32;

                            while breadcrumb.next_embedded < num_embedded {

                                let mono_embedded = &mono_variant.embedded[breadcrumb.next_embedded as usize];

                                let layout_result = Self::get_memory_layout_or_breadcrumb(

                                    &self.definition_lookup, &self.mono_type_lookup, &self.mono_types,

                                    &mut self.mono_search_key, arch, &mono_embedded.concrete_type.parts,