language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-08-02 11:22:19 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 6

Merge remote-tracking branch 'remote/main' into docs-highlight

Browse source
This commit is contained in:
Luke Boswell 2023-03-07 17:59:32 +11:00
commit a87794e7b2
No known key found for this signature in database
GPG key ID: F6DB3C9DB47377B0
20 changed files with 589 additions and 386 deletions
Download patch file Download diff file Expand all files Collapse all files

51
crates/compiler/gen_dev/src/generic64/aarch64.rs
View file

@ -843,12 +843,12 @@ impl Assembler<AArch64GeneralReg, AArch64FloatReg> for AArch64Assembler {
}
#[inline(always)]
fn sub_reg64_reg64_reg64(
_buf: &mut Vec<'_, u8>,
_dst: AArch64GeneralReg,
_src1: AArch64GeneralReg,
_src2: AArch64GeneralReg,
buf: &mut Vec<'_, u8>,
dst: AArch64GeneralReg,
src1: AArch64GeneralReg,
src2: AArch64GeneralReg,
) {
todo!("registers subtractions for AArch64");
sub_reg64_reg64_reg64(buf, dst, src1, src2);
}
#[inline(always)]
@ -1477,6 +1477,19 @@ fn sub_reg64_reg64_imm12(
buf.extend(inst.bytes());
}
/// `SUB Xd, Xm, Xn` -> Subtract Xm and Xn and place the result into Xd.
#[inline(always)]
fn sub_reg64_reg64_reg64(
buf: &mut Vec<'_, u8>,
dst: AArch64GeneralReg,
src1: AArch64GeneralReg,
src2: AArch64GeneralReg,
) {
let inst = ArithmeticShifted::new(true, false, ShiftType::LSL, 0, src2, src1, dst);
buf.extend(inst.bytes());
}
/// `RET Xn` -> Return to the address stored in Xn.
#[inline(always)]
fn ret_reg64(buf: &mut Vec<'_, u8>, xn: AArch64GeneralReg) {
@ -1697,6 +1710,34 @@ mod tests {
);
}
#[test]
fn test_sub_reg64_reg64_reg64() {
disassembler_test!(
sub_reg64_reg64_reg64,
|reg1: AArch64GeneralReg, reg2: AArch64GeneralReg, reg3: AArch64GeneralReg| {
if reg2 == AArch64GeneralReg::ZRSP {
// When the second register is ZR, it gets disassembled as neg,
// which is an alias for sub.
format!(
"neg {}, {}",
reg1.capstone_string(UsesZR),
reg3.capstone_string(UsesZR)
)
} else {
format!(
"sub {}, {}, {}",
reg1.capstone_string(UsesZR),
reg2.capstone_string(UsesZR),
reg3.capstone_string(UsesZR)
)
}
},
ALL_GENERAL_REGS,
ALL_GENERAL_REGS,
ALL_GENERAL_REGS
);
}
#[test]
fn test_ret_reg64() {
disassembler_test!(

115
crates/compiler/mono/src/ir.rs
View file

@ -2317,15 +2317,6 @@ impl<'a> Stmt<'a> {
String::from_utf8(w).unwrap()
}
pub fn is_terminal(&self) -> bool {
use Stmt::*;
matches!(
self,
Switch { .. } | Ret(_) | Jump(_, _) // TODO for Switch; is this the reason Lean only looks at the outermost `when`?
)
}
pub fn if_then_else(
arena: &'a Bump,
condition_symbol: Symbol,
@ -10849,7 +10840,20 @@ fn union_lambda_set_to_switch<'a>(
return empty_lambda_set_error(env);
}
let join_point_id = JoinPointId(env.unique_symbol());
let (opt_join, branch_assigned, branch_hole) = match hole {
Stmt::Ret(_) => {
// No need to jump to a joinpoint, inline the return in each statement as-is.
// This makes further analyses, like TCO, easier as well.
(None, assigned, hole)
}
_ => {
let join_point_id = JoinPointId(env.unique_symbol());
let assigned = env.unique_symbol();
let hole = Stmt::Jump(join_point_id, env.arena.alloc([assigned]));
(Some(join_point_id), assigned, &*env.arena.alloc(hole))
}
};
let mut branches = Vec::with_capacity_in(lambda_set.len(), env.arena);
@ -10865,12 +10869,13 @@ fn union_lambda_set_to_switch<'a>(
let stmt = union_lambda_set_branch(
env,
join_point_id,
lambda_name,
closure_info,
argument_symbols,
argument_layouts,
return_layout,
branch_assigned,
branch_hole,
);
branches.push((i as u64, BranchInfo::None, stmt));
}
@ -10889,34 +10894,36 @@ fn union_lambda_set_to_switch<'a>(
ret_layout: return_layout,
};
let param = Param {
symbol: assigned,
layout: return_layout,
ownership: Ownership::Owned,
};
match opt_join {
None => switch,
Some(join_point_id) => {
let param = Param {
symbol: assigned,
layout: return_layout,
ownership: Ownership::Owned,
};
Stmt::Join {
id: join_point_id,
parameters: &*env.arena.alloc([param]),
body: hole,
remainder: env.arena.alloc(switch),
Stmt::Join {
id: join_point_id,
parameters: &*env.arena.alloc([param]),
body: hole,
remainder: env.arena.alloc(switch),
}
}
}
}
#[allow(clippy::too_many_arguments)]
fn union_lambda_set_branch<'a>(
env: &mut Env<'a, '_>,
join_point_id: JoinPointId,
lambda_name: LambdaName<'a>,
closure_info: ClosureInfo<'a>,
argument_symbols_slice: &'a [Symbol],
argument_layouts_slice: &'a [InLayout<'a>],
return_layout: InLayout<'a>,
assigned: Symbol,
hole: &'a Stmt<'a>,
) -> Stmt<'a> {
let result_symbol = env.unique_symbol();
let hole = Stmt::Jump(join_point_id, env.arena.alloc([result_symbol]));
union_lambda_set_branch_help(
env,
lambda_name,
@ -10924,7 +10931,7 @@ fn union_lambda_set_branch<'a>(
argument_symbols_slice,
argument_layouts_slice,
return_layout,
result_symbol,
assigned,
env.arena.alloc(hole),
)
}
@ -11010,18 +11017,32 @@ fn enum_lambda_set_to_switch<'a>(
) -> Stmt<'a> {
debug_assert_ne!(lambda_set.len(), 0);
let join_point_id = JoinPointId(env.unique_symbol());
let (opt_join, branch_assigned, branch_hole) = match hole {
Stmt::Ret(_) => {
// No need to jump to a joinpoint, inline the return in each statement as-is.
// This makes further analyses, like TCO, easier as well.
(None, assigned, hole)
}
_ => {
let join_point_id = JoinPointId(env.unique_symbol());
let assigned = env.unique_symbol();
let hole = Stmt::Jump(join_point_id, env.arena.alloc([assigned]));
(Some(join_point_id), assigned, &*env.arena.alloc(hole))
}
};
let mut branches = Vec::with_capacity_in(lambda_set.len(), env.arena);
for (i, lambda_name) in lambda_set.into_iter().enumerate() {
let stmt = enum_lambda_set_branch(
env,
join_point_id,
lambda_name,
argument_symbols,
argument_layouts,
return_layout,
branch_assigned,
branch_hole,
);
branches.push((i as u64, BranchInfo::None, stmt));
}
@ -11040,17 +11061,22 @@ fn enum_lambda_set_to_switch<'a>(
ret_layout: return_layout,
};
let param = Param {
symbol: assigned,
layout: return_layout,
ownership: Ownership::Owned,
};
match opt_join {
None => switch,
Some(join_point_id) => {
let param = Param {
symbol: assigned,
layout: return_layout,
ownership: Ownership::Owned,
};
Stmt::Join {
id: join_point_id,
parameters: &*env.arena.alloc([param]),
body: hole,
remainder: env.arena.alloc(switch),
Stmt::Join {
id: join_point_id,
parameters: &*env.arena.alloc([param]),
body: hole,
remainder: env.arena.alloc(switch),
}
}
}
}
@ -11058,18 +11084,13 @@ fn enum_lambda_set_to_switch<'a>(
#[allow(clippy::too_many_arguments)]
fn enum_lambda_set_branch<'a>(
env: &mut Env<'a, '_>,
join_point_id: JoinPointId,
lambda_name: LambdaName<'a>,
argument_symbols: &'a [Symbol],
argument_layouts: &'a [InLayout<'a>],
return_layout: InLayout<'a>,
assigned: Symbol,
hole: &'a Stmt<'a>,
) -> Stmt<'a> {
let result_symbol = env.unique_symbol();
let hole = Stmt::Jump(join_point_id, env.arena.alloc([result_symbol]));
let assigned = result_symbol;
let call = self::Call {
call_type: CallType::ByName {
name: lambda_name,
@ -11079,7 +11100,7 @@ fn enum_lambda_set_branch<'a>(
},
arguments: argument_symbols,
};
build_call(env, call, assigned, return_layout, env.arena.alloc(hole))
build_call(env, call, assigned, return_layout, hole)
}
#[allow(clippy::too_many_arguments)]

20
crates/compiler/test_mono/generated/function_specialization_information_in_lambda_set_thunk.txt
View file

@ -23,19 +23,19 @@ procedure Test.4 (Test.5, Test.3):
jump Test.19 Test.20;
default:
let Test.21 : I64 = CallByName Test.7 Test.18;
jump Test.19 Test.21;
let Test.20 : I64 = CallByName Test.7 Test.18;
jump Test.19 Test.20;
procedure Test.6 (Test.22):
let Test.25 : Int1 = true;
let Test.24 : I64 = CallByName Test.2;
let Test.23 : I64 = CallByName Test.4 Test.25 Test.24;
ret Test.23;
procedure Test.6 (Test.21):
let Test.24 : Int1 = true;
let Test.23 : I64 = CallByName Test.2;
let Test.22 : I64 = CallByName Test.4 Test.24 Test.23;
ret Test.22;
procedure Test.7 (Test.26):
let Test.27 : I64 = 10i64;
ret Test.27;
procedure Test.7 (Test.25):
let Test.26 : I64 = 10i64;
ret Test.26;
procedure Test.0 ():
let Test.11 : Int1 = false;

34
crates/compiler/test_mono/generated/inline_return_joinpoints_in_bool_lambda_set.txt Normal file
View file

@ -0,0 +1,34 @@
procedure Bool.1 ():
let Bool.23 : Int1 = false;
ret Bool.23;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.256 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.256;
procedure Test.3 (Test.4):
ret Test.4;
procedure Test.0 (Test.14):
joinpoint Test.5 Test.1:
joinpoint Test.10 Test.2:
let Test.8 : I64 = 1i64;
let Test.7 : I64 = CallByName Num.19 Test.1 Test.8;
switch Test.2:
case 0:
jump Test.5 Test.7;
default:
let Test.6 : I64 = CallByName Test.3 Test.7;
ret Test.6;
in
let Test.12 : Int1 = CallByName Bool.1;
if Test.12 then
let Test.9 : Int1 = false;
jump Test.10 Test.9;
else
let Test.9 : Int1 = true;
jump Test.10 Test.9;
in
jump Test.5 Test.14;

60
crates/compiler/test_mono/generated/inline_return_joinpoints_in_enum_lambda_set.txt Normal file
View file

@ -0,0 +1,60 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.258 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.258;
procedure Test.2 (Test.3):
switch Test.3:
case 0:
let Test.16 : U8 = 0u8;
ret Test.16;
case 1:
let Test.17 : U8 = 1u8;
ret Test.17;
case 2:
let Test.19 : U8 = 2u8;
ret Test.19;
default:
let Test.22 : U8 = 3u8;
ret Test.22;
procedure Test.4 (Test.5):
ret Test.5;
procedure Test.6 (Test.7):
let Test.21 : I64 = 1i64;
let Test.20 : I64 = CallByName Num.19 Test.7 Test.21;
ret Test.20;
procedure Test.8 (Test.9):
let Test.24 : I64 = 2i64;
let Test.23 : I64 = CallByName Num.19 Test.9 Test.24;
ret Test.23;
procedure Test.0 (Test.30):
joinpoint Test.11 Test.1:
let Test.25 : I64 = 1i64;
let Test.13 : I64 = CallByName Num.19 Test.1 Test.25;
let Test.15 : U8 = 0u8;
let Test.14 : U8 = CallByName Test.2 Test.15;
switch Test.14:
case 0:
jump Test.11 Test.13;
case 1:
let Test.12 : I64 = CallByName Test.4 Test.13;
ret Test.12;
case 2:
let Test.12 : I64 = CallByName Test.6 Test.13;
ret Test.12;
default:
let Test.12 : I64 = CallByName Test.8 Test.13;
ret Test.12;
in
jump Test.11 Test.30;

36
crates/compiler/test_mono/generated/inline_return_joinpoints_in_union_lambda_set.txt Normal file
View file

@ -0,0 +1,36 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.257 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.257;
procedure Test.2 (Test.3, Test.1):
let Test.17 : Int1 = false;
let Test.18 : Int1 = lowlevel Eq Test.17 Test.3;
if Test.18 then
let Test.13 : [C , C I64] = TagId(0) ;
ret Test.13;
else
let Test.14 : [C , C I64] = TagId(1) Test.1;
ret Test.14;
procedure Test.4 (Test.5, #Attr.12):
let Test.1 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : I64 = CallByName Num.19 Test.5 Test.1;
ret Test.16;
procedure Test.0 (Test.25):
joinpoint Test.7 Test.1:
let Test.20 : I64 = 1i64;
let Test.9 : I64 = CallByName Num.19 Test.1 Test.20;
let Test.12 : Int1 = false;
let Test.10 : [C , C I64] = CallByName Test.2 Test.12 Test.1;
let Test.11 : U8 = GetTagId Test.10;
switch Test.11:
case 0:
jump Test.7 Test.9;
default:
let Test.8 : I64 = CallByName Test.4 Test.9 Test.10;
ret Test.8;
in
jump Test.7 Test.25;

44
crates/compiler/test_mono/generated/issue_4557.txt
View file

@ -8,11 +8,11 @@ procedure Bool.4 (#Attr.2, #Attr.3):
procedure Test.1 (Test.2, Test.3):
let Test.17 : {Int1, Int1} = Struct {Test.2, Test.3};
let Test.34 : Int1 = StructAtIndex 0 Test.17;
let Test.33 : Int1 = StructAtIndex 1 Test.17;
let Test.19 : Int1 = CallByName Test.1 Test.33 Test.34;
let Test.27 : {} = Struct {};
joinpoint Test.28 Test.21:
let Test.32 : Int1 = StructAtIndex 0 Test.17;
let Test.31 : Int1 = StructAtIndex 1 Test.17;
let Test.19 : Int1 = CallByName Test.1 Test.31 Test.32;
let Test.26 : {} = Struct {};
joinpoint Test.27 Test.21:
let Test.23 : {} = Struct {};
joinpoint Test.24 Test.22:
let Test.20 : Int1 = CallByName Bool.11 Test.21 Test.22;
@ -21,36 +21,36 @@ procedure Test.1 (Test.2, Test.3):
let Test.18 : Int1 = CallByName Bool.4 Test.19 Test.20;
ret Test.18;
in
switch Test.33:
switch Test.31:
case 0:
let Test.25 : Str = CallByName Test.9 Test.23;
jump Test.24 Test.25;
default:
let Test.26 : Str = CallByName Test.11 Test.23;
jump Test.24 Test.26;
let Test.25 : Str = CallByName Test.11 Test.23;
jump Test.24 Test.25;
in
switch Test.34:
switch Test.32:
case 0:
let Test.29 : Str = CallByName Test.9 Test.27;
jump Test.28 Test.29;
let Test.28 : Str = CallByName Test.9 Test.26;
jump Test.27 Test.28;
default:
let Test.30 : Str = CallByName Test.11 Test.27;
jump Test.28 Test.30;
let Test.28 : Str = CallByName Test.11 Test.26;
jump Test.27 Test.28;
procedure Test.11 (Test.36):
let Test.37 : Str = "a";
ret Test.37;
procedure Test.11 (Test.34):
let Test.35 : Str = "a";
ret Test.35;
procedure Test.9 (Test.39):
let Test.40 : Str = "a";
ret Test.40;
procedure Test.9 (Test.37):
let Test.38 : Str = "a";
ret Test.38;
procedure Test.0 ():
let Test.38 : Int1 = false;
let Test.35 : Int1 = true;
let Test.13 : Int1 = CallByName Test.1 Test.38 Test.35;
let Test.36 : Int1 = false;
let Test.33 : Int1 = true;
let Test.13 : Int1 = CallByName Test.1 Test.36 Test.33;
ret Test.13;

53
crates/compiler/test_mono/generated/lambda_capture_niche_u8_vs_u64.txt
View file

@ -7,48 +7,45 @@ procedure Num.94 (#Attr.2):
ret Num.257;
procedure Test.1 (Test.4):
let Test.16 : [C U8, C U64] = TagId(1) Test.4;
ret Test.16;
let Test.13 : [C U8, C U64] = TagId(1) Test.4;
ret Test.13;
procedure Test.1 (Test.4):
let Test.22 : [C U8, C U64] = TagId(0) 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;
let Test.19 : [C U8, C U64] = TagId(0) Test.4;
ret Test.19;
procedure Test.5 (Test.17, #Attr.12):
procedure Test.5 (Test.14, #Attr.12):
let Test.4 : U64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.16 : Str = CallByName Num.94 Test.4;
ret Test.16;
procedure Test.5 (Test.14, #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;
let Test.22 : Str = CallByName Num.94 Test.4;
ret Test.22;
procedure Test.0 ():
let Test.2 : Int1 = true;
joinpoint Test.13 Test.3:
joinpoint Test.10 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;
let Test.7 : Str = CallByName Test.5 Test.8 Test.3;
ret Test.7;
default:
let Test.12 : Str = CallByName Test.5 Test.8 Test.3;
jump Test.10 Test.12;
let Test.7 : Str = CallByName Test.5 Test.8 Test.3;
ret Test.7;
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;
let Test.23 : Int1 = true;
let Test.24 : Int1 = lowlevel Eq Test.23 Test.2;
if Test.24 then
let Test.12 : U64 = 123i64;
let Test.11 : [C U8, C U64] = CallByName Test.1 Test.12;
jump Test.10 Test.11;
else
let Test.21 : U8 = 18i64;
let Test.20 : [C U8, C U64] = CallByName Test.1 Test.21;
jump Test.13 Test.20;
let Test.18 : U8 = 18i64;
let Test.17 : [C U8, C U64] = CallByName Test.1 Test.18;
jump Test.10 Test.17;

99
crates/compiler/test_mono/generated/lambda_capture_niches_have_captured_function_in_closure.txt
View file

@ -1,83 +1,80 @@
procedure Test.11 (Test.37):
let Test.38 : Str = "";
ret Test.38;
procedure Test.11 (Test.34):
let Test.35 : Str = "";
ret Test.35;
procedure Test.13 (Test.51, Test.12):
procedure Test.13 (Test.48, Test.12):
ret Test.12;
procedure Test.15 (Test.39):
let Test.40 : Str = "";
ret Test.40;
procedure Test.15 (Test.36):
let Test.37 : Str = "";
ret Test.37;
procedure Test.16 (Test.54):
let Test.56 : Str = "s1";
ret Test.56;
procedure Test.16 (Test.51):
let Test.53 : Str = "s1";
ret Test.53;
procedure Test.2 (Test.7, Test.8):
let Test.30 : [C {} {}, C {} {}] = TagId(1) Test.7 Test.8;
ret Test.30;
let Test.27 : [C {} {}, C {} {}] = TagId(1) Test.7 Test.8;
ret Test.27;
procedure Test.2 (Test.7, Test.8):
let Test.44 : [C {} {}, C {} {}] = TagId(0) Test.7 Test.8;
ret Test.44;
let Test.41 : [C {} {}, C {} {}] = TagId(0) Test.7 Test.8;
ret Test.41;
procedure Test.3 (Test.17):
let Test.36 : {} = Struct {};
ret Test.36;
let Test.33 : {} = Struct {};
ret Test.33;
procedure Test.4 (Test.18):
inc Test.18;
ret Test.18;
procedure Test.9 (Test.29, #Attr.12):
procedure Test.9 (Test.26, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 0) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 0) (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;
dec Test.48;
let Test.47 : {} = Struct {};
let Test.46 : Str = CallByName Test.13 Test.47 Test.45;
ret Test.46;
let Test.46 : {} = Struct {};
let Test.45 : Str = CallByName Test.16 Test.46;
let Test.42 : Str = CallByName Test.4 Test.45;
dec Test.45;
let Test.44 : {} = Struct {};
let Test.43 : Str = CallByName Test.13 Test.44 Test.42;
ret Test.43;
procedure Test.9 (Test.29, #Attr.12):
procedure Test.9 (Test.26, #Attr.12):
let Test.8 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.7 : {} = UnionAtIndex (Id 1) (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;
let Test.32 : {} = Struct {};
let Test.31 : Str = CallByName Test.15 Test.32;
let Test.28 : {} = CallByName Test.3 Test.31;
dec Test.31;
let Test.30 : {} = Struct {};
let Test.29 : Str = CallByName Test.11 Test.30;
ret Test.29;
procedure Test.0 ():
let Test.5 : Int1 = true;
joinpoint Test.25 Test.6:
joinpoint Test.22 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;
let Test.19 : Str = CallByName Test.9 Test.20 Test.6;
ret Test.19;
default:
let Test.24 : Str = CallByName Test.9 Test.20 Test.6;
jump Test.22 Test.24;
let Test.19 : Str = CallByName Test.9 Test.20 Test.6;
ret Test.19;
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;
let Test.54 : Int1 = true;
let Test.55 : Int1 = lowlevel Eq Test.54 Test.5;
if Test.55 then
let Test.24 : {} = Struct {};
let Test.25 : {} = Struct {};
let Test.23 : [C {} {}, C {} {}] = CallByName Test.2 Test.24 Test.25;
jump Test.22 Test.23;
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;
let Test.39 : {} = Struct {};
let Test.40 : {} = Struct {};
let Test.38 : [C {} {}, C {} {}] = CallByName Test.2 Test.39 Test.40;
jump Test.22 Test.38;

57
crates/compiler/test_mono/generated/lambda_capture_niches_with_non_capturing_function.txt
View file

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

61
crates/compiler/test_mono/generated/lambda_capture_niches_with_other_lambda_capture.txt
View file

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

23
crates/compiler/test_mono/generated/lambda_set_with_imported_toplevels_issue_4733.txt
View file

@ -15,26 +15,23 @@ procedure Num.21 (#Attr.2, #Attr.3):
ret Num.257;
procedure Test.0 (Test.8):
let Test.23 : Int1 = CallByName Bool.2;
if Test.23 then
let Test.24 : Int1 = true;
ret Test.24;
let Test.20 : Int1 = CallByName Bool.2;
if Test.20 then
let Test.21 : Int1 = true;
ret Test.21;
else
let Test.22 : Int1 = false;
ret Test.22;
let Test.19 : Int1 = false;
ret Test.19;
procedure Test.5 (Test.6, Test.2):
joinpoint Test.19 Test.18:
ret Test.18;
in
switch Test.2:
case 0:
let Test.20 : U64 = CallByName Num.19 Test.6 Test.6;
jump Test.19 Test.20;
let Test.18 : U64 = CallByName Num.19 Test.6 Test.6;
ret Test.18;
default:
let Test.21 : U64 = CallByName Num.21 Test.6 Test.6;
jump Test.19 Test.21;
let Test.18 : U64 = CallByName Num.21 Test.6 Test.6;
ret Test.18;
procedure Test.7 ():

41
crates/compiler/test_mono/generated/recursive_lambda_set_has_nested_non_recursive_lambda_sets_issue_5026.txt
View file

@ -2,18 +2,18 @@ procedure Bool.2 ():
let Bool.23 : Int1 = true;
ret Bool.23;
procedure Test.10 (Test.28):
let Test.32 : Int1 = CallByName Bool.2;
if Test.32 then
let Test.33 : [<rnu><null>, C {}] = CallByName Test.0;
ret Test.33;
procedure Test.10 (Test.25):
let Test.29 : Int1 = CallByName Bool.2;
if Test.29 then
let Test.30 : [<rnu><null>, C {}] = CallByName Test.0;
ret Test.30;
else
let Test.29 : [<rnu><null>, C {}] = TagId(1) ;
ret Test.29;
let Test.26 : [<rnu><null>, C {}] = TagId(1) ;
ret Test.26;
procedure Test.11 (Test.30):
let Test.31 : Str = "done";
ret Test.31;
procedure Test.11 (Test.27):
let Test.28 : Str = "done";
ret Test.28;
procedure Test.2 (Test.5):
let Test.17 : [<rnu><null>, C {}] = TagId(0) Test.5;
@ -27,27 +27,24 @@ procedure Test.6 (Test.16, #Attr.12):
let Test.5 : {} = UnionAtIndex (Id 0) (Index 0) #Attr.12;
dec #Attr.12;
let Test.19 : {} = Struct {};
let Test.25 : Str = "foobar";
let Test.20 : [<rnu><null>, C {}] = CallByName Test.8 Test.25 Test.5;
dec Test.25;
let Test.22 : Str = "foobar";
let Test.20 : [<rnu><null>, C {}] = CallByName Test.8 Test.22 Test.5;
dec Test.22;
let Test.21 : U8 = GetTagId Test.20;
joinpoint Test.22 Test.18:
ret Test.18;
in
switch Test.21:
case 0:
let Test.23 : Str = CallByName Test.6 Test.19 Test.20;
jump Test.22 Test.23;
let Test.18 : Str = CallByName Test.6 Test.19 Test.20;
ret Test.18;
default:
dec Test.20;
let Test.24 : Str = CallByName Test.11 Test.19;
jump Test.22 Test.24;
let Test.18 : Str = CallByName Test.11 Test.19;
ret Test.18;
procedure Test.8 (Test.9, Test.7):
let Test.27 : [<rnu><null>, C {}] = CallByName Test.10 Test.9;
ret Test.27;
let Test.24 : [<rnu><null>, C {}] = CallByName Test.10 Test.9;
ret Test.24;
procedure Test.0 ():
let Test.13 : {} = Struct {};

59
crates/compiler/test_mono/generated/recursively_build_effect.txt
View file

@ -14,27 +14,26 @@ procedure Test.11 (Test.29, #Attr.12):
procedure Test.11 (Test.29, Test.10):
ret Test.10;
procedure Test.14 (Test.36, #Attr.12):
let Test.12 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.13 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
dec #Attr.12;
let Test.46 : {} = Struct {};
let Test.45 : {} = CallByName Test.11 Test.46 Test.12;
let Test.38 : [<r>C {}, C I64 {}] = CallByName Test.9 Test.45 Test.13;
let Test.40 : {} = Struct {};
let Test.41 : U8 = GetTagId Test.38;
joinpoint Test.42 Test.39:
ret Test.39;
procedure Test.14 (Test.62, Test.63):
joinpoint Test.37 Test.36 #Attr.12:
let Test.12 : {} = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.13 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
dec #Attr.12;
let Test.43 : {} = Struct {};
let Test.42 : {} = CallByName Test.11 Test.43 Test.12;
let Test.38 : [<r>C {}, C I64 {}] = CallByName Test.9 Test.42 Test.13;
let Test.40 : {} = Struct {};
let Test.41 : U8 = GetTagId Test.38;
switch Test.41:
case 0:
let Test.39 : {} = CallByName Test.11 Test.40 Test.38;
ret Test.39;
default:
jump Test.37 Test.40 Test.38;
in
switch Test.41:
case 0:
let Test.43 : {} = CallByName Test.11 Test.40 Test.38;
jump Test.42 Test.43;
default:
let Test.44 : {} = CallByName Test.14 Test.40 Test.38;
jump Test.42 Test.44;
jump Test.37 Test.62 Test.63;
procedure Test.2 ():
let Test.6 : Str = "Hello";
@ -50,15 +49,15 @@ procedure Test.2 ():
ret Test.19;
procedure Test.3 (Test.8):
let Test.57 : I64 = 0i64;
let Test.58 : Int1 = lowlevel Eq Test.57 Test.8;
if Test.58 then
let Test.54 : I64 = 0i64;
let Test.55 : Int1 = lowlevel Eq Test.54 Test.8;
if Test.55 then
let Test.27 : {} = Struct {};
let Test.26 : [<r>C {}, C I64 {}] = CallByName Test.4 Test.27;
ret Test.26;
else
let Test.52 : {} = Struct {};
let Test.33 : {} = CallByName Test.4 Test.52;
let Test.49 : {} = Struct {};
let Test.33 : {} = CallByName Test.4 Test.49;
let Test.32 : [<r>C {}, C I64 {}] = CallByName Test.5 Test.33 Test.8;
ret Test.32;
@ -73,11 +72,11 @@ procedure Test.5 (Test.16, Test.13):
let Test.35 : [<r>C {}, C I64 {}] = TagId(1) Test.13 Test.16;
ret Test.35;
procedure Test.9 (Test.47, Test.8):
let Test.51 : I64 = 1i64;
let Test.50 : I64 = CallByName Num.20 Test.8 Test.51;
let Test.49 : [<r>C {}, C I64 {}] = CallByName Test.3 Test.50;
ret Test.49;
procedure Test.9 (Test.44, Test.8):
let Test.48 : I64 = 1i64;
let Test.47 : I64 = CallByName Num.20 Test.8 Test.48;
let Test.46 : [<r>C {}, C I64 {}] = CallByName Test.3 Test.47;
ret Test.46;
procedure Test.0 ():
let Test.24 : I64 = 4i64;

33
crates/compiler/test_mono/generated/specialize_closures.txt
View file

@ -12,30 +12,27 @@ procedure Num.21 (#Attr.2, #Attr.3):
procedure Test.1 (Test.2, Test.3):
let Test.15 : U8 = GetTagId Test.2;
joinpoint Test.16 Test.14:
ret Test.14;
in
switch Test.15:
case 0:
let Test.17 : I64 = CallByName Test.7 Test.3 Test.2;
jump Test.16 Test.17;
let Test.14 : I64 = CallByName Test.7 Test.3 Test.2;
ret Test.14;
default:
let Test.18 : I64 = CallByName Test.8 Test.3 Test.2;
jump Test.16 Test.18;
let Test.14 : I64 = CallByName Test.8 Test.3 Test.2;
ret Test.14;
procedure Test.7 (Test.9, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.24 : I64 = CallByName Num.19 Test.9 Test.4;
ret Test.24;
let Test.21 : I64 = CallByName Num.19 Test.9 Test.4;
ret Test.21;
procedure Test.8 (Test.10, #Attr.12):
let Test.6 : Int1 = UnionAtIndex (Id 1) (Index 1) #Attr.12;
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
if Test.6 then
let Test.22 : I64 = CallByName Num.21 Test.10 Test.5;
ret Test.22;
let Test.19 : I64 = CallByName Num.21 Test.10 Test.5;
ret Test.19;
else
ret Test.10;
@ -43,15 +40,15 @@ procedure Test.0 ():
let Test.4 : I64 = 1i64;
let Test.5 : I64 = 2i64;
let Test.6 : Int1 = CallByName Bool.2;
joinpoint Test.20 Test.12:
joinpoint Test.17 Test.12:
let Test.13 : I64 = 42i64;
let Test.11 : I64 = CallByName Test.1 Test.12 Test.13;
ret Test.11;
in
let Test.23 : Int1 = CallByName Bool.2;
if Test.23 then
let Test.19 : [C I64, C I64 Int1] = TagId(0) Test.4;
jump Test.20 Test.19;
let Test.20 : Int1 = CallByName Bool.2;
if Test.20 then
let Test.16 : [C I64, C I64 Int1] = TagId(0) Test.4;
jump Test.17 Test.16;
else
let Test.19 : [C I64, C I64 Int1] = TagId(1) Test.5 Test.6;
jump Test.20 Test.19;
let Test.16 : [C I64, C I64 Int1] = TagId(1) Test.5 Test.6;
jump Test.17 Test.16;

33
crates/compiler/test_mono/generated/specialize_lowlevel.txt
View file

@ -12,37 +12,34 @@ procedure Num.21 (#Attr.2, #Attr.3):
procedure Test.6 (Test.8, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;
let Test.21 : I64 = CallByName Num.19 Test.8 Test.4;
ret Test.21;
let Test.18 : I64 = CallByName Num.19 Test.8 Test.4;
ret Test.18;
procedure Test.7 (Test.9, #Attr.12):
let Test.5 : I64 = UnionAtIndex (Id 1) (Index 0) #Attr.12;
let Test.19 : I64 = CallByName Num.21 Test.9 Test.5;
ret Test.19;
let Test.16 : I64 = CallByName Num.21 Test.9 Test.5;
ret Test.16;
procedure Test.0 ():
let Test.4 : I64 = 1i64;
let Test.5 : I64 = 2i64;
let Test.11 : I64 = 42i64;
joinpoint Test.18 Test.12:
joinpoint Test.15 Test.12:
let Test.13 : U8 = GetTagId Test.12;
joinpoint Test.14 Test.10:
ret Test.10;
in
switch Test.13:
case 0:
let Test.15 : I64 = CallByName Test.6 Test.11 Test.12;
jump Test.14 Test.15;
let Test.10 : I64 = CallByName Test.6 Test.11 Test.12;
ret Test.10;
default:
let Test.16 : I64 = CallByName Test.7 Test.11 Test.12;
jump Test.14 Test.16;
let Test.10 : I64 = CallByName Test.7 Test.11 Test.12;
ret Test.10;
in
let Test.20 : Int1 = CallByName Bool.2;
if Test.20 then
let Test.17 : [C I64, C I64] = TagId(0) Test.4;
jump Test.18 Test.17;
let Test.17 : Int1 = CallByName Bool.2;
if Test.17 then
let Test.14 : [C I64, C I64] = TagId(0) Test.4;
jump Test.15 Test.14;
else
let Test.17 : [C I64, C I64] = TagId(1) Test.5;
jump Test.18 Test.17;
let Test.14 : [C I64, C I64] = TagId(1) Test.5;
jump Test.15 Test.14;

33
crates/compiler/test_mono/generated/unreachable_branch_is_eliminated_but_produces_lambda_specializations.txt
View file

@ -1,29 +1,26 @@
procedure Test.1 (Test.2):
let Test.14 : Int1 = false;
ret Test.14;
let Test.11 : Int1 = false;
ret Test.11;
procedure Test.3 (Test.13):
let Test.15 : Str = "t1";
procedure Test.3 (Test.10):
let Test.12 : Str = "t1";
ret Test.12;
procedure Test.4 (Test.13):
let Test.15 : Str = "t2";
ret Test.15;
procedure Test.4 (Test.16):
let Test.18 : Str = "t2";
ret Test.18;
procedure Test.0 ():
let Test.19 : Str = "abc";
let Test.6 : Int1 = CallByName Test.1 Test.19;
dec Test.19;
let Test.16 : Str = "abc";
let Test.6 : Int1 = CallByName Test.1 Test.16;
dec Test.16;
let Test.9 : {} = Struct {};
joinpoint Test.10 Test.8:
ret Test.8;
in
switch Test.6:
case 0:
let Test.11 : Str = CallByName Test.3 Test.9;
jump Test.10 Test.11;
let Test.8 : Str = CallByName Test.3 Test.9;
ret Test.8;
default:
let Test.12 : Str = CallByName Test.4 Test.9;
jump Test.10 Test.12;
let Test.8 : Str = CallByName Test.4 Test.9;
ret Test.8;

59
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification.txt
View file

@ -3,50 +3,47 @@ procedure Bool.2 ():
ret Bool.23;
procedure Test.12 (Test.52):
let Test.75 : Int1 = false;
ret Test.75;
let Test.72 : Int1 = false;
ret Test.72;
procedure Test.13 (Test.51):
let Test.83 : Int1 = true;
ret Test.83;
let Test.80 : Int1 = true;
ret Test.80;
procedure Test.14 (Test.50):
ret Test.50;
procedure Test.15 (Test.49):
let Test.74 : {} = Struct {};
let Test.73 : Int1 = CallByName Test.12 Test.74;
ret Test.73;
let Test.71 : {} = Struct {};
let Test.70 : Int1 = CallByName Test.12 Test.71;
ret Test.70;
procedure Test.16 (Test.48):
let Test.82 : {} = Struct {};
let Test.81 : Int1 = CallByName Test.13 Test.82;
ret Test.81;
let Test.79 : {} = Struct {};
let Test.78 : Int1 = CallByName Test.13 Test.79;
ret Test.78;
procedure Test.17 (Test.47):
ret Test.47;
procedure Test.35 (Test.36, Test.76):
procedure Test.35 (Test.36, Test.73):
inc Test.36;
ret Test.36;
procedure Test.37 (Test.38, Test.84):
procedure Test.37 (Test.38, Test.81):
inc Test.38;
ret Test.38;
procedure Test.40 (Test.41, Test.65, Test.39):
let Test.68 : {} = Struct {};
joinpoint Test.69 Test.67:
ret Test.67;
in
switch Test.39:
case 0:
let Test.70 : List U8 = CallByName Test.35 Test.41 Test.68;
jump Test.69 Test.70;
let Test.67 : List U8 = CallByName Test.35 Test.41 Test.68;
ret Test.67;
default:
let Test.71 : List U8 = CallByName Test.37 Test.41 Test.68;
jump Test.69 Test.71;
let Test.67 : List U8 = CallByName Test.37 Test.41 Test.68;
ret Test.67;
procedure Test.43 (Test.44, Test.42):
@ -56,26 +53,26 @@ procedure Test.43 (Test.44, Test.42):
dec Test.59;
ret Test.58;
in
let Test.78 : Int1 = CallByName Bool.2;
if Test.78 then
let Test.80 : Str = StructAtIndex 0 Test.42;
inc Test.80;
let Test.75 : Int1 = CallByName Bool.2;
if Test.75 then
let Test.77 : Str = StructAtIndex 0 Test.42;
inc Test.77;
dec Test.42;
let Test.79 : Int1 = CallByName Test.16 Test.80;
dec Test.80;
let Test.61 : Int1 = CallByName Test.14 Test.79;
let Test.76 : Int1 = CallByName Test.16 Test.77;
dec Test.77;
let Test.61 : Int1 = CallByName Test.14 Test.76;
jump Test.62 Test.61;
else
let Test.72 : U8 = StructAtIndex 1 Test.42;
let Test.69 : U8 = StructAtIndex 1 Test.42;
dec Test.42;
let Test.63 : Int1 = CallByName Test.15 Test.72;
let Test.63 : Int1 = CallByName Test.15 Test.69;
let Test.61 : Int1 = CallByName Test.14 Test.63;
jump Test.62 Test.61;
procedure Test.0 ():
let Test.86 : Str = "";
let Test.87 : U8 = 7i64;
let Test.55 : {Str, U8} = Struct {Test.86, Test.87};
let Test.83 : Str = "";
let Test.84 : U8 = 7i64;
let Test.55 : {Str, U8} = Struct {Test.83, Test.84};
let Test.46 : {Str, U8} = CallByName Test.17 Test.55;
let Test.54 : {} = Struct {};
let Test.53 : List U8 = CallByName Test.43 Test.54 Test.46;

19
crates/compiler/test_mono/generated/unspecialized_lambda_set_unification_keeps_all_concrete_types_without_unification_of_unifiable.txt
View file

@ -56,26 +56,23 @@ procedure Encode.23 (Encode.94, Encode.102, Encode.96):
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.117 : U8 = GetTagId Encode.102;
joinpoint Encode.118 Encode.116:
ret Encode.116;
in
switch Encode.117:
case 0:
let Encode.119 : List U8 = CallByName #Derived.2 Encode.94 Encode.96 Encode.102;
jump Encode.118 Encode.119;
let Encode.116 : List U8 = CallByName #Derived.2 Encode.94 Encode.96 Encode.102;
ret Encode.116;
default:
let Encode.120 : List U8 = CallByName #Derived.7 Encode.94 Encode.96 Encode.102;
jump Encode.118 Encode.120;
let Encode.116 : List U8 = CallByName #Derived.7 Encode.94 Encode.96 Encode.102;
ret Encode.116;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.132 : List U8 = CallByName Json.126 Encode.94 Encode.96 Encode.102;
ret Encode.132;
let Encode.129 : List U8 = CallByName Json.126 Encode.94 Encode.96 Encode.102;
ret Encode.129;
procedure Encode.23 (Encode.94, Encode.102, Encode.96):
let Encode.136 : Str = "a Lambda Set is empty. Most likely there is a type error in your program.";
Crash Encode.136
let Encode.133 : Str = "a Lambda Set is empty. Most likely there is a type error in your program.";
Crash Encode.133
procedure Encode.25 (Encode.100, Encode.101):
let Encode.104 : List U8 = Array [];

45
crates/compiler/test_mono/src/tests.rs
View file

@ -2723,3 +2723,48 @@ fn unspecialized_lambda_set_unification_does_not_duplicate_identical_concrete_ty
"#
)
}
#[mono_test]
fn inline_return_joinpoints_in_bool_lambda_set() {
indoc!(
r#"
app "test" provides [f] to "./platform"
f = \x ->
caller = if Bool.false then f else \n -> n
caller (x + 1)
"#
)
}
#[mono_test]
fn inline_return_joinpoints_in_enum_lambda_set() {
indoc!(
r#"
app "test" provides [f] to "./platform"
f = \x ->
caller = \t -> when t is
A -> f
B -> \n -> n
C -> \n -> n + 1
D -> \n -> n + 2
(caller A) (x + 1)
"#
)
}
#[mono_test]
fn inline_return_joinpoints_in_union_lambda_set() {
indoc!(
r#"
app "test" provides [f] to "./platform"
f = \x ->
caller = \t -> when t is
A -> f
B -> \n -> n + x
(caller A) (x + 1)
"#
)
}