language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-07-24 06:55:15 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Weaken let-binding calls

Browse source
This commit is contained in:
Ayaz Hafiz 2023-01-12 10:37:44 -06:00 • committed by Folkert
parent d27a72de1f
commit cb1373a3a4
No known key found for this signature in database
GPG key ID: 1F17F6FFD112B97C
3 changed files with 25 additions and 77 deletions
Download patch file Download diff file Expand all files Collapse all files

2
crates/compiler/constrain/src/expr.rs
View file

@ -3829,13 +3829,13 @@ fn is_generalizable_expr(mut expr: &Expr) -> bool {
Str(_) | List { .. } | SingleQuote(_, _, _, _) | When { .. } | If { .. } Str(_) | List { .. } | SingleQuote(_, _, _, _) | When { .. } | If { .. }
| LetRec(_, _, _) | LetRec(_, _, _)
| LetNonRec(_, _) | LetNonRec(_, _)
| Call(_, _, _)
=> { => {
return false return false
} }
// TODO(weakening) // TODO(weakening)
Var(_, _) Var(_, _)
| AbilityMember(_, _, _) | AbilityMember(_, _, _)
| Call(_, _, _)
| RunLowLevel { .. } | RunLowLevel { .. }
| ForeignCall { .. } | ForeignCall { .. }
| Expr::Record { .. } | Expr::Record { .. }

19
crates/compiler/solve/tests/solve_expr.rs
View file

@ -7264,7 +7264,7 @@ mod solve_expr {
} }
#[test] #[test]
fn polymorphic_lambda_set_specialization_with_let_generalization() { fn polymorphic_lambda_set_specialization_with_let_weakened() {
infer_queries!( infer_queries!(
indoc!( indoc!(
r#" r#"
@ -7282,6 +7282,7 @@ mod solve_expr {
#^{-1} #^{-1}
main = main =
# h should get weakened
h = f (@Fo {}) h = f (@Fo {})
# ^ ^ # ^ ^
h (@Go {}) h (@Go {})
@ -7291,15 +7292,15 @@ mod solve_expr {
@r###" @r###"
Fo#f(7) : Fo -[[f(7)]]-> (b -[[] + b:g(4):1]-> {}) | b has G Fo#f(7) : Fo -[[f(7)]]-> (b -[[] + b:g(4):1]-> {}) | b has G
Go#g(8) : Go -[[g(8)]]-> {} Go#g(8) : Go -[[g(8)]]-> {}
h : b -[[] + b:g(4):1]-> {} | b has G h : Go -[[g(8)]]-> {}
Fo#f(7) : Fo -[[f(7)]]-> (b -[[] + b:g(4):1]-> {}) | b has G Fo#f(7) : Fo -[[f(7)]]-> (Go -[[g(8)]]-> {})
h : Go -[[g(8)]]-> {} h : Go -[[g(8)]]-> {}
"### "###
); );
} }
#[test] #[test]
fn polymorphic_lambda_set_specialization_with_let_generalization_unapplied() { fn polymorphic_lambda_set_specialization_with_let_weakened_unapplied() {
infer_queries!( infer_queries!(
indoc!( indoc!(
r#" r#"
@ -7461,9 +7462,9 @@ mod solve_expr {
main = main =
#^^^^{-1} #^^^^{-1}
it = it = \x ->
# ^^ # ^^
(f A (@C {}) (@D {})) (f A (@C {}) (@D {})) x
# ^ # ^
if Bool.true if Bool.true
then it (@E {}) then it (@E {})
@ -7484,10 +7485,10 @@ mod solve_expr {
J#j(2) : j -[[] + j:j(2):1]-> (k -[[] + j1:j(2):2 + j:j(2):2]-> {}) | j has J, j1 has J, k has K J#j(2) : j -[[] + j:j(2):1]-> (k -[[] + j1:j(2):2 + j:j(2):2]-> {}) | j has J, j1 has J, k has K
it : k -[[] + j:j(2):2 + j1:j(2):2]-> {} | j has J, j1 has J, k has K it : k -[[] + j:j(2):2 + j1:j(2):2]-> {} | j has J, j1 has J, k has K
main : {} main : {}
it : k -[[] + k:k(4):1]-> {} | k has K it : k -[[it(21)]]-> {} | k has K
f : [A, B], C, D -[[f(13)]]-> (k -[[] + k:k(4):1]-> {}) | k has K f : [A, B], C, D -[[f(13)]]-> (k -[[] + k:k(4):1]-> {}) | k has K
it : E -[[kE(11)]]-> {} it : E -[[it(21)]]-> {}
it : F -[[kF(12)]]-> {} it : F -[[it(21)]]-> {}
"### "###
); );
} }

81
crates/compiler/test_mono/generated/anonymous_closure_in_polymorphic_expression_issue_4717.txt
View file

@ -1,7 +1,3 @@
procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.23 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.23;
procedure Bool.11 (#Attr.2, #Attr.3): procedure Bool.11 (#Attr.2, #Attr.3):
let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3; let Bool.24 : Int1 = lowlevel Eq #Attr.2 #Attr.3;
ret Bool.24; ret Bool.24;
@ -18,18 +14,6 @@ procedure List.26 (List.152, List.153, List.154):
let List.156 : U64 = UnionAtIndex (Id 0) (Index 0) List.493; let List.156 : U64 = UnionAtIndex (Id 0) (Index 0) List.493;
ret List.156; ret List.156;
procedure List.26 (List.152, List.153, List.154):
let List.515 : [C I64, C I64] = CallByName List.90 List.152 List.153 List.154;
let List.518 : U8 = 1i64;
let List.519 : U8 = GetTagId List.515;
let List.520 : Int1 = lowlevel Eq List.518 List.519;
if List.520 then
let List.155 : I64 = UnionAtIndex (Id 1) (Index 0) List.515;
ret List.155;
else
let List.156 : I64 = UnionAtIndex (Id 0) (Index 0) List.515;
ret List.156;
procedure List.29 (List.294, List.295): procedure List.29 (List.294, List.295):
let List.492 : U64 = CallByName List.6 List.294; let List.492 : U64 = CallByName List.6 List.294;
let List.296 : U64 = CallByName Num.77 List.492 List.295; let List.296 : U64 = CallByName Num.77 List.492 List.295;
@ -75,13 +59,7 @@ procedure List.90 (List.426, List.427, List.428):
let List.499 : [C U64, C U64] = CallByName List.91 List.426 List.427 List.428 List.500 List.501; let List.499 : [C U64, C U64] = CallByName List.91 List.426 List.427 List.428 List.500 List.501;
ret List.499; ret List.499;
procedure List.90 (List.426, List.427, List.428): procedure List.91 (List.528, List.529, List.530, List.531, List.532):
let List.522 : U64 = 0i64;
let List.523 : U64 = CallByName List.6 List.426;
let List.521 : [C I64, C I64] = CallByName List.91 List.426 List.427 List.428 List.522 List.523;
ret List.521;
procedure List.91 (List.549, List.550, List.551, List.552, List.553):
joinpoint List.502 List.429 List.430 List.431 List.432 List.433: joinpoint List.502 List.429 List.430 List.431 List.432 List.433:
let List.504 : Int1 = CallByName Num.22 List.432 List.433; let List.504 : Int1 = CallByName Num.22 List.432 List.433;
if List.504 then if List.504 then
@ -103,66 +81,35 @@ procedure List.91 (List.549, List.550, List.551, List.552, List.553):
let List.503 : [C U64, C U64] = TagId(1) List.430; let List.503 : [C U64, C U64] = TagId(1) List.430;
ret List.503; ret List.503;
in in
jump List.502 List.549 List.550 List.551 List.552 List.553; jump List.502 List.528 List.529 List.530 List.531 List.532;
procedure List.91 (List.562, List.563, List.564, List.565, List.566):
joinpoint List.524 List.429 List.430 List.431 List.432 List.433:
let List.526 : Int1 = CallByName Num.22 List.432 List.433;
if List.526 then
let List.535 : U8 = CallByName List.66 List.429 List.432;
let List.527 : [C I64, C I64] = CallByName Test.4 List.430 List.535;
let List.532 : U8 = 1i64;
let List.533 : U8 = GetTagId List.527;
let List.534 : Int1 = lowlevel Eq List.532 List.533;
if List.534 then
let List.434 : I64 = UnionAtIndex (Id 1) (Index 0) List.527;
let List.530 : U64 = 1i64;
let List.529 : U64 = CallByName Num.19 List.432 List.530;
jump List.524 List.429 List.434 List.431 List.529 List.433;
else
let List.435 : I64 = UnionAtIndex (Id 0) (Index 0) List.527;
let List.531 : [C I64, C I64] = TagId(0) List.435;
ret List.531;
else
let List.525 : [C I64, C I64] = TagId(1) List.430;
ret List.525;
in
jump List.524 List.562 List.563 List.564 List.565 List.566;
procedure Num.19 (#Attr.2, #Attr.3): procedure Num.19 (#Attr.2, #Attr.3):
let Num.259 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; let Num.258 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.259; ret Num.258;
procedure Num.22 (#Attr.2, #Attr.3): procedure Num.22 (#Attr.2, #Attr.3):
let Num.261 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; let Num.259 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.261; ret Num.259;
procedure Num.77 (#Attr.2, #Attr.3): procedure Num.77 (#Attr.2, #Attr.3):
let Num.257 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3; let Num.257 : U64 = lowlevel NumSubSaturated #Attr.2 #Attr.3;
ret Num.257; ret Num.257;
procedure Test.1 (Test.2): procedure Test.1 (Test.2):
let Test.18 : I64 = 0i64; let Test.13 : U64 = 0i64;
let Test.19 : {} = Struct {}; let Test.14 : {} = Struct {};
let Test.12 : I64 = CallByName List.26 Test.2 Test.18 Test.19; let Test.3 : U64 = CallByName List.26 Test.2 Test.13 Test.14;
let Test.14 : U64 = 0i64; let Test.12 : U64 = 0i64;
let Test.15 : {} = Struct {}; let Test.10 : Int1 = CallByName Bool.11 Test.3 Test.12;
let Test.3 : U64 = CallByName List.26 Test.2 Test.14 Test.15;
let Test.13 : I64 = 0i64;
let Test.10 : Int1 = CallByName Bool.11 Test.12 Test.13;
if Test.10 then if Test.10 then
ret Test.2; ret Test.2;
else else
let Test.9 : List U8 = CallByName List.29 Test.2 Test.3; let Test.9 : List U8 = CallByName List.29 Test.2 Test.3;
ret Test.9; ret Test.9;
procedure Test.4 (Test.5, Test.16): procedure Test.4 (Test.5, Test.15):
let Test.17 : [C U64, C U64] = TagId(0) Test.5; let Test.16 : [C U64, C U64] = TagId(0) Test.5;
ret Test.17; ret Test.16;
procedure Test.4 (Test.5, Test.16):
let Test.21 : [C U64, C U64] = TagId(0) Test.5;
ret Test.21;
procedure Test.0 (): procedure Test.0 ():
let Test.8 : List U8 = Array [1i64, 2i64, 3i64]; let Test.8 : List U8 = Array [1i64, 2i64, 3i64];