Store lambda set variables as flex inference variables

This is actually correct - the rigid approach is not. Lambda set variables should be inferred in-scope.
roc-lang · Jan 6, 2025 · 561f3d9 · 561f3d9
1 parent 54cc5e4
commit 561f3d9
Show file tree

Hide file tree

Showing 3 changed files with 9 additions and 12 deletions.
diff --git a/crates/compiler/constrain/src/expr.rs b/crates/compiler/constrain/src/expr.rs
@@ -3808,19 +3808,18 @@ fn instantiate_rigids(
         // wildcards are always freshly introduced in this annotation
         new_rigid_variables.extend(introduced_vars.wildcards.iter().copied());
 
-        // lambda set vars are always freshly introduced in this annotation
-        new_rigid_variables.extend(introduced_vars.lambda_sets.iter().map(|&v| Loc::at_zero(v)));
+        let has_explicit_inference_variables = !introduced_vars.inferred.is_empty();
 
+        new_infer_variables.extend(introduced_vars.inferred.iter().copied());
         // ext-infer vars are always freshly introduced in this annotation
         new_infer_variables.extend(
             introduced_vars
                 .infer_ext_in_output
                 .iter()
                 .map(|&v| Loc::at_zero(v)),
         );
-
-        let has_explicit_inference_variables = !introduced_vars.inferred.is_empty();
-        new_infer_variables.extend(introduced_vars.inferred.iter().copied());
+        // lambda set vars are always freshly introduced in this annotation
+        new_infer_variables.extend(introduced_vars.lambda_sets.iter().map(|&v| Loc::at_zero(v)));
 
         // Instantiate rigid variables
         if !rigid_substitution.is_empty() {
@@ -3900,19 +3899,17 @@ fn instantiate_rigids_simple(
     // wildcards are always freshly introduced in this annotation
     new_rigid_variables.extend(introduced_vars.wildcards.iter().copied());
 
-    // lambda set vars are always freshly introduced in this annotation
-    new_rigid_variables.extend(introduced_vars.lambda_sets.iter().map(|&v| Loc::at_zero(v)));
-
     let has_explicit_inference_variables = !introduced_vars.inferred.is_empty();
     let mut new_infer_variables: Vec<Loc<Variable>> = introduced_vars.inferred.clone();
-
     // ext-infer vars are always freshly introduced in this annotation
     new_infer_variables.extend(
         introduced_vars
             .infer_ext_in_output
             .iter()
             .map(|&v| Loc::at_zero(v)),
     );
+    // lambda set vars are always freshly introduced in this annotation
+    new_infer_variables.extend(introduced_vars.lambda_sets.iter().map(|&v| Loc::at_zero(v)));
 
     // Instantiate rigid variables
     if !rigid_substitution.is_empty() {

diff --git a/crates/compiler/uitest/tests/recursion/calls_result_in_unique_specializations.txt b/crates/compiler/uitest/tests/recursion/calls_result_in_unique_specializations.txt
@@ -7,7 +7,7 @@ main =
 #   ^^^ a, Bool -[[foo(1)]]-> Str
 
     bar = \_ -> foo {} Bool.true
-#               ^^^ {}, Bool -[[]]-> Str
+#               ^^^ {}, Bool -[[foo(1)]]-> Str
 
     foo "" Bool.false
 #   ^^^{inst} Str, Bool -[[foo(1)]]-> Str

diff --git a/...mpiler/uitest/tests/recursion/constrain_recursive_annotation_independently_issue_5256.txt b/...mpiler/uitest/tests/recursion/constrain_recursive_annotation_independently_issue_5256.txt
@@ -5,8 +5,8 @@ main =
 
     map : { f1: (I64 -> I64) } -> List I64
     map = \{ f1 } -> List.concat [f1 1] (map { f1 })
-#                                        ^^^ { f1 : I64 -[[]]-> I64 } -[[map(2)]]-> List I64
-#   ^^^ { f1 : I64 -[[]]-> I64 } -[[map(2)]]-> List I64
+#                                        ^^^ { f1 : I64 -[[f(1)]]-> I64 } -[[map(2)]]-> List I64
+#   ^^^ { f1 : I64 -[[f(1)]]-> I64 } -[[map(2)]]-> List I64
 
 
     map { f1: f }