From d08aecf55fe6e2c34b6aa9c4b8cd1f2aa11aa97c Mon Sep 17 00:00:00 2001 From: Ayaz Hafiz Date: Fri, 1 Jul 2022 15:56:06 -0400 Subject: [PATCH] Rename multimorphic tests to capture niche --- ...cialize_errors_behind_unified_branches.txt | 65 ++++++++++++++ compiler/test_mono/generated/list_get.txt | 35 ++++++++ .../generated/list_pass_to_function.txt | 39 +++++++++ .../test_mono/generated/closure_in_list.txt | 10 +++ crates/compiler/test_mono/generated/dict.txt | 8 +- .../generated/empty_list_of_function_type.txt | 41 ++++++++- .../compiler/test_mono/generated/encode.txt | 10 +++ .../test_mono/generated/factorial.txt | 8 +- .../if_guard_bind_variable_false.txt | 4 +- .../test_mono/generated/ir_int_add.txt | 14 ++- .../compiler/test_mono/generated/ir_plus.txt | 4 +- .../compiler/test_mono/generated/ir_round.txt | 4 +- .../test_mono/generated/ir_two_defs.txt | 4 +- .../test_mono/generated/ir_when_idiv.txt | 18 ++-- .../test_mono/generated/ir_when_just.txt | 4 +- .../lambda_capture_niche_u8_vs_u64.txt | 54 ++++++++++++ ...ches_have_captured_function_in_closure.txt | 85 +++++++++++++++++++ ...ure_niches_with_non_capturing_function.txt | 59 +++++++++++++ ...pture_niches_with_other_lambda_capture.txt | 68 +++++++++++++++ .../test_mono/generated/list_append.txt | 10 +++ .../generated/list_append_closure.txt | 10 +++ .../generated/list_cannot_update_inplace.txt | 56 +++++++++++- .../compiler/test_mono/generated/list_len.txt | 22 ++++- .../generated/list_map_closure_borrows.txt | 54 +++++++++++- .../generated/list_map_closure_owns.txt | 52 +++++++++++- .../test_mono/generated/list_sort_asc.txt | 30 ++++++- .../multimorphic_lambda_set_capture.txt | 8 +- .../generated/nested_pattern_match.txt | 4 +- .../test_mono/generated/optional_when.txt | 4 +- .../test_mono/generated/quicksort_help.txt | 12 +-- .../test_mono/generated/quicksort_swap.txt | 62 +++++++++++++- ...optional_field_function_no_use_default.txt | 4 +- ...rd_optional_field_function_use_default.txt | 4 +- ...cord_optional_field_let_no_use_default.txt | 4 +- .../record_optional_field_let_use_default.txt | 4 +- .../compiler/test_mono/generated/rigids.txt | 62 +++++++++++++- .../generated/specialize_closures.txt | 8 +- .../generated/specialize_lowlevel.txt | 8 +- .../generated/tail_call_elimination.txt | 8 +- .../test_mono/generated/when_nested_maybe.txt | 4 +- .../test_mono/generated/when_on_record.txt | 4 +- .../generated/when_on_two_values.txt | 4 +- crates/compiler/test_mono/src/tests.rs | 8 +- 43 files changed, 889 insertions(+), 91 deletions(-) create mode 100644 compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt create mode 100644 compiler/test_mono/generated/list_get.txt create mode 100644 compiler/test_mono/generated/list_pass_to_function.txt create mode 100644 crates/compiler/test_mono/generated/lambda_capture_niche_u8_vs_u64.txt create mode 100644 crates/compiler/test_mono/generated/lambda_capture_niches_have_captured_function_in_closure.txt create mode 100644 crates/compiler/test_mono/generated/lambda_capture_niches_with_non_capturing_function.txt create mode 100644 crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt diff --git a/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt b/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt new file mode 100644 index 0000000000..23285418ff --- /dev/null +++ b/compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt @@ -0,0 +1,65 @@ +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; diff --git a/compiler/test_mono/generated/list_get.txt b/compiler/test_mono/generated/list_get.txt new file mode 100644 index 0000000000..44e45be867 --- /dev/null +++ b/compiler/test_mono/generated/list_get.txt @@ -0,0 +1,35 @@ +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; diff --git a/compiler/test_mono/generated/list_pass_to_function.txt b/compiler/test_mono/generated/list_pass_to_function.txt new file mode 100644 index 0000000000..6d7eba5654 --- /dev/null +++ b/compiler/test_mono/generated/list_pass_to_function.txt @@ -0,0 +1,39 @@ +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; diff --git a/crates/compiler/test_mono/generated/closure_in_list.txt b/crates/compiler/test_mono/generated/closure_in_list.txt index e26803f469..643a75fdad 100644 --- a/crates/compiler/test_mono/generated/closure_in_list.txt +++ b/crates/compiler/test_mono/generated/closure_in_list.txt @@ -1,6 +1,16 @@ procedure List.6 (#Attr.2): +<<<<<<< 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) procedure Test.1 (Test.5): let Test.2 : I64 = 41i64; diff --git a/crates/compiler/test_mono/generated/dict.txt b/crates/compiler/test_mono/generated/dict.txt index 31ae33d719..bd378e9414 100644 --- a/crates/compiler/test_mono/generated/dict.txt +++ b/crates/compiler/test_mono/generated/dict.txt @@ -1,11 +1,11 @@ procedure Dict.1 (): - let Dict.28 : Dict [] [] = lowlevel DictEmpty ; - ret Dict.28; + let Dict.16 : Dict [] [] = lowlevel DictEmpty ; + ret Dict.16; procedure Dict.7 (#Attr.2): - let Dict.27 : U64 = lowlevel DictSize #Attr.2; + let Dict.15 : U64 = lowlevel DictSize #Attr.2; dec #Attr.2; - ret Dict.27; + ret Dict.15; procedure Test.0 (): let Test.2 : Dict [] [] = CallByName Dict.1; diff --git a/crates/compiler/test_mono/generated/empty_list_of_function_type.txt b/crates/compiler/test_mono/generated/empty_list_of_function_type.txt index 617e58feba..d1ffaafe5b 100644 --- a/crates/compiler/test_mono/generated/empty_list_of_function_type.txt +++ b/crates/compiler/test_mono/generated/empty_list_of_function_type.txt @@ -1,3 +1,4 @@ +<<<<<<< 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; @@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76): 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) else let List.285 : {} = Struct {}; let List.284 : [C {}, C {}] = Err List.285; @@ -15,12 +26,38 @@ procedure List.6 (#Attr.2): ret List.293; 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 Num.22 (#Attr.2, #Attr.3): - let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.188; procedure Test.2 (Test.6): let Test.18 : Str = "bar"; diff --git a/crates/compiler/test_mono/generated/encode.txt b/crates/compiler/test_mono/generated/encode.txt index cf24697b6f..7115be0912 100644 --- a/crates/compiler/test_mono/generated/encode.txt +++ b/crates/compiler/test_mono/generated/encode.txt @@ -1,6 +1,16 @@ procedure List.4 (#Attr.2, #Attr.3): +<<<<<<< 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) procedure Test.20 (Test.22): let Test.34 : {U8} = Struct {Test.22}; diff --git a/crates/compiler/test_mono/generated/factorial.txt b/crates/compiler/test_mono/generated/factorial.txt index a0ad7c91ac..165dc059a3 100644 --- a/crates/compiler/test_mono/generated/factorial.txt +++ b/crates/compiler/test_mono/generated/factorial.txt @@ -1,10 +1,10 @@ procedure Num.20 (#Attr.2, #Attr.3): - let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3; - ret Num.274; + let Num.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3; + ret Num.189; procedure Num.21 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3; + ret Num.188; procedure Test.1 (Test.15, Test.16): joinpoint Test.7 Test.2 Test.3: diff --git a/crates/compiler/test_mono/generated/if_guard_bind_variable_false.txt b/crates/compiler/test_mono/generated/if_guard_bind_variable_false.txt index cf492ae71d..7d73011b72 100644 --- a/crates/compiler/test_mono/generated/if_guard_bind_variable_false.txt +++ b/crates/compiler/test_mono/generated/if_guard_bind_variable_false.txt @@ -1,6 +1,6 @@ procedure Bool.7 (#Attr.2, #Attr.3): - let Bool.14 : Int1 = lowlevel Eq #Attr.2 #Attr.3; - ret Bool.14; + let Bool.9 : Int1 = lowlevel Eq #Attr.2 #Attr.3; + ret Bool.9; procedure Test.1 (Test.3): let Test.6 : I64 = 10i64; diff --git a/crates/compiler/test_mono/generated/ir_int_add.txt b/crates/compiler/test_mono/generated/ir_int_add.txt index 60f044c4cd..11f2565ef7 100644 --- a/crates/compiler/test_mono/generated/ir_int_add.txt +++ b/crates/compiler/test_mono/generated/ir_int_add.txt @@ -1,10 +1,20 @@ procedure List.6 (#Attr.2): +<<<<<<< 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) procedure Num.19 (#Attr.2, #Attr.3): - let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.275; + let Num.190 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.190; procedure Test.0 (): let Test.1 : List I64 = Array [1i64, 2i64]; diff --git a/crates/compiler/test_mono/generated/ir_plus.txt b/crates/compiler/test_mono/generated/ir_plus.txt index 8a3eff1485..7a8550c5e0 100644 --- a/crates/compiler/test_mono/generated/ir_plus.txt +++ b/crates/compiler/test_mono/generated/ir_plus.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.2 : I64 = 1i64; diff --git a/crates/compiler/test_mono/generated/ir_round.txt b/crates/compiler/test_mono/generated/ir_round.txt index 19f78559ec..233527563b 100644 --- a/crates/compiler/test_mono/generated/ir_round.txt +++ b/crates/compiler/test_mono/generated/ir_round.txt @@ -1,6 +1,6 @@ procedure Num.45 (#Attr.2): - let Num.273 : I64 = lowlevel NumRound #Attr.2; - ret Num.273; + let Num.188 : I64 = lowlevel NumRound #Attr.2; + ret Num.188; procedure Test.0 (): let Test.2 : Float64 = 3.6f64; diff --git a/crates/compiler/test_mono/generated/ir_two_defs.txt b/crates/compiler/test_mono/generated/ir_two_defs.txt index bdfba4a214..52214a8c65 100644 --- a/crates/compiler/test_mono/generated/ir_two_defs.txt +++ b/crates/compiler/test_mono/generated/ir_two_defs.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.1 : I64 = 3i64; diff --git a/crates/compiler/test_mono/generated/ir_when_idiv.txt b/crates/compiler/test_mono/generated/ir_when_idiv.txt index a4c3915acf..9706bd86fa 100644 --- a/crates/compiler/test_mono/generated/ir_when_idiv.txt +++ b/crates/compiler/test_mono/generated/ir_when_idiv.txt @@ -1,14 +1,14 @@ procedure Num.40 (#Attr.2, #Attr.3): - let Num.278 : I64 = 0i64; - let Num.275 : Int1 = lowlevel NotEq #Attr.3 Num.278; - if Num.275 then - let Num.277 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3; - let Num.276 : [C {}, C I64] = Ok Num.277; - ret Num.276; + let Num.193 : I64 = 0i64; + let Num.190 : Int1 = lowlevel NotEq #Attr.3 Num.193; + if Num.190 then + let Num.192 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3; + let Num.191 : [C {}, C I64] = Ok Num.192; + ret Num.191; else - let Num.274 : {} = Struct {}; - let Num.273 : [C {}, C I64] = Err Num.274; - ret Num.273; + let Num.189 : {} = Struct {}; + let Num.188 : [C {}, C I64] = Err Num.189; + ret Num.188; procedure Test.0 (): let Test.8 : I64 = 1000i64; diff --git a/crates/compiler/test_mono/generated/ir_when_just.txt b/crates/compiler/test_mono/generated/ir_when_just.txt index d6619036ab..8959b2d342 100644 --- a/crates/compiler/test_mono/generated/ir_when_just.txt +++ b/crates/compiler/test_mono/generated/ir_when_just.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.10 : I64 = 41i64; diff --git a/crates/compiler/test_mono/generated/lambda_capture_niche_u8_vs_u64.txt b/crates/compiler/test_mono/generated/lambda_capture_niche_u8_vs_u64.txt new file mode 100644 index 0000000000..b7cc9bd341 --- /dev/null +++ b/crates/compiler/test_mono/generated/lambda_capture_niche_u8_vs_u64.txt @@ -0,0 +1,54 @@ +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; diff --git a/crates/compiler/test_mono/generated/lambda_capture_niches_have_captured_function_in_closure.txt b/crates/compiler/test_mono/generated/lambda_capture_niches_have_captured_function_in_closure.txt new file mode 100644 index 0000000000..d7371b4421 --- /dev/null +++ b/crates/compiler/test_mono/generated/lambda_capture_niches_have_captured_function_in_closure.txt @@ -0,0 +1,85 @@ +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; diff --git a/crates/compiler/test_mono/generated/lambda_capture_niches_with_non_capturing_function.txt b/crates/compiler/test_mono/generated/lambda_capture_niches_with_non_capturing_function.txt new file mode 100644 index 0000000000..6ef000047c --- /dev/null +++ b/crates/compiler/test_mono/generated/lambda_capture_niches_with_non_capturing_function.txt @@ -0,0 +1,59 @@ +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; + diff --git a/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt b/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt new file mode 100644 index 0000000000..b553adfbc1 --- /dev/null +++ b/crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt @@ -0,0 +1,68 @@ +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; + diff --git a/crates/compiler/test_mono/generated/list_append.txt b/crates/compiler/test_mono/generated/list_append.txt index ba872126f2..9d9624a7a0 100644 --- a/crates/compiler/test_mono/generated/list_append.txt +++ b/crates/compiler/test_mono/generated/list_append.txt @@ -1,6 +1,16 @@ procedure List.4 (#Attr.2, #Attr.3): +<<<<<<< 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) procedure Test.0 (): let Test.2 : List I64 = Array [1i64]; diff --git a/crates/compiler/test_mono/generated/list_append_closure.txt b/crates/compiler/test_mono/generated/list_append_closure.txt index c02bd4ddcb..9566c7d113 100644 --- a/crates/compiler/test_mono/generated/list_append_closure.txt +++ b/crates/compiler/test_mono/generated/list_append_closure.txt @@ -1,6 +1,16 @@ procedure List.4 (#Attr.2, #Attr.3): +<<<<<<< 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) procedure Test.1 (Test.2): let Test.6 : I64 = 42i64; diff --git a/crates/compiler/test_mono/generated/list_cannot_update_inplace.txt b/crates/compiler/test_mono/generated/list_cannot_update_inplace.txt index f98eb4a9d0..8d0977f122 100644 --- a/crates/compiler/test_mono/generated/list_cannot_update_inplace.txt +++ b/crates/compiler/test_mono/generated/list_cannot_update_inplace.txt @@ -1,3 +1,4 @@ +<<<<<<< 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; @@ -11,6 +12,22 @@ procedure List.57 (List.81, List.82, List.83): 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; + +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) else let List.289 : {List I64, I64} = Struct {List.81, List.83}; ret List.289; @@ -20,16 +37,47 @@ procedure List.6 (#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; + 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; + else + let List.218 : {List I64, I64} = Struct {List.76, List.78}; + ret List.218; + +procedure List.6 (#Attr.2): + let List.214 : U64 = lowlevel ListLen #Attr.2; + ret List.214; + +procedure List.61 (#Attr.2, #Attr.3, #Attr.4): + 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) procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Num.22 (#Attr.2, #Attr.3): - let Num.274 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.274; + let Num.189 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.189; procedure Test.1 (): let Test.8 : List I64 = Array [1i64, 2i64, 3i64]; diff --git a/crates/compiler/test_mono/generated/list_len.txt b/crates/compiler/test_mono/generated/list_len.txt index 246d7c2fb4..01f1647f98 100644 --- a/crates/compiler/test_mono/generated/list_len.txt +++ b/crates/compiler/test_mono/generated/list_len.txt @@ -1,14 +1,32 @@ procedure List.6 (#Attr.2): +<<<<<<< HEAD let List.284 : U64 = lowlevel ListLen #Attr.2; ret List.284; 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) procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : U64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.1 : List I64 = Array [1i64, 2i64, 3i64]; diff --git a/crates/compiler/test_mono/generated/list_map_closure_borrows.txt b/crates/compiler/test_mono/generated/list_map_closure_borrows.txt index 338e6a59b2..3e4c8afc1a 100644 --- a/crates/compiler/test_mono/generated/list_map_closure_borrows.txt +++ b/crates/compiler/test_mono/generated/list_map_closure_borrows.txt @@ -1,3 +1,4 @@ +<<<<<<< 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; @@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76): 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) else let List.285 : {} = Struct {}; let List.284 : [C {}, C Str] = Err List.285; @@ -19,20 +30,59 @@ procedure List.6 (#Attr.2): ret List.294; 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 Num.22 (#Attr.2, #Attr.3): - let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.188; procedure Str.16 (#Attr.2, #Attr.3): +<<<<<<< HEAD:crates/compiler/test_mono/generated/list_map_closure_borrows.txt let Str.67 : Str = lowlevel StrRepeat #Attr.2 #Attr.3; ret Str.67; procedure Str.3 (#Attr.2, #Attr.3): let Str.68 : Str = lowlevel StrConcat #Attr.2 #Attr.3; ret Str.68; +======= + let Str.36 : Str = lowlevel StrRepeat #Attr.2 #Attr.3; + ret Str.36; + +procedure Str.3 (#Attr.2, #Attr.3): + let Str.37 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.37; +>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_map_closure_borrows.txt procedure Test.1 (): let Test.21 : Str = "lllllllllllllllllllllooooooooooong"; diff --git a/crates/compiler/test_mono/generated/list_map_closure_owns.txt b/crates/compiler/test_mono/generated/list_map_closure_owns.txt index 8818b60944..db2a916558 100644 --- a/crates/compiler/test_mono/generated/list_map_closure_owns.txt +++ b/crates/compiler/test_mono/generated/list_map_closure_owns.txt @@ -1,3 +1,4 @@ +<<<<<<< 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; @@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76): 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) else let List.285 : {} = Struct {}; let List.284 : [C {}, C Str] = Err List.285; @@ -21,16 +32,53 @@ procedure List.6 (#Attr.2): ret List.294; 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 Num.22 (#Attr.2, #Attr.3): - let Num.273 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.188; procedure Str.3 (#Attr.2, #Attr.3): +<<<<<<< HEAD:crates/compiler/test_mono/generated/list_map_closure_owns.txt let Str.68 : Str = lowlevel StrConcat #Attr.2 #Attr.3; ret Str.68; +======= + let Str.37 : Str = lowlevel StrConcat #Attr.2 #Attr.3; + ret Str.37; +>>>>>>> a5fc399f4 (Rename multimorphic tests to capture niche):compiler/test_mono/generated/list_map_closure_owns.txt procedure Test.1 (): let Test.21 : Str = "lllllllllllllllllllllooooooooooong"; diff --git a/crates/compiler/test_mono/generated/list_sort_asc.txt b/crates/compiler/test_mono/generated/list_sort_asc.txt index fa7e00c424..a385b049f6 100644 --- a/crates/compiler/test_mono/generated/list_sort_asc.txt +++ b/crates/compiler/test_mono/generated/list_sort_asc.txt @@ -1,5 +1,10 @@ procedure List.28 (#Attr.2, #Attr.3): +<<<<<<< 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; @@ -7,14 +12,35 @@ procedure List.28 (#Attr.2, #Attr.3): 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 Bool.9 : Int1 = lowlevel ListIsUnique #Attr.2; + if Bool.9 then + ret List.216; + else + decref #Attr.2; + ret List.216; + +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 Num.46 (#Attr.2, #Attr.3): - let Num.273 : U8 = lowlevel NumCompare #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : U8 = lowlevel NumCompare #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.2 : List I64 = Array [4i64, 3i64, 2i64, 1i64]; diff --git a/crates/compiler/test_mono/generated/multimorphic_lambda_set_capture.txt b/crates/compiler/test_mono/generated/multimorphic_lambda_set_capture.txt index 50b76169e7..b7cc9bd341 100644 --- a/crates/compiler/test_mono/generated/multimorphic_lambda_set_capture.txt +++ b/crates/compiler/test_mono/generated/multimorphic_lambda_set_capture.txt @@ -1,10 +1,10 @@ procedure Num.94 (#Attr.2): - let Num.273 : Str = lowlevel NumToStr #Attr.2; - ret Num.273; + let Num.188 : Str = lowlevel NumToStr #Attr.2; + ret Num.188; procedure Num.94 (#Attr.2): - let Num.274 : Str = lowlevel NumToStr #Attr.2; - ret Num.274; + 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; diff --git a/crates/compiler/test_mono/generated/nested_pattern_match.txt b/crates/compiler/test_mono/generated/nested_pattern_match.txt index 272fa01449..6673261ca3 100644 --- a/crates/compiler/test_mono/generated/nested_pattern_match.txt +++ b/crates/compiler/test_mono/generated/nested_pattern_match.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.19 : I64 = 41i64; diff --git a/crates/compiler/test_mono/generated/optional_when.txt b/crates/compiler/test_mono/generated/optional_when.txt index 239dbc721f..00f3ca57b7 100644 --- a/crates/compiler/test_mono/generated/optional_when.txt +++ b/crates/compiler/test_mono/generated/optional_when.txt @@ -1,6 +1,6 @@ procedure Num.21 (#Attr.2, #Attr.3): - let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3; - ret Num.275; + let Num.190 : I64 = lowlevel NumMul #Attr.2 #Attr.3; + ret Num.190; procedure Test.1 (Test.6): let Test.21 : Int1 = false; diff --git a/crates/compiler/test_mono/generated/quicksort_help.txt b/crates/compiler/test_mono/generated/quicksort_help.txt index 2c00aa804b..ba35a161f7 100644 --- a/crates/compiler/test_mono/generated/quicksort_help.txt +++ b/crates/compiler/test_mono/generated/quicksort_help.txt @@ -1,14 +1,14 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Num.20 (#Attr.2, #Attr.3): - let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3; - ret Num.274; + let Num.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3; + ret Num.189; procedure Num.22 (#Attr.2, #Attr.3): - let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.275; + let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.190; procedure Test.1 (Test.24, Test.25, Test.26): joinpoint Test.12 Test.2 Test.3 Test.4: diff --git a/crates/compiler/test_mono/generated/quicksort_swap.txt b/crates/compiler/test_mono/generated/quicksort_swap.txt index 84bedc1a65..43dac09ce8 100644 --- a/crates/compiler/test_mono/generated/quicksort_swap.txt +++ b/crates/compiler/test_mono/generated/quicksort_swap.txt @@ -1,3 +1,4 @@ +<<<<<<< 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; @@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76): 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) else let List.299 : {} = Struct {}; let List.298 : [C {}, C I64] = Err List.299; @@ -36,12 +47,59 @@ procedure List.60 (#Attr.2, #Attr.3): ret List.312; 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.57 (List.76, List.77, List.78): + let List.239 : U64 = CallByName List.6 List.76; + let List.236 : Int1 = CallByName Num.22 List.77 List.239; + if List.236 then + let List.237 : {List I64, I64} = CallByName List.61 List.76 List.77 List.78; + ret List.237; + else + let List.235 : {List I64, I64} = Struct {List.76, List.78}; + ret List.235; + +procedure List.6 (#Attr.2): + let List.240 : U64 = lowlevel ListLen #Attr.2; + ret List.240; + +procedure List.60 (#Attr.2, #Attr.3): + let List.241 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.241; + +procedure List.61 (#Attr.2, #Attr.3, #Attr.4): + 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) procedure Num.22 (#Attr.2, #Attr.3): - let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.275; + let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.190; procedure Test.1 (Test.2): let Test.28 : U64 = 0i64; diff --git a/crates/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt b/crates/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt index 82db9ad2db..2c661940cc 100644 --- a/crates/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt +++ b/crates/compiler/test_mono/generated/record_optional_field_function_no_use_default.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.1 (Test.4): let Test.2 : I64 = StructAtIndex 0 Test.4; diff --git a/crates/compiler/test_mono/generated/record_optional_field_function_use_default.txt b/crates/compiler/test_mono/generated/record_optional_field_function_use_default.txt index eaba7d9de5..2145dec395 100644 --- a/crates/compiler/test_mono/generated/record_optional_field_function_use_default.txt +++ b/crates/compiler/test_mono/generated/record_optional_field_function_use_default.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.1 (Test.4): let Test.2 : I64 = 10i64; diff --git a/crates/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt b/crates/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt index 959902f6d8..84a986e3c6 100644 --- a/crates/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt +++ b/crates/compiler/test_mono/generated/record_optional_field_let_no_use_default.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.1 (Test.2): let Test.3 : I64 = StructAtIndex 0 Test.2; diff --git a/crates/compiler/test_mono/generated/record_optional_field_let_use_default.txt b/crates/compiler/test_mono/generated/record_optional_field_let_use_default.txt index aad801aab9..ede661ab6b 100644 --- a/crates/compiler/test_mono/generated/record_optional_field_let_use_default.txt +++ b/crates/compiler/test_mono/generated/record_optional_field_let_use_default.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.1 (Test.2): let Test.3 : I64 = 10i64; diff --git a/crates/compiler/test_mono/generated/rigids.txt b/crates/compiler/test_mono/generated/rigids.txt index 2285fe56ac..c3ca7f7ca5 100644 --- a/crates/compiler/test_mono/generated/rigids.txt +++ b/crates/compiler/test_mono/generated/rigids.txt @@ -1,3 +1,4 @@ +<<<<<<< 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; @@ -5,6 +6,16 @@ procedure List.2 (List.75, List.76): 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) else let List.299 : {} = Struct {}; let List.298 : [C {}, C I64] = Err List.299; @@ -36,12 +47,59 @@ procedure List.60 (#Attr.2, #Attr.3): ret List.312; 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.57 (List.76, List.77, List.78): + let List.239 : U64 = CallByName List.6 List.76; + let List.236 : Int1 = CallByName Num.22 List.77 List.239; + if List.236 then + let List.237 : {List I64, I64} = CallByName List.61 List.76 List.77 List.78; + ret List.237; + else + let List.235 : {List I64, I64} = Struct {List.76, List.78}; + ret List.235; + +procedure List.6 (#Attr.2): + let List.240 : U64 = lowlevel ListLen #Attr.2; + ret List.240; + +procedure List.60 (#Attr.2, #Attr.3): + let List.241 : I64 = lowlevel ListGetUnsafe #Attr.2 #Attr.3; + ret List.241; + +procedure List.61 (#Attr.2, #Attr.3, #Attr.4): + 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) procedure Num.22 (#Attr.2, #Attr.3): - let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; - ret Num.275; + let Num.190 : Int1 = lowlevel NumLt #Attr.2 #Attr.3; + ret Num.190; procedure Test.1 (Test.2, Test.3, Test.4): let Test.29 : [C {}, C I64] = CallByName List.2 Test.4 Test.3; diff --git a/crates/compiler/test_mono/generated/specialize_closures.txt b/crates/compiler/test_mono/generated/specialize_closures.txt index 251e80285d..30e609df83 100644 --- a/crates/compiler/test_mono/generated/specialize_closures.txt +++ b/crates/compiler/test_mono/generated/specialize_closures.txt @@ -1,10 +1,10 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.274; + let Num.189 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.189; procedure Num.21 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3; + ret Num.188; procedure Test.1 (Test.2, Test.3): let Test.17 : U8 = GetTagId Test.2; diff --git a/crates/compiler/test_mono/generated/specialize_lowlevel.txt b/crates/compiler/test_mono/generated/specialize_lowlevel.txt index 74bc5c3bbb..e460b2b108 100644 --- a/crates/compiler/test_mono/generated/specialize_lowlevel.txt +++ b/crates/compiler/test_mono/generated/specialize_lowlevel.txt @@ -1,10 +1,10 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.274; + let Num.189 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.189; procedure Num.21 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumMul #Attr.2 #Attr.3; + ret Num.188; procedure Test.6 (Test.8, #Attr.12): let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12; diff --git a/crates/compiler/test_mono/generated/tail_call_elimination.txt b/crates/compiler/test_mono/generated/tail_call_elimination.txt index 236038343a..fb7a162575 100644 --- a/crates/compiler/test_mono/generated/tail_call_elimination.txt +++ b/crates/compiler/test_mono/generated/tail_call_elimination.txt @@ -1,10 +1,10 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Num.20 (#Attr.2, #Attr.3): - let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3; - ret Num.274; + let Num.189 : I64 = lowlevel NumSub #Attr.2 #Attr.3; + ret Num.189; procedure Test.1 (Test.15, Test.16): joinpoint Test.7 Test.2 Test.3: diff --git a/crates/compiler/test_mono/generated/when_nested_maybe.txt b/crates/compiler/test_mono/generated/when_nested_maybe.txt index 272fa01449..6673261ca3 100644 --- a/crates/compiler/test_mono/generated/when_nested_maybe.txt +++ b/crates/compiler/test_mono/generated/when_nested_maybe.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.19 : I64 = 41i64; diff --git a/crates/compiler/test_mono/generated/when_on_record.txt b/crates/compiler/test_mono/generated/when_on_record.txt index 71fec29389..2cc52368b6 100644 --- a/crates/compiler/test_mono/generated/when_on_record.txt +++ b/crates/compiler/test_mono/generated/when_on_record.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.5 : I64 = 2i64; diff --git a/crates/compiler/test_mono/generated/when_on_two_values.txt b/crates/compiler/test_mono/generated/when_on_two_values.txt index f3d84fff9e..c5361ba0b9 100644 --- a/crates/compiler/test_mono/generated/when_on_two_values.txt +++ b/crates/compiler/test_mono/generated/when_on_two_values.txt @@ -1,6 +1,6 @@ procedure Num.19 (#Attr.2, #Attr.3): - let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; - ret Num.273; + let Num.188 : I64 = lowlevel NumAdd #Attr.2 #Attr.3; + ret Num.188; procedure Test.0 (): let Test.15 : I64 = 3i64; diff --git a/crates/compiler/test_mono/src/tests.rs b/crates/compiler/test_mono/src/tests.rs index e1ca980d51..2b0fd0fafa 100644 --- a/crates/compiler/test_mono/src/tests.rs +++ b/crates/compiler/test_mono/src/tests.rs @@ -1527,7 +1527,7 @@ fn tail_call_with_different_layout() { } #[mono_test] -fn multimorphic_lambda_set_capture() { +fn lambda_capture_niche_u8_vs_u64() { indoc!( r#" capture : _ -> ({} -> Str) @@ -1549,7 +1549,7 @@ fn multimorphic_lambda_set_capture() { } #[mono_test] -fn multimorphic_lambdas_with_other_lambda_capture() { +fn lambda_capture_niches_with_other_lambda_capture() { indoc!( r#" capture : a -> ({} -> Str) @@ -1575,7 +1575,7 @@ fn multimorphic_lambdas_with_other_lambda_capture() { } #[mono_test] -fn multimorphic_lambdas_with_non_capturing_function() { +fn lambda_capture_niches_with_non_capturing_function() { indoc!( r#" capture : a -> ({} -> Str) @@ -1601,7 +1601,7 @@ fn multimorphic_lambdas_with_non_capturing_function() { } #[mono_test] -fn multimorphic_lambdas_have_captured_function_in_closure() { +fn lambda_capture_niches_have_captured_function_in_closure() { indoc!( r#" Lazy a : {} -> a