Files
rexlang/tests/run.rs
T
Your NameandClaude Opus 5.5 7cf9727bcd Rename the language from Dino to Rex
Files use .rex, the command is rex, and the crate, runtime prefixes,
docs, editor files and examples all use the new name.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-08 13:51:23 +01:00

2262 lines
77 KiB
Rust

//! End-to-end tests: compile Rex programs to C, build them with the system C
//! compiler, run them, and compare the output.
use std::process::Command;
use rex::driver;
struct Output {
stdout: String,
stderr: String,
code: i32,
}
fn run_source(src: &str) -> Output {
let c = driver::compile_to_c(src).unwrap_or_else(|d| panic!("{}", d.render("test.rex", src)));
run_c(&c, src)
}
fn run_c(c: &str, src: &str) -> Output {
let c = c.to_string();
let exe = driver::temp_exe();
// every test program also runs under the address sanitizer: a double free,
// a use after free or a leak makes the test fail
let sanitized = driver::build_exe_with(&c, &exe, &["-std=c11", "-fwrapv", "-w", "-fsanitize=address", "-g"]);
if let Err(e) = sanitized {
// a compiler without the sanitizer library: run the tests without it
assert!(e.contains("asan"), "{e}");
driver::build_exe(&c, &exe).unwrap();
}
let o = Command::new(&exe).env("ASAN_OPTIONS", "detect_leaks=1").output().unwrap();
let _ = std::fs::remove_file(&exe);
let out = Output {
stdout: String::from_utf8_lossy(&o.stdout).into_owned(),
stderr: String::from_utf8_lossy(&o.stderr).into_owned(),
code: o.status.code().unwrap_or(-1),
};
assert!(
!out.stderr.contains("Sanitizer"),
"memory error in the generated program:\n{}\n--- program ---\n{src}",
out.stderr
);
out
}
fn out_of(src: &str) -> String {
run_source(src).stdout
}
#[test]
fn golden_examples() {
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/basics");
let mut n = 0;
for entry in std::fs::read_dir(dir).unwrap() {
let path = entry.unwrap().path();
if path.extension().map_or(false, |e| e == "rex") {
let src = std::fs::read_to_string(&path).unwrap();
let want = std::fs::read_to_string(path.with_extension("out"))
.unwrap_or_else(|_| panic!("missing .out file for {}", path.display()));
let got = out_of(&src);
assert_eq!(got, want, "output of {} changed", path.display());
n += 1;
}
}
assert!(n >= 21, "found only {n} example programs");
}
#[test]
fn division_by_zero_panics() {
let o = run_source("func main() {\n var z = 0\n print(1)\n print(10 / z)\n print(2)\n}");
assert_eq!(o.stdout, "1\n");
assert!(o.stderr.contains("division by zero"), "{}", o.stderr);
assert_eq!(o.code, 2);
}
#[test]
fn remainder_by_zero_panics() {
let o = run_source("func main() {\n var z = 0\n print(10 % z)\n}");
assert_eq!(o.code, 2);
}
#[test]
fn min_int_divided_by_minus_one_does_not_crash() {
let o = run_source(
"func main() {\n var m = -9223372036854775807 - 1\n var d = -1\n print(m / d)\n print(m % d)\n}",
);
assert_eq!(o.code, 0, "{}", o.stderr);
assert_eq!(o.stdout, "-9223372036854775808\n0\n");
}
#[test]
fn zero_step_panics() {
let o = run_source("func main() {\n var s = 0\n for i in 0..3 step s { print(i) }\n}");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("step"), "{}", o.stderr);
}
#[test]
fn loop_variable_is_a_copy() {
// changing `i` inside the body must not change how many times the loop runs
let out = out_of("func main() {\n for i in 0..3 {\n print(i)\n i += 10\n }\n}");
assert_eq!(out, "0\n1\n2\n");
}
#[test]
fn range_bounds_are_evaluated_once() {
let out = out_of(
"func n(): int {\n print(\"n called\")\n return 2\n}\nfunc main() {\n for i in 0..n() { print(i) }\n}",
);
assert_eq!(out, "n called\n0\n1\n");
}
#[test]
fn while_condition_with_calls() {
let out = out_of(
"func lt(a, b: int): bool {\n print(\"check\")\n return a < b\n}\nfunc main() {\n var i = 0\n for lt(i, 2) {\n i += 1\n }\n print(i)\n}",
);
assert_eq!(out, "check\ncheck\ncheck\n2\n");
}
#[test]
fn shadowing_in_inner_scope() {
let out = out_of("func main() {\n var x = 1\n if true {\n var x = 2\n print(x)\n }\n print(x)\n}");
assert_eq!(out, "2\n1\n");
}
#[test]
fn const_expressions() {
let out = out_of("const A = 3\nconst B = A * 2 + 1\nfunc main() {\n print(B)\n}");
assert_eq!(out, "7\n");
}
#[test]
fn recursion_and_mutual_recursion() {
let out = out_of(
"func even(n: int): bool {\n if n == 0 { return true }\n return odd(n - 1)\n}\nfunc odd(n: int): bool {\n if n == 0 { return false }\n return even(n - 1)\n}\nfunc main() {\n print(even(10), odd(7), even(7))\n}",
);
assert_eq!(out, "true true false\n");
}
#[test]
fn empty_and_unicode_strings() {
let out = out_of("func main() {\n var e = \"\"\n print(\"[{e}]\", \"héllo\" + \"✓\")\n}");
assert_eq!(out, "[] héllo✓\n");
}
#[test]
fn c_string_escapes() {
// quotes, backslashes, `?` (trigraph-safe), and a digit right after a non-ASCII byte
let out = out_of("func main() {\n print(\"a\\\\b \\\"q\\\" ??= é1\")\n}");
assert_eq!(out, "a\\b \"q\" ??= é1\n");
}
// ---------- type errors ----------
fn check_err(src: &str) -> String {
match driver::compile_to_c(src) {
Ok(_) => panic!("expected an error for:\n{src}"),
Err(d) => d.msg,
}
}
fn main_with(body: &str) -> String {
format!("func main() {{\n{body}\n}}")
}
#[test]
fn error_mismatched_types() {
let m = check_err(&main_with("var a = 1\nvar b = \"x\"\nvar c = a + b"));
assert!(m.contains("`+` between `int` and `string`"), "{m}");
}
#[test]
fn error_int_float_hint() {
let m = check_err(&main_with("var a = 1\nvar b = 2.5\nvar c = a + b"));
assert!(m.contains("float(...)"), "{m}");
}
#[test]
fn error_wrong_assignment_type() {
let m = check_err(&main_with("var a = 1\na = \"no\""));
assert!(m.contains("expected `int`, found `string`"), "{m}");
}
#[test]
fn error_condition_must_be_bool() {
let m = check_err(&main_with("if 1 { }"));
assert!(m.contains("expected `bool`"), "{m}");
}
#[test]
fn error_unknown_name() {
let m = check_err(&main_with("print(nope)"));
assert!(m.contains("unknown name `nope`"), "{m}");
}
#[test]
fn error_unknown_function() {
let m = check_err(&main_with("nope(1)"));
assert!(m.contains("unknown function `nope`"), "{m}");
}
#[test]
fn error_wrong_argument_count() {
let m = check_err("func f(a: int): int { return a }\nfunc main() {\n f(1, 2)\n}");
assert!(m.contains("takes 1 argument, but 2 were given"), "{m}");
}
#[test]
fn error_wrong_argument_type() {
let m = check_err("func f(a: int): int { return a }\nfunc main() {\n f(true)\n}");
assert!(m.contains("expected `int`, found `bool`"), "{m}");
}
#[test]
fn error_missing_return() {
let m = check_err("func f(a: int): int {\n if a > 0 { return 1 }\n}\nfunc main() { }");
assert!(m.contains("without returning"), "{m}");
}
#[test]
fn error_return_value_from_unit_function() {
let m = check_err("func f() { return 1 }\nfunc main() { }");
assert!(m.contains("returns nothing"), "{m}");
}
#[test]
fn error_assign_to_const() {
let m = check_err(&main_with("const x = 1\nx = 2"));
assert!(m.contains("constant"), "{m}");
}
#[test]
fn error_redeclare_in_same_scope() {
let m = check_err(&main_with("var x = 1\nvar x = 2"));
assert!(m.contains("already defined"), "{m}");
}
#[test]
fn error_break_outside_loop() {
let m = check_err(&main_with("break"));
assert!(m.contains("only makes sense inside a `for`"), "{m}");
}
#[test]
fn error_no_main() {
let m = check_err("func f() { }");
assert!(m.contains("no `main`"), "{m}");
}
#[test]
fn error_unused_value() {
let m = check_err(&main_with("1 + 2"));
assert!(m.contains("never used"), "{m}");
}
#[test]
fn error_using_nothing_as_value() {
let m = check_err("func f() { }\nfunc main() {\n var x = f()\n}");
assert!(m.contains("returns nothing"), "{m}");
}
#[test]
fn error_float_modulo() {
let m = check_err(&main_with("var x = 1.5 % 2.0"));
assert!(m.contains("doesn't work on `float`"), "{m}");
}
#[test]
fn error_const_with_call() {
let m = check_err("func f(): int { return 1 }\nconst X = f()\nfunc main() { }");
assert!(m.contains("can't call functions"), "{m}");
}
#[test]
fn error_not_supported_yet_is_clear() {
let m = check_err("interface I[T] { f() }\nfunc main() { }");
assert!(m.contains("not supported yet"), "{m}");
}
// ---------- structs and methods ----------
#[test]
fn generated_c_is_const_correct() {
// Methods inferred as non-mutating take `const T *self`; if the inference were
// wrong, the C compiler would complain about discarding `const`.
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/basics");
for name in ["structs", "value_semantics", "lists", "list_values", "sieve", "enums", "enum_data", "errors", "optionals", "sized", "own_strings", "own_structs", "own_flows"] {
let src = std::fs::read_to_string(format!("{dir}/{name}.rex")).unwrap();
let c = driver::compile_to_c(&src).unwrap();
let exe = driver::temp_exe();
driver::build_exe_with(
&c,
&exe,
&["-std=c11", "-Wall", "-Werror=discarded-qualifiers", "-Werror=incompatible-pointer-types"],
)
.unwrap_or_else(|e| panic!("{name}: {e}"));
let _ = std::fs::remove_file(&exe);
}
}
const POINT: &str = "struct P {\n x, y: int\n func sum(): int { return x + y }\n func inc() { x += 1 }\n}\n";
#[test]
fn struct_order_does_not_matter() {
let out = out_of(
"struct Outer { inner: Inner }\nstruct Inner { n: int }\nfunc main() {\n var o = Outer{Inner{5}}\n print(o.inner.n)\n}",
);
assert_eq!(out, "5\n");
}
#[test]
fn param_shadows_field_and_self_reaches_it() {
let out = out_of(
"struct S {\n x: int\n func set(x: int) { self.x = x * 2 }\n func get(): int { return x }\n}\nfunc main() {\n var s: S\n s.set(21)\n print(s.get())\n}",
);
assert_eq!(out, "42\n");
}
#[test]
fn method_returning_self_is_a_copy() {
let out = out_of(&format!(
"{POINT}func main() {{\n var a = P{{1, 2}}\n func_check(a)\n}}\nfunc func_check(a: P) {{\n var b = a\n b.inc()\n print(a.x, b.x)\n}}"
));
assert_eq!(out, "1 2\n");
}
#[test]
fn mutation_through_nested_field() {
let out = out_of(
"struct In { n: int\n func up() { n += 1 } }\nstruct Out { a: In\n func go() { a.up()\n a.up() } }\nfunc main() {\n var o: Out\n o.go()\n o.a.up()\n print(o.a.n)\n}",
);
assert_eq!(out, "3\n");
}
#[test]
fn readonly_methods_work_on_constants() {
let out = out_of(&format!("{POINT}const ORIGIN = P{{3, 4}}\nfunc main() {{\n print(ORIGIN.sum(), ORIGIN.x)\n const k = P{{1, 1}}\n print(k.sum())\n}}"));
assert_eq!(out, "7 3\n2\n");
}
#[test]
fn struct_values_in_strings_and_print() {
let out = out_of("struct P { x: int\n name: string }\nfunc main() {\n var p = P{1, \"a\"}\n print(\"p = {p}\")\n print(p, 2)\n}");
assert_eq!(out, "p = P{x: 1, name: a}\nP{x: 1, name: a} 2\n");
}
#[test]
fn empty_struct() {
let out = out_of("struct E {}\nfunc main() {\n var e: E\n var f = E{}\n print(e, f)\n}");
assert_eq!(out, "E{} E{}\n");
}
#[test]
fn fields_named_like_c_keywords() {
let out = out_of("struct K { default, register, int: int }\nfunc main() {\n var k = K{1, 2, 3}\n print(k.default + k.register + k.int)\n}");
assert_eq!(out, "6\n");
}
#[test]
fn struct_field_assignment_ops() {
let out = out_of("struct A { n: int\n f: float }\nfunc main() {\n var a: A\n a.n += 5\n a.n *= 3\n a.f = 1\n a.f /= 4\n print(a.n, a.f)\n}");
assert_eq!(out, "15 0.25\n");
}
#[test]
fn call_in_struct_literal_keeps_order() {
let out = out_of(
"struct P { a, b: int }\nfunc say(s: string, v: int): int {\n print(s)\n return v\n}\nfunc main() {\n var p = P{b: say(\"b\", 2), a: say(\"a\", 1)}\n print(p.a, p.b)\n}",
);
// initializers run in the order written, not declaration order
assert_eq!(out, "b\na\n1 2\n");
}
#[test]
fn method_call_on_call_result() {
let out = out_of(&format!("{POINT}func make(): P {{\n return P{{2, 3}}\n}}\nfunc main() {{\n print(make().sum(), make().y)\n}}"));
assert_eq!(out, "5 3\n");
}
#[test]
fn error_struct_compare() {
let m = check_err("struct P { x: int }\nfunc main() {\n var a: P\n var b: P\n var c = a == b\n}");
assert!(m.contains("compare the fields"), "{m}");
}
#[test]
fn error_unknown_field_lists_options() {
let m = check_err(&format!("{POINT}func main() {{\n var a: P\n print(a.z)\n}}"));
assert!(m.contains("no field or method `z`") && m.contains("sum"), "{m}");
}
#[test]
fn error_method_without_call() {
let m = check_err(&format!("{POINT}func main() {{\n var a: P\n print(a.sum)\n}}"));
assert!(m.contains("is a method"), "{m}");
}
#[test]
fn error_unknown_method() {
let m = check_err(&format!("{POINT}func main() {{\n var a: P\n a.nope()\n}}"));
assert!(m.contains("no field or method `nope`"), "{m}");
}
#[test]
fn error_fields_on_a_non_struct() {
let m = check_err("func main() {\n var a = 1\n print(a.x)\n}");
assert!(m.contains("`int` has no fields"), "{m}");
}
#[test]
fn error_literal_wrong_count() {
let m = check_err(&format!("{POINT}func main() {{\n var a = P{{1}}\n}}"));
assert!(m.contains("has 2 fields, but 1 value was given"), "{m}");
}
#[test]
fn error_literal_mixed_names() {
let m = check_err(&format!("{POINT}func main() {{\n var a = P{{x: 1, 2}}\n}}"));
assert!(m.contains("not a mix"), "{m}");
}
#[test]
fn error_literal_unknown_and_duplicate_field() {
let m = check_err(&format!("{POINT}func main() {{\n var a = P{{z: 1}}\n}}"));
assert!(m.contains("no field `z`"), "{m}");
let m = check_err(&format!("{POINT}func main() {{\n var a = P{{x: 1, x: 2}}\n}}"));
assert!(m.contains("given twice"), "{m}");
}
#[test]
fn error_literal_wrong_field_type() {
let m = check_err(&format!("{POINT}func main() {{\n var a = P{{x: \"s\"}}\n}}"));
assert!(m.contains("expected `int`, found `string`"), "{m}");
}
#[test]
fn error_struct_contains_itself() {
let m = check_err("struct A { b: B }\nstruct B { a: A }\nfunc main() { }");
assert!(m.contains("contains itself"), "{m}");
let m = check_err("struct A { a: A }\nfunc main() { }");
assert!(m.contains("contains itself"), "{m}");
}
#[test]
fn error_method_name_clashes() {
let m = check_err("struct A {\n x: int\n func x() { }\n}\nfunc main() { }");
assert!(m.contains("already a field"), "{m}");
let m = check_err("struct A {\n func f() { }\n func f() { }\n}\nfunc main() { }");
assert!(m.contains("two methods"), "{m}");
let m = check_err("struct A { x: int\n x: int }\nfunc main() { }");
assert!(m.contains("two fields"), "{m}");
}
#[test]
fn error_self_parameter() {
let m = check_err("struct A {\n func f(self: int) { }\n}\nfunc main() { }");
assert!(m.contains("`self` is added automatically"), "{m}");
}
#[test]
fn error_mutating_method_on_constant() {
let m = check_err(&format!("{POINT}func main() {{\n const k = P{{1, 2}}\n k.inc()\n}}"));
assert!(m.contains("`inc` changes `k`, but `k` is a constant"), "{m}");
}
#[test]
fn error_mutating_method_on_temporary() {
let m = check_err(&format!("{POINT}func make(): P {{\n return P{{1, 2}}\n}}\nfunc main() {{\n make().inc()\n}}"));
assert!(m.contains("temporary or a constant"), "{m}");
}
#[test]
fn error_mutating_method_on_global_const() {
let m = check_err(&format!("{POINT}const G = P{{1, 2}}\nfunc main() {{\n G.inc()\n}}"));
assert!(m.contains("temporary or a constant"), "{m}");
}
#[test]
fn error_indirect_mutation_is_found() {
// `outer` calls `inner`, which assigns: so `outer` mutates too
let m = check_err(
"struct A {\n n: int\n func inner() { n = 1 }\n func outer() { inner() }\n}\nfunc main() {\n const a = A{0}\n a.outer()\n}",
);
assert!(m.contains("`outer` changes `a`"), "{m}");
}
#[test]
fn error_assign_field_of_constant() {
let m = check_err(&format!("{POINT}func main() {{\n const k = P{{1, 2}}\n k.x = 5\n}}"));
assert!(m.contains("part of `k` because it is a constant"), "{m}");
}
#[test]
fn error_type_used_as_value() {
let m = check_err(&format!("{POINT}func main() {{\n var a = P\n}}"));
assert!(m.contains("is a type, not a value"), "{m}");
}
#[test]
fn error_struct_name_clash() {
let m = check_err("struct int { }\nfunc main() { }");
assert!(m.contains("built-in type"), "{m}");
let m = check_err("struct A { }\nfunc A() { }\nfunc main() { }");
assert!(m.contains("already defined"), "{m}");
}
// ---------- lists ----------
#[test]
fn index_out_of_range_panics() {
let o = run_source("func main() {\n var a = [1, 2]\n print(a[0])\n print(a[2])\n print(3)\n}");
assert_eq!(o.stdout, "1\n");
assert!(o.stderr.contains("index 2 is out of range (the length is 2)"), "{}", o.stderr);
assert_eq!(o.code, 2);
}
#[test]
fn negative_index_panics() {
let o = run_source("func main() {\n var a = [1]\n var i = 0 - 1\n print(a[i])\n}");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("index -1"), "{}", o.stderr);
}
#[test]
fn pop_from_empty_panics() {
let o = run_source("func main() {\n var a: []int\n a.pop()\n}");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("empty list"), "{}", o.stderr);
}
#[test]
fn bad_slice_panics() {
let o = run_source("func main() {\n var a = [1, 2, 3]\n var n = 5\n print(a[1..n])\n}");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("slice 1..5"), "{}", o.stderr);
let o = run_source("func main() {\n var a = [1, 2, 3]\n var lo = 2\n var hi = 1\n print(a[lo..hi])\n}");
assert_eq!(o.code, 2);
}
#[test]
fn slices_are_copies() {
let out = out_of("func main() {\n var a = [1, 2, 3, 4]\n var b = a[1..3]\n b[0] = 99\n print(a, b, a[0..0], a[4..])\n}");
assert_eq!(out, "[1, 2, 3, 4] [99, 3] [] []\n");
}
#[test]
fn list_growth_keeps_values() {
let out = out_of(
"func main() {\n var a: []int\n for i in 0..1000 { a.push(i * 2) }\n var s = 0\n for x in a { s += x }\n print(a.len(), a[999], s)\n}",
);
assert_eq!(out, "1000 1998 999000\n");
}
#[test]
fn lists_of_structs() {
let out = out_of(
"struct P { x, y: int\n func norm1(): int { return x + y } }\nfunc main() {\n var ps = [P{1, 2}, P{3, 4}]\n ps.push(P{5, 6})\n ps[0].x = 10\n var t = 0\n for p in ps { t += p.norm1() }\n print(ps, t)\n}",
);
assert_eq!(out, "[P{x: 10, y: 2}, P{x: 3, y: 4}, P{x: 5, y: 6}] 30\n");
}
#[test]
fn methods_that_change_list_fields_are_mutating() {
let out = out_of(
"struct Stack {\n items: []int\n func push_all(n: int) { for i in 0..n { items.push(i) } }\n func top(): int { return items[items.len() - 1] }\n func take(): int { return items.pop() }\n}\nfunc main() {\n var s: Stack\n s.push_all(4)\n print(s.top(), s.take(), s.top(), s.items)\n}",
);
assert_eq!(out, "3 3 2 [0, 1, 2]\n");
}
#[test]
fn index_with_side_effects_runs_once() {
let out = out_of(
"func idx(): int {\n print(\"idx\")\n return 1\n}\nfunc main() {\n var a = [10, 20, 30]\n a[idx()] += 5\n a[idx()] = a[idx()] * 2\n print(a)\n}",
);
assert_eq!(out, "idx\nidx\nidx\n[10, 50, 30]\n");
}
#[test]
fn read_before_push_in_one_expression() {
// the earlier read of the list sees the list as it was
let out = out_of("func main() {\n var a = [1]\n print(a, a.pop(), a)\n}");
assert_eq!(out, "[1] 1 []\n");
}
#[test]
fn returning_a_local_list_does_not_alias() {
let out = out_of(
"func make(): []int {\n var a = [1, 2]\n return a\n}\nfunc pass(xs: []int): []int {\n return xs\n}\nfunc main() {\n var a = make()\n var b = pass(a)\n b[0] = 9\n print(a, b)\n}",
);
assert_eq!(out, "[1, 2] [9, 2]\n");
}
#[test]
fn borrowed_parameter_is_not_copied() {
let src = "func total(xs: []int): int {\n var t = 0\n for x in xs { t += x }\n return t\n}\nfunc main() {\n var a = [1, 2, 3]\n print(total(a))\n}";
let c = driver::compile_to_c(src).unwrap();
assert!(c.contains("d_total(&a_"), "expected the list to be passed by address:\n{c}");
assert!(!c.contains("L_i64_copy(a_"), "the argument should not be copied");
}
#[test]
fn changed_parameter_is_copied() {
let src = "func grow(xs: []int): int {\n xs.push(1)\n return xs.len()\n}\nfunc main() {\n var a = [1, 2, 3]\n print(grow(a), a.len())\n}";
assert_eq!(out_of(src), "4 3\n");
}
#[test]
fn list_of_list_of_strings() {
let out = out_of("func main() {\n var g = [[\"a\"], [\"b\", \"c\"]]\n g[1].push(\"d\")\n print(g, g[1].len(), g[1][2])\n}");
assert_eq!(out, "[[a], [b, c, d]] 3 d\n");
}
#[test]
fn string_len_counts_bytes() {
let out = out_of("func main() {\n print(\"abc\".len(), \"\".len(), \"é\".len())\n}");
assert_eq!(out, "3 0 2\n");
}
#[test]
fn list_in_interpolation() {
let out = out_of("func main() {\n var a = [1, 2]\n print(\"a = {a}, n = {a.len()}\")\n}");
assert_eq!(out, "a = [1, 2], n = 2\n");
}
#[test]
fn loop_over_call_result() {
let out = out_of("func f(): []int {\n print(\"f\")\n return [7, 8]\n}\nfunc main() {\n for x in f() { print(x) }\n}");
assert_eq!(out, "f\n7\n8\n");
}
#[test]
fn error_list_element_type_mismatch() {
let m = check_err(&main_with("var a = [1, \"x\"]"));
assert!(m.contains("expected `int`, found `string`"), "{m}");
}
#[test]
fn error_empty_list_needs_a_type() {
let m = check_err(&main_with("var a = []"));
assert!(m.contains("write the type"), "{m}");
}
#[test]
fn error_wrong_push_type() {
let m = check_err(&main_with("var a = [1]\na.push(\"s\")"));
assert!(m.contains("expected `int`, found `string`"), "{m}");
}
#[test]
fn error_push_on_constant() {
let m = check_err(&main_with("const a = [1]\na.push(2)"));
assert!(m.contains("`push` changes `a`, but `a` is a constant"), "{m}");
}
#[test]
fn error_assign_index_of_constant() {
let m = check_err(&main_with("const a = [1]\na[0] = 2"));
assert!(m.contains("constant"), "{m}");
}
#[test]
fn error_push_on_temporary() {
let m = check_err("func f(): []int { return [1] }\nfunc main() {\n f().push(2)\n}");
assert!(m.contains("temporary"), "{m}");
}
#[test]
fn error_unknown_list_method() {
let m = check_err(&main_with("var a = [1]\na.reverse()"));
assert!(m.contains("no method `reverse`") && m.contains("len, push, pop"), "{m}");
}
#[test]
fn error_index_a_non_list() {
let m = check_err(&main_with("var a = 1\nprint(a[0])"));
assert!(m.contains("can't index a `int`"), "{m}");
// strings can be indexed since `char` exists
assert_eq!(out_of("func main() {\n var s = \"abc\"\n print(s[1])\n}"), "b\n");
}
#[test]
fn error_index_must_be_int() {
let m = check_err(&main_with("var a = [1]\nprint(a[1.5])"));
assert!(m.contains("expected `int`, found `float`"), "{m}");
}
#[test]
fn error_assign_to_slice() {
let m = check_err(&main_with("var a = [1, 2]\na[0..1] = [5]"));
assert!(m.contains("can't be assigned to"), "{m}");
}
#[test]
fn error_loop_over_int() {
let m = check_err(&main_with("var n = 3\nfor x in n { }"));
assert!(m.contains("can't loop over a `int`"), "{m}");
}
#[test]
fn error_step_with_list() {
let m = check_err(&main_with("var a = [1]\nfor x in a step 2 { }"));
assert!(m.contains("`step` only works with ranges"), "{m}");
}
#[test]
fn error_list_equality() {
let m = check_err(&main_with("var a = [1]\nvar b = [1]\nvar c = a == b"));
assert!(m.contains("doesn't work on `[]int`"), "{m}");
}
#[test]
fn error_const_list_not_yet() {
let m = check_err("const PRIMES = [2, 3, 5]\nfunc main() { }");
assert!(m.contains("not supported yet"), "{m}");
}
#[test]
fn error_wrong_list_argument() {
let m = check_err("func f(xs: []int) { }\nfunc main() {\n f([\"a\"])\n}");
assert!(m.contains("expected `int`, found `string`"), "{m}");
}
// ---------- enums and match ----------
const COLOR: &str = "enum Color { Red\n Green\n Blue }\n";
const SHAPE: &str = "enum Shape {\n Circle(r: float)\n Rect(w, h: float)\n Point\n}\n";
#[test]
fn match_evaluates_the_value_once() {
let out = out_of(&format!(
"{COLOR}func pick(): Color {{\n print(\"pick\")\n return Color.Blue\n}}\nfunc main() {{\n match pick() {{\n Red => print(1)\n Green => print(2)\n Blue => print(3)\n }}\n}}"
));
assert_eq!(out, "pick\n3\n");
}
#[test]
fn return_inside_match_arms_counts_as_returning() {
// every arm returns, so the function needs no `return` after the match
let out = out_of(&format!(
"{COLOR}func f(c: Color): int {{\n match c {{\n Red => {{ return 1 }}\n Green => {{ return 2 }}\n Blue => return 3\n }}\n}}\nfunc main() {{\n print(f(Color.Red), f(Color.Green), f(Color.Blue))\n}}"
));
assert_eq!(out, "1 2 3\n");
}
#[test]
fn return_arm_inside_a_value_match() {
let out = out_of(
"enum R { Ok(v: int)\n Err(m: string) }\nfunc f(r: R): int {\n var x = match r {\n Ok(v) => v * 2\n Err(_) => return -1\n }\n return x + 1\n}\nfunc main() {\n print(f(R.Ok(5)), f(R.Err(\"no\")))\n}",
);
assert_eq!(out, "11 -1\n");
}
#[test]
fn break_and_continue_inside_match_arms() {
let out = out_of(&format!(
"{COLOR}func main() {{\n var seen = 0\n for i in 0..10 {{\n var c = Color.Red\n if i % 3 == 1 {{ c = Color.Green }}\n if i == 7 {{ c = Color.Blue }}\n match c {{\n Red => continue\n Green => {{ seen += 1 }}\n Blue => break\n }}\n }}\n print(seen)\n}}"
));
assert_eq!(out, "2\n");
}
#[test]
fn enum_method_can_replace_self() {
let out = out_of(
"enum Light {\n Red\n Green\n Yellow\n func advance() {\n self = match self {\n Red => Light.Green\n Green => Light.Yellow\n Yellow => Light.Red\n }\n }\n}\nfunc main() {\n var l = Light.Red\n l.advance()\n l.advance()\n print(l)\n l.advance()\n print(l)\n}",
);
assert_eq!(out, "Light.Yellow\nLight.Red\n");
}
#[test]
fn enum_methods_call_each_other() {
let out = out_of(
"enum Shape {\n Circle(r: float)\n Rect(w, h: float)\n Point\n func area(): float {\n return match self {\n Circle(r) => r * r\n Rect(w, h) => w * h\n Point => 0\n }\n }\n func double_area(): float {\n return area() * 2\n }\n}\nfunc main() {\n print(Shape.Rect(2, 3).double_area())\n}",
);
assert_eq!(out, "12.0\n");
}
#[test]
fn list_of_enums_and_enum_in_struct() {
let out = out_of(&format!(
"{COLOR}struct Pixel {{ c: Color\n x: int }}\nfunc main() {{\n var ps = [Pixel{{Color.Blue, 1}}, Pixel{{x: 2}}]\n print(ps)\n var cs: []Color\n cs.push(Color.Green)\n print(cs, cs[0] == Color.Green)\n}}"
));
assert_eq!(out, "[Pixel{c: Color.Blue, x: 1}, Pixel{c: Color.Red, x: 2}]\n[Color.Green] true\n");
}
#[test]
fn match_binding_shadows_and_arms_have_their_own_scope() {
let out = out_of(&format!(
"{SHAPE}func main() {{\n var r = 100.0\n match Shape.Circle(1.5) {{\n Circle(r) => print(r)\n Rect(r, _) => print(r)\n Point => print(0)\n }}\n print(r)\n}}"
));
assert_eq!(out, "1.5\n100.0\n");
}
#[test]
fn match_on_negative_numbers_and_strings() {
let out = out_of(
"func sign(n: int): string {\n return match n {\n -1 => \"minus one\"\n 0 => \"zero\"\n _ => \"other\"\n }\n}\nfunc main() {\n print(sign(-1), sign(0), sign(5))\n var s = \"b\"\n print(match s {\n \"a\" => 1\n \"b\" => 2\n _ => 3\n })\n}",
);
assert_eq!(out, "minus one zero other\n2\n");
}
#[test]
fn catch_all_binding_takes_the_value() {
let out = out_of("func f(n: int): int {\n return match n {\n 0 => 100\n other => other * 2\n }\n}\nfunc main() {\n print(f(0), f(21))\n}");
assert_eq!(out, "100 42\n");
}
#[test]
fn value_match_arms_unify_int_literal_into_float() {
let out = out_of(&format!("{COLOR}func main() {{\n var x: float = match Color.Red {{\n Red => 1\n _ => 2.5\n }}\n print(x)\n}}"));
assert_eq!(out, "1.0\n");
}
#[test]
fn match_in_condition_with_side_effects_keeps_order() {
let out = out_of(&format!(
"{COLOR}func say(s: string): Color {{\n print(s)\n return Color.Red\n}}\nfunc main() {{\n var ok = match say(\"a\") {{\n Red => true\n _ => false\n }} && match say(\"b\") {{\n Red => true\n _ => false\n }}\n print(ok)\n}}"
));
assert_eq!(out, "a\nb\ntrue\n");
}
#[test]
fn payload_data_is_copied_when_changed() {
let out = out_of(
"enum E { L(xs: []int)\n N }\nfunc main() {\n var a = E.L([1, 2])\n match a {\n L(xs) => {\n xs.push(3)\n xs[0] = 9\n print(xs)\n }\n N => print(0)\n }\n print(a)\n}",
);
assert_eq!(out, "[9, 2, 3]\nE.L([1, 2])\n");
}
#[test]
fn changing_the_matched_variable_inside_an_arm() {
// the arm keeps seeing the value as it was when the match started
let out = out_of(
"enum E { L(xs: []int)\n N }\nfunc main() {\n var a = E.L([1, 2])\n match a {\n L(xs) => {\n a = E.N\n print(xs, a)\n }\n N => print(0)\n }\n}",
);
assert_eq!(out, "[1, 2] E.N\n");
}
#[test]
fn returning_a_match_binding_copies_it() {
let out = out_of(
"enum E { L(xs: []int) }\nfunc get(e: E): []int {\n return match e {\n L(xs) => xs\n }\n}\nfunc main() {\n var e = E.L([1])\n var a = get(e)\n a.push(2)\n print(a, e)\n}",
);
assert_eq!(out, "[1, 2] E.L([1])\n");
}
#[test]
fn enum_printing_with_strings_and_nesting() {
let out = out_of(
"enum In { A(n: int)\n B }\nenum Out { W(i: In, s: string)\n Z }\nfunc main() {\n print(Out.W(In.A(3), \"x\"), Out.W(In.B, \"y\"), Out.Z)\n}",
);
assert_eq!(out, "Out.W(In.A(3), x) Out.W(In.B, y) Out.Z\n");
}
#[test]
fn enums_declared_after_use_and_inside_each_other() {
let out = out_of(
"struct Holder { s: Shape }\nfunc main() {\n var h = Holder{Shape.Circle(2)}\n print(h)\n}\nenum Shape { Circle(r: float) }",
);
assert_eq!(out, "Holder{s: Shape.Circle(2.0)}\n");
}
// ---------- enum and match errors ----------
#[test]
fn error_match_missing_cases_are_listed() {
let m = check_err(&format!("{COLOR}func main() {{\n match Color.Red {{\n Red => print(1)\n }}\n}}"));
assert!(m.contains("doesn't handle Color.Green, Color.Blue"), "{m}");
}
#[test]
fn error_match_int_needs_catch_all() {
let m = check_err("func main() {\n match 1 {\n 1 => print(1)\n }\n}");
assert!(m.contains("add a `_` case"), "{m}");
}
#[test]
fn error_match_bool_incomplete() {
let m = check_err("func main() {\n match true {\n true => print(1)\n }\n}");
assert!(m.contains("doesn't handle false"), "{m}");
}
#[test]
fn error_match_duplicate_case() {
let m = check_err(&format!("{COLOR}func main() {{\n match Color.Red {{\n Red => print(1)\n Red => print(2)\n _ => print(3)\n }}\n}}"));
assert!(m.contains("already handled"), "{m}");
let m = check_err("func main() {\n match 1 {\n 1 => print(1)\n 1 => print(2)\n _ => print(3)\n }\n}");
assert!(m.contains("already handled"), "{m}");
}
#[test]
fn error_match_unreachable_case() {
let m = check_err(&format!("{COLOR}func main() {{\n match Color.Red {{\n _ => print(1)\n Red => print(2)\n }}\n}}"));
assert!(m.contains("can never match"), "{m}");
let m = check_err("func main() {\n match 1 {\n x => print(x)\n 2 => print(2)\n }\n}");
assert!(m.contains("can never match"), "{m}");
}
#[test]
fn error_match_unknown_case_is_not_a_silent_binding() {
let m = check_err(&format!("{COLOR}func main() {{\n match Color.Red {{\n Red => print(1)\n Gren => print(2)\n Blue => print(3)\n }}\n}}"));
assert!(m.contains("no case `Gren`") && m.contains("Red, Green, Blue"), "{m}");
}
#[test]
fn error_match_case_with_data_needs_parentheses() {
let m = check_err(&format!("{SHAPE}func main() {{\n match Shape.Point {{\n Circle => print(1)\n _ => print(2)\n }}\n}}"));
assert!(m.contains("carries data") && m.contains("Circle(_)"), "{m}");
}
#[test]
fn error_match_wrong_number_of_pieces() {
let m = check_err(&format!("{SHAPE}func main() {{\n match Shape.Point {{\n Rect(w) => print(w)\n _ => print(2)\n }}\n}}"));
assert!(m.contains("carries w: float, h: float"), "{m}");
let m = check_err(&format!("{SHAPE}func main() {{\n match Shape.Point {{\n Point(x) => print(x)\n _ => print(2)\n }}\n}}"));
assert!(m.contains("has no data"), "{m}");
}
#[test]
fn error_match_nested_pattern_not_yet() {
let m = check_err(&format!("{SHAPE}enum Wrap {{ W(s: Shape) }}\nfunc main() {{\n match Wrap.W(Shape.Point) {{\n W(Point) => print(1)\n _ => print(2)\n }}\n}}"));
assert!(m.contains("not supported yet") || m.contains("lowercase"), "{m}");
}
#[test]
fn error_match_arms_of_different_types() {
let m = check_err(&format!("{COLOR}func main() {{\n var x = match Color.Red {{\n Red => 1\n _ => \"s\"\n }}\n}}"));
assert!(m.contains("expected `int`, found `string`"), "{m}");
}
#[test]
fn error_match_value_arm_must_be_one_expression() {
let m = check_err(&format!("{COLOR}func main() {{\n var x = match Color.Red {{\n Red => {{\n print(1)\n }}\n _ => 2\n }}\n}}"));
assert!(m.contains("single expression"), "{m}");
}
#[test]
fn error_match_on_unsupported_type() {
let m = check_err("func main() {\n match 1.5 {\n _ => print(1)\n }\n}");
assert!(m.contains("can't `match` on a `float`"), "{m}");
let m = check_err("struct P { x: int }\nfunc main() {\n var p: P\n match p {\n _ => print(1)\n }\n}");
assert!(m.contains("can't `match` on a `P`"), "{m}");
}
#[test]
fn error_match_pattern_of_wrong_kind() {
let m = check_err("func main() {\n match 1 {\n true => print(1)\n _ => print(2)\n }\n}");
assert!(m.contains("this is a bool"), "{m}");
let m = check_err(&format!("{COLOR}func main() {{\n match Color.Red {{\n 1 => print(1)\n _ => print(2)\n }}\n}}"));
assert!(m.contains("this is a number"), "{m}");
}
#[test]
fn error_enum_construction() {
let m = check_err(&format!("{SHAPE}func main() {{\n var s = Shape.Circle()\n}}"));
assert!(m.contains("`Shape.Circle` needs 1 value: (r: float)"), "{m}");
let m = check_err(&format!("{SHAPE}func main() {{\n var s = Shape.Point(1)\n}}"));
assert!(m.contains("has no data, so write it without parentheses"), "{m}");
let m = check_err(&format!("{SHAPE}func main() {{\n var s = Shape.Circle\n}}"));
assert!(m.contains("needs 1 value"), "{m}");
let m = check_err(&format!("{SHAPE}func main() {{\n var s = Shape.Triangle(1)\n}}"));
assert!(m.contains("no case `Triangle`") && m.contains("Circle, Rect, Point"), "{m}");
let m = check_err(&format!("{SHAPE}func main() {{\n var s = Shape.Circle(\"x\")\n}}"));
assert!(m.contains("expected `float`, found `string`"), "{m}");
}
#[test]
fn error_enum_name_alone_is_a_type() {
let m = check_err(&format!("{SHAPE}func main() {{\n var s = Shape\n}}"));
assert!(m.contains("is a type, not a value") && m.contains("Shape.Circle"), "{m}");
}
#[test]
fn error_enum_has_no_fields() {
let m = check_err(&format!("{SHAPE}func main() {{\n var s = Shape.Point\n print(s.r)\n}}"));
assert!(m.contains("use `match`"), "{m}");
}
#[test]
fn error_enum_equality_only_without_data() {
let m = check_err(&format!("{SHAPE}func main() {{\n var a = Shape.Point\n print(a == Shape.Point)\n}}"));
assert!(m.contains("doesn't work on `Shape`") && m.contains("use `match`"), "{m}");
}
#[test]
fn error_enum_declarations() {
let m = check_err("enum E { }\nfunc main() { }");
assert!(m.contains("at least one case"), "{m}");
let m = check_err("enum E { A\n A }\nfunc main() { }");
assert!(m.contains("two cases named `A`"), "{m}");
let m = check_err("enum E { A(x: int, x: int) }\nfunc main() { }");
assert!(m.contains("two values named `x`"), "{m}");
let m = check_err("enum E { A(e: E) }\nfunc main() { }");
assert!(m.contains("enum `E` contains itself"), "{m}");
let m = check_err("struct S { e: E }\nenum E { A(s: S) }\nfunc main() { }");
assert!(m.contains("contains itself"), "{m}");
let m = check_err("enum E { A }\nstruct E { }\nfunc main() { }");
assert!(m.contains("already defined"), "{m}");
}
#[test]
fn error_mutating_enum_method_on_constant() {
let m = check_err(
"enum L { A\n B\n func flip() { self = L.B } }\nfunc main() {\n const l = L.A\n l.flip()\n}",
);
assert!(m.contains("`flip` changes `l`, but `l` is a constant"), "{m}");
}
#[test]
fn error_unknown_enum_method() {
let m = check_err(&format!("{COLOR}func main() {{\n var c = Color.Red\n c.paint()\n}}"));
assert!(m.contains("enum `Color` has no method `paint`"), "{m}");
}
// ---------- errors and optionals ----------
#[test]
fn main_error_prints_and_exits_1() {
let o = run_source("func main(): error {\n print(1)\n return error(\"boom {2}\")\n}");
assert_eq!(o.stdout, "1\n");
assert_eq!(o.stderr, "error: boom 2\n");
assert_eq!(o.code, 1);
}
#[test]
fn main_error_nil_exits_0() {
let o = run_source("func main(): error {\n print(1)\n return nil\n}");
assert_eq!(o.code, 0, "{}", o.stderr);
}
#[test]
fn error_shorthand_fills_zero_values_for_several_results() {
let out = out_of(
"func a(n: int): (int, string, error) {\n if n > 0 { return n, \"x\", nil }\n return error(\"neg\")\n}\n\
func b(n: int): (int, error) {\n var v, s, e = a(n)\n if e != nil { return e }\n return v + s.len(), nil\n}\n\
func main() {\n var r, e = b(-1)\n print(r, e)\n var r2, e2 = b(4)\n print(r2, e2)\n}",
);
assert_eq!(out, "0 neg\n5 nil\n");
}
#[test]
fn try_in_the_middle_of_an_expression_keeps_order() {
let out = out_of(
"func f(n: int): (int, error) {\n print(\"f\", n)\n if n == 2 { return error(\"two\") }\n return n, nil\n}\n\
func g(): (int, error) {\n var s = f(1)? + f(2)? + f(3)?\n return s, nil\n}\n\
func main() {\n var v, e = g()\n print(v, e)\n}",
);
assert_eq!(out, "f 1\nf 2\n0 two\n");
}
#[test]
fn try_inside_a_condition_and_loop() {
let out = out_of(
"func ok(n: int): (bool, error) {\n if n == 3 { return error(\"three\") }\n return n < 5, nil\n}\n\
func run(): error {\n for i in 0..10 {\n if ok(i)? { print(i) }\n }\n return nil\n}\n\
func main() {\n var e = run()\n print(e)\n}",
);
assert_eq!(out, "0\n1\n2\nthree\n");
}
#[test]
fn optional_struct_and_list_values_are_copied() {
let out = out_of(
"func pick(xs: []int): []int? {\n return xs\n}\n\
func main() {\n var a = [1, 2]\n var b = pick(a)\n a.push(3)\n print(a, b)\n\
var c: []int? = a\n a.push(4)\n print(a, c)\n}",
);
assert_eq!(out, "[1, 2, 3] [1, 2]\n[1, 2, 3, 4] [1, 2, 3]\n");
}
#[test]
fn narrowing_covers_if_early_exit_and_and_or() {
let out = out_of(
"func f(x: int?): int {\n if x == nil { return -1 }\n return x * 2\n}\n\
func g(x: int?): string {\n if x != nil && x > 5 { return \"big\" }\n if x == nil || x < 0 { return \"none or negative\" }\n return \"small\"\n}\n\
func main() {\n print(f(4), f(nil), g(9), g(nil), g(-1), g(2))\n}",
);
assert_eq!(out, "8 -1 big none or negative none or negative small\n");
}
#[test]
fn narrowing_is_forgotten_after_assignment() {
let m = check_err("func main() {\n var x: int? = 3\n if x != nil {\n x = nil\n print(x + 1)\n }\n}");
assert!(m.contains("can't use `+` between `int?` and `int`"), "{m}");
}
#[test]
fn narrowing_in_a_loop_stays_safe_at_runtime() {
// x is assigned later in the body, so the use at the top of the next round sees nil
let o = run_source(
"func main() {\n var x: int? = 1\n for i in 0..3 {\n if x == nil { break }\n print(x)\n x = nil\n }\n}",
);
assert_eq!(o.stdout, "1\n");
assert_eq!(o.code, 0, "{}", o.stderr);
}
#[test]
fn narrowing_reaches_fields_and_methods() {
let out = out_of(
"struct S {\n n: int\n func twice(): int { return n * 2 }\n}\n\
func main() {\n var s: S? = S{4}\n if s != nil {\n print(s.n, s.twice())\n }\n}",
);
assert_eq!(out, "4 8\n");
}
#[test]
fn discard_with_underscore_and_error_values_print() {
let out = out_of(
"func f(): (int, error) {\n return 1, error(\"x\")\n}\n\
func main() {\n var _, e = f()\n print(e)\n var n: error\n print(n == nil, e != nil)\n}",
);
assert_eq!(out, "x\ntrue true\n");
}
#[test]
fn optional_as_struct_return_through_match() {
let out = out_of(
"enum Shape { Circle(r: float)\n Dot }\n\
func find(n: int): Shape? {\n if n > 0 { return Shape.Circle(1.5) }\n return nil\n}\n\
func main() {\n var s = find(1)\n if s != nil {\n match s {\n Circle(r) => print(\"circle\", r)\n Dot => print(\"dot\")\n }\n }\n}",
);
assert_eq!(out, "circle 1.5\n");
}
#[test]
fn generated_c_for_errors_is_clean() {
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/basics");
for name in ["errors", "optionals", "sized", "own_strings", "own_structs", "own_flows"] {
let src = std::fs::read_to_string(format!("{dir}/{name}.rex")).unwrap();
let c = driver::compile_to_c(&src).unwrap();
let exe = driver::temp_exe();
driver::build_exe_with(&c, &exe, &["-std=c11", "-Wall", "-Werror=incompatible-pointer-types"])
.unwrap_or_else(|e| panic!("{name}: {e}"));
let _ = std::fs::remove_file(&exe);
}
}
#[test]
fn error_try_needs_an_error_returning_function() {
let m = check_err("func f(): (int, error) { return 1, nil }\nfunc main() {\n var x = f()?\n}");
assert!(m.contains("this function must return an `error`"), "{m}");
}
#[test]
fn error_try_on_non_error() {
let m = check_err("func f(): int { return 1 }\nfunc g(): error {\n var x = f()?\n return nil\n}\nfunc main() { }");
assert!(m.contains("`?` needs a call that returns an error"), "{m}");
}
#[test]
fn error_ignored_error() {
let m = check_err("func f(): error { return nil }\nfunc main() {\n f()\n}");
assert!(m.contains("its error is ignored"), "{m}");
}
#[test]
fn error_several_values_used_as_one() {
let m = check_err("func f(): (int, error) { return 1, nil }\nfunc main() {\n var x = f()\n}");
assert!(m.contains("returns several values"), "{m}");
}
#[test]
fn error_wrong_number_of_names_and_returns() {
let m = check_err("func f(): (int, error) { return 1, nil }\nfunc main() {\n var a, b, c = f()\n}");
assert!(m.contains("but 3 names are listed"), "{m}");
let m = check_err("func f(): (int, error) { return 1 }\nfunc main() { }");
assert!(m.contains("needs 2 values"), "{m}");
}
#[test]
fn error_nil_without_a_type() {
let m = check_err("func main() {\n var x = nil\n}");
assert!(m.contains("can't tell what `nil` stands for"), "{m}");
}
#[test]
fn error_nil_for_plain_type() {
let m = check_err("func main() {\n var x: int = nil\n}");
assert!(m.contains("can't tell what `nil`") || m.contains("expected `int`"), "{m}");
let m = check_err("func main() {\n var x = 1\n if x == nil { }\n}");
assert!(m.contains("can never be nil"), "{m}");
}
#[test]
fn error_optional_used_without_check() {
let m = check_err("func main() {\n var x: int? = 3\n print(x + 1)\n}");
assert!(m.contains("`+` between `int?` and `int`") || m.contains("can't use `+`"), "{m}");
}
#[test]
fn error_optional_in_struct_not_supported_yet() {
let m = check_err("struct S { x: int? }\nfunc main() { }");
assert!(m.contains("not supported yet"), "{m}");
}
// ---------- colon syntax for types ----------
#[test]
fn colon_syntax_everywhere() {
let out = out_of(
"struct P { x, y: int\n tag: string }\nenum E { A(n: int)\n B(a, b: float) }\n\
func add(a, b: int): int { return a + b }\n\
func name(p: P): string { return p.tag }\n\
func main() {\n var n: int = add(1, 2)\n var xs: []int\n xs.push(n)\n var e: E = E.A(4)\n var p: P = P{1, 2, \"t\"}\n print(xs, e, name(p))\n}",
);
assert_eq!(out, "[3] E.A(4) t\n");
}
#[test]
fn error_missing_colons_are_explained() {
let m = check_err("func f(a int) { }\nfunc main() { }");
assert!(m.contains("`:` and then the type"), "{m}");
let m = check_err("func f(): int { return 1 }\nfunc g() int { return 1 }\nfunc main() { }");
assert!(m.contains("`:` before the return type"), "{m}");
let m = check_err("func main() {\n var x int = 1\n}");
assert!(m.contains("`:` and then the type"), "{m}");
let m = check_err("struct S { x int }\nfunc main() { }");
assert!(m.contains("`:` and then the type of the field"), "{m}");
}
// ---------- sized numbers ----------
#[test]
fn i64_and_f64_are_int_and_float() {
let out = out_of(
"func f(a: i64): f64 { return float(a) / 2 }\nfunc main() {\n var x: int = 5\n var y: float = f(x)\n print(y)\n}",
);
assert_eq!(out, "2.5\n");
}
#[test]
fn sized_integers_wrap_around() {
let out = out_of(
"func main() {\n var a: u8 = 255\n a += 1\n var b: i8 = 127\n b += 1\n var c: u16 = 0\n c -= 1\n var d: u32 = 4000000000\n d += d\n var e: i16 = -32768\n e = -e\n print(a, b, c, d, e)\n}",
);
assert_eq!(out, "0 -128 65535 3705032704 -32768\n");
}
#[test]
fn sized_division_checks_zero_and_min() {
let o = run_source("func main() {\n var m: i32 = -2147483647 - 1\n var d: i32 = -1\n print(m / d, m % d)\n var z: u64 = 0\n print(1 / z)\n}");
assert_eq!(o.stdout, "-2147483648 0\n");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("division by zero"), "{}", o.stderr);
}
#[test]
fn big_u64_values() {
let out = out_of(
"func main() {\n var x: u64 = 9223372036854775807\n x = x * 2 + 1\n print(x, x / 3, x > 5)\n print(u64(-1), u64(1000000000000000000000000.0), float(x))\n}",
);
assert_eq!(out, "18446744073709551615 6148914691236517205 true\n18446744073709551615 18446744073709551615 1.84467440737096e+19\n");
}
#[test]
fn f32_arithmetic_and_printing() {
let out = out_of(
"func main() {\n var a: f32 = 0.1\n var b: f32 = 0.2\n print(a + b, f64(a + b) == 0.3, a * 3)\n var big: f32 = 16777216\n print(big + 1)\n print(f32(1) / f32(3))\n}",
);
assert_eq!(out, "0.3 false 0.3\n16777216.0\n0.33333334\n");
}
#[test]
fn literals_adapt_in_every_place() {
let out = out_of(
"struct P { hp: u8\n speed: f32 }\nfunc heal(p: P, n: u8): u8 { return p.hp + n }\n\
func main() {\n var p = P{100, 2}\n print(heal(p, 200), p.speed * 2)\n}",
);
assert_eq!(out, "44 4.0\n");
}
#[test]
fn sized_values_in_lists_options_and_errors() {
let out = out_of(
"func half(n: u8): (u8, error) {\n if n % 2 == 1 { return error(\"odd\") }\n return n / 2, nil\n}\n\
func main() {\n var xs: []u8 = [4, 7]\n for x in xs {\n var h, e = half(x)\n print(h, e)\n }\n var o: i16? = 5\n if o != nil { print(o + 1) }\n}",
);
assert_eq!(out, "2 nil\n0 odd\n6\n");
}
#[test]
fn error_mixing_number_types() {
let m = check_err("func main() {\n var a: i32 = 1\n var b: i64 = 2\n print(a + b)\n}");
assert!(m.contains("can't use `+` between `i32` and `int`"), "{m}");
let m = check_err("func main() {\n var a: u8 = 1\n var b: int = a\n}");
assert!(m.contains("expected `int`, found `u8` (convert it with `int(...)`)"), "{m}");
}
#[test]
fn error_literal_out_of_range() {
let m = check_err("func main() {\n var a: u8 = 256\n}");
assert!(m.contains("256 doesn't fit in a `u8` (it holds 0 to 255)"), "{m}");
let m = check_err("func main() {\n var a: i8 = -129\n}");
assert!(m.contains("-129 doesn't fit in a `i8`"), "{m}");
let m = check_err("func main() {\n var a: u32 = -1\n}");
assert!(m.contains("-1 doesn't fit in a `u32`"), "{m}");
let m = check_err("func main() {\n var a: u8 = 1\n var b = a + 300\n}");
assert!(m.contains("300 doesn't fit in a `u8`"), "{m}");
}
#[test]
fn error_negating_unsigned_and_float_remainder() {
let m = check_err("func main() {\n var a: u8 = 1\n print(-a)\n}");
assert!(m.contains("can't be negative"), "{m}");
let m = check_err("func main() {\n var a: f32 = 1\n print(a % 2)\n}");
assert!(m.contains("`%` doesn't work on `f32`"), "{m}");
}
#[test]
fn error_float_literal_for_integer_type() {
let m = check_err("func main() {\n var a: u8 = 1.5\n}");
assert!(m.contains("expected `u8`, found `float`"), "{m}");
}
// ---------- modules: `import utils` ----------
fn project_c(main: &str, modules: &[(&str, &str)]) -> Result<String, String> {
driver::compile_project("main.rex", main, |key| {
modules.iter().find(|(k, _)| *k == key).map(|(k, src)| (format!("{k}.rex"), src.to_string()))
})
}
fn run_project(main: &str, modules: &[(&str, &str)]) -> String {
let c = project_c(main, modules).unwrap_or_else(|e| panic!("{e}"));
run_c(&c, main).stdout
}
const UTILS: &str = "pub const SCALE = 10
pub struct Vec2 {
pub x, y: float
pub func len2(): float { return x * x + y * y }
func secret(): int { return 1 }
}
pub enum Shape {
Circle(r: float)
Point
}
pub func double(n: int): int { return n * 2 * SCALE / 10 }
pub func shout(s: string): string { return s.upper() + helper() }
func helper(): string { return \"!\" }
pub func area(s: Shape): float {
return match s {
Circle(r) => r * r * 3.0
Point => 0.0
}
}
pub func make(): []Vec2 { return [Vec2{1.0, 2.0}] }
";
#[test]
fn import_user_module() {
let main = "import utils
func main() {
print(utils.double(21), utils.SCALE)
var v = utils.Vec2{3.0, 4.0}
print(v.len2())
print(utils.shout(\"hey\"))
var s = utils.Shape.Circle(2.0)
print(utils.area(s), utils.area(utils.Shape.Point))
var xs = utils.make()
print(xs.len())
}";
assert_eq!(run_project(main, &[("utils", UTILS)]), "42 10\n25.0\nHEY!\n12.0 0.0\n1\n");
}
#[test]
fn module_types_in_signatures() {
let main = "import utils
func total(v: utils.Vec2, s: utils.Shape): float { return v.len2() + utils.area(s) }
func main() { print(total(utils.Vec2{1.0, 1.0}, utils.Shape.Circle(1.0))) }";
assert_eq!(run_project(main, &[("utils", UTILS)]), "5.0\n");
}
#[test]
fn modules_can_use_each_other_and_share_names() {
let a = "import b
pub func f(): int { return b.f() + 1 }";
let b = "pub func f(): int { return 10 }";
let main = "import a
import b
func f(): int { return 100 }
func main() { print(f(), a.f(), b.f()) }";
assert_eq!(run_project(main, &[("b", b), ("a", a)]), "100 11 10\n");
}
#[test]
fn nested_module_path() {
let main = "import tools.math2
func main() { print(math2.twice(4)) }";
let m = "pub func twice(n: int): int { return n * 2 }";
assert_eq!(run_project(main, &[("tools.math2", m)]), "8\n");
}
fn project_err(main: &str, modules: &[(&str, &str)]) -> String {
project_c(main, modules).unwrap_err()
}
#[test]
fn error_private_function() {
let e = project_err("import utils\nfunc main() { print(utils.helper()) }", &[("utils", UTILS)]);
assert!(e.contains("`helper` is private to `utils`"), "{e}");
assert!(e.contains("main.rex:2"), "{e}");
}
#[test]
fn error_private_method() {
let e = project_err(
"import utils\nfunc main() { var v = utils.Vec2{1.0, 2.0}\nprint(v.secret()) }",
&[("utils", UTILS)],
);
assert!(e.contains("method `secret` is private"), "{e}");
}
#[test]
fn error_private_type() {
let m = "struct Hidden { x: int }\npub func f() {}";
let e = project_err("import m\nfunc main() { var h = m.Hidden{1} }", &[("m", m)]);
assert!(e.contains("`Hidden` is private to `m`"), "{e}");
}
#[test]
fn error_in_module_names_that_file() {
let e = project_err("import bad\nfunc main() { print(bad.f()) }", &[("bad", "pub func f(): int { return \"x\" }")]);
assert!(e.contains("bad.rex:1"), "{e}");
assert!(e.contains("expected `int`"), "{e}");
}
#[test]
fn error_syntax_error_in_module() {
let e = project_err("import bad\nfunc main() {}", &[("bad", "func f( {")]);
assert!(e.contains("bad.rex"), "{e}");
}
#[test]
fn error_missing_module() {
let e = project_err("import nope\nfunc main() {}", &[]);
assert!(e.contains("cannot find module `nope`") && e.contains("nope.rex"), "{e}");
}
#[test]
fn error_circular_import() {
let e = project_err("import a\nfunc main() {}", &[("a", "import b"), ("b", "import a")]);
assert!(e.contains("circular import: a -> b -> a"), "{e}");
}
#[test]
fn error_unknown_name_in_module() {
let e = project_err("import utils\nfunc main() { print(utils.nothing(1)) }", &[("utils", UTILS)]);
assert!(e.contains("unknown function `nothing`"), "{e}");
}
#[test]
fn error_module_does_not_see_main_or_other_imports() {
// `b` imports nothing, so it can't use `os`
let e = project_err("import b\nfunc main() { print(b.f()) }", &[("b", "pub func f(): int { return os.exists(\"x\") }")]);
assert!(e.contains("b.rex"), "{e}");
}
#[test]
fn error_private_field() {
let m = "pub struct P {\n pub a: int\n b: int\n}\npub func make(): P { return P{1, 2} }";
let e = project_err("import m\nfunc main() { var p = m.make()\nprint(p.b) }", &[("m", m)]);
assert!(e.contains("field `b` is private to `m`"), "{e}");
let e = project_err("import m\nfunc main() { var p = m.P{a: 1, b: 2} }", &[("m", m)]);
assert!(e.contains("field `b` is private"), "{e}");
assert_eq!(run_project("import m\nfunc main() { var p = m.P{a: 5}\nprint(p.a, m.make().a) }", &[("m", m)]), "5 1\n");
}
// ---------- move on last use ----------
fn c_of(src: &str) -> String {
driver::compile_to_c(src).unwrap_or_else(|d| panic!("{}", d.render("test.rex", src)))
}
#[test]
fn last_use_moves_instead_of_copying() {
let src = "func main() {
var a = [1, 2, 3]
var b = a
b.push(4)
print(b)
}";
let c = c_of(src);
let main_fn = &c[c.rfind("void d_main(void) {").unwrap()..];
assert!(!main_fn.contains("_copy("), "the list should have been moved, not copied");
assert_eq!(out_of(src), "[1, 2, 3, 4]\n");
}
#[test]
fn later_use_still_copies() {
let src = "func main() {
var a = [1, 2, 3]
var b = a
b.push(4)
print(a, b)
}";
let c = c_of(src);
assert!(c[c.rfind("void d_main(void) {").unwrap()..].contains("_copy("));
assert_eq!(out_of(src), "[1, 2, 3] [1, 2, 3, 4]\n");
}
#[test]
fn moves_inside_loops_are_not_done() {
let src = "func main() {
var a = [1]
for i in 0..3 {
var b = a
b.push(i)
print(b)
}
}";
assert_eq!(out_of(src), "[1, 0]\n[1, 1]\n[1, 2]\n");
}
#[test]
fn moves_after_a_loop_and_in_branches() {
let src = "struct Box {
xs: []int
tag: string
}
func main() {
var a = Box{[1, 2], \"t\"}
for i in 0..2 { print(a.xs.len()) }
var s = \"hello\"
var t = s
var flag = true
if flag {
var c = a
c.xs.push(9)
print(c.xs, c.tag, t)
} else {
print(\"no\")
}
}";
assert_eq!(out_of(src), "2\n2\n[1, 2, 9] t hello\n");
}
#[test]
fn same_statement_twice_is_not_moved() {
let src = "func join(a: []int, b: []int): []int {
var r = a
for x in b { r.push(x) }
return r
}
func main() {
var a = [1, 2]
print(join(a, a))
var s = \"x\"
var p = [s, s]
print(p)
}";
assert_eq!(out_of(src), "[1, 2, 1, 2]\n[x, x]\n");
}
#[test]
fn moved_value_in_calls_and_structs() {
let src = "struct W { xs: []int }
func take(xs: []int): int { xs.push(1)
return xs.len() }
func main() {
var a = [5, 6]
var w = W{a}
var b = [7]
print(take(b))
var e = \"err\"
var r = error(e)
print(w.xs, r)
}";
assert_eq!(out_of(src), "2\n[5, 6] err\n");
}
// ---------- generic functions ----------
const GENERICS: &str = "func max[T: Ordered](a, b: T): T {
if a > b { return a }
return b
}
func first[T](xs: []T): T { return xs[0] }
func pair[A, B](a: A, b: B): string { return \"{a}/{b}\" }
func sum[T: Number](xs: []T): T {
var total: T = 0
for x in xs { total += x }
return total
}
func count_down[T: Number](n: T): T {
if n <= 0 { return n }
return count_down(n - 1)
}
struct P { x: int }
";
fn generic_err(body: &str) -> String {
let src = format!("{GENERICS}func main() {{\n{body}\n}}");
driver::compile_to_c(&src).map(|_| String::new()).unwrap_or_else(|d| d.msg)
}
#[test]
fn generic_functions_work_for_each_type() {
let src = format!(
"{GENERICS}func main() {{
print(max(3, 9), max(2.5, 1), max(\"a\", \"b\"))
var small: u8 = 7
print(max(small, 200))
print(first([10, 20]), first([\"x\", \"y\"]), first([P{{4}}]))
print(pair(1, \"z\"), pair(true, 2.5))
print(sum([1, 2, 3]), sum([1.5, 2.5]), count_down(3), count_down(2.0))
var names = [\"b\", \"a\"]
var f = first(names)
names.push(\"c\")
print(f, names.len())
}}"
);
assert_eq!(
out_of(&src),
"9 2.5 b\n200\n10 x P{x: 4}\n1/z true/2.5\n6 4.0 0 0.0\nb 3\n"
);
}
#[test]
fn generic_errors_are_clear() {
let e = generic_err("print(max(1, 2.5, 3))");
assert!(e.contains("takes 2 arguments"), "{e}");
let e = generic_err("var a: u8 = 1\nvar b: i32 = 2\nprint(max(a, b))");
assert!(e.contains("`T` is `u8` from an earlier argument, but this one is `i32`"), "{e}");
let e = generic_err("print(max(P{1}, P{2}))");
assert!(e.contains("needs `T` to be a number or a string"), "{e}");
let e = generic_err("print(sum([\"a\"]))");
assert!(e.contains("needs `T` to be a number"), "{e}");
let e = generic_err("var e: []int\nprint(max(e, e))");
assert!(e.contains("needs `T`"), "{e}");
}
#[test]
fn generic_declaration_errors() {
let e = driver::compile_to_c("func f[T: Whatever](a: T) {}\nfunc main() {}").unwrap_err().msg;
assert!(e.contains("unknown rule for `T`"), "{e}");
let e = driver::compile_to_c("func f[T](a: int) {}\nfunc main() {}").unwrap_err().msg;
assert!(e.contains("needs at least one parameter that uses its type"), "{e}");
}
#[test]
fn generic_error_inside_body_names_the_types() {
let src = "func bad[T](a: T): T { return a + a }\nfunc main() { print(bad(true)) }";
let e = driver::compile_to_c(src).unwrap_err().msg;
assert!(e.contains("bool"), "{e}");
}
#[test]
fn generic_functions_across_modules() {
let m = "pub func twice[T: Number](x: T): T { return x + x }\npub func helper[T](x: T): T { return x }";
let main = "import m\nfunc main() { print(m.twice(4), m.twice(1.5)) }";
assert_eq!(run_project(main, &[("m", m)]), "8 3.0\n");
let e = project_err("import m\nfunc main() { print(m.twice(true)) }", &[("m", m)]);
assert!(e.contains("needs `T` to be a number"), "{e}");
}
// ---------- generic structs and enums ----------
fn type_err(src: &str) -> String {
driver::compile_to_c(src).map(|_| String::new()).unwrap_or_else(|d| d.msg)
}
const BOX: &str = "struct Box[T] {
v: T
func get(): T { return v }
func set(x: T) { v = x }
}
enum Opt2[T] {
Has(x: T)
Not
}
";
#[test]
fn generic_struct_with_different_types_and_nesting() {
let src = format!(
"{BOX}func main() {{
var a = Box[int]{{5}}
var b = Box[string]{{v: \"hi\"}}
var c = Box[Box[int]]{{a}}
a.set(6)
print(a.get(), b.get(), c.get().get(), c)
var l = Box[[]int]{{[1, 2]}}
l.v.push(3)
print(l.get())
var o = Opt2[float].Has(1.5)
print(o, Opt2[float].Not)
}}"
);
assert_eq!(out_of(&src), "6 hi 5 Box[Box[int]]{v: Box[int]{v: 5}}\n[1, 2, 3]\nOpt2[float].Has(1.5) Opt2[float].Not\n");
}
#[test]
fn generic_type_errors() {
let e = type_err(&format!("{BOX}func main() {{ var a = Box{{1}} }}"));
assert!(e.contains("`Box` needs types"), "{e}");
let e = type_err(&format!("{BOX}func main() {{ var a: Box }}"));
assert!(e.contains("`Box` needs types"), "{e}");
let e = type_err(&format!("{BOX}func main() {{ var a: Box[int, int] }}"));
assert!(e.contains("takes 1 type"), "{e}");
let e = type_err(&format!("{BOX}func main() {{ var a = Box[int]{{\"x\"}} }}"));
assert!(e.contains("expected `int`"), "{e}");
let e = type_err("struct P { x: int }\nfunc main() { var a: P[int] }");
assert!(e.contains("not a generic type"), "{e}");
let e = type_err("struct S[T: Number] { v: T }\nfunc main() { var a: S[string] }");
assert!(e.contains("needs `T` to be a number"), "{e}");
let e = type_err("struct S[T] { v: T }\nstruct S[U] { v: U }\nfunc main() {}");
assert!(e.contains("already defined"), "{e}");
}
#[test]
fn indexing_still_works_next_to_generics() {
let src = format!(
"{BOX}func main() {{
var Xs = [1, 2, 3]
var i = 1
print(Xs[i], Xs[0] + Xs[2])
var b = Box[int]{{Xs[i]}}
print(b.v)
}}"
);
assert_eq!(out_of(&src), "2 4\n2\n");
}
#[test]
fn generic_types_across_modules() {
let m = "pub struct Stack[T] {
pub items: []T
pub func push_item(x: T) { items.push(x) }
func hidden(): int { return 1 }
}
pub enum Maybe[T] { Some(v: T)\n None }
struct Secret[T] { v: T }
pub func make[T](x: T): Stack[T] { var s = Stack[T]{}\n s.push_item(x)\n return s }";
let main = "import m
func main() {
var s = m.Stack[int]{}
s.push_item(4)
print(s.items, m.make(\"z\").items)
print(m.Maybe[int].Some(2), m.Maybe[string].None)
}";
assert_eq!(run_project(main, &[("m", m)]), "[4] [z]\nm.Maybe[int].Some(2) m.Maybe[string].None\n");
let e = project_err("import m\nfunc main() { var s = m.Stack[int]{}\nprint(s.hidden()) }", &[("m", m)]);
assert!(e.contains("method `hidden` is private"), "{e}");
let e = project_err("import m\nfunc main() { var s: m.Secret[int] }", &[("m", m)]);
assert!(e.contains("`Secret` is private"), "{e}");
}
// ---------- shared and weak ----------
const SHARED_TYPES: &str = "struct Node {
name: string
parent: weak Node?
kids: []shared Node
func add(k: shared Node) { kids.push(k) }
func path(): string {
if parent == nil { return name }
return parent.path() + \"/\" + name
}
}
enum Light {
On(level: int)
Off
}
";
#[test]
fn shared_values_are_one_value_with_many_owners() {
let src = format!(
"{SHARED_TYPES}func main() {{
var a = shared Node{{name: \"a\"}}
var b = a
b.name = \"changed\"
print(a.name, b.name)
var xs = [a, b, a]
xs[0].name = \"again\"
print(a.name, xs.len())
var l = shared Light.On(3)
var m = l
match m {{
On(v) => print(\"on\", v)
Off => print(\"off\")
}}
}}"
);
assert_eq!(out_of(&src), "changed changed\nagain 3\non 3\n");
}
#[test]
fn weak_parents_do_not_leak_and_go_nil() {
let src = format!(
"{SHARED_TYPES}func make(): shared Node {{
var root = shared Node{{name: \"root\"}}
var kid = shared Node{{name: \"kid\", parent: weak root}}
root.add(kid)
var leaf = shared Node{{name: \"leaf\", parent: weak kid}}
kid.add(leaf)
return leaf
}}
func main() {{
var leaf = make()
print(leaf.parent == nil)
print(leaf.name)
var keep = shared Node{{name: \"top\"}}
var k2 = shared Node{{name: \"mid\", parent: weak keep}}
keep.add(k2)
var l2 = shared Node{{name: \"low\", parent: weak k2}}
k2.add(l2)
print(l2.path())
var w = weak k2
print(w == nil)
keep = shared Node{{name: \"new\"}}
k2 = shared Node{{name: \"x\"}}
print(w == nil, l2.path())
}}"
);
// `make` frees root and kid when it returns: leaf's parent (kid) is gone
assert_eq!(out_of(&src), "true\nleaf\ntop/mid/low\nfalse\ntrue mid/low\n".replace("true mid/low", "true low"));
}
#[test]
fn shared_passed_returned_and_optional() {
let src = format!(
"{SHARED_TYPES}func rename(n: shared Node, to: string) {{ n.name = to }}
func pick(a, b: shared Node, first: bool): shared Node {{
if first {{ return a }}
return b
}}
func main() {{
var a = shared Node{{name: \"a\"}}
var b = shared Node{{name: \"b\"}}
rename(pick(a, b, false), \"B\")
print(a.name, b.name)
var maybe: shared Node? = nil
print(maybe == nil)
maybe = a
if maybe != nil {{ print(maybe.name) }}
var s = \"{{a.name}} and {{b.name}}\"
print(s)
}}"
);
assert_eq!(out_of(&src), "a B\ntrue\na\na and B\n");
}
#[test]
fn shared_errors() {
let e = type_err(&format!("{SHARED_TYPES}func main() {{ var x = shared 5 }}"));
assert!(e.contains("only structs and enums"), "{e}");
let e = type_err(&format!("{SHARED_TYPES}func main() {{ var n = Node{{name: \"a\"}}\nvar w = weak n }}"));
assert!(e.contains("`weak` points at a `shared` value"), "{e}");
let e = type_err(&format!("{SHARED_TYPES}func main() {{ var n = shared Node{{name: \"a\"}}\nvar x: weak Node = n }}"));
assert!(e.contains("expected `weak Node`, found `shared Node`"), "{e}");
let e = type_err(&format!("{SHARED_TYPES}func main() {{ var n = shared Node{{name: \"a\"}}\nvar x = n == nil }}"));
assert!(e.contains("can never be nil"), "{e}");
}
#[test]
fn empty_shared_and_gone_weak_panic_cleanly() {
let src = format!(
"{SHARED_TYPES}func main() {{
var w: weak Node
print(w == nil)
print(w.name)
}}"
);
let o = run_source(&src);
assert_eq!(o.stdout, "true\n");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("gone"), "{}", o.stderr);
}
// ---------- interfaces ----------
const SHAPES: &str = "interface Shape {
area(): float
}
struct Sq {
s: float
func area(): float { return s * s }
}
struct Wrong {
func area(): int { return 1 }
}
struct Nothing {
x: int
}
func show[T: Shape](v: T): float { return v.area() }
";
#[test]
fn interface_rule_accepts_any_type_with_the_methods() {
let src = format!("{SHAPES}func main() {{ print(show(Sq{{3.0}})) }}");
assert_eq!(out_of(&src), "9.0\n");
}
#[test]
fn interface_errors_say_what_is_missing() {
let e = type_err(&format!("{SHAPES}func main() {{ print(show(Nothing{{1}})) }}"));
assert!(e.contains("`show` needs `T` to be something with the methods of `Shape`, but `Nothing` has no method `area`"), "{e}");
let e = type_err(&format!("{SHAPES}func main() {{ print(show(Wrong{{}})) }}"));
assert!(e.contains("`Wrong` has `area(): int`, but `Shape` needs `area(): float`"), "{e}");
let e = type_err(&format!("{SHAPES}func main() {{ print(show(5)) }}"));
assert!(e.contains("`int` has no method `area`"), "{e}");
let e = type_err(&format!("{SHAPES}func main() {{ var s: Shape = Nothing{{1}} }}"));
assert!(e.contains("expected `Shape`, found `Nothing`: `Nothing` has no method `area`"), "{e}");
let e = type_err("func f[T: Missing](x: T) {}\nfunc main() {}");
assert!(e.contains("unknown rule for `T`"), "{e}");
let e = type_err("interface I { f() }\nstruct I { x: int }\nfunc main() {}");
assert!(e.contains("already defined"), "{e}");
}
#[test]
fn interfaces_across_modules() {
let m = "pub interface Named { name(): string }\nstruct Hidden { x: int }\n\
pub func greet[T: Named](x: T): string { return \"hi \" + x.name() }";
let main = "import m
struct Dog {
func name(): string { return \"rex\" }
}
func call[T: m.Named](x: T): string { return x.name() }
func main() { print(m.greet(Dog{}), call(Dog{})) }";
assert_eq!(run_project(main, &[("m", m)]), "hi rex rex\n");
let m2 = "interface Secret { f() }";
let e = project_err("import m\nfunc g[T: m.Secret](x: T) {}\nfunc main() {}", &[("m", m2)]);
assert!(e.contains("`Secret` is private"), "{e}");
}
// ---------- closures ----------
#[test]
fn closures_capture_copies_and_keep_their_own_state() {
let src = "func make(): func(): int {
var n = 0
return func(): int {
n += 1
return n
}
}
func main() {
var x = 5
var f = func(): int { return x * 2 }
x = 100
print(f(), x)
var a = make()
var b = make()
print(a(), a(), b())
var c = a
print(a(), c(), c())
var xs = [1, 2]
var g = func(): int { xs.push(3)
return xs.len() }
print(g(), g(), xs.len())
}";
assert_eq!(out_of(src), "10 100\n1 2 1\n3 3 4\n3 4 2\n");
}
#[test]
fn closures_nest_and_capture_strings_lists_structs() {
let src = "struct P { name: string
tags: []string }
func main() {
var p = P{\"bob\", [\"a\", \"b\"]}
var greet = func(g: string): func(): string {
return func(): string { return g + \" \" + p.name + \" \" + p.tags.join(\",\") }
}
var f = greet(\"hi\")
p.name = \"changed\"
print(f())
var fs: []func(int): int
for i in 0..3 { fs.push(func(x: int): int { return x + i }) }
for f2 in fs { print(f2(10)) }
}";
assert_eq!(out_of(src), "hi bob a,b\n10\n11\n12\n");
}
#[test]
fn closures_in_methods_see_fields() {
let src = "struct Counter {
n: int
func adder(): func(int): int {
return func(k: int): int { return n + k }
}
func bump() { n += 1 }
}
func main() {
var c = Counter{10}
var add = c.adder()
c.bump()
print(add(1), c.n)
}";
assert_eq!(out_of(src), "11 11\n");
}
#[test]
fn generic_functions_take_short_closures() {
let src = "func map[T, U](xs: []T, f: func(T): U): []U {
var out: []U
for x in xs { out.push(f(x)) }
return out
}
func fold[T, A](xs: []T, start: A, f: func(A, T): A): A {
var acc = start
for x in xs { acc = f(acc, x) }
return acc
}
func main() {
print(map([1, 2, 3], x => x + 1))
print(map([1.5, 2.5], x => int(x)))
print(fold([1, 2, 3], 0, (a, x) => a + x))
print(fold([\"a\", \"b\"], \"\", (s, x) => s + x))
}";
assert_eq!(out_of(src), "[2, 3, 4]\n[1, 2]\n6\nab\n");
}
#[test]
fn closure_errors() {
let e = type_err("func main() { var f = x => x }");
assert!(e.contains("can't tell what type `x` is"), "{e}");
let e = type_err("func main() { var f: func(int): int = func(x: int): string { return \"a\" } }");
assert!(e.contains("expected `func(int): int`, found `func(int): string`"), "{e}");
let e = type_err("func main() { var f = func(x: int): int { print(x) } }");
assert!(e.contains("can reach its end without returning"), "{e}");
let e = type_err("func main() { var f = func(x: int): int { return x }\nprint(f(1, 2)) }");
assert!(e.contains("takes 1 argument"), "{e}");
let e = type_err("func main() { var n = 5\nprint(n(1)) }");
assert!(e.contains("is a variable, not a function"), "{e}");
let e = type_err("func call(f: func(int): int): int { return f(1) }\nfunc main() { print(call((a, b) => a)) }");
assert!(e.contains("has 2 parameters, but 1 is expected"), "{e}");
}
#[test]
fn empty_function_value_panics_cleanly() {
let src = "func main() {
var f: func(): int
print(f())
}";
let o = run_source(src);
assert_eq!(o.code, 2);
assert!(o.stderr.contains("empty function value"), "{}", o.stderr);
}
// ---------- interface values ----------
#[test]
fn interface_values_mix_types_and_copy() {
let src = format!(
"{SHAPES}func main() {{
var xs: []Shape = [Sq{{2.0}}, Sq{{3.0}}]
var total = 0.0
for x in xs {{ total += x.area() }}
print(total, xs.len())
var a: Shape = Sq{{1.0}}
var b = a
print(a.area(), b.area(), show(a))
var maybe: Shape
print(maybe == nil)
maybe = Sq{{4.0}}
print(maybe != nil, maybe.area())
}}"
);
assert_eq!(out_of(&src), "13.0 2\n1.0 1.0 1.0\ntrue\ntrue 16.0\n");
}
#[test]
fn interface_value_methods_can_change_the_value() {
let src = "interface Counter { bump(): int }
struct C { n: int
func bump(): int { n += 1
return n } }
func run(c: Counter): int { c.bump()
return c.bump() }
func main() {
var c: Counter = C{0}
print(c.bump(), c.bump())
print(run(c), c.bump())
}";
assert_eq!(out_of(src), "1 2\n4 3\n");
}
#[test]
fn empty_interface_value_panics_cleanly() {
let src = "interface I { f(): int }\nfunc main() { var x: I\nprint(x.f()) }";
let o = run_source(src);
assert_eq!(o.code, 2);
assert!(o.stderr.contains("empty interface value"), "{}", o.stderr);
}
#[test]
fn interface_values_across_modules() {
let m = "pub interface Named { name(): string }
pub struct Dog {
pub func name(): string { return \"rex\" }
}
pub func all(): []Named { return [Dog{}] }";
let main = "import m
struct Cat { func name(): string { return \"tom\" } }
func main() {
var xs = m.all()
xs.push(Cat{})
for x in xs { print(x.name()) }
var one: m.Named = Cat{}
print(one.name())
}";
assert_eq!(run_project(main, &[("m", m)]), "rex\ntom\ntom\n");
}
// ---------- weak -> shared ----------
#[test]
fn weak_upgrade_gives_a_shared_value_or_nil() {
let src = format!(
"{SHARED_TYPES}func main() {{
var root = shared Node{{name: \"root\"}}
var w = weak root
var p = w.upgrade()
print(p == nil)
if p != nil {{
p.name = \"seen through upgrade\"
print(p.name)
}}
print(root.name)
// the upgraded pointer is an owner: the value stays alive while it exists
var keep = shared Node{{name: \"keep\"}}
var w2 = weak keep
var strong = w2.upgrade()
keep = shared Node{{name: \"other\"}}
print(w2 == nil)
strong = nil
print(w2 == nil, w2.upgrade() == nil)
}}"
);
assert_eq!(out_of(&src), "false\nseen through upgrade\nseen through upgrade\nfalse\ntrue true\n");
}
#[test]
fn weak_upgrade_of_an_empty_weak_is_nil() {
let src = format!("{SHARED_TYPES}func main() {{ var w: weak Node\nprint(w.upgrade() == nil) }}");
assert_eq!(out_of(&src), "true\n");
}
#[test]
fn string_slicing() {
let o = out_of("func main() {\n var s = \"hello world\"\n print(s[0..5])\n print(s[6..])\n print(s[..5])\n print(s[3..3] == \"\")\n}");
assert_eq!(o, "hello\nworld\nhello\ntrue\n");
}
#[test]
fn string_slice_out_of_range_panics() {
let o = run_source("func main() {\n var s = \"abc\"\n var n = 5\n print(s[1..n])\n}");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("the length is 3"), "{}", o.stderr);
}
#[test]
fn calc_example_session() {
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/examples/calc");
let main = format!("{dir}/main.rex");
let c = driver::compile_file(&main).unwrap_or_else(|e| panic!("{e}"));
let exe = driver::temp_exe();
driver::build_exe_with(&c, &exe, &["-std=c11", "-fwrapv", "-w", "-fsanitize=address", "-g"]).unwrap();
let o = Command::new(&exe)
.arg(format!("{dir}/session.txt"))
.env("ASAN_OPTIONS", "detect_leaks=1")
.output()
.unwrap();
let _ = std::fs::remove_file(&exe);
let err = String::from_utf8_lossy(&o.stderr);
assert!(!err.contains("Sanitizer"), "{err}");
let want = std::fs::read_to_string(format!("{dir}/session.out")).unwrap();
assert_eq!(String::from_utf8_lossy(&o.stdout), want);
}
#[test]
fn map_missing_key_panics() {
let o = run_source("func main() {\n var m = {\"a\": 1}\n print(m[\"b\"])\n}");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("not in the map"), "{}", o.stderr);
}
#[test]
fn map_counts_from_zero_and_keeps_order() {
let o = out_of("func main() {\n var m: map[int, int] = {}\n m[5] += 2\n m[1] += 1\n m[5] += 3\n print(m)\n}");
assert_eq!(o, "{5: 5, 1: 1}\n");
}
#[test]
fn map_errors() {
assert!(check_err(&main_with("var m = {1.5: 2}")).contains("map key"));
assert!(check_err(&main_with("var m = {}")).contains("can't tell what kind of map"));
assert!(check_err(&main_with("var m = {\"a\": 1}\n m[1] = 2")).contains("string"));
assert!(check_err(&main_with("var m = {\"a\": 1}\n m.bogus()")).contains("maps have no method"));
}
/// Every complete program in the docs folder must compile, and print what the text says.
#[test]
fn docs_examples_run() {
let dir = concat!(env!("CARGO_MANIFEST_DIR"), "/docs");
let mut checked = 0;
for entry in std::fs::read_dir(dir).unwrap() {
let path = entry.unwrap().path();
if path.extension().map_or(true, |e| e != "md") {
continue;
}
let text = std::fs::read_to_string(&path).unwrap();
let mut rest = text.as_str();
while let Some(start) = rest.find("```rex\n") {
let after = &rest[start + "```rex\n".len()..];
let end = after.find("```").unwrap();
let code = &after[..end];
rest = &after[end + 3..];
if !code.contains("func main") || code.contains("import utils") {
continue;
}
// the output block, if one follows right away
let expected = rest.strip_prefix("\n```text\n").and_then(|r| r.find("```").map(|e| &r[..e]));
if code.contains("import \"") {
// C libraries: the header may be one written next to the program in the text,
// or a library that isn't installed here
match driver::compile_to_c(code) {
Err(d) if d.msg.contains("cannot find the C header") => continue,
Err(d) => panic!("{} failed:\n{code}\n{}", path.display(), d.msg),
// without printed output it is a program to look at (a window), not to run
Ok(_) if expected.is_none() => continue,
Ok(_) => {}
}
}
let o = run_source(code);
assert_eq!(o.code, 0, "{} failed:\n{code}\n{}", path.display(), o.stderr);
if let Some(want) = expected {
assert_eq!(o.stdout, want, "wrong output in {}:\n{code}", path.display());
}
checked += 1;
}
}
assert!(checked >= 40, "only {checked} doc examples found");
}
#[test]
fn char_in_the_middle_of_a_character_panics() {
let o = run_source("func main() {\n var s = \"é\"\n print(s[1])\n}");
assert_eq!(o.code, 2);
assert!(o.stderr.contains("middle of a character"), "{}", o.stderr);
}
#[test]
fn char_errors() {
assert!(check_err(&main_with("var c = 'ab'")).contains("exactly one character"));
assert!(check_err(&main_with("var c = ''")).contains("empty character"));
assert!(check_err(&main_with("var c: char = 65")).contains("char"));
assert!(check_err(&main_with("var c = 'a' + 'b'")).contains("doesn't work on `char`"));
assert!(check_err(&main_with("var s = \"abc\"\n s[0] = 'x'")).contains("can't be changed in place"));
assert!(check_err(&main_with("var c = 'a'\n c.bogus()")).contains("characters have no method"));
}
#[test]
fn string_chars_list() {
let out = out_of(
"func main() {\n var cs = \"héllo, 世界\".chars()\n print(cs.len(), cs[1], cs[7])\n var up: []char = \"abc\".chars()\n up.push('d')\n print(up, \"\".chars().len())\n for c in \"xy\".chars() { print(c) }\n}\n",
);
assert_eq!(out, "9 é 世\n[a, b, c, d] 0\nx\ny\n");
}