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)

            },

        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

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

        });

                        },

                        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 {

                    if field.field_idx == FIELD_NOT_FOUND_SENTINEL {

                        return Err(ParseError::new_error(

                            &ctx.module.source, field.identifier.position,

                            &format!(

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

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

                            )

                        ));

                    }

                    // Check if specified more than once

                    if specified[field.field_idx] {

                        return Err(ParseError::new_error(

                            &ctx.module.source, field.identifier.position,

                            "This field is specified more than once"

                        ));

                    }

                    specified[field.field_idx] = true;

                }

                if !specified.iter().all(|v| *v) {

                    // Some fields were not specified

                    let mut not_specified = String::new();

                    for (def_field_idx, is_specified) in specified.iter().enumerate() {

                        if !is_specified {

                            if !not_specified.is_empty() { not_specified.push_str(", ") }

                            let field_ident = &definition.fields[def_field_idx].identifier;

                            not_specified.push_str(&String::from_utf8_lossy(&field_ident.value));

                        }

                    }

                    return Err(ParseError::new_error(

                    ));

                }

                // Need to traverse fields expressions in struct and evaluate

                // the poly args

                let old_num_exprs = self.expression_buffer.len();

                self.expression_buffer.extend(literal.fields.iter().map(|v| v.value));

                let new_num_exprs = self.expression_buffer.len();

                self.visit_literal_poly_args(ctx, id)?;

                for expr_idx in old_num_exprs..new_num_exprs {

                    let expr_id = self.expression_buffer[expr_idx];

                    self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);

                    self.visit_expr(ctx, expr_id)?;

                }

                self.expression_buffer.truncate(old_num_exprs);

            },

            Literal::Enum(literal) => {

                // TODO: @tokenizer, remove this horrible hack once we have a 

                //  tokenizer and can distinguish types during AST-construction.

                //  For now see this horrible hack and weep!

                let (symbol, _) = ctx.symbols.resolve_namespaced_identifier(

                        let variant = String::from_utf8_lossy(variant_ident).to_string();

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

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

                        return Err(ParseError::new_error(

                            &ctx.module.source, literal.identifier.position,

                            &format!(

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

                                &variant, &String::from_utf8_lossy(&union_definition.identifier.value)

                            )

                        ));

                    }

                }

                // Make sure the number of specified values matches the expected

                // number of embedded values in the union variant.

                let union_variant = &union_definition.variants[literal.variant_idx];

                if union_variant.embedded.len() != literal.values.len() {

                    // Reborrow

                    let variant = String::from_utf8_lossy(variant_ident).to_string();

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

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

                    return Err(ParseError::new_error(

                        &ctx.module.source, literal.identifier.position,

                        &format!(

                            variant, &String::from_utf8_lossy(&union_definition.identifier.value),

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

                        ),

                    ))

                }

                // Traverse embedded values of union (if any) and evaluate the

                // polymorphic arguments

                let old_num_exprs = self.expression_buffer.len();

                self.expression_buffer.extend(&literal.values);

                let new_num_exprs = self.expression_buffer.len();

                self.visit_literal_poly_args(ctx, id)?;

                for expr_idx in old_num_exprs..new_num_exprs {

                    let expr_id = self.expression_buffer[expr_idx];

                    self.expr_parent = ExpressionParent::Expression(upcast_id, expr_idx as u32);

                    self.visit_expr(ctx, expr_id)?;

                }

                self.expression_buffer.truncate(old_num_exprs);

            }

        }

        .assert_ctx_has(0, "Pair{ first: first_arg, second: second_arg }")

        .assert_occurs_at(0, "Pair{")

        .assert_msg_has(0, "Conflicting type for polymorphic variable 'T'")

        .assert_occurs_at(1, "second_arg")

        .assert_msg_has(1, "inferred it to 'long'")

        .assert_occurs_at(2, "first_arg")

        .assert_msg_has(2, "inferred it to 'byte'");

    });

    // Cannot really test literal inference error, but this comes close

    Tester::new_single_source_expect_err(

        "enum literal inference mismatch",

        "

        enum Uninteresting<T>{ Variant }

        int fix_t<T>(Uninteresting<T> arg) { return 0; }

        int call() {

            auto a = Uninteresting::Variant;

            fix_t<byte>(a);

            fix_t<int>(a);

            return 4;

        }

        "

    ).error(|e| { e

        .assert_num(2)

    });

    Tester::new_single_source_expect_err(

        "field access inference mismatch",

        "

        struct Holder<Shazam>{ Shazam a }

        int call() {

            byte to_hold = 0;

            auto holder = Holder{ a: to_hold };

            return holder.a;

        }

        "

    ).error(|e| { e

        .assert_num(3)

        .assert_ctx_has(0, "holder.a")

        .assert_occurs_at(0, ".")

        .assert_msg_has(0, "Conflicting type for polymorphic variable 'Shazam'")

        .assert_msg_has(1, "inferred it to 'byte'")

        .assert_msg_has(2, "inferred it to 'int'");

    });

    // TODO: Needs better error messages anyway, but this failed before

    Tester::new_single_source_expect_err(

        "nested field access inference mismatch",

    );

    Tester::new_single_source_expect_ok(

        "multiple fields, different explicit polymorph",

        "

        struct Pair<T1, T2>{ T1 first, T2 second }

        int bar(int arg1, byte arg2) {

            auto shoo = Pair<int, byte>{ first: arg1, second: arg2 };

            return arg1;

        }

        "

    );

    Tester::new_single_source_expect_ok(

        "multiple fields, different implicit polymorph",

        "

        struct Pair<T1, T2>{ T1 first, T2 second }

        int bar(int arg1, byte arg2) {

            auto shrubbery = Pair{ first: arg1, second: arg2 };

            return arg1;

        }

        "

    );

}

        self

    }

    pub(crate) fn assert_ctx_has(self, idx: usize, msg: &str) -> Self {

        assert!(

            self.error.statements[idx].context.contains(msg),

            "[{}] expected error statement {}'s context to contain '{}' for {}",

            self.test_name, idx, msg, self.assert_postfix()

        );

        self

    }

    pub(crate) fn assert_msg_has(self, idx: usize, msg: &str) -> Self {

        assert!(

            self.error.statements[idx].message.contains(msg),

            "[{}] expected error statement {}'s message to contain '{}' for {}",

            self.test_name, idx, msg, self.assert_postfix()

        );

        self

    }

    /// Seeks the index of the pattern in the context message, then checks if

    /// the input position corresponds to that index.

    pub (crate) fn assert_occurs_at(self, idx: usize, pattern: &str) -> Self {

        let pos = self.error.statements[idx].context.find(pattern);

        assert!(

            pos.is_some(),

            "[{}] incorrect occurs_at: '{}' could not be found in the context for {}",

            self.test_name, pattern, self.assert_postfix()

        );

        let pos = pos.unwrap();

        let col = self.error.statements[idx].position.col();

        assert_eq!(

            pos + 1, col,

            "[{}] Expected error to occur at column {}, but found it at {} for {}",

            self.test_name, pos + 1, col, self.assert_postfix()

        );

        self

    }

    fn assert_postfix(&self) -> String {

        let mut v = String::new();

        v.push_str("error: [");

        for (idx, stmt) in self.error.statements.iter().enumerate() {