CSY/reowolf Changeset - c14c92253f09 · Centrum Wiskunde & Informatica (CWI)

Changeset - c14c92253f09

Parent rev.

Child rev.

[Not reviewed]

0 1 0

MH - 3 years ago 2022-02-21 17:57:49
contact@maxhenger.nl

WIP: More refactored inferencing rules

1 file changed with 241 insertions and 49 deletions:

src/protocol/parser/pass_typing.rs

241

0 comments (0 inline, 0 general)

src/protocol/parser/pass_typing.rs

➞

Show inline comments

@@ @@ -769,309 +769,309 @@ impl<'a> Iterator for InferenceTypeMarkerIter<'a> { @@
             self.idx += 1;
+        }
         None
+    }
+}
 #[derive(Debug, PartialEq, Eq)]
 enum DualInferenceResult {
     Neither,        // neither argument is clarified
     First,          // first argument is clarified using the second one
     Second,         // second argument is clarified using the first one
     Both,           // both arguments are clarified
     Incompatible,   // types are incompatible: programmer error
+}
 impl DualInferenceResult {
     fn modified_lhs(&self) -> bool {
         match self {
             DualInferenceResult::First | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
     fn modified_rhs(&self) -> bool {
         match self {
             DualInferenceResult::Second | DualInferenceResult::Both => true,
             _ => false
+        }
+    }
+}
 #[derive(Debug, PartialEq, Eq)]
 enum SingleInferenceResult {
     Unmodified,
     Modified,
     Incompatible
+}
 // -----------------------------------------------------------------------------
 // PassTyping - Public Interface
 // -----------------------------------------------------------------------------
 type InferNodeIndex = usize;
 type PolyDataIndex = 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>;
 #[derive(Clone)]
 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
 /// abstraction.
 enum InferenceRule {
     Noop,
     MonoTemplate(InferenceRuleTemplate),
     BiEqual(InferenceRuleBiEqual),
     TriEqualArgs(InferenceRuleTriEqualArgs),
     TriEqualAll(InferenceRuleTriEqualAll),
     Concatenate(InferenceRuleTwoArgs),
     IndexingExpr(InferenceRuleIndexingExpr),
     SlicingExpr(InferenceRuleSlicingExpr),
     SelectStructField(InferenceRuleSelectStructField),
     SelectTupleMember(InferenceRuleSelectTupleMember),
     LiteralStruct(InferenceRuleLiteralStruct),
-    LiteralEnum(InferenceRuleLiteralEnum),
     LiteralEnum,
     LiteralUnion(InferenceRuleLiteralUnion),
     LiteralArray(InferenceRuleLiteralArray),
     LiteralTuple(InferenceRuleLiteralTuple),
     CastExpr(InferenceRuleCastExpr),
     CallExpr(InferenceRuleCallExpr),
     VariableExpr(InferenceRuleVariableExpr),
+}
 impl InferenceRule {
     union_cast_method_impl!(as_mono_template, InferenceRuleTemplate, InferenceRule::MonoTemplate);
     union_cast_method_impl!(as_bi_equal, InferenceRuleBiEqual, InferenceRule::BiEqual);
     union_cast_method_impl!(as_tri_equal_args, InferenceRuleTriEqualArgs, InferenceRule::TriEqualArgs);
     union_cast_method_impl!(as_tri_equal_all, InferenceRuleTriEqualAll, InferenceRule::TriEqualAll);
     union_cast_method_impl!(as_concatenate, InferenceRuleTwoArgs, InferenceRule::Concatenate);
     union_cast_method_impl!(as_indexing_expr, InferenceRuleIndexingExpr, InferenceRule::IndexingExpr);
     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);
+}
 struct InferenceRuleTemplate {
     template: &'static [InferenceTypePart],
     application: InferenceRuleTemplateApplication,
+}
 impl InferenceRuleTemplate {
     fn new_none() -> Self {
         return Self{
             template: &[],
             application: InferenceRuleTemplateApplication::None,
         };
+    }
     fn new_forced(template: &'static [InferenceTypePart]) -> Self {
         return Self{
             template,
             application: InferenceRuleTemplateApplication::Forced,
         };
+    }
     fn new_template(template: &'static [InferenceTypePart]) -> Self {
         return Self{
             template,
             application: InferenceRuleTemplateApplication::Template,
+        }
+    }
+}
 #[derive(Clone, Copy)]
 enum InferenceRuleTemplateApplication {
     None, // do not apply template, silly, but saves some bytes
     Forced,
     Template,
+}
 /// Type equality applied to 'self' and the argument. An optional template will
 /// be applied to 'self' first. Example: "bitwise not"
 struct InferenceRuleBiEqual {
     template: InferenceRuleTemplate,
     argument_index: InferNodeIndex,
+}
 /// Type equality applied to two arguments. Template can be applied to 'self'
 /// (generally forced, since this rule does not apply a type equality constraint
 /// to 'self') and the two arguments. Example: "equality operator"
 struct InferenceRuleTriEqualArgs {
     argument_template: InferenceRuleTemplate,
     result_template: InferenceRuleTemplate,
     argument1_index: InferNodeIndex,
     argument2_index: InferNodeIndex,
+}
 /// Type equality applied to 'self' and two arguments. Template may be
 /// optionally applied to 'self'. Example: "addition operator"
 struct InferenceRuleTriEqualAll {
     template: InferenceRuleTemplate,
     argument1_index: InferNodeIndex,
     argument2_index: InferNodeIndex,
+}
 /// Information for an inference rule that is applied to 'self' and two
 /// arguments, see `InferenceRule` for its meaning.
 struct InferenceRuleTwoArgs {
     argument1_index: InferNodeIndex,
     argument2_index: InferNodeIndex,
+}
 struct InferenceRuleIndexingExpr {
     subject_index: InferNodeIndex,
     index_index: InferNodeIndex,
+}
 struct InferenceRuleSlicingExpr {
     subject_index: InferNodeIndex,
     from_index: InferNodeIndex,
     to_index: InferNodeIndex,
+}
 struct InferenceRuleSelectStructField {
     subject_index: InferNodeIndex,
     selected_field: Identifier,
+}
 struct InferenceRuleSelectTupleMember {
     subject_index: InferNodeIndex,
     selected_index: u64,
+}
 struct InferenceRuleLiteralStruct {
     element_indices: Vec<InferNodeIndex>,
+}
 struct InferenceRuleLiteralEnum {
+}
 struct InferenceRuleLiteralUnion {
     element_indices: Vec<InferNodeIndex>
+}
 struct InferenceRuleLiteralArray {
     element_indices: Vec<InferNodeIndex>
+}
 struct InferenceRuleLiteralTuple {
     element_indices: Vec<InferNodeIndex>
+}
 struct InferenceRuleCastExpr {
     subject_index: InferNodeIndex,
+}
 struct InferenceRuleCallExpr {
     argument_indices: Vec<InferNodeIndex>
+}
 /// Data associated with a variable expression: an expression that reads the
 /// value from a variable.
 struct InferenceRuleVariableExpr {
     variable_index: InferNodeIndex,
+}
 /// Data associated with a variable: keeping track of all the variable
 /// expressions in which it is used.
 struct InferenceRuleVariable {
     used_at_indices: Vec<InferNodeIndex>,
+}
 /// This particular visitor will recurse depth-first into the AST and ensures
 /// that all expressions have the appropriate types.
 pub(crate) struct PassTyping {
     // Current definition we're typechecking.
     reserved_type_id: TypeId,
     definition_type: DefinitionType,
     poly_vars: Vec<ConcreteType>,
     // Temporary variables during construction of inference rulesr
     parent_index: Option<InferNodeIndex>,
     // Buffers for iteration over various types
     var_buffer: ScopedBuffer<VariableId>,
     expr_buffer: ScopedBuffer<ExpressionId>,
     stmt_buffer: ScopedBuffer<StatementId>,
     bool_buffer: ScopedBuffer<bool>,
     index_buffer: ScopedBuffer<usize>,
     poly_progress_buffer: ScopedBuffer<u32>,
     // Mapping from parser type to inferred type. We attempt to continue to
     // 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
     poly_data: Vec<PolyData>,       // data for polymorph inference
     // 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>,
+}
 /// Generic struct that is used to store inferred types associated with
 /// polymorphic types.
 struct PolyData {
     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,
+}
 impl Default for PolyData {
     fn default() -> Self {
         Self {
             definition_id: DefinitionId::new_invalid(),
             poly_vars: Vec::new(),
             associated: Vec::new(),
             returned: InferenceType::default(),
+        }
+    }
+}
 #[derive(Clone, Copy)]
 enum PolyDataTypeIndex {
     Associated(usize), // indexes into `PolyData.associated`
     Returned,
+}
 impl PolyData {
     fn get_type(&self, index: PolyDataTypeIndex) -> &InferenceType {
         match index {
             PolyDataTypeIndex::Associated(index) => return &self.associated[index],
@@ @@ -2289,244 +2289,440 @@ impl PassTyping { @@
+            }
             // Nothing is known yet
             return Ok(None);
+        }
         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(
                             &ctx.module().source, rule.selected_field.span, format!(
                                 "Can only apply field access to structs, got a subject of type '{}'",
                                 subject_type.display_name(&ctx.heap)
+                            )
                         ));
                     };
                     // 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() {
                         if field.identifier.value == rule.selected_field.value {
                             // 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(
                             &ctx.module().source, rule.selected_field.span, format!(
                                 "this field does not exist on the struct '{}'",
                                 ast_struct_def.identifier.value.as_str()
+                            )
                         ));
+                    }
                     // 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 '{}'",
                             subject_type.display_name(&ctx.heap)
+                        )
                     ));
                 },
+            }
+        }
         // 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();
         let (_, progress_subject_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, subject_expr_id, "selected struct's",
             PolyDataTypeIndex::Associated(0), 0, subject_index, 0, &mut poly_progress_section
         )?;
         let (_, progress_field_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, field_expr_id, "selected field's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         // Maybe make progress on types due to inferred polymorphic variables
         let progress_subject_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Associated(0), subject_index, &poly_progress_section
         );
         let progress_field_2 = self.apply_polydata_polyvar_constraint(
             ctx, node_index, PolyDataTypeIndex::Returned, node_index, &poly_progress_section
         );
         if progress_subject_1 || progress_subject_2 { self.queue_node(subject_index); }
         if progress_field_1 || progress_field_2 { self.queue_node_parent(node_index); }
         poly_progress_section.forget();
         return Ok(())
+    }
     fn progress_inference_rule_select_tuple_member(&mut self, ctx: &mut Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_select_tuple_member();
         let subject_index = rule.subject_index;
         let tuple_member_index = rule.selected_index;
         fn get_tuple_size_from_inference_type(inference_type: &InferenceType) -> Result<Option<u32>, ()> {
             for part in &inference_type.parts {
                 if part.is_marker() { continue; }
                 if !part.is_concrete() { break; }
                 if let InferenceTypePart::Tuple(size) = part {
                     return Ok(Some(*size));
                 } else {
                     return Err(()); // not a tuple!
+                }
+            }
             return Ok(None);
+        }
         if node.field_or_monomorph_index < 0 {
             let subject_type = &self.infer_nodes[subject_index].expr_type;
             let tuple_size = get_tuple_size_from_inference_type(subject_type);
             let tuple_size = match tuple_size {
                 Ok(Some(tuple_size)) => {
                     tuple_size
                 },
                 Ok(None) => {
                     // We can't infer anything yet
                     return Ok(())
                 },
                 Err(()) => {
                     let select_expr_span = ctx.heap[node.expr_id].full_span();
                     return Err(ParseError::new_error_at_span(
                         &ctx.module().source, select_expr_span, format!(
                             "tuple element select cannot be applied to a subject of type '{}'",
                             subject_type.display_name(&ctx.heap)
+                        )
                     ));
+                }
             };
             // If here then we at least have the tuple size. Now check if the
             // index doesn't exceed that size.
             if tuple_member_index >= tuple_size as u64 {
                 let select_expr_span = ctx.heap[node.expr_id].full_span();
                 return Err(ParseError::new_error_at_span(
                     &ctx.module().source, select_expr_span, format!(
                         "element index {} is out of bounds, tuple has {} elements",
                         tuple_member_index, tuple_size
+                    )
                 ));
+            }
             // Within bounds, set index on the type inference node
             let node = &mut self.infer_nodes[node_index];
             node.field_or_monomorph_index = tuple_member_index as i32;
+        }
         // 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(
             ctx, node_index, node_index, 0, subject_index, selected_member_start_idx
         )?;
         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();
         for (field_index, field_node_index) in rule.element_indices.iter().copied().enumerate() {
             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(
             ctx, node_index, node.expr_id, "struct literal's",
             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.
         for (field_index, field_node_index) in rule.element_indices.iter().copied().enumerate() {
             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();
         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 rule = node.inference_rule.as_literal_enum();
         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(
             ctx, node_index, node.expr_id, "enum literal's",
             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();
         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();
         for (embedded_index, embedded_node_index) in rule.element_indices.iter().copied().enumerate() {
             let embedded_node_expr_id = self.infer_nodes[embedded_node_index].expr_id;
             let (_, progress_embedded) = self.apply_polydata_equal2_constraint(
                 ctx, node_index, embedded_node_expr_id, "embedded value's",
                 PolyDataTypeIndex::Associated(embedded_index), 0,
                 embedded_node_index, 0, &mut poly_progress_section
             )?;
             if progress_embedded { self.queue_node(embedded_node_index); }
+        }
         let (_, progress_literal_1) = self.apply_polydata_equal2_constraint(
             ctx, node_index, node.expr_id, "union's",
             PolyDataTypeIndex::Returned, 0, node_index, 0, &mut poly_progress_section
         )?;
         // Propagate progress in the polymorphic variables to the expressions
         // that constitute the union literal.
         for (embedded_index, embedded_node_index) in rule.element_indices.iter().copied().enumerate() {
             let progress_embedded = self.apply_polydata_polyvar_constraint(
                 ctx, node_index, PolyDataTypeIndex::Associated(embedded_index),
                 embedded_node_index, &poly_progress_section
             );
             if progress_embedded { self.queue_node(embedded_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();
         return Ok(());
+    }
     fn progress_inference_rule_literal_array(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_literal_array();
         // Apply equality rule to all of the elements that form the array
         let argument_node_indices = self.index_buffer.start_section_initialized(&rule.element_indices);
         let mut argument_progress_section = self.bool_buffer.start_section();
         self.apply_equal_n_constraint(ctx, node_index, &argument_node_indices, &mut argument_progress_section)?;
         debug_assert_eq!(argument_node_indices.len(), argument_progress_section.len());
         for argument_index in 0..argument_node_indices.len() {
             let argument_node_index = argument_node_indices[argument_index];
             let progress = argument_progress_section[argument_index];
             if progress { self.queue_node(argument_node_index); }
+        }
         // If elements are of type `T`, then the array is of type `Array<T>`, so:
         let mut progress_literal = self.apply_template_constraint(ctx, node_index, &ARRAY_TEMPLATE)?;
         if argument_node_indices.len() != 0 {
             let argument_node_index = argument_node_indices[0];
             let (progress_literal_inner, progress_argument) = self.apply_equal2_constraint(
                 ctx, node_index, node_index, 1, argument_node_index, 0
             )?;
             progress_literal = progress_literal || progress_literal_inner;
             // It is possible that the `Array<T>` has a more progress `T` then
             // the arguments. So in the case we progress our argument type we
             // simply queue this rule again
             if progress_argument { self.queue_expr(node_index); }
+        }
         argument_node_indices.forget();
         argument_progress_section.forget();
         if progress_literal { self.queue_node_parent(node_index); }
         return Ok(());
+    }
     fn progress_inference_rule_literal_tuple(&mut self, ctx: &Ctx, node_index: InferNodeIndex) -> Result<(), ParseError> {
         let node = &self.infer_nodes[node_index];
         let rule = node.inference_rule.as_literal_tuple();
+    }
     fn progress_template(&mut self, ctx: &Ctx, node_index: InferNodeIndex, application: InferenceRuleTemplateApplication, template: &[InferenceTypePart]) -> Result<bool, ParseError> {
         use InferenceRuleTemplateApplication as TA;
         match application {
             TA::None => Ok(false),
             TA::Template => self.apply_template_constraint(ctx, node_index, template),
             TA::Forced => self.apply_forced_constraint(ctx, node_index, template),
+        }
+    }
     fn progress_expr(&mut self, ctx: &mut Ctx, idx: i32) -> Result<(), ParseError> {
         let id = self.infer_nodes[idx as usize].expr_id;
         match &ctx.heap[id] {
             Expression::Assignment(expr) => {
                 let id = expr.this;
                 self.progress_assignment_expr(ctx, id)
             },
             Expression::Binding(expr) => {
                 let id = expr.this;
                 self.progress_binding_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::Literal(expr) => {
                 let id = expr.this;
                 self.progress_literal_expr(ctx, id)
             },
             Expression::Cast(expr) => {
                 let id = expr.this;
                 self.progress_cast_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, infer_index: InferNodeIndex) -> Result<(), ParseError> {
         use AssignmentOperator as AO;
         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.debug_get_display_name(ctx, arg1_expr_id));
         debug_log!("   - Arg2 type: {}", self.debug_get_display_name(ctx, arg2_expr_id));
         debug_log!("   - Expr type: {}", self.debug_get_display_name(ctx, upcast_id));
         // Assignment does not return anything (it operates like a statement)
         let progress_expr = self.apply_forced_constraint(ctx, upcast_id, &VOID_TEMPLATE)?;
         // Apply forced constraint to LHS value
         let progress_forced = match expr.operation {
             AO::Set =>
                 false,
             AO::Concatenated =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &ARRAYLIKE_TEMPLATE)?,
             AO::Multiplied | AO::Divided | AO::Added | AO::Subtracted =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &NUMBERLIKE_TEMPLATE)?,
             AO::Remained | AO::ShiftedLeft | AO::ShiftedRight |
             AO::BitwiseAnded | AO::BitwiseXored | AO::BitwiseOred =>
                 self.apply_template_constraint(ctx, arg1_expr_id, &INTEGERLIKE_TEMPLATE)?,
         };
         let (progress_arg1, progress_arg2) = self.apply_equal2_constraint(
             ctx, upcast_id, arg1_expr_id, 0, arg2_expr_id, 0
@@ @@ -4057,261 +4253,257 @@ impl PassTyping { @@
     /// This function returns true if the expression's type has been progressed
     fn apply_equal2_polyvar_constraint(
         polymorph_data: &PolyData, _polymorph_progress: &HashSet<u32>,
         signature_type: *mut InferenceType, expr_type: *mut InferenceType
     ) -> bool {
         // Safety: all pointers should be distinct
         //         polymorph_data containers may not be modified
         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 let Some((poly_idx, start_idx)) = signature_type.find_marker(seek_idx) {
             let end_idx = InferenceType::find_subtree_end_idx(&signature_type.parts, start_idx);
             // if polymorph_progress.contains(&poly_idx) {
                 // Need to match subtrees
                 let polymorph_type = &polymorph_data.poly_vars[poly_idx as usize];
                 let modified_at_marker = Self::apply_template_constraint_to_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;
+        }
         // 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, true
             ) {
                 SingleInferenceResult::Modified => true,
                 SingleInferenceResult::Unmodified => false,
                 SingleInferenceResult::Incompatible =>
                     unreachable!("encountered failure while reapplying modified signature to expression after polyvar inference")
+            }
         } else {
             false
+        }
+    }
     /// Applies a type constraint that expects all three provided types to be
     /// equal. In case we can make progress in inferring the types then we
     /// attempt to do so. If the call is successful then the composition of all
     /// types is made equal.
     fn apply_equal3_constraint(
         &mut self, ctx: &Ctx, node_index: InferNodeIndex,
         arg1_index: InferNodeIndex, arg2_index: InferNodeIndex,
         start_idx: usize
     ) -> Result<(bool, bool, bool), ParseError> {
         // Safety: all indices are unique
         //         containers may not be modified
         let expr_type: *mut _ = &mut self.infer_nodes[node_index].expr_type;
         let arg1_type: *mut _ = &mut self.infer_nodes[arg1_index].expr_type;
         let arg2_type: *mut _ = &mut self.infer_nodes[arg2_index].expr_type;
         let expr_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(expr_type, start_idx, arg1_type, start_idx)
         };
         if expr_res == DualInferenceResult::Incompatible {
             return Err(self.construct_expr_type_error(ctx, node_index, arg1_index));
+        }
         let args_res = unsafe{
             InferenceType::infer_subtrees_for_both_types(arg1_type, start_idx, arg2_type, start_idx) };
         if args_res == DualInferenceResult::Incompatible {
             return Err(self.construct_arg_type_error(ctx, node_index, arg1_index, arg2_index));
+        }
         // If all types are compatible, but the second call caused the arg1_type
         // to be expanded, then we must also assign this to expr_type.
         let mut progress_expr = expr_res.modified_lhs();
         let mut progress_arg1 = expr_res.modified_rhs();
         let progress_arg2 = args_res.modified_rhs();
         if args_res.modified_lhs() {
             unsafe {
                 let end_idx = InferenceType::find_subtree_end_idx(&(*arg2_type).parts, start_idx);
                 let subtree = &((*arg2_type).parts[start_idx..end_idx]);
                 (*expr_type).replace_subtree(start_idx, subtree);
+            }
             progress_expr = true;
             progress_arg1 = true;
+        }
         Ok((progress_expr, progress_arg1, progress_arg2))
+    }
     /// Applies equal constraint to N consecutive expressions. The returned
     /// `progress` vec will contain which expressions were progressed and will
     /// have length N
     // If you ever
     /// have length N.
     fn apply_equal_n_constraint(
         &mut self, ctx: &Ctx, expr_id: ExpressionId,
         args: &ScopedSection<ExpressionId>, progress: &mut ScopedSection<bool>
         &mut self, ctx: &Ctx, outer_node_index: InferNodeIndex,
         arguments: &ScopedSection<InferNodeIndex>, progress: &mut ScopedSection<bool>
     ) -> Result<(), ParseError> {
         // Early exit
         // Depending on the argument perform an early exit. This simplifies
         // later logic
         debug_assert_eq!(progress.len(), 0);
-        match args.len() {
+        match arguments.len() {
 => {
                 // nothing to progress
                 return Ok(())
             },
 => {
                 // only one type, so nothing to infer
                 progress.push(false);
                 return Ok(())
             },
             n => {
                 for _ in 0..n {
                     progress.push(false);
+                }
+            }
+        }
         // Do pairwise inference, keep track of the last entry we made progress
         // on. Once done we need to update everything to the most-inferred type.
         let mut arg_iter = args.iter_copied();
         let mut last_arg_id = arg_iter.next().unwrap();
         let mut last_lhs_progressed = 0;
         let mut lhs_arg_idx = 0;
         while let Some(next_arg_id) = arg_iter.next() {
             let last_expr_idx = ctx.heap[last_arg_id].get_unique_id_in_definition(); // TODO: @Temp
             let next_expr_idx = ctx.heap[next_arg_id].get_unique_id_in_definition();
             let last_type: *mut _ = &mut self.infer_nodes[last_expr_idx as usize].expr_type;
             let next_type: *mut _ = &mut self.infer_nodes[next_expr_idx as usize].expr_type;
             let res = unsafe {
                 InferenceType::infer_subtrees_for_both_types(last_type, 0, next_type, 0)
             };
         // We'll start doing pairwise inference for all of the inference nodes
         // (node[0] with node[1], then node[1] with node[2], then node[2] ...,
         // etc.), so when we're at the end we have `node[N-1]` as the most
         // progressed type.
         let mut last_index_requiring_inference = 0;
             if res == DualInferenceResult::Incompatible {
                 return Err(self.construct_arg_type_error(ctx, expr_id, last_arg_id, next_arg_id));
+            }
         for prev_argument_index in 0..arguments.len() - 1 {
             let next_argument_index = prev_argument_index + 1;
             if res.modified_lhs() {
                 // We re-inferred something on the left hand side, so everything
                 // up until now should be re-inferred.
                 progress[lhs_arg_idx] = true;
                 last_lhs_progressed = lhs_arg_idx;
+            }
             progress[lhs_arg_idx + 1] = res.modified_rhs();
             let prev_node_index = arguments[prev_argument_index];
             let next_node_index = arguments[next_argument_index];
             let (prev_progress, next_progress) = self.apply_equal2_constraint(
                 ctx, outer_node_index, prev_node_index, 0, next_node_index, 0
             )?;
             last_arg_id = next_arg_id;
             lhs_arg_idx += 1;
             if prev_progress {
                 // Previous node is progress, so every type in front of it needs
                 // to be reinferred.
                 progress[prev_argument_index] = true;
                 last_index_requiring_inference = prev_argument_index;
+            }
             progress[next_argument_index] = next_progress;
+        }
         // Re-infer everything. Note that we do not need to re-infer the type
         // exactly at `last_lhs_progressed`, but only everything up to it.
         let last_arg_expr_idx = ctx.heap[last_arg_id].get_unique_id_in_definition();
         let last_type: *mut _ = &mut self.infer_nodes[last_arg_expr_idx as usize].expr_type;
         for arg_idx in 0..last_lhs_progressed {
             let other_arg_expr_idx = ctx.heap[args[arg_idx]].get_unique_id_in_definition();
             let arg_type: *mut _ = &mut self.infer_nodes[other_arg_expr_idx as usize].expr_type;
             unsafe{
                 (*arg_type).replace_subtree(0, &(*last_type).parts);
         // Apply inference using the most progressed type (the last one) to the
         // ones that did not obtain this information during the inference
         // process.
         let last_argument_node_index = arguments[arguments.len() - 1];
         let last_argument_type: *mut _ = &mut self.infer_nodes[last_argument_node_index].expr_type;
         for argument_index in 0..last_index_requiring_inference {
             // We can cheat, we know the LHS is less specific than the right
             // hand side, so:
             let argument_node_index = arguments[argument_index];
             let argument_type = &mut self.infer_nodes[argument_node_index].expr_type;
             unsafe {
                 // safety: we're dealing with different vectors, so cannot alias
                 argument_type.replace_subtree(0, &(*last_argument_type).parts);
+            }
-            progress[arg_idx] = true;
+            progress[argument_index] = true;
+        }
         return Ok(());
+    }
     /// Determines the `InferenceType` for the expression based on the
     /// expression parent (this is not done if the parent is a regular 'ol
     /// expression). Expects `parent_index` to be set to the parent of the
     /// inference node that is created here.
     fn insert_initial_inference_node(
         &mut self, ctx: &mut Ctx, expr_id: ExpressionId
     ) -> Result<InferNodeIndex, ParseError> {
         use ExpressionParent as EP;
         use InferenceTypePart as ITP;
         // Set the initial inference type based on the expression parent.
         let expr = &ctx.heap[expr_id];
         let inference_type = match expr.parent() {
             EP::None =>
                 // Should have been set by linker
                 unreachable!(),
             EP::Memory(_) | EP::ExpressionStmt(_) =>
                 // Determined during type inference
                 InferenceType::new(false, false, vec![ITP::Unknown]),
             EP::Expression(parent_id, idx_in_parent) => {
                 // If we are the test expression of a conditional expression,
                 // then we must resolve to a boolean
                 let is_conditional = if let Expression::Conditional(_) = &ctx.heap[*parent_id] {
                     true
                 } else {
                     false
                 };
                 if is_conditional && *idx_in_parent == 0 {
                     InferenceType::new(false, true, vec![ITP::Bool])
                 } else {
                     InferenceType::new(false, false, vec![ITP::Unknown])
+                }
             },
             EP::If(_) | EP::While(_) =>
                 // Must be a boolean
                 InferenceType::new(false, true, vec![ITP::Bool]),
             EP::Return(_) =>
                 // Must match the return type of the function
                 if let DefinitionType::Function(func_id) = self.definition_type {
                     let returned = &ctx.heap[func_id].return_type;
                     self.determine_inference_type_from_parser_type_elements(&returned.elements, true)
                 } else {
                     // Cannot happen: definition always set upon body traversal
                     // and "return" calls in components are illegal.
                     unreachable!();
                 },
             EP::New(_) =>
                 // Must be a component call, which we assign a "Void" return
                 // type
                 InferenceType::new(false, true, vec![ITP::Void]),
         };
         let infer_index = self.infer_nodes.len() as InferNodeIndex;
         self.infer_nodes.push(InferenceNode {
             expr_type: inference_type,
             expr_id,
             parent_index: self.parent_index,
             field_or_monomorph_index: -1,
             extra_data_idx: -1,
             type_id: TypeId::new_invalid(),
         });
         return Ok(infer_index);
+    }
     fn insert_initial_call_polymorph_data(
         &mut self, ctx: &mut Ctx, call_id: CallExpressionId
     ) -> PolyDataIndex {
         // 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.
         //
         // The arguments of the call may refer to polymorphic variables in the
         // definition of the function we're calling, not of the wrapping
         // definition. We insert markers in these inferred types to be able to
         // map them back and forth to the polymorphic arguments of the function
         // we are calling.
         let call = &ctx.heap[call_id];
         // Handle the polymorphic arguments (if there are any)
         let num_poly_args = call.parser_type.elements[0].variant.num_embedded();
         let mut poly_args = Vec::with_capacity(num_poly_args);
         for embedded_elements in call.parser_type.iter_embedded(0) {
             poly_args.push(self.determine_inference_type_from_parser_type_elements(embedded_elements, true));
+        }
         // Handle the arguments and return types
         let definition = &ctx.heap[call.definition];
         let (parameters, returned) = match definition {
             Definition::Component(definition) => {

0 comments (0 inline, 0 general)