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

+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"));
}