let mut name = String::with_capacity(128);

        let _final_idx = display_part(&self.parts, heap, 0, &mut name);

    fn next(&mut self) -> Option<Self::Item> {

                    if variant.value.is_empty() {

                        self.kv(indent4).with_s_key("Value").with_s_val("None");

                    } else {

                        self.kv(indent4).with_s_key("Values");

                        for embedded in &variant.value {

                            self.kv(indent4+1).with_s_key("Value")

                                .with_custom_val(|v| write_parser_type(v, heap, embedded));

                    types_section.into_vec()

                    types_section.forget()

 * We will insert these pointers into the variants of unions. However note that

 * we can only compute the stack size of a union until we've looked at *all*

 * variants. Hence we perform an initial pass where we detect type loops, a

 * second pass where we compute the stack sizes of everything, and a third pass

 * where we actually compute the size of the heap allocations for unions.

 *

    /// Returns the number of monomorphs that are instantiated. Remember that

    /// during the type loop detection, and the memory layout phase we will

    /// pre-allocate monomorphs which are not yet fully laid out in memory.

    pub(crate) fn num_monomorphs(&self) -> usize {

        match &self.definition {

            DTV::Function(_) | DTV::Component(_) => unreachable!(),

    /// phantom types). If the type is not polymorphic and its memory has been

    /// layed out, then this will always return `Some(0)`.

                let b_section = b_iter.next().unwrap();

                assert_eq!(num_poly_args as usize, self.poly_vars.len());

    /// Retrieves size and alignment of the particular type's monomorph if it

    /// has been layed out in memory.

    pub(crate) fn get_monomorph_size_alignment(&self, idx: usize) -> Option<(usize, usize)> {

        let (size, alignment) = match &self.definition {

                (monomorph.stack_size, monomorph.stack_alignment)

                unreachable!("retrieving size and alignment of procedure type");

        };

        if size == 0 && alignment == 0 {

            // The "marker" for when the type has not been layed out yet. Even

            // for zero-size types we will set alignment to `1` to simplify

            // alignment calculations.

            return None;

        } else {

            return Some((size, alignment));

enum MemoryLayoutResult {

    TypeExists(usize, usize), // (size, alignment)

    PushBreadcrumb(TypeLoopBreadcrumb),

}

            breadcrumbs: Vec::with_capacity(32),

            type_loops: Vec::with_capacity(8),

            encountered_types: Vec::with_capacity(32),

        let empty_concrete_type = ConcreteType{ parts: Vec::new() };

        for definition_idx in 0..ctx.heap.definitions.len() {

            let definition_id = ctx.heap.definitions.get_id(definition_idx);

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

            // Here we explicitly want to instantiate types which have no

            // polymorphic arguments (even if it has phantom polymorphic

            // arguments) because otherwise the user will see very weird

            // error messages.

            if poly_type.poly_vars.is_empty() && poly_type.num_monomorphs() == 0 {

                self.detect_and_resolve_type_loops_for(

                    modules, ctx,

                    ConcreteType{

                        parts: vec![ConcreteTypePart::Instance(definition_id, 0)]

                    },

                )?;

                self.lay_out_memory_for_encountered_types(ctx);

            }

        }

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

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

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

                        struct_result = self.push_breadcrumb_for_type_loops(poly_type.ast_definition, &mono_field.concrete_type);

                    struct_result

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

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

        self.type_loops.clear();

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

    fn lay_out_memory_for_encountered_types(&mut self, ctx: &PassCtx) {

        use DefinedTypeVariant as DTV;

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

        // types only

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

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

        debug_assert!(!self.encountered_types.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.breadcrumbs.push(TypeLoopBreadcrumb{

            definition_id: first_entry.definition_id,

            monomorph_idx: first_entry.monomorph_idx,

            next_member: 0,

            next_embedded: 0,

        });

        // Enter the main resolving loop

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

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

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

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

            match &mut poly_type.definition {

                DTV::Enum(definition) => {

                    // Size should already be computed

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

                },

                DTV::Union(definition) => {

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

                    // compute the offsets or total type sizes yet.

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

                    let num_variants = mono_type.variants.len();

                    while breadcrumb.next_member < num_variants {

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

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

                            while breadcrumb.next_embedded < num_embedded {

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

                                match self.get_memory_layout_or_breadcrumb(ctx, &mono_embedded.concrete_type) {

                                    MemoryLayoutResult::TypeExists(size, alignment) => {

                                        mono_embedded.size = size;

                                        mono_embedded.alignment = alignment;

                                    },

                                    MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {

                                        self.breadcrumbs.push(new_breadcrumb);

                                        continue 'breadcrumb_loop;

                                    }

                                }

                                breadcrumb.next_embedded += 1;

                            }

                        }

                        breadcrumb.next_member += 1;

                        breadcrumb.next_embedded = 0;

                    }

                    // If here then we can at least compute the stack size of

                    // the type, we'll have to come back at the very end to

                    // fill in the heap size/alignment/offset of each heap-

                    // allocated variant.

                    let mut max_size = definition.tag_size;

                    let mut max_alignment = definition.tag_size;

                    for variant in &mut mono_type.variants {

                        // We're doing stack computations, so always start with

                        // the tag size/alignment.

                        let mut variant_offset = definition.tag_size;

                        let mut variant_alignment = definition.tag_size;

                        if variant.lives_on_heap {

                            // Variant lives on heap, so just a pointer

                            let (ptr_size, ptr_align) = ctx.arch.pointer_size_alignment;

                            align_offset_to(&mut variant_offset, ptr_align);

                            variant_offset += ptr_size;

                            variant_alignment = variant_alignment.max(ptr_align);

                        } else {

                            // Variant lives on stack, so walk all embedded

                            // types.

                            for embedded in &mut variant.embedded {

                                align_offset_to(&mut variant_offset, embedded.alignment);

                                embedded.offset = variant_offset;

                                variant_offset += embedded.size;

                                variant_alignment = variant_alignment.max(embedded.alignment);

                            }

                        };

                        max_size = max_size.max(variant_offset);

                        max_alignment = max_alignment.max(variant_alignment);

                    }

                    mono_type.stack_size = max_size;

                    mono_type.stack_alignment = max_alignment;

                },

                DTV::Struct(definition) => {

                    // Retrieve size and alignment of each struct member. We'll

                    // compute the offsets once all of those are known

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

                    let num_fields = mono_type.fields.len();

                    while breadcrumb.next_member < num_fields {

                        let mono_field = &mut mono_type.fields[breadcrumb.next_member];

                        match self.get_memory_layout_or_breadcrumb(ctx, &mono_field.concrete_type) {

                            MemoryLayoutResult::TypeExists(size, alignment) => {

                                mono_field.size = size;

                                mono_field.alignment = alignment;

                            },

                            MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {

                                self.breadcrumbs.push(new_breadcrumb);

                                continue 'breadcrumb_loop;

                            },

                        }

                        breadcrumb.next_member += 1;

                    }

                    // Compute offsets and size of total type

                    let mut cur_offset = 0;

                    let mut max_alignment = 1;

                    for field in &mut mono_type.fields {

                        align_offset_to(&mut cur_offset, field.alignment);

                        field.offset = cur_offset;

                        cur_offset += field.size;

                        max_alignment = max_alignment.max(field.alignment);

                    }

                    mono_type.size = cur_offset;

                    mono_type.alignment = max_alignment;

                },

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

                    unreachable!();

                }

            }

            // If here, then we completely layed out the current type. So move

            // to the next breadcrumb

            self.breadcrumbs.pop();

        }

        // If here then all types have been layed out. What remains is to

        // compute the sizes/alignment/offsets of the heap variants of the

        // unions we have encountered.

        for entry in &self.encountered_types {

            if !entry.is_union {

                continue;

            }

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

            match &mut poly_type.definition {

                DTV::Union(definition) => {

                    let mono_type = &mut definition.monomorphs[entry.monomorph_idx];

                    let mut max_size = 0;

                    let mut max_alignment = 1;

                    for variant in &mut mono_type.variants {

                        if !variant.lives_on_heap {

                            continue;

                        }

                        let mut variant_offset = 0;

                        let mut variant_alignment = 1;

                        debug_assert!(!variant.embedded.is_empty());

                        for embedded in &mut variant.embedded {

                            match self.get_memory_layout_or_breadcrumb(ctx, &embedded.concrete_type) {

                                MemoryLayoutResult::TypeExists(size, alignment) => {

                                    embedded.size = size;

                                    embedded.alignment = alignment;

                                    align_offset_to(&mut variant_offset, alignment);

                                    embedded.alignment = variant_offset;

                                    variant_offset += size;

                                    variant_alignment = variant_alignment.max(alignment);

                                },

                                _ => unreachable!(),

                            }

                        }

                        // Update heap size/alignment

                        max_size = max_size.max(variant_offset);

                        max_alignment = max_alignment.max(variant_alignment);

                    }

                    if max_size != 0 {

                        // At least one entry lives on the heap

                        mono_type.heap_size = max_size;

                        mono_type.heap_alignment = max_alignment;

                    }

                },

                _ => unreachable!(),

            }

        }

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

    }

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