roc-lang/roc
1
1
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2024-09-20 23:37:56 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #3390 from rtfeldman/clean

Browse Source 
Leftover file cleanup
This commit is contained in:
Folkert de Vries 2022-07-04 13:19:20 +02:00 committed by GitHub
commit e0b5f16516
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
7 changed files with 0 additions and 405 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

65
compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt
View File

@ -1,65 +0,0 @@
procedure List.2 (List.71, List.72):
let List.228 : U64 = CallByName List.6 List.71;
let List.224 : Int1 = CallByName Num.22 List.72 List.228;
if List.224 then
let List.226 : I64 = CallByName List.60 List.71 List.72;
let List.225 : [C {}, C I64] = Ok List.226;
ret List.225;
else
let List.223 : {} = Struct {};
let List.222 : [C {}, C I64] = Err List.223;
ret List.222;
procedure List.6 (#Attr.2):
let List.229 : U64 = lowlevel ListLen #Attr.2;
ret List.229;
procedure List.60 (#Attr.2, #Attr.3):
let List.227 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.227;
procedure List.9 (List.147):
let List.220 : U64 = 0i64;
let List.213 : [C {}, C I64] = CallByName List.2 List.147 List.220;
let List.217 : U8 = 1i64;
let List.218 : U8 = GetTagId List.213;
let List.219 : Int1 = lowlevel Eq List.217 List.218;
if List.219 then
let List.148 : I64 = UnionAtIndex (Id 1) (Index 0) List.213;
let List.214 : [C Int1, C I64] = Ok List.148;
ret List.214;
else
let List.216 : Int1 = true;
let List.215 : [C Int1, C I64] = Err List.216;
ret List.215;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Str.27 (#Attr.2):
let #Attr.3 : {I64, U8} = lowlevel StrToNum #Attr.2;
let Str.41 : U8 = StructAtIndex 1 #Attr.3;
let Str.42 : U8 = 0i64;
let Str.38 : Int1 = lowlevel NumGt Str.41 Str.42;
if Str.38 then
let Str.40 : Int1 = false;
let Str.39 : [C Int1, C I64] = Err Str.40;
ret Str.39;
else
let Str.37 : I64 = StructAtIndex 0 #Attr.3;
let Str.36 : [C Int1, C I64] = Ok Str.37;
ret Str.36;
procedure Test.0 ():
let Test.4 : Int1 = true;
if Test.4 then
let Test.6 : List I64 = Array [];
let Test.5 : [C Int1, C I64] = CallByName List.9 Test.6;
dec Test.6;
ret Test.5;
else
let Test.3 : Str = "";
let Test.2 : [C Int1, C I64] = CallByName Str.27 Test.3;
dec Test.3;
ret Test.2;

35
compiler/test_mono/generated/list_get.txt
View File

@ -1,35 +0,0 @@
procedure List.2 (List.71, List.72):
let List.219 : U64 = CallByName List.6 List.71;
let List.215 : Int1 = CallByName Num.22 List.72 List.219;
if List.215 then
let List.217 : I64 = CallByName List.60 List.71 List.72;
let List.216 : [C {}, C I64] = Ok List.217;
ret List.216;
else
let List.214 : {} = Struct {};
let List.213 : [C {}, C I64] = Err List.214;
ret List.213;
procedure List.6 (#Attr.2):
let List.222 : U64 = lowlevel ListLen #Attr.2;
ret List.222;
procedure List.60 (#Attr.2, #Attr.3):
let List.221 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
ret List.221;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Test.1 (Test.2):
let Test.6 : List I64 = Array [1i64, 2i64, 3i64];
let Test.7 : U64 = 0i64;
let Test.5 : [C {}, C I64] = CallByName List.2 Test.6 Test.7;
dec Test.6;
ret Test.5;
procedure Test.0 ():
let Test.4 : {} = Struct {};
let Test.3 : [C {}, C I64] = CallByName Test.1 Test.4;
ret Test.3;

39
compiler/test_mono/generated/list_pass_to_function.txt
View File

@ -1,39 +0,0 @@
procedure List.3 (List.79, List.80, List.81):
let List.214 : {List I64, I64} = CallByName List.57 List.79 List.80 List.81;
let List.213 : List I64 = StructAtIndex 0 List.214;
inc List.213;
dec List.214;
ret List.213;
procedure List.57 (List.76, List.77, List.78):
let List.220 : U64 = CallByName List.6 List.76;
let List.217 : Int1 = CallByName Num.22 List.77 List.220;
if List.217 then
let List.218 : {List I64, I64} = CallByName List.61 List.76 List.77 List.78;
ret List.218;
else
let List.216 : {List I64, I64} = Struct {List.76, List.78};
ret List.216;
procedure List.6 (#Attr.2):
let List.221 : U64 = lowlevel ListLen #Attr.2;
ret List.221;
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
let List.219 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
ret List.219;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.188;
procedure Test.2 (Test.3):
let Test.6 : U64 = 0i64;
let Test.7 : I64 = 0i64;
let Test.5 : List I64 = CallByName List.3 Test.3 Test.6 Test.7;
ret Test.5;
procedure Test.0 ():
let Test.1 : List I64 = Array [1i64, 2i64, 3i64];
let Test.4 : List I64 = CallByName Test.2 Test.1;
ret Test.4;

54
crates/compiler/test_mono/generated/multimorphic_lambda_set_capture.txt
View File

@ -1,54 +0,0 @@
procedure Num.94 (#Attr.2):
let Num.188 : Str = lowlevel NumToStr #Attr.2;
ret Num.188;
procedure Num.94 (#Attr.2):
let Num.189 : Str = lowlevel NumToStr #Attr.2;
ret Num.189;
procedure Test.1 (Test.4):
let Test.16 : [C U8, C U64] = ClosureTag(Test.5) Test.4;
ret Test.16;
procedure Test.1 (Test.4):
let Test.22 : [C U8, C U64] = ClosureTag(Test.5) Test.4;
ret Test.22;
procedure Test.5 (Test.17, #Attr.12):
let Test.4 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.19 : Str = CallByName Num.94 Test.4;
ret Test.19;
procedure Test.5 (Test.17, #Attr.12):
let Test.4 : U8 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.25 : Str = CallByName Num.94 Test.4;
ret Test.25;
procedure Test.0 ():
let Test.2 : Int1 = true;
joinpoint Test.13 Test.3:
let Test.8 : {} = Struct {};
let Test.9 : U8 = GetTagId Test.3;
joinpoint Test.10 Test.7:
ret Test.7;
in
switch Test.9:
case 0:
let Test.11 : Str = CallByName Test.5 Test.8 Test.3;
jump Test.10 Test.11;
default:
let Test.12 : Str = CallByName Test.5 Test.8 Test.3;
jump Test.10 Test.12;
in
let Test.26 : Int1 = true;
let Test.27 : Int1 = lowlevel Eq Test.26 Test.2;
if Test.27 then
let Test.15 : U64 = 123i64;
let Test.14 : [C U8, C U64] = CallByName Test.1 Test.15;
jump Test.13 Test.14;
else
let Test.21 : U8 = 18i64;
let Test.20 : [C U8, C U64] = CallByName Test.1 Test.21;
jump Test.13 Test.20;

85
crates/compiler/test_mono/generated/multimorphic_lambdas_have_captured_function_in_closure.txt
View File

@ -1,85 +0,0 @@
procedure Test.11 (Test.37):
let Test.38 : Str = "";
ret Test.38;
procedure Test.13 (Test.51, #Attr.12):
let Test.12 : Str = StructAtIndex 0 #Attr.12;
inc Test.12;
dec #Attr.12;
ret Test.12;
procedure Test.15 (Test.39):
let Test.40 : Str = "";
ret Test.40;
procedure Test.16 (Test.54):
let Test.56 : Str = "s1";
ret Test.56;
procedure Test.2 (Test.7, Test.8):
let Test.9 : [C {} {}, C {} {}] = ClosureTag(Test.9) Test.7 Test.8;
ret Test.9;
procedure Test.2 (Test.7, Test.8):
let Test.9 : [C {} {}, C {} {}] = ClosureTag(Test.9) Test.7 Test.8;
ret Test.9;
procedure Test.3 (Test.17):
let Test.36 : {} = Struct {};
ret Test.36;
procedure Test.4 (Test.18):
let Test.50 : {Str} = Struct {Test.18};
ret Test.50;
procedure Test.9 (Test.29, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 0) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.35 : {} = Struct {};
let Test.34 : Str = CallByName Test.15 Test.35;
let Test.31 : {} = CallByName Test.3 Test.34;
dec Test.34;
let Test.33 : {} = Struct {};
let Test.32 : Str = CallByName Test.11 Test.33;
ret Test.32;
procedure Test.9 (Test.29, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.49 : {} = Struct {};
let Test.48 : Str = CallByName Test.16 Test.49;
let Test.45 : {Str} = CallByName Test.4 Test.48;
let Test.47 : {} = Struct {};
let Test.46 : Str = CallByName Test.13 Test.47 Test.45;
ret Test.46;
procedure Test.0 ():
let Test.5 : Int1 = true;
joinpoint Test.25 Test.6:
let Test.20 : {} = Struct {};
let Test.21 : U8 = GetTagId Test.6;
joinpoint Test.22 Test.19:
ret Test.19;
in
switch Test.21:
case 0:
let Test.23 : Str = CallByName Test.9 Test.20 Test.6;
jump Test.22 Test.23;
default:
let Test.24 : Str = CallByName Test.9 Test.20 Test.6;
jump Test.22 Test.24;
in
let Test.57 : Int1 = true;
let Test.58 : Int1 = lowlevel Eq Test.57 Test.5;
if Test.58 then
let Test.27 : {} = Struct {};
let Test.28 : {} = Struct {};
let Test.26 : [C {} {}, C {} {}] = CallByName Test.2 Test.27 Test.28;
jump Test.25 Test.26;
else
let Test.42 : {} = Struct {};
let Test.43 : {} = Struct {};
let Test.41 : [C {} {}, C {} {}] = CallByName Test.2 Test.42 Test.43;
jump Test.25 Test.41;

59
crates/compiler/test_mono/generated/multimorphic_lambdas_with_non_capturing_function.txt
View File

@ -1,59 +0,0 @@
procedure Test.1 (Test.5):
let Test.19 : [C , C U64, C {}] = ClosureTag(Test.6) Test.5;
ret Test.19;
procedure Test.1 (Test.5):
let Test.27 : [C , C U64, C {}] = ClosureTag(Test.6) Test.5;
ret Test.27;
procedure Test.2 (Test.8):
let Test.24 : Str = "";
ret Test.24;
procedure Test.6 (Test.20, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.30 : Str = "";
ret Test.30;
procedure Test.6 (Test.20, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 2) (Index 0) #Attr.12;
let Test.22 : Str = "";
ret Test.22;
procedure Test.0 ():
let Test.3 : U8 = 0u8;
joinpoint Test.16 Test.4:
let Test.10 : {} = Struct {};
let Test.11 : U8 = GetTagId Test.4;
joinpoint Test.12 Test.9:
ret Test.9;
in
switch Test.11:
case 0:
let Test.13 : Str = CallByName Test.2 Test.10;
jump Test.12 Test.13;
case 1:
let Test.14 : Str = CallByName Test.6 Test.10 Test.4;
jump Test.12 Test.14;
default:
let Test.15 : Str = CallByName Test.6 Test.10 Test.4;
jump Test.12 Test.15;
in
switch Test.3:
case 0:
let Test.18 : {} = Struct {};
let Test.17 : [C , C U64, C {}] = CallByName Test.1 Test.18;
jump Test.16 Test.17;
case 1:
let Test.2 : [C , C U64, C {}] = ClosureTag(Test.2) ;
jump Test.16 Test.2;
default:
let Test.26 : U64 = 1i64;
let Test.25 : [C , C U64, C {}] = CallByName Test.1 Test.26;
jump Test.16 Test.25;

68
crates/compiler/test_mono/generated/multimorphic_lambdas_with_other_lambda_capture.txt
View File

@ -1,68 +0,0 @@
procedure Test.1 (Test.5):
let Test.20 : [C U64, C {}, C Str] = ClosureTag(Test.6) Test.5;
ret Test.20;
procedure Test.1 (Test.5):
let Test.32 : [C U64, C {}, C Str] = ClosureTag(Test.6) Test.5;
ret Test.32;
procedure Test.2 (Test.7):
let Test.26 : [C U64, C {}, C Str] = ClosureTag(Test.8) Test.7;
ret Test.26;
procedure Test.6 (Test.21, #Attr.12):
let Test.5 : U64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
dec #Attr.12;
let Test.35 : Str = "";
ret Test.35;
procedure Test.6 (Test.21, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 1) (Index 0) #Attr.12;
dec #Attr.12;
let Test.23 : Str = "";
ret Test.23;
procedure Test.8 (Test.27, #Attr.12):
let Test.7 : Str = UnionAtIndex (Id 2) (Index 0) #Attr.12;
inc Test.7;
dec #Attr.12;
ret Test.7;
procedure Test.0 ():
let Test.3 : U8 = 0u8;
joinpoint Test.17 Test.4:
let Test.11 : {} = Struct {};
let Test.12 : U8 = GetTagId Test.4;
joinpoint Test.13 Test.10:
ret Test.10;
in
switch Test.12:
case 0:
let Test.14 : Str = CallByName Test.6 Test.11 Test.4;
jump Test.13 Test.14;
case 1:
let Test.15 : Str = CallByName Test.6 Test.11 Test.4;
jump Test.13 Test.15;
default:
let Test.16 : Str = CallByName Test.8 Test.11 Test.4;
jump Test.13 Test.16;
in
switch Test.3:
case 0:
let Test.19 : {} = Struct {};
let Test.18 : [C U64, C {}, C Str] = CallByName Test.1 Test.19;
jump Test.17 Test.18;
case 1:
let Test.25 : Str = "foo";
let Test.24 : [C U64, C {}, C Str] = CallByName Test.2 Test.25;
jump Test.17 Test.24;
default:
let Test.31 : U64 = 1i64;
let Test.30 : [C U64, C {}, C Str] = CallByName Test.1 Test.31;
jump Test.17 Test.30;