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

type InferNodeIndex = usize;

enum DefinitionType{

    Component(ComponentDefinitionId),

    inference_rule: InferenceRule,

    parent_index: Option<InferNodeIndex>,

    field_or_monomorph_index: i32,    // index of field

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

}

    reserved_type_id: TypeId,

    definition_type: DefinitionType,

    poly_vars: Vec<ConcreteType>,

    parent_index: Option<InferNodeIndex>,

    // Buffers for iteration over various types

    var_buffer: ScopedBuffer<VariableId>,

    // specify these types until we're stuck or we've fully determined the type.

    var_types: HashMap<VariableId, VarData>,            // types of variables

    infer_nodes: Vec<InferenceNode>,                     // will be transferred to type table at end

    // Keeping track of which expressions need to be reinferred because the

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

    expr_queued: DequeSet<i32>,

}

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

    poly_vars: Vec<InferenceType>,

    returned: InferenceType,

}

    fn default() -> Self {

            definition_id: DefinitionId::new_invalid(),

            poly_vars: Vec::new(),

            returned: InferenceType::default(),

        }

    }

}

struct VarData {

    /// Type of the variable

    var_type: InferenceType,

            bool_buffer: ScopedBuffer::with_capacity(BUFFER_INIT_CAP_SMALL),

            var_types: HashMap::new(),

            infer_nodes: Vec::new(),

            expr_queued: DequeSet::new(),

        }

    }

        self.poly_vars.clear();

        self.var_types.clear();

        self.infer_nodes.clear();

        self.expr_queued.clear();

    }

}

                // Assign rule and extra data index to inference node

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

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

                node.inference_rule = InferenceRule::LiteralStruct(InferenceRuleLiteralStruct{

                    element_indices,

                });

                // polymorphic variable

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

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

                node.inference_rule = InferenceRule::LiteralEnum(InferenceRuleLiteralEnum{

                });

                let element_indices = expr_indices.into_vec();

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

                node.inference_rule = InferenceRule::LiteralUnion(InferenceRuleLiteralUnion{

                    element_indices,

                });

                let element_indices = expr_indices.into_vec();

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

                node.inference_rule = InferenceRule::LiteralArray(InferenceRuleLiteralArray{

                    element_indices,

                })

        let argument_indices = expr_indices.into_vec();

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

        node.inference_rule = InferenceRule::CallExpr(InferenceRuleCallExpr{

            argument_indices,

        });

            // 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

                    // fields

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

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

                },

                Ok(None) => {

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

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

        // the type of the selected field

        let node = &self.infer_nodes[node_index];

        let mut poly_progress = HashSet::new(); // TODO: @Performance

        // Apply to struct's type

        let subject_type: *mut _ = &mut self.infer_nodes[subject_expr_idx as usize].expr_type;

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

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

            ctx, upcast_id, None, poly_data, &mut poly_progress,

            signature_type, 0, expr_type, 0

        if progress_expr {

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

        }

        // Reapply progress in polymorphic variables to struct's type

        let subject_type: *mut _ = &mut self.infer_nodes[subject_expr_idx as usize].expr_type;

        let progress_subject = Self::apply_equal2_polyvar_constraint(

                // If here then field index is known, and the referenced struct type

                // information is inserted into `extra_data`. Check to see if we can

                // do some mutual inference.

                let mut poly_progress = HashSet::new(); // TODO: @Performance

                // Apply to struct's type

                let subject_type: *mut _ = &mut self.infer_nodes[subject_expr_idx as usize].expr_type;

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

                }

                // Reapply progress in polymorphic variables to struct's type

                let subject_type: *mut _ = &mut self.infer_nodes[subject_expr_idx as usize].expr_type;

                let progress_subject = Self::apply_equal2_polyvar_constraint(

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

            },

            Literal::Struct(data) => {

                for _poly in &extra.poly_vars {

                    debug_log!(" * Poly: {}", _poly.display_name(&ctx.heap));

                }

                let mut poly_progress = HashSet::new();

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

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

                    let field_expr_id = field.value;

                    let field_expr_idx = ctx.heap[field_expr_id].get_unique_id_in_definition();

                    let field_type: *mut _ = &mut self.infer_nodes[field_expr_idx as usize].expr_type;

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

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

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

                // For all field expressions

                    // Note: fields in extra.embedded are in the same order as

                    // they are specified in the literal. Whereas

                    // `data.fields[...].field_idx` points to the field in the

                    // struct definition.

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

                    let field_expr_idx = ctx.heap[field_expr_id].get_unique_id_in_definition();

                    let field_type: *mut _ = &mut self.infer_nodes[field_expr_idx as usize].expr_type;

                progress_expr

            },

            Literal::Enum(_) => {

                for _poly in &extra.poly_vars {

                    debug_log!(" * Poly: {}", _poly.display_name(&ctx.heap));

                }

                progress_expr

            },

            Literal::Union(data) => {

                for _poly in &extra.poly_vars {

                    debug_log!(" * Poly: {}", _poly.display_name(&ctx.heap));

                }

                let mut poly_progress = HashSet::new();

                debug_log!(" * During (inferring types from variant values and union type):");

                for (value_idx, value_expr_id) in data.values.iter().enumerate() {

                    let value_expr_id = *value_expr_id;

                    let value_expr_idx = ctx.heap[value_expr_id].get_unique_id_in_definition();

                    let value_type: *mut _ = &mut self.infer_nodes[value_expr_idx as usize].expr_type;

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

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

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

                // For all embedded values of the union variant

                    let value_expr_id = data.values[value_idx];

                    let value_expr_idx = ctx.heap[value_expr_id].get_unique_id_in_definition();

                    let value_type: *mut _ = &mut self.infer_nodes[value_expr_idx as usize].expr_type;

        debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));

        debug_log!(" * During (inferring types from arguments and return type):");

        // Check if we can make progress using the arguments and/or return types

        // while keeping track of the polyvars we've extended

        let mut poly_progress = HashSet::new();

        for (call_arg_idx, arg_id) in expr.arguments.clone().into_iter().enumerate() {

            let arg_expr_idx = ctx.heap[arg_id].get_unique_id_in_definition();

            let argument_type: *mut _ = &mut self.infer_nodes[arg_expr_idx as usize].expr_type;

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

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

        // TODO: @performance If the algorithm is changed to be more "on demand

        //  argument re-evaluation", instead of "all-argument re-evaluation",

        //  then this is no longer true

            let arg_expr_id = expr.arguments[arg_idx];

            let arg_expr_idx = ctx.heap[arg_expr_id].get_unique_id_in_definition();

            let arg_type: *mut _ = &mut self.infer_nodes[arg_expr_idx as usize].expr_type;

        Ok((infer_res.modified_lhs(), infer_res.modified_rhs()))

    }

    /// 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

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

    fn apply_equal2_signature_constraint(

        ctx: &Ctx, outer_expr_id: ExpressionId, expr_id: Option<ExpressionId>,

        signature_type: *mut InferenceType, signature_start_idx: usize,

        expression_type: *mut InferenceType, expression_start_idx: usize

    ) -> Result<(bool, bool), ParseError> {

            InferenceType::infer_subtrees_for_both_types(

                signature_type, signature_start_idx,

                expression_type, expression_start_idx

        };

        if infer_res == DualInferenceResult::Incompatible {

    ///

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

    fn apply_equal2_polyvar_constraint(

        signature_type: *mut InferenceType, expr_type: *mut InferenceType

    ) -> bool {

        // Safety: all pointers should be distinct

    fn insert_initial_call_polymorph_data(

        &mut self, ctx: &mut Ctx, call_id: CallExpressionId

        // Note: the polymorph variables may be partially specified and may

        // contain references to the wrapping definition's (i.e. the proctype

        // we are currently visiting) polymorphic arguments.

            }

        };

            expr_id: call_id.upcast(),

            definition_id: call.definition,

            poly_vars: poly_args,

            returned: return_type

        });

        return extra_data_idx

    fn insert_initial_struct_polymorph_data(

        &mut self, ctx: &mut Ctx, lit_id: LiteralExpressionId,

        use InferenceTypePart as ITP;

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

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

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

            expr_id: lit_id.upcast(),

            definition_id: literal.definition,

            poly_vars: poly_args,

            returned: return_type,

        });

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

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

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

            expr_id: lit_id.upcast(),

            definition_id: literal.definition,

            poly_vars: poly_args,

            returned: enum_type,

        });

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

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

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

            expr_id: lit_id.upcast(),

            definition_id: literal.definition,

            poly_vars: poly_args,

            returned: union_type

        });

    /// expression's referenced (definition_id, field_idx) has been resolved.

    fn insert_initial_select_polymorph_data(

        &mut self, ctx: &Ctx, node_index: InferNodeIndex, struct_def_id: DefinitionId

        use InferenceTypePart as ITP;

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

        // Generate initial field type

        let field_type = self.determine_inference_type_from_parser_type_elements(&definition.fields[field_index].parser_type.elements, false);

            definition_id: struct_def_id,

            poly_vars,

            returned: field_type

        });

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

    /// and that an actual error has occurred.

    fn construct_poly_arg_error(

    ) -> ParseError {

        // Helper function to check for polymorph mismatch between two inference

        // types.

        }

        // Helper function to construct initial error

            match expr {

                Expression::Call(expr) => {

                    let (poly_var, func_name) = get_poly_var_and_definition_name(ctx, poly_var_idx, poly_data.definition_id);

        }

        // - check arguments with each other argument and with return type

                if arg_b_idx > arg_a_idx {

                    break;

                }

        // Now check against the explicitly specified polymorphic variables (if

        // any).

            if let Some((poly_idx, poly_section, arg_section)) = has_explicit_poly_mismatch(&poly_data.poly_vars, arg) {

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

                return construct_main_error(ctx, poly_data, poly_idx, expr)