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

                ));

            }

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

                            _ => {}, // 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() {

            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