Add bit operators, defer, list methods, rand, assert and rex test
- Bit operators & | ^ ~ << >> and their op= forms (Go precedence),
plus hex, binary and octal literals (0xff, 0b1010, 0o755)
- defer stmt / defer { ... }: runs when the block ends, last first,
also on return, ?, break and continue
- List methods insert, remove, clear, contains, index_of, reverse,
sort and sort_by (stable merge sort)
- rand module: int(a, b), float(), seed(n)
- assert(cond[, msg]) and `rex test`, which runs each test_ function
in its own process
- rex.toml marks a project's top folder: imports count from there
- Docs, formatter, LSP completions and editor grammars updated
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
910bde692a
commit
300d767124
28 files changed
+1373
-65
No files matched your search
@@ -119,3 +119,10 @@ fn import_paths_going_up_keep_their_dots() {
|
||||
let src = "import ...engine.engine\nimport ..side\nimport a.b\n\nfunc main() {\n for i in 0..3 { print(i) }\n}\n";
|
||||
assert_eq!(fmt(src), src);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bit_operators_and_defer() {
|
||||
let src = "func main() {\nvar a=0xff&~0b1|1<<4>>2^3\na<<=1\na>>=1\na&=3\na|=4\na^=5\ndefer print(a)\ndefer{\nprint(-a)\n}\n}\n";
|
||||
let want = "func main() {\n var a = 0xff & ~0b1 | 1 << 4 >> 2 ^ 3\n a <<= 1\n a >>= 1\n a &= 3\n a |= 4\n a ^= 5\n defer print(a)\n defer {\n print(-a)\n }\n}\n";
|
||||
assert_eq!(fmt(src), want);
|
||||
}
|
||||
@@ -64,3 +64,51 @@ fn one_dot_is_not_an_import_path() {
|
||||
assert!(!o.status.success());
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn a_rex_toml_marks_the_project_root() {
|
||||
let dir = tree(&[
|
||||
("rex.toml", ""),
|
||||
("engine/engine.rex", "import engine.util\n\npub func hi(): int { return util.seven() }\n"),
|
||||
("engine/util.rex", "pub func seven(): int { return 7 }\n"),
|
||||
("game/app/main.rex", "import engine.engine\nimport game.common\n\nfunc main() {\n print(engine.hi(), common.two())\n}\n"),
|
||||
("game/common.rex", "pub func two(): int { return 2 }\n"),
|
||||
("game/deeper/x/main.rex", "import engine.engine\n\nfunc main() {\n print(engine.hi())\n}\n"),
|
||||
]);
|
||||
// the same import works from any depth, and from any folder the command is run in
|
||||
let o = rex(&dir, "game/app", "main.rex");
|
||||
assert!(o.status.success(), "{}", String::from_utf8_lossy(&o.stderr));
|
||||
assert_eq!(String::from_utf8_lossy(&o.stdout), "7 2\n");
|
||||
let o = rex(&dir, "game/deeper/x", "main.rex");
|
||||
assert!(o.status.success(), "{}", String::from_utf8_lossy(&o.stderr));
|
||||
assert_eq!(String::from_utf8_lossy(&o.stdout), "7\n");
|
||||
let o = Command::new(env!("CARGO_BIN_EXE_rex"))
|
||||
.args(["run", dir.join("game/app/main.rex").to_str().unwrap()])
|
||||
.current_dir(std::env::temp_dir())
|
||||
.output()
|
||||
.unwrap();
|
||||
assert!(o.status.success(), "{}", String::from_utf8_lossy(&o.stderr));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn without_rex_toml_imports_count_from_the_main_file() {
|
||||
let dir = tree(&[
|
||||
("engine/engine.rex", "pub func hi(): int { return 7 }\n"),
|
||||
("game/main.rex", "import engine.engine\n\nfunc main() { }\n"),
|
||||
]);
|
||||
let o = rex(&dir, "game", "main.rex");
|
||||
assert!(!o.status.success());
|
||||
assert!(String::from_utf8_lossy(&o.stderr).contains("cannot find module `engine.engine`"));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn project_dir_finds_the_nearest_root() {
|
||||
use rex::loader::project_dir;
|
||||
let dir = tree(&[("rex.toml", ""), ("a/b/main.rex", ""), ("a/rex.toml", ""), ("c/d/main.rex", "")]);
|
||||
let canon = |p: PathBuf| std::fs::canonicalize(p).unwrap();
|
||||
assert_eq!(canon(project_dir(&dir.join("a/b/main.rex"))), canon(dir.join("a")));
|
||||
assert_eq!(canon(project_dir(&dir.join("c/d/main.rex"))), canon(dir.clone()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
@@ -287,3 +287,24 @@ fn imports_from_a_folder_above_are_found() {
|
||||
let hover = out.iter().find(|m| m.get("id") == Some(&Json::Num(2.0))).unwrap();
|
||||
assert!(format!("{hover:?}").contains("twice"), "{hover:?}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn the_editor_counts_imports_from_the_project_root() {
|
||||
let dir = std::env::temp_dir().join(format!("rex-lsp-root-{}", std::process::id()));
|
||||
std::fs::create_dir_all(dir.join("engine")).unwrap();
|
||||
std::fs::create_dir_all(dir.join("game/app")).unwrap();
|
||||
std::fs::write(dir.join("rex.toml"), "").unwrap();
|
||||
std::fs::write(dir.join("engine/engine.rex"), "import engine.util\npub func twice(x: int): int { return util.dbl(x) }\n").unwrap();
|
||||
std::fs::write(dir.join("engine/util.rex"), "pub func dbl(x: int): int { return x * 2 }\n").unwrap();
|
||||
let main = format!("file://{}/game/app/main.rex", dir.display());
|
||||
let module = format!("file://{}/engine/engine.rex", dir.display());
|
||||
let src = "import engine.engine\nfunc main() {\n print(engine.twice(2))\n}\n";
|
||||
let mod_src = "import engine.util\npub func twice(x: int): int { return util.dbl(x) }\n";
|
||||
// both the main file and a module of the project are checked with the same root
|
||||
let mut msgs = vec![open(&main, src), open(&module, mod_src)];
|
||||
msgs.extend(exit_messages());
|
||||
let (out, _) = talk(msgs);
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
assert_eq!(out[0].path(&["params", "diagnostics"]), Some(&Json::Arr(vec![])), "{:?}", out[0]);
|
||||
assert_eq!(out[1].path(&["params", "diagnostics"]), Some(&Json::Arr(vec![])), "{:?}", out[1]);
|
||||
}
|
||||
+10
-2
@@ -226,8 +226,16 @@ fn error_const_needs_value() {
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn error_single_ampersand() {
|
||||
assert!(err("func f() { var a = b & c }").msg.contains("&&"));
|
||||
fn bit_operators_bind_like_go() {
|
||||
// `&` and shifts go with `*`, `|` and `^` with `+`, all tighter than comparisons
|
||||
let p = parse("func f() { var a = b & 1 == 0 }").unwrap();
|
||||
let text = format!("{p:?}");
|
||||
let eq = text.find("op: Eq").unwrap();
|
||||
let and = text.find("op: BitAnd").unwrap();
|
||||
assert!(eq < and, "`==` should be the outer operator: {text}");
|
||||
let p = parse("func f() { var a = b | c << 2 }").unwrap();
|
||||
let text = format!("{p:?}");
|
||||
assert!(text.find("op: BitOr").unwrap() < text.find("op: Shl").unwrap(), "{text}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
|
||||
+119
-2
@@ -666,8 +666,8 @@ fn error_push_on_temporary() {
|
||||
|
||||
#[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}");
|
||||
let m = check_err(&main_with("var a = [1]\na.shuffle()"));
|
||||
assert!(m.contains("no method `shuffle`") && m.contains("len, push, pop, insert"), "{m}");
|
||||
}
|
||||
|
||||
#[test]
|
||||
@@ -2259,3 +2259,120 @@ fn string_chars_list() {
|
||||
);
|
||||
assert_eq!(out, "9 é 世\n[a, b, c, d] 0\nx\ny\n");
|
||||
}
|
||||
|
||||
// ---------- bit operators ----------
|
||||
|
||||
#[test]
|
||||
fn bit_operators() {
|
||||
let out = out_of(
|
||||
"func main() {\n var f = 0b0101 | 0x10\n print(f, f & 3, f ^ 1, ~0, 1 << 10, -16 >> 2, f & 1 == 1, 0o17)\n f &= 0xf\n f |= 0b1000\n f ^= 1\n f <<= 2\n f >>= 1\n print(f)\n var b: u8 = 200\n b <<= 1\n print(b, b >> 1, ~b)\n var x: u32 = 1\n var n = 40\n print(x << n, x << 31, -1 >> 70, 1 << 64)\n var h: u64 = 0xff\n print(h << 56 >> 60)\n}\n",
|
||||
);
|
||||
assert_eq!(out, "21 1 20 -1 1024 -4 true 15\n24\n144 72 111\n0 2147483648 -1 0\n15\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn negative_shift_panics() {
|
||||
let o = run_source("func main() {\n var n = -1\n print(1 << n)\n}");
|
||||
assert_eq!(o.code, 2);
|
||||
assert!(o.stderr.contains("negative"), "{}", o.stderr);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bit_operator_errors() {
|
||||
assert!(check_err(&main_with("var a = 1.5 & 1.0")).contains("doesn't work on `float`"));
|
||||
assert!(check_err(&main_with("var a = true | false")).contains("`||`"));
|
||||
assert!(check_err(&main_with("var a = ~true")).contains("`~`"));
|
||||
assert!(check_err(&main_with("var a = 1.0 << 2")).contains("shifts the bits"));
|
||||
assert!(check_err(&main_with("var a = 1 << -2")).contains("negative"));
|
||||
assert!(check_err(&main_with("var a = 0xfg")).contains("hexadecimal"));
|
||||
assert!(check_err(&main_with("var a = 0b102")).contains("binary"));
|
||||
}
|
||||
|
||||
// ---------- defer ----------
|
||||
|
||||
#[test]
|
||||
fn defer_runs_at_the_end_of_the_block() {
|
||||
let out = out_of(
|
||||
"func work(n: int): int {\n defer print(\"leave\", n)\n defer {\n print(\"second runs first\")\n }\n if n > 2 {\n return n * 10\n }\n for i in 0..4 {\n defer print(\" end\", i)\n if i == 1 {\n continue\n }\n if i == 2 {\n break\n }\n print(\" round\", i)\n }\n return n\n}\n\nfunc main() {\n print(work(1))\n print(work(5))\n}\n",
|
||||
);
|
||||
assert_eq!(
|
||||
out,
|
||||
" round 0\n end 0\n end 1\n end 2\nsecond runs first\nleave 1\n1\nsecond runs first\nleave 5\n50\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defer_sees_the_latest_values_and_runs_on_errors() {
|
||||
let out = out_of(
|
||||
"func fail(): error {\n return error(\"boom\")\n}\n\nfunc job(): error {\n var log: []string\n defer print(\"log:\", log)\n log.push(\"start\")\n fail()?\n log.push(\"never\")\n return nil\n}\n\nfunc keep(): []int {\n var xs = [1]\n defer print(\"returning\", xs)\n xs.push(2)\n return xs\n}\n\nfunc main() {\n var err = job()\n print(err)\n print(keep())\n var s = \"a\"\n {\n defer print(\"inner\", s)\n s = s + \"b\"\n }\n var t = s\n print(t)\n}\n",
|
||||
);
|
||||
assert_eq!(out, "log: [start]\nboom\nreturning [1, 2]\n[1, 2]\ninner ab\nab\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn defer_errors() {
|
||||
assert!(check_err(&main_with("defer return")).contains("defer return"));
|
||||
assert!(check_err(&main_with("for { defer { break } }")).contains("can't jump out of a `defer`"));
|
||||
assert!(check_err("func f(): error { return nil }\nfunc g(): error {\n defer f()?\n return nil\n}\nfunc main() {}\n").contains("`?` can't be used inside a `defer`"));
|
||||
assert!(check_err(&main_with("defer var x = 1")).contains("`var`"));
|
||||
assert!(check_err(&main_with("defer")).contains("what to run later"));
|
||||
// a loop inside the deferred code may use break
|
||||
assert_eq!(out_of(&main_with("defer {\n for { break }\n print(\"ok\")\n }")), "ok\n");
|
||||
}
|
||||
|
||||
// ---------- list methods ----------
|
||||
|
||||
#[test]
|
||||
fn list_methods() {
|
||||
let out = out_of(
|
||||
"func main() {\n var xs = [5, 3, 9, 1]\n xs.insert(0, 7)\n xs.insert(5, 8)\n print(xs)\n print(xs.remove(1), xs)\n xs.sort()\n print(xs, xs.contains(9), xs.index_of(9), xs.index_of(42))\n xs.reverse()\n print(xs)\n xs.clear()\n print(xs, xs.len())\n var names = [\"bob\", \"al\", \"cy\"]\n names.sort()\n names.insert(1, \"ann\")\n print(names, names.contains(\"al\"), names.remove(0), names)\n names.clear()\n names.push(\"z\")\n print(names, [1, 2].contains(2))\n}\n",
|
||||
);
|
||||
assert_eq!(
|
||||
out,
|
||||
"[7, 5, 3, 9, 1, 8]\n5 [7, 3, 9, 1, 8]\n[1, 3, 7, 8, 9] true 4 -1\n[9, 8, 7, 3, 1]\n[] 0\n[al, ann, bob, cy] true al [ann, bob, cy]\n[z] true\n"
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn sort_by_is_stable_and_frees_its_copies() {
|
||||
let out = out_of(
|
||||
"struct P {\n name: string\n tags: []string\n age: int\n}\n\nfunc main() {\n var ps = [P{\"a\", [\"x\"], 30}, P{\"b\", [], 20}, P{\"c\", [\"y\"], 30}, P{\"d\", [], 10}]\n ps.sort_by((p, q) => p.age < q.age)\n for p in ps {\n print(p.name, p.age)\n }\n var lists = [[3], [1, 2], []]\n var by_len = func(a, b: []int): bool { return a.len() < b.len() }\n lists.sort_by(by_len)\n print(lists)\n var words = [\"pear\", \"fig\", \"apple\"]\n words.sort_by((a, b) => a.len() > b.len())\n print(words)\n var e: []int\n e.sort()\n e.sort_by((a, b) => a < b)\n print(e)\n}\n",
|
||||
);
|
||||
assert_eq!(out, "d 10\nb 20\na 30\nc 30\n[[], [3], [1, 2]]\n[apple, pear, fig]\n[]\n");
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn list_method_panics_and_errors() {
|
||||
let o = run_source("func main() {\n var xs = [1]\n xs.insert(3, 1)\n}");
|
||||
assert_eq!(o.code, 2);
|
||||
let o = run_source("func main() {\n var xs = [1]\n xs.remove(1)\n}");
|
||||
assert_eq!(o.code, 2);
|
||||
assert!(check_err("struct P { x: int }\nfunc main() {\n var ps = [P{1}]\n ps.sort()\n}").contains("sort_by"));
|
||||
assert!(check_err("struct P { x: int }\nfunc main() {\n var ps = [P{1}]\n print(ps.contains(P{1}))\n}").contains("write a loop"));
|
||||
assert!(check_err(&main_with("const XS = 1\n [1].sort()")).contains("not a temporary"));
|
||||
assert!(check_err(&main_with("var xs = [1]\n xs.shuffle()")).contains("sort_by"));
|
||||
}
|
||||
|
||||
// ---------- rand and assert ----------
|
||||
|
||||
#[test]
|
||||
fn rand_module() {
|
||||
let out = out_of(
|
||||
"import rand\n\nfunc main() {\n rand.seed(7)\n var a = rand.int(0, 1000)\n rand.seed(7)\n print(a == rand.int(0, 1000))\n var seen = [false, false, false]\n for i in 0..300 {\n var n = rand.int(-1, 2)\n assert(n >= -1 && n < 2)\n seen[n + 1] = true\n var f = rand.float()\n assert(f >= 0.0 && f < 1.0)\n }\n print(seen)\n}\n",
|
||||
);
|
||||
assert_eq!(out, "true\n[true, true, true]\n");
|
||||
let o = run_source("import rand\nfunc main() {\n print(rand.int(3, 3))\n}");
|
||||
assert_eq!(o.code, 2);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn assert_stops_the_program() {
|
||||
let o = run_source("func main() {\n var x = 4\n assert(x == 4)\n print(\"a\")\n assert(x == 5, \"x is {x}\")\n print(\"b\")\n}");
|
||||
assert_eq!(o.stdout, "a\n");
|
||||
assert_eq!(o.code, 2);
|
||||
assert!(o.stderr.contains("assertion failed: x is 4 (line 5)"), "{}", o.stderr);
|
||||
let o = run_source("func main() {\n assert(false)\n}");
|
||||
assert!(o.stderr.contains("assertion failed (line 2)"), "{}", o.stderr);
|
||||
assert!(check_err(&main_with("assert(1)")).contains("bool"));
|
||||
assert!(check_err(&main_with("assert()")).contains("condition"));
|
||||
}
|
||||
@@ -0,0 +1,48 @@
|
||||
//! Tests of `rex test`.
|
||||
|
||||
use std::process::Command;
|
||||
|
||||
#[test]
|
||||
fn runs_each_test_on_its_own() {
|
||||
let dir = std::env::temp_dir().join(format!("rex-test-cmd-{}", std::process::id()));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
std::fs::create_dir_all(dir.join("sub")).unwrap();
|
||||
std::fs::write(
|
||||
dir.join("calc.rex"),
|
||||
"func add(a, b: int): int {\n return a + b\n}\n\nfunc test_add() {\n assert(add(2, 2) == 4)\n}\n\nfunc test_wrong() {\n print(\"shown when it fails\")\n assert(add(2, 2) == 5, \"2 + 2 is {add(2, 2)}\")\n}\n\nfunc test_error(): error {\n return error(\"nope\")\n}\n\nfunc test_panic() {\n var xs: []int\n xs.pop()\n}\n\nfunc test_after_panic() {}\n\nfunc main() {\n print(\"main is not run\")\n}\n",
|
||||
)
|
||||
.unwrap();
|
||||
// a file without tests is skipped; one without `main` is fine
|
||||
std::fs::write(dir.join("sub/plain.rex"), "func main() {}\n").unwrap();
|
||||
std::fs::write(dir.join("sub/lib.rex"), "func test_ok(): error {\n return nil\n}\n").unwrap();
|
||||
let o = Command::new(env!("CARGO_BIN_EXE_rex")).arg("test").current_dir(&dir).output().unwrap();
|
||||
let out = String::from_utf8_lossy(&o.stdout).into_owned();
|
||||
assert_eq!(o.status.code(), Some(1), "{out}");
|
||||
for want in [
|
||||
"ok calc.rex: test_add",
|
||||
"FAIL calc.rex: test_wrong",
|
||||
" shown when it fails",
|
||||
" assertion failed: 2 + 2 is 4 (line 11)",
|
||||
"FAIL calc.rex: test_error",
|
||||
" error: nope",
|
||||
"FAIL calc.rex: test_panic",
|
||||
" panic: pop from an empty list",
|
||||
"ok calc.rex: test_after_panic",
|
||||
"ok sub/lib.rex: test_ok",
|
||||
"3 passed, 3 failed",
|
||||
] {
|
||||
assert!(out.contains(want), "missing {want:?} in:\n{out}");
|
||||
}
|
||||
assert!(!out.contains("main is not run"), "{out}");
|
||||
|
||||
// only one file, all passing
|
||||
let o = Command::new(env!("CARGO_BIN_EXE_rex")).args(["test", "sub/lib.rex"]).current_dir(&dir).output().unwrap();
|
||||
assert_eq!(o.status.code(), Some(0), "{}", String::from_utf8_lossy(&o.stdout));
|
||||
|
||||
// a test with parameters is an error
|
||||
std::fs::write(dir.join("sub/lib.rex"), "func test_bad(n: int) {}\n").unwrap();
|
||||
let o = Command::new(env!("CARGO_BIN_EXE_rex")).args(["test", "sub/lib.rex"]).current_dir(&dir).output().unwrap();
|
||||
assert_eq!(o.status.code(), Some(1));
|
||||
assert!(String::from_utf8_lossy(&o.stderr).contains("a test takes nothing"));
|
||||
let _ = std::fs::remove_dir_all(&dir);
|
||||
}
|
||||
Reference in new issue
Block a user