mirror of
https://github.com/roc-lang/roc.git
synced 2024-09-20 23:37:56 +03:00
Fix mono
This commit is contained in:
ayazhafiz
parent
71e3e0baff
commit
671a19b29d
@ -1,21 +1,6 @@
|
||||
procedure List.6 (#Attr.2):
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
let List.284 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.284;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/closure_in_list.txt
|
||||
let List.259 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.259;
|
||||
=======
|
||||
let List.213 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.213;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/closure_in_list.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.238 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.238;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.266 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.266;
|
||||
|
||||
procedure Test.1 (Test.5):
|
||||
let Test.2 : I64 = 41i64;
|
||||
|
||||
@ -1,81 +1,22 @@
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
procedure List.2 (List.75, List.76):
|
||||
let List.290 : U64 = CallByName List.6 List.75;
|
||||
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
|
||||
if List.286 then
|
||||
let List.288 : {} = CallByName List.60 List.75 List.76;
|
||||
let List.287 : [C {}, C {}] = Ok List.288;
|
||||
ret List.287;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/empty_list_of_function_type.txt
|
||||
procedure List.2 (List.73, List.74):
|
||||
let List.265 : U64 = CallByName List.6 List.73;
|
||||
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
|
||||
if List.261 then
|
||||
let List.263 : {} = CallByName List.60 List.73 List.74;
|
||||
let List.262 : [C {}, C {}] = Ok List.263;
|
||||
ret List.262;
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
procedure List.2 (List.74, List.75):
|
||||
let List.272 : U64 = CallByName List.6 List.74;
|
||||
let List.268 : Int1 = CallByName Num.22 List.75 List.272;
|
||||
if List.268 then
|
||||
let List.270 : {} = CallByName List.60 List.74 List.75;
|
||||
let List.269 : [C {}, C {}] = Ok List.270;
|
||||
ret List.269;
|
||||
else
|
||||
let List.285 : {} = Struct {};
|
||||
let List.284 : [C {}, C {}] = Err List.285;
|
||||
ret List.284;
|
||||
let List.267 : {} = Struct {};
|
||||
let List.266 : [C {}, C {}] = Err List.267;
|
||||
ret List.266;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.293 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.293;
|
||||
let List.275 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.275;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
<<<<<<< HEAD
|
||||
let List.292 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.292;
|
||||
=======
|
||||
let List.267 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.267;
|
||||
=======
|
||||
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 : {} = CallByName List.60 List.71 List.72;
|
||||
let List.216 : [C {}, C {}] = Ok List.217;
|
||||
ret List.216;
|
||||
else
|
||||
let List.214 : {} = Struct {};
|
||||
let List.213 : [C {}, C {}] = 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 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.221;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/empty_list_of_function_type.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
procedure List.2 (List.72, List.73):
|
||||
let List.244 : U64 = CallByName List.6 List.72;
|
||||
let List.240 : Int1 = CallByName Num.22 List.73 List.244;
|
||||
if List.240 then
|
||||
let List.242 : {} = CallByName List.60 List.72 List.73;
|
||||
let List.241 : [C {}, C {}] = Ok List.242;
|
||||
ret List.241;
|
||||
else
|
||||
let List.239 : {} = Struct {};
|
||||
let List.238 : [C {}, C {}] = Err List.239;
|
||||
ret List.238;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.247 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.247;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.246 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.246;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.274 : {} = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.274;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,21 +1,6 @@
|
||||
procedure List.4 (#Attr.2, #Attr.3):
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
let List.284 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.284;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/encode.txt
|
||||
let List.259 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.259;
|
||||
=======
|
||||
let List.213 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.213;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/encode.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.238 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.238;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.266 : List U8 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.266;
|
||||
|
||||
procedure Test.20 (Test.22):
|
||||
let Test.34 : {U8} = Struct {Test.22};
|
||||
|
||||
@ -1,21 +1,6 @@
|
||||
procedure List.6 (#Attr.2):
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
let List.284 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.284;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/ir_int_add.txt
|
||||
let List.259 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.259;
|
||||
=======
|
||||
let List.213 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.213;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/ir_int_add.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.238 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.238;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.266 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.266;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.190 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,74 +1,37 @@
|
||||
<<<<<<< HEAD
|
||||
procedure List.2 (List.75, List.76):
|
||||
let List.299 : U64 = CallByName List.6 List.75;
|
||||
let List.295 : Int1 = CallByName Num.22 List.76 List.299;
|
||||
if List.295 then
|
||||
let List.297 : I64 = CallByName List.60 List.75 List.76;
|
||||
let List.296 : [C {}, C I64] = Ok List.297;
|
||||
ret List.296;
|
||||
procedure List.2 (List.74, List.75):
|
||||
let List.281 : U64 = CallByName List.6 List.74;
|
||||
let List.277 : Int1 = CallByName Num.22 List.75 List.281;
|
||||
if List.277 then
|
||||
let List.279 : I64 = CallByName List.60 List.74 List.75;
|
||||
let List.278 : [C {}, C I64] = Ok List.279;
|
||||
ret List.278;
|
||||
else
|
||||
let List.294 : {} = Struct {};
|
||||
let List.293 : [C {}, C I64] = Err List.294;
|
||||
ret List.293;
|
||||
let List.276 : {} = Struct {};
|
||||
let List.275 : [C {}, C I64] = Err List.276;
|
||||
ret List.275;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.300 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.300;
|
||||
let List.282 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.282;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.298 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.298;
|
||||
let List.280 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.280;
|
||||
|
||||
procedure List.9 (List.202):
|
||||
let List.291 : U64 = 0i64;
|
||||
let List.284 : [C {}, C I64] = CallByName List.2 List.202 List.291;
|
||||
let List.288 : U8 = 1i64;
|
||||
let List.289 : U8 = GetTagId List.284;
|
||||
let List.290 : Int1 = lowlevel Eq List.288 List.289;
|
||||
if List.290 then
|
||||
let List.203 : I64 = UnionAtIndex (Id 1) (Index 0) List.284;
|
||||
let List.285 : [C Int1, C I64] = Ok List.203;
|
||||
ret List.285;
|
||||
procedure List.9 (List.188):
|
||||
let List.273 : U64 = 0i64;
|
||||
let List.266 : [C {}, C I64] = CallByName List.2 List.188 List.273;
|
||||
let List.270 : U8 = 1i64;
|
||||
let List.271 : U8 = GetTagId List.266;
|
||||
let List.272 : Int1 = lowlevel Eq List.270 List.271;
|
||||
if List.272 then
|
||||
let List.189 : I64 = UnionAtIndex (Id 1) (Index 0) List.266;
|
||||
let List.267 : [C Int1, C I64] = Ok List.189;
|
||||
ret List.267;
|
||||
else
|
||||
let List.287 : Int1 = true;
|
||||
let List.286 : [C Int1, C I64] = Err List.287;
|
||||
ret List.286;
|
||||
=======
|
||||
procedure List.2 (List.72, List.73):
|
||||
let List.253 : U64 = CallByName List.6 List.72;
|
||||
let List.249 : Int1 = CallByName Num.22 List.73 List.253;
|
||||
if List.249 then
|
||||
let List.251 : I64 = CallByName List.60 List.72 List.73;
|
||||
let List.250 : [C {}, C I64] = Ok List.251;
|
||||
ret List.250;
|
||||
else
|
||||
let List.248 : {} = Struct {};
|
||||
let List.247 : [C {}, C I64] = Err List.248;
|
||||
ret List.247;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.254 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.254;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.252 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.252;
|
||||
|
||||
procedure List.9 (List.168):
|
||||
let List.245 : U64 = 0i64;
|
||||
let List.238 : [C {}, C I64] = CallByName List.2 List.168 List.245;
|
||||
let List.242 : U8 = 1i64;
|
||||
let List.243 : U8 = GetTagId List.238;
|
||||
let List.244 : Int1 = lowlevel Eq List.242 List.243;
|
||||
if List.244 then
|
||||
let List.169 : I64 = UnionAtIndex (Id 1) (Index 0) List.238;
|
||||
let List.239 : [C Int1, C I64] = Ok List.169;
|
||||
ret List.239;
|
||||
else
|
||||
let List.241 : Int1 = true;
|
||||
let List.240 : [C Int1, C I64] = Err List.241;
|
||||
ret List.240;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.269 : Int1 = true;
|
||||
let List.268 : [C Int1, C I64] = Err List.269;
|
||||
ret List.268;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,21 +1,6 @@
|
||||
procedure List.4 (#Attr.2, #Attr.3):
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
let List.284 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.284;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_append.txt
|
||||
let List.259 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.259;
|
||||
=======
|
||||
let List.213 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.213;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_append.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.238 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.238;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.266 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.266;
|
||||
|
||||
procedure Test.0 ():
|
||||
let Test.2 : List I64 = Array [1i64];
|
||||
|
||||
@ -1,21 +1,6 @@
|
||||
procedure List.4 (#Attr.2, #Attr.3):
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
let List.284 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.284;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_append_closure.txt
|
||||
let List.259 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.259;
|
||||
=======
|
||||
let List.213 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.213;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_append_closure.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.238 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.238;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.266 : List I64 = lowlevel ListAppend #Attr.2 #Attr.3;
|
||||
ret List.266;
|
||||
|
||||
procedure Test.1 (Test.2):
|
||||
let Test.6 : I64 = 42i64;
|
||||
|
||||
@ -1,96 +1,27 @@
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
procedure List.3 (List.84, List.85, List.86):
|
||||
let List.287 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
|
||||
let List.286 : List I64 = StructAtIndex 0 List.287;
|
||||
inc List.286;
|
||||
dec List.287;
|
||||
ret List.286;
|
||||
|
||||
procedure List.57 (List.81, List.82, List.83):
|
||||
let List.293 : U64 = CallByName List.6 List.81;
|
||||
let List.290 : Int1 = CallByName Num.22 List.82 List.293;
|
||||
if List.290 then
|
||||
let List.291 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
|
||||
ret List.291;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_cannot_update_inplace.txt
|
||||
procedure List.3 (List.82, List.83, List.84):
|
||||
let List.262 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
|
||||
let List.261 : List I64 = StructAtIndex 0 List.262;
|
||||
inc List.261;
|
||||
dec List.262;
|
||||
ret List.261;
|
||||
let List.269 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
|
||||
let List.268 : List I64 = StructAtIndex 0 List.269;
|
||||
inc List.268;
|
||||
dec List.269;
|
||||
ret List.268;
|
||||
|
||||
procedure List.57 (List.79, List.80, List.81):
|
||||
let List.268 : U64 = CallByName List.6 List.79;
|
||||
let List.265 : Int1 = CallByName Num.22 List.80 List.268;
|
||||
if List.265 then
|
||||
let List.266 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
|
||||
ret List.266;
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
let List.275 : U64 = CallByName List.6 List.79;
|
||||
let List.272 : Int1 = CallByName Num.22 List.80 List.275;
|
||||
if List.272 then
|
||||
let List.273 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
|
||||
ret List.273;
|
||||
else
|
||||
let List.289 : {List I64, I64} = Struct {List.81, List.83};
|
||||
ret List.289;
|
||||
let List.271 : {List I64, I64} = Struct {List.79, List.81};
|
||||
ret List.271;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.285 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.285;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
<<<<<<< HEAD
|
||||
let List.292 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.292;
|
||||
=======
|
||||
let List.267 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
let List.267 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.267;
|
||||
=======
|
||||
procedure List.3 (List.79, List.80, List.81):
|
||||
let List.216 : {List I64, I64} = CallByName List.57 List.79 List.80 List.81;
|
||||
let List.215 : List I64 = StructAtIndex 0 List.216;
|
||||
inc List.215;
|
||||
dec List.216;
|
||||
ret List.215;
|
||||
|
||||
procedure List.57 (List.76, List.77, List.78):
|
||||
let List.222 : U64 = CallByName List.6 List.76;
|
||||
let List.219 : Int1 = CallByName Num.22 List.77 List.222;
|
||||
if List.219 then
|
||||
let List.220 : {List I64, I64} = CallByName List.61 List.76 List.77 List.78;
|
||||
ret List.220;
|
||||
=======
|
||||
procedure List.3 (List.80, List.81, List.82):
|
||||
let List.241 : {List I64, I64} = CallByName List.57 List.80 List.81 List.82;
|
||||
let List.240 : List I64 = StructAtIndex 0 List.241;
|
||||
inc List.240;
|
||||
dec List.241;
|
||||
ret List.240;
|
||||
|
||||
procedure List.57 (List.77, List.78, List.79):
|
||||
let List.247 : U64 = CallByName List.6 List.77;
|
||||
let List.244 : Int1 = CallByName Num.22 List.78 List.247;
|
||||
if List.244 then
|
||||
let List.245 : {List I64, I64} = CallByName List.61 List.77 List.78 List.79;
|
||||
ret List.245;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
else
|
||||
let List.243 : {List I64, I64} = Struct {List.77, List.79};
|
||||
ret List.243;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.239 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.239;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
<<<<<<< HEAD
|
||||
let List.221 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.221;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_cannot_update_inplace.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.246 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.246;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.274 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.274;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,44 +1,22 @@
|
||||
<<<<<<< HEAD
|
||||
procedure List.2 (List.75, List.76):
|
||||
let List.290 : U64 = CallByName List.6 List.75;
|
||||
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
|
||||
if List.286 then
|
||||
let List.288 : I64 = CallByName List.60 List.75 List.76;
|
||||
let List.287 : [C {}, C I64] = Ok List.288;
|
||||
ret List.287;
|
||||
procedure List.2 (List.74, List.75):
|
||||
let List.272 : U64 = CallByName List.6 List.74;
|
||||
let List.268 : Int1 = CallByName Num.22 List.75 List.272;
|
||||
if List.268 then
|
||||
let List.270 : I64 = CallByName List.60 List.74 List.75;
|
||||
let List.269 : [C {}, C I64] = Ok List.270;
|
||||
ret List.269;
|
||||
else
|
||||
let List.285 : {} = Struct {};
|
||||
let List.284 : [C {}, C I64] = Err List.285;
|
||||
ret List.284;
|
||||
let List.267 : {} = Struct {};
|
||||
let List.266 : [C {}, C I64] = Err List.267;
|
||||
ret List.266;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.293 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.293;
|
||||
let List.275 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.275;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.292 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.292;
|
||||
=======
|
||||
procedure List.2 (List.72, List.73):
|
||||
let List.244 : U64 = CallByName List.6 List.72;
|
||||
let List.240 : Int1 = CallByName Num.22 List.73 List.244;
|
||||
if List.240 then
|
||||
let List.242 : I64 = CallByName List.60 List.72 List.73;
|
||||
let List.241 : [C {}, C I64] = Ok List.242;
|
||||
ret List.241;
|
||||
else
|
||||
let List.239 : {} = Struct {};
|
||||
let List.238 : [C {}, C I64] = Err List.239;
|
||||
ret List.238;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.247 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.247;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.246 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.246;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.274 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.274;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,37 +1,10 @@
|
||||
procedure List.6 (#Attr.2):
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
let List.284 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.284;
|
||||
let List.266 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.266;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.285 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.285;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_len.txt
|
||||
let List.259 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.259;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.260 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.260;
|
||||
=======
|
||||
let List.213 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.213;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.214 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.214;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_len.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.238 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.238;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.239 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.239;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.267 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.267;
|
||||
|
||||
procedure Num.19 (#Attr.2, #Attr.3):
|
||||
let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,93 +1,26 @@
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
procedure List.2 (List.75, List.76):
|
||||
let List.290 : U64 = CallByName List.6 List.75;
|
||||
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
|
||||
if List.286 then
|
||||
let List.288 : Str = CallByName List.60 List.75 List.76;
|
||||
let List.287 : [C {}, C Str] = Ok List.288;
|
||||
ret List.287;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_map_closure_borrows.txt
|
||||
procedure List.2 (List.73, List.74):
|
||||
let List.265 : U64 = CallByName List.6 List.73;
|
||||
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
|
||||
if List.261 then
|
||||
let List.263 : Str = CallByName List.60 List.73 List.74;
|
||||
let List.262 : [C {}, C Str] = Ok List.263;
|
||||
ret List.262;
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
procedure List.2 (List.74, List.75):
|
||||
let List.272 : U64 = CallByName List.6 List.74;
|
||||
let List.268 : Int1 = CallByName Num.22 List.75 List.272;
|
||||
if List.268 then
|
||||
let List.270 : Str = CallByName List.60 List.74 List.75;
|
||||
let List.269 : [C {}, C Str] = Ok List.270;
|
||||
ret List.269;
|
||||
else
|
||||
let List.285 : {} = Struct {};
|
||||
let List.284 : [C {}, C Str] = Err List.285;
|
||||
ret List.284;
|
||||
let List.267 : {} = Struct {};
|
||||
let List.266 : [C {}, C Str] = Err List.267;
|
||||
ret List.266;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.292 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
ret List.292;
|
||||
let List.274 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
ret List.274;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.294 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.294;
|
||||
let List.276 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.276;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
<<<<<<< HEAD
|
||||
let List.293 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.293;
|
||||
=======
|
||||
let List.268 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.268;
|
||||
=======
|
||||
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 : Str = CallByName List.60 List.71 List.72;
|
||||
let List.216 : [C {}, C Str] = Ok List.217;
|
||||
ret List.216;
|
||||
else
|
||||
let List.214 : {} = Struct {};
|
||||
let List.213 : [C {}, C Str] = Err List.214;
|
||||
ret List.213;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.221 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
ret List.221;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.223 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.223;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.222 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.222;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_map_closure_borrows.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
procedure List.2 (List.72, List.73):
|
||||
let List.244 : U64 = CallByName List.6 List.72;
|
||||
let List.240 : Int1 = CallByName Num.22 List.73 List.244;
|
||||
if List.240 then
|
||||
let List.242 : Str = CallByName List.60 List.72 List.73;
|
||||
let List.241 : [C {}, C Str] = Ok List.242;
|
||||
ret List.241;
|
||||
else
|
||||
let List.239 : {} = Struct {};
|
||||
let List.238 : [C {}, C Str] = Err List.239;
|
||||
ret List.238;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
let List.246 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
ret List.246;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.248 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.248;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.247 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.247;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.275 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.275;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,99 +1,28 @@
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
procedure List.2 (List.75, List.76):
|
||||
let List.290 : U64 = CallByName List.6 List.75;
|
||||
let List.286 : Int1 = CallByName Num.22 List.76 List.290;
|
||||
if List.286 then
|
||||
let List.288 : Str = CallByName List.60 List.75 List.76;
|
||||
let List.287 : [C {}, C Str] = Ok List.288;
|
||||
ret List.287;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_map_closure_owns.txt
|
||||
procedure List.2 (List.73, List.74):
|
||||
let List.265 : U64 = CallByName List.6 List.73;
|
||||
let List.261 : Int1 = CallByName Num.22 List.74 List.265;
|
||||
if List.261 then
|
||||
let List.263 : Str = CallByName List.60 List.73 List.74;
|
||||
let List.262 : [C {}, C Str] = Ok List.263;
|
||||
ret List.262;
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
procedure List.2 (List.74, List.75):
|
||||
let List.272 : U64 = CallByName List.6 List.74;
|
||||
let List.268 : Int1 = CallByName Num.22 List.75 List.272;
|
||||
if List.268 then
|
||||
let List.270 : Str = CallByName List.60 List.74 List.75;
|
||||
let List.269 : [C {}, C Str] = Ok List.270;
|
||||
ret List.269;
|
||||
else
|
||||
let List.285 : {} = Struct {};
|
||||
let List.284 : [C {}, C Str] = Err List.285;
|
||||
ret List.284;
|
||||
let List.267 : {} = Struct {};
|
||||
let List.266 : [C {}, C Str] = Err List.267;
|
||||
ret List.266;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
inc #Attr.2;
|
||||
let List.292 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
let List.274 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.292;
|
||||
ret List.274;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.294 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.294;
|
||||
let List.276 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.276;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
<<<<<<< HEAD
|
||||
let List.293 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.293;
|
||||
=======
|
||||
let List.268 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.268;
|
||||
=======
|
||||
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 : Str = CallByName List.60 List.71 List.72;
|
||||
let List.216 : [C {}, C Str] = Ok List.217;
|
||||
ret List.216;
|
||||
else
|
||||
let List.214 : {} = Struct {};
|
||||
let List.213 : [C {}, C Str] = Err List.214;
|
||||
ret List.213;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
inc #Attr.2;
|
||||
let List.221 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.221;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.223 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.223;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.222 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.222;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_map_closure_owns.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
procedure List.2 (List.72, List.73):
|
||||
let List.244 : U64 = CallByName List.6 List.72;
|
||||
let List.240 : Int1 = CallByName Num.22 List.73 List.244;
|
||||
if List.240 then
|
||||
let List.242 : Str = CallByName List.60 List.72 List.73;
|
||||
let List.241 : [C {}, C Str] = Ok List.242;
|
||||
ret List.241;
|
||||
else
|
||||
let List.239 : {} = Struct {};
|
||||
let List.238 : [C {}, C Str] = Err List.239;
|
||||
ret List.238;
|
||||
|
||||
procedure List.5 (#Attr.2, #Attr.3):
|
||||
inc #Attr.2;
|
||||
let List.246 : List Str = lowlevel ListMap { xs: `#Attr.#arg1` } #Attr.2 Test.3 #Attr.3;
|
||||
decref #Attr.2;
|
||||
ret List.246;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.248 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.248;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.247 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.247;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.275 : Str = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.275;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,54 +1,27 @@
|
||||
<<<<<<< HEAD
|
||||
procedure List.3 (List.84, List.85, List.86):
|
||||
let List.285 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
|
||||
let List.284 : List I64 = StructAtIndex 0 List.285;
|
||||
inc List.284;
|
||||
dec List.285;
|
||||
ret List.284;
|
||||
procedure List.3 (List.82, List.83, List.84):
|
||||
let List.267 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
|
||||
let List.266 : List I64 = StructAtIndex 0 List.267;
|
||||
inc List.266;
|
||||
dec List.267;
|
||||
ret List.266;
|
||||
|
||||
procedure List.57 (List.81, List.82, List.83):
|
||||
let List.291 : U64 = CallByName List.6 List.81;
|
||||
let List.288 : Int1 = CallByName Num.22 List.82 List.291;
|
||||
if List.288 then
|
||||
let List.289 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
|
||||
ret List.289;
|
||||
procedure List.57 (List.79, List.80, List.81):
|
||||
let List.273 : U64 = CallByName List.6 List.79;
|
||||
let List.270 : Int1 = CallByName Num.22 List.80 List.273;
|
||||
if List.270 then
|
||||
let List.271 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
|
||||
ret List.271;
|
||||
else
|
||||
let List.287 : {List I64, I64} = Struct {List.81, List.83};
|
||||
ret List.287;
|
||||
let List.269 : {List I64, I64} = Struct {List.79, List.81};
|
||||
ret List.269;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.292 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.292;
|
||||
let List.274 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.274;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.290 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.290;
|
||||
=======
|
||||
procedure List.3 (List.80, List.81, List.82):
|
||||
let List.239 : {List I64, I64} = CallByName List.57 List.80 List.81 List.82;
|
||||
let List.238 : List I64 = StructAtIndex 0 List.239;
|
||||
inc List.238;
|
||||
dec List.239;
|
||||
ret List.238;
|
||||
|
||||
procedure List.57 (List.77, List.78, List.79):
|
||||
let List.245 : U64 = CallByName List.6 List.77;
|
||||
let List.242 : Int1 = CallByName Num.22 List.78 List.245;
|
||||
if List.242 then
|
||||
let List.243 : {List I64, I64} = CallByName List.61 List.77 List.78 List.79;
|
||||
ret List.243;
|
||||
else
|
||||
let List.241 : {List I64, I64} = Struct {List.77, List.79};
|
||||
ret List.241;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.246 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.246;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
let List.244 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.244;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.272 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.272;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,53 +1,16 @@
|
||||
procedure List.28 (#Attr.2, #Attr.3):
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
let List.287 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/list_sort_asc.txt
|
||||
let List.262 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
let Bool.14 : Int1 = lowlevel ListIsUnique #Attr.2;
|
||||
if Bool.14 then
|
||||
ret List.287;
|
||||
else
|
||||
decref #Attr.2;
|
||||
ret List.287;
|
||||
|
||||
<<<<<<< HEAD
|
||||
procedure List.54 (List.196):
|
||||
let List.285 : {} = Struct {};
|
||||
let List.284 : List I64 = CallByName List.28 List.196 List.285;
|
||||
ret List.284;
|
||||
=======
|
||||
procedure List.54 (List.178):
|
||||
let List.260 : {} = Struct {};
|
||||
let List.259 : List I64 = CallByName List.28 List.178 List.260;
|
||||
ret List.259;
|
||||
=======
|
||||
let List.216 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
=======
|
||||
let List.241 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.269 : List I64 = lowlevel ListSortWith { xs: `#Attr.#arg1` } #Attr.2 Num.46 #Attr.3;
|
||||
let Bool.9 : Int1 = lowlevel ListIsUnique #Attr.2;
|
||||
if Bool.9 then
|
||||
ret List.241;
|
||||
ret List.269;
|
||||
else
|
||||
decref #Attr.2;
|
||||
ret List.241;
|
||||
ret List.269;
|
||||
|
||||
<<<<<<< HEAD
|
||||
procedure List.54 (List.142):
|
||||
let List.214 : {} = Struct {};
|
||||
let List.213 : List I64 = CallByName List.28 List.142 List.214;
|
||||
ret List.213;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_sort_asc.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
procedure List.54 (List.163):
|
||||
let List.239 : {} = Struct {};
|
||||
let List.238 : List I64 = CallByName List.28 List.163 List.239;
|
||||
ret List.238;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
procedure List.54 (List.183):
|
||||
let List.267 : {} = Struct {};
|
||||
let List.266 : List I64 = CallByName List.28 List.183 List.267;
|
||||
ret List.266;
|
||||
|
||||
procedure Num.46 (#Attr.2, #Attr.3):
|
||||
let Num.188 : U8 = lowlevel NumCompare #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,127 +1,43 @@
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
procedure List.2 (List.75, List.76):
|
||||
let List.304 : U64 = CallByName List.6 List.75;
|
||||
let List.300 : Int1 = CallByName Num.22 List.76 List.304;
|
||||
if List.300 then
|
||||
let List.302 : I64 = CallByName List.60 List.75 List.76;
|
||||
let List.301 : [C {}, C I64] = Ok List.302;
|
||||
ret List.301;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/quicksort_swap.txt
|
||||
procedure List.2 (List.73, List.74):
|
||||
let List.279 : U64 = CallByName List.6 List.73;
|
||||
let List.275 : Int1 = CallByName Num.22 List.74 List.279;
|
||||
if List.275 then
|
||||
let List.277 : I64 = CallByName List.60 List.73 List.74;
|
||||
let List.276 : [C {}, C I64] = Ok List.277;
|
||||
ret List.276;
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
procedure List.2 (List.74, List.75):
|
||||
let List.286 : U64 = CallByName List.6 List.74;
|
||||
let List.282 : Int1 = CallByName Num.22 List.75 List.286;
|
||||
if List.282 then
|
||||
let List.284 : I64 = CallByName List.60 List.74 List.75;
|
||||
let List.283 : [C {}, C I64] = Ok List.284;
|
||||
ret List.283;
|
||||
else
|
||||
let List.299 : {} = Struct {};
|
||||
let List.298 : [C {}, C I64] = Err List.299;
|
||||
ret List.298;
|
||||
let List.281 : {} = Struct {};
|
||||
let List.280 : [C {}, C I64] = Err List.281;
|
||||
ret List.280;
|
||||
|
||||
procedure List.3 (List.84, List.85, List.86):
|
||||
let List.288 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
|
||||
let List.287 : List I64 = StructAtIndex 0 List.288;
|
||||
inc List.287;
|
||||
dec List.288;
|
||||
ret List.287;
|
||||
procedure List.3 (List.82, List.83, List.84):
|
||||
let List.270 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
|
||||
let List.269 : List I64 = StructAtIndex 0 List.270;
|
||||
inc List.269;
|
||||
dec List.270;
|
||||
ret List.269;
|
||||
|
||||
procedure List.57 (List.81, List.82, List.83):
|
||||
let List.310 : U64 = CallByName List.6 List.81;
|
||||
let List.307 : Int1 = CallByName Num.22 List.82 List.310;
|
||||
if List.307 then
|
||||
let List.308 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
|
||||
ret List.308;
|
||||
procedure List.57 (List.79, List.80, List.81):
|
||||
let List.292 : U64 = CallByName List.6 List.79;
|
||||
let List.289 : Int1 = CallByName Num.22 List.80 List.292;
|
||||
if List.289 then
|
||||
let List.290 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
|
||||
ret List.290;
|
||||
else
|
||||
let List.306 : {List I64, I64} = Struct {List.81, List.83};
|
||||
ret List.306;
|
||||
let List.288 : {List I64, I64} = Struct {List.79, List.81};
|
||||
ret List.288;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.311 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.311;
|
||||
let List.293 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.293;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.312 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.312;
|
||||
let List.294 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.294;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
<<<<<<< HEAD
|
||||
let List.309 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.309;
|
||||
=======
|
||||
let List.284 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.284;
|
||||
=======
|
||||
procedure List.2 (List.71, List.72):
|
||||
let List.233 : U64 = CallByName List.6 List.71;
|
||||
let List.229 : Int1 = CallByName Num.22 List.72 List.233;
|
||||
if List.229 then
|
||||
let List.231 : I64 = CallByName List.60 List.71 List.72;
|
||||
let List.230 : [C {}, C I64] = Ok List.231;
|
||||
ret List.230;
|
||||
else
|
||||
let List.228 : {} = Struct {};
|
||||
let List.227 : [C {}, C I64] = Err List.228;
|
||||
ret List.227;
|
||||
|
||||
procedure List.3 (List.79, List.80, List.81):
|
||||
let List.217 : {List I64, I64} = CallByName List.57 List.79 List.80 List.81;
|
||||
let List.216 : List I64 = StructAtIndex 0 List.217;
|
||||
inc List.216;
|
||||
dec List.217;
|
||||
ret List.216;
|
||||
=======
|
||||
procedure List.2 (List.72, List.73):
|
||||
let List.258 : U64 = CallByName List.6 List.72;
|
||||
let List.254 : Int1 = CallByName Num.22 List.73 List.258;
|
||||
if List.254 then
|
||||
let List.256 : I64 = CallByName List.60 List.72 List.73;
|
||||
let List.255 : [C {}, C I64] = Ok List.256;
|
||||
ret List.255;
|
||||
else
|
||||
let List.253 : {} = Struct {};
|
||||
let List.252 : [C {}, C I64] = Err List.253;
|
||||
ret List.252;
|
||||
|
||||
procedure List.3 (List.80, List.81, List.82):
|
||||
let List.242 : {List I64, I64} = CallByName List.57 List.80 List.81 List.82;
|
||||
let List.241 : List I64 = StructAtIndex 0 List.242;
|
||||
inc List.241;
|
||||
dec List.242;
|
||||
ret List.241;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
|
||||
procedure List.57 (List.77, List.78, List.79):
|
||||
let List.264 : U64 = CallByName List.6 List.77;
|
||||
let List.261 : Int1 = CallByName Num.22 List.78 List.264;
|
||||
if List.261 then
|
||||
let List.262 : {List I64, I64} = CallByName List.61 List.77 List.78 List.79;
|
||||
ret List.262;
|
||||
else
|
||||
let List.260 : {List I64, I64} = Struct {List.77, List.79};
|
||||
ret List.260;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.265 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.265;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.266 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.266;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
<<<<<<< HEAD
|
||||
let List.238 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.238;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/quicksort_swap.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.263 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.263;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.291 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.291;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
||||
@ -1,127 +1,43 @@
|
||||
<<<<<<< HEAD
|
||||
<<<<<<< HEAD
|
||||
procedure List.2 (List.75, List.76):
|
||||
let List.304 : U64 = CallByName List.6 List.75;
|
||||
let List.300 : Int1 = CallByName Num.22 List.76 List.304;
|
||||
if List.300 then
|
||||
let List.302 : I64 = CallByName List.60 List.75 List.76;
|
||||
let List.301 : [C {}, C I64] = Ok List.302;
|
||||
ret List.301;
|
||||
=======
|
||||
<<<<<<< HEAD:crates/compiler/test_mono/generated/rigids.txt
|
||||
procedure List.2 (List.73, List.74):
|
||||
let List.279 : U64 = CallByName List.6 List.73;
|
||||
let List.275 : Int1 = CallByName Num.22 List.74 List.279;
|
||||
if List.275 then
|
||||
let List.277 : I64 = CallByName List.60 List.73 List.74;
|
||||
let List.276 : [C {}, C I64] = Ok List.277;
|
||||
ret List.276;
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
procedure List.2 (List.74, List.75):
|
||||
let List.286 : U64 = CallByName List.6 List.74;
|
||||
let List.282 : Int1 = CallByName Num.22 List.75 List.286;
|
||||
if List.282 then
|
||||
let List.284 : I64 = CallByName List.60 List.74 List.75;
|
||||
let List.283 : [C {}, C I64] = Ok List.284;
|
||||
ret List.283;
|
||||
else
|
||||
let List.299 : {} = Struct {};
|
||||
let List.298 : [C {}, C I64] = Err List.299;
|
||||
ret List.298;
|
||||
let List.281 : {} = Struct {};
|
||||
let List.280 : [C {}, C I64] = Err List.281;
|
||||
ret List.280;
|
||||
|
||||
procedure List.3 (List.84, List.85, List.86):
|
||||
let List.288 : {List I64, I64} = CallByName List.57 List.84 List.85 List.86;
|
||||
let List.287 : List I64 = StructAtIndex 0 List.288;
|
||||
inc List.287;
|
||||
dec List.288;
|
||||
ret List.287;
|
||||
procedure List.3 (List.82, List.83, List.84):
|
||||
let List.270 : {List I64, I64} = CallByName List.57 List.82 List.83 List.84;
|
||||
let List.269 : List I64 = StructAtIndex 0 List.270;
|
||||
inc List.269;
|
||||
dec List.270;
|
||||
ret List.269;
|
||||
|
||||
procedure List.57 (List.81, List.82, List.83):
|
||||
let List.310 : U64 = CallByName List.6 List.81;
|
||||
let List.307 : Int1 = CallByName Num.22 List.82 List.310;
|
||||
if List.307 then
|
||||
let List.308 : {List I64, I64} = CallByName List.61 List.81 List.82 List.83;
|
||||
ret List.308;
|
||||
procedure List.57 (List.79, List.80, List.81):
|
||||
let List.292 : U64 = CallByName List.6 List.79;
|
||||
let List.289 : Int1 = CallByName Num.22 List.80 List.292;
|
||||
if List.289 then
|
||||
let List.290 : {List I64, I64} = CallByName List.61 List.79 List.80 List.81;
|
||||
ret List.290;
|
||||
else
|
||||
let List.306 : {List I64, I64} = Struct {List.81, List.83};
|
||||
ret List.306;
|
||||
let List.288 : {List I64, I64} = Struct {List.79, List.81};
|
||||
ret List.288;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.311 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.311;
|
||||
let List.293 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.293;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.312 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.312;
|
||||
let List.294 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.294;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
<<<<<<< HEAD
|
||||
let List.309 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.309;
|
||||
=======
|
||||
let List.284 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.284;
|
||||
=======
|
||||
procedure List.2 (List.71, List.72):
|
||||
let List.233 : U64 = CallByName List.6 List.71;
|
||||
let List.229 : Int1 = CallByName Num.22 List.72 List.233;
|
||||
if List.229 then
|
||||
let List.231 : I64 = CallByName List.60 List.71 List.72;
|
||||
let List.230 : [C {}, C I64] = Ok List.231;
|
||||
ret List.230;
|
||||
else
|
||||
let List.228 : {} = Struct {};
|
||||
let List.227 : [C {}, C I64] = Err List.228;
|
||||
ret List.227;
|
||||
|
||||
procedure List.3 (List.79, List.80, List.81):
|
||||
let List.217 : {List I64, I64} = CallByName List.57 List.79 List.80 List.81;
|
||||
let List.216 : List I64 = StructAtIndex 0 List.217;
|
||||
inc List.216;
|
||||
dec List.217;
|
||||
ret List.216;
|
||||
=======
|
||||
procedure List.2 (List.72, List.73):
|
||||
let List.258 : U64 = CallByName List.6 List.72;
|
||||
let List.254 : Int1 = CallByName Num.22 List.73 List.258;
|
||||
if List.254 then
|
||||
let List.256 : I64 = CallByName List.60 List.72 List.73;
|
||||
let List.255 : [C {}, C I64] = Ok List.256;
|
||||
ret List.255;
|
||||
else
|
||||
let List.253 : {} = Struct {};
|
||||
let List.252 : [C {}, C I64] = Err List.253;
|
||||
ret List.252;
|
||||
|
||||
procedure List.3 (List.80, List.81, List.82):
|
||||
let List.242 : {List I64, I64} = CallByName List.57 List.80 List.81 List.82;
|
||||
let List.241 : List I64 = StructAtIndex 0 List.242;
|
||||
inc List.241;
|
||||
dec List.242;
|
||||
ret List.241;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
|
||||
procedure List.57 (List.77, List.78, List.79):
|
||||
let List.264 : U64 = CallByName List.6 List.77;
|
||||
let List.261 : Int1 = CallByName Num.22 List.78 List.264;
|
||||
if List.261 then
|
||||
let List.262 : {List I64, I64} = CallByName List.61 List.77 List.78 List.79;
|
||||
ret List.262;
|
||||
else
|
||||
let List.260 : {List I64, I64} = Struct {List.77, List.79};
|
||||
ret List.260;
|
||||
|
||||
procedure List.6 (#Attr.2):
|
||||
let List.265 : U64 = lowlevel ListLen #Attr.2;
|
||||
ret List.265;
|
||||
|
||||
procedure List.60 (#Attr.2, #Attr.3):
|
||||
let List.266 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3;
|
||||
ret List.266;
|
||||
|
||||
procedure List.61 (#Attr.2, #Attr.3, #Attr.4):
|
||||
<<<<<<< HEAD
|
||||
let List.238 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.238;
|
||||
>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/rigids.txt
|
||||
>>>>>>> 25bb3751b (Rename multimorphic tests to capture niche)
|
||||
=======
|
||||
let List.263 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.263;
|
||||
>>>>>>> 61fcac491 (Fix mono tests)
|
||||
let List.291 : {List I64, I64} = lowlevel ListReplaceUnsafe #Attr.2 #Attr.3 #Attr.4;
|
||||
ret List.291;
|
||||
|
||||
procedure Num.22 (#Attr.2, #Attr.3):
|
||||
let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
|
||||
|
||||
Loading…
Reference in New Issue
Block a user