self.consume_string(b"::")?;

///     slightly more specific: initially it seemed that expressions just need 

///     to apply constraints between their expression types and the expression

///     types of the arguments. But it seems to appear more-and-more that the 

///     expressions may need their own little datastructures. Using some kind of

///     scratch allocator and proper considerations for dependencies might lead 

///     to a much more efficient algorithm

use crate::protocol::parser::type_table::*;

    // TODO: @rename to something appropriate, I keep confusing myself...

    /// Generates a new InferenceType. The two boolean flags will be checked in

    /// debug mode.

    /// Replaces a type subtree with the provided subtree. The caller must make

    /// sure the the replacement is a well formed type subtree.

        let end_idx = Self::find_subtree_end_idx(&self.parts, start_idx);

            *to_infer_idx += template_end_idx - *template_idx;

        let literal_expr = &ctx.heap[id];

        match &literal_expr.value {

            Literal::Null | Literal::False | Literal::True |

            Literal::Integer(_) | Literal::Character(_) => {

                // No subexpressions

            },

            Literal::Struct(literal) => {

                // TODO: @performance

                let expr_ids: Vec<_> = literal.fields

                    .iter()

                    .map(|f| f.value)

                    .collect();

                self.insert_initial_struct_polymorph_data(ctx, id);

                for expr_id in expr_ids {

                    self.visit_expr(ctx, expr_id)?;

                }

            }

        }

        self.progress_literal_expr(ctx, id)

                self.progress_literal_expr(ctx, id)

            Field::Symbolic(field) => {

                // Check if we already know the definition ID of the subject

                let mut definition_and_field = None;

                let subject_type = self.expr_types.get(&subject_id).unwrap();

                'type_loop: for part in &subject_type.parts {

                    if part.is_marker() || !part.is_concrete() { continue; }

                    if let InferenceTypePart::Instance(definition_id, _) = part {

                        // Make sure we're accessing a struct of some sort

                        let definition_type = ctx.types.get_base_definition(definition_id).unwrap();

                        if let DefinedTypeVariant::Struct(definition) = &definition_type.definition {

                            // Make sure the struct has the specified field

                            let mut field_found = false;

                            for (def_field_idx, def_field) in definition.fields.iter().enumerate() {

                                if def_field.identifier == *field {

                                    definition_and_field = Some((*definition_id, def_field_idx));

                                    break 'type_loop;

                                }

                            }

                            // If here then field was not found

                            if !field_found {

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

                                return Err(ParseError2::new_error(

                                    &ctx.module.source, field.position,

                                    &format!(

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

                                        &String::from_utf8_lossy(&field.value),

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

                                    )

                                ))

                            }

                        }

                        // Else, fall through and complain about not being a struct

                    }

                    // Concrete part that is not an instance of a struct,

                    // select expression cannot possibly be correct

                    return Err(ParseError2::new_error(

                        &ctx.module.source, ctx.heap[subject_id].position(),

                        &format!(

                            "Expected to find a struct instance to access a field from, found a '{}'",

                            subject_type.display_name(&ctx.heap)

                        )

                    ))

                }

                // If here then we have our definition and field idx

                let (definition_id, field_idx) = definition_and_field.unwrap();

                (false, false)

    fn progress_literal_expr(&mut self, ctx: &mut Ctx, id: LiteralExpressionId) -> Result<(), ParseError2> {

        debug_log!("Literal expr: {}", upcast_id.index);

        debug_log!(" * Before:");

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

                let extra = self.extra_data.get_mut(&upcast_id).unwrap();

                let mut poly_progress = HashSet::new();

                debug_assert_eq!(extra.embedded.len(), data.fields.len());

                debug_log!(" * During (inferring types from fields and struct type):");

                // Mutually infer field signature/expression types

                for (field_idx, field) in data.fields.iter().enumerate() {

                    let field_expr_id = field.value;

                    let signature_type: *mut _ = &mut extra.embedded[field_idx];

                    let field_type: *mut _ = self.expr_types.get_mut(&field_expr_id).unwrap();

                    let (_, progress_arg) = Self::apply_equal2_signature_constraint(

                        ctx, upcast_id, Some(field_expr_id), extra, &mut poly_progress,

                        signature_type, 0, field_type, 0

                    )?;

                    debug_log!(

                        "   - Field {} type | sig: {}, field: {}", field_idx,

                        unsafe{&*signature_type}.display_name(&ctx.heap),

                        unsafe{&*field_type}.display_name(&ctx.heap)

                    );

                    if progress_arg {

                        self.expr_queued.insert(field_expr_id);

                    }

                }

                // Same for the type of the struct itself

                let signature_type: *mut _ = &mut extra.returned;

                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

                let (_, progress_expr) = Self::apply_equal2_signature_constraint(

                    ctx, upcast_id, None, extra, &mut poly_progress,

                    signature_type, 0, expr_type, 0

                )?;

                debug_log!(

                    "   - Ret type | sig: {}, expr: {}",

                    unsafe{&*signature_type}.display_name(&ctx.heap),

                    unsafe{&*expr_type}.display_name(&ctx.heap)

                );

                if progress_expr {

                    // TODO: @cleanup, cannot call utility self.queue_parent thingo

                    if let Some(parent_id) = ctx.heap[upcast_id].parent_expr_id() {

                        self.expr_queued.insert(parent_id);

                    }

                }

                // Check which expressions use the polymorphic arguments. If the

                // polymorphic variables have been progressed then we try to 

                // progress them inside the expression as well.

                debug_log!(" * During (reinferring from progressed polyvars):");

                // For all field expressions

                for field_idx in 0..extra.embedded.len() {

                    debug_assert_eq!(field_idx, data.fields[field_idx].field_idx, "confusing, innit?");

                    let signature_type: *mut _ = &mut extra.embedded[field_idx];

                    let field_expr_id = data.fields[field_idx].value;

                    let field_type: *mut _ = self.expr_types.get_mut(&field_expr_id).unwrap();

                    let progress_arg = Self::apply_equal2_polyvar_constraint(

                        extra, &poly_progress, signature_type, field_type

                    );

                    debug_log!(

                        "   - Field {} type | sig: {}, field: {}", field_idx,

                        unsafe{&*signature_type}.display_name(&ctx.heap),

                        unsafe{&*field_type}.display_name(&ctx.heap)

                    );

                    if progress_arg {

                        self.expr_queued.insert(field_expr_id);

                    }

                }

                // For the return type

                let signature_type: *mut _ = &mut extra.returned;

                let expr_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

                let progress_expr = Self::apply_equal2_polyvar_constraint(

                    extra, &poly_progress, signature_type, expr_type

                );

                progress_expr

        debug_log!(" * After:");

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

        // TODO: FIX!!!!

        if progress_expr { self.queue_expr_parent(ctx, upcast_id); }

            let signature_type: *mut _ = &mut extra.embedded[arg_idx];

            let (_, progress_arg) = Self::apply_equal2_signature_constraint(

                ctx, upcast_id, Some(arg_id), extra, &mut poly_progress,

                signature_type, 0, argument_type, 0

            debug_log!(

                "   - Arg {} type | sig: {}, arg: {}", arg_idx,

                unsafe{&*signature_type}.display_name(&ctx.heap), 

                unsafe{&*argument_type}.display_name(&ctx.heap));

        let signature_type: *mut _ = &mut extra.returned;

        let (_, progress_expr) = Self::apply_equal2_signature_constraint(

            ctx, upcast_id, None, extra, &mut poly_progress,

            signature_type, 0, expr_type, 0

        debug_log!(

            "   - Ret type | sig: {}, expr: {}", 

            unsafe{&*signature_type}.display_name(&ctx.heap), 

            unsafe{&*expr_type}.display_name(&ctx.heap)

        );

            // TODO: @cleanup, cannot call utility self.queue_parent thingo

        debug_log!(" * During (reinferring from progressed polyvars):");

        for arg_idx in 0..extra.embedded.len() {

            let signature_type: *mut _ = &mut extra.embedded[arg_idx];

            let arg_expr_id = expr.arguments[arg_idx];

            let arg_type: *mut _ = self.expr_types.get_mut(&arg_expr_id).unwrap();

            let progress_arg = Self::apply_equal2_polyvar_constraint(

                extra, &poly_progress,

                signature_type, arg_type

            );

            debug_log!(

                "   - Arg {} type | sig: {}, arg: {}", arg_idx, 

                unsafe{&*signature_type}.display_name(&ctx.heap), 

                unsafe{&*arg_type}.display_name(&ctx.heap)

            );

            if progress_arg {

                self.expr_queued.insert(arg_expr_id);

        }

        // Once more for the return type

        let signature_type: *mut _ = &mut extra.returned;

        let ret_type: *mut _ = self.expr_types.get_mut(&upcast_id).unwrap();

        let progress_ret = Self::apply_equal2_polyvar_constraint(

            extra, &poly_progress, signature_type, ret_type

        );

        debug_log!(

            "   - Ret type | sig: {}, arg: {}", 

            unsafe{&*signature_type}.display_name(&ctx.heap), 

            unsafe{&*ret_type}.display_name(&ctx.heap)

        );

        if progress_ret {

            self.queue_expr_parent(ctx, upcast_id);

    /// Applies an equal2 constraint between a signature type (e.g. a function

    /// argument or struct field) and an expression whose type should match that

    /// expression. If we make progress on the signature, then we try to see if

    /// any of the embedded polymorphic types can be progressed.

    ///

    /// `outer_expr_id` is the main expression we're progressing (e.g. a 

    /// function call), while `expr_id` is the embedded expression we're 

    /// matching against the signature. `expression_type` and 

    /// `expression_start_idx` belong to `expr_id`.

        polymorph_data: &mut ExtraData, polymorph_progress: &mut HashSet<usize>,

        // Safety: cannot mutually infer the same types

        //         polymorph_data containers may not be modified

        // Infer the signature and expression type

                None => ("type's", outer_position)

        // Try to see if we can progress any of the polymorphic variables

        let progress_sig = infer_res.modified_lhs();

        let progress_expr = infer_res.modified_rhs();

        if progress_sig {

            let signature_type = unsafe{&mut *signature_type};

            debug_assert!(

                signature_type.has_body_marker, 

                "made progress on signature type, but it doesn't have a marker"

            );

            for (poly_idx, poly_section) in signature_type.body_marker_iter() {

                let polymorph_type = &mut polymorph_data.poly_vars[poly_idx];

                match Self::apply_forced_constraint_types(

                    polymorph_type, 0, poly_section, 0

                ) {

                    Ok(true) => { polymorph_progress.insert(poly_idx); },

                    Ok(false) => {},

                    Err(()) => { return Err(Self::construct_poly_arg_error(ctx, polymorph_data, outer_expr_id))}

                }

            }

        }

        Ok((progress_sig, progress_expr))

    }

    /// Applies equal2 constraints on the signature type for each of the 

    /// polymorphic variables. If the signature type is progressed then we 

    /// progress the expression type as well.

    ///

    /// This function assumes that the polymorphic variables have already been

    /// progressed as far as possible by calling 

    /// `apply_equal2_signature_constraint`. As such, we expect to not encounter

    /// any errors.

    ///

    /// This function returns true if the expression's type has been progressed

    fn apply_equal2_polyvar_constraint(

        polymorph_data: &ExtraData, polymorph_progress: &HashSet<usize>,

        signature_type: *mut InferenceType, expr_type: *mut InferenceType

    ) -> bool {

        // Safety: all pointers should be distinct

        //         polymorph_data contains may not be modified

        debug_assert_ptrs_distinct!(signature_type, expr_type);

        let signature_type = unsafe{&mut *signature_type};

        let expr_type = unsafe{&mut *expr_type};

        // Iterate through markers in signature type to try and make progress

        // on the polymorphic variable        

        let mut seek_idx = 0;

        let mut modified_sig = false;

        while seek_idx < signature_type.parts.len() {

            if let InferenceTypePart::MarkerBody(poly_idx) = &signature_type.parts[seek_idx] {

                let poly_idx = *poly_idx;

                if polymorph_progress.contains(&poly_idx) {

                    // Need to match subtrees

                    let polymorph_type = &polymorph_data.poly_vars[poly_idx];

                    let start_idx = seek_idx + 1;

                    let end_idx = InferenceType::find_subtree_end_idx(&signature_type.parts, start_idx);

                    let modified_at_marker = Self::apply_forced_constraint_types(

                        signature_type, start_idx, 

                        &polymorph_type.parts, 0

                    ).expect("no failure when applying polyvar constraints");

                    modified_sig = modified_sig || modified_at_marker;

                    seek_idx = end_idx;

                    continue;

                }

            }

            seek_idx += 1;

        }

        // If we made any progress on the signature's type, then we also need to

        // apply it to the expression that is supposed to match the signature.

        if modified_sig {

            match InferenceType::infer_subtree_for_single_type(

                expr_type, 0, &signature_type.parts, 0

            ) {

                SingleInferenceResult::Modified => true,

                SingleInferenceResult::Unmodified => false,

                SingleInferenceResult::Incompatible =>

                    unreachable!("encountered failure while reapplying modified signature to expression after polyvar inference")

            }

        } else {

            false

        }

                        debug_assert_eq!(poly_vars.len(), definition.poly_vars.len());

        use InferenceTypePart as ITP;

        let mut total_num_poly_parts = 0;

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

        let definition = match definition {

                definition

        };

        // Note: programmer is capable of specifying fields in a struct literal

        // in a different order than on the definition. We take the programmer-

        // specified order to be leading.

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

        for lit_field in literal.fields.iter() {

            let def_field = &definition.fields[lit_field.field_idx];

            let inference_type = self.determine_inference_type_from_parser_type(

                ctx, def_field.parser_type, false

            );

            embedded_types.push(inference_type);

        // Return type is the struct type itself, with the appropriate 

        // polymorphic variables. So:

        // - 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(true, return_type_done, parts);

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

            poly_vars, 

            embedded: embedded_types,

            returned: return_type,

        });

    /// on a polymorphic variable to a function call or literal construction 

    /// failed. This may only be caused by a pair of inference types (which may 

    /// come from arguments or the return type) having two different inferred 

    /// values for that polymorphic variable.

    /// So we find this pair and construct the error using it.

    ///

    /// We assume that the expression is a function call or a struct literal,

    /// and that an actual error has occurred.

        ctx: &Ctx, poly_data: &ExtraData, expr_id: ExpressionId

        // Helpers function to retrieve polyvar name and definition name

        fn get_poly_var_and_literal_name(ctx: &Ctx, poly_var_idx: usize, expr: &LiteralExpression) -> (String, String) {

            let expr = expr.value.as_struct();

            let definition = &ctx.heap[expr.definition.unwrap()];

            match definition {

                Definition::Enum(_) | Definition::Function(_) | Definition::Component(_) =>

                    unreachable!(),

                Definition::Struct(definition) => (

                    String::from_utf8_lossy(&definition.poly_vars[poly_var_idx].value).to_string(),

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

                ),

            }

        }

        fn construct_main_error(ctx: &Ctx, poly_var_idx: usize, expr: &Expression) -> ParseError2 {

            match expr {

                Expression::Call(expr) => {

                    let (poly_var, func_name) = get_poly_var_and_func_name(ctx, poly_var_idx, expr);

                    return ParseError2::new_error(

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

                        &format!(

                            "Conflicting type for polymorphic variable '{}' of '{}'",

                            poly_var, func_name

                        )

                    )

                },

                Expression::Literal(expr) => {

                    let (poly_var, struct_name) = get_poly_var_and_literal_name(ctx, poly_var_idx, expr);

                    return ParseError2::new_error(

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

                        &format!(

                            "Conflicting type for polymorphic variable '{}' of instantiation of '{}'",

                            poly_var, struct_name

                        )

                    )

                },

                _ => unreachable!("called construct_poly_arg_error without a call/literal expression")

            }

        let expr = &ctx.heap[expr_id];

        let (expr_args, expr_return_name) = match expr {

            Expression::Call(expr) => 

                (

                    expr.arguments.clone(),

                    "return type"

                ),

            Expression::Literal(expr) => 

                (

                    expr.value.as_struct().fields

                        .iter()

                        .map(|f| f.value)

                        .collect(),

                    "literal"

                ),

            _ => unreachable!(),

        };

        if let Some((poly_idx, section_a, section_b)) = has_poly_mismatch(

            &poly_data.returned, &poly_data.returned

        ) {

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