// 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!(),

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

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

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