debug_assert!((infer_expr.extra_data_idx != -1) == needs_extra_data);

        }

        Ok(())

    }

    fn insert_initial_call_polymorph_data(

        &mut self, ctx: &mut Ctx, call_id: CallExpressionId

    ) {

        // Note: the polymorph variables may be partially specified and may

        // contain references to the wrapping definition's (i.e. the proctype

        // we are currently visiting) polymorphic arguments.

        //

        // The arguments of the call may refer to polymorphic variables in the

        // definition of the function we're calling, not of the wrapping

        // definition. We insert markers in these inferred types to be able to

        // map them back and forth to the polymorphic arguments of the function

        // we are calling.

        let call = &ctx.heap[call_id];

        let extra_data_idx = self.expr_types[call.unique_id_in_definition as usize].extra_data_idx; // TODO: @Temp

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

        // Handle the polymorphic arguments (if there are any)

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

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

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

            poly_args.push(self.determine_inference_type_from_parser_type_elements(embedded_elements, true));

        }

        // Handle the arguments and return types

        let definition = &ctx.heap[call.definition];

        let (parameters, returned) = match definition {

            Definition::Component(definition) => {

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

                (&definition.parameters, None)

            },

            Definition::Function(definition) => {

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

                (&definition.parameters, Some(&definition.return_types))

            },

            Definition::Struct(_) | Definition::Enum(_) | Definition::Union(_) => {

                unreachable!("insert_initial_call_polymorph data for non-procedure type");

            },

        };

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

        for parameter_id in parameters.clone().into_iter() { // TODO: @Performance @Now

            let param = &ctx.heap[parameter_id];

            parameter_types.push(self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, false));

        }

        let return_type = match returned {

            None => {

                // Component, so returns a "Void"

                InferenceType::new(false, true, vec![InferenceTypePart::Void])

            },

            Some(returned) => {

                debug_assert_eq!(returned.len(), 1); // TODO: @ReturnTypes

                let returned = &returned[0];

                self.determine_inference_type_from_parser_type_elements(&returned.elements, false)

            }

        };

        self.extra_data[extra_data_idx as usize] = ExtraData{

            expr_id: call_id.upcast(),

            definition_id: call.definition,

            poly_vars: poly_args,

            embedded: parameter_types,

            returned: return_type

        };

    }

    fn insert_initial_struct_polymorph_data(

        &mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId,

    ) {

        use InferenceTypePart as ITP;

        let literal = &ctx.heap[lit_id];

        let extra_data_idx = self.expr_types[literal.unique_id_in_definition as usize].extra_data_idx; // TODO: @Temp

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

        let literal = ctx.heap[lit_id].value.as_struct();

        // Handle polymorphic arguments

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

        let mut total_num_poly_parts = 0;

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

        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 parser types on struct definition

        let defined_type = ctx.types.get_base_definition(&literal.definition).unwrap();

        let struct_type = defined_type.definition.as_struct();

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

        // Note: programmer is capable of specifying fields in a struct literal

        // in a different order than on the definition. We take the literal-

        // specified order to be leading.

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

        for lit_field in literal.fields.iter() {

            let def_field = &struct_type.fields[lit_field.field_idx];

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

            embedded_types.push(inference_type);

        }

        // Return type is the struct type itself, with the appropriate 

        // polymorphic variables. So:

        // - 1 part for definition

        // - N_poly_arg marker parts for each polymorphic argument

        // - all the parts for the currently known polymorphic arguments 

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

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

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

        let mut return_type_done = true;

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

            if !poly_var.is_done { return_type_done = false; }

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

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

        }

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

        let return_type = InferenceType::new(!poly_args.is_empty(), return_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: embedded_types,

            returned: return_type,

        };

    }

    /// Inserts the extra polymorphic data struct for enum expressions. These

    /// can never be determined from the enum itself, but may be inferred from

    /// the use of the enum.

    fn insert_initial_enum_polymorph_data(

        &mut self, ctx: &Ctx, lit_id: LiteralExpressionId

    ) {

        use InferenceTypePart as ITP;

        let literal = &ctx.heap[lit_id];

        let extra_data_idx = self.expr_types[literal.unique_id_in_definition as usize].extra_data_idx; // TODO: @Temp

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

        let literal = ctx.heap[lit_id].value.as_enum();

        // Handle polymorphic arguments to the enum

        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 enum type itself

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

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

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

        let mut enum_type_done = true;

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

            if !poly_var.is_done { enum_type_done = false; }

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

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

        }

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

        let enum_type = InferenceType::new(!poly_args.is_empty(), enum_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: Vec::new(),

            returned: enum_type,

        };

    }

    /// Inserts the extra polymorphic data struct for unions. The polymorphic

    /// arguments may be partially determined from embedded values in the union.

    fn insert_initial_union_polymorph_data(

        &mut self, ctx: &Ctx, lit_id: LiteralExpressionId

    ) {

        use InferenceTypePart as ITP;

        let literal = &ctx.heap[lit_id];

        let extra_data_idx = self.expr_types[literal.unique_id_in_definition as usize].extra_data_idx; // TODO: @Temp

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

        let literal = ctx.heap[lit_id].value.as_union();

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

            }

        }

        // Actual checking

        let expr = &ctx.heap[expr_id];

        let (expr_args, expr_return_name) = match expr {

            Expression::Call(expr) => 

                (

                    expr.arguments.clone(),

                    "return type"

                ),

            Expression::Literal(expr) => {

                let expressions = match &expr.value {

                    Literal::Struct(v) => v.fields.iter()

                        .map(|f| f.value)

                        .collect(),

                    Literal::Enum(_) => Vec::new(),

                    Literal::Union(v) => v.values.clone(),

                    _ => unreachable!()

                };

                ( expressions, "literal" )

            },

            Expression::Select(expr) =>

                // Select expression uses the polymorphic variables of the 

                // struct it is accessing, so get the subject expression.

                (

                    vec![expr.subject],

                    "selected field"

                ),

            _ => unreachable!(),

        };

        // - check return type with itself

        if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(

            &poly_data.returned, &poly_data.returned

        ) {

            return construct_main_error(ctx, poly_data, poly_idx, expr)

                .with_info_at_span(

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

                        "The {} inferred the conflicting types '{}' and '{}'",

                        expr_return_name,

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

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

                    )

                );

        }

        // - check arguments with each other argument and with return type

        for (arg_a_idx, arg_a) in poly_data.embedded.iter().enumerate() {

            for (arg_b_idx, arg_b) in poly_data.embedded.iter().enumerate() {

                if arg_b_idx > arg_a_idx {

                    break;

                }

                if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(&arg_a, &arg_b) {

                    let error = construct_main_error(ctx, poly_data, poly_idx, expr);

                    if arg_a_idx == arg_b_idx {

                        // Same argument

                        let arg = &ctx.heap[expr_args[arg_a_idx]];

                        return error.with_info_at_span(

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

                                "This argument inferred the conflicting types '{}' and '{}'",

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

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

                            )

                        );

                    } else {

                        let arg_a = &ctx.heap[expr_args[arg_a_idx]];

                        let arg_b = &ctx.heap[expr_args[arg_b_idx]];

                        return error.with_info_at_span(

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

                                "This argument inferred it to '{}'",

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

                            )

                        ).with_info_at_span(

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

                                "While this argument inferred it to '{}'",

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

                            )

                        )

                    }

                }

            }

            // Check with return type

            if let Some((poly_idx, section_arg, section_ret)) = has_poly_mismatch(arg_a, &poly_data.returned) {

                let arg = &ctx.heap[expr_args[arg_a_idx]];

                return construct_main_error(ctx, poly_data, poly_idx, expr)

                    .with_info_at_span(

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

                            "This argument inferred it to '{}'",

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

                        )

                    )

                    .with_info_at_span(

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

                            "While the {} inferred it to '{}'",

                            expr_return_name,

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

                        )

                    );

            }

        }

        // Now check against the explicitly specified polymorphic variables (if

        // any).

        for (arg_idx, arg) in poly_data.embedded.iter().enumerate() {

            if let Some((poly_idx, poly_section, arg_section)) = has_explicit_poly_mismatch(&poly_data.poly_vars, arg) {

                let arg = &ctx.heap[expr_args[arg_idx]];

                return construct_main_error(ctx, poly_data, poly_idx, expr)

                    .with_info_at_span(

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

                            "The polymorphic variable has type '{}' (which might have been partially inferred) while the argument inferred it to '{}'",

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

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

                        )

                    );

            }

        }

        if let Some((poly_idx, poly_section, ret_section)) = has_explicit_poly_mismatch(&poly_data.poly_vars, &poly_data.returned) {

            return construct_main_error(ctx, poly_data, poly_idx, expr)

                .with_info_at_span(

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

                        "The polymorphic variable has type '{}' (which might have been partially inferred) while the {} inferred it to '{}'",

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

                        expr_return_name,

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

                    )

                )

        }

        unreachable!("construct_poly_arg_error without actual error found?")

    }

}

#[cfg(test)]

mod tests {

    use super::*;

    use crate::protocol::arena::Id;

    use InferenceTypePart as ITP;

    use InferenceType as IT;

    #[test]

    fn test_single_part_inference() {

        // lhs argument inferred from rhs

        let pairs = [

            (ITP::NumberLike, ITP::UInt8),

            (ITP::IntegerLike, ITP::SInt32),

            (ITP::Unknown, ITP::UInt64),

            (ITP::Unknown, ITP::Bool)

        ];

        for (lhs, rhs) in pairs.iter() {

            // Using infer-both

            let mut lhs_type = IT::new(false, false, vec![lhs.clone()]);

            let mut rhs_type = IT::new(false, true, vec![rhs.clone()]);

            let result = unsafe{ IT::infer_subtrees_for_both_types(

                &mut lhs_type, 0, &mut rhs_type, 0

            ) };

            assert_eq!(DualInferenceResult::First, result);

            assert_eq!(lhs_type.parts, rhs_type.parts);

            // Using infer-single

            let mut lhs_type = IT::new(false, false, vec![lhs.clone()]);

            let rhs_type = IT::new(false, true, vec![rhs.clone()]);

            let result = IT::infer_subtree_for_single_type(

                &mut lhs_type, 0, &rhs_type.parts, 0, false

            );

            assert_eq!(SingleInferenceResult::Modified, result);

            assert_eq!(lhs_type.parts, rhs_type.parts);

        }

    }

    #[test]

    fn test_multi_part_inference() {

        let pairs = [

            (vec![ITP::ArrayLike, ITP::NumberLike], vec![ITP::Slice, ITP::SInt8]),

            (vec![ITP::Unknown], vec![ITP::Input, ITP::Array, ITP::String, ITP::Character]),

            (vec![ITP::PortLike, ITP::SInt32], vec![ITP::Input, ITP::SInt32]),

            (vec![ITP::Unknown], vec![ITP::Output, ITP::SInt32]),

            (

                vec![ITP::Instance(Id::new(0), 2), ITP::Input, ITP::Unknown, ITP::Output, ITP::Unknown],

                vec![ITP::Instance(Id::new(0), 2), ITP::Input, ITP::Array, ITP::SInt32, ITP::Output, ITP::SInt32]

            )

        ];

        for (lhs, rhs) in pairs.iter() {

            let mut lhs_type = IT::new(false, false, lhs.clone());

            let mut rhs_type = IT::new(false, true, rhs.clone());

            let result = unsafe{ IT::infer_subtrees_for_both_types(

                &mut lhs_type, 0, &mut rhs_type, 0

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

        if cfg!(debug_assertions) {

            for (index, module) in modules.iter().enumerate() {

                debug_assert_eq!(index, module.root_id.index as usize);

            }

        }

        // Use context to guess hashmap size of the base types

        let reserve_size = ctx.heap.definitions.len();

        self.lookup.reserve(reserve_size);

        // Resolve all base types

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

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

            let definition = &ctx.heap[definition_id];

            match definition {

                Definition::Enum(_) => self.build_base_enum_definition(modules, ctx, definition_id)?,

                Definition::Union(_) => self.build_base_union_definition(modules, ctx, definition_id)?,

                Definition::Struct(_) => self.build_base_struct_definition(modules, ctx, definition_id)?,

                Definition::Function(_) => self.build_base_function_definition(modules, ctx, definition_id)?,

                Definition::Component(_) => self.build_base_component_definition(modules, ctx, definition_id)?,

            }

        }

        debug_assert_eq!(self.lookup.len(), reserve_size, "mismatch in reserved size of type table"); // NOTE: Temp fix for builtin functions

        for module in modules.iter_mut() {

            module.phase = ModuleCompilationPhase::TypesAddedToTable;

        }

        // Go through all types again, lay out all types that are not

        // polymorphic. This might cause us to lay out types that are monomorphs

        // of polymorphic types.

        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.definition.type_class().is_data_type() && poly_type.poly_vars.is_empty() && poly_type.num_monomorphs() == 0 {

                self.detect_and_resolve_type_loops_for(

                    modules, ctx.heap,

                    ConcreteType{

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

                    },

                )?;

                self.lay_out_memory_for_encountered_types(ctx.arch);

            }

        }

        Ok(())

    }

    /// Retrieves base definition from type table. We must be able to retrieve

    /// it as we resolve all base types upon type table construction (for now).

    /// However, in the future we might do on-demand type resolving, so return

    /// an option anyway

    pub(crate) fn get_base_definition(&self, definition_id: &DefinitionId) -> Option<&DefinedType> {

        self.lookup.get(&definition_id)

    }

    /// Returns the index into the monomorph type array if the procedure type

    /// already has a (reserved) monomorph.

    pub(crate) fn get_procedure_monomorph_index(&self, definition_id: &DefinitionId, types: &ConcreteType) -> Option<i32> {

        let def = self.lookup.get(definition_id).unwrap();

        let monos = def.definition.procedure_monomorphs();

        return monos.iter()

            .position(|v| v.concrete_type == *types)

            .map(|v| v as i32);

    }

    /// Returns a mutable reference to a procedure's monomorph expression data.

    /// Used by typechecker to fill in previously reserved type information

    pub(crate) fn get_procedure_expression_data_mut(&mut self, definition_id: &DefinitionId, monomorph_idx: i32) -> &mut ProcedureMonomorph {

        debug_assert!(monomorph_idx >= 0);

        let def = self.lookup.get_mut(definition_id).unwrap();

        let monomorphs = def.definition.procedure_monomorphs_mut();

        return &mut monomorphs[monomorph_idx as usize];

    }

    pub(crate) fn get_procedure_expression_data(&self, definition_id: &DefinitionId, monomorph_idx: i32) -> &ProcedureMonomorph {

        debug_assert!(monomorph_idx >= 0);

        let def = self.lookup.get(definition_id).unwrap();

        let monomorphs = def.definition.procedure_monomorphs();

        return &monomorphs[monomorph_idx as usize];

    }

    /// Reserves space for a monomorph of a polymorphic procedure. The index

    /// will point into a (reserved) slot of the array of expression types. The

    /// monomorph may NOT exist yet (because the reservation implies that we're

    /// going to be performing typechecking on it, and we don't want to

    /// check the same monomorph twice)

    pub(crate) fn reserve_procedure_monomorph_index(&mut self, definition_id: &DefinitionId, concrete_type: ConcreteType) -> i32 {

        let def = self.lookup.get_mut(definition_id).unwrap();

        let mono_types = def.definition.procedure_monomorphs_mut();