// Construct the polymorphic variables

        let num_poly_args = literal.parser_type.elements[0].variant.num_embedded();

        let mut total_num_poly_parts = 0;

        let mut poly_args = Vec::with_capacity(num_poly_args);

        for embedded_elements in literal.parser_type.iter_embedded(0) {

            let poly_type = self.determine_inference_type_from_parser_type_elements(embedded_elements, true);

            total_num_poly_parts += poly_type.parts.len();

            poly_args.push(poly_type);

        }

        // Handle any of the embedded values in the variant, if specified

        let definition_id = literal.definition;

        let type_definition = ctx.types.get_base_definition(&definition_id).unwrap();

        let union_definition = type_definition.definition.as_union();

        debug_assert_eq!(poly_args.len(), type_definition.poly_vars.len());

        let variant_definition = &union_definition.variants[literal.variant_idx];

        debug_assert_eq!(variant_definition.embedded.len(), literal.values.len());

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

        for embedded_parser_type in &variant_definition.embedded {

            let inference_type = self.determine_inference_type_from_parser_type_elements(&embedded_parser_type.elements, false);

            embedded.push(inference_type);

        }

        // Handle the type of the union itself

        let parts_reserved = 1 + poly_args.len() + total_num_poly_parts;

        let mut parts = Vec::with_capacity(parts_reserved);

        parts.push(ITP::Instance(definition_id, poly_args.len() as u32));

        let mut union_type_done = true;

        for (poly_var_idx, poly_var) in poly_args.iter().enumerate() {

            if !poly_var.is_done { union_type_done = false; }

            parts.push(ITP::Marker(poly_var_idx as u32));

            parts.extend(poly_var.parts.iter().cloned());

        }

        debug_assert_eq!(parts_reserved, parts.len());

        let union_type = InferenceType::new(!poly_args.is_empty(), union_type_done, parts);

        self.extra_data[extra_data_idx as usize] = ExtraData{

            expr_id: lit_id.upcast(),

            definition_id: literal.definition,

            poly_vars: poly_args,

            embedded,

            returned: union_type

        };

    }

    /// Inserts the extra polymorphic data struct. Assumes that the select

    /// expression's referenced (definition_id, field_idx) has been resolved.

    fn insert_initial_select_polymorph_data(

        &mut self, ctx: &Ctx, select_id: SelectExpressionId, struct_def_id: DefinitionId

    ) {

        use InferenceTypePart as ITP;

        // Retrieve relevant data

        let expr = &ctx.heap[select_id];

        let expr_type = &self.expr_types[expr.unique_id_in_definition as usize];

        let field_idx = expr_type.field_or_monomorph_idx as usize;

        let extra_data_idx = expr_type.extra_data_idx; // TODO: @Temp

        debug_assert!(extra_data_idx != -1, "initial select polymorph data, but no preallocated ExtraData");

        let definition = ctx.heap[struct_def_id].as_struct();

        // Generate initial polyvar types and struct type

        // TODO: @Performance: we can immediately set the polyvars of the subject's struct type

        let num_poly_vars = definition.poly_vars.len();

        let mut poly_vars = Vec::with_capacity(num_poly_vars);

        let struct_parts_reserved = 1 + 2 * num_poly_vars;

        let mut struct_parts = Vec::with_capacity(struct_parts_reserved);

        struct_parts.push(ITP::Instance(struct_def_id, num_poly_vars as u32));

        for poly_idx in 0..num_poly_vars {

            poly_vars.push(InferenceType::new(true, false, vec![

                ITP::Marker(poly_idx as u32), ITP::Unknown,

            ]));

            struct_parts.push(ITP::Marker(poly_idx as u32));

            struct_parts.push(ITP::Unknown);

        }

        debug_assert_eq!(struct_parts.len(), struct_parts_reserved);

        // Generate initial field type

        let field_type = self.determine_inference_type_from_parser_type_elements(&definition.fields[field_idx].parser_type.elements, false);

        self.extra_data[extra_data_idx as usize] = ExtraData{

            expr_id: select_id.upcast(),

            definition_id: struct_def_id,

            poly_vars,

            embedded: vec![InferenceType::new(num_poly_vars != 0, num_poly_vars == 0, struct_parts)],

            returned: field_type

        };

    }

    /// Determines the initial InferenceType from the provided ParserType. This

    /// may be called with two kinds of intentions:

    /// 1. To resolve a ParserType within the body of a function, or on

    ///     polymorphic arguments to calls/instantiations within that body. This

    ///     means that the polymorphic variables are known and can be replaced

    ///     with the monomorph we're instantiating.

    /// 2. To resolve a ParserType on a called function's definition or on

    ///     an instantiated datatype's members. This means that the polymorphic

    ///     arguments inside those ParserTypes refer to the polymorphic

    ///     variables in the called/instantiated type's definition.

    /// In the second case we place InferenceTypePart::Marker instances such

    /// that we can perform type inference on the polymorphic variables.

    fn determine_inference_type_from_parser_type_elements(

        &mut self, elements: &[ParserTypeElement],

        use_definitions_known_poly_args: bool

    ) -> InferenceType {

        use ParserTypeVariant as PTV;

        use InferenceTypePart as ITP;

        let mut infer_type = Vec::with_capacity(elements.len());

        let mut has_inferred = false;

        let mut has_markers = false;

        for element in elements {

            match &element.variant {

                // Compiler-only types

                PTV::Void => { infer_type.push(ITP::Void); },

                PTV::InputOrOutput => { infer_type.push(ITP::PortLike); has_inferred = true },

                PTV::ArrayLike => { infer_type.push(ITP::ArrayLike); has_inferred = true },

                PTV::IntegerLike => { infer_type.push(ITP::IntegerLike); has_inferred = true },

                // Builtins

                PTV::Message => {

                    // TODO: @types Remove the Message -> Byte hack at some point...

                    infer_type.push(ITP::Message);

                    infer_type.push(ITP::UInt8);

                },

                PTV::Bool => { infer_type.push(ITP::Bool); },

                PTV::UInt8 => { infer_type.push(ITP::UInt8); },

                PTV::UInt16 => { infer_type.push(ITP::UInt16); },

                PTV::UInt32 => { infer_type.push(ITP::UInt32); },

                PTV::UInt64 => { infer_type.push(ITP::UInt64); },

                PTV::SInt8 => { infer_type.push(ITP::SInt8); },

                PTV::SInt16 => { infer_type.push(ITP::SInt16); },

                PTV::SInt32 => { infer_type.push(ITP::SInt32); },

                PTV::SInt64 => { infer_type.push(ITP::SInt64); },

                PTV::Character => { infer_type.push(ITP::Character); },

                PTV::String => {

                    infer_type.push(ITP::String);

                    infer_type.push(ITP::Character);

                },

                // Special markers

                PTV::IntegerLiteral => { unreachable!("integer literal type on variable type"); },

                PTV::Inferred => {

                    infer_type.push(ITP::Unknown);

                    has_inferred = true;

                },

                // With nested types

                PTV::Array => { infer_type.push(ITP::Array); },

                PTV::Input => { infer_type.push(ITP::Input); },

                PTV::Output => { infer_type.push(ITP::Output); },

                PTV::PolymorphicArgument(belongs_to_definition, poly_arg_idx) => {

                    let poly_arg_idx = *poly_arg_idx;

                    if use_definitions_known_poly_args {

                        // Refers to polymorphic argument on procedure we're currently processing.

                        // This argument is already known.

                        debug_assert_eq!(*belongs_to_definition, self.definition_type.definition_id());

                        debug_assert!((poly_arg_idx as usize) < self.poly_vars.len());

                        Self::determine_inference_type_from_concrete_type(

                            &mut infer_type, &self.poly_vars[poly_arg_idx as usize].parts

                        );

                    } else {

                        // Polymorphic argument has to be inferred

                        has_markers = true;

                        has_inferred = true;

                        infer_type.push(ITP::Marker(poly_arg_idx));

                        infer_type.push(ITP::Unknown)

                    }

                },

                PTV::Definition(definition_id, num_embedded) => {

                    infer_type.push(ITP::Instance(*definition_id, *num_embedded));

                }

            }

        }

        InferenceType::new(has_markers, !has_inferred, infer_type)

    }

    /// Determines the inference type from an already concrete type. Applies the

    /// various type "hacks" inside the type inferencer.

    fn determine_inference_type_from_concrete_type(parser_type: &mut Vec<InferenceTypePart>, concrete_type: &[ConcreteTypePart]) {

        use InferenceTypePart as ITP;

        use ConcreteTypePart as CTP;

        for concrete_part in concrete_type {

            match concrete_part {

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

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

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

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

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

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

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

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

                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)),

                CTP::Function(_, _) => unreachable!("function type during concrete to inference type conversion"),

                CTP::Component(_, _) => unreachable!("component type during concrete to inference type conversion"),

            }

        }

    }

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

        // TODO: Expand and provide more meaningful information for humans

        let expr = &ctx.heap[expr_id];

        let arg_expr = &ctx.heap[arg_id];

        let expr_idx = expr.get_unique_id_in_definition();

        let arg_expr_idx = arg_expr.get_unique_id_in_definition();

        let expr_type = &self.expr_types[expr_idx as usize].expr_type;

        let arg_type = &self.expr_types[arg_expr_idx as usize].expr_type;

        return ParseError::new_error_at_span(

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

                "incompatible types: this expression expected a '{}'",

                expr_type.display_name(&ctx.heap)

            )

        ).with_info_at_span(

            &ctx.module().source, arg_expr.full_span(), format!(

                "but this expression yields a '{}'",

                arg_type.display_name(&ctx.heap)

            )

        )

    }

    fn construct_arg_type_error(

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

        arg1_id: ExpressionId, arg2_id: ExpressionId

    ) -> ParseError {

        let expr = &ctx.heap[expr_id];

        let arg1 = &ctx.heap[arg1_id];

        let arg2 = &ctx.heap[arg2_id];

        let arg1_idx = arg1.get_unique_id_in_definition();

        let arg1_type = &self.expr_types[arg1_idx as usize].expr_type;

        let arg2_idx = arg2.get_unique_id_in_definition();

        let arg2_type = &self.expr_types[arg2_idx as usize].expr_type;

        return ParseError::new_error_str_at_span(

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

            "incompatible types: cannot apply this expression"

        ).with_info_at_span(

            &ctx.module().source, arg1.full_span(), format!(

                "Because this expression has type '{}'",

                arg1_type.display_name(&ctx.heap)

            )

        ).with_info_at_span(

            &ctx.module().source, arg2.full_span(), format!(

                "But this expression has type '{}'",

                arg2_type.display_name(&ctx.heap)

            )

        )

    }

    fn construct_template_type_error(

        &self, ctx: &Ctx, expr_id: ExpressionId, template: &[InferenceTypePart]

    ) -> ParseError {

        let expr = &ctx.heap[expr_id];

        let expr_idx = expr.get_unique_id_in_definition();

        let expr_type = &self.expr_types[expr_idx as usize].expr_type;

        return ParseError::new_error_at_span(

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

                "incompatible types: got a '{}' but expected a '{}'",

                expr_type.display_name(&ctx.heap), 

                InferenceType::partial_display_name(&ctx.heap, template)

            )

        )

    }

    /// Constructs a human interpretable error in the case that type inference

    /// on a polymorphic variable to a function call or literal construction 

    /// failed. This may only be caused by a pair of inference types (which may 

    /// come from arguments or the return type) having two different inferred 

    /// values for that polymorphic variable.

    ///

    /// So we find this pair and construct the error using it.

    ///

    /// We assume that the expression is a function call or a struct literal,

    /// and that an actual error has occurred.

    fn construct_poly_arg_error(

        ctx: &Ctx, poly_data: &ExtraData, expr_id: ExpressionId

    ) -> ParseError {

        // Helper function to check for polymorph mismatch between two inference

        // types.

        fn has_poly_mismatch<'a>(type_a: &'a InferenceType, type_b: &'a InferenceType) -> Option<(u32, &'a [InferenceTypePart], &'a [InferenceTypePart])> {

            if !type_a.has_marker || !type_b.has_marker {

                return None

            }

            for (marker_a, section_a) in type_a.marker_iter() {

                for (marker_b, section_b) in type_b.marker_iter() {

                    if marker_a != marker_b {

                        // Not the same polymorphic variable

                        continue;

                    }

                    if !InferenceType::check_subtrees(section_a, 0, section_b, 0) {

                        // Not compatible

                        return Some((marker_a, section_a, section_b))

                    }

                }

            }

            None

        }

        // Helper function to check for polymorph mismatch between an inference

        // type and the polymorphic variables in the poly_data struct.

        fn has_explicit_poly_mismatch<'a>(

            poly_vars: &'a [InferenceType], arg: &'a InferenceType

        ) -> Option<(u32, &'a [InferenceTypePart], &'a [InferenceTypePart])> {

            for (marker, section) in arg.marker_iter() {

                debug_assert!((marker as usize) < poly_vars.len());

                let poly_section = &poly_vars[marker as usize].parts;

                if !InferenceType::check_subtrees(poly_section, 0, section, 0) {

                    return Some((marker, poly_section, section))

                }

            }

            None

        }

        // Helpers function to retrieve polyvar name and definition name

        fn get_poly_var_and_definition_name<'a>(ctx: &'a Ctx, poly_var_idx: u32, definition_id: DefinitionId) -> (&'a str, &'a str) {

            let definition = &ctx.heap[definition_id];

            let poly_var = definition.poly_vars()[poly_var_idx as usize].value.as_str();

            let func_name = definition.identifier().value.as_str();

            (poly_var, func_name)

        }

        // Helper function to construct initial error

        fn construct_main_error(ctx: &Ctx, poly_data: &ExtraData, poly_var_idx: u32, expr: &Expression) -> ParseError {

            match expr {

                Expression::Call(expr) => {

                    let (poly_var, func_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);

                    return ParseError::new_error_at_span(

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

                            "Conflicting type for polymorphic variable '{}' of '{}'",

                            poly_var, func_name

                        )

                    )

                },

                Expression::Literal(expr) => {

                    let (poly_var, type_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);

                    return ParseError::new_error_at_span(

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

                            "Conflicting type for polymorphic variable '{}' of instantiation of '{}'",

                            poly_var, type_name

                        )

                    );

                },

                Expression::Select(expr) => {

                    let (poly_var, struct_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);

                    return ParseError::new_error_at_span(

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

                            "Conflicting type for polymorphic variable '{}' while accessing field '{}' of '{}'",

                            poly_var, expr.field_name.value.as_str(), struct_name

                        )

                    )

                }

                _ => unreachable!("called construct_poly_arg_error without an expected expression, got: {:?}", expr)

        self.lookup.insert(definition_id, DefinedType {

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Enum(EnumType{

                variants,

                monomorphs: Vec::new(),

                minimum_tag_value: min_enum_value,

                maximum_tag_value: max_enum_value,

                tag_type,

                size: size_and_alignment,

                alignment: size_and_alignment

            }),

            poly_vars,

            is_polymorph: false,

        });

        return Ok(());

    }

    /// Builds the base type for a union. Will compute byte sizes.

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

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

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

        let root_id = definition.defined_in;

        // Check all variants and their embedded types

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

        let mut tag_counter = 0;

        for variant in &definition.variants {

            for embedded in &variant.value {

                Self::check_member_parser_type(

                    modules, ctx, root_id, embedded, false

                )?;

            }

            variants.push(UnionVariant{

                identifier: variant.identifier.clone(),

                embedded: variant.value.clone(),

                tag_value: tag_counter,

            });

            tag_counter += 1;

        }

        let mut max_tag_value = 0;

        if tag_counter != 0 {

            max_tag_value = tag_counter - 1

        }

        let (tag_type, tag_size) = Self::variant_tag_type_from_values(0, max_tag_value);

        // Make sure there are no conflicts in identifiers

        Self::check_identifier_collision(

            modules, root_id, &variants, |variant| &variant.identifier, "union variant"

        )?;

        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;

        // Construct internal representation of union

        let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);

        for variant in &definition.variants {

            for embedded in &variant.value {

                Self::mark_used_polymorphic_variables(&mut poly_vars, embedded);

            }

        }

        let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);

        self.lookup.insert(definition_id, DefinedType{

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Union(UnionType{

                variants,

                monomorphs: Vec::new(),

                tag_type,

                tag_size,

            }),

            poly_vars,

            is_polymorph

        });

        return Ok(());

    }

    /// Builds base struct type. Will not compute byte sizes.

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

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

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

        let root_id = definition.defined_in;

        // Check all struct fields and construct internal representation

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

        for field in &definition.fields {

            Self::check_member_parser_type(

                modules, ctx, root_id, &field.parser_type, false

            )?;

            fields.push(StructField{

                identifier: field.field.clone(),

                parser_type: field.parser_type.clone(),

            });

        }

        // Make sure there are no conflicting variables

        Self::check_identifier_collision(

            modules, root_id, &fields, |field| &field.identifier, "struct field"

        )?;

        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;

        // Construct base type in table

        let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);

        for field in &fields {

            Self::mark_used_polymorphic_variables(&mut poly_vars, &field.parser_type);

        }

        let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);

        self.lookup.insert(definition_id, DefinedType{

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Struct(StructType{

                fields,

                monomorphs: Vec::new(),

            }),

            poly_vars,

            is_polymorph

        });

        return Ok(())

    }

    /// Builds base function type.

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

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

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

        let root_id = definition.defined_in;

        // Check and construct return types and argument types.

        debug_assert_eq!(definition.return_types.len(), 1, "not one return type"); // TODO: @ReturnValues

        for return_type in &definition.return_types {

            Self::check_member_parser_type(

                modules, ctx, root_id, return_type, definition.builtin

            )?;

        }

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

        for parameter_id in &definition.parameters {

            let parameter = &ctx.heap[*parameter_id];

            Self::check_member_parser_type(

                modules, ctx, root_id, &parameter.parser_type, definition.builtin

            )?;

            arguments.push(FunctionArgument{

                identifier: parameter.identifier.clone(),

                parser_type: parameter.parser_type.clone(),

            });

        }

        // Check conflict of identifiers

        Self::check_identifier_collision(

            modules, root_id, &arguments, |arg| &arg.identifier, "function argument"

        )?;

        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;

        // Construct internal representation of function type

        let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);

        for return_type in &definition.return_types {

            Self::mark_used_polymorphic_variables(&mut poly_vars, return_type);

        }

        for argument in &arguments {

            Self::mark_used_polymorphic_variables(&mut poly_vars, &argument.parser_type);

        }

        let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);

        self.lookup.insert(definition_id, DefinedType{

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Function(FunctionType{

                return_types: definition.return_types.clone(),

                arguments,

                monomorphs: Vec::new(),

            }),

            poly_vars,

            is_polymorph

        });

        return Ok(());

    }

    /// Builds base component type.

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

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

        let root_id = definition.defined_in;

        // Check the argument types

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

        for parameter_id in &definition.parameters {

            let parameter = &ctx.heap[*parameter_id];

            Self::check_member_parser_type(

                modules, ctx, root_id, &parameter.parser_type, false

            )?;

            arguments.push(FunctionArgument{

                identifier: parameter.identifier.clone(),

                parser_type: parameter.parser_type.clone(),

            });

        }

        // Check conflict of identifiers

        Self::check_identifier_collision(

            modules, root_id, &arguments, |arg| &arg.identifier, "connector argument"

        )?;

        Self::check_poly_args_collision(modules, ctx, root_id, &definition.poly_vars)?;

        // Construct internal representation of component

        let mut poly_vars = Self::create_polymorphic_variables(&definition.poly_vars);

        for argument in &arguments {

            Self::mark_used_polymorphic_variables(&mut poly_vars, &argument.parser_type);

        }

        let is_polymorph = poly_vars.iter().any(|arg| arg.is_in_use);

        self.lookup.insert(definition_id, DefinedType{

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Component(ComponentType{

                variant: definition.variant,

                arguments,

                monomorphs: Vec::new()

            }),

            poly_vars,

            is_polymorph

        });

        Ok(())

    }

    /// Will check if the member type (field of a struct, embedded type in a

    /// union variant) is valid.

    fn check_member_parser_type(

        modules: &[Module], ctx: &PassCtx, base_definition_root_id: RootId,

        member_parser_type: &ParserType, allow_special_compiler_types: bool

    ) -> Result<(), ParseError> {

        use ParserTypeVariant as PTV;

        for element in &member_parser_type.elements {

            match element.variant {

                // Special cases

                PTV::Void | PTV::InputOrOutput | PTV::ArrayLike | PTV::IntegerLike => {

                    if !allow_special_compiler_types {

                        unreachable!("compiler-only ParserTypeVariant in member type");

                    }

                },

                // Builtin types, always valid

                PTV::Message | PTV::Bool |

                PTV::UInt8 | PTV::UInt16 | PTV::UInt32 | PTV::UInt64 |

                PTV::SInt8 | PTV::SInt16 | PTV::SInt32 | PTV::SInt64 |

                PTV::Character | PTV::String |

                PTV::Array | PTV::Input | PTV::Output |

                // Likewise, polymorphic variables are always valid

                PTV::PolymorphicArgument(_, _) => {},

                // Types that are not constructable, or types that are not

                // allowed (and checked earlier)

                PTV::IntegerLiteral | PTV::Inferred => {

                    unreachable!("illegal ParserTypeVariant within type definition");

                },

                // Finally, user-defined types

                PTV::Definition(definition_id, _) => {

                    let definition = &ctx.heap[definition_id];

                    if !(definition.is_struct() || definition.is_enum() || definition.is_union()) {

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

                        return Err(ParseError::new_error_str_at_span(

                            source, element.element_span, "expected a datatype (a struct, enum or union)"

                        ));

                    }

                    // Otherwise, we're fine

                }

            }

        }

        // If here, then all elements check out

        return Ok(());

    }

    /// Go through a list of identifiers and ensure that all identifiers have

    /// unique names

    fn check_identifier_collision<T: Sized, F: Fn(&T) -> &Identifier>(

        modules: &[Module], root_id: RootId, items: &[T], getter: F, item_name: &'static str

    ) -> Result<(), ParseError> {

        for (item_idx, item) in items.iter().enumerate() {

            let item_ident = getter(item);

            for other_item in &items[0..item_idx] {

                let other_item_ident = getter(other_item);

                if item_ident == other_item_ident {

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

                    return Err(ParseError::new_error_at_span(

                        module_source, item_ident.span, format!("This {} is defined more than once", item_name)

                    ).with_info_at_span(

                        module_source, other_item_ident.span, format!("The other {} is defined here", item_name)

                    ));

                }

            }

        }

        Ok(())

    }

    /// Go through a list of polymorphic arguments and make sure that the

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

    fn detect_and_resolve_type_loops_for(&mut self, modules: &[Module], heap: &Heap, concrete_type: ConcreteType) -> Result<(), ParseError> {

        use DefinedTypeVariant as DTV;

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

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

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

        // Push the initial breadcrumb

        let initial_breadcrumb = self.check_member_for_type_loops(&concrete_type);

        if let TypeLoopResult::PushBreadcrumb(definition_id, concrete_type) = initial_breadcrumb {

            self.handle_new_breadcrumb_for_type_loops(definition_id, concrete_type);

        } else {

            unreachable!();

        }

        // Enter into the main resolving loop

        while !self.type_loop_breadcrumbs.is_empty() {

            // Because we might be modifying the breadcrumb array we need to

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

            let mut breadcrumb = self.type_loop_breadcrumbs[breadcrumb_idx].clone();

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

            let poly_type_definition_id = poly_type.ast_definition;

            let resolve_result = match &poly_type.definition {

use super::*;

#[test]

fn test_concatenate_operator() {

    Tester::new_single_source_expect_ok(

        "concatenate and check values",

        "

        // Too see if we accept the polymorphic arg

        func check_pair<T>(T[] arr, u32 idx) -> bool {

            return arr[idx] == arr[idx + 1];

        }

        // Too see if we can check fields of polymorphs

        func check_values<T>(T[] arr, u32 idx, u32 x, u32 y) -> bool {

            auto value = arr[idx];

            return value.x == x && value.y == y;

        }

        struct Point2D {

            u32 x,

            u32 y,

        }

        // Could do this inline, but we're attempt to stress the system a bit

        func create_point(u32 x, u32 y) -> Point2D {

            return Point2D{ x: x, y: y };

        }

        // Again, more stressing: returning a heap-allocated thing

        func create_array() -> Point2D[] {

            return {

                create_point(1, 2),

                create_point(1, 2),

                create_point(3, 4),

                create_point(3, 4)

            };

        }

        // The silly checkamajig

        func foo() -> bool {

            auto lhs = create_array();

            auto rhs = create_array();

            auto total = lhs @ rhs;

            auto is_equal =

                check_pair(total, 0) &&

                check_pair(total, 2) &&

                check_pair(total, 4) &&

                check_pair(total, 6);

            auto is_not_equal =

                !check_pair(total, 0) ||

                !check_pair(total, 2) ||

                !check_pair(total, 4) ||

                !check_pair(total, 6);

            auto has_correct_fields =

                check_values(total, 3, 3, 4) &&

                check_values(total, 4, 1, 2);

            auto array_check = lhs == rhs && total == total;

            return is_equal && !is_not_equal && has_correct_fields && array_check;

        }

        "

    ).for_function("foo", |f| {

        f.call_ok(Some(Value::Bool(true)));

    });

}

#[test]

fn test_slicing_magic() {

    Tester::new_single_source_expect_ok("slicing", "

        struct Holder<T> {

            T[] left,

            T[] right,

        }

        func create_array<T>(T first_index, T last_index) -> T[] {

            auto result = {};

            while (first_index < last_index) {

                // Absolutely rediculous, but we don't have builtin array functions yet...

                result = result @ { first_index };

                first_index += 1;

            }

            return result;

        }

        func create_holder<T>(T left_first, T left_last, T right_first, T right_last) -> Holder<T> {

            return Holder{

                left: create_array(left_first, left_last),

                right: create_array(right_first, right_last)

            };

        }

        // Another silly thing, we first slice the full thing. Then subslice a single

        // element, then concatenate. We always return an array of two things.

        func slicing_magic<T>(Holder<T> holder, u32 left_base, u32 left_amount, u32 right_base, u32 right_amount) -> T[] {