// - for each argument try to make sure the types match

        for arg_idx in 0..arguments.values.len() {

            let expected_type = &mono_type.arg_types[arg_idx];

            let provided_value = &arguments.values[arg_idx];

            if !self.verify_same_type(expected_type, 0, &arguments, provided_value) {

                return Err(ComponentCreationError::InvalidArgumentType(arg_idx));

            }

        }

        // By now we're sure that all of the arguments are correct. So create

        // the connector.

    }

    fn lookup_module_root(&self, module_name: &[u8]) -> Option<RootId> {

        for module in self.modules.iter() {

            match &module.name {

                Some(name) => if name.as_bytes() == module_name {

                    return Some(module.root_id);

                },

                None => if module_name.is_empty() {

                    return Some(module.root_id);

                }

            }

    pub(crate) root_id: RootId,

    pub(crate) definition_id: DefinitionId,

    pub(crate) reserved_monomorph_idx: i32,

}

pub(crate) type ResolveQueue = Vec<ResolveQueueElement>;

#[derive(Clone)]

struct InferenceExpression {

    expr_type: InferenceType,       // result type from expression

    expr_id: ExpressionId,          // expression that is evaluated

    field_or_monomorph_idx: i32,    // index of field, of index of monomorph array in type table

}

impl Default for InferenceExpression {

    fn default() -> Self {

        Self{

            expr_type: InferenceType::default(),

            expr_id: ExpressionId::new_invalid(),

            field_or_monomorph_idx: -1,

            extra_data_idx: -1,

        }

    }

}

                            expr_type.display_name(&ctx.heap)

                        )

                    ));

                }

            }

            // Expression is fine, check if any extra data is attached

            if infer_expr.extra_data_idx < 0 { continue; }

            // Extra data is attached, perform typechecking and transfer

            // resolved information to the expression

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

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

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

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

            match &ctx.heap[extra_data.expr_id] {

                Expression::Call(expr) => {

                    // Check if it is not a builtin function. If not, then

                    // construct the first part of the concrete type.

                    let first_concrete_part = if expr.method == Method::UserFunction {

                        ConcreteTypePart::Function(expr.definition, extra_data.poly_vars.len() as u32)

                    } else if expr.method == Method::UserComponent {

                        ConcreteTypePart::Component(expr.definition, extra_data.poly_vars.len() as u32)

                if self.in_use[in_use_index] {

                    section.hash(state);

                }

                in_use_index += 1;

            }

        }

    }

}

impl PartialEq for MonomorphKey {

    fn eq(&self, other: &Self) -> bool {

        if self.in_use.is_empty() {

        } else {

            // Outer type does not match

            if self.parts[0] != other.parts[0] {

                return false;

            }

            debug_assert_eq!(self.parts[0].num_embedded() as usize, self.in_use.len());

            let mut iter_self = ConcreteTypeIter::new(self.parts.as_slice(), 0);

            let mut iter_other = ConcreteTypeIter::new(other.parts.as_slice(), 0);

            let mut index = 0;

            while let Some(section_self) = iter_self.next() {

                let section_other = iter_other.next().unwrap();

    // boilerplate. I opted for the `UnsafeCell` instead of the boilerplate.

    key: UnsafeCell<MonomorphKey>,

}

impl MonomorphTable {

    fn new() -> Self {

        return Self {

            lookup: HashMap::with_capacity(256),

            monomorphs: Vec::with_capacity(256),

            key: UnsafeCell::new(MonomorphKey{

                parts: Vec::with_capacity(32),

                in_use: Vec::with_capacity(32),

        }

    }

    fn insert_with_zero_size_and_alignment(&mut self, concrete_type: ConcreteType, in_use: &[PolymorphicVariable], variant: MonomorphVariant) -> i32 {

        let key = MonomorphKey{

            parts: Vec::from(concrete_type.parts.as_slice()),

            in_use: in_use.iter().map(|v| v.is_in_use).collect(),

        };

        let index = self.monomorphs.len();

        let _result = self.lookup.insert(key, index as i32);

        debug_assert!(_result.is_none()); // did not exist yet

        self.monomorphs.push(TypeMonomorph{

            concrete_type,

            size: 0,

            alignment: 0,

            variant,

        });

        return index as i32;

    }

    fn get_monomorph_index(&self, parts: &[ConcreteTypePart], in_use: &[PolymorphicVariable]) -> Option<i32> {

        let key = unsafe {

            let key = &mut *self.key.get();

            key.parts.clear();

            key.parts.extend_from_slice(parts);

            key.in_use.clear();

            key.in_use.extend(in_use.iter().map(|v| v.is_in_use));

            &*key

        };

        match self.lookup.get(key) {

            Some(index) => return Some(*index),

            None => return None,

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

        }

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

        self.type_lookup.insert(definition_id, DefinedType{

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Component(ComponentType{ variant: definition.variant, arguments }),

            poly_vars,

            is_polymorph

        });

                        MemoryLayoutResult::PushBreadcrumb(new_breadcrumb) => {

                            self.memory_layout_breadcrumbs[cur_breadcrumb_idx] = breadcrumb;

                            self.memory_layout_breadcrumbs.push(new_breadcrumb);

                            continue 'breadcrumb_loop;

                        },

                    }

                    breadcrumb.next_member += 1;

                }

                // If here then we can compute the memory layout of the tuple.

                let mut cur_offset = 0;

                let mono_info = self.mono_lookup.get_mut(breadcrumb.monomorph_idx);

                let mono_tuple = mono_info.variant.as_tuple_mut();

                let mut size_alignment_index = breadcrumb.first_size_alignment_idx;

                for member_index in 0..num_members {

                    let (member_size, member_alignment) = self.size_alignment_stack[size_alignment_index];

                    align_offset_to(&mut cur_offset, member_alignment);

                    size_alignment_index += 1;

                    let member = &mut mono_tuple.members[member_index];

                    member.size = member_size;

                    member.alignment = member_alignment;

        "single tuple arg",

        "

        union Option<T>{ Some(T), None }

        func thing() -> u32 {

            auto a = Option<()>::None;

            auto b = Option<(u32, u64)>::None;

            auto c = Option<(Option<(u8, s8)>, Option<(s8, u8)>)>::None;

            return 0;

        }

        "

    ).for_union("Option", |u| { u

        .assert_has_monomorph("Option<()>")

    });

}

#[test]

fn test_incorrect_tuple_polymorph_args() {

}

#[test]

fn test_polymorph_array_types() {

    Tester::new_single_source_expect_ok(

        "array of polymorph in struct",

        "

        struct Foo<T> { T[] hello }

        struct Bar { Foo<u32>[] world }

        "

    ).for_struct("Bar", |s| { s

        .for_field("world", |f| { f.assert_parser_type("Foo<u32>[]"); });

        let first_idx = full_buffer.len();

        full_buffer.push_str(concrete_type.display_name(ctx.heap).as_str());

        if &full_buffer[first_idx..] == serialized_monomorph {

            has_match = Some(mono_idx as i32);

        }

        full_buffer.push('"');

    };

    // Bit wasteful, but this is (temporary?) testing code:

    for (mono_idx, mono) in ctx.types.mono_lookup.monomorphs.iter().enumerate() {

    }

    full_buffer.push(']');

    (has_match, full_buffer)

}

fn serialize_parser_type(buffer: &mut String, heap: &Heap, parser_type: &ParserType) {

    use ParserTypeVariant as PTV;

    fn serialize_variant(buffer: &mut String, heap: &Heap, parser_type: &ParserType, mut idx: usize) -> usize {

        match &parser_type.elements[idx].variant {