language-servers/roc
1
0
Fork 0
mirror of https://github.com/roc-lang/roc.git synced 2025-09-29 06:44:46 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 7

Merge test_dev, test_wasm, and test_wasm_util into test_gen

Browse source
This commit is contained in:
Brendan Hansknecht 2021-11-08 19:31:20 -08:00
parent cba0f07992
commit 360974398a
32 changed files with 2417 additions and 6571 deletions
Download patch file Download diff file Expand all files Collapse all files

609
compiler/test_gen/src/gen_compare.rs
View file

@ -1,196 +1,218 @@
#[cfg(test)]
mod gen_compare {
use crate::assert_evals_to;
// use crate::assert_wasm_evals_to as assert_evals_to;
use indoc::indoc;
#![cfg(not(feature = "gen-wasm"))]
#[test]
fn eq_i64() {
assert_evals_to!(
indoc!(
r#"
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
#[cfg(feature = "gen-dev")]
use crate::helpers::dev::assert_evals_to;
// #[cfg(feature = "gen-wasm")]
// use crate::helpers::wasm::assert_evals_to;
// use crate::assert_wasm_evals_to as assert_evals_to;
use indoc::indoc;
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn eq_i64() {
assert_evals_to!(
indoc!(
r#"
i : I64
i = 1
i == i
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn neq_i64() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn neq_i64() {
assert_evals_to!(
indoc!(
r#"
i : I64
i = 1
i != i
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
fn eq_u64() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn eq_u64() {
assert_evals_to!(
indoc!(
r#"
i : U64
i = 1
i == i
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn neq_u64() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn neq_u64() {
assert_evals_to!(
indoc!(
r#"
i : U64
i = 1
i != i
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
fn eq_f64() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_f64() {
assert_evals_to!(
indoc!(
r#"
i : F64
i = 1
i == i
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn neq_f64() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn neq_f64() {
assert_evals_to!(
indoc!(
r#"
i : F64
i = 1
i != i
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
fn eq_bool_tag() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_bool_tag() {
assert_evals_to!(
indoc!(
r#"
true : Bool
true = True
true == True
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn neq_bool_tag() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn neq_bool_tag() {
assert_evals_to!(
indoc!(
r#"
true : Bool
true = True
true == False
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
fn empty_record() {
assert_evals_to!("{} == {}", true, bool);
assert_evals_to!("{} != {}", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn empty_record() {
assert_evals_to!("{} == {}", true, bool);
assert_evals_to!("{} != {}", false, bool);
}
#[test]
fn unit() {
assert_evals_to!("Unit == Unit", true, bool);
assert_evals_to!("Unit != Unit", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn unit() {
assert_evals_to!("Unit == Unit", true, bool);
assert_evals_to!("Unit != Unit", false, bool);
}
#[test]
fn newtype() {
assert_evals_to!("Identity 42 == Identity 42", true, bool);
assert_evals_to!("Identity 42 != Identity 42", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn newtype() {
assert_evals_to!("Identity 42 == Identity 42", true, bool);
assert_evals_to!("Identity 42 != Identity 42", false, bool);
}
#[test]
fn small_str() {
assert_evals_to!("\"aaa\" == \"aaa\"", true, bool);
assert_evals_to!("\"aaa\" == \"bbb\"", false, bool);
assert_evals_to!("\"aaa\" != \"aaa\"", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn small_str() {
assert_evals_to!("\"aaa\" == \"aaa\"", true, bool);
assert_evals_to!("\"aaa\" == \"bbb\"", false, bool);
assert_evals_to!("\"aaa\" != \"aaa\"", false, bool);
}
#[test]
fn large_str() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn large_str() {
assert_evals_to!(
indoc!(
r#"
x = "Unicode can represent text values which span multiple languages"
y = "Unicode can represent text values which span multiple languages"
x == y
"#
),
true,
bool
);
),
true,
bool
);
assert_evals_to!(
indoc!(
r#"
assert_evals_to!(
indoc!(
r#"
x = "Unicode can represent text values which span multiple languages"
y = "Here are some valid Roc strings"
x != y
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn eq_result_tag_true() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_result_tag_true() {
assert_evals_to!(
indoc!(
r#"
x : Result I64 I64
x = Ok 1
@ -199,17 +221,18 @@ mod gen_compare {
x == y
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn eq_result_tag_false() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_result_tag_false() {
assert_evals_to!(
indoc!(
r#"
x : Result I64 I64
x = Ok 1
@ -218,17 +241,18 @@ mod gen_compare {
x == y
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
fn eq_expr() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_expr() {
assert_evals_to!(
indoc!(
r#"
Expr : [ Add Expr Expr, Mul Expr Expr, Val I64, Var I64 ]
x : Expr
@ -239,17 +263,18 @@ mod gen_compare {
x == y
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn eq_linked_list() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_linked_list() {
assert_evals_to!(
indoc!(
r#"
LinkedList a : [ Nil, Cons a (LinkedList a) ]
x : LinkedList I64
@ -260,14 +285,14 @@ mod gen_compare {
x == y
"#
),
true,
bool
);
),
true,
bool
);
assert_evals_to!(
indoc!(
r#"
assert_evals_to!(
indoc!(
r#"
LinkedList a : [ Nil, Cons a (LinkedList a) ]
x : LinkedList I64
@ -278,14 +303,14 @@ mod gen_compare {
x == y
"#
),
true,
bool
);
),
true,
bool
);
assert_evals_to!(
indoc!(
r#"
assert_evals_to!(
indoc!(
r#"
LinkedList a : [ Nil, Cons a (LinkedList a) ]
x : LinkedList I64
@ -296,17 +321,18 @@ mod gen_compare {
x == y
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn eq_linked_list_false() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_linked_list_false() {
assert_evals_to!(
indoc!(
r#"
LinkedList a : [ Nil, Cons a (LinkedList a) ]
x : LinkedList I64
@ -317,17 +343,18 @@ mod gen_compare {
y == x
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
fn eq_nullable_expr() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_nullable_expr() {
assert_evals_to!(
indoc!(
r#"
Expr : [ Add Expr Expr, Mul Expr Expr, Val I64, Empty ]
x : Expr
@ -338,17 +365,18 @@ mod gen_compare {
x != y
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn eq_rosetree() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn eq_rosetree() {
assert_evals_to!(
indoc!(
r#"
Rose a : [ Rose (List (Rose a)) ]
x : Rose I64
@ -359,14 +387,14 @@ mod gen_compare {
x == y
"#
),
true,
bool
);
),
true,
bool
);
assert_evals_to!(
indoc!(
r#"
assert_evals_to!(
indoc!(
r#"
Rose a : [ Rose (List (Rose a)) ]
x : Rose I64
@ -377,20 +405,21 @@ mod gen_compare {
x != y
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
#[ignore]
fn rosetree_with_tag() {
// currently stack overflows in type checking
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn rosetree_with_tag() {
// currently stack overflows in type checking
assert_evals_to!(
indoc!(
r#"
assert_evals_to!(
indoc!(
r#"
Rose a : [ Rose (Result (List (Rose a)) I64) ]
x : Rose I64
@ -401,53 +430,60 @@ mod gen_compare {
x == y
"#
),
true,
bool
);
}
),
true,
bool
);
}
#[test]
fn list_eq_empty() {
assert_evals_to!("[] == []", true, bool);
assert_evals_to!("[] != []", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_eq_empty() {
assert_evals_to!("[] == []", true, bool);
assert_evals_to!("[] != []", false, bool);
}
#[test]
fn list_eq_by_length() {
assert_evals_to!("[1] == []", false, bool);
assert_evals_to!("[] == [1]", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_eq_by_length() {
assert_evals_to!("[1] == []", false, bool);
assert_evals_to!("[] == [1]", false, bool);
}
#[test]
fn list_eq_compare_pointwise() {
assert_evals_to!("[1] == [1]", true, bool);
assert_evals_to!("[2] == [1]", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_eq_compare_pointwise() {
assert_evals_to!("[1] == [1]", true, bool);
assert_evals_to!("[2] == [1]", false, bool);
}
#[test]
fn list_eq_nested() {
assert_evals_to!("[[1]] == [[1]]", true, bool);
assert_evals_to!("[[2]] == [[1]]", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_eq_nested() {
assert_evals_to!("[[1]] == [[1]]", true, bool);
assert_evals_to!("[[2]] == [[1]]", false, bool);
}
#[test]
fn list_neq_compare_pointwise() {
assert_evals_to!("[1] != [1]", false, bool);
assert_evals_to!("[2] != [1]", true, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_neq_compare_pointwise() {
assert_evals_to!("[1] != [1]", false, bool);
assert_evals_to!("[2] != [1]", true, bool);
}
#[test]
fn list_neq_nested() {
assert_evals_to!("[[1]] != [[1]]", false, bool);
assert_evals_to!("[[2]] != [[1]]", true, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_neq_nested() {
assert_evals_to!("[[1]] != [[1]]", false, bool);
assert_evals_to!("[[2]] != [[1]]", true, bool);
}
#[test]
fn compare_union_same_content() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn compare_union_same_content() {
assert_evals_to!(
indoc!(
r#"
Foo : [ A I64, B I64 ]
a : Foo
@ -458,17 +494,18 @@ mod gen_compare {
a == b
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
fn compare_recursive_union_same_content() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn compare_recursive_union_same_content() {
assert_evals_to!(
indoc!(
r#"
Expr : [ Add Expr Expr, Mul Expr Expr, Val1 I64, Val2 I64 ]
v1 : Expr
@ -479,17 +516,18 @@ mod gen_compare {
v1 == v2
"#
),
false,
bool
);
}
),
false,
bool
);
}
#[test]
fn compare_nullable_recursive_union_same_content() {
assert_evals_to!(
indoc!(
r#"
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn compare_nullable_recursive_union_same_content() {
assert_evals_to!(
indoc!(
r#"
Expr : [ Add Expr Expr, Mul Expr Expr, Val1 I64, Val2 I64, Empty ]
v1 : Expr
@ -500,9 +538,8 @@ mod gen_compare {
v1 == v2
"#
),
false,
bool
);
}
),
false,
bool
);
}

34
compiler/test_gen/src/gen_dict.rs
View file

@ -1,10 +1,19 @@
#![cfg(test)]
#![cfg(feature = "gen-llvm")]
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
// #[cfg(feature = "gen-dev")]
// use crate::helpers::dev::assert_evals_to;
// #[cfg(feature = "gen-wasm")]
// use crate::helpers::wasm::assert_evals_to;
use crate::assert_evals_to;
use indoc::indoc;
use roc_std::{RocList, RocStr};
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn dict_empty_len() {
assert_evals_to!(
indoc!(
@ -18,6 +27,7 @@ fn dict_empty_len() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn dict_insert_empty() {
assert_evals_to!(
indoc!(
@ -32,6 +42,7 @@ fn dict_insert_empty() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn dict_empty_contains() {
assert_evals_to!(
indoc!(
@ -48,6 +59,7 @@ fn dict_empty_contains() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn dict_nonempty_contains() {
assert_evals_to!(
indoc!(
@ -64,6 +76,7 @@ fn dict_nonempty_contains() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn dict_empty_remove() {
assert_evals_to!(
indoc!(
@ -82,6 +95,7 @@ fn dict_empty_remove() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn dict_nonempty_remove() {
assert_evals_to!(
indoc!(
@ -100,6 +114,7 @@ fn dict_nonempty_remove() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn dict_nonempty_get() {
assert_evals_to!(
indoc!(
@ -142,6 +157,7 @@ fn dict_nonempty_get() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn keys() {
assert_evals_to!(
indoc!(
@ -163,6 +179,7 @@ fn keys() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn values() {
assert_evals_to!(
indoc!(
@ -184,6 +201,7 @@ fn values() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn from_list_with_fold() {
assert_evals_to!(
indoc!(
@ -226,6 +244,7 @@ fn from_list_with_fold() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn small_str_keys() {
assert_evals_to!(
indoc!(
@ -247,6 +266,7 @@ fn small_str_keys() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn big_str_keys() {
assert_evals_to!(
indoc!(
@ -272,6 +292,7 @@ fn big_str_keys() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn big_str_values() {
assert_evals_to!(
indoc!(
@ -296,6 +317,7 @@ fn big_str_values() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn unit_values() {
assert_evals_to!(
indoc!(
@ -317,6 +339,7 @@ fn unit_values() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn single() {
assert_evals_to!(
indoc!(
@ -334,6 +357,7 @@ fn single() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn union() {
assert_evals_to!(
indoc!(
@ -351,6 +375,7 @@ fn union() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn union_prefer_first() {
assert_evals_to!(
indoc!(
@ -368,6 +393,7 @@ fn union_prefer_first() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn intersection() {
assert_evals_to!(
indoc!(
@ -398,6 +424,7 @@ fn intersection() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn intersection_prefer_first() {
assert_evals_to!(
indoc!(
@ -428,6 +455,7 @@ fn intersection_prefer_first() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn difference() {
assert_evals_to!(
indoc!(
@ -458,6 +486,7 @@ fn difference() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn difference_prefer_first() {
assert_evals_to!(
indoc!(
@ -488,6 +517,7 @@ fn difference_prefer_first() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn walk_sum_keys() {
assert_evals_to!(
indoc!(

179
compiler/test_gen/src/gen_list.rs
View file

@ -1,63 +1,34 @@
#![cfg(test)]
#![cfg(feature = "gen-llvm")]
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
// #[cfg(feature = "gen-dev")]
// use crate::helpers::dev::assert_evals_to;
// #[cfg(feature = "gen-wasm")]
// use crate::helpers::wasm::assert_evals_to;
use crate::assert_evals_to;
use crate::helpers::with_larger_debug_stack;
//use crate::assert_wasm_evals_to as assert_evals_to;
use core::ffi::c_void;
use indoc::indoc;
use roc_std::{RocList, RocStr};
#[no_mangle]
pub unsafe fn roc_alloc(size: usize, _alignment: u32) -> *mut c_void {
libc::malloc(size)
}
#[no_mangle]
pub unsafe fn roc_realloc(
c_ptr: *mut c_void,
new_size: usize,
_old_size: usize,
_alignment: u32,
) -> *mut c_void {
libc::realloc(c_ptr, new_size)
}
#[no_mangle]
pub unsafe fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) {
libc::free(c_ptr)
}
#[no_mangle]
pub unsafe fn roc_panic(c_ptr: *mut c_void, tag_id: u32) {
use roc_gen_llvm::llvm::build::PanicTagId;
use std::convert::TryFrom;
use std::ffi::CStr;
use std::os::raw::c_char;
match PanicTagId::try_from(tag_id) {
Ok(PanicTagId::NullTerminatedString) => {
let slice = CStr::from_ptr(c_ptr as *const c_char);
let string = slice.to_str().unwrap();
eprintln!("Roc hit a panic: {}", string);
std::process::exit(1);
}
Err(_) => unreachable!(),
}
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn roc_list_construction() {
let list = RocList::from_slice(&[1i64; 23]);
assert_eq!(&list, &list);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn empty_list_literal() {
assert_evals_to!("[]", RocList::from_slice(&[]), RocList<i64>);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_literal_empty_record() {
assert_evals_to!("[{}]", RocList::from_slice(&[()]), RocList<()>);
}
@ -68,6 +39,7 @@ fn int_singleton_list_literal() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn int_list_literal() {
assert_evals_to!("[ 12, 9 ]", RocList::from_slice(&[12, 9]), RocList<i64>);
assert_evals_to!(
@ -78,6 +50,7 @@ fn int_list_literal() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn bool_list_literal() {
// NOTE: make sure to explicitly declare the elements to be of type bool, or
// use both True and False; only using one of them causes the list to in practice be
@ -156,6 +129,7 @@ fn bool_list_literal() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn variously_sized_list_literals() {
assert_evals_to!("[]", RocList::from_slice(&[]), RocList<i64>);
assert_evals_to!("[1]", RocList::from_slice(&[1]), RocList<i64>);
@ -174,6 +148,7 @@ fn variously_sized_list_literals() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_append() {
assert_evals_to!(
"List.append [1] 2",
@ -188,6 +163,7 @@ fn list_append() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_take_first() {
assert_evals_to!(
"List.takeFirst [1, 2, 3] 2",
@ -212,6 +188,7 @@ fn list_take_first() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_drop() {
assert_evals_to!(
"List.drop [1,2,3] 2",
@ -223,6 +200,7 @@ fn list_drop() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_drop_at() {
assert_evals_to!(
"List.dropAt [1, 2, 3] 0",
@ -239,6 +217,7 @@ fn list_drop_at() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_drop_at_shared() {
assert_evals_to!(
indoc!(
@ -260,6 +239,7 @@ fn list_drop_at_shared() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_drop_last() {
assert_evals_to!(
"List.dropLast [1, 2, 3]",
@ -271,6 +251,7 @@ fn list_drop_last() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_drop_last_mutable() {
assert_evals_to!(
indoc!(
@ -292,6 +273,7 @@ fn list_drop_last_mutable() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_drop_first() {
assert_evals_to!(
"List.dropFirst [1, 2, 3]",
@ -303,6 +285,7 @@ fn list_drop_first() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_swap() {
assert_evals_to!("List.swap [] 0 1", RocList::from_slice(&[]), RocList<i64>);
assert_evals_to!(
@ -338,11 +321,13 @@ fn list_swap() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_append_to_empty_list() {
assert_evals_to!("List.append [] 3", RocList::from_slice(&[3]), RocList<i64>);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_append_to_empty_list_of_int() {
assert_evals_to!(
indoc!(
@ -360,6 +345,7 @@ fn list_append_to_empty_list_of_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_append_bools() {
assert_evals_to!(
"List.append [ True, False ] True",
@ -369,6 +355,7 @@ fn list_append_bools() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_append_longer_list() {
assert_evals_to!(
"List.append [ 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22 ] 23",
@ -378,6 +365,7 @@ fn list_append_longer_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_prepend() {
assert_evals_to!("List.prepend [] 1", RocList::from_slice(&[1]), RocList<i64>);
assert_evals_to!(
@ -416,6 +404,7 @@ fn list_prepend() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_prepend_bools() {
assert_evals_to!(
"List.prepend [ True, False ] True",
@ -425,6 +414,7 @@ fn list_prepend_bools() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_prepend_big_list() {
assert_evals_to!(
"List.prepend [ 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 100, 100, 100, 100 ] 9",
@ -436,6 +426,7 @@ fn list_prepend_big_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_walk_backwards_empty_all_inline() {
assert_evals_to!(
indoc!(
@ -463,6 +454,7 @@ fn list_walk_backwards_empty_all_inline() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_walk_backwards_with_str() {
assert_evals_to!(
r#"List.walkBackwards [ "x", "y", "z" ] "<" Str.concat"#,
@ -478,6 +470,7 @@ fn list_walk_backwards_with_str() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_walk_backwards_with_record() {
assert_evals_to!(
indoc!(
@ -505,6 +498,7 @@ fn list_walk_backwards_with_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_walk_with_str() {
assert_evals_to!(
r#"List.walk [ "x", "y", "z" ] "<" Str.concat"#,
@ -520,11 +514,13 @@ fn list_walk_with_str() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_walk_subtraction() {
assert_evals_to!(r#"List.walk [ 1, 2 ] 1 Num.sub"#, (1 - 1) - 2, i64);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_walk_until_sum() {
assert_evals_to!(
r#"List.walkUntil [ 1, 2 ] 0 \a,b -> Continue (a + b)"#,
@ -534,6 +530,7 @@ fn list_walk_until_sum() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_walk_until_even_prefix_sum() {
assert_evals_to!(
r#"
@ -551,6 +548,7 @@ fn list_walk_until_even_prefix_sum() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_keep_if_empty_list_of_int() {
assert_evals_to!(
indoc!(
@ -568,6 +566,7 @@ fn list_keep_if_empty_list_of_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_keep_if_empty_list() {
assert_evals_to!(
indoc!(
@ -586,6 +585,7 @@ fn list_keep_if_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_keep_if_always_true_for_non_empty_list() {
assert_evals_to!(
indoc!(
@ -607,6 +607,7 @@ fn list_keep_if_always_true_for_non_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_keep_if_always_false_for_non_empty_list() {
assert_evals_to!(
indoc!(
@ -624,6 +625,7 @@ fn list_keep_if_always_false_for_non_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_keep_if_one() {
assert_evals_to!(
indoc!(
@ -641,6 +643,7 @@ fn list_keep_if_one() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_keep_if_str_is_hello() {
assert_evals_to!(
indoc!(
@ -657,6 +660,7 @@ fn list_keep_if_str_is_hello() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_on_empty_list_with_int_layout() {
assert_evals_to!(
indoc!(
@ -674,6 +678,7 @@ fn list_map_on_empty_list_with_int_layout() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_on_non_empty_list() {
assert_evals_to!(
indoc!(
@ -691,6 +696,7 @@ fn list_map_on_non_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_changes_input() {
assert_evals_to!(
indoc!(
@ -708,6 +714,7 @@ fn list_map_changes_input() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_on_big_list() {
assert_evals_to!(
indoc!(
@ -727,6 +734,7 @@ fn list_map_on_big_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_with_type_change() {
assert_evals_to!(
indoc!(
@ -745,6 +753,7 @@ fn list_map_with_type_change() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_using_defined_function() {
assert_evals_to!(
indoc!(
@ -766,6 +775,7 @@ fn list_map_using_defined_function() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_all_inline() {
assert_evals_to!(
indoc!(
@ -779,6 +789,7 @@ fn list_map_all_inline() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_closure() {
assert_evals_to!(
indoc!(
@ -799,6 +810,7 @@ fn list_map_closure() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map4_group() {
assert_evals_to!(
indoc!(
@ -812,6 +824,7 @@ fn list_map4_group() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map4_different_length() {
assert_evals_to!(
indoc!(
@ -830,6 +843,7 @@ fn list_map4_different_length() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map3_group() {
assert_evals_to!(
indoc!(
@ -843,6 +857,7 @@ fn list_map3_group() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map3_different_length() {
assert_evals_to!(
indoc!(
@ -860,6 +875,7 @@ fn list_map3_different_length() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map2_pair() {
assert_evals_to!(
indoc!(
@ -874,6 +890,7 @@ fn list_map2_pair() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map2_different_lengths() {
assert_evals_to!(
indoc!(
@ -890,11 +907,13 @@ fn list_map2_different_lengths() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_empty_list() {
assert_evals_to!("List.join []", RocList::from_slice(&[]), RocList<i64>);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_one_list() {
assert_evals_to!(
"List.join [ [1, 2, 3 ] ]",
@ -904,6 +923,7 @@ fn list_join_one_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_two_non_empty_lists() {
assert_evals_to!(
"List.join [ [1, 2, 3 ] , [4 ,5, 6] ]",
@ -913,6 +933,7 @@ fn list_join_two_non_empty_lists() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_two_non_empty_lists_of_float() {
assert_evals_to!(
"List.join [ [ 1.2, 1.1 ], [ 2.1, 2.2 ] ]",
@ -922,6 +943,7 @@ fn list_join_two_non_empty_lists_of_float() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_to_big_list() {
assert_evals_to!(
indoc!(
@ -947,6 +969,7 @@ fn list_join_to_big_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_defined_empty_list() {
assert_evals_to!(
indoc!(
@ -964,6 +987,7 @@ fn list_join_defined_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_all_empty_lists() {
assert_evals_to!(
"List.join [ [], [], [] ]",
@ -973,6 +997,7 @@ fn list_join_all_empty_lists() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_one_empty_list() {
assert_evals_to!(
"List.join [ [ 1.2, 1.1 ], [] ]",
@ -982,12 +1007,14 @@ fn list_join_one_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_single() {
assert_evals_to!("List.single 1", RocList::from_slice(&[1]), RocList<i64>);
assert_evals_to!("List.single 5.6", RocList::from_slice(&[5.6]), RocList<f64>);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_repeat() {
assert_evals_to!(
"List.repeat 5 1",
@ -1028,6 +1055,7 @@ fn list_repeat() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_reverse() {
assert_evals_to!(
"List.reverse [ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12 ]",
@ -1043,6 +1071,7 @@ fn list_reverse() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_reverse_empty_list_of_int() {
assert_evals_to!(
indoc!(
@ -1060,11 +1089,13 @@ fn list_reverse_empty_list_of_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_reverse_empty_list() {
assert_evals_to!("List.reverse []", RocList::from_slice(&[]), RocList<i64>);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn foobarbaz() {
assert_evals_to!(
indoc!(
@ -1086,11 +1117,13 @@ fn foobarbaz() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_two_empty_lists() {
assert_evals_to!("List.concat [] []", RocList::from_slice(&[]), RocList<i64>);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_two_empty_lists_of_int() {
assert_evals_to!(
indoc!(
@ -1112,6 +1145,7 @@ fn list_concat_two_empty_lists_of_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_second_list_is_empty() {
assert_evals_to!(
"List.concat [ 12, 13 ] []",
@ -1126,6 +1160,7 @@ fn list_concat_second_list_is_empty() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_first_list_is_empty() {
assert_evals_to!(
"List.concat [] [ 23, 24 ]",
@ -1135,6 +1170,7 @@ fn list_concat_first_list_is_empty() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_two_non_empty_lists() {
assert_evals_to!(
"List.concat [1, 2 ] [ 3, 4 ]",
@ -1144,6 +1180,7 @@ fn list_concat_two_non_empty_lists() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_two_bigger_non_empty_lists() {
assert_evals_to!(
"List.concat [ 1.1, 2.2 ] [ 3.3, 4.4, 5.5 ]",
@ -1173,6 +1210,7 @@ fn assert_concat_worked(num_elems1: i64, num_elems2: i64) {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_empty_list() {
assert_concat_worked(0, 0);
assert_concat_worked(1, 0);
@ -1196,6 +1234,7 @@ fn list_concat_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_nonempty_lists() {
assert_concat_worked(1, 1);
assert_concat_worked(1, 2);
@ -1211,6 +1250,7 @@ fn list_concat_nonempty_lists() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_concat_large() {
with_larger_debug_stack(|| {
// these values produce mono ASTs so large that
@ -1223,16 +1263,19 @@ fn list_concat_large() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn empty_list_len() {
assert_evals_to!("List.len []", 0, usize);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn basic_int_list_len() {
assert_evals_to!("List.len [ 12, 9, 6, 3 ]", 4, usize);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn loaded_int_list_len() {
assert_evals_to!(
indoc!(
@ -1248,6 +1291,7 @@ fn loaded_int_list_len() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn fn_int_list_len() {
assert_evals_to!(
indoc!(
@ -1265,16 +1309,19 @@ fn fn_int_list_len() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn int_list_is_empty() {
assert_evals_to!("List.isEmpty [ 12, 9, 6, 3 ]", false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn empty_list_is_empty() {
assert_evals_to!("List.isEmpty []", true, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn first_int_list() {
assert_evals_to!(
indoc!(
@ -1290,6 +1337,7 @@ fn first_int_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn first_wildcard_empty_list() {
assert_evals_to!(
@ -1306,6 +1354,7 @@ fn first_wildcard_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn first_empty_list() {
assert_evals_to!(
indoc!(
@ -1321,6 +1370,7 @@ fn first_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn last_int_list() {
assert_evals_to!(
indoc!(
@ -1336,6 +1386,7 @@ fn last_int_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn last_wildcard_empty_list() {
assert_evals_to!(
@ -1352,6 +1403,7 @@ fn last_wildcard_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn last_empty_list() {
assert_evals_to!(
indoc!(
@ -1367,6 +1419,7 @@ fn last_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn get_empty_list() {
assert_evals_to!(
indoc!(
@ -1382,6 +1435,7 @@ fn get_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn get_wildcard_empty_list() {
assert_evals_to!(
@ -1398,6 +1452,7 @@ fn get_wildcard_empty_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn get_int_list_ok() {
assert_evals_to!(
indoc!(
@ -1413,6 +1468,7 @@ fn get_int_list_ok() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn get_int_list_oob() {
assert_evals_to!(
indoc!(
@ -1428,6 +1484,7 @@ fn get_int_list_oob() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn get_set_unique_int_list() {
assert_evals_to!(
indoc!(
@ -1443,6 +1500,7 @@ fn get_set_unique_int_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn set_unique_int_list() {
assert_evals_to!(
"List.set [ 12, 9, 7, 1, 5 ] 2 33",
@ -1452,6 +1510,7 @@ fn set_unique_int_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn set_unique_list_oob() {
assert_evals_to!(
"List.set [ 3, 17, 4.1 ] 1337 9.25",
@ -1461,6 +1520,7 @@ fn set_unique_list_oob() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn set_shared_int_list() {
assert_evals_to!(
indoc!(
@ -1488,6 +1548,7 @@ fn set_shared_int_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn set_shared_list_oob() {
assert_evals_to!(
indoc!(
@ -1514,6 +1575,7 @@ fn set_shared_list_oob() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn get_unique_int_list() {
assert_evals_to!(
indoc!(
@ -1531,6 +1593,7 @@ fn get_unique_int_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_wrap_len() {
assert_evals_to!(
indoc!(
@ -1547,6 +1610,7 @@ fn gen_wrap_len() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_wrap_first() {
assert_evals_to!(
indoc!(
@ -1563,6 +1627,7 @@ fn gen_wrap_first() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_duplicate() {
assert_evals_to!(
indoc!(
@ -1585,6 +1650,7 @@ fn gen_duplicate() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_swap() {
assert_evals_to!(
indoc!(
@ -1613,6 +1679,7 @@ fn gen_swap() {
}
// #[test]
#[cfg(any(feature = "gen-llvm"))]
// fn gen_partition() {
// assert_evals_to!(
// indoc!(
@ -1665,6 +1732,7 @@ fn gen_swap() {
// }
// #[test]
#[cfg(any(feature = "gen-llvm"))]
// fn gen_partition() {
// assert_evals_to!(
// indoc!(
@ -1702,8 +1770,8 @@ fn gen_swap() {
// RocList<i64>
// );
// }
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_quicksort() {
with_larger_debug_stack(|| {
assert_evals_to!(
@ -1775,6 +1843,7 @@ fn gen_quicksort() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn foobar2() {
with_larger_debug_stack(|| {
assert_evals_to!(
@ -1848,6 +1917,7 @@ fn foobar2() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn foobar() {
with_larger_debug_stack(|| {
assert_evals_to!(
@ -1921,6 +1991,7 @@ fn foobar() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn empty_list_increment_decrement() {
assert_evals_to!(
indoc!(
@ -1937,6 +2008,7 @@ fn empty_list_increment_decrement() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_literal_increment_decrement() {
assert_evals_to!(
indoc!(
@ -1953,6 +2025,7 @@ fn list_literal_increment_decrement() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_pass_to_function() {
assert_evals_to!(
indoc!(
@ -1972,6 +2045,7 @@ fn list_pass_to_function() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_pass_to_set() {
assert_evals_to!(
indoc!(
@ -1991,6 +2065,7 @@ fn list_pass_to_set() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_wrap_in_tag() {
assert_evals_to!(
indoc!(
@ -2008,6 +2083,7 @@ fn list_wrap_in_tag() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_contains() {
assert_evals_to!(indoc!("List.contains [1,2,3] 1"), true, bool);
@ -2016,6 +2092,7 @@ fn list_contains() {
assert_evals_to!(indoc!("List.contains [] 4"), false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_min() {
assert_evals_to!(
indoc!(
@ -2042,6 +2119,7 @@ fn list_min() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_max() {
assert_evals_to!(
indoc!(
@ -2068,6 +2146,7 @@ fn list_max() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_sum() {
assert_evals_to!("List.sum []", 0, i64);
assert_evals_to!("List.sum [ 1, 2, 3 ]", 6, i64);
@ -2075,6 +2154,7 @@ fn list_sum() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_product() {
assert_evals_to!("List.product []", 1, i64);
assert_evals_to!("List.product [ 1, 2, 3 ]", 6, i64);
@ -2082,6 +2162,7 @@ fn list_product() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_keep_oks() {
assert_evals_to!("List.keepOks [] (\\x -> x)", 0, i64);
assert_evals_to!(
@ -2102,6 +2183,7 @@ fn list_keep_oks() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_keep_errs() {
assert_evals_to!("List.keepErrs [] (\\x -> x)", 0, i64);
assert_evals_to!(
@ -2127,6 +2209,7 @@ fn list_keep_errs() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_map_with_index() {
assert_evals_to!(
"List.mapWithIndex [0,0,0] (\\index, x -> Num.intCast index + x)",
@ -2136,6 +2219,7 @@ fn list_map_with_index() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = r#"Roc failed with message: "integer addition overflowed!"#)]
fn cleanup_because_exception() {
assert_evals_to!(
@ -2155,6 +2239,7 @@ fn cleanup_because_exception() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_range() {
assert_evals_to!("List.range 0 -1", RocList::from_slice(&[]), RocList<i64>);
assert_evals_to!("List.range 0 0", RocList::from_slice(&[0]), RocList<i64>);
@ -2166,6 +2251,7 @@ fn list_range() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_sort_with() {
assert_evals_to!(
"List.sortWith [] Num.compare",
@ -2185,6 +2271,7 @@ fn list_sort_with() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_any() {
assert_evals_to!("List.any [] (\\e -> e > 3)", false, bool);
assert_evals_to!("List.any [ 1, 2, 3 ] (\\e -> e > 3)", false, bool);
@ -2192,6 +2279,7 @@ fn list_any() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn list_any_empty_with_unknown_element_type() {
// Segfaults with invalid memory reference. Running this as a stand-alone
@ -2204,6 +2292,7 @@ fn list_any_empty_with_unknown_element_type() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = r#"Roc failed with message: "invalid ret_layout""#)]
fn lists_with_incompatible_type_param_in_if() {
assert_evals_to!(
@ -2224,6 +2313,7 @@ fn lists_with_incompatible_type_param_in_if() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn map_with_index_multi_record() {
// see https://github.com/rtfeldman/roc/issues/1700
assert_evals_to!(
@ -2238,6 +2328,7 @@ fn map_with_index_multi_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn empty_list_of_function_type() {
// see https://github.com/rtfeldman/roc/issues/1732
assert_evals_to!(
@ -2266,6 +2357,7 @@ fn empty_list_of_function_type() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_map() {
assert_evals_to!(
indoc!(
@ -2285,6 +2377,7 @@ fn list_join_map() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_join_map_empty() {
assert_evals_to!(
indoc!(

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

File diff suppressed because it is too large Load diff

137
compiler/test_gen/src/gen_primitives.rs
View file

@ -1,22 +1,41 @@
#![cfg(test)]
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_llvm_evals_to;
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_non_opt_evals_to;
#[cfg(feature = "gen-dev")]
use crate::helpers::dev::assert_evals_to;
// #[cfg(feature = "gen-dev")]
// use crate::helpers::dev::assert_evals_to as assert_llvm_evals_to;
// #[cfg(feature = "gen-dev")]
// use crate::helpers::dev::assert_evals_to as assert_non_opt_evals_to;
#[cfg(feature = "gen-wasm")]
use crate::helpers::wasm::assert_evals_to;
// #[cfg(feature = "gen-wasm")]
// use crate::helpers::wasm::assert_evals_to as assert_llvm_evals_to;
// #[cfg(feature = "gen-wasm")]
// use crate::helpers::wasm::assert_evals_to as assert_non_opt_evals_to;
use crate::assert_evals_to;
use crate::assert_llvm_evals_to;
use crate::assert_non_opt_evals_to;
use indoc::indoc;
use roc_std::RocStr;
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn basic_int() {
assert_evals_to!("123", 123, i64);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn basic_float() {
assert_evals_to!("1234.0", 1234.0, f64);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn branch_first_float() {
assert_evals_to!(
indoc!(
@ -32,6 +51,7 @@ fn branch_first_float() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn branch_second_float() {
assert_evals_to!(
indoc!(
@ -47,6 +67,7 @@ fn branch_second_float() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn branch_third_float() {
assert_evals_to!(
indoc!(
@ -63,6 +84,7 @@ fn branch_third_float() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn branch_first_int() {
assert_evals_to!(
indoc!(
@ -78,6 +100,7 @@ fn branch_first_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn branch_second_int() {
assert_evals_to!(
indoc!(
@ -93,6 +116,7 @@ fn branch_second_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn branch_third_int() {
assert_evals_to!(
indoc!(
@ -109,6 +133,7 @@ fn branch_third_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn branch_store_variable() {
assert_evals_to!(
indoc!(
@ -124,6 +149,7 @@ fn branch_store_variable() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn when_one_element_tag() {
assert_evals_to!(
indoc!(
@ -141,6 +167,7 @@ fn when_one_element_tag() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_two_element_tag_first() {
assert_evals_to!(
indoc!(
@ -159,6 +186,7 @@ fn when_two_element_tag_first() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_two_element_tag_second() {
assert_evals_to!(
indoc!(
@ -177,6 +205,7 @@ fn when_two_element_tag_second() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn gen_when_one_branch() {
assert_evals_to!(
indoc!(
@ -191,6 +220,7 @@ fn gen_when_one_branch() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_large_when_int() {
assert_evals_to!(
indoc!(
@ -213,6 +243,7 @@ fn gen_large_when_int() {
}
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn gen_large_when_float() {
// assert_evals_to!(
// indoc!(
@ -235,6 +266,7 @@ fn gen_large_when_int() {
// }
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn or_pattern() {
assert_evals_to!(
indoc!(
@ -250,6 +282,7 @@ fn or_pattern() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn apply_identity() {
assert_evals_to!(
indoc!(
@ -265,6 +298,7 @@ fn apply_identity() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn apply_unnamed_identity() {
assert_evals_to!(
indoc!(
@ -281,6 +315,7 @@ fn apply_unnamed_identity() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn return_unnamed_fn() {
assert_evals_to!(
indoc!(
@ -301,6 +336,7 @@ fn return_unnamed_fn() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_when_fn() {
assert_evals_to!(
indoc!(
@ -320,6 +356,7 @@ fn gen_when_fn() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn gen_basic_def() {
assert_evals_to!(
indoc!(
@ -347,6 +384,7 @@ fn gen_basic_def() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_multiple_defs() {
assert_evals_to!(
indoc!(
@ -380,6 +418,7 @@ fn gen_multiple_defs() {
// These tests caught a bug in how Defs are converted to the mono IR
// but they have UnusedDef or UnusedArgument problems, and don't run any more
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn gen_chained_defs() {
// assert_evals_to!(
// indoc!(
@ -399,6 +438,7 @@ fn gen_multiple_defs() {
// }
//
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn gen_nested_defs_old() {
// assert_evals_to!(
// indoc!(
@ -440,6 +480,7 @@ fn gen_multiple_defs() {
// }
//
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn let_x_in_x() {
// assert_evals_to!(
// indoc!(
@ -462,6 +503,7 @@ fn gen_multiple_defs() {
// }
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn factorial() {
assert_evals_to!(
indoc!(
@ -483,6 +525,7 @@ fn factorial() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn peano1() {
assert_non_opt_evals_to!(
indoc!(
@ -503,6 +546,7 @@ fn peano1() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn peano2() {
assert_non_opt_evals_to!(
indoc!(
@ -524,6 +568,7 @@ fn peano2() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn top_level_constant() {
assert_evals_to!(
indoc!(
@ -542,6 +587,7 @@ fn top_level_constant() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_len_0() {
assert_non_opt_evals_to!(
indoc!(
@ -569,6 +615,7 @@ fn linked_list_len_0() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_len_twice_0() {
assert_non_opt_evals_to!(
indoc!(
@ -596,6 +643,7 @@ fn linked_list_len_twice_0() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_len_1() {
assert_non_opt_evals_to!(
indoc!(
@ -623,6 +671,7 @@ fn linked_list_len_1() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_len_twice_1() {
assert_non_opt_evals_to!(
indoc!(
@ -650,6 +699,7 @@ fn linked_list_len_twice_1() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_len_3() {
assert_non_opt_evals_to!(
indoc!(
@ -678,6 +728,7 @@ fn linked_list_len_3() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_sum_num_a() {
assert_non_opt_evals_to!(
indoc!(
@ -706,6 +757,7 @@ fn linked_list_sum_num_a() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_sum_int() {
assert_non_opt_evals_to!(
indoc!(
@ -733,6 +785,7 @@ fn linked_list_sum_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_map() {
assert_non_opt_evals_to!(
indoc!(
@ -766,6 +819,7 @@ fn linked_list_map() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_nested_maybe() {
assert_evals_to!(
indoc!(
@ -822,6 +876,7 @@ fn when_nested_maybe() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_peano() {
assert_non_opt_evals_to!(
indoc!(
@ -879,6 +934,7 @@ fn when_peano() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "Roc failed with message: ")]
fn overflow_frees_list() {
assert_evals_to!(
@ -903,6 +959,7 @@ fn overflow_frees_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "Roc failed with message: ")]
fn undefined_variable() {
assert_evals_to!(
@ -920,6 +977,7 @@ fn undefined_variable() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "Roc failed with message: ")]
fn annotation_without_body() {
assert_evals_to!(
@ -937,6 +995,7 @@ fn annotation_without_body() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn simple_closure() {
assert_evals_to!(
indoc!(
@ -958,6 +1017,7 @@ fn simple_closure() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_closure() {
assert_evals_to!(
indoc!(
@ -981,6 +1041,7 @@ fn nested_closure() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn closure_in_list() {
assert_evals_to!(
indoc!(
@ -1006,6 +1067,7 @@ fn closure_in_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn specialize_closure() {
use roc_std::RocList;
@ -1037,6 +1099,7 @@ fn specialize_closure() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn io_poc_effect() {
assert_non_opt_evals_to!(
indoc!(
@ -1067,6 +1130,7 @@ fn io_poc_effect() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn io_poc_desugared() {
assert_evals_to!(
indoc!(
@ -1094,6 +1158,7 @@ fn io_poc_desugared() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn return_wrapped_function_pointer() {
assert_non_opt_evals_to!(
indoc!(
@ -1116,6 +1181,7 @@ fn return_wrapped_function_pointer() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn return_wrapped_function_pointer_b() {
assert_non_opt_evals_to!(
indoc!(
@ -1137,6 +1203,7 @@ fn return_wrapped_function_pointer_b() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn return_wrapped_closure() {
assert_non_opt_evals_to!(
indoc!(
@ -1162,6 +1229,7 @@ fn return_wrapped_closure() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_is_singleton() {
assert_non_opt_evals_to!(
indoc!(
@ -1196,6 +1264,7 @@ fn linked_list_is_singleton() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_is_empty_1() {
assert_non_opt_evals_to!(
indoc!(
@ -1230,6 +1299,7 @@ fn linked_list_is_empty_1() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_is_empty_2() {
assert_non_opt_evals_to!(
indoc!(
@ -1261,6 +1331,7 @@ fn linked_list_is_empty_2() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_singleton() {
// verifies only that valid llvm is produced
assert_non_opt_evals_to!(
@ -1281,6 +1352,7 @@ fn linked_list_singleton() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn recursive_function_with_rigid() {
assert_non_opt_evals_to!(
indoc!(
@ -1307,6 +1379,7 @@ fn recursive_function_with_rigid() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn rbtree_insert() {
assert_non_opt_evals_to!(
indoc!(
@ -1394,6 +1467,7 @@ fn rbtree_insert() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn rbtree_balance_3() {
assert_non_opt_evals_to!(
indoc!(
@ -1418,6 +1492,7 @@ fn rbtree_balance_3() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn rbtree_layout_issue() {
// there is a flex var in here somewhere that blows up layout creation
@ -1459,6 +1534,7 @@ fn rbtree_layout_issue() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn rbtree_balance_mono_problem() {
// because of how the function is written, only `Red` is used and so in the function's
@ -1512,6 +1588,7 @@ fn rbtree_balance_mono_problem() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn rbtree_balance_full() {
assert_non_opt_evals_to!(
indoc!(
@ -1563,6 +1640,7 @@ fn rbtree_balance_full() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_pattern_match_two_ways() {
// exposed an issue in the ordering of pattern match checks when ran with `--release` mode
assert_non_opt_evals_to!(
@ -1616,6 +1694,7 @@ fn nested_pattern_match_two_ways() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_guarded_double_pattern_match() {
// the important part here is that the first case (with the nested Cons) does not match
// TODO this also has undefined behavior
@ -1647,6 +1726,7 @@ fn linked_list_guarded_double_pattern_match() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn linked_list_double_pattern_match() {
assert_non_opt_evals_to!(
indoc!(
@ -1672,6 +1752,7 @@ fn linked_list_double_pattern_match() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn binary_tree_double_pattern_match() {
assert_non_opt_evals_to!(
indoc!(
@ -1697,6 +1778,7 @@ fn binary_tree_double_pattern_match() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn unified_empty_closure_bool() {
// none of the Closure tags will have a payload
// this was not handled correctly in the past
@ -1721,6 +1803,7 @@ fn unified_empty_closure_bool() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn unified_empty_closure_byte() {
// none of the Closure tags will have a payload
// this was not handled correctly in the past
@ -1746,6 +1829,7 @@ fn unified_empty_closure_byte() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn task_always_twice() {
assert_non_opt_evals_to!(
indoc!(
@ -1790,6 +1874,7 @@ fn task_always_twice() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn wildcard_rigid() {
assert_non_opt_evals_to!(
indoc!(
@ -1819,6 +1904,7 @@ fn wildcard_rigid() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn todo_bad_error_message() {
assert_non_opt_evals_to!(
@ -1866,6 +1952,7 @@ fn todo_bad_error_message() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn hof_conditional() {
// exposed issue with the if condition being just a symbol
assert_evals_to!(
@ -1882,6 +1969,7 @@ fn hof_conditional() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(
expected = "Roc failed with message: \"Shadowing { original_region: |L 3-3, C 4-5|, shadow: |L 6-6, C 8-9| Ident"
)]
@ -1901,6 +1989,7 @@ fn pattern_shadowing() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "TODO non-exhaustive pattern")]
fn non_exhaustive_pattern_let() {
assert_evals_to!(
@ -1920,6 +2009,7 @@ fn non_exhaustive_pattern_let() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
#[should_panic(expected = "")]
fn unsupported_pattern_str_interp() {
@ -1937,6 +2027,7 @@ fn unsupported_pattern_str_interp() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn fingertree_basic() {
assert_non_opt_evals_to!(
@ -1978,6 +2069,7 @@ fn fingertree_basic() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn case_or_pattern() {
// the `0` branch body should only be generated once in the future
// it is currently duplicated
@ -1998,6 +2090,7 @@ fn case_or_pattern() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn rosetree_basic() {
assert_non_opt_evals_to!(
@ -2025,6 +2118,7 @@ fn rosetree_basic() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn case_jump() {
// the decision tree will generate a jump to the `1` branch here
assert_evals_to!(
@ -2050,6 +2144,7 @@ fn case_jump() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nullable_eval_cfold() {
// the decision tree will generate a jump to the `1` branch here
assert_evals_to!(
@ -2086,6 +2181,7 @@ fn nullable_eval_cfold() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_switch() {
// exposed bug with passing the right symbol/layout down into switch branch generation
assert_evals_to!(
@ -2128,6 +2224,7 @@ fn nested_switch() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn count_deriv_x() {
// exposed bug with basing the block_of_memory on a specific (smaller) tag layout
assert_evals_to!(
@ -2154,6 +2251,7 @@ fn count_deriv_x() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn deriv_pow() {
// exposed bug with ordering of variable declarations before switch
assert_evals_to!(
@ -2190,6 +2288,7 @@ fn deriv_pow() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn multiple_increment() {
// the `leaf` value will be incremented multiple times at once
assert_evals_to!(
@ -2223,6 +2322,7 @@ fn multiple_increment() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn switch_fuse_rc_non_exhaustive() {
assert_evals_to!(
indoc!(
@ -2252,6 +2352,7 @@ fn switch_fuse_rc_non_exhaustive() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn switch_fuse_rc_exhaustive() {
assert_evals_to!(
indoc!(
@ -2280,6 +2381,7 @@ fn switch_fuse_rc_exhaustive() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn build_then_apply_closure() {
assert_evals_to!(
indoc!(
@ -2299,6 +2401,7 @@ fn build_then_apply_closure() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn expanded_result() {
assert_evals_to!(
indoc!(
@ -2329,6 +2432,7 @@ fn expanded_result() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn backpassing_result() {
assert_evals_to!(
@ -2362,6 +2466,7 @@ fn backpassing_result() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
#[should_panic(
expected = "Shadowing { original_region: |L 3-3, C 4-5|, shadow: |L 5-5, C 6-7| Ident"
)]
@ -2380,6 +2485,7 @@ fn function_malformed_pattern() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "Hit an erroneous type when creating a layout for")]
fn call_invalid_layout() {
assert_llvm_evals_to!(
@ -2399,6 +2505,7 @@ fn call_invalid_layout() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "An expectation failed!")]
fn expect_fail() {
assert_evals_to!(
@ -2415,6 +2522,7 @@ fn expect_fail() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn increment_or_double_closure() {
assert_evals_to!(
indoc!(
@ -2452,6 +2560,7 @@ fn increment_or_double_closure() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn module_thunk_is_function() {
assert_evals_to!(
indoc!(
@ -2468,6 +2577,7 @@ fn module_thunk_is_function() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "Roc failed with message: ")]
fn hit_unresolved_type_variable() {
assert_evals_to!(
@ -2491,6 +2601,7 @@ fn hit_unresolved_type_variable() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn pattern_match_empty_record() {
assert_evals_to!(
indoc!(
@ -2510,6 +2621,7 @@ fn pattern_match_empty_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn pattern_match_unit_tag() {
assert_evals_to!(
indoc!(
@ -2534,6 +2646,7 @@ fn pattern_match_unit_tag() {
// see for why this is disabled on wasm32 https://github.com/rtfeldman/roc/issues/1687
#[cfg(not(feature = "wasm-cli-run"))]
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn mirror_llvm_alignment_padding() {
// see https://github.com/rtfeldman/roc/issues/1569
assert_evals_to!(
@ -2556,6 +2669,7 @@ fn mirror_llvm_alignment_padding() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn lambda_set_bool() {
assert_evals_to!(
indoc!(
@ -2580,6 +2694,7 @@ fn lambda_set_bool() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn lambda_set_byte() {
assert_evals_to!(
indoc!(
@ -2605,6 +2720,7 @@ fn lambda_set_byte() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn lambda_set_struct_byte() {
assert_evals_to!(
indoc!(
@ -2632,6 +2748,7 @@ fn lambda_set_struct_byte() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn lambda_set_enum_byte_byte() {
assert_evals_to!(
indoc!(
@ -2662,6 +2779,7 @@ fn lambda_set_enum_byte_byte() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn list_walk_until() {
// see https://github.com/rtfeldman/roc/issues/1576
assert_evals_to!(
@ -2687,6 +2805,7 @@ fn list_walk_until() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn int_literal_not_specialized_with_annotation() {
// see https://github.com/rtfeldman/roc/issues/1600
assert_evals_to!(
@ -2714,6 +2833,7 @@ fn int_literal_not_specialized_with_annotation() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn int_literal_not_specialized_no_annotation() {
// see https://github.com/rtfeldman/roc/issues/1600
assert_evals_to!(
@ -2740,6 +2860,7 @@ fn int_literal_not_specialized_no_annotation() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn unresolved_tvar_when_capture_is_unused() {
// see https://github.com/rtfeldman/roc/issues/1585
assert_evals_to!(
@ -2766,6 +2887,7 @@ fn unresolved_tvar_when_capture_is_unused() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "Roc failed with message: ")]
fn value_not_exposed_hits_panic() {
assert_evals_to!(
@ -2784,6 +2906,7 @@ fn value_not_exposed_hits_panic() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn mix_function_and_closure() {
// see https://github.com/rtfeldman/roc/pull/1706
assert_evals_to!(
@ -2809,6 +2932,7 @@ fn mix_function_and_closure() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn mix_function_and_closure_level_of_indirection() {
// see https://github.com/rtfeldman/roc/pull/1706
assert_evals_to!(
@ -2833,6 +2957,7 @@ fn mix_function_and_closure_level_of_indirection() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn do_pass_bool_byte_closure_layout() {
// see https://github.com/rtfeldman/roc/pull/1706
// the distinction is actually important, dropping that info means some functions just get
@ -2908,6 +3033,7 @@ fn do_pass_bool_byte_closure_layout() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_rigid_list() {
assert_evals_to!(
indoc!(
@ -2932,6 +3058,7 @@ fn nested_rigid_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn nested_rigid_alias() {
assert_evals_to!(
indoc!(
@ -2958,6 +3085,7 @@ fn nested_rigid_alias() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn nested_rigid_tag_union() {
assert_evals_to!(
indoc!(
@ -2982,6 +3110,7 @@ fn nested_rigid_tag_union() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn call_that_needs_closure_parameter() {
// here both p2 is lifted to the top-level, which means that `list` must be
// passed to it from `manyAux`.

66
compiler/test_gen/src/gen_records.rs
View file

@ -1,10 +1,17 @@
#![cfg(test)]
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
#[cfg(feature = "gen-dev")]
use crate::helpers::dev::assert_evals_to;
#[cfg(feature = "gen-wasm")]
use crate::helpers::wasm::assert_evals_to;
use crate::assert_evals_to;
// use crate::assert_wasm_evals_to as assert_evals_to;
use indoc::indoc;
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn basic_record() {
assert_evals_to!(
indoc!(
@ -38,6 +45,7 @@ fn basic_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn f64_record() {
assert_evals_to!(
indoc!(
@ -77,6 +85,7 @@ fn f64_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn fn_record() {
assert_evals_to!(
indoc!(
@ -128,6 +137,7 @@ fn fn_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn def_record() {
assert_evals_to!(
indoc!(
@ -167,6 +177,7 @@ fn def_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn when_on_record() {
assert_evals_to!(
indoc!(
@ -181,6 +192,7 @@ fn when_on_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn when_record_with_guard_pattern() {
assert_evals_to!(
indoc!(
@ -195,6 +207,7 @@ fn when_record_with_guard_pattern() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn let_with_record_pattern() {
assert_evals_to!(
indoc!(
@ -210,6 +223,7 @@ fn let_with_record_pattern() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn record_guard_pattern() {
assert_evals_to!(
indoc!(
@ -225,6 +239,7 @@ fn record_guard_pattern() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn twice_record_access() {
assert_evals_to!(
indoc!(
@ -239,6 +254,7 @@ fn twice_record_access() {
);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-dev"))]
fn empty_record() {
assert_evals_to!(
indoc!(
@ -253,6 +269,7 @@ fn empty_record() {
);
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn i64_record2_literal() {
assert_evals_to!(
indoc!(
@ -266,6 +283,7 @@ fn i64_record2_literal() {
}
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn i64_record3_literal() {
// assert_evals_to!(
// indoc!(
@ -277,8 +295,8 @@ fn i64_record2_literal() {
// (i64, i64, i64)
// );
// }
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn f64_record2_literal() {
assert_evals_to!(
indoc!(
@ -292,6 +310,7 @@ fn f64_record2_literal() {
}
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn f64_record3_literal() {
// assert_evals_to!(
// indoc!(
@ -305,6 +324,7 @@ fn f64_record2_literal() {
// }
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn bool_record4_literal() {
// assert_evals_to!(
// indoc!(
@ -319,8 +339,8 @@ fn f64_record2_literal() {
// (bool, bool, bool, bool)
// );
// }
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn i64_record1_literal() {
assert_evals_to!(
indoc!(
@ -334,6 +354,7 @@ fn i64_record1_literal() {
}
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn i64_record9_literal() {
// assert_evals_to!(
// indoc!(
@ -347,6 +368,7 @@ fn i64_record1_literal() {
// }
// #[test]
// #[cfg(any(feature = "gen-llvm"))]
// fn f64_record3_literal() {
// assert_evals_to!(
// indoc!(
@ -358,8 +380,8 @@ fn i64_record1_literal() {
// (f64, f64, f64)
// );
// }
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn bool_literal() {
assert_evals_to!(
indoc!(
@ -376,6 +398,7 @@ fn bool_literal() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record() {
assert_evals_to!(
indoc!(
@ -392,6 +415,7 @@ fn return_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn optional_field_when_use_default() {
assert_evals_to!(
indoc!(
@ -419,6 +443,7 @@ fn optional_field_when_use_default() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn optional_field_when_use_default_nested() {
assert_evals_to!(
indoc!(
@ -442,6 +467,7 @@ fn optional_field_when_use_default_nested() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn optional_field_when_no_use_default() {
assert_evals_to!(
indoc!(
@ -462,6 +488,7 @@ fn optional_field_when_no_use_default() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn optional_field_when_no_use_default_nested() {
assert_evals_to!(
indoc!(
@ -479,6 +506,7 @@ fn optional_field_when_no_use_default_nested() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn optional_field_let_use_default() {
assert_evals_to!(
indoc!(
@ -499,6 +527,7 @@ fn optional_field_let_use_default() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn optional_field_let_no_use_default() {
assert_evals_to!(
indoc!(
@ -519,6 +548,7 @@ fn optional_field_let_no_use_default() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn optional_field_let_no_use_default_nested() {
assert_evals_to!(
indoc!(
@ -536,6 +566,7 @@ fn optional_field_let_no_use_default_nested() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn optional_field_function_use_default() {
assert_evals_to!(
indoc!(
@ -552,6 +583,7 @@ fn optional_field_function_use_default() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn optional_field_function_no_use_default() {
// blocked on https://github.com/rtfeldman/roc/issues/786
@ -572,6 +604,7 @@ fn optional_field_function_no_use_default() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn optional_field_function_no_use_default_nested() {
// blocked on https://github.com/rtfeldman/roc/issues/786
@ -590,6 +623,7 @@ fn optional_field_function_no_use_default_nested() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn optional_field_singleton_record() {
assert_evals_to!(
indoc!(
@ -604,6 +638,7 @@ fn optional_field_singleton_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn optional_field_empty_record() {
assert_evals_to!(
indoc!(
@ -618,6 +653,7 @@ fn optional_field_empty_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_2() {
assert_evals_to!(
indoc!(
@ -631,6 +667,7 @@ fn return_record_2() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_3() {
assert_evals_to!(
indoc!(
@ -644,6 +681,7 @@ fn return_record_3() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_4() {
assert_evals_to!(
indoc!(
@ -657,6 +695,7 @@ fn return_record_4() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_5() {
assert_evals_to!(
indoc!(
@ -670,6 +709,7 @@ fn return_record_5() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_6() {
assert_evals_to!(
indoc!(
@ -683,6 +723,7 @@ fn return_record_6() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_7() {
assert_evals_to!(
indoc!(
@ -696,6 +737,7 @@ fn return_record_7() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_float_int() {
assert_evals_to!(
indoc!(
@ -709,6 +751,7 @@ fn return_record_float_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_int_float() {
assert_evals_to!(
indoc!(
@ -722,6 +765,7 @@ fn return_record_int_float() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_float_float() {
assert_evals_to!(
indoc!(
@ -735,6 +779,7 @@ fn return_record_float_float() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_record_float_float_float() {
assert_evals_to!(
indoc!(
@ -748,6 +793,7 @@ fn return_record_float_float_float() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-wasm"))]
fn return_nested_record() {
assert_evals_to!(
indoc!(
@ -761,11 +807,13 @@ fn return_nested_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn accessor_twice() {
assert_evals_to!(".foo { foo: 4 } + .foo { bar: 6.28, foo: 3 } ", 7, i64);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn accessor_multi_element_record() {
assert_evals_to!(
indoc!(
@ -779,6 +827,7 @@ fn accessor_multi_element_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn accessor_single_element_record() {
assert_evals_to!(
indoc!(
@ -792,6 +841,7 @@ fn accessor_single_element_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn update_record() {
assert_evals_to!(
indoc!(
@ -807,6 +857,7 @@ fn update_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn update_single_element_record() {
assert_evals_to!(
indoc!(
@ -822,6 +873,7 @@ fn update_single_element_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn booleans_in_record() {
assert_evals_to!(
indoc!("{ x: 1 == 1, y: 1 == 1 }"),
@ -846,6 +898,7 @@ fn booleans_in_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn alignment_in_record() {
assert_evals_to!(
indoc!("{ c: 32, b: if True then Red else if True then Green else Blue, a: 1 == 1 }"),
@ -855,6 +908,7 @@ fn alignment_in_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn blue_and_present() {
assert_evals_to!(
indoc!(
@ -873,6 +927,7 @@ fn blue_and_present() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn blue_and_absent() {
assert_evals_to!(
indoc!(
@ -891,6 +946,7 @@ fn blue_and_absent() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev", feature = "gen-wasm"))]
fn update_the_only_field() {
assert_evals_to!(
indoc!(

18
compiler/test_gen/src/gen_result.rs
View file

@ -1,9 +1,18 @@
#![cfg(test)]
#![cfg(feature = "gen-llvm")]
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
// #[cfg(feature = "gen-dev")]
// use crate::helpers::dev::assert_evals_to;
// #[cfg(feature = "gen-wasm")]
// use crate::helpers::wasm::assert_evals_to;
use crate::assert_evals_to;
use indoc::indoc;
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn with_default() {
assert_evals_to!(
indoc!(
@ -33,6 +42,7 @@ fn with_default() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn result_map() {
assert_evals_to!(
indoc!(
@ -66,6 +76,7 @@ fn result_map() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn result_map_err() {
assert_evals_to!(
indoc!(
@ -99,6 +110,7 @@ fn result_map_err() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn err_type_var() {
assert_evals_to!(
indoc!(
@ -113,6 +125,7 @@ fn err_type_var() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn err_type_var_annotation() {
assert_evals_to!(
indoc!(
@ -130,6 +143,7 @@ fn err_type_var_annotation() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn err_empty_tag_union() {
assert_evals_to!(
indoc!(

23
compiler/test_gen/src/gen_set.rs
View file

@ -1,10 +1,19 @@
#![cfg(test)]
#![cfg(feature = "gen-llvm")]
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
// #[cfg(feature = "gen-dev")]
// use crate::helpers::dev::assert_evals_to;
// #[cfg(feature = "gen-wasm")]
// use crate::helpers::wasm::assert_evals_to;
use crate::assert_evals_to;
use indoc::indoc;
use roc_std::RocList;
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn empty_len() {
assert_evals_to!(
indoc!(
@ -18,6 +27,7 @@ fn empty_len() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn single_len() {
assert_evals_to!(
indoc!(
@ -31,6 +41,7 @@ fn single_len() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn single_to_list() {
assert_evals_to!(
indoc!(
@ -64,6 +75,7 @@ fn single_to_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn insert() {
assert_evals_to!(
indoc!(
@ -81,6 +93,7 @@ fn insert() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn remove() {
assert_evals_to!(
indoc!(
@ -99,6 +112,7 @@ fn remove() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn union() {
assert_evals_to!(
indoc!(
@ -119,6 +133,7 @@ fn union() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn difference() {
assert_evals_to!(
indoc!(
@ -139,6 +154,7 @@ fn difference() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn intersection() {
assert_evals_to!(
indoc!(
@ -159,6 +175,7 @@ fn intersection() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn walk_sum() {
assert_evals_to!(
indoc!(
@ -172,6 +189,7 @@ fn walk_sum() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn contains() {
assert_evals_to!(
indoc!(
@ -195,6 +213,7 @@ fn contains() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn from_list() {
assert_evals_to!(
indoc!(

89
compiler/test_gen/src/gen_str.rs
View file

@ -1,11 +1,22 @@
#![cfg(test)]
#![cfg(not(feature = "gen-wasm"))]
use crate::assert_evals_to;
use crate::assert_llvm_evals_to;
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_llvm_evals_to;
#[cfg(feature = "gen-dev")]
use crate::helpers::dev::assert_evals_to;
#[cfg(feature = "gen-dev")]
use crate::helpers::dev::assert_evals_to as assert_llvm_evals_to;
#[allow(unused_imports)]
use indoc::indoc;
#[allow(unused_imports)]
use roc_std::{RocList, RocStr};
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_bigger_delimiter_small_str() {
assert_evals_to!(
indoc!(
@ -35,6 +46,7 @@ fn str_split_bigger_delimiter_small_str() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_str_concat_repeated() {
assert_evals_to!(
indoc!(
@ -58,6 +70,7 @@ fn str_split_str_concat_repeated() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_small_str_bigger_delimiter() {
assert_evals_to!(
indoc!(
@ -76,6 +89,7 @@ fn str_split_small_str_bigger_delimiter() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_big_str_small_delimiter() {
assert_evals_to!(
indoc!(
@ -105,6 +119,7 @@ fn str_split_big_str_small_delimiter() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_small_str_small_delimiter() {
assert_evals_to!(
indoc!(
@ -122,6 +137,7 @@ fn str_split_small_str_small_delimiter() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_bigger_delimiter_big_strs() {
assert_evals_to!(
indoc!(
@ -137,6 +153,7 @@ fn str_split_bigger_delimiter_big_strs() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_empty_strs() {
assert_evals_to!(
indoc!(
@ -150,6 +167,7 @@ fn str_split_empty_strs() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_minimal_example() {
assert_evals_to!(
indoc!(
@ -163,6 +181,7 @@ fn str_split_minimal_example() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_small_str_big_delimiter() {
assert_evals_to!(
indoc!(
@ -195,6 +214,7 @@ fn str_split_small_str_big_delimiter() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_split_small_str_20_char_delimiter() {
assert_evals_to!(
indoc!(
@ -214,6 +234,7 @@ fn str_split_small_str_20_char_delimiter() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_concat_big_to_big() {
assert_evals_to!(
indoc!(
@ -229,6 +250,7 @@ fn str_concat_big_to_big() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn small_str_literal() {
assert_llvm_evals_to!(
"\"JJJJJJJJJJJJJJJ\"",
@ -255,6 +277,7 @@ fn small_str_literal() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn small_str_zeroed_literal() {
// Verifies that we zero out unused bytes in the string.
// This is important so that string equality tests don't randomly
@ -284,6 +307,7 @@ fn small_str_zeroed_literal() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn small_str_concat_empty_first_arg() {
assert_llvm_evals_to!(
r#"Str.concat "" "JJJJJJJJJJJJJJJ""#,
@ -310,6 +334,7 @@ fn small_str_concat_empty_first_arg() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn small_str_concat_empty_second_arg() {
assert_llvm_evals_to!(
r#"Str.concat "JJJJJJJJJJJJJJJ" """#,
@ -336,6 +361,7 @@ fn small_str_concat_empty_second_arg() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn small_str_concat_small_to_big() {
assert_evals_to!(
r#"Str.concat "abc" " this is longer than 15 chars""#,
@ -345,6 +371,7 @@ fn small_str_concat_small_to_big() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn small_str_concat_small_to_small_staying_small() {
assert_llvm_evals_to!(
r#"Str.concat "J" "JJJJJJJJJJJJJJ""#,
@ -371,6 +398,7 @@ fn small_str_concat_small_to_small_staying_small() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn small_str_concat_small_to_small_overflow_to_big() {
assert_evals_to!(
r#"Str.concat "abcdefghijklm" "nopqrstuvwxyz""#,
@ -380,16 +408,19 @@ fn small_str_concat_small_to_small_overflow_to_big() {
}
#[test]
#[cfg(any(feature = "gen-llvm", feature = "gen-dev"))]
fn str_concat_empty() {
assert_evals_to!(r#"Str.concat "" """#, RocStr::default(), RocStr);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn small_str_is_empty() {
assert_evals_to!(r#"Str.isEmpty "abc""#, false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn big_str_is_empty() {
assert_evals_to!(
r#"Str.isEmpty "this is more than 15 chars long""#,
@ -399,11 +430,13 @@ fn big_str_is_empty() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn empty_str_is_empty() {
assert_evals_to!(r#"Str.isEmpty """#, true, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_starts_with() {
assert_evals_to!(r#"Str.startsWith "hello world" "hell""#, true, bool);
assert_evals_to!(r#"Str.startsWith "hello world" """#, true, bool);
@ -413,6 +446,7 @@ fn str_starts_with() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_starts_with_code_point() {
assert_evals_to!(
&format!(r#"Str.startsWithCodePt "foobar" {}"#, 'f' as u32),
@ -427,6 +461,7 @@ fn str_starts_with_code_point() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_ends_with() {
assert_evals_to!(r#"Str.endsWith "hello world" "world""#, true, bool);
assert_evals_to!(r#"Str.endsWith "nope" "hello world""#, false, bool);
@ -434,16 +469,19 @@ fn str_ends_with() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_count_graphemes_small_str() {
assert_evals_to!(r#"Str.countGraphemes "å🤔""#, 2, usize);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_count_graphemes_three_js() {
assert_evals_to!(r#"Str.countGraphemes "JJJ""#, 3, usize);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_count_graphemes_big_str() {
assert_evals_to!(
r#"Str.countGraphemes "6🤔å🤔e¥🤔çppkd🙃1jdal🦯asdfa∆ltråø˚waia8918.,🏅jjc""#,
@ -453,6 +491,7 @@ fn str_count_graphemes_big_str() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_starts_with_same_big_str() {
assert_evals_to!(
r#"Str.startsWith "123456789123456789" "123456789123456789""#,
@ -462,6 +501,7 @@ fn str_starts_with_same_big_str() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_starts_with_different_big_str() {
assert_evals_to!(
r#"Str.startsWith "12345678912345678910" "123456789123456789""#,
@ -471,20 +511,24 @@ fn str_starts_with_different_big_str() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_starts_with_same_small_str() {
assert_evals_to!(r#"Str.startsWith "1234" "1234""#, true, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_starts_with_different_small_str() {
assert_evals_to!(r#"Str.startsWith "1234" "12""#, true, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_starts_with_false_small_str() {
assert_evals_to!(r#"Str.startsWith "1234" "23""#, false, bool);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_int() {
assert_evals_to!(
r#"Str.fromInt 1234"#,
@ -518,6 +562,7 @@ fn str_from_int() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_pass_single_ascii() {
assert_evals_to!(
indoc!(
@ -533,6 +578,7 @@ fn str_from_utf8_pass_single_ascii() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_pass_many_ascii() {
assert_evals_to!(
indoc!(
@ -548,6 +594,7 @@ fn str_from_utf8_pass_many_ascii() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_pass_single_unicode() {
assert_evals_to!(
indoc!(
@ -563,6 +610,7 @@ fn str_from_utf8_pass_single_unicode() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_pass_many_unicode() {
assert_evals_to!(
indoc!(
@ -578,6 +626,7 @@ fn str_from_utf8_pass_many_unicode() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_pass_single_grapheme() {
assert_evals_to!(
indoc!(
@ -593,6 +642,7 @@ fn str_from_utf8_pass_single_grapheme() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_pass_many_grapheme() {
assert_evals_to!(
indoc!(
@ -608,6 +658,7 @@ fn str_from_utf8_pass_many_grapheme() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_pass_all() {
assert_evals_to!(
indoc!(
@ -623,6 +674,7 @@ fn str_from_utf8_pass_all() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_fail_invalid_start_byte() {
assert_evals_to!(
indoc!(
@ -642,6 +694,7 @@ fn str_from_utf8_fail_invalid_start_byte() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_fail_unexpected_end_of_sequence() {
assert_evals_to!(
indoc!(
@ -661,6 +714,7 @@ fn str_from_utf8_fail_unexpected_end_of_sequence() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_fail_expected_continuation() {
assert_evals_to!(
indoc!(
@ -680,6 +734,7 @@ fn str_from_utf8_fail_expected_continuation() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_fail_overlong_encoding() {
assert_evals_to!(
indoc!(
@ -699,6 +754,7 @@ fn str_from_utf8_fail_overlong_encoding() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_fail_codepoint_too_large() {
assert_evals_to!(
indoc!(
@ -718,6 +774,7 @@ fn str_from_utf8_fail_codepoint_too_large() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_fail_surrogate_half() {
assert_evals_to!(
indoc!(
@ -737,6 +794,7 @@ fn str_from_utf8_fail_surrogate_half() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_equality() {
assert_evals_to!(r#""a" == "a""#, true, bool);
assert_evals_to!(
@ -761,6 +819,7 @@ fn str_clone() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_recursive_literal() {
assert_evals_to!(
indoc!(
@ -791,6 +850,7 @@ fn nested_recursive_literal() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_join_comma_small() {
assert_evals_to!(
r#"Str.joinWith ["1", "2"] ", " "#,
@ -800,6 +860,7 @@ fn str_join_comma_small() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_join_comma_big() {
assert_evals_to!(
r#"Str.joinWith ["10000000", "2000000", "30000000"] ", " "#,
@ -809,16 +870,19 @@ fn str_join_comma_big() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_join_comma_single() {
assert_evals_to!(r#"Str.joinWith ["1"] ", " "#, RocStr::from("1"), RocStr);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_float() {
assert_evals_to!(r#"Str.fromFloat 3.14"#, RocStr::from("3.14"), RocStr);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_to_utf8() {
assert_evals_to!(
r#"Str.toUtf8 "hello""#,
@ -836,6 +900,7 @@ fn str_to_utf8() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_range() {
assert_evals_to!(
indoc!(
@ -852,6 +917,7 @@ fn str_from_utf8_range() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_range_slice() {
assert_evals_to!(
indoc!(
@ -868,6 +934,7 @@ fn str_from_utf8_range_slice() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_range_slice_not_end() {
assert_evals_to!(
indoc!(
@ -884,6 +951,7 @@ fn str_from_utf8_range_slice_not_end() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_range_order_does_not_matter() {
assert_evals_to!(
indoc!(
@ -900,6 +968,7 @@ fn str_from_utf8_range_order_does_not_matter() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_range_out_of_bounds_start_value() {
assert_evals_to!(
indoc!(
@ -917,6 +986,7 @@ fn str_from_utf8_range_out_of_bounds_start_value() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_range_count_too_high() {
assert_evals_to!(
indoc!(
@ -934,6 +1004,7 @@ fn str_from_utf8_range_count_too_high() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_from_utf8_range_count_too_high_for_start() {
assert_evals_to!(
indoc!(
@ -951,6 +1022,7 @@ fn str_from_utf8_range_count_too_high_for_start() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_repeat_small() {
assert_evals_to!(
indoc!(r#"Str.repeat "Roc" 3"#),
@ -960,6 +1032,7 @@ fn str_repeat_small() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_repeat_big() {
assert_evals_to!(
indoc!(r#"Str.repeat "more than 16 characters" 2"#),
@ -969,26 +1042,31 @@ fn str_repeat_big() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_repeat_empty_string() {
assert_evals_to!(indoc!(r#"Str.repeat "" 3"#), RocStr::from(""), RocStr);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_repeat_zero_times() {
assert_evals_to!(indoc!(r#"Str.repeat "Roc" 0"#), RocStr::from(""), RocStr);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_trim_empty_string() {
assert_evals_to!(indoc!(r#"Str.trim """#), RocStr::from(""), RocStr);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_trim_small_blank_string() {
assert_evals_to!(indoc!(r#"Str.trim " ""#), RocStr::from(""), RocStr);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_trim_small_to_small() {
assert_evals_to!(
indoc!(r#"Str.trim " hello world ""#),
@ -998,6 +1076,7 @@ fn str_trim_small_to_small() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_trim_large_to_large_unique() {
assert_evals_to!(
indoc!(r#"Str.trim (Str.concat " " "hello world from a large string ")"#),
@ -1007,6 +1086,7 @@ fn str_trim_large_to_large_unique() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_trim_large_to_small_unique() {
assert_evals_to!(
indoc!(r#"Str.trim (Str.concat " " "hello world ")"#),
@ -1016,6 +1096,7 @@ fn str_trim_large_to_small_unique() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_trim_large_to_large_shared() {
assert_evals_to!(
indoc!(
@ -1035,6 +1116,7 @@ fn str_trim_large_to_large_shared() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_trim_large_to_small_shared() {
assert_evals_to!(
indoc!(
@ -1054,6 +1136,7 @@ fn str_trim_large_to_small_shared() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn str_trim_small_to_small_shared() {
assert_evals_to!(
indoc!(

72
compiler/test_gen/src/gen_tags.rs
View file

@ -1,11 +1,20 @@
#![cfg(test)]
#![cfg(feature = "gen-llvm")]
#[cfg(feature = "gen-llvm")]
use crate::helpers::llvm::assert_evals_to;
// #[cfg(feature = "gen-dev")]
// use crate::helpers::dev::assert_evals_to;
// #[cfg(feature = "gen-wasm")]
// use crate::helpers::wasm::assert_evals_to;
use crate::assert_evals_to;
// use crate::assert_wasm_evals_to as assert_evals_to;
use indoc::indoc;
use roc_std::{RocList, RocStr};
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn width_and_alignment_u8_u8() {
use roc_mono::layout::Builtin;
use roc_mono::layout::Layout;
@ -23,6 +32,7 @@ fn width_and_alignment_u8_u8() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn applied_tag_nothing_ir() {
assert_evals_to!(
indoc!(
@ -42,6 +52,7 @@ fn applied_tag_nothing_ir() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn applied_tag_nothing() {
assert_evals_to!(
indoc!(
@ -61,6 +72,7 @@ fn applied_tag_nothing() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn applied_tag_just() {
assert_evals_to!(
indoc!(
@ -79,6 +91,7 @@ fn applied_tag_just() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn applied_tag_just_ir() {
assert_evals_to!(
indoc!(
@ -97,6 +110,7 @@ fn applied_tag_just_ir() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn applied_tag_just_enum() {
assert_evals_to!(
indoc!(
@ -120,6 +134,7 @@ fn applied_tag_just_enum() {
}
// #[test]
#[cfg(any(feature = "gen-llvm"))]
// fn raw_result() {
// assert_evals_to!(
// indoc!(
@ -134,8 +149,8 @@ fn applied_tag_just_enum() {
// i8
// );
// }
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn true_is_true() {
assert_evals_to!(
indoc!(
@ -152,6 +167,7 @@ fn true_is_true() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn false_is_false() {
assert_evals_to!(
indoc!(
@ -168,6 +184,7 @@ fn false_is_false() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn basic_enum() {
assert_evals_to!(
indoc!(
@ -189,6 +206,7 @@ fn basic_enum() {
}
// #[test]
#[cfg(any(feature = "gen-llvm"))]
// fn linked_list_empty() {
// assert_evals_to!(
// indoc!(
@ -207,6 +225,7 @@ fn basic_enum() {
// }
//
// #[test]
#[cfg(any(feature = "gen-llvm"))]
// fn linked_list_singleton() {
// assert_evals_to!(
// indoc!(
@ -225,6 +244,7 @@ fn basic_enum() {
// }
//
// #[test]
#[cfg(any(feature = "gen-llvm"))]
// fn linked_list_is_empty() {
// assert_evals_to!(
// indoc!(
@ -244,8 +264,8 @@ fn basic_enum() {
// bool
// );
// }
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn even_odd() {
assert_evals_to!(
indoc!(
@ -271,6 +291,7 @@ fn even_odd() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_literal_true() {
assert_evals_to!(
indoc!(
@ -284,6 +305,7 @@ fn gen_literal_true() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn gen_if_float() {
assert_evals_to!(
indoc!(
@ -296,6 +318,7 @@ fn gen_if_float() {
);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_on_nothing() {
assert_evals_to!(
indoc!(
@ -314,6 +337,7 @@ fn when_on_nothing() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_on_just() {
assert_evals_to!(
indoc!(
@ -332,6 +356,7 @@ fn when_on_just() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_on_result() {
assert_evals_to!(
indoc!(
@ -350,6 +375,7 @@ fn when_on_result() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_on_these() {
assert_evals_to!(
indoc!(
@ -371,6 +397,7 @@ fn when_on_these() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn match_on_two_values() {
// this will produce a Chain internally
assert_evals_to!(
@ -387,6 +414,7 @@ fn match_on_two_values() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn pair_with_guard_pattern() {
assert_evals_to!(
indoc!(
@ -403,6 +431,7 @@ fn pair_with_guard_pattern() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn result_with_guard_pattern() {
// This test revealed an issue with hashing Test values
assert_evals_to!(
@ -423,6 +452,7 @@ fn result_with_guard_pattern() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn maybe_is_just() {
assert_evals_to!(
indoc!(
@ -447,6 +477,7 @@ fn maybe_is_just() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn maybe_is_just_nested() {
assert_evals_to!(
indoc!(
@ -468,6 +499,7 @@ fn maybe_is_just_nested() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_pattern_match() {
assert_evals_to!(
indoc!(
@ -488,6 +520,7 @@ fn nested_pattern_match() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn if_guard_vanilla() {
assert_evals_to!(
indoc!(
@ -503,6 +536,7 @@ fn if_guard_vanilla() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn when_on_single_value_tag() {
// this fails because the switched-on symbol is not defined
@ -520,6 +554,7 @@ fn when_on_single_value_tag() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn if_guard_multiple() {
assert_evals_to!(
indoc!(
@ -540,6 +575,7 @@ fn if_guard_multiple() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn if_guard_constructor_switch() {
assert_evals_to!(
indoc!(
@ -583,6 +619,7 @@ fn if_guard_constructor_switch() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn if_guard_constructor_chain() {
assert_evals_to!(
indoc!(
@ -599,6 +636,7 @@ fn if_guard_constructor_chain() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn if_guard_pattern_false() {
assert_evals_to!(
indoc!(
@ -617,6 +655,7 @@ fn if_guard_pattern_false() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn if_guard_switch() {
assert_evals_to!(
indoc!(
@ -635,6 +674,7 @@ fn if_guard_switch() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn if_guard_pattern_true() {
assert_evals_to!(
indoc!(
@ -653,6 +693,7 @@ fn if_guard_pattern_true() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn if_guard_exhaustiveness() {
assert_evals_to!(
indoc!(
@ -671,6 +712,7 @@ fn if_guard_exhaustiveness() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn when_on_enum() {
assert_evals_to!(
indoc!(
@ -692,6 +734,7 @@ fn when_on_enum() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn pattern_matching_unit() {
assert_evals_to!(
indoc!(
@ -750,6 +793,7 @@ fn pattern_matching_unit() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn one_element_tag() {
assert_evals_to!(
indoc!(
@ -766,6 +810,7 @@ fn one_element_tag() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_tag_union() {
assert_evals_to!(
indoc!(
@ -786,6 +831,7 @@ fn nested_tag_union() {
);
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn unit_type() {
assert_evals_to!(
indoc!(
@ -804,6 +850,7 @@ fn unit_type() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_record_load() {
assert_evals_to!(
indoc!(
@ -821,6 +868,7 @@ fn nested_record_load() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn join_point_if() {
assert_evals_to!(
indoc!(
@ -837,6 +885,7 @@ fn join_point_if() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn join_point_when() {
assert_evals_to!(
indoc!(
@ -862,6 +911,7 @@ fn join_point_when() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn join_point_with_cond_expr() {
assert_evals_to!(
indoc!(
@ -900,6 +950,7 @@ fn join_point_with_cond_expr() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn alignment_in_single_tag_construction() {
assert_evals_to!(indoc!("Three (1 == 1) 32"), (32i64, true), (i64, bool));
@ -911,6 +962,7 @@ fn alignment_in_single_tag_construction() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn alignment_in_single_tag_pattern_match() {
assert_evals_to!(
indoc!(
@ -942,6 +994,7 @@ fn alignment_in_single_tag_pattern_match() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn alignment_in_multi_tag_construction_two() {
assert_evals_to!(
indoc!(
@ -959,6 +1012,7 @@ fn alignment_in_multi_tag_construction_two() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn alignment_in_multi_tag_construction_three() {
assert_evals_to!(
indoc!(
@ -975,6 +1029,7 @@ fn alignment_in_multi_tag_construction_three() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn alignment_in_multi_tag_pattern_match() {
assert_evals_to!(
indoc!(
@ -1013,6 +1068,7 @@ fn alignment_in_multi_tag_pattern_match() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn phantom_polymorphic() {
// see https://github.com/rtfeldman/roc/issues/786 and below
@ -1038,6 +1094,7 @@ fn phantom_polymorphic() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[ignore]
fn phantom_polymorphic_record() {
// see https://github.com/rtfeldman/roc/issues/786
@ -1065,6 +1122,7 @@ fn phantom_polymorphic_record() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn result_never() {
assert_evals_to!(
indoc!(
@ -1086,6 +1144,7 @@ fn result_never() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn nested_recursive_literal() {
assert_evals_to!(
indoc!(
@ -1105,6 +1164,7 @@ fn nested_recursive_literal() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn newtype_wrapper() {
assert_evals_to!(
indoc!(
@ -1128,6 +1188,7 @@ fn newtype_wrapper() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn applied_tag_function() {
assert_evals_to!(
indoc!(
@ -1147,6 +1208,7 @@ fn applied_tag_function() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn applied_tag_function_result() {
assert_evals_to!(
indoc!(
@ -1166,6 +1228,7 @@ fn applied_tag_function_result() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
fn applied_tag_function_linked_list() {
assert_evals_to!(
indoc!(
@ -1186,6 +1249,7 @@ fn applied_tag_function_linked_list() {
}
#[test]
#[cfg(any(feature = "gen-llvm"))]
#[should_panic(expected = "")]
fn tag_must_be_its_own_type() {
assert_evals_to!(

252
compiler/test_gen/src/helpers/dev.rs Normal file
View file

@ -0,0 +1,252 @@
use libloading::Library;
use roc_build::link::{link, LinkType};
use roc_builtins::bitcode;
use roc_can::builtins::builtin_defs_map;
use roc_collections::all::MutMap;
use tempfile::tempdir;
#[allow(dead_code)]
fn promote_expr_to_module(src: &str) -> String {
let mut buffer = String::from("app \"test\" provides [ main ] to \"./platform\"\n\nmain =\n");
for line in src.lines() {
// indent the body!
buffer.push_str(" ");
buffer.push_str(line);
buffer.push('\n');
}
buffer
}
#[allow(dead_code)]
pub fn helper(
arena: &bumpalo::Bump,
src: &str,
stdlib: roc_builtins::std::StdLib,
_leak: bool,
lazy_literals: bool,
) -> (String, Vec<roc_problem::can::Problem>, Library) {
use std::path::{Path, PathBuf};
let dir = tempdir().unwrap();
let filename = PathBuf::from("Test.roc");
let src_dir = Path::new("fake/test/path");
let app_o_file = dir.path().join("app.o");
let module_src;
let temp;
if src.starts_with("app") {
// this is already a module
module_src = src;
} else {
// this is an expression, promote it to a module
temp = promote_expr_to_module(src);
module_src = &temp;
}
let exposed_types = MutMap::default();
let loaded = roc_load::file::load_and_monomorphize_from_str(
arena,
filename,
module_src,
&stdlib,
src_dir,
exposed_types,
8,
builtin_defs_map,
);
let mut loaded = loaded.expect("failed to load module");
use roc_load::file::MonomorphizedModule;
let MonomorphizedModule {
procedures: top_procedures,
interns,
exposed_to_host,
..
} = loaded;
let mut procedures = MutMap::default();
for (key, proc) in top_procedures {
procedures.insert(key, proc);
}
// You can comment and uncomment this block out to get more useful information
// while you're working on the dev backend!
{
// println!("=========== Procedures ==========");
// println!("{:?}", procedures);
// println!("=================================\n");
// println!("=========== Interns ==========");
// println!("{:?}", interns);
// println!("=================================\n");
// println!("=========== Exposed ==========");
// println!("{:?}", exposed_to_host);
// println!("=================================\n");
}
debug_assert_eq!(exposed_to_host.len(), 1);
let main_fn_symbol = loaded.entry_point.symbol;
let main_fn_layout = loaded.entry_point.layout;
let mut layout_ids = roc_mono::layout::LayoutIds::default();
let main_fn_name_base = layout_ids
.get_toplevel(main_fn_symbol, &main_fn_layout)
.to_symbol_string(main_fn_symbol, &interns);
let main_fn_name = format!("roc_{}_exposed", main_fn_name_base);
let mut lines = Vec::new();
// errors whose reporting we delay (so we can see that code gen generates runtime errors)
let mut delayed_errors = Vec::new();
for (home, (module_path, src)) in loaded.sources {
use roc_reporting::report::{
can_problem, mono_problem, type_problem, RocDocAllocator, DEFAULT_PALETTE,
};
let can_problems = loaded.can_problems.remove(&home).unwrap_or_default();
let type_problems = loaded.type_problems.remove(&home).unwrap_or_default();
let mono_problems = loaded.mono_problems.remove(&home).unwrap_or_default();
let error_count = can_problems.len() + type_problems.len() + mono_problems.len();
if error_count == 0 {
continue;
}
let src_lines: Vec<&str> = src.split('\n').collect();
let palette = DEFAULT_PALETTE;
// Report parsing and canonicalization problems
let alloc = RocDocAllocator::new(&src_lines, home, &interns);
use roc_problem::can::Problem::*;
for problem in can_problems.into_iter() {
// Ignore "unused" problems
match problem {
UnusedDef(_, _) | UnusedArgument(_, _, _) | UnusedImport(_, _) => {
delayed_errors.push(problem);
continue;
}
_ => {
let report = can_problem(&alloc, module_path.clone(), problem);
let mut buf = String::new();
report.render_color_terminal(&mut buf, &alloc, &palette);
lines.push(buf);
}
}
}
for problem in type_problems {
if let Some(report) = type_problem(&alloc, module_path.clone(), problem) {
let mut buf = String::new();
report.render_color_terminal(&mut buf, &alloc, &palette);
lines.push(buf);
}
}
for problem in mono_problems {
let report = mono_problem(&alloc, module_path.clone(), problem);
let mut buf = String::new();
report.render_color_terminal(&mut buf, &alloc, &palette);
lines.push(buf);
}
}
if !lines.is_empty() {
println!("{}", lines.join("\n"));
assert_eq!(0, 1, "Mistakes were made");
}
let env = roc_gen_dev::Env {
arena,
interns,
exposed_to_host: exposed_to_host.keys().copied().collect(),
lazy_literals,
generate_allocators: true, // Needed for testing, since we don't have a platform
};
let target = target_lexicon::Triple::host();
let module_object =
roc_gen_dev::build_module(&env, &target, procedures).expect("failed to compile module");
let module_out = module_object
.write()
.expect("failed to build output object");
std::fs::write(&app_o_file, module_out).expect("failed to write object to file");
// std::fs::copy(&app_o_file, "/tmp/app.o").unwrap();
let (mut child, dylib_path) = link(
&target,
app_o_file.clone(),
// Long term we probably want a smarter way to link in zig builtins.
// With the current method all methods are kept and it adds about 100k to all outputs.
&[app_o_file.to_str().unwrap(), bitcode::OBJ_PATH],
LinkType::Dylib,
)
.expect("failed to link dynamic library");
child.wait().unwrap();
// Load the dylib
let path = dylib_path.as_path().to_str().unwrap();
// std::fs::copy(&path, "/tmp/libapp.so").unwrap();
let lib = unsafe { Library::new(path) }.expect("failed to load shared library");
(main_fn_name, delayed_errors, lib)
}
#[allow(unused_macros)]
macro_rules! assert_evals_to {
($src:expr, $expected:expr, $ty:ty) => {{
assert_evals_to!($src, $expected, $ty, (|val| val));
}};
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
// Same as above, except with an additional transformation argument.
{
assert_evals_to!($src, $expected, $ty, $transform, true);
}
};
($src:expr, $expected:expr, $ty:ty, $transform:expr, $leak:expr) => {
// Run both with and without lazy literal optimization.
{
assert_evals_to!($src, $expected, $ty, $transform, $leak, false);
}
{
assert_evals_to!($src, $expected, $ty, $transform, $leak, true);
}
};
($src:expr, $expected:expr, $ty:ty, $transform:expr, $leak:expr, $lazy_literals:expr) => {
use bumpalo::Bump;
use roc_gen_dev::run_jit_function_raw;
let stdlib = roc_builtins::std::standard_stdlib();
let arena = Bump::new();
let (main_fn_name, errors, lib) =
$crate::helpers::dev::helper(&arena, $src, stdlib, $leak, $lazy_literals);
let transform = |success| {
let expected = $expected;
let given = $transform(success);
assert_eq!(&given, &expected);
};
run_jit_function_raw!(lib, main_fn_name, $ty, transform, errors)
};
}
#[allow(unused_imports)]
pub(crate) use assert_evals_to;

210
compiler/test_gen/src/helpers/from_wasm32_memory.rs Normal file
View file

@ -0,0 +1,210 @@
use roc_std::{RocDec, RocList, RocOrder, RocStr};
pub trait FromWasm32Memory: Sized {
const SIZE_OF_WASM: usize;
const ALIGN_OF_WASM: usize;
const ACTUAL_WIDTH: usize = if (Self::SIZE_OF_WASM % Self::ALIGN_OF_WASM) == 0 {
Self::SIZE_OF_WASM
} else {
Self::SIZE_OF_WASM + (Self::ALIGN_OF_WASM - (Self::SIZE_OF_WASM % Self::ALIGN_OF_WASM))
};
fn decode(memory: &wasmer::Memory, offset: u32) -> Self;
}
macro_rules! from_wasm_memory_primitive_decode {
($type_name:ident) => {
const SIZE_OF_WASM: usize = core::mem::size_of::<$type_name>();
const ALIGN_OF_WASM: usize = core::mem::align_of::<$type_name>();
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
use core::mem::MaybeUninit;
let mut output: MaybeUninit<Self> = MaybeUninit::uninit();
let width = std::mem::size_of::<Self>();
let ptr = output.as_mut_ptr();
let raw_ptr = ptr as *mut u8;
let slice = unsafe { std::slice::from_raw_parts_mut(raw_ptr, width) };
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(offset as u32);
let foobar = (ptr.deref(memory, 0, width as u32)).unwrap();
let wasm_slice = unsafe { std::mem::transmute(foobar) };
slice.copy_from_slice(wasm_slice);
unsafe { output.assume_init() }
}
};
}
macro_rules! from_wasm_memory_primitive {
($($type_name:ident ,)+) => {
$(
impl FromWasm32Memory for $type_name {
from_wasm_memory_primitive_decode!($type_name);
}
)*
}
}
from_wasm_memory_primitive!(
u8, i8, u16, i16, u32, i32, u64, i64, u128, i128, f32, f64, bool, RocDec, RocOrder,
);
impl FromWasm32Memory for () {
const SIZE_OF_WASM: usize = 0;
const ALIGN_OF_WASM: usize = 0;
fn decode(_: &wasmer::Memory, _: u32) -> Self {}
}
impl FromWasm32Memory for RocStr {
const SIZE_OF_WASM: usize = 8;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let bytes = <u64 as FromWasm32Memory>::decode(memory, offset);
let length = (bytes >> 32) as u32;
let elements = bytes as u32;
if length == 0 {
RocStr::default()
} else if (length as i32) < 0 {
// this is a small string
let last_byte = bytes.to_ne_bytes()[7];
let actual_length = (last_byte ^ 0b1000_0000) as usize;
let slice = &bytes.to_ne_bytes()[..actual_length as usize];
RocStr::from_slice(slice)
} else {
// this is a big string
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(elements);
let foobar = (ptr.deref(memory, 0, length)).unwrap();
let wasm_slice = unsafe { std::mem::transmute(foobar) };
RocStr::from_slice(wasm_slice)
}
}
}
impl<T: FromWasm32Memory + Clone> FromWasm32Memory for RocList<T> {
const SIZE_OF_WASM: usize = 8;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let bytes = <u64 as FromWasm32Memory>::decode(memory, offset);
let length = (bytes >> 32) as u32;
let elements = bytes as u32;
let mut items = Vec::with_capacity(length as usize);
for i in 0..length {
let item = <T as FromWasm32Memory>::decode(
memory,
elements + i * <T as FromWasm32Memory>::SIZE_OF_WASM as u32,
);
items.push(item);
}
RocList::from_slice(&items)
}
}
impl<T: FromWasm32Memory> FromWasm32Memory for &'_ T {
const SIZE_OF_WASM: usize = 4;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let elements = <u32 as FromWasm32Memory>::decode(memory, offset);
let actual = <T as FromWasm32Memory>::decode(memory, elements);
let b = Box::new(actual);
std::boxed::Box::<T>::leak(b)
}
}
impl<T: FromWasm32Memory + Clone, const N: usize> FromWasm32Memory for [T; N] {
const SIZE_OF_WASM: usize = N * T::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = T::ALIGN_OF_WASM;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
let ptr: wasmer::WasmPtr<u8, wasmer::Array> = wasmer::WasmPtr::new(offset);
let width = <T as FromWasm32Memory>::SIZE_OF_WASM as u32 * N as u32;
let foobar = (ptr.deref(memory, 0, width)).unwrap();
let wasm_slice: &[T; N] = unsafe { &*(foobar as *const _ as *const [T; N]) };
wasm_slice.clone()
}
}
impl FromWasm32Memory for usize {
const SIZE_OF_WASM: usize = 4;
const ALIGN_OF_WASM: usize = 4;
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
<u32 as FromWasm32Memory>::decode(memory, offset) as usize
}
}
impl<T: FromWasm32Memory, U: FromWasm32Memory> FromWasm32Memory for (T, U) {
const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = max2(T::SIZE_OF_WASM, U::SIZE_OF_WASM);
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
debug_assert!(
T::ALIGN_OF_WASM >= U::ALIGN_OF_WASM,
"this function does not handle alignment"
);
let t = <T as FromWasm32Memory>::decode(memory, offset);
let u = <U as FromWasm32Memory>::decode(memory, offset + T::ACTUAL_WIDTH as u32);
(t, u)
}
}
const fn max2(a: usize, b: usize) -> usize {
if a > b {
a
} else {
b
}
}
const fn max3(a: usize, b: usize, c: usize) -> usize {
max2(max2(a, b), c)
}
impl<T: FromWasm32Memory, U: FromWasm32Memory, V: FromWasm32Memory> FromWasm32Memory for (T, U, V) {
const SIZE_OF_WASM: usize = T::SIZE_OF_WASM + U::SIZE_OF_WASM + V::SIZE_OF_WASM;
const ALIGN_OF_WASM: usize = max3(T::SIZE_OF_WASM, U::SIZE_OF_WASM, V::SIZE_OF_WASM);
fn decode(memory: &wasmer::Memory, offset: u32) -> Self {
debug_assert!(
T::ALIGN_OF_WASM >= U::ALIGN_OF_WASM,
"this function does not handle alignment"
);
debug_assert!(
U::ALIGN_OF_WASM >= V::ALIGN_OF_WASM,
"this function does not handle alignment"
);
let t = <T as FromWasm32Memory>::decode(memory, offset);
let u = <U as FromWasm32Memory>::decode(memory, offset + T::ACTUAL_WIDTH as u32);
let v = <V as FromWasm32Memory>::decode(
memory,
offset + T::ACTUAL_WIDTH as u32 + U::ACTUAL_WIDTH as u32,
);
(t, u, v)
}
}

66
compiler/test_gen/src/helpers/eval.rs → compiler/test_gen/src/helpers/llvm.rs
View file

@ -1,3 +1,4 @@
use crate::helpers::from_wasm32_memory::FromWasm32Memory;
use inkwell::module::Module;
use libloading::Library;
use roc_build::link::module_to_dylib;
@ -10,7 +11,6 @@ use roc_module::symbol::Symbol;
use roc_mono::ir::OptLevel;
use roc_types::subs::VarStore;
use target_lexicon::Triple;
use test_wasm_util::from_wasm32_memory::FromWasm32Memory;
fn promote_expr_to_module(src: &str) -> String {
let mut buffer = String::from("app \"test\" provides [ main ] to \"./platform\"\n\nmain =\n");
@ -469,7 +469,7 @@ where
let stdlib = arena.alloc(roc_builtins::std::standard_stdlib());
let is_gen_test = true;
let instance = crate::helpers::eval::helper_wasm(
let instance = crate::helpers::llvm::helper_wasm(
&arena,
src,
stdlib,
@ -480,7 +480,7 @@ where
let memory = instance.exports.get_memory("memory").unwrap();
crate::helpers::eval::MEMORY.with(|f| {
crate::helpers::llvm::MEMORY.with(|f| {
*f.borrow_mut() = Some(unsafe { std::mem::transmute(memory) });
});
@ -494,7 +494,7 @@ where
_ => panic!(),
};
let output = <T as crate::helpers::eval::FromWasm32Memory>::decode(
let output = <T as crate::helpers::llvm::FromWasm32Memory>::decode(
memory,
// skip the RocCallResult tag id
address as u32 + 8,
@ -505,10 +505,10 @@ where
}
}
#[macro_export]
#[allow(unused_macros)]
macro_rules! assert_wasm_evals_to {
($src:expr, $expected:expr, $ty:ty, $transform:expr, $ignore_problems:expr) => {
match $crate::helpers::eval::assert_wasm_evals_to_help::<$ty>($src, $ignore_problems) {
match $crate::helpers::llvm::assert_wasm_evals_to_help::<$ty>($src, $ignore_problems) {
Err(msg) => panic!("Wasm test failed: {:?}", msg),
Ok(actual) => {
#[allow(clippy::bool_assert_comparison)]
@ -518,15 +518,21 @@ macro_rules! assert_wasm_evals_to {
};
($src:expr, $expected:expr, $ty:ty) => {
$crate::assert_wasm_evals_to!($src, $expected, $ty, $crate::helpers::eval::identity, false);
$crate::helpers::llvm::assert_wasm_evals_to!(
$src,
$expected,
$ty,
$crate::helpers::llvm::identity,
false
);
};
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
$crate::assert_wasm_evals_to!($src, $expected, $ty, $transform, false);
$crate::helpers::llvm::assert_wasm_evals_to!($src, $expected, $ty, $transform, false);
};
}
#[macro_export]
#[allow(unused_macros)]
macro_rules! assert_llvm_evals_to {
($src:expr, $expected:expr, $ty:ty, $transform:expr, $ignore_problems:expr) => {
use bumpalo::Bump;
@ -540,7 +546,7 @@ macro_rules! assert_llvm_evals_to {
let stdlib = arena.alloc(roc_builtins::std::standard_stdlib());
let is_gen_test = true;
let (main_fn_name, errors, lib) = $crate::helpers::eval::helper(
let (main_fn_name, errors, lib) = $crate::helpers::llvm::helper(
&arena,
$src,
stdlib,
@ -559,26 +565,32 @@ macro_rules! assert_llvm_evals_to {
};
($src:expr, $expected:expr, $ty:ty) => {
$crate::assert_llvm_evals_to!($src, $expected, $ty, $crate::helpers::eval::identity, false);
$crate::helpers::llvm::assert_llvm_evals_to!(
$src,
$expected,
$ty,
$crate::helpers::llvm::identity,
false
);
};
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
$crate::assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
$crate::helpers::llvm::assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
};
}
#[macro_export]
#[allow(unused_macros)]
macro_rules! assert_evals_to {
($src:expr, $expected:expr, $ty:ty) => {{
assert_evals_to!($src, $expected, $ty, $crate::helpers::eval::identity);
assert_evals_to!($src, $expected, $ty, $crate::helpers::llvm::identity);
}};
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
// Same as above, except with an additional transformation argument.
{
#[cfg(feature = "wasm-cli-run")]
$crate::assert_wasm_evals_to!($src, $expected, $ty, $transform, false);
$crate::helpers::llvm::assert_wasm_evals_to!($src, $expected, $ty, $transform, false);
$crate::assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
$crate::helpers::llvm::assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
}
};
}
@ -588,18 +600,32 @@ pub fn identity<T>(value: T) -> T {
value
}
#[macro_export]
#[allow(unused_macros)]
macro_rules! assert_non_opt_evals_to {
($src:expr, $expected:expr, $ty:ty) => {{
$crate::assert_llvm_evals_to!($src, $expected, $ty, $crate::helpers::eval::identity);
$crate::helpers::llvm::assert_llvm_evals_to!(
$src,
$expected,
$ty,
$crate::helpers::llvm::identity
);
}};
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
// Same as above, except with an additional transformation argument.
{
$crate::assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
$crate::helpers::llvm::assert_llvm_evals_to!($src, $expected, $ty, $transform, false);
}
};
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {{
$crate::assert_llvm_evals_to!($src, $expected, $ty, $transform);
$crate::helpers::llvm::assert_llvm_evals_to!($src, $expected, $ty, $transform);
}};
}
#[allow(unused_imports)]
pub(crate) use assert_evals_to;
#[allow(unused_imports)]
pub(crate) use assert_llvm_evals_to;
#[allow(unused_imports)]
pub(crate) use assert_non_opt_evals_to;
#[allow(unused_imports)]
pub(crate) use assert_wasm_evals_to;

11
compiler/test_gen/src/helpers/mod.rs
View file

@ -1,7 +1,14 @@
extern crate bumpalo;
#[macro_use]
pub mod eval;
#[cfg(feature = "gen-dev")]
pub mod dev;
pub mod from_wasm32_memory;
#[cfg(feature = "gen-llvm")]
pub mod llvm;
#[cfg(feature = "gen-wasm")]
pub mod wasm;
#[cfg(feature = "gen-wasm")]
pub mod wasm32_test_result;
/// Used in the with_larger_debug_stack() function, for tests that otherwise
/// run out of stack space in debug builds (but don't in --release builds)

239
compiler/test_gen/src/helpers/wasm.rs Normal file
View file

@ -0,0 +1,239 @@
use std::cell::Cell;
use std::collections::hash_map::DefaultHasher;
use std::hash::{Hash, Hasher};
use crate::helpers::from_wasm32_memory::FromWasm32Memory;
use crate::helpers::wasm32_test_result::Wasm32TestResult;
use roc_can::builtins::builtin_defs_map;
use roc_collections::all::{MutMap, MutSet};
const TEST_WRAPPER_NAME: &str = "test_wrapper";
std::thread_local! {
static TEST_COUNTER: Cell<u32> = Cell::new(0);
}
fn promote_expr_to_module(src: &str) -> String {
let mut buffer = String::from("app \"test\" provides [ main ] to \"./platform\"\n\nmain =\n");
for line in src.lines() {
// indent the body!
buffer.push_str(" ");
buffer.push_str(line);
buffer.push('\n');
}
buffer
}
#[allow(dead_code)]
pub fn helper_wasm<'a, T: Wasm32TestResult>(
arena: &'a bumpalo::Bump,
src: &str,
stdlib: &'a roc_builtins::std::StdLib,
_result_type_dummy: &T,
) -> wasmer::Instance {
use std::path::{Path, PathBuf};
let filename = PathBuf::from("Test.roc");
let src_dir = Path::new("fake/test/path");
let module_src;
let temp;
if src.starts_with("app") {
// this is already a module
module_src = src;
} else {
// this is an expression, promote it to a module
temp = promote_expr_to_module(src);
module_src = &temp;
}
let exposed_types = MutMap::default();
let loaded = roc_load::file::load_and_monomorphize_from_str(
arena,
filename,
module_src,
stdlib,
src_dir,
exposed_types,
8,
builtin_defs_map,
);
let loaded = loaded.expect("failed to load module");
use roc_load::file::MonomorphizedModule;
let MonomorphizedModule {
procedures,
interns,
exposed_to_host,
..
} = loaded;
// You can comment and uncomment this block out to get more useful information
// while you're working on the wasm backend!
// {
// println!("=========== Procedures ==========");
// println!("{:?}", procedures);
// println!("=================================\n");
// println!("=========== Interns ==========");
// println!("{:?}", interns);
// println!("=================================\n");
// println!("=========== Exposed ==========");
// println!("{:?}", exposed_to_host);
// println!("=================================\n");
// }
debug_assert_eq!(exposed_to_host.len(), 1);
let main_fn_symbol = loaded.entry_point.symbol;
let main_fn_index = procedures
.keys()
.position(|(s, _)| *s == main_fn_symbol)
.unwrap();
let exposed_to_host = exposed_to_host.keys().copied().collect::<MutSet<_>>();
let env = roc_gen_wasm::Env {
arena,
interns,
exposed_to_host,
};
let mut wasm_module = roc_gen_wasm::build_module_help(&env, procedures).unwrap();
T::insert_test_wrapper(
arena,
&mut wasm_module,
TEST_WRAPPER_NAME,
main_fn_index as u32,
);
let mut module_bytes = std::vec::Vec::with_capacity(4096);
wasm_module.serialize(&mut module_bytes);
// for debugging (e.g. with wasm2wat or wasm-objdump)
if false {
use std::io::Write;
let mut hash_state = DefaultHasher::new();
src.hash(&mut hash_state);
let src_hash = hash_state.finish();
// Filename contains a hash of the Roc test source code. Helpful when comparing across commits.
let dir = "/tmp/roc/compiler/gen_wasm/output";
std::fs::create_dir_all(dir).unwrap();
let path = format!("{}/test-{:016x}.wasm", dir, src_hash);
// Print out filename (appears just after test name)
println!("dumping file {:?}", path);
match std::fs::File::create(path) {
Err(e) => eprintln!("Problem creating wasm debug file: {:?}", e),
Ok(mut file) => {
file.write_all(&module_bytes).unwrap();
}
}
}
// now, do wasmer stuff
use wasmer::{Instance, Module, Store};
let store = Store::default();
// let module = Module::from_file(&store, &test_wasm_path).unwrap();
let wasmer_module = Module::from_binary(&store, &module_bytes).unwrap();
// First, we create the `WasiEnv`
use wasmer_wasi::WasiState;
let mut wasi_env = WasiState::new("hello").finalize().unwrap();
// Then, we get the import object related to our WASI
// and attach it to the Wasm instance.
let import_object = wasi_env
.import_object(&wasmer_module)
.unwrap_or_else(|_| wasmer::imports!());
Instance::new(&wasmer_module, &import_object).unwrap()
}
#[allow(dead_code)]
pub fn assert_wasm_evals_to_help<T>(src: &str, expected: T) -> Result<T, String>
where
T: FromWasm32Memory + Wasm32TestResult,
{
let arena = bumpalo::Bump::new();
// NOTE the stdlib must be in the arena; just taking a reference will segfault
let stdlib = arena.alloc(roc_builtins::std::standard_stdlib());
let instance = crate::helpers::wasm::helper_wasm(&arena, src, stdlib, &expected);
let memory = instance.exports.get_memory("memory").unwrap();
let test_wrapper = instance.exports.get_function(TEST_WRAPPER_NAME).unwrap();
match test_wrapper.call(&[]) {
Err(e) => Err(format!("{:?}", e)),
Ok(result) => {
let address = match result[0] {
wasmer::Value::I32(a) => a,
_ => panic!(),
};
let output = <T as FromWasm32Memory>::decode(memory, address as u32);
Ok(output)
}
}
}
#[allow(unused_macros)]
macro_rules! assert_wasm_evals_to {
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
match $crate::helpers::wasm::assert_wasm_evals_to_help::<$ty>($src, $expected) {
Err(msg) => panic!("{:?}", msg),
Ok(actual) => {
assert_eq!($transform(actual), $expected)
}
}
};
($src:expr, $expected:expr, $ty:ty) => {
$crate::helpers::wasm::assert_wasm_evals_to!(
$src,
$expected,
$ty,
$crate::helpers::wasm::identity
);
};
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
$crate::helpers::wasm::assert_wasm_evals_to!($src, $expected, $ty, $transform);
};
}
#[allow(unused_macros)]
macro_rules! assert_evals_to {
($src:expr, $expected:expr, $ty:ty) => {{
assert_evals_to!($src, $expected, $ty, $crate::helpers::wasm::identity);
}};
($src:expr, $expected:expr, $ty:ty, $transform:expr) => {
// Same as above, except with an additional transformation argument.
{
$crate::helpers::wasm::assert_wasm_evals_to!($src, $expected, $ty, $transform);
}
};
}
#[allow(dead_code)]
pub fn identity<T>(value: T) -> T {
value
}
#[allow(unused_imports)]
pub(crate) use assert_evals_to;
#[allow(unused_imports)]
pub(crate) use assert_wasm_evals_to;

268
compiler/test_gen/src/helpers/wasm32_test_result.rs Normal file
View file

@ -0,0 +1,268 @@
use bumpalo::collections::Vec;
use crate::helpers::from_wasm32_memory::FromWasm32Memory;
use roc_gen_wasm::wasm_module::opcodes;
use roc_gen_wasm::wasm_module::{
Align, CodeBuilder, Export, ExportType, LocalId, Signature, ValueType, WasmModule,
};
use roc_std::{RocDec, RocList, RocOrder, RocStr};
pub trait Wasm32TestResult {
fn insert_test_wrapper<'a>(
arena: &'a bumpalo::Bump,
wasm_module: &mut WasmModule<'a>,
wrapper_name: &str,
main_function_index: u32,
) {
wasm_module.add_function_signature(Signature {
param_types: Vec::with_capacity_in(0, arena),
ret_type: Some(ValueType::I32),
});
wasm_module.export.entries.push(Export {
name: wrapper_name.to_string(),
ty: ExportType::Func,
index: wasm_module.code.code_builders.len() as u32,
});
let mut code_builder = CodeBuilder::new(arena);
Self::build_wrapper_body(&mut code_builder, main_function_index);
wasm_module.code.code_builders.push(code_builder);
}
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32);
}
macro_rules! build_wrapper_body_primitive {
($store_instruction: ident, $align: expr) => {
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
let frame_pointer_id = LocalId(0);
let frame_pointer = Some(frame_pointer_id);
let local_types = &[ValueType::I32];
let frame_size = 8;
code_builder.get_local(frame_pointer_id);
// Raw "call" instruction. Don't bother with symbol & relocation since we're not going to link.
code_builder.inst_imm32(opcodes::CALL, 0, true, main_function_index);
code_builder.$store_instruction($align, 0);
code_builder.get_local(frame_pointer_id);
code_builder.finalize(local_types, frame_size, frame_pointer);
}
};
}
macro_rules! wasm_test_result_primitive {
($type_name: ident, $store_instruction: ident, $align: expr) => {
impl Wasm32TestResult for $type_name {
build_wrapper_body_primitive!($store_instruction, $align);
}
};
}
fn build_wrapper_body_stack_memory(
code_builder: &mut CodeBuilder,
main_function_index: u32,
size: usize,
) {
let local_id = LocalId(0);
let local_types = &[ValueType::I32];
let frame_pointer = Some(local_id);
code_builder.get_local(local_id);
// Raw "call" instruction. Don't bother with symbol & relocation since we're not going to link.
code_builder.inst_imm32(opcodes::CALL, 0, true, main_function_index);
code_builder.get_local(local_id);
code_builder.finalize(local_types, size as i32, frame_pointer);
}
macro_rules! wasm_test_result_stack_memory {
($type_name: ident) => {
impl Wasm32TestResult for $type_name {
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(
code_builder,
main_function_index,
$type_name::ACTUAL_WIDTH,
)
}
}
};
}
wasm_test_result_primitive!(bool, i32_store8, Align::Bytes1);
wasm_test_result_primitive!(RocOrder, i32_store8, Align::Bytes1);
wasm_test_result_primitive!(u8, i32_store8, Align::Bytes1);
wasm_test_result_primitive!(i8, i32_store8, Align::Bytes1);
wasm_test_result_primitive!(u16, i32_store16, Align::Bytes2);
wasm_test_result_primitive!(i16, i32_store16, Align::Bytes2);
wasm_test_result_primitive!(u32, i32_store, Align::Bytes4);
wasm_test_result_primitive!(i32, i32_store, Align::Bytes4);
wasm_test_result_primitive!(u64, i64_store, Align::Bytes8);
wasm_test_result_primitive!(i64, i64_store, Align::Bytes8);
wasm_test_result_primitive!(usize, i32_store, Align::Bytes4);
wasm_test_result_primitive!(f32, f32_store, Align::Bytes8);
wasm_test_result_primitive!(f64, f64_store, Align::Bytes8);
wasm_test_result_stack_memory!(u128);
wasm_test_result_stack_memory!(i128);
wasm_test_result_stack_memory!(RocDec);
wasm_test_result_stack_memory!(RocStr);
impl<T: Wasm32TestResult> Wasm32TestResult for RocList<T> {
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(code_builder, main_function_index, 12)
}
}
impl<T: Wasm32TestResult> Wasm32TestResult for &'_ T {
build_wrapper_body_primitive!(i32_store, Align::Bytes4);
}
impl<T, const N: usize> Wasm32TestResult for [T; N]
where
T: Wasm32TestResult + FromWasm32Memory,
{
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(code_builder, main_function_index, N * T::ACTUAL_WIDTH)
}
}
impl<T, U> Wasm32TestResult for (T, U)
where
T: Wasm32TestResult + FromWasm32Memory,
U: Wasm32TestResult + FromWasm32Memory,
{
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(
code_builder,
main_function_index,
T::ACTUAL_WIDTH + U::ACTUAL_WIDTH,
)
}
}
impl<T, U, V> Wasm32TestResult for (T, U, V)
where
T: Wasm32TestResult + FromWasm32Memory,
U: Wasm32TestResult + FromWasm32Memory,
V: Wasm32TestResult + FromWasm32Memory,
{
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(
code_builder,
main_function_index,
T::ACTUAL_WIDTH + U::ACTUAL_WIDTH + V::ACTUAL_WIDTH,
)
}
}
impl<T, U, V, W> Wasm32TestResult for (T, U, V, W)
where
T: Wasm32TestResult + FromWasm32Memory,
U: Wasm32TestResult + FromWasm32Memory,
V: Wasm32TestResult + FromWasm32Memory,
W: Wasm32TestResult + FromWasm32Memory,
{
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(
code_builder,
main_function_index,
T::ACTUAL_WIDTH + U::ACTUAL_WIDTH + V::ACTUAL_WIDTH + W::ACTUAL_WIDTH,
)
}
}
impl<T, U, V, W, X> Wasm32TestResult for (T, U, V, W, X)
where
T: Wasm32TestResult + FromWasm32Memory,
U: Wasm32TestResult + FromWasm32Memory,
V: Wasm32TestResult + FromWasm32Memory,
W: Wasm32TestResult + FromWasm32Memory,
X: Wasm32TestResult + FromWasm32Memory,
{
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(
code_builder,
main_function_index,
T::ACTUAL_WIDTH + U::ACTUAL_WIDTH + V::ACTUAL_WIDTH + W::ACTUAL_WIDTH + X::ACTUAL_WIDTH,
)
}
}
impl<T, U, V, W, X, Y> Wasm32TestResult for (T, U, V, W, X, Y)
where
T: Wasm32TestResult + FromWasm32Memory,
U: Wasm32TestResult + FromWasm32Memory,
V: Wasm32TestResult + FromWasm32Memory,
W: Wasm32TestResult + FromWasm32Memory,
X: Wasm32TestResult + FromWasm32Memory,
Y: Wasm32TestResult + FromWasm32Memory,
{
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(
code_builder,
main_function_index,
T::ACTUAL_WIDTH
+ U::ACTUAL_WIDTH
+ V::ACTUAL_WIDTH
+ W::ACTUAL_WIDTH
+ X::ACTUAL_WIDTH
+ Y::ACTUAL_WIDTH,
)
}
}
impl<T, U, V, W, X, Y, Z> Wasm32TestResult for (T, U, V, W, X, Y, Z)
where
T: Wasm32TestResult + FromWasm32Memory,
U: Wasm32TestResult + FromWasm32Memory,
V: Wasm32TestResult + FromWasm32Memory,
W: Wasm32TestResult + FromWasm32Memory,
X: Wasm32TestResult + FromWasm32Memory,
Y: Wasm32TestResult + FromWasm32Memory,
Z: Wasm32TestResult + FromWasm32Memory,
{
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(
code_builder,
main_function_index,
T::ACTUAL_WIDTH
+ U::ACTUAL_WIDTH
+ V::ACTUAL_WIDTH
+ W::ACTUAL_WIDTH
+ X::ACTUAL_WIDTH
+ Y::ACTUAL_WIDTH
+ Z::ACTUAL_WIDTH,
)
}
}
impl<T, U, V, W, X, Y, Z, A> Wasm32TestResult for (T, U, V, W, X, Y, Z, A)
where
T: Wasm32TestResult + FromWasm32Memory,
U: Wasm32TestResult + FromWasm32Memory,
V: Wasm32TestResult + FromWasm32Memory,
W: Wasm32TestResult + FromWasm32Memory,
X: Wasm32TestResult + FromWasm32Memory,
Y: Wasm32TestResult + FromWasm32Memory,
Z: Wasm32TestResult + FromWasm32Memory,
A: Wasm32TestResult + FromWasm32Memory,
{
fn build_wrapper_body(code_builder: &mut CodeBuilder, main_function_index: u32) {
build_wrapper_body_stack_memory(
code_builder,
main_function_index,
T::ACTUAL_WIDTH
+ U::ACTUAL_WIDTH
+ V::ACTUAL_WIDTH
+ W::ACTUAL_WIDTH
+ X::ACTUAL_WIDTH
+ Y::ACTUAL_WIDTH
+ Z::ACTUAL_WIDTH
+ A::ACTUAL_WIDTH,
)
}
}

42
compiler/test_gen/src/tests.rs
View file

@ -10,8 +10,48 @@ pub mod gen_list;
pub mod gen_num;
pub mod gen_primitives;
pub mod gen_records;
pub mod gen_result;
pub mod gen_set;
pub mod gen_str;
pub mod gen_tags;
mod helpers;
pub mod wasm_str;
use core::ffi::c_void;
#[no_mangle]
pub unsafe fn roc_alloc(size: usize, _alignment: u32) -> *mut c_void {
libc::malloc(size)
}
#[no_mangle]
pub unsafe fn roc_realloc(
c_ptr: *mut c_void,
new_size: usize,
_old_size: usize,
_alignment: u32,
) -> *mut c_void {
libc::realloc(c_ptr, new_size)
}
#[no_mangle]
pub unsafe fn roc_dealloc(c_ptr: *mut c_void, _alignment: u32) {
libc::free(c_ptr)
}
#[no_mangle]
pub unsafe fn roc_panic(c_ptr: *mut c_void, tag_id: u32) {
use roc_gen_llvm::llvm::build::PanicTagId;
use std::convert::TryFrom;
use std::ffi::CStr;
use std::os::raw::c_char;
match PanicTagId::try_from(tag_id) {
Ok(PanicTagId::NullTerminatedString) => {
let slice = CStr::from_ptr(c_ptr as *const c_char);
let string = slice.to_str().unwrap();
eprintln!("Roc hit a panic: {}", string);
std::process::exit(1);
}
Err(_) => unreachable!(),
}
}

1072
compiler/test_gen/src/wasm_str.rs Normal file
View file

File diff suppressed because it is too large Load diff