idx = write_concrete_part(target, heap, def_id, t, idx + 1);

                }

                target.push('>');

        }

        idx + 1

        for module_idx in 0..self.modules.len() {

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

            };

            self.pass_validation.visit_module(&mut ctx)?;

        }

        // Perform typechecking on all modules

        let mut queue = ResolveQueue::new();

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

            };

            PassTyping::queue_module_definitions(&mut ctx, &mut queue);

        };

            let top = queue.pop().unwrap();

            let mut ctx = visitor::Ctx{

                heap: &mut self.heap,

                symbols: &mut self.symbol_table,

                types: &mut self.type_table,

            };

            self.pass_typing.handle_module_definition(&mut ctx, &mut queue, top)?;

        }

    /// Performs the conversion of the inference type into a concrete type.

    /// By calling this function you must make sure that no unspecified types

    fn write_concrete_type(&self, concrete_type: &mut ConcreteType) {

        use InferenceTypePart as ITP;

        use ConcreteTypePart as CTP;

        // Make sure inference type is specified but concrete type is not yet specified

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

        concrete_type.parts.reserve(self.parts.len());

        let mut idx = 0;

}

pub(crate) struct ResolveQueueElement {

    pub(crate) root_id: RootId,

    pub(crate) definition_id: DefinitionId,

    pub(crate) reserved_monomorph_idx: i32,

}

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

#[derive(Clone)]

    // TODO: @cleanup Unsure about this, maybe a pattern will arise after

    //  a while.

    pub(crate) fn queue_module_definitions(ctx: &mut Ctx, queue: &mut ResolveQueue) {

        let root = &ctx.heap.protocol_descriptions[root_id];

        for definition_id in &root.definitions {

            let definition = &ctx.heap[*definition_id];

            };

                queue.push(ResolveQueueElement{

                    root_id,

                    definition_id: *definition_id,

                    reserved_monomorph_idx: reserved_idx,

                })

            }

    pub(crate) fn handle_module_definition(

        &mut self, ctx: &mut Ctx, queue: &mut ResolveQueue, element: ResolveQueueElement

    ) -> VisitorResult {

        self.reset();

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

        self.reserved_idx = element.reserved_monomorph_idx;

        self.resolve_types(ctx, queue)?;

        Ok(())

    }

        fn inference_type_to_concrete_type(

            ctx: &Ctx, expr_id: ExpressionId, inference: &Vec<InferenceType>,

            first_concrete_part: ConcreteTypePart,

            // Prepare storage vector

            let mut num_inference_parts = 0;

            for inference_type in inference {

                num_inference_parts += inference_type.parts.len();

            }

            // Go through all polymorphic arguments and add them to the concrete

            // types.

                    };

                    let poly_vars = ctx.heap[definition].poly_vars();

                    return Err(ParseError::new_error_at_span(

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

                            poly_vars[poly_idx].value.as_str(), poly_type.display_name(&ctx.heap)

                        )

                    ));

                }

                poly_type.write_concrete_type(&mut concrete_type);

            }

        }

        // Inference is now done. But we may still have uninferred types. So we

                } else {

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

                    return Err(ParseError::new_error_at_span(

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

                            expr_type.display_name(&ctx.heap)

                        )

                    };

                    let definition_id = expr.definition;

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

                    )?;

                        Some(reserved_idx) => {

                            // Already typechecked, or already put into the resolve queue

                            infer_expr.field_or_monomorph_idx = reserved_idx;

                        },

                        None => {

                            // Not typechecked yet, so add an entry in the queue

                            infer_expr.field_or_monomorph_idx = reserved_idx;

                            queue.push(ResolveQueueElement{

                                root_id: ctx.heap[definition_id].defined_in(),

                                definition_id,

                                reserved_monomorph_idx: reserved_idx,

                            });

                        }

                        _ => unreachable!(),

                    };

                    let first_concrete_part = ConcreteTypePart::Instance(definition_id, extra_data.poly_vars.len() as u32);

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

                    )?;

                    infer_expr.field_or_monomorph_idx = mono_index;

                },

                Expression::Select(_) => {

        };

        let target = ctx.types.get_procedure_expression_data_mut(&definition_id, self.reserved_idx);

        debug_assert!(target.expr_data.is_empty()); // makes sure we never queue something twice

        target.expr_data.reserve(self.expr_types.len());

                        struct_def

                    } else {

                        return Err(ParseError::new_error_at_span(

                                "Can only apply field access to structs, got a subject of type '{}'",

                                subject_type.display_name(&ctx.heap)

                            )

                    if struct_def_id.is_none() {

                        let ast_struct_def = ctx.heap[type_def.ast_definition].as_struct();

                        return Err(ParseError::new_error_at_span(

                                "this field does not exist on the struct '{}'",

                                ast_struct_def.identifier.value.as_str()

                            )

                },

                Err(()) => {

                    return Err(ParseError::new_error_at_span(

                            "Can only apply field access to structs, got a subject of type '{}'",

                            subject_type.display_name(&ctx.heap)

                        )

            let cast_expr = &ctx.heap[id];

            let subject_expr = &ctx.heap[cast_expr.subject];

            return Err(ParseError::new_error_str_at_span(

            ).with_info_at_span(

                    "cannot cast the argument type '{}' to the cast type '{}'",

                    subject_type.display_name(&ctx.heap),

                    expr_type.display_name(&ctx.heap)

        if infer_res == DualInferenceResult::Incompatible {

            let var_decl = &ctx.heap[var_id];

            return Err(ParseError::new_error_at_span(

                    "Conflicting types for this variable, previously assigned the type '{}'",

                    var_data.var_type.display_name(&ctx.heap)

                )

            ).with_info_at_span(

                    "But inferred to have incompatible type '{}' here",

                    expr_type.display_name(&ctx.heap)

                )

                        let link_decl = &ctx.heap[linked_id];

                        return Err(ParseError::new_error_at_span(

                                "Conflicting types for this variable, assigned the type '{}'",

                                var_data.var_type.display_name(&ctx.heap)

                            )

                        ).with_info_at_span(

                                "Because it is incompatible with this variable, assigned the type '{}'",

                                link_data.var_type.display_name(&ctx.heap)

                            )

            ) };

            return Err(ParseError::new_error_str_at_span(

                "failed to fully resolve the types of this expression"

            ).with_info_at_span(

                    "because the {} signature has been resolved to '{}', but the expression has been resolved to '{}'",

                    span_name, signature_display_type, expression_display_type

                )

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

        return ParseError::new_error_at_span(

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

                expr_type.display_name(&ctx.heap)

            )

        ).with_info_at_span(

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

                arg_type.display_name(&ctx.heap)

            )

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

        return ParseError::new_error_str_at_span(

            "incompatible types: cannot apply this expression"

        ).with_info_at_span(

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

                arg1_type.display_name(&ctx.heap)

            )

        ).with_info_at_span(

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

                arg2_type.display_name(&ctx.heap)

            )

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

        return ParseError::new_error_at_span(

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

                expr_type.display_name(&ctx.heap), 

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

                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(

                            "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(

                            "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(

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

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

                        )

        ) {

            return construct_main_error(ctx, poly_data, poly_idx, expr)

                .with_info_at_span(

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

                        expr_return_name,

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

                        // Same argument

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

                        return error.with_info_at_span(

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

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

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

                        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(

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

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

                            )

                        ).with_info_at_span(

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

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

                            )

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

                return construct_main_error(ctx, poly_data, poly_idx, expr)

                    .with_info_at_span(

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

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

                        )

                    )

                    .with_info_at_span(

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

                            expr_return_name,

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

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

                return construct_main_error(ctx, poly_data, poly_idx, expr)

                    .with_info_at_span(

                            "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(

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

impl Visitor for PassValidationLinking {

    fn visit_module(&mut self, ctx: &mut Ctx) -> VisitorResult {

        let section = self.definition_buffer.start_section_initialized(&root.definitions);

        for definition_idx in 0..section.len() {

            let definition_id = section[definition_idx];

        }

        section.forget();

        Ok(())

    }

    //--------------------------------------------------------------------------

            // Nested synchronous statement

            let old_sync_span = ctx.heap[self.in_sync].span;

            return Err(ParseError::new_error_str_at_span(

            ).with_info_str_at_span(

            ));

        }

        if !self.def_type.is_primitive() {

            return Err(ParseError::new_error_str_at_span(

                "synchronous statements may only be used in primitive components"

            ));

        }

        let stmt = &ctx.heap[id];

        if !self.def_type.is_function() {

            return Err(ParseError::new_error_str_at_span(

                "return statements may only appear in function bodies"

            ));

        }

            let goto_stmt = &ctx.heap[id];

            let sync_stmt = &ctx.heap[self.in_sync];

            return Err(

            );

        }

        if !self.def_type.is_composite() {

            let new_stmt = &ctx.heap[id];

            return Err(ParseError::new_error_str_at_span(

                "instantiating components may only be done in composite components"

            ));

        }

        match self.expr_parent {

            // Look at us: lying through our teeth while providing error messages.

            ExpressionParent::ExpressionStmt(_) => {},

                    "assignments are statements, and cannot be used in expressions"

        }

        let left_expr_id = assignment_expr.left;

        // Check for valid context of binding expression

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

            ));

        }

        if self.in_test_expr.is_invalid() {

            let binding_expr = &ctx.heap[id];

            return Err(ParseError::new_error_str_at_span(

                "binding expressions can only be used inside the testing expression of 'if' and 'while' statements"

            ));

        }

            let binding_expr = &ctx.heap[id];

            let previous_expr = &ctx.heap[self.in_binding_expr];

            return Err(ParseError::new_error_str_at_span(

                "nested binding expressions are not allowed"

            ).with_info_str_at_span(

                "the outer binding expression is found here"

            ));

        }

                let binding_expr = &ctx.heap[id];

                let parent_expr = &ctx.heap[seeking_parent.as_expression()];

                return Err(ParseError::new_error_str_at_span(

                    "only the logical-and operator (&&) may be applied to binding expressions"

                ).with_info_str_at_span(

                    "this was the disallowed operation applied to the result from a binding expression"

                ));

            }

            _ => {

                let binding_expr = &ctx.heap[id];

                return Err(ParseError::new_error_str_at_span(

                    "the left hand side of a binding expression may only be a variable or a literal expression"

                ));

            },

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

            ))

        }

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

            ))

        }

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

            ))

        }

        if let Some(span) = self.must_be_assignable {

            // TODO: @Slicing

            return Err(ParseError::new_error_str_at_span(

            ));

        }

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

            ))

        }

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

                        let ast_definition = &ctx.heap[literal.definition];

                        return Err(ParseError::new_error_at_span(

                                "This field does not exist on the struct '{}'",

                                ast_definition.identifier().value.as_str()

                            )

                    // Check if specified more than once

                    if specified[field.field_idx] {

                        return Err(ParseError::new_error_str_at_span(

                            "This field is specified more than once"

                        ));

                    }

                        format!("not all fields are specified, [{}] are missing", not_specified)

                    };

                    return Err(ParseError::new_error_at_span(

                    ));

                }

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

                    let ast_definition = ctx.heap[literal.definition].as_enum();

                    return Err(ParseError::new_error_at_span(

                            "the variant '{}' does not exist on the enum '{}'",

                            literal.variant.value.as_str(), ast_definition.identifier.value.as_str()

                        )

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

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

                    return Err(ParseError::new_error_at_span(

                            "the variant '{}' does not exist on the union '{}'",

                            literal.variant.value.as_str(), ast_definition.identifier.value.as_str()

                        )

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

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

                    return Err(ParseError::new_error_at_span(

                            "The variant '{}' of union '{}' expects {} embedded values, but {} were specified",

                            literal.variant.value.as_str(), ast_definition.identifier.value.as_str(),

                            union_variant.embedded.len(), literal.values.len()

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

            ))

        }

        if let Some(span) = self.must_be_assignable {

            return Err(ParseError::new_error_str_at_span(

            ))

        }

        match &mut call_expr.method {

            Method::Get => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError::new_error_str_at_span(

                        "a call to 'get' may only occur in primitive component definitions"

                    ));

                }

                if self.in_sync.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        "a call to 'get' may only occur inside synchronous blocks"

                    ));

                }

            },

            Method::Put => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError::new_error_str_at_span(

                        "a call to 'put' may only occur in primitive component definitions"

                    ));

                }

                if self.in_sync.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        "a call to 'put' may only occur inside synchronous blocks"

                    ));

                }

            },

            Method::Fires => {

                if !self.def_type.is_primitive() {

                    return Err(ParseError::new_error_str_at_span(

                        "a call to 'fires' may only occur in primitive component definitions"

                    ));

                }

                if self.in_sync.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        "a call to 'fires' may only occur inside synchronous blocks"

                    ));

                }

            Method::Length => {},

            Method::Assert => {

                if self.def_type.is_function() {

                    return Err(ParseError::new_error_str_at_span(

                        "assert statement may only occur in components"

                    ));

                }

                if self.in_sync.is_invalid() {

                    return Err(ParseError::new_error_str_at_span(

                        "assert statements may only occur inside synchronous blocks"

                    ));

                }

        if expected_wrapping_new_stmt {

            if !self.expr_parent.is_new() {

                return Err(ParseError::new_error_str_at_span(

                    "cannot call a component, it can only be instantiated by using 'new'"

                ));

            }

        } else {

            if self.expr_parent.is_new() {

                return Err(ParseError::new_error_str_at_span(

                    "only components can be instantiated, this is a function"

                ));

            }

        let num_provided_args = call_expr.arguments.len();

        if num_provided_args != num_expected_args {

            let argument_text = if num_expected_args == 1 { "argument" } else { "arguments" };

            return Err(ParseError::new_error_at_span(

                    "expected {} {}, but {} were provided",

                    num_expected_args, argument_text, num_provided_args

                )

                // then this may be the thing we're binding to.

                if self.in_binding_expr.is_invalid() || !self.in_binding_expr_lhs {

                    return Err(ParseError::new_error_str_at_span(