// Builtin types without nested types

    Message,

    Bool,

    UInt8, UInt16, UInt32, UInt64,

    SInt8, SInt16, SInt32, SInt64,

    Character, String,

    // Builtin types with one nested type

    Array,

    Slice,

    Input,

    Output,

    // User defined type with any number of nested types

}

impl ConcreteTypePart {

    fn num_embedded(&self) -> u32 {

        use ConcreteTypePart::*;

        match self {

            Void | Message | Bool |

            UInt8 | UInt16 | UInt32 | UInt64 |

            SInt8 | SInt16 | SInt32 | SInt64 |

            Character | String =>

                0,

            Array | Slice | Input | Output =>

                1,

        }

    }

}

#[derive(Debug, Clone, Eq, PartialEq)]

pub struct ConcreteType {

    pub(crate) parts: Vec<ConcreteTypePart>

}

impl Default for ConcreteType {

    fn default() -> Self {

        Self{ parts: Vec::new() }

                CTP::Input => {

                    target.push_str(KW_TYPE_IN_PORT_STR);

                    target.push('<');

                    idx = display_part(parts, heap, idx, target);

                    target.push('>');

                },

                CTP::Output => {

                    target.push_str(KW_TYPE_OUT_PORT_STR);

                    target.push('<');

                    idx = display_part(parts, heap, idx, target);

                    target.push('>');

                },

                    let definition = &heap[definition_id];

                    target.push_str(definition.identifier().value.as_str());

                    if num_poly_args != 0 {

                        target.push('<');

                        for poly_arg_idx in 0..num_poly_args {

                            if poly_arg_idx != 0 {

                                target.push(',');

                                idx = display_part(parts, heap, idx, target);

                            }

                        }

                        target.push('>');

                    |source, iter, ctx| {

                        let poly_vars = ctx.heap[definition_id].poly_vars();

                        consume_parser_type(

                            source, iter, &ctx.symbols, &ctx.heap, poly_vars,

                            module_scope, definition_id, false, 0

                        )

                    },

                    &mut types_section, "an embedded type", Some(&mut close_pos)

                )?;

                let value = if has_embedded {

                    types_section.into_vec()

                } else {

                };

                Ok(UnionVariantDefinition{

                    span: InputSpan::from_positions(identifier.span.begin, close_pos),

                    identifier,

                    value

                })

            },

            &mut variants_section, "a union variant", "a list of union variants", None

        )?;

        // Transfer to AST

        expr_type.display_name(&ctx.heap)

    }

    fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> {

        // Keep inferring until we can no longer make any progress

        while !self.expr_queued.is_empty() {

            let next_expr_idx = self.expr_queued.pop_front().unwrap();

            self.progress_expr(ctx, next_expr_idx)?;

        }

        // Helper for transferring polymorphic variables to concrete types and

        // checking if they're completely specified

            for (poly_idx, poly_type) in inference.iter().enumerate() {

                if !poly_type.is_done {

                    let expr = &ctx.heap[expr_id];

                    let definition = match expr {

                        Expression::Call(expr) => expr.definition,

                        Expression::Literal(expr) => match &expr.value {

                            Literal::Enum(lit) => lit.definition,

                            Literal::Union(lit) => lit.definition,

                            Literal::Struct(lit) => lit.definition,

                            _ => unreachable!()

                        },

                        _ => unreachable!(),

                    };

                    let poly_vars = ctx.heap[definition].poly_vars();

                    return Err(ParseError::new_error_at_span(

                        &ctx.module.source, expr.operation_span(), format!(

                            "could not fully infer the type of polymorphic variable '{}' of this expression (got '{}')",

                            poly_vars[poly_idx].value.as_str(), poly_type.display_name(&ctx.heap)

                        )

                    ));

                }

                let mut concrete_type = ConcreteType::default();

                poly_type.write_concrete_type(&mut concrete_type);

            }

        }

        // Inference is now done. But we may still have uninferred types. So we

        // check for these.

        for (infer_expr_idx, infer_expr) in self.expr_types.iter_mut().enumerate() {

            let expr_type = &mut infer_expr.expr_type;

            if !expr_type.is_done {

                // Auto-infer numberlike/integerlike types to a regular int

                if expr_type.parts.len() == 1 && expr_type.parts[0] == InferenceTypePart::IntegerLike {

                    expr_type.parts[0] = InferenceTypePart::SInt32;

                    self.expr_queued.push_back(infer_expr_idx as i32);

                } else {

            if infer_expr.extra_data_idx < 0 { continue; }

            // Extra data is attached, perform typechecking and transfer

            // resolved information to the expression

            let extra_data = &self.extra_data[infer_expr.extra_data_idx as usize];

            if extra_data.poly_vars.is_empty() { continue; }

            // Note that only call and literal expressions need full inference.

            // Select expressions also use `extra_data`, but only for temporary

            // storage of the struct type whose field it is selecting.

            match &ctx.heap[extra_data.expr_id] {

                Expression::Call(expr) => {

                        // Builtin function

                        continue;

                    let definition_id = expr.definition;

                    match ctx.types.get_procedure_monomorph_index(&definition_id, &poly_types) {

                        Some(reserved_idx) => {

                            // Already typechecked, or already put into the resolve queue

                            infer_expr.field_or_monomorph_idx = reserved_idx;

                        },

                        None => {

                            // Not typechecked yet, so add an entry in the queue

                            let reserved_idx = ctx.types.reserve_procedure_monomorph_index(&definition_id, Some(poly_types.clone()));

                            infer_expr.field_or_monomorph_idx = reserved_idx;

                            queue.push(ResolveQueueElement{

                                root_id: ctx.heap[definition_id].defined_in(),

                                reserved_monomorph_idx: reserved_idx,

                            });

                        }

                    }

                },

                Expression::Literal(expr) => {

                    let definition_id = match &expr.value {

                        Literal::Enum(lit) => lit.definition,

                        Literal::Union(lit) => lit.definition,

                        Literal::Struct(lit) => lit.definition,

                        _ => unreachable!(),

                    };

                    infer_expr.field_or_monomorph_idx = mono_index;

                },

                Expression::Select(_) => {

                    debug_assert!(infer_expr.field_or_monomorph_idx >= 0);

                },

                _ => {

                    unreachable!("handling extra data for expression {:?}", &ctx.heap[extra_data.expr_id]);

                }

            }

        }

        // If we did any implicit type forcing, then our queue isn't empty

                CTP::SInt32 => parser_type.push(ITP::SInt32),

                CTP::SInt64 => parser_type.push(ITP::SInt64),

                CTP::Character => parser_type.push(ITP::Character),

                CTP::String => {

                    parser_type.push(ITP::String);

                    parser_type.push(ITP::Character)

                },

                CTP::Array => parser_type.push(ITP::Array),

                CTP::Slice => parser_type.push(ITP::Slice),

                CTP::Input => parser_type.push(ITP::Input),

                CTP::Output => parser_type.push(ITP::Output),

                CTP::Instance(id, num) => parser_type.push(ITP::Instance(*id, *num)),

            }

        }

    }

    /// Construct an error when an expression's type does not match. This

    /// happens if we infer the expression type from its arguments (e.g. the

    /// expression type of an addition operator is the type of the arguments)

    /// But the expression type was already set due to our parent (e.g. an

    /// "if statement" or a "logical not" always expecting a boolean)

    fn construct_expr_type_error(

        &self, ctx: &Ctx, expr_id: ExpressionId, arg_id: ExpressionId

    ) -> ParseError {

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

// Type table

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

struct TypeLoopBreadcrumb {

    definition_id: DefinitionId,

    monomorph_idx: usize,

    next_member: usize,

    next_embedded: usize, // for unions, the index into the variant's embedded types

}

enum BreadcrumbResult {

    TypeExists,

    PushedBreadcrumb,

    TypeLoop(usize), // index into vec of breadcrumbs at which the type matched

}

enum MemoryLayoutResult {

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

    PushBreadcrumb(TypeLoopBreadcrumb),

}

// TODO: @Optimize, initial memory-unoptimized implementation

            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.

    }

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

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

                },

                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;

                            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

                        }

                let mono_idx = definition.monomorphs.len();

                definition.monomorphs.push(StructMonomorph{

                    concrete_type: definition_type.clone(),

                    fields: mono_fields,

                    size: 0,

                    alignment: 0

                });

                mono_idx

            },

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

            },

        };

        self.breadcrumbs.push(TypeLoopBreadcrumb{

            definition_id,

            monomorph_idx,

            next_member: 0,

            next_embedded: 0

        });

        // With the breadcrumb constructed we know this is a new type, so we

        // also need to add an entry in the list of all encountered types

        }

        let mut parts = Vec::with_capacity(member_type.elements.len()); // usually a correct estimation, might not be

        for member_part in &member_type.elements {

            // Check if we have a regular builtin type

            if let Some(part) = parser_to_concrete_part(&member_part.variant) {

                parts.push(part);

                continue;

            }

            // Not builtin, but if all code is working correctly, we only care

            // about the polymorphic argument at this point.

                let mut container_iter = container_type.embedded_iter(0);

                    container_iter.next();

                }

                let poly_section = container_iter.next().unwrap();

                parts.extend(poly_section);

                continue;

            }

            unreachable!("unexpected type part {:?} from {:?}", member_part, member_type);

        }