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

Merge pull request #2987 from rtfeldman/issue-2793/u8-signed-comparison

Browse source 
Issue 2793/u8 signed comparison
This commit is contained in:
Brian Carroll 2022-05-03 08:01:40 -05:00 • committed by GitHub
commit 0a3d3e8409
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
37 changed files with 360 additions and 198 deletions
Download patch file Download diff file Expand all files Collapse all files

7
compiler/can/src/builtins.rs
View file

@ -2506,7 +2506,10 @@ fn list_take_last(symbol: Symbol, var_store: &mut VarStore) -> Def {
let get_sub = RunLowLevel {
op: LowLevel::NumSubWrap,
args: vec![(len_var, get_list_len), (len_var, Var(Symbol::ARG_2))],
args: vec![
(len_var, get_list_len.clone()),
(len_var, Var(Symbol::ARG_2)),
],
ret_var: len_var,
};
@ -2516,7 +2519,7 @@ fn list_take_last(symbol: Symbol, var_store: &mut VarStore) -> Def {
branches: vec![(
no_region(RunLowLevel {
op: LowLevel::NumGt,
args: vec![(len_var, get_sub.clone()), (len_var, zero.clone())],
args: vec![(len_var, get_list_len), (len_var, Var(Symbol::ARG_2))],
ret_var: bool_var,
}),
no_region(get_sub),

32
compiler/gen_llvm/src/llvm/build.rs
View file

@ -6671,10 +6671,34 @@ fn build_int_binop<'a, 'ctx, 'env>(
&LLVM_MUL_WITH_OVERFLOW[int_width],
&[lhs.into(), rhs.into()],
),
NumGt => bd.build_int_compare(SGT, lhs, rhs, "int_gt").into(),
NumGte => bd.build_int_compare(SGE, lhs, rhs, "int_gte").into(),
NumLt => bd.build_int_compare(SLT, lhs, rhs, "int_lt").into(),
NumLte => bd.build_int_compare(SLE, lhs, rhs, "int_lte").into(),
NumGt => {
if int_width.is_signed() {
bd.build_int_compare(SGT, lhs, rhs, "gt_int").into()
} else {
bd.build_int_compare(UGT, lhs, rhs, "gt_uint").into()
}
}
NumGte => {
if int_width.is_signed() {
bd.build_int_compare(SGE, lhs, rhs, "gte_int").into()
} else {
bd.build_int_compare(UGE, lhs, rhs, "gte_uint").into()
}
}
NumLt => {
if int_width.is_signed() {
bd.build_int_compare(SLT, lhs, rhs, "lt_int").into()
} else {
bd.build_int_compare(ULT, lhs, rhs, "lt_uint").into()
}
}
NumLte => {
if int_width.is_signed() {
bd.build_int_compare(SLE, lhs, rhs, "lte_int").into()
} else {
bd.build_int_compare(ULE, lhs, rhs, "lte_uint").into()
}
}
NumRemUnchecked => {
if int_width.is_signed() {
bd.build_int_signed_rem(lhs, rhs, "rem_int").into()

71
compiler/gen_wasm/src/low_level.rs
View file

@ -116,6 +116,13 @@ impl From<&StoredValue> for CodeGenNumType {
}
}
fn integer_symbol_is_signed(backend: &WasmBackend<'_>, symbol: Symbol) -> bool {
return match backend.storage.symbol_layouts[&symbol] {
Layout::Builtin(Builtin::Int(int_width)) => int_width.is_signed(),
x => internal_error!("Expected integer, found {:?}", x),
};
}
pub struct LowLevelCall<'a> {
pub lowlevel: LowLevel,
pub arguments: &'a [Symbol],
@ -377,8 +384,20 @@ impl<'a> LowLevelCall<'a> {
NumGt => {
self.load_args(backend);
match CodeGenNumType::for_symbol(backend, self.arguments[0]) {
I32 => backend.code_builder.i32_gt_s(),
I64 => backend.code_builder.i64_gt_s(),
I32 => {
if integer_symbol_is_signed(backend, self.arguments[0]) {
backend.code_builder.i32_gt_s()
} else {
backend.code_builder.i32_gt_u()
}
}
I64 => {
if integer_symbol_is_signed(backend, self.arguments[0]) {
backend.code_builder.i64_gt_s()
} else {
backend.code_builder.i64_gt_u()
}
}
F32 => backend.code_builder.f32_gt(),
F64 => backend.code_builder.f64_gt(),
x => todo!("{:?} for {:?}", self.lowlevel, x),
@ -387,8 +406,20 @@ impl<'a> LowLevelCall<'a> {
NumGte => {
self.load_args(backend);
match CodeGenNumType::for_symbol(backend, self.arguments[0]) {
I32 => backend.code_builder.i32_ge_s(),
I64 => backend.code_builder.i64_ge_s(),
I32 => {
if integer_symbol_is_signed(backend, self.arguments[0]) {
backend.code_builder.i32_ge_s()
} else {
backend.code_builder.i32_ge_u()
}
}
I64 => {
if integer_symbol_is_signed(backend, self.arguments[0]) {
backend.code_builder.i64_ge_s()
} else {
backend.code_builder.i64_ge_u()
}
}
F32 => backend.code_builder.f32_ge(),
F64 => backend.code_builder.f64_ge(),
x => todo!("{:?} for {:?}", self.lowlevel, x),
@ -397,8 +428,20 @@ impl<'a> LowLevelCall<'a> {
NumLt => {
self.load_args(backend);
match CodeGenNumType::for_symbol(backend, self.arguments[0]) {
I32 => backend.code_builder.i32_lt_s(),
I64 => backend.code_builder.i64_lt_s(),
I32 => {
if integer_symbol_is_signed(backend, self.arguments[0]) {
backend.code_builder.i32_lt_s()
} else {
backend.code_builder.i32_lt_u()
}
}
I64 => {
if integer_symbol_is_signed(backend, self.arguments[0]) {
backend.code_builder.i64_lt_s()
} else {
backend.code_builder.i64_lt_u()
}
}
F32 => backend.code_builder.f32_lt(),
F64 => backend.code_builder.f64_lt(),
x => todo!("{:?} for {:?}", self.lowlevel, x),
@ -407,8 +450,20 @@ impl<'a> LowLevelCall<'a> {
NumLte => {
self.load_args(backend);
match CodeGenNumType::for_symbol(backend, self.arguments[0]) {
I32 => backend.code_builder.i32_le_s(),
I64 => backend.code_builder.i64_le_s(),
I32 => {
if integer_symbol_is_signed(backend, self.arguments[0]) {
backend.code_builder.i32_le_s()
} else {
backend.code_builder.i32_le_u()
}
}
I64 => {
if integer_symbol_is_signed(backend, self.arguments[0]) {
backend.code_builder.i64_le_s()
} else {
backend.code_builder.i64_le_u()
}
}
F32 => backend.code_builder.f32_le(),
F64 => backend.code_builder.f64_le(),
x => todo!("{:?} for {:?}", self.lowlevel, x),

2
compiler/mono/src/code_gen_help/mod.rs
View file

@ -83,7 +83,7 @@ pub struct CodeGenHelp<'a> {
impl<'a> CodeGenHelp<'a> {
pub fn new(arena: &'a Bump, target_info: TargetInfo, home: ModuleId) -> Self {
let layout_isize = Layout::usize(target_info);
let layout_isize = Layout::isize(target_info);
// Refcount is a boxed isize. TODO: use the new Box layout when dev backends support it
let union_refcount = UnionLayout::NonNullableUnwrapped(arena.alloc([layout_isize]));

80
compiler/test_gen/src/gen_num.rs
View file

@ -1210,6 +1210,86 @@ fn bitwise_or() {
assert_evals_to!("Num.bitwiseOr 1 2", 3, i64);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn lt_u8() {
assert_evals_to!("1u8 < 2u8", true, bool);
assert_evals_to!("1u8 < 1u8", false, bool);
assert_evals_to!("2u8 < 1u8", false, bool);
assert_evals_to!("0u8 < 0u8", false, bool);
assert_evals_to!("128u8 < 0u8", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn lte_u8() {
assert_evals_to!("1u8 <= 1u8", true, bool);
assert_evals_to!("2u8 <= 1u8", false, bool);
assert_evals_to!("1u8 <= 2u8", true, bool);
assert_evals_to!("0u8 <= 0u8", true, bool);
assert_evals_to!("128u8 <= 0u8", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn gt_u8() {
assert_evals_to!("2u8 > 1u8", true, bool);
assert_evals_to!("2u8 > 2u8", false, bool);
assert_evals_to!("1u8 > 1u8", false, bool);
assert_evals_to!("0u8 > 0u8", false, bool);
assert_evals_to!("0u8 > 128u8", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn gte_u8() {
assert_evals_to!("1u8 >= 1u8", true, bool);
assert_evals_to!("1u8 >= 2u8", false, bool);
assert_evals_to!("2u8 >= 1u8", true, bool);
assert_evals_to!("0u8 >= 0u8", true, bool);
assert_evals_to!("0u8 >= 128u8", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn lt_u64() {
assert_evals_to!("1u64 < 2u64", true, bool);
assert_evals_to!("1u64 < 1u64", false, bool);
assert_evals_to!("2u64 < 1u64", false, bool);
assert_evals_to!("0u64 < 0u64", false, bool);
assert_evals_to!("9223372036854775808u64 < 0u64", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn lte_u64() {
assert_evals_to!("1u64 <= 1u64", true, bool);
assert_evals_to!("2u64 <= 1u64", false, bool);
assert_evals_to!("1u64 <= 2u64", true, bool);
assert_evals_to!("0u64 <= 0u64", true, bool);
assert_evals_to!("9223372036854775808u64 <= 0u64", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn gt_u64() {
assert_evals_to!("2u64 > 1u64", true, bool);
assert_evals_to!("2u64 > 2u64", false, bool);
assert_evals_to!("1u64 > 1u64", false, bool);
assert_evals_to!("0u64 > 0u64", false, bool);
assert_evals_to!("0u64 > 9223372036854775808u64", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn gte_u64() {
assert_evals_to!("1u64 >= 1u64", true, bool);
assert_evals_to!("1u64 >= 2u64", false, bool);
assert_evals_to!("2u64 >= 1u64", true, bool);
assert_evals_to!("0u64 >= 0u64", true, bool);
assert_evals_to!("0u64 >= 9223372036854775808u64", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn lt_i64() {

8
compiler/test_mono/generated/factorial.txt
View file

@ -1,10 +1,10 @@
procedure Num.20 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.229;
let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.15, Test.16):
joinpoint Test.7 Test.2 Test.3:

50
compiler/test_mono/generated/has_none.txt
View file

@ -1,30 +1,30 @@
procedure Test.3 (Test.29):
joinpoint Test.13 Test.4:
let Test.23 : Int1 = 1i64;
let Test.24 : Int1 = GetTagId Test.4;
let Test.25 : Int1 = lowlevel Eq Test.23 Test.24;
if Test.25 then
let Test.14 : Int1 = false;
ret Test.14;
else
let Test.19 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.4;
let Test.20 : U8 = 1i64;
let Test.21 : U8 = GetTagId Test.19;
let Test.22 : Int1 = lowlevel Eq Test.20 Test.21;
if Test.22 then
let Test.15 : Int1 = true;
procedure Test.4 (Test.30):
joinpoint Test.14 Test.5:
let Test.24 : Int1 = 1i64;
let Test.25 : Int1 = GetTagId Test.5;
let Test.26 : Int1 = lowlevel Eq Test.24 Test.25;
if Test.26 then
let Test.15 : Int1 = false;
ret Test.15;
else
let Test.7 : [<rnu><null>, C [C I64, C ] *self] = UnionAtIndex (Id 0) (Index 1) Test.4;
jump Test.13 Test.7;
let Test.20 : [C I64, C ] = UnionAtIndex (Id 0) (Index 0) Test.5;
let Test.21 : U8 = 1i64;
let Test.22 : U8 = GetTagId Test.20;
let Test.23 : Int1 = lowlevel Eq Test.21 Test.22;
if Test.23 then
let Test.16 : Int1 = true;
ret Test.16;
else
let Test.8 : [<rnu><null>, C [C I64, C ] *self] = UnionAtIndex (Id 0) (Index 1) Test.5;
jump Test.14 Test.8;
in
jump Test.13 Test.29;
jump Test.14 Test.30;
procedure Test.0 ():
let Test.28 : I64 = 3i64;
let Test.26 : [C I64, C ] = Just Test.28;
let Test.27 : [<rnu><null>, C [C I64, C ] *self] = Nil ;
let Test.12 : [<rnu><null>, C [C I64, C ] *self] = Cons Test.26 Test.27;
let Test.11 : Int1 = CallByName Test.3 Test.12;
dec Test.12;
ret Test.11;
let Test.29 : I64 = 3i64;
let Test.27 : [C I64, C ] = Just Test.29;
let Test.28 : [<rnu><null>, C [C I64, C ] *self] = Nil ;
let Test.13 : [<rnu><null>, C [C I64, C ] *self] = Cons Test.27 Test.28;
let Test.12 : Int1 = CallByName Test.4 Test.13;
dec Test.13;
ret Test.12;

4
compiler/test_mono/generated/ir_int_add.txt
View file

@ -3,8 +3,8 @@ procedure List.6 (#Attr.2):
ret List.139;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.230 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.230;
let Num.275 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.275;
procedure Test.0 ():
let Test.8 : U64 = 5i64;

4
compiler/test_mono/generated/ir_plus.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.2 : I64 = 1i64;

4
compiler/test_mono/generated/ir_round.txt
View file

@ -1,6 +1,6 @@
procedure Num.45 (#Attr.2):
let Num.228 : I64 = lowlevel NumRound #Attr.2;
ret Num.228;
let Num.273 : I64 = lowlevel NumRound #Attr.2;
ret Num.273;
procedure Test.0 ():
let Test.2 : Float64 = 3.6f64;

4
compiler/test_mono/generated/ir_two_defs.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.4 : I64 = 3i64;

18
compiler/test_mono/generated/ir_when_idiv.txt
View file

@ -1,14 +1,14 @@
procedure Num.40 (#Attr.2, #Attr.3):
let Num.233 : I64 = 0i64;
let Num.230 : Int1 = lowlevel NotEq #Attr.3 Num.233;
if Num.230 then
let Num.232 : I64 = lowlevel NumDivUnchecked #Attr.2 #Attr.3;
let Num.231 : [C {}, C I64] = Ok Num.232;
ret Num.231;
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;
else
let Num.229 : {} = Struct {};
let Num.228 : [C {}, C I64] = Err Num.229;
ret Num.228;
let Num.274 : {} = Struct {};
let Num.273 : [C {}, C I64] = Err Num.274;
ret Num.273;
procedure Test.0 ():
let Test.8 : I64 = 1000i64;

4
compiler/test_mono/generated/ir_when_just.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.10 : I64 = 41i64;

30
compiler/test_mono/generated/is_nil.txt
View file

@ -1,18 +1,18 @@
procedure Test.2 (Test.3):
let Test.12 : Int1 = 1i64;
let Test.13 : Int1 = GetTagId Test.3;
let Test.14 : Int1 = lowlevel Eq Test.12 Test.13;
if Test.14 then
let Test.10 : Int1 = true;
ret Test.10;
else
let Test.11 : Int1 = false;
procedure Test.3 (Test.4):
let Test.13 : Int1 = 1i64;
let Test.14 : Int1 = GetTagId Test.4;
let Test.15 : Int1 = lowlevel Eq Test.13 Test.14;
if Test.15 then
let Test.11 : Int1 = true;
ret Test.11;
else
let Test.12 : Int1 = false;
ret Test.12;
procedure Test.0 ():
let Test.15 : I64 = 2i64;
let Test.16 : [<rnu><null>, C I64 *self] = Nil ;
let Test.9 : [<rnu><null>, C I64 *self] = Cons Test.15 Test.16;
let Test.8 : Int1 = CallByName Test.2 Test.9;
dec Test.9;
ret Test.8;
let Test.16 : I64 = 2i64;
let Test.17 : [<rnu><null>, C I64 *self] = Nil ;
let Test.10 : [<rnu><null>, C I64 *self] = Cons Test.16 Test.17;
let Test.9 : Int1 = CallByName Test.3 Test.10;
dec Test.10;
ret Test.9;

20
compiler/test_mono/generated/issue_2583_specialize_errors_behind_unified_branches.txt
View file

@ -14,17 +14,17 @@ procedure List.9 (#Attr.2):
procedure Str.27 (#Attr.2):
let #Attr.3 : {I64, U8} = lowlevel StrToNum #Attr.2;
let Str.69 : U8 = StructAtIndex 1 #Attr.3;
let Str.70 : U8 = 0i64;
let Str.66 : Int1 = lowlevel NumGt Str.69 Str.70;
if Str.66 then
let Str.68 : Int1 = false;
let Str.67 : [C Int1, C I64] = Err Str.68;
ret Str.67;
let Str.70 : U8 = StructAtIndex 1 #Attr.3;
let Str.71 : U8 = 0i64;
let Str.67 : Int1 = lowlevel NumGt Str.70 Str.71;
if Str.67 then
let Str.69 : Int1 = false;
let Str.68 : [C Int1, C I64] = Err Str.69;
ret Str.68;
else
let Str.65 : I64 = StructAtIndex 0 #Attr.3;
let Str.64 : [C Int1, C I64] = Ok Str.65;
ret Str.64;
let Str.66 : I64 = StructAtIndex 0 #Attr.3;
let Str.65 : [C Int1, C I64] = Ok Str.66;
ret Str.65;
procedure Test.0 ():
let Test.4 : Int1 = true;

10
compiler/test_mono/generated/issue_2810.txt
View file

@ -1,6 +1,6 @@
procedure Test.0 ():
let Test.16 : [C [<rnnu>C [C *self, C ]], C ] = SystemTool ;
let Test.14 : [<rnnu>C [C *self, C ]] = Job Test.16;
let Test.13 : [C [<rnnu>C [C *self, C ]], C ] = FromJob Test.14;
let Test.4 : [<rnnu>C [C *self, C ]] = Job Test.13;
ret Test.4;
let Test.19 : [C [<rnnu>C [C *self, C ]], C ] = SystemTool ;
let Test.17 : [<rnnu>C [C *self, C ]] = Job Test.19;
let Test.16 : [C [<rnnu>C [C *self, C ]], C ] = FromJob Test.17;
let Test.7 : [<rnnu>C [C *self, C ]] = Job Test.16;
ret Test.7;

40
compiler/test_mono/generated/linked_list_length_twice.txt
View file

@ -1,25 +1,25 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.229;
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Test.3 (Test.5):
let Test.15 : Int1 = 1i64;
let Test.16 : Int1 = GetTagId Test.5;
let Test.17 : Int1 = lowlevel Eq Test.15 Test.16;
if Test.17 then
let Test.11 : I64 = 0i64;
ret Test.11;
else
let Test.6 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.5;
let Test.13 : I64 = 1i64;
let Test.14 : I64 = CallByName Test.3 Test.6;
let Test.12 : I64 = CallByName Num.19 Test.13 Test.14;
procedure Test.4 (Test.6):
let Test.16 : Int1 = 1i64;
let Test.17 : Int1 = GetTagId Test.6;
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then
let Test.12 : I64 = 0i64;
ret Test.12;
else
let Test.7 : [<rnu><null>, C I64 *self] = UnionAtIndex (Id 0) (Index 1) Test.6;
let Test.14 : I64 = 1i64;
let Test.15 : I64 = CallByName Test.4 Test.7;
let Test.13 : I64 = CallByName Num.19 Test.14 Test.15;
ret Test.13;
procedure Test.0 ():
let Test.2 : [<rnu><null>, C I64 *self] = Nil ;
let Test.8 : I64 = CallByName Test.3 Test.2;
let Test.9 : I64 = CallByName Test.3 Test.2;
dec Test.2;
let Test.7 : I64 = CallByName Num.19 Test.8 Test.9;
ret Test.7;
let Test.3 : [<rnu><null>, C I64 *self] = Nil ;
let Test.9 : I64 = CallByName Test.4 Test.3;
let Test.10 : I64 = CallByName Test.4 Test.3;
dec Test.3;
let Test.8 : I64 = CallByName Num.19 Test.9 Test.10;
ret Test.8;

4
compiler/test_mono/generated/list_cannot_update_inplace.txt
View file

@ -20,8 +20,8 @@ procedure List.6 (#Attr.2):
ret List.140;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 ():
let Test.8 : List I64 = Array [1i64, 2i64, 3i64];

4
compiler/test_mono/generated/list_len.txt
View file

@ -7,8 +7,8 @@ procedure List.6 (#Attr.2):
ret List.140;
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.7 : List I64 = Array [1i64, 2i64, 3i64];

4
compiler/test_mono/generated/monomorphized_ints_aliased.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : U64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.5 (Test.7, Test.8):
let Test.17 : U64 = 1i64;

4
compiler/test_mono/generated/nested_pattern_match.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.19 : I64 = 41i64;

4
compiler/test_mono/generated/optional_when.txt
View file

@ -1,6 +1,6 @@
procedure Num.21 (#Attr.2, #Attr.3):
let Num.230 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.230;
let Num.275 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.6):
let Test.21 : Int1 = false;

8
compiler/test_mono/generated/peano.txt
View file

@ -1,6 +1,6 @@
procedure Test.0 ():
let Test.10 : [<rnu><null>, C *self] = Z ;
let Test.11 : [<rnu><null>, C *self] = Z ;
let Test.10 : [<rnu><null>, C *self] = S Test.11;
let Test.9 : [<rnu><null>, C *self] = S Test.10;
let Test.8 : [<rnu><null>, C *self] = S Test.9;
let Test.2 : [<rnu><null>, C *self] = S Test.8;
ret Test.2;
let Test.3 : [<rnu><null>, C *self] = S Test.9;
ret Test.3;

24
compiler/test_mono/generated/peano1.txt
View file

@ -1,15 +1,15 @@
procedure Test.0 ():
let Test.14 : [<rnu><null>, C *self] = Z ;
let Test.15 : [<rnu><null>, C *self] = Z ;
let Test.14 : [<rnu><null>, C *self] = S Test.15;
let Test.13 : [<rnu><null>, C *self] = S Test.14;
let Test.12 : [<rnu><null>, C *self] = S Test.13;
let Test.2 : [<rnu><null>, C *self] = S Test.12;
let Test.9 : Int1 = 1i64;
let Test.10 : Int1 = GetTagId Test.2;
dec Test.2;
let Test.11 : Int1 = lowlevel Eq Test.9 Test.10;
if Test.11 then
let Test.7 : I64 = 0i64;
ret Test.7;
else
let Test.8 : I64 = 1i64;
let Test.3 : [<rnu><null>, C *self] = S Test.13;
let Test.10 : Int1 = 1i64;
let Test.11 : Int1 = GetTagId Test.3;
dec Test.3;
let Test.12 : Int1 = lowlevel Eq Test.10 Test.11;
if Test.12 then
let Test.8 : I64 = 0i64;
ret Test.8;
else
let Test.9 : I64 = 1i64;
ret Test.9;

40
compiler/test_mono/generated/peano2.txt
View file

@ -1,26 +1,26 @@
procedure Test.0 ():
let Test.20 : [<rnu><null>, C *self] = Z ;
let Test.21 : [<rnu><null>, C *self] = Z ;
let Test.20 : [<rnu><null>, C *self] = S Test.21;
let Test.19 : [<rnu><null>, C *self] = S Test.20;
let Test.18 : [<rnu><null>, C *self] = S Test.19;
let Test.2 : [<rnu><null>, C *self] = S Test.18;
let Test.15 : Int1 = 0i64;
let Test.16 : Int1 = GetTagId Test.2;
let Test.17 : Int1 = lowlevel Eq Test.15 Test.16;
if Test.17 then
let Test.11 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.2;
inc Test.11;
dec Test.2;
let Test.12 : Int1 = 0i64;
let Test.13 : Int1 = GetTagId Test.11;
dec Test.11;
let Test.14 : Int1 = lowlevel Eq Test.12 Test.13;
if Test.14 then
let Test.7 : I64 = 1i64;
ret Test.7;
else
let Test.8 : I64 = 0i64;
let Test.3 : [<rnu><null>, C *self] = S Test.19;
let Test.16 : Int1 = 0i64;
let Test.17 : Int1 = GetTagId Test.3;
let Test.18 : Int1 = lowlevel Eq Test.16 Test.17;
if Test.18 then
let Test.12 : [<rnu><null>, C *self] = UnionAtIndex (Id 0) (Index 0) Test.3;
inc Test.12;
dec Test.3;
let Test.13 : Int1 = 0i64;
let Test.14 : Int1 = GetTagId Test.12;
dec Test.12;
let Test.15 : Int1 = lowlevel Eq Test.13 Test.14;
if Test.15 then
let Test.8 : I64 = 1i64;
ret Test.8;
else
dec Test.2;
let Test.9 : I64 = 0i64;
ret Test.9;
else
dec Test.3;
let Test.10 : I64 = 0i64;
ret Test.10;

12
compiler/test_mono/generated/quicksort_help.txt
View file

@ -1,14 +1,14 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Num.20 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.229;
let Num.274 : I64 = lowlevel NumSub #Attr.2 #Attr.3;
ret Num.274;
procedure Num.22 (#Attr.2, #Attr.3):
let Num.230 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.230;
let Num.275 : Int1 = lowlevel NumLt #Attr.2 #Attr.3;
ret Num.275;
procedure Test.1 (Test.24, Test.25, Test.26):
joinpoint Test.12 Test.2 Test.3 Test.4:

4
compiler/test_mono/generated/record_optional_field_function_no_use_default.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.4):
let Test.2 : I64 = StructAtIndex 0 Test.4;

4
compiler/test_mono/generated/record_optional_field_function_use_default.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.4):
let Test.8 : I64 = 10i64;

4
compiler/test_mono/generated/record_optional_field_let_no_use_default.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.2):
let Test.3 : I64 = StructAtIndex 0 Test.2;

4
compiler/test_mono/generated/record_optional_field_let_use_default.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.2):
let Test.3 : I64 = 10i64;

8
compiler/test_mono/generated/somehow_drops_definitions.txt
View file

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.229;
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 ():
let Test.26 : I64 = 1i64;

10
compiler/test_mono/generated/specialize_ability_call.txt
View file

@ -1,7 +1,7 @@
procedure Test.5 (Test.7):
ret Test.7;
procedure Test.7 (Test.9):
ret Test.9;
procedure Test.0 ():
let Test.9 : U64 = 1234i64;
let Test.8 : U64 = CallByName Test.5 Test.9;
ret Test.8;
let Test.11 : U64 = 1234i64;
let Test.10 : U64 = CallByName Test.7 Test.11;
ret Test.10;

8
compiler/test_mono/generated/specialize_closures.txt
View file

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.229;
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.1 (Test.2, Test.3):
let Test.17 : U8 = GetTagId Test.2;

8
compiler/test_mono/generated/specialize_lowlevel.txt
View file

@ -1,10 +1,10 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.229 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.229;
let Num.274 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.274;
procedure Num.21 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumMul #Attr.2 #Attr.3;
ret Num.273;
procedure Test.6 (Test.8, #Attr.12):
let Test.4 : I64 = UnionAtIndex (Id 0) (Index 0) #Attr.12;

4
compiler/test_mono/generated/when_nested_maybe.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.19 : I64 = 41i64;

4
compiler/test_mono/generated/when_on_record.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.5 : I64 = 2i64;

4
compiler/test_mono/generated/when_on_two_values.txt
View file

@ -1,6 +1,6 @@
procedure Num.19 (#Attr.2, #Attr.3):
let Num.228 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.228;
let Num.273 : I64 = lowlevel NumAdd #Attr.2 #Attr.3;
ret Num.273;
procedure Test.0 ():
let Test.15 : I64 = 3i64;