return;

            }

        }

        vec.push(value);

        hide!(self.cur_size += 1);

    }

    #[inline]

    pub(crate) fn contains(&self, value: &T) -> bool {

        self.check_length();

        let vec = unsafe{&*self.inner};

                return true;

            }

        }

        return false;

    }

}

impl<T: Copy> ScopedSection<T> {

    pub(crate) fn iter_copied(&self) -> ScopedIter<T> {

        return ScopedIter{

            inner: self.inner,

    () => { false };

}

macro_rules! debug_log {

    ($format:literal) => {

        enabled_debug_print!(false, "types", $format);

    };

    ($format:literal, $($args:expr),*) => {

        enabled_debug_print!(false, "types", $format, $($args),*);

    };

}

use crate::collections::{ScopedBuffer, ScopedSection, DequeSet};

use crate::protocol::ast::*;

use crate::protocol::input_source::ParseError;

use crate::protocol::parser::ModuleCompilationPhase;

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

use crate::protocol::parser::token_parsing::*;

use super::visitor::{

    BUFFER_INIT_CAP_LARGE,

    BUFFER_INIT_CAP_SMALL,

    Ctx,

};

#[derive(Debug, PartialEq, Eq)]

enum SingleInferenceResult {

    Unmodified,

    Modified,

    Incompatible

}

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

// PassTyping - Public Interface

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

type InferNodeIndex = usize;

type VarDataIndex = usize;

enum DefinitionType{

    Component(ComponentDefinitionId),

    Function(FunctionDefinitionId),

}

impl DefinitionType {

    fn definition_id(&self) -> DefinitionId {

        match self {

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

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

pub(crate) struct ResolveQueueElement {

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

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

    // the polymorphic arguments to the procedure.

    pub(crate) root_id: RootId,

    pub(crate) definition_id: DefinitionId,

    pub(crate) reserved_type_id: TypeId,

}

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

struct InferenceNode {

    expr_type: InferenceType,       // result type from expression

    expr_id: ExpressionId,          // expression that is evaluated

    inference_rule: InferenceRule,

    parent_index: Option<InferNodeIndex>,

    field_or_monomorph_index: i32,    // index of field

    poly_data_index: PolyDataIndex,            // index of extra data needed for inference

    type_id: TypeId,                // when applicable indexes into type table

}

/// Inferencing rule to apply. Some of these are reasonably generic. Other ones

/// require so much custom logic that we'll not try to come up with an

    union_cast_method_impl!(as_slicing_expr, InferenceRuleSlicingExpr, InferenceRule::SlicingExpr);

    union_cast_method_impl!(as_select_struct_field, InferenceRuleSelectStructField, InferenceRule::SelectStructField);

    union_cast_method_impl!(as_select_tuple_member, InferenceRuleSelectTupleMember, InferenceRule::SelectTupleMember);

    union_cast_method_impl!(as_literal_struct, InferenceRuleLiteralStruct, InferenceRule::LiteralStruct);

    union_cast_method_impl!(as_literal_union, InferenceRuleLiteralUnion, InferenceRule::LiteralUnion);

    union_cast_method_impl!(as_literal_array, InferenceRuleLiteralArray, InferenceRule::LiteralArray);

    union_cast_method_impl!(as_literal_tuple, InferenceRuleLiteralTuple, InferenceRule::LiteralTuple);

    union_cast_method_impl!(as_cast_expr, InferenceRuleCastExpr, InferenceRule::CastExpr);

    union_cast_method_impl!(as_call_expr, InferenceRuleCallExpr, InferenceRule::CallExpr);

    union_cast_method_impl!(as_variable_expr, InferenceRuleVariableExpr, InferenceRule::VariableExpr);

}

struct InferenceRuleTemplate {

    template: &'static [InferenceTypePart],

    application: InferenceRuleTemplateApplication,

}

impl InferenceRuleTemplate {

    fn new_none() -> Self {

        return Self{

            template: &[],

            application: InferenceRuleTemplateApplication::None,

        };

    }

    // expressions they're linked to made progression on an associated type

    node_queued: DequeSet<InferNodeIndex>,

}

/// Generic struct that is used to store inferred types associated with

/// polymorphic types.

struct PolyData {

    first_rule_application: bool,

    definition_id: DefinitionId, // the definition, only used for user feedback

    /// Inferred types of the polymorphic variables as they are written down

    /// at the type's definition.

    poly_vars: Vec<InferenceType>,

    /// Inferred types of associated types (e.g. struct fields, tuple members,

    /// function arguments). These types may depend on the polymorphic variables

    /// defined above.

    associated: Vec<InferenceType>,

    /// Inferred "returned" type (e.g. if a struct field is selected, then this

    /// contains the type of the selected field, for a function call it contains

    /// the return type). May depend on the polymorphic variables defined above.

    returned: InferenceType,

}

#[derive(Clone, Copy)]

enum PolyDataTypeIndex {

    Associated(usize), // indexes into `PolyData.associated`

    Returned,

}

    fn get_type(&self, index: PolyDataTypeIndex) -> &InferenceType {

        match index {

            PolyDataTypeIndex::Associated(index) => return &self.associated[index],

            PolyDataTypeIndex::Returned => return &self.returned,

        }

    }

    fn get_type_mut(&mut self, index: PolyDataTypeIndex) -> &mut InferenceType {

        match index {

            PolyDataTypeIndex::Associated(index) => return &mut self.associated[index],

            PolyDataTypeIndex::Returned => return &mut self.returned,

        }

    fn visit_union_definition(&mut self, _: &mut Ctx, _: UnionDefinitionId) -> VisitorResult { return Ok(()) }

    fn visit_component_definition(&mut self, ctx: &mut Ctx, id: ComponentDefinitionId) -> VisitorResult {

        self.definition_type = DefinitionType::Component(id);

        let comp_def = &ctx.heap[id];

        debug_assert_eq!(comp_def.poly_vars.len(), self.poly_vars.len(), "component polyvars do not match imposed polyvars");

        debug_log!("{}", "-".repeat(50));

        debug_log!("Visiting component '{}': {}", comp_def.identifier.value.as_str(), id.0.index);

        debug_log!("{}", "-".repeat(50));

        // Visit parameters

        let section = self.var_buffer.start_section_initialized(comp_def.parameters.as_slice());

        for param_id in section.iter_copied() {

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);

            debug_assert!(var_type.is_done, "expected component arguments to be concrete types");

            self.var_data.push(VarData{

                var_id: param_id,

                var_type,

                used_at: Vec::new(),

                linked_var: None

            });

            debug_log!("Polymorphic variables:");

            for (_idx, poly_var) in self.poly_vars.iter().enumerate() {

                let mut infer_type_parts = Vec::new();

                Self::determine_inference_type_from_concrete_type(

                    &mut infer_type_parts, &poly_var.parts

                );

                let _infer_type = InferenceType::new(false, true, infer_type_parts);

                debug_log!(" - [{:03}] {:?}", _idx, _infer_type.display_name(&ctx.heap));

            }

        }

        debug_log!("{}", "-".repeat(50));

        // Visit parameters

        let section = self.var_buffer.start_section_initialized(func_def.parameters.as_slice());

        for param_id in section.iter_copied() {

            let param = &ctx.heap[param_id];

            let var_type = self.determine_inference_type_from_parser_type_elements(&param.parser_type.elements, true);

            debug_assert!(var_type.is_done, "expected function arguments to be concrete types");

            self.var_data.push(VarData{

                var_id: param_id,

                var_type,

                used_at: Vec::new(),

                linked_var: None

            })

                    expr_ids.push(field.value);

                }

                let mut expr_indices = self.index_buffer.start_section();

                for expr_id in expr_ids.iter_copied() {

                    let expr_index = self.visit_expr(ctx, expr_id)?;

                    expr_indices.push(expr_index);

                }

                expr_ids.forget();

                let element_indices = expr_indices.into_vec();

                // Assign rule and extra data index to inference node

                let node = &mut self.infer_nodes[self_index];

                node.inference_rule = InferenceRule::LiteralStruct(InferenceRuleLiteralStruct{

                    element_indices,

                });

            },

            Literal::Enum(_) => {

                // Enumerations do not carry any subexpressions, but may still

                // have a user-defined polymorphic marker variable. For this 

                // reason we may still have to apply inference to this 

                // polymorphic variable

                let node = &mut self.infer_nodes[self_index];

                node.inference_rule = InferenceRule::LiteralEnum;

            },

            Literal::Union(literal) => {

                // May carry subexpressions and polymorphic arguments

                let expr_ids = self.expr_buffer.start_section_initialized(literal.values.as_slice());

                let mut expr_indices = self.index_buffer.start_section();

                for expr_id in expr_ids.iter_copied() {

                    let expr_index = self.visit_expr(ctx, expr_id)?;

                    expr_indices.push(expr_index);

                }

                expr_ids.forget();

                let element_indices = expr_indices.into_vec();

                let node = &mut self.infer_nodes[self_index];

                node.inference_rule = InferenceRule::LiteralUnion(InferenceRuleLiteralUnion{

                    element_indices,

                });

            },

                let expr_ids = self.expr_buffer.start_section_initialized(expressions.as_slice());

                for expr_id in expr_ids.iter_copied() {

                    let expr_index = self.visit_expr(ctx, expr_id)?;

                    expr_indices.push(expr_index);

                }

                expr_ids.forget();

                let element_indices = expr_indices.into_vec();

                let node = &mut self.infer_nodes[self_index];

                node.inference_rule = InferenceRule::LiteralArray(InferenceRuleLiteralArray{

                    element_indices,

                })

            }

        }

        self.parent_index = old_parent;

        self.progress_inference_rule(ctx, self_index)?;

        return Ok(self_index);

    }

    fn visit_cast_expr(&mut self, ctx: &mut Ctx, id: CastExpressionId) -> VisitExprResult {

        let upcast_id = id.upcast();

        let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;

        let node = &mut self.infer_nodes[self_index];

        node.inference_rule = InferenceRule::CastExpr(InferenceRuleCastExpr{

            subject_index,

        });

        self.parent_index = old_parent;

        // The cast expression is a bit special at this point: the progression

        // function simply makes sure input/output types are compatible. But if

        // the programmer explicitly specified the output type, then we can

        // already perform that inference rule here.

        {

            let specified_type = self.determine_inference_type_from_parser_type_elements(&cast_expr.to_type.elements, true);

            let _progress = self.apply_template_constraint(ctx, self_index, &specified_type.parts)?;

        }

        self.progress_inference_rule_cast_expr(ctx, self_index)?;

        return Ok(self_index);

    }

    fn visit_call_expr(&mut self, ctx: &mut Ctx, id: CallExpressionId) -> VisitExprResult {

        let upcast_id = id.upcast();

        let self_index = self.insert_initial_inference_node(ctx, upcast_id)?;

        let extra_index = self.insert_initial_call_polymorph_data(ctx, id);

impl PassTyping {

    #[allow(dead_code)] // used when debug flag at the top of this file is true.

    fn debug_get_display_name(&self, ctx: &Ctx, expr_id: ExpressionId) -> String {

        let expr_idx = ctx.heap[expr_id].get_unique_id_in_definition();

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

        expr_type.display_name(&ctx.heap)

    }

    fn resolve_types(&mut self, ctx: &mut Ctx, queue: &mut ResolveQueue) -> Result<(), ParseError> {

        // Keep inferring until we can no longer make any progress

        while !self.node_queued.is_empty() {

            while !self.node_queued.is_empty() {

            }

            // Nothing is queued anymore. However we might have integer literals

            // whose type cannot be inferred. For convenience's sake we'll

            // infer these to be s32.

            for (infer_node_index, infer_node) in self.infer_nodes.iter_mut().enumerate() {

                let expr_type = &mut infer_node.expr_type;

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

                    // Force integer type to s32

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

                    expr_type.is_done = true;

                    // Requeue expression (and its parent, if it exists)

                    self.node_queued.push_back(infer_node_index);

                    }

                }

            }

        }

        // Helper for transferring polymorphic variables to concrete types and

        // checking if they're completely specified

        fn inference_type_to_concrete_type(

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

            first_concrete_part: ConcreteTypePart,

        ) -> Result<ConcreteType, ParseError> {

            // Prepare storage vector

        for infer_expr in self.infer_nodes.iter_mut() {

            if !infer_expr.expr_type.is_done {

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

                return Err(ParseError::new_error_at_span(

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

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

                        infer_expr.expr_type.display_name(&ctx.heap)

                    )

                ));

            }

            // Expression is fine, check if any extra data is attached

            // Extra data is attached, perform typechecking and transfer

            // resolved information to the expression

            // Note that only call and literal expressions need full inference.

            // Select expressions also use `extra_data`, but only for temporary

            // storage of the struct type whose field it is selecting.

                Expression::Call(expr) => {

                    // Check if it is not a builtin function. If not, then

                    // construct the first part of the concrete type.

                    let first_concrete_part = if expr.method == Method::UserFunction {

                    } else if expr.method == Method::UserComponent {

                    } else {

                        // Builtin function

                        continue;

                    };

                    let definition_id = expr.definition;

                    let concrete_type = inference_type_to_concrete_type(

                    )?;

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

                        Some(type_id) => {

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

                            infer_expr.type_id = type_id;

                        },

                        None => {

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

                            let reserved_type_id = ctx.types.reserve_procedure_monomorph_type_id(&definition_id, concrete_type);

                            infer_expr.type_id = reserved_type_id;

                            queue.push(ResolveQueueElement {

                                reserved_type_id,

                            });

                        }

                    }

                },

                Expression::Literal(expr) => {

                    let definition_id = match &expr.value {

                        Literal::Enum(lit) => lit.definition,

                        Literal::Union(lit) => lit.definition,

                        Literal::Struct(lit) => lit.definition,

                        _ => unreachable!(),

                    };

                    let concrete_type = inference_type_to_concrete_type(

                    )?;

                    let type_id = ctx.types.add_monomorphed_type(ctx.modules, ctx.heap, ctx.arch, definition_id, concrete_type)?;

                    infer_expr.type_id = type_id;

                },

                Expression::Select(_) => {

                    debug_assert!(infer_expr.field_or_monomorph_index >= 0);

                },

                _ => {

                }

            }

        }

        // Every expression checked, and new monomorphs are queued. Transfer the

        // expression information to the type table.

        let procedure_arguments = match &self.definition_type {

            DefinitionType::Component(id) => {

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

                &definition.parameters

            },

            DefinitionType::Function(id) => {

                self.progress_inference_rule_literal_tuple(ctx, node_index),

            IR::CastExpr(_) =>

                self.progress_inference_rule_cast_expr(ctx, node_index),

            IR::CallExpr(_) =>

                self.progress_inference_rule_call_expr(ctx, node_index),

            IR::VariableExpr(_) =>

                self.progress_inference_rule_variable_expr(ctx, node_index),

        }

    }

    fn progress_inference_rule_mono_template(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let progress = self.progress_template(ctx, node_index, rule.application, rule.template)?;

        if progress { self.queue_node_parent(node_index); }

        return Ok(());

    }

    fn progress_inference_rule_bi_equal(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let rule = node.inference_rule.as_bi_equal();

        let arg_index = rule.argument_index;

        let (node_progress, arg_progress) = self.apply_equal2_constraint(ctx, node_index, node_index, 0, arg_index, 0)?;

        if base_progress || node_progress { self.queue_node_parent(node_index); }

        if arg_progress { self.queue_node(arg_index); }

        return Ok(())

    }

    fn progress_inference_rule_tri_equal_args(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let rule = node.inference_rule.as_tri_equal_args();

        let arg1_index = rule.argument1_index;

        let arg2_index = rule.argument2_index;

        let (arg1_progress, arg2_progress) = self.apply_equal2_constraint(ctx, node_index, arg1_index, 0, arg2_index, 0)?;

        if self_template_progress { self.queue_node_parent(node_index); }

        if arg1_template_progress || arg1_progress { self.queue_node(arg1_index); }

        return Ok(());

    }

    fn progress_inference_rule_tri_equal_all(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let rule = node.inference_rule.as_tri_equal_all();

        let arg1_index = rule.argument1_index;

        let arg2_index = rule.argument2_index;

        let (node_progress, arg1_progress, arg2_progress) =

            self.apply_equal3_constraint(ctx, node_index, arg1_index, arg2_index, 0)?;

        if template_progress || node_progress { self.queue_node_parent(node_index); }

        if arg1_progress { self.queue_node(arg1_index); }

        if arg2_progress { self.queue_node(arg2_index); }

        return Ok(());

    }

    fn progress_inference_rule_concatenate(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let rule = node.inference_rule.as_concatenate();

        let arg1_index = rule.argument1_index;

        let arg2_index = rule.argument2_index;

        // Two cases: one of the arguments is a string (then all must be), or

        // one of the arguments is an array (and all must be arrays).

        let (expr_is_str, expr_is_not_str) = self.type_is_certainly_or_certainly_not_string(node_index);

        let (arg1_is_str, arg1_is_not_str) = self.type_is_certainly_or_certainly_not_string(arg1_index);

        let (arg2_is_str, arg2_is_not_str) = self.type_is_certainly_or_certainly_not_string(arg2_index);

        let someone_is_str = expr_is_str || arg1_is_str || arg2_is_str;

        let someone_is_not_str = expr_is_not_str || arg1_is_not_str || arg2_is_not_str;

        // Note: this statement is an expression returning the progression bools

        let (node_progress, arg1_progress, arg2_progress) = if someone_is_str {

            // One of the arguments is a string, then all must be strings

            self.apply_equal3_constraint(ctx, node_index, arg1_index, arg2_index, 0)?

        } else {

            let progress_expr = if someone_is_not_str {

                // Output must be a normal array

                self.apply_template_constraint(ctx, node_index, &ARRAY_TEMPLATE)?

            } else {

                // Output may still be anything

                self.apply_template_constraint(ctx, node_index, &ARRAYLIKE_TEMPLATE)?

            };

        debug_log!("Rule slicing [node: {}, expr: {}]", node_index, node.expr_id.index);

        // Subject is arraylike, indices are integerlike

        let subject_template_progress = self.apply_template_constraint(ctx, subject_index, &ARRAYLIKE_TEMPLATE)?;

        let from_template_progress = self.apply_template_constraint(ctx, from_index_index, &INTEGERLIKE_TEMPLATE)?;

        let to_template_progress = self.apply_template_constraint(ctx, to_index_index, &INTEGERLIKE_TEMPLATE)?;

        let (from_index_progress, to_index_progress) =

            self.apply_equal2_constraint(ctx, node_index, from_index_index, 0, to_index_index, 0)?;

        // Same as array indexing: result depends on whether subject is string

        // or array

        let (is_string, is_not_string) = self.type_is_certainly_or_certainly_not_string(node_index);

        let (node_progress, subject_progress) = if is_string {

            // Certainly a string

            (

                self.apply_forced_constraint(ctx, node_index, &STRING_TEMPLATE)?,

                false

            )

        } else if is_not_string {

            // Certainly not a string, apply template constraint. Then make sure

            // that if we have an `Array<T>`, that the slice produces `Slice<T>`

            let node_template_progress = self.apply_template_constraint(ctx, node_index, &SLICE_TEMPLATE)?;

            let (node_progress, subject_progress) =

                self.apply_equal2_constraint(ctx, node_index, node_index, 1, subject_index, 1)?;

        if subject_template_progress || subject_progress { self.queue_node(subject_index); }

        if from_template_progress || from_index_progress { self.queue_node(from_index_index); }

        if to_template_progress || to_index_progress { self.queue_node(to_index_index); }

        return Ok(());

    }

    fn progress_inference_rule_select_struct_field(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let rule = node.inference_rule.as_select_struct_field();

        let subject_index = rule.subject_index;

        fn get_definition_id_from_inference_type(inference_type: &InferenceType) -> Result<Option<DefinitionId>, ()> {

            for part in inference_type.parts.iter() {

                if part.is_marker() { continue; }

                if !part.is_concrete() { break; }

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

                    return Ok(Some(*definition_id));

                } else {

                    return Err(())

                }

            }

        if node.field_or_monomorph_index < 0 {

            // Don't know the subject definition, hence the field yet. Try to

            // determine it.

            let subject_node = &self.infer_nodes[subject_index];

            match get_definition_id_from_inference_type(&subject_node.expr_type) {

                Ok(Some(definition_id)) => {

                    // Determined definition of subject for the first time.

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

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

                        struct_definition

                    } else {

                        return Err(ParseError::new_error_at_span(

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

                            )

                        ));

                    };

                    // Seek the field that is referenced by the select

                    // expression

                    let mut field_found = false;

                    for (field_index, field) in struct_definition.fields.iter().enumerate() {

                            // Found the field of interest

                            field_found = true;

                            let node = &mut self.infer_nodes[node_index];

                            node.field_or_monomorph_index = field_index as i32;

                            break;

                        }

                    }

                    if !field_found {

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

                        return Err(ParseError::new_error_at_span(

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

                            )

                        ));

                    }

                    // Insert the initial data needed to infer polymorphic

                    // fields

                    let extra_index = self.insert_initial_select_polymorph_data(ctx, node_index, definition_id);

                    let node = &mut self.infer_nodes[node_index];

                    node.poly_data_index = extra_index;

                },

                Ok(None) => {

                    // We don't know what to do yet, because we don't know the

                    // subject type yet.

                    return Ok(())

                },

                Err(()) => {

                    return Err(ParseError::new_error_at_span(

                        &ctx.module().source, rule.selected_field.span, format!(

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

                        )

                    ));

                },

            }

        }

        // If here then the field index is known, hence we can start inferring

        // the type of the selected field

        let field_expr_id = self.infer_nodes[node_index].expr_id;

        let subject_expr_id = self.infer_nodes[subject_index].expr_id;

        let mut poly_progress_section = self.poly_progress_buffer.start_section();

        }

        // If here then we know we can use `tuple_member_index`. We need to keep

        // computing the offset to the subtype, as its value changes during

        // inference

        let subject_type = &self.infer_nodes[subject_index].expr_type;

        let mut selected_member_start_index = 1; // start just after the InferenceTypeElement::Tuple

        for _ in 0..tuple_member_index {

            selected_member_start_index = InferenceType::find_subtree_end_idx(&subject_type.parts, selected_member_start_index);

        }

        let (progress_member, progress_subject) = self.apply_equal2_constraint(

        )?;

        if progress_member { self.queue_node_parent(node_index); }

        if progress_subject { self.queue_node(subject_index); }

        return Ok(());

    }

    fn progress_inference_rule_literal_struct(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let rule = node.inference_rule.as_literal_struct();

        // For each of the fields in the literal struct, apply the type equality

        // constraint. If the literal is polymorphic, then we try to progress

        // their types during this process

        let mut poly_progress_section = self.poly_progress_buffer.start_section();

            let field_expr_id = self.infer_nodes[field_node_index].expr_id;

            let (_, progress_field) = self.apply_polydata_equal2_constraint(

                ctx, node_index, field_expr_id, "struct field's",

                PolyDataTypeIndex::Associated(field_index), 0,

                field_node_index, 0, &mut poly_progress_section

            )?;

            if progress_field { self.queue_node(field_node_index); }

        }

        // Now we do the same thing for the struct literal expression (the type

        // of the struct itself).

        let (_, progress_literal_1) = self.apply_polydata_equal2_constraint(

            PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section

        )?;

        // And the other way around: if any of our polymorphic variables are

        // more specific then they were before, then we forward that information

        // back to our struct/fields.

            let progress_field = self.apply_polydata_polyvar_constraint(

                ctx, node_index, PolyDataTypeIndex::Associated(field_index),

                field_node_index, &poly_progress_section

            );

            if progress_field { self.queue_node(field_node_index); }

        }

        let progress_literal_2 = self.apply_polydata_polyvar_constraint(

            ctx, node_index, PolyDataTypeIndex::Returned,

            node_index, &poly_progress_section

        );

        if progress_literal_1 || progress_literal_2 { self.queue_node_parent(node_index); }

        poly_progress_section.forget();

        self.finish_polydata_constraint(node_index);

        return Ok(())

    }

    fn progress_inference_rule_literal_enum(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let mut poly_progress_section = self.poly_progress_buffer.start_section();

        // An enum literal type is simply, well, the enum's type. However, it

        // might still have polymorphic variables, hence the use of `PolyData`.

        let (_, progress_literal_1) = self.apply_polydata_equal2_constraint(

            PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section

        )?;

        let progress_literal_2 = self.apply_polydata_polyvar_constraint(

            ctx, node_index, PolyDataTypeIndex::Returned, node_index, &poly_progress_section

        );

        if progress_literal_1 || progress_literal_2 { self.queue_node_parent(node_index); }

        poly_progress_section.forget();

        self.finish_polydata_constraint(node_index);

        return Ok(());

    }

    fn progress_inference_rule_literal_union(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {

        let node = &self.infer_nodes[node_index];

        let rule = node.inference_rule.as_literal_union();

        // Infer type of any embedded values in the union variant. At the same

        // time progress the polymorphic variables associated with the union.

        let mut poly_progress_section = self.poly_progress_buffer.start_section();