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

        // 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() {

            }

        }

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

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

                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 {