debug_assert!(monomorph_idx >= 0);

        let def = self.lookup.get(definition_id).unwrap();

        let monomorphs = def.definition.procedure_monomorphs();

        return &monomorphs[monomorph_idx as usize];

    }

    /// 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_index(&mut self, definition_id: &DefinitionId, types: Option<Vec<ConcreteType>>) -> i32 {

        let def = self.lookup.get_mut(definition_id).unwrap();

        if let Some(types) = types {

            // Expecting a polymorphic procedure

            let monos = def.definition.procedure_monomorphs_mut();

            debug_assert!(def.is_polymorph);

            debug_assert!(def.poly_vars.len() == types.len());

            debug_assert!(monos.iter().find(|v| v.poly_args == types).is_none());

            let mono_idx = monos.len();

            monos.push(ProcedureMonomorph{ poly_args: types, expr_data: Vec::new() });

            return mono_idx as i32;

        } else {

            // Expecting a non-polymorphic procedure

            let monos = def.definition.procedure_monomorphs_mut();

            debug_assert!(!def.is_polymorph);

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

            debug_assert!(monos.is_empty());

            monos.push(ProcedureMonomorph{ poly_args: Vec::new(), expr_data: Vec::new() });

            return 0;

        }

    }

    /// Adds a datatype polymorph to the type table. Will not add the

    /// monomorph if it is already present, or if the type's polymorphic

    /// variables are all unused.

    pub(crate) fn add_data_monomorph(

        &mut self, modules: &[Module], ctx: &PassCtx, definition_id: &DefinitionId, concrete_type: ConcreteType

    ) -> Result<i32, ParseError> {

        debug_assert_eq!(*definition_id, get_concrete_type_definition(&concrete_type));

        // Check if the monomorph already exists

        let poly_type = self.lookup.get_mut(definition_id).unwrap();

        if let Some(idx) = poly_type.get_monomorph_index(&concrete_type) {

        }

        // Doesn't exist, so instantiate a monomorph and determine its memory

        // layout.

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

        debug_assert_eq!(self.encountered_types[0].definition_id, definition_id);

        let mono_idx = self.encountered_types[0].monomorph_idx;

        self.lay_out_memory_for_encountered_types(ctx);

    }

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

    // Building base types

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

    /// Builds the base type for an enum. Will not compute byte sizes

    fn build_base_enum_definition(&mut self, modules: &[Module], ctx: &mut PassCtx, definition_id: DefinitionId) -> Result<(), ParseError> {

        debug_assert!(!self.lookup.contains_key(&definition_id), "base enum already built");

        let definition = ctx.heap[definition_id].as_enum();

        let root_id = definition.defined_in;

        // Determine enum variants

        let mut enum_value = -1;

        let mut variants = Vec::with_capacity(definition.variants.len());

        for variant in &definition.variants {

            if enum_value == i64::MAX {

                let source = &modules[definition.defined_in.index as usize].source;

                return Err(ParseError::new_error_str_at_span(

                    source, variant.identifier.span,

                    "this enum variant has an integer value that is too large"

                ));

            }

            enum_value += 1;

            if let EnumVariantValue::Integer(explicit_value) = variant.value {

                enum_value = explicit_value;

            }

            variants.push(EnumVariant{

                identifier: variant.identifier.clone(),

                value: enum_value,

            });

        }

        // Determine tag size

        let mut min_enum_value = 0;

        let mut max_enum_value = 0;

        if !variants.is_empty() {

            min_enum_value = variants[0].value;

            max_enum_value = variants[0].value;

            for variant in variants.iter().skip(1) {

                min_enum_value = min_enum_value.min(variant.value);

                max_enum_value = max_enum_value.max(variant.value);

            }

        }

    /// arguments all have unique names, and the arguments do not conflict with

    /// any symbols defined at the module scope.

    fn check_poly_args_collision(

        modules: &[Module], ctx: &PassCtx, root_id: RootId, poly_args: &[Identifier]

    ) -> Result<(), ParseError> {

        // Make sure polymorphic arguments are unique and none of the

        // identifiers conflict with any imported scopes

        for (arg_idx, poly_arg) in poly_args.iter().enumerate() {

            for other_poly_arg in &poly_args[..arg_idx] {

                if poly_arg == other_poly_arg {

                    let module_source = &modules[root_id.index as usize].source;

                    return Err(ParseError::new_error_str_at_span(

                        module_source, poly_arg.span,

                        "This polymorphic argument is defined more than once"

                    ).with_info_str_at_span(

                        module_source, other_poly_arg.span,

                        "It conflicts with this polymorphic argument"

                    ));

                }

            }

            // Check if identifier conflicts with a symbol defined or imported

            // in the current module

            if let Some(symbol) = ctx.symbols.get_symbol_by_name(SymbolScope::Module(root_id), poly_arg.value.as_bytes()) {

                // We have a conflict

                let module_source = &modules[root_id.index as usize].source;

                let introduction_span = symbol.variant.span_of_introduction(ctx.heap);

                return Err(ParseError::new_error_str_at_span(

                    module_source, poly_arg.span,

                    "This polymorphic argument conflicts with another symbol"

                ).with_info_str_at_span(

                    module_source, introduction_span,

                    "It conflicts due to this symbol"

                ));

            }

        }

        // All arguments are fine

        Ok(())

    }

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

    // Detecting type loops

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

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

        use DefinedTypeVariant as DTV;

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

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

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

        // Push the initial breadcrumb

        let _initial_result = self.push_breadcrumb_for_type_loops(get_concrete_type_definition(&concrete_type), &concrete_type);

        debug_assert_eq!(_initial_result, BreadcrumbResult::PushedBreadcrumb);

        // Enter into the main resolving loop

        while !self.breadcrumbs.is_empty() {

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

            let breadcrumb = self.breadcrumbs.last_mut().unwrap();

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

            // TODO: Misuse of BreadcrumbResult enum?

            let resolve_result = match &poly_type.definition {

                DTV::Enum(_) => {

                    BreadcrumbResult::TypeExists

                },

                DTV::Union(definition) => {

                    let monomorph = &definition.monomorphs[breadcrumb.monomorph_idx];

                    let num_variants = monomorph.variants.len();

                    let mut union_result = BreadcrumbResult::TypeExists;

                    'member_loop: while breadcrumb.next_member < num_variants {

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

                        let num_embedded = mono_variant.embedded.len();

                        while breadcrumb.next_embedded < num_embedded {

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

                            union_result = self.push_breadcrumb_for_type_loops(poly_type.ast_definition, &mono_embedded.concrete_type);

                            if union_result != BreadcrumbResult::TypeExists {

                                // In type loop or new breadcrumb pushed, so

                                // break out of the resolving loop

                                break 'member_loop;

                            }

                            breadcrumb.next_embedded += 1;

                        }

                        breadcrumb.next_embedded = 0;

                        breadcrumb.next_member += 1

                    }

                },

                BreadcrumbResult::PushedBreadcrumb => {

                    // We recurse into the member type, since the breadcrumb is

                    // already pushed we don't take any action here.

                },

                BreadcrumbResult::TypeLoop(first_idx) => {

                    // We're in a type loop. Add the type loop

                    let mut loop_members = Vec::with_capacity(self.breadcrumbs.len() - first_idx);

                    for breadcrumb_idx in first_idx..self.breadcrumbs.len() {

                        let breadcrumb = &mut self.breadcrumbs[breadcrumb_idx];

                        let mut is_union = false;

                        let entry = self.lookup.get_mut(&breadcrumb.definition_id).unwrap();

                        match &mut entry.definition {

                            DTV::Union(definition) => {

                                // Mark the currently processed variant as requiring heap

                                // allocation, then advance the *embedded* type. The loop above

                                // will then take care of advancing it to the next *member*.

                                let monomorph = &mut definition.monomorphs[breadcrumb.monomorph_idx];

                                let variant = &mut monomorph.variants[breadcrumb.next_member];

                                variant.lives_on_heap = true;

                                breadcrumb.next_embedded += 1;

                                is_union = true;

                            },

                            _ => {}, // else: we don't care for now

                        }

                        loop_members.push(TypeLoopEntry{

                            definition_id: breadcrumb.definition_id,

                            monomorph_idx: breadcrumb.monomorph_idx,

                            is_union

                        });

                    }

                    self.type_loops.push(TypeLoop{ members: loop_members });

                }

            }

        }

        // All breadcrumbs have been cleared. So now `type_loops` contains all

        // of the encountered type loops, and `encountered_types` contains a

        // list of all unique monomorphs we encountered.

        // The next step is to figure out if all of the type loops can be

        // broken. A type loop can be broken if at least one union exists in the

        // loop and that union ended up having variants that are not part of

        // a type loop.

        fn type_loop_source_span_and_message<'a>(

        ) -> (&'a InputSource, InputSpan, String) {

            // Note: because we will discover the type loop the *first* time we

            // instantiate a monomorph with the provided polymorphic arguments

            // (not all arguments are actually used in the type). We don't have

            // to care about a second instantiation where certain unused

            // polymorphic arguments are different.

            let monomorph_type = match &defined_type.definition {

                DTV::Union(definition) => &definition.monomorphs[monomorph_idx].concrete_type,

                DTV::Struct(definition) => &definition.monomorphs[monomorph_idx].concrete_type,

                DTV::Enum(_) | DTV::Function(_) | DTV::Component(_) =>

                    unreachable!(), // impossible to have an enum/procedure in a type loop

            };

            let message = if index_in_loop == 0 {

                format!(

                    "encountered an infinitely large type for '{}' (which can be fixed by \

                    introducing a union type that has a variant whose embedded types are \

                    not part of a type loop, or do not have embedded types)",

                    type_name

                )

            } else if index_in_loop == 1 {

                format!("because it depends on the type '{}'", type_name)

            } else {

                format!("which depends on the type '{}'", type_name)

            };

            let ast_root_id = ast_definition.defined_in();

            return (

                &modules[ast_root_id.index as usize].source,

                ast_definition.identifier().span,

                message

            );

        }

        for type_loop in &self.type_loops {

            let mut can_be_broken = false;

            debug_assert!(!type_loop.members.is_empty());

            for entry in &type_loop.members {

                if entry.is_union {

                    let base_type = self.lookup.get(&entry.definition_id).unwrap();

                    let monomorph = &base_type.definition.as_union().monomorphs[entry.monomorph_idx];

                    debug_assert!(!monomorph.variants.is_empty()); // otherwise it couldn't be part of the type loop

                    let has_stack_variant = monomorph.variants.iter().any(|variant| !variant.lives_on_heap);

                    if has_stack_variant {

                        can_be_broken = true;

                    }

                }

            }

            if !can_be_broken {

                // Construct a type loop error

                let first_entry = &type_loop.members[0];

                let first_type = self.lookup.get(&first_entry.definition_id).unwrap();

                let (first_module, first_span, first_message) = type_loop_source_span_and_message(

                );

                let mut parse_error = ParseError::new_error_at_span(first_module, first_span, first_message);

                for member_idx in 1..type_loop.members.len() {

                    let entry = &type_loop.members[member_idx];

                    let entry_type = self.lookup.get(&first_entry.definition_id).unwrap();

                    let (module, span, message) = type_loop_source_span_and_message(

                    );

                    parse_error = parse_error.with_info_at_span(module, span, message);

                }

                return Err(parse_error);

            }

        }

        // If here, then all type loops have been resolved and we can lay out

        // all of the members

        self.type_loops.clear();

        return Ok(());

    }

    // TODO: Pass in definition_type by value?

    fn push_breadcrumb_for_type_loops(&mut self, definition_id: DefinitionId, definition_type: &ConcreteType) -> BreadcrumbResult {

        use DefinedTypeVariant as DTV;

        let mut base_type = self.lookup.get_mut(&definition_id).unwrap();

        if let Some(mono_idx) = base_type.get_monomorph_index(&definition_type) {

            // Monomorph is already known. Check if it is present in the

            // breadcrumbs. If so, then we are in a type loop

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

                if breadcrumb.definition_id == definition_id && breadcrumb.monomorph_idx == mono_idx {

                    return BreadcrumbResult::TypeLoop(breadcrumb_idx);

                }

            }

            return BreadcrumbResult::TypeExists;

        }

        // Type is not yet known, so we need to insert it into the lookup and

        // push a new breadcrumb.

        let mut is_union = false;

        let monomorph_idx = match &mut base_type.definition {

            DTV::Enum(definition) => {

                debug_assert!(definition.monomorphs.is_empty());

                definition.monomorphs.push(EnumMonomorph{

                    concrete_type: definition_type.clone(),

                });

                0

            },

            DTV::Union(definition) => {

                // Create all the variants with their concrete types

                let mut mono_variants = Vec::with_capacity(definition.variants.len());

                for poly_variant in &definition.variants {

                    let mut mono_embedded = Vec::with_capacity(poly_variant.embedded.len());

            }

        }

        // And now, we're actually, properly, done

        self.encountered_types.clear();

    }

    fn get_memory_layout_or_breadcrumb(&self, ctx: &PassCtx, concrete_type: &ConcreteType) -> MemoryLayoutResult {

        use ConcreteTypePart as CTP;

        // Before we do any fancy shenanigans, we need to check if the concrete

        // type actually requires laying out memory.

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

        let (builtin_size, builtin_alignment) = match concrete_type.parts[0] {

            CTP::Void   => (0, 1),

            CTP::Message => ctx.arch.array_size_alignment,

            CTP::Bool   => (1, 1),

            CTP::UInt8  => (1, 1),

            CTP::UInt16 => (2, 2),

            CTP::UInt32 => (4, 4),

            CTP::UInt64 => (8, 8),

            CTP::SInt8  => (1, 1),

            CTP::SInt16 => (2, 2),

            CTP::SInt32 => (4, 4),

            CTP::SInt64 => (8, 8),

            CTP::Character => (4, 4),

            CTP::String => ctx.arch.string_size_alignment,

            CTP::Array => ctx.arch.array_size_alignment,

            CTP::Slice => ctx.arch.array_size_alignment,

            CTP::Input => ctx.arch.port_size_alignment,

            CTP::Output => ctx.arch.port_size_alignment,

            CTP::Instance(definition_id, _) => {

                // Special case where we explicitly return to simplify the

                // return case for the builtins.

                let entry = self.lookup.get(&definition_id).unwrap();

                let monomorph_idx = entry.get_monomorph_index(concrete_type).unwrap();

                if let Some((size, alignment)) = entry.get_monomorph_size_alignment(monomorph_idx) {

                    // Type has been layed out in memory

                    return MemoryLayoutResult::TypeExists(size, alignment);

                } else {

                    return MemoryLayoutResult::PushBreadcrumb(TypeLoopBreadcrumb {

                        definition_id,

                        monomorph_idx,

                        next_member: 0,

                        next_embedded: 0,

                    });

                }

            }

        };

        return MemoryLayoutResult::TypeExists(builtin_size, builtin_alignment);

    }

    /// Returns tag concrete type (always a builtin integer type), the size of

    /// that type in bytes (and implicitly, its alignment)

    fn variant_tag_type_from_values(min_val: i64, max_val: i64) -> (ConcreteType, usize) {

        debug_assert!(min_val <= max_val);

        let (part, size) = if min_val >= 0 {

            // Can be an unsigned integer

            if max_val <= (u8::MAX as i64) {

                (ConcreteTypePart::UInt8, 1)

            } else if max_val <= (u16::MAX as i64) {

                (ConcreteTypePart::UInt16, 2)

            } else if max_val <= (u32::MAX as i64) {

                (ConcreteTypePart::UInt32, 4)

            } else {

                (ConcreteTypePart::UInt64, 8)

            }

        } else {

            // Must be a signed integer

            if min_val >= (i8::MIN as i64) && max_val <= (i8::MAX as i64) {

                (ConcreteTypePart::SInt8, 1)

            } else if min_val >= (i16::MIN as i64) && max_val <= (i16::MAX as i64) {

                (ConcreteTypePart::SInt16, 2)

            } else if min_val >= (i32::MIN as i64) && max_val <= (i32::MAX as i64) {

                (ConcreteTypePart::SInt32, 4)

            } else {

                (ConcreteTypePart::SInt64, 8)

            }

        };

        return (ConcreteType{ parts: vec![part] }, size);

    }

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

    // Small utilities

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

    fn create_polymorphic_variables(variables: &[Identifier]) -> Vec<PolymorphicVariable> {

        let mut result = Vec::with_capacity(variables.len());

        for variable in variables.iter() {

            result.push(PolymorphicVariable{ identifier: variable.clone(), is_in_use: false });

        }