if !ast_definition.poly_vars.is_empty() {

            return Err(ComponentCreationError::DefinitionNotComponent);

        }

        // - check number of arguments by retrieving the one instantiated

        //   monomorph

        let concrete_type = ConcreteType{ parts: vec![ConcreteTypePart::Component(definition_id, 0)] };

        let mono_index = self.types.get_procedure_monomorph_index(&definition_id, &concrete_type.parts).unwrap();

        let mono_type = self.types.get_procedure_monomorph(mono_index);

        if mono_type.arg_types.len() != arguments.values.len() {

            return Err(ComponentCreationError::InvalidNumArguments);

        }

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

                }

            }

        }

        return None;

    }

    fn verify_same_type(&self, expected: &ConcreteType, expected_idx: usize, arguments: &ValueGroup, argument: &Value) -> bool {

        use ConcreteTypePart as CTP;

        match &expected.parts[expected_idx] {

            CTP::Void | CTP::Message | CTP::Slice | CTP::Function(_, _) | CTP::Component(_, _) => unreachable!(),

            CTP::Bool => if let Value::Bool(_) = argument { true } else { false },

            CTP::UInt8 => if let Value::UInt8(_) = argument { true } else { false },

    fn definition_id(&self) -> DefinitionId {

        match self {

            DefinitionType::Component(v) => v.upcast(),

            DefinitionType::Function(v) => v.upcast(),

        }

    }

}

pub(crate) struct ResolveQueueElement {

    // Note that using the `definition_id` and the `monomorph_idx` one may

    // query the type table for the full procedure type, thereby retrieving

    // the polymorphic arguments to the procedure.

    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,

        }

    }

}

/// This particular visitor will recurse depth-first into the AST and ensures

/// that all expressions have the appropriate types.

pub(crate) struct PassTyping {

    // Current definition we're typechecking.

    reserved_idx: i32,

    definition_type: DefinitionType,

    poly_vars: Vec<ConcreteType>,

    // Buffers for iteration over substatements and subexpressions

    stmt_buffer: Vec<StatementId>,

    expr_buffer: Vec<ExpressionId>,

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

            let expr_type = &mut infer_expr.expr_type;

            if !expr_type.is_done {

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

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

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

                    self.expr_queued.push_back(infer_expr_idx as i32);

                } else {

                    let expr = &ctx.heap[infer_expr.expr_id];

                    return Err(ParseError::new_error_at_span(

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

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

                            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)

                    } else {

                        // Builtin function

                        continue;

                    };

                    let definition_id = expr.definition;

                    let concrete_type = inference_type_to_concrete_type(

                        ctx, extra_data.expr_id, &extra_data.poly_vars, first_concrete_part

                    )?;

                    match ctx.types.get_procedure_monomorph_index(&definition_id, &concrete_type.parts) {

                        Some(reserved_idx) => {

        if self.in_use.is_empty() {

            self.parts.hash(state);

        } else {

            // type is polymorphic

            self.parts[0].hash(state);

            // note: hash is computed in a unique way, because practically

            // speaking `in_use` is fixed per base type. So we cannot have the

            // same base type (hence: a type with the same DefinitionId) with

            // different different polymorphic variables in use.

            let mut in_use_index = 0;

            for section in ConcreteTypeIter::new(self.parts.as_slice(), 0) {

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

                let in_use = self.in_use[index];

                index += 1;

                if !in_use {

                    continue;

                }

                if section_self != section_other {

                    return false;

                }

            }

pub(crate) struct MonomorphTable {

    lookup: HashMap<MonomorphKey, i32>, // indexes into `monomorphs`

    pub(crate) monomorphs: Vec<TypeMonomorph>,

    // We use an UnsafeCell because this is only used internally per call to

    // `get_monomorph_index` calls. This is safe because `&TypeMonomorph`s

    // retrieved for this class remain valid when the key is mutated and the

    // type table is not multithreaded.

    //

    // I added this because we don't want to allocate for each lookup, hence we

    // need a reusable `key` internal to this class. This in turn makes

    // `get_monomorph_index` a mutable call. Now the code that calls this

    // function (even though we're not mutating the table!) needs a lot of extra

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

        }

    }

    #[inline]

    fn get(&self, index: i32) -> &TypeMonomorph {

        debug_assert!(index >= 0);

        return &self.monomorphs[index as usize];

    }

    #[inline]

    fn get_mut(&mut self, index: i32) -> &mut TypeMonomorph {

        debug_assert!(index >= 0);

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

        }

        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

        });

        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 {

            // TODO: Same as above, replace lookup of base definition, should not

            //  be needed.

            if breadcrumb.definition_id.is_invalid() {

                // Handle tuple

                let mono_tuple = self.mono_lookup.get(breadcrumb.monomorph_idx).variant.as_tuple();

                let num_members = mono_tuple.members.len();

                while breadcrumb.next_member < num_members {

                    let mono_member = &mono_tuple.members[breadcrumb.next_member];

                    match self.get_memory_layout_or_breadcrumb(arch, &mono_member.concrete_type.parts) {

                        MemoryLayoutResult::TypeExists(size, alignment) => {

                            self.size_alignment_stack.push((size, alignment));

                        },

                        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;

                    member.offset = cur_offset;

                    cur_offset += member_size;

                    max_alignment = max_alignment.max(member_alignment);

                }

                mono_info.size = cur_offset;

                mono_info.alignment = max_alignment;

                self.size_alignment_stack.truncate(breadcrumb.first_size_alignment_idx);

            } else {

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

                match &poly_type.definition {

        "double three-tuple",

        "struct Foo{ (u8,u16,u32,) bar, (s8,s16,s32,) baz }"

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

        .for_field("bar", |f| { f.assert_parser_type("(u8,u16,u32)"); })

        .for_field("baz", |f| { f.assert_parser_type("(s8,s16,s32)"); })

        .assert_size_alignment("Foo", 16, 4);

    });

}

#[test]

fn test_correct_tuple_polymorph_args() {

    Tester::new_single_source_expect_ok(

        "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>[]"); });

    });

    Tester::new_single_source_expect_ok(

        "array of port in struct",

        "

        struct Bar { in<u32>[] inputs }

        "

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

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

    });

}

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

    // Note: full_buffer is just for error reporting

    let mut full_buffer = String::new();

    let mut has_match = None;

    full_buffer.push('[');

    let mut append_to_full_buffer = |concrete_type: &ConcreteType, mono_idx: usize| {

        if full_buffer.len() != 1 {

            full_buffer.push_str(", ");

        }

        full_buffer.push('"');

        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 {

            PTV::Void => buffer.push_str("void"),

            PTV::InputOrOutput => {

                buffer.push_str("portlike<");

                idx = serialize_variant(buffer, heap, parser_type, idx + 1);

                buffer.push('>');

            },

            PTV::ArrayLike => {

                idx = serialize_variant(buffer, heap, parser_type, idx + 1);

                buffer.push_str("[???]");

            },

            PTV::IntegerLike => buffer.push_str("integerlike"),

            PTV::Message => buffer.push_str(KW_TYPE_MESSAGE_STR),