mirror of
https://github.com/roc-lang/roc.git
synced 2025-08-04 04:08:19 +00:00
Ayaz Hafiz
parent
238e64c0b3
commit
1916a6dba5
2 changed files with 223 additions and 0 deletions
199
crates/compiler/test_mono/generated/issue_4770.txt
Normal file
199
crates/compiler/test_mono/generated/issue_4770.txt
Normal file
|
|
@ -0,0 +1,199 @@
|
|||
procedure Bool.1 ():
|
||||
let Bool.25 : Int1 = false;
|
||||
ret Bool.25;
|
||||
|
||||
procedure Bool.2 ():
|
||||
let Bool.24 : Int1 = true;
|
||||
ret Bool.24;
|
||||
|
||||
procedure List.188 (List.496, List.189, List.187):
|
||||
let List.526 : Int1 = CallByName Test.1 List.189;
|
||||
if List.526 then
|
||||
let List.528 : {} = Struct {};
|
||||
let List.527 : [C {}, C {}] = TagId(1) List.528;
|
||||
ret List.527;
|
||||
else
|
||||
let List.525 : {} = Struct {};
|
||||
let List.524 : [C {}, C {}] = TagId(0) List.525;
|
||||
ret List.524;
|
||||
|
||||
procedure List.23 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.529 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListMap2 { xs: `#Attr.#arg1`, ys: `#Attr.#arg2` } #Attr.2 #Attr.3 Test.15 #Attr.4;
|
||||
decref #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.529;
|
||||
|
||||
procedure List.56 (List.186, List.187):
|
||||
let List.505 : {} = Struct {};
|
||||
let List.497 : [C {}, C {}] = CallByName List.92 List.186 List.505 List.187;
|
||||
let List.502 : U8 = 1i64;
|
||||
let List.503 : U8 = GetTagId List.497;
|
||||
let List.504 : Int1 = lowlevel Eq List.502 List.503;
|
||||
if List.504 then
|
||||
let List.498 : Int1 = CallByName Bool.2;
|
||||
ret List.498;
|
||||
else
|
||||
let List.499 : Int1 = CallByName Bool.1;
|
||||
ret List.499;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.495 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.495;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.523 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.523;
|
||||
|
||||
procedure List.66 (#Attr.2, #Attr.3):
|
||||
let List.522 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.522;
|
||||
|
||||
procedure List.80 (List.534, List.535, List.536, List.537, List.538):
|
||||
joinpoint List.510 List.433 List.434 List.435 List.436 List.437:
|
||||
let List.512 : Int1 = CallByName Num.22 List.436 List.437;
|
||||
if List.512 then
|
||||
let List.521 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.66 List.433 List.436;
|
||||
let List.513 : [C {}, C {}] = CallByName List.188 List.434 List.521 List.435;
|
||||
let List.518 : U8 = 1i64;
|
||||
let List.519 : U8 = GetTagId List.513;
|
||||
let List.520 : Int1 = lowlevel Eq List.518 List.519;
|
||||
if List.520 then
|
||||
let List.438 : {} = UnionAtIndex (Id 1) (Index 0) List.513;
|
||||
let List.516 : U64 = 1i64;
|
||||
let List.515 : U64 = CallByName Num.19 List.436 List.516;
|
||||
jump List.510 List.433 List.438 List.435 List.515 List.437;
|
||||
else
|
||||
dec List.433;
|
||||
let List.439 : {} = UnionAtIndex (Id 0) (Index 0) List.513;
|
||||
let List.517 : [C {}, C {}] = TagId(0) List.439;
|
||||
ret List.517;
|
||||
else
|
||||
dec List.433;
|
||||
let List.511 : [C {}, C {}] = TagId(1) List.434;
|
||||
ret List.511;
|
||||
in
|
||||
jump List.510 List.534 List.535 List.536 List.537 List.538;
|
||||
|
||||
procedure List.92 (List.430, List.431, List.432):
|
||||
let List.508 : U64 = 0i64;
|
||||
let List.509 : U64 = CallByName List.6 List.430;
|
||||
let List.507 : [C {}, C {}] = CallByName List.80 List.430 List.431 List.432 List.508 List.509;
|
||||
ret List.507;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.280 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
ret Num.280;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.278 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.278;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.281 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
ret Num.281;
|
||||
|
||||
procedure Test.1 (Test.77):
|
||||
joinpoint Test.26 Test.6:
|
||||
let Test.65 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
|
||||
inc Test.65;
|
||||
let Test.66 : U8 = 0i64;
|
||||
let Test.67 : U8 = GetTagId Test.65;
|
||||
dec Test.65;
|
||||
let Test.68 : Int1 = lowlevel Eq Test.66 Test.67;
|
||||
if Test.68 then
|
||||
let Test.57 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
|
||||
inc Test.57;
|
||||
let Test.58 : U8 = 0i64;
|
||||
let Test.59 : U8 = GetTagId Test.57;
|
||||
let #Derived_gen.1 : [<r>C I64, C List *self] = Reset { symbol: Test.57, id: UpdateModeId { id: 1 } };
|
||||
let Test.60 : Int1 = lowlevel Eq Test.58 Test.59;
|
||||
if Test.60 then
|
||||
decref #Derived_gen.1;
|
||||
let Test.50 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
|
||||
inc Test.50;
|
||||
let Test.8 : I64 = UnionAtIndex (Id 0) (Index 0) Test.50;
|
||||
dec Test.50;
|
||||
let Test.49 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
|
||||
inc Test.49;
|
||||
dec Test.6;
|
||||
let Test.10 : I64 = UnionAtIndex (Id 0) (Index 0) Test.49;
|
||||
dec Test.49;
|
||||
let Test.27 : Int1 = CallByName Num.22 Test.8 Test.10;
|
||||
ret Test.27;
|
||||
else
|
||||
let Test.39 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
|
||||
inc Test.39;
|
||||
let Test.42 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
|
||||
inc Test.42;
|
||||
dec Test.6;
|
||||
let Test.41 : List [<r>C I64, C List *self] = Array [Test.42];
|
||||
let Test.40 : [<r>C I64, C List *self] = Reuse #Derived_gen.1 UpdateModeId { id: 1 } TagId(1) Test.41;
|
||||
let Test.38 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.39, Test.40};
|
||||
jump Test.26 Test.38;
|
||||
else
|
||||
let Test.61 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
|
||||
inc Test.61;
|
||||
let Test.62 : U8 = 1i64;
|
||||
let Test.63 : U8 = GetTagId Test.61;
|
||||
let #Derived_gen.4 : [<r>C I64, C List *self] = Reset { symbol: Test.61, id: UpdateModeId { id: 4 } };
|
||||
let Test.64 : Int1 = lowlevel Eq Test.62 Test.63;
|
||||
if Test.64 then
|
||||
decref #Derived_gen.4;
|
||||
let Test.52 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
|
||||
inc Test.52;
|
||||
let Test.12 : List [<r>C I64, C List *self] = UnionAtIndex (Id 1) (Index 0) Test.52;
|
||||
inc Test.12;
|
||||
dec Test.52;
|
||||
let Test.51 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
|
||||
inc Test.51;
|
||||
dec Test.6;
|
||||
let Test.14 : List [<r>C I64, C List *self] = UnionAtIndex (Id 1) (Index 0) Test.51;
|
||||
inc Test.14;
|
||||
dec Test.51;
|
||||
let Test.35 : {} = Struct {};
|
||||
inc Test.12;
|
||||
inc Test.14;
|
||||
let Test.33 : List {[<r>C I64, C List *self], [<r>C I64, C List *self]} = CallByName List.23 Test.12 Test.14 Test.35;
|
||||
let Test.34 : {} = Struct {};
|
||||
let Test.29 : Int1 = CallByName List.56 Test.33 Test.34;
|
||||
if Test.29 then
|
||||
let Test.31 : U64 = CallByName List.6 Test.12;
|
||||
dec Test.12;
|
||||
let Test.32 : U64 = CallByName List.6 Test.14;
|
||||
dec Test.14;
|
||||
let Test.30 : Int1 = CallByName Num.22 Test.31 Test.32;
|
||||
ret Test.30;
|
||||
else
|
||||
dec Test.12;
|
||||
dec Test.14;
|
||||
let Test.28 : Int1 = CallByName Bool.1;
|
||||
ret Test.28;
|
||||
else
|
||||
let Test.48 : [<r>C I64, C List *self] = StructAtIndex 0 Test.6;
|
||||
inc Test.48;
|
||||
let Test.47 : List [<r>C I64, C List *self] = Array [Test.48];
|
||||
let Test.45 : [<r>C I64, C List *self] = Reuse #Derived_gen.4 UpdateModeId { id: 4 } TagId(1) Test.47;
|
||||
let Test.46 : [<r>C I64, C List *self] = StructAtIndex 1 Test.6;
|
||||
inc Test.46;
|
||||
dec Test.6;
|
||||
let Test.44 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.45, Test.46};
|
||||
jump Test.26 Test.44;
|
||||
in
|
||||
jump Test.26 Test.77;
|
||||
|
||||
procedure Test.15 (Test.16, Test.17):
|
||||
let Test.36 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.16, Test.17};
|
||||
ret Test.36;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.76 : I64 = 10i64;
|
||||
let Test.75 : [<r>C I64, C List *self] = TagId(0) Test.76;
|
||||
let Test.74 : List [<r>C I64, C List *self] = Array [Test.75];
|
||||
let Test.69 : [<r>C I64, C List *self] = TagId(1) Test.74;
|
||||
let Test.73 : I64 = 20i64;
|
||||
let Test.72 : [<r>C I64, C List *self] = TagId(0) Test.73;
|
||||
let Test.71 : List [<r>C I64, C List *self] = Array [Test.72];
|
||||
let Test.70 : [<r>C I64, C List *self] = TagId(1) Test.71;
|
||||
let Test.25 : {[<r>C I64, C List *self], [<r>C I64, C List *self]} = Struct {Test.69, Test.70};
|
||||
let Test.24 : Int1 = CallByName Test.1 Test.25;
|
||||
ret Test.24;
|
||||
|
|
@ -2888,3 +2888,27 @@ fn layout_cache_structure_with_multiple_recursive_structures() {
|
|||
"#
|
||||
)
|
||||
}
|
||||
|
||||
#[mono_test]
|
||||
fn issue_4770() {
|
||||
indoc!(
|
||||
r#"
|
||||
app "test" provides [main] to "./platform"
|
||||
|
||||
main =
|
||||
isCorrectOrder { left: IsList [IsInteger 10], right: IsList [IsInteger 20] }
|
||||
|
||||
isCorrectOrder = \pair ->
|
||||
when pair is
|
||||
{ left: IsInteger left, right: IsInteger right } -> left < right
|
||||
{ left: IsList l, right: IsList r } ->
|
||||
if List.map2 l r (\left, right -> { left, right }) |> List.all isCorrectOrder then
|
||||
List.len l < List.len r
|
||||
else
|
||||
Bool.false
|
||||
|
||||
{ left: IsList _, right: IsInteger _ } -> isCorrectOrder { left: pair.left, right: IsList [pair.right] }
|
||||
{ left: IsInteger _, right: IsList _ } -> isCorrectOrder { left: IsList [pair.left], right: pair.right }
|
||||
"#
|
||||
)
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue