},

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

        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

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

            auto left = holder.left[left_base..left_base + left_amount];

            auto right = holder.right[right_base..right_base + right_amount];

            return left[0..1] @ right[0..1];

        }

        func foo() -> bool {

            // Preliminaries:

            // 1. construct a holder, where:

            //      - left array will be [0, 1, 2, ...]

            //      - right array will be [2, 3, 4, ...]

            // 2. Perform slicing magic, always returning an array [3, 3]

            // 3. Make sure result is 6

            // But ofcourse, because we want to be silly, we will check this for

            // any possible integer type.

            auto created_u08 = create_holder<u8> (0, 5, 2, 8);

            auto created_u16 = create_holder<u16>(0, 5, 2, 8);

            auto created_u32 = create_holder<u32>(0, 5, 2, 8);

            auto created_u64 = create_holder<u64>(0, 5, 2, 8);

            auto result_u08 = slicing_magic(created_u08, 3, 2, 1, 2);

            auto result_u16 = slicing_magic(created_u16, 3, 2, 1, 2);

            auto result_u32 = slicing_magic(created_u32, 3, 2, 1, 2);

            auto result_u64 = slicing_magic(created_u64, 3, 2, 1, 2);

            auto result_s08 = slicing_magic(create_holder<s8> (0, 5, 2, 8), 3, 2, 1, 2);

            auto result_s16 = slicing_magic(create_holder<s16>(0, 5, 2, 8), 3, 2, 1, 2);

            auto result_s32 = slicing_magic(create_holder<s32>(0, 5, 2, 8), 3, 2, 1, 2);

            auto result_s64 = slicing_magic(create_holder<s64>(0, 5, 2, 8), 3, 2, 1, 2);

            return

                result_u08[0] + result_u08[1] == 6 &&

                result_u16[0] + result_u16[1] == 6 &&

                result_u32[0] + result_u32[1] == 6 &&

                result_u64[0] + result_u64[1] == 6 &&

                result_s08[0] + result_s08[1] == 6 &&

                result_s16[0] + result_s16[1] == 6 &&

                result_s32[0] + result_s32[1] == 6 &&

                result_s64[0] + result_s64[1] == 6;

        }

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

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

    }).for_struct("Holder", |s| { s

        .assert_num_monomorphs(8)

    });

}

#[test]

fn test_struct_fields() {

    Tester::new_single_source_expect_ok("struct field access", "

        struct Nester<T> {

            T v,

        }

        func make<T>(T inner) -> Nester<T> {

            return Nester{ v: inner };

        }

        func modify<T>(Nester<T> outer, T inner) -> Nester<T> {

            outer.v = inner;

            return outer;

        }

        func foo() -> bool {

            // Single depth modification

            auto original1 = make<u32>(5);

            auto modified1 = modify(original1, 2);

            auto success1 = original1.v == 5 && modified1.v == 2;

            // Multiple levels of modification

            auto original2 = make(make(make(make(true))));

            auto modified2 = modify(original2.v, make(make(false))); // strip one Nester level

            auto success2 = original2.v.v.v.v == true && modified2.v.v.v == false;

            return success1 && success2;

        }

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

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

    });

}

#[test]

fn test_field_selection_polymorphism() {

    // Bit silly, but just to be sure

    Tester::new_single_source_expect_ok("struct field shuffles", "

        struct VecXYZ<T> { T x, T y, T z }

        struct VecYZX<T> { T y, T z, T x }

        struct VecZXY<T> { T z, T x, T y }

        func modify_x<T>(T input) -> T {

            input.x = 1337;

            return input;