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

                } else {

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

                    return Err(ParseError::new_error(

                        &ctx.module.source, expr.position(),

                        &format!(

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

                            expr_type.display_name(&ctx.heap)

                        )

                    ))

                }

            }

            if !already_checked {

                let concrete_type = ctx.heap[*expr_id].get_type_mut();

                expr_type.write_concrete_type(concrete_type);

            } else {

                if cfg!(debug_assertions) {

                    let mut concrete_type = ConcreteType::default();

                    expr_type.write_concrete_type(&mut concrete_type);

                    debug_assert_eq!(*ctx.heap[*expr_id].get_type(), concrete_type);

                }

            }

        }

        // All types are fine

        ctx.types.add_monomorph(&definition_id, self.poly_vars.clone());

        // Check all things we need to monomorphize

        // TODO: Struct/enum/union monomorphization

        for (expr_id, extra_data) in self.extra_data.iter() {

            if extra_data.poly_vars.is_empty() { continue; }

            // Retrieve polymorph variable specification. Those of struct 

            // literals and those of procedure calls need to be fully inferred.

            // The remaining ones (e.g. select expressions) allow partial 

            // inference of types, as long as the accessed field's type is

            // fully inferred.

            let needs_full_inference = match &ctx.heap[*expr_id] {

                Expression::Call(_) => true,

                Expression::Literal(_) => true,

                _ => false

            };

            if needs_full_inference {

                let mut monomorph_types = Vec::with_capacity(extra_data.poly_vars.len());

                for (poly_idx, poly_type) in extra_data.poly_vars.iter().enumerate() {

                    if !poly_type.is_done {

                        // TODO: Single clean function for function signatures and polyvars.

                        // TODO: Better error message

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

                        return Err(ParseError::new_error(

                            &ctx.module.source, expr.position(),

                            &format!(

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

                                poly_idx, poly_type.display_name(&ctx.heap)

                            )

                        ))

                    }

                    let mut concrete_type = ConcreteType::default();

                    poly_type.write_concrete_type(&mut concrete_type);

                    monomorph_types.insert(poly_idx, concrete_type);

                }

                // Resolve to the appropriate expression and instantiate 

                // monomorphs.

                match &ctx.heap[*expr_id] {

                    Expression::Call(call_expr) => {

                        // Add to type table if not yet typechecked

                        if let Method::Symbolic(symbolic) = &call_expr.method {

                            let definition_id = symbolic.definition.unwrap();

                            if !ctx.types.has_monomorph(&definition_id, &monomorph_types) {

                                let root_id = ctx.types

                                    .get_base_definition(&definition_id)

                                    .unwrap()

                                    .ast_root;

                                // Pre-emptively add the monomorph to the type table, but

                                // we still need to perform typechecking on it

                                // TODO: Unsure about this, performance wise

                                let queue_element = ResolveQueueElement{

                                    root_id,

                                    definition_id,

                                    monomorph_types,

                                };

                                if !queue.contains(&queue_element) {

                                    queue.push(queue_element);

                                }

                            }

                        }

                    },

                    Expression::Literal(lit_expr) => {

                        let definition_id = match &lit_expr.value {

                            Literal::Struct(literal) => literal.definition.as_ref().unwrap(),

                            Literal::Enum(literal) => literal.definition.as_ref().unwrap(),

                            _ => unreachable!("post-inference monomorph for non-struct, non-enum literal")

                        };

                        if !ctx.types.has_monomorph(definition_id, &monomorph_types) {

                            ctx.types.add_monomorph(definition_id, monomorph_types);

                        }

                    },

                    _ => unreachable!("needs fully inference, but not a struct literal or call expression")

                }

            } // else: was just a helper structure...

        }

        Ok(())

    }

    fn progress_expr(&mut self, ctx: &mut Ctx, id: ExpressionId) -> Result<(), ParseError> {

        match &ctx.heap[id] {

            Expression::Assignment(expr) => {

                let id = expr.this;

                self.progress_assignment_expr(ctx, id)

            },

            Expression::Conditional(expr) => {

                let id = expr.this;

                self.progress_conditional_expr(ctx, id)

            },

            Expression::Binary(expr) => {

                let id = expr.this;

                self.progress_binary_expr(ctx, id)

            },

            Expression::Unary(expr) => {

                let id = expr.this;

                self.progress_unary_expr(ctx, id)

            },

            Expression::Indexing(expr) => {

                let id = expr.this;

                self.progress_indexing_expr(ctx, id)

            },

            Expression::Slicing(expr) => {

                let id = expr.this;

                self.progress_slicing_expr(ctx, id)

            },

            Expression::Select(expr) => {

                let id = expr.this;

                self.progress_select_expr(ctx, id)

            },

            Expression::Array(expr) => {

                let id = expr.this;

                self.progress_array_expr(ctx, id)

            },

            Expression::Literal(expr) => {

                let id = expr.this;

                self.progress_literal_expr(ctx, id)

            },

            Expression::Call(expr) => {

                let id = expr.this;

                self.progress_call_expr(ctx, id)

            },

            Expression::Variable(expr) => {

                let id = expr.this;

                self.progress_variable_expr(ctx, id)

            }

        }

    }

    fn progress_assignment_expr(&mut self, ctx: &mut Ctx, id: AssignmentExpressionId) -> Result<(), ParseError> {

        use AssignmentOperator as AO;

        // TODO: Assignable check

        let upcast_id = id.upcast();

        let expr = &ctx.heap[id];

        let arg1_expr_id = expr.left;

        let arg2_expr_id = expr.right;

        debug_log!("Assignment expr '{:?}': {}", expr.operation, upcast_id.index);

        debug_log!(" * Before:");

        debug_log!("   - Arg1 type: {}", self.expr_types.get(&arg1_expr_id).unwrap().display_name(&ctx.heap));

        debug_log!("   - Arg2 type: {}", self.expr_types.get(&arg2_expr_id).unwrap().display_name(&ctx.heap));

        debug_log!("   - Expr type: {}", self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

        let progress_base = match expr.operation {

            AO::Set =>

                false,

            AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>

                self.apply_forced_constraint(ctx, upcast_id, &NUMBERLIKE_TEMPLATE)?,

            AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |

            AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>

                self.apply_forced_constraint(ctx, upcast_id, &INTEGERLIKE_TEMPLATE)?,

        };

        let (progress_expr, progress_arg1, progress_arg2) = self.apply_equal3_constraint(

            ctx, upcast_id, arg1_expr_id, arg2_expr_id, 0

        )?;

        debug_log!(" * After:");

        debug_log!("   - Arg1 type [{}]: {}", progress_arg1, self.expr_types.get(&arg1_expr_id).unwrap().display_name(&ctx.heap));

        debug_log!("   - Arg2 type [{}]: {}", progress_arg2, self.expr_types.get(&arg2_expr_id).unwrap().display_name(&ctx.heap));

        debug_log!("   - Expr type [{}]: {}", progress_base || progress_expr, self.expr_types.get(&upcast_id).unwrap().display_name(&ctx.heap));

        // - 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_vars.len() + total_num_poly_parts;

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

        parts.push(ITP::Instance(definition.this.upcast(), poly_vars.len()));

        let mut return_type_done = true;

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

            if !poly_var.is_done { return_type_done = false; }

            parts.push(ITP::MarkerBody(poly_var_idx));

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

        }

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

        let return_type = InferenceType::new(!poly_vars.is_empty(), return_type_done, parts);

        self.extra_data.insert(lit_id.upcast(), ExtraData{

            poly_vars, 

            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].value.as_enum();

        // Handle polymorphic arguments to the enum

        let mut poly_vars = Vec::with_capacity(literal.poly_args2.len());

        let mut total_num_poly_parts = 0;

        for poly_arg_type_id in literal.poly_args2.clone() { // TODO: @performance

            let inference_type = self.determine_inference_type_from_parser_type(

                ctx, poly_arg_type_id, true

            );

            total_num_poly_parts += inference_type.parts.len();

            poly_vars.push(inference_type);

        }

        // Handle enum type itself

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

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

        parts.push(ITP::Instance(literal.definition.unwrap(), poly_vars.len()));

        let mut enum_type_done = true;

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

            if !poly_var.is_done { enum_type_done = false; }

            parts.push(ITP::MarkerBody(poly_var_idx));

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

        }

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

        let enum_type = InferenceType::new(!poly_vars.is_empty(), enum_type_done, parts);

        self.extra_data.insert(lit_id.upcast(), ExtraData{

            poly_vars,

            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].value.as_union();

        // Construct the polymorphic variables

        let mut poly_vars = Vec::with_capacity(literal.poly_args2.len());

        let mut total_num_poly_parts = 0;

        for poly_arg_type_id in literal.poly_args2.clone() { // TODO: @performance

            let inference_type = self.determine_inference_type_from_parser_type(

                ctx, poly_arg_type_id, true

            );

            total_num_poly_parts += inference_type.parts.len();

            poly_vars.push(inference_type);

        }

        // Handle any of the embedded values in the variant, if specified

        let definition_id = literal.definition.unwrap();

        let union_definition = ctx.types.get_base_definition(&definition_id)

            .unwrap()

            .definition.as_union();

        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_id in &variant_definition.embedded {

            let inference_type = self.determine_inference_type_from_parser_type(

            );

            embedded.push(inference_type);

        }

        // Handle the type of the union itself

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

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

        parts.push(ITP::Instance(definition_id, poly_vars.len()));

        let mut union_type_done = true;

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

            if !poly_var.is_done { union_type_done = false; }

            parts.push(ITP::MarkerBody(poly_var_idx));

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

        }

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

        let union_type = InferenceType::new(!poly_vars.is_empty(), union_type_done, parts);

        self.extra_data.insert(lit_id.upcast(), ExtraData{

            poly_vars,

            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

    ) {

        use InferenceTypePart as ITP;

        // Retrieve relevant data

        let expr = &ctx.heap[select_id];

        let field = expr.field.as_symbolic();

        let definition_id = field.definition.unwrap();

        let definition = ctx.heap[definition_id].as_struct();

        let field_idx = field.field_idx;

        // Generate initial polyvar types and 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(definition_id, num_poly_vars));        

        for poly_idx in 0..num_poly_vars {

            poly_vars.push(InferenceType::new(true, false, vec![

                ITP::MarkerBody(poly_idx), ITP::Unknown,

            ]));

            struct_parts.push(ITP::MarkerBody(poly_idx));

            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(

            ctx, definition.fields[field_idx].parser_type, false

        );

        self.extra_data.insert(select_id.upcast(), ExtraData{

            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(

        &mut self, ctx: &Ctx, parser_type_id: ParserTypeId,

        parser_type_in_body: bool

    ) -> InferenceType {

        use ParserTypeVariant as PTV;

        use InferenceTypePart as ITP;

        let mut to_consider = VecDeque::with_capacity(16);

        to_consider.push_back(parser_type_id);

        let mut infer_type = Vec::new();

        let mut has_inferred = false;

        let mut has_markers = false;

        while !to_consider.is_empty() {

            let parser_type_id = to_consider.pop_front().unwrap();

            let parser_type = &ctx.heap[parser_type_id];

            match &parser_type.variant {

                PTV::Message => {

                    // TODO: @types Remove the Message -> Byte hack at some point...

                    infer_type.push(ITP::Message);

                    infer_type.push(ITP::Byte);

                },

                PTV::Bool => { infer_type.push(ITP::Bool); },

                PTV::Byte => { infer_type.push(ITP::Byte); },

                PTV::Short => { infer_type.push(ITP::Short); },

                PTV::Int => { infer_type.push(ITP::Int); },

                PTV::Long => { infer_type.push(ITP::Long); },

                PTV::String => { infer_type.push(ITP::String); },

                PTV::IntegerLiteral => { unreachable!("integer literal type on variable type"); },

                PTV::Inferred => {

                    infer_type.push(ITP::Unknown);

                    has_inferred = true;

                },

                PTV::Array(subtype_id) => {

                    infer_type.push(ITP::Array);

                    to_consider.push_front(*subtype_id);

                },

                PTV::Input(subtype_id) => {

                    infer_type.push(ITP::Input);

                    to_consider.push_front(*subtype_id);

                },

                PTV::Output(subtype_id) => {

                    infer_type.push(ITP::Output);

                    to_consider.push_front(*subtype_id);

                },

                PTV::Symbolic(symbolic) => {

                    debug_assert!(symbolic.variant.is_some(), "symbolic variant not yet determined");

                    match symbolic.variant.as_ref().unwrap() {

                        SymbolicParserTypeVariant::PolyArg(_, arg_idx) => {

                            let arg_idx = *arg_idx;

                            debug_assert!(symbolic.poly_args2.is_empty()); // TODO: @hkt

                            if parser_type_in_body {

                                // Polymorphic argument refers to definition's

                                // polymorphic variables

                                debug_assert!(arg_idx < self.poly_vars.len());

                                debug_assert!(!self.poly_vars[arg_idx].has_marker());

                                infer_type.push(ITP::MarkerDefinition(arg_idx));

                                for concrete_part in &self.poly_vars[arg_idx].parts {

                                    infer_type.push(ITP::from(*concrete_part));

                                }

                            } else {

                                // Polymorphic argument has to be inferred

                                has_markers = true;

                                has_inferred = true;

                                infer_type.push(ITP::MarkerBody(arg_idx));

                                infer_type.push(ITP::Unknown);

                            }

                        },

                        SymbolicParserTypeVariant::Definition(definition_id) => {

                            // TODO: @cleanup

                            if cfg!(debug_assertions) {

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

                                let num_poly = match definition {

                                    Definition::Struct(v) => v.poly_vars.len(),

                                    Definition::Enum(v) => v.poly_vars.len(),

                                    _ => unreachable!(),

                                };

                                debug_assert_eq!(symbolic.poly_args2.len(), num_poly);

                            }

                            infer_type.push(ITP::Instance(*definition_id, symbolic.poly_args2.len()));

                            let mut poly_arg_idx = symbolic.poly_args2.len();

                            while poly_arg_idx > 0 {

                                poly_arg_idx -= 1;

                                to_consider.push_front(symbolic.poly_args2[poly_arg_idx]);

                            }

                        }

                    }

                }

            }

        }

        InferenceType::new(has_markers, !has_inferred, infer_type)

    }

    /// 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_type = self.expr_types.get(&expr_id).unwrap();

        let arg_type = self.expr_types.get(&arg_id).unwrap();

        return ParseError::new_error(

            &ctx.module.source, expr.position(),

            &format!(

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

                expr_type.display_name(&ctx.heap)

            )

        ).with_postfixed_info(

            &ctx.module.source, arg_expr.position(),

            &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_type = self.expr_types.get(&arg1_id).unwrap();

        let arg2_type = self.expr_types.get(&arg2_id).unwrap();

        return ParseError::new_error(

            &ctx.module.source, expr.position(),

            "Incompatible types: cannot apply this expression"

        ).with_postfixed_info(

            &ctx.module.source, arg1.position(),

            &format!(

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

                arg1_type.display_name(&ctx.heap)

            )

        ).with_postfixed_info(

            &ctx.module.source, arg2.position(),

            &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_type = self.expr_types.get(&expr_id).unwrap();

        return ParseError::new_error(

            &ctx.module.source, expr.position(),

            &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 

        let mut variants = Vec::with_capacity(definition.variants.len());

        for variant in &definition.variants {

            enum_value += 1;

            match &variant.value {

                EnumVariantValue::None => {

                    variants.push(EnumVariant{

                        identifier: variant.identifier.clone(),

                        value: enum_value,

                    });

                },

                EnumVariantValue::Integer(override_value) => {

                    enum_value = *override_value;

                    variants.push(EnumVariant{

                        identifier: variant.identifier.clone(),

                        value: enum_value,

                    });

                }

            }

            if enum_value < min_enum_value { min_enum_value = enum_value; }

            else if enum_value > max_enum_value { max_enum_value = enum_value; }

        }

        // Ensure enum names and polymorphic args do not conflict

        self.check_identifier_collision(

            ctx, root_id, &variants, |variant| &variant.identifier, "enum variant"

        )?;

        self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;

        // Note: although we cannot have embedded type dependent on the

        // polymorphic variables, they might still be present as tokens

        let definition_id = definition.this.upcast();

        self.lookup.insert(definition_id, DefinedType {

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Enum(EnumType{

                variants,

                representation: Self::enum_tag_type(min_enum_value, max_enum_value)

            }),

            poly_vars: self.create_initial_poly_vars(&definition.poly_vars),

            is_polymorph: false,

            is_pointerlike: false,

            monomorphs: Vec::new()

        });

        Ok(true)

    }

    /// Resolves the basic union definiton to an entry in the type table. It

    /// will not instantiate any monomorphized instances of polymorphic union

    /// definitions. If a subtype has to be resolved first then this function

    /// will return `false` after calling `ingest_resolve_result`.

    fn resolve_base_union_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError> {

        debug_assert!(ctx.heap[definition_id].is_union());

        debug_assert!(!self.lookup.contains_key(&definition_id), "base union already resolved");

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

        // Make sure all embedded types are resolved

        for variant in &definition.variants {

            match &variant.value {

                UnionVariantValue::None => {},

                UnionVariantValue::Embedded(embedded) => {

                    for embedded_id in embedded {

                        let resolve_result = self.resolve_base_parser_type(ctx, &definition.poly_vars, root_id, *embedded_id)?;

                        if !self.ingest_resolve_result(ctx, resolve_result)? {

                            return Ok(false)

                        }

                    }

                }

            }

        }

        // If here then all embedded types are resolved

        // Determine the union variants

        let mut tag_value = -1;

        let mut variants = Vec::with_capacity(definition.variants.len());

        for variant in &definition.variants {

            tag_value += 1;

            let embedded = match &variant.value {

                UnionVariantValue::None => { Vec::new() },

                UnionVariantValue::Embedded(embedded) => {

                    // Type should be resolvable, we checked this above

                    embedded.clone()

                },

            };

            variants.push(UnionVariant{

                identifier: variant.identifier.clone(),

                embedded,

                tag_value,

            })

        }

        // Ensure union names and polymorphic args do not conflict

        self.check_identifier_collision(

        )?;

        self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;

        let mut poly_args = self.create_initial_poly_vars(&definition.poly_vars);

        for variant in &variants {

            for embedded_id in &variant.embedded {

                self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, *embedded_id)?;

            }

        }

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

        // Insert base definition in type table

        self.lookup.insert(definition_id, DefinedType {

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Union(UnionType{

                variants,

                tag_representation: Self::enum_tag_type(-1, tag_value),

            }),

            poly_vars: poly_args,

            is_polymorph,

            is_pointerlike: false, // TODO: @cyclic_types

            monomorphs: Vec::new()

        });

        Ok(true)

    }

    /// Resolves the basic struct definition to an entry in the type table. It

    /// will not instantiate any monomorphized instances of polymorphic struct

    /// definitions.

    fn resolve_base_struct_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError> {

        debug_assert!(ctx.heap[definition_id].is_struct());

        debug_assert!(!self.lookup.contains_key(&definition_id), "base struct already resolved");

        let definition = ctx.heap[definition_id].as_struct();

        // Make sure all fields point to resolvable types

        for field_definition in &definition.fields {

            let resolve_result = self.resolve_base_parser_type(ctx, &definition.poly_vars, root_id, field_definition.parser_type)?;

            if !self.ingest_resolve_result(ctx, resolve_result)? {

                return Ok(false)

            }

        }

        // All fields types are resolved, construct base type

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

        for field_definition in &definition.fields {

            fields.push(StructField{

                identifier: field_definition.field.clone(),

                parser_type: field_definition.parser_type,

            })

        }

        // And make sure no conflicts exist in field names and/or polymorphic args

        self.check_identifier_collision(

            ctx, root_id, &fields, |field| &field.identifier, "struct field"

        )?;

        self.check_poly_args_collision(ctx, root_id, &definition.poly_vars)?;

        // Construct representation of polymorphic arguments

        let mut poly_args = self.create_initial_poly_vars(&definition.poly_vars);

        for field in &fields {

            self.check_and_resolve_embedded_type_and_modify_poly_args(ctx, definition_id, &mut poly_args, root_id, field.parser_type)?;

        }

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

        self.lookup.insert(definition_id, DefinedType{

            ast_root: root_id,

            ast_definition: definition_id,

            definition: DefinedTypeVariant::Struct(StructType{

                fields,

            }),

            poly_vars: poly_args,

            is_polymorph,

            is_pointerlike: false, // TODO: @cyclic

            monomorphs: Vec::new(),

        });

        Ok(true)

    }

    /// Resolves the basic function definition to an entry in the type table. It

    /// will not instantiate any monomorphized instances of polymorphic function

    /// definitions.

    fn resolve_base_function_definition(&mut self, ctx: &mut TypeCtx, root_id: RootId, definition_id: DefinitionId) -> Result<bool, ParseError> {

        debug_assert!(ctx.heap[definition_id].is_function());

        debug_assert!(!self.lookup.contains_key(&definition_id), "base function already resolved");

        let definition = ctx.heap[definition_id].as_function();

        let return_type = definition.return_type;

        // Check the return type

        let resolve_result = self.resolve_base_parser_type(

            ctx, &definition.poly_vars, root_id, definition.return_type

        'resolve_loop: while let Some(parser_type_id) = self.parser_type_iter.pop_back() {

            let parser_type = &ctx.heap[parser_type_id];

            match &parser_type.variant {

                // Builtin types. An array is a builtin as it is implemented as a

                // couple of pointers, so we do not require the subtype to be fully

                // resolved. Similar for input/output ports.

                PTV::Array(_) | PTV::Input(_) | PTV::Output(_) | PTV::Message |

                PTV::Bool | PTV::Byte | PTV::Short | PTV::Int | PTV::Long |

                PTV::String => {

                    set_resolve_result(ResolveResult::BuiltIn);

                },

                // IntegerLiteral types and the inferred marker are not allowed in

                // definitions of types

                PTV::IntegerLiteral |

                PTV::Inferred => {

                    debug_assert!(false, "Encountered illegal ParserTypeVariant within type definition");

                    unreachable!();

                },

                // Symbolic type, make sure its base type, and the base types

                // of all members of the embedded type tree are resolved. We

                // don't care about monomorphs yet.

                PTV::Symbolic(symbolic) => {

                    // Check if the symbolic type is one of the definition's

                    // polymorphic arguments. If so then we can halt the

                    // execution

                    for (poly_arg_idx, poly_arg) in poly_vars.iter().enumerate() {

                        if symbolic.identifier.matches_identifier(poly_arg) {

                            set_resolve_result(ResolveResult::PolyArg(poly_arg_idx));

                            continue 'resolve_loop;

                        }

                    }

                    // Lookup the definition in the symbol table

                    let (symbol, mut ident_iter) = ctx.symbols.resolve_namespaced_identifier(root_id, &symbolic.identifier);

                    if symbol.is_none() {

                        return Err(ParseError::new_error(

                            &ctx.modules[root_id.index as usize].source, symbolic.identifier.position,

                            "Could not resolve type"

                        ))

                    }

                    let symbol_value = symbol.unwrap();

                    let module_source = &ctx.modules[root_id.index as usize].source;

                    match symbol_value.symbol {

                        Symbol::Namespace(_) => {

                            // Reference to a namespace instead of a type

                            let last_ident = ident_iter.prev();

                            return if ident_iter.num_remaining() == 0 {

                                // Could also have polymorphic args, but we 

                                // don't care, just throw this error: 

                                Err(ParseError::new_error(

                                    module_source, symbolic.identifier.position,

                                    "Expected a type, got a module name"

                                ))

                            } else if last_ident.is_some() && last_ident.map(|(_, poly_args)| poly_args.is_some()).unwrap() {

                                // Halted at a namespaced because we encountered

                                // polymorphic arguments

                                Err(ParseError::new_error(

                                    module_source, symbolic.identifier.position,

                                    "Illegal specification of polymorphic arguments to a module name"

                                ))

                            } else {

                                // Impossible (with the current implementation 

                                // of the symbol table)

                                unreachable!(

                                    "Got namespace symbol with {} returned symbols from {}",

                                    ident_iter.num_returned(),

                                    &String::from_utf8_lossy(&symbolic.identifier.value)

                                );

                            }

                        },

                        Symbol::Definition((root_id, definition_id)) => {

                            let definition = &ctx.heap[definition_id];

                            if ident_iter.num_remaining() > 0 {

                                // Namespaced identifier is longer than the type

                                // we found. Return the appropriate message

                                return if definition.is_struct() || definition.is_enum() {

                                    Err(ParseError::new_error(

                                        module_source, symbolic.identifier.position,

                                        &format!(

                                            "Unknown type '{}', did you mean to use '{}'?",

                                            String::from_utf8_lossy(&symbolic.identifier.value),

                                            String::from_utf8_lossy(&definition.identifier().value)

                                        )

                                    ))

                                } else {

                                    Err(ParseError::new_error(

                                        module_source, symbolic.identifier.position,

                                        "Unknown datatype"

                                    ))

                                }

                            }

                            // Found a match, make sure it is a datatype

                                return Err(ParseError::new_error(

                                    module_source, symbolic.identifier.position,

                                    "Embedded types must be datatypes (structs or enums)"

                                ))

                            }

                            // Found a struct/enum definition

                            if !self.lookup.contains_key(&definition_id) {

                                // Type is not yet resoled, immediately return

                                // this

                                return Ok(ResolveResult::Unresolved((root_id, definition_id)));

                            }

                            // Type is resolved, so set as result, but continue

                            // iterating over the parser types in the embedded

                            // type's tree

                            set_resolve_result(ResolveResult::Resolved((root_id, definition_id)));

                            // Note: because we're resolving parser types, not

                            // embedded types, we're parsing a tree, so we can't

                            // get stuck in a cyclic loop.

                            let last_ident = ident_iter.prev();

                            if let Some((_, Some(poly_args))) = last_ident {

                                for poly_arg_type_id in poly_args {

                                    self.parser_type_iter.push_back(*poly_arg_type_id);