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:
Your NameandClaude Opus 5.5 committed 2026-11-12 23:30:05 +01:00
1 parent 910bde692a
commit 300d767124
28 files changed
+1373 -65

No files matched your search

+7
View File
@@ -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);
}
+48
View File
@@ -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);
}
+21
View File
@@ -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
View File
@@ -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
View File
@@ -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"));
}
+48
View File
@@ -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);
}