//! End-to-end tests: compile Dino programs to C, build them with the system C //! compiler, run them, and compare the output. use std::process::Command; use dino::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.dino", 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 == "dino") { 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}.dino")).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}.dino")).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 { driver::compile_project("main.dino", main, |key| { modules.iter().find(|(k, _)| *k == key).map(|(k, src)| (format!("{k}.dino"), 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.dino: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.dino: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.dino"), "{e}"); } #[test] fn error_missing_module() { let e = project_err("import nope\nfunc main() {}", &[]); assert!(e.contains("cannot find module `nope`") && e.contains("nope.dino"), "{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.dino"), "{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.dino", 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.dino"); 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("```dino\n") { let after = &rest[start + 8..]; 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])); 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"); }