Compiler in Rust (lexer, parser, checker, C codegen), maps, chars, dino fmt, dino lsp (diagnostics, formatting, outline, definition, hover, completion, signature help), docs, examples, VS Code/Vim files. Co-Authored-By: Claude Sonnet 5.5 <noreply@anthropic.com>
2251 lines
76 KiB
Rust
2251 lines
76 KiB
Rust
//! 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<String, String> {
|
|
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");
|
|
}
|