dymokomi/luce-base
Source of release 0.45.0
0.45.0 / src / sema / check / tests.lucb
#==============================================================================================
#
# check/tests - Tests
#
# DESCRIPTION:
# The checker's unit tests.
#
#==============================================================================================
# mark: Tests =================================================================================
## Check a program given as text, in a fresh arena; the first error is returned.
pub func check_text(text: str, scratch: u8[]) -> !:
var checker = try Checker.create(scratch)
try checker.add_prelude()
let src = try source.Source.over("test", text.bytes)
try checker.add_module("test", src, false)
try checker.check_program()
## Budget tree and binding storage for the standard library's source and a test program,
## with headroom: not a compiler memory limit or an accuracy bound.
func test_arena_size() -> usize!:
return 268435456
func expect_error(text: str, fragment: str) -> !:
let capacity = try test_arena_size()
let backing = try new u8[capacity] --- in memory.heap
defer free(backing) in memory.heap
var arena = memory.FixedBuffer.over(backing)
var scratch: u8[1024]
var failed = false
with arena:
check_text(text, scratch) catch failure:
if not contains(failure.message, fragment):
print(f"expected `{fragment}`, got: {failure.message}")
error(failure.code, "wrong diagnostic")
failed = true
recover ()
if not failed:
error(type_error, "expected an error, the program checked")
func expect_ok(text: str) -> !:
let capacity = try test_arena_size()
let backing = try new u8[capacity] --- in memory.heap
defer free(backing) in memory.heap
var arena = memory.FixedBuffer.over(backing)
var scratch: u8[1024]
with arena:
check_text(text, scratch) catch failure:
# the message lives in this frame's scratch; the runner reads it after the return
let kept = try strings.format(test_message, f"{failure.message}")
error(failure.code, kept)
var test_message: u8[1024]
func contains(haystack: str, needle: str) -> bool:
let h = haystack.bytes
let n = needle.bytes
if n.length > h.length:
return false
var i: usize = 0
while i + n.length <= h.length:
if (str)h[i..<i + n.length] == needle:
return true
i += 1
return false
test "a function with a typed body checks":
try expect_ok("func add(a: i64, b: i64) -> i64:\n return a + b\n")
test "an unknown name is reported with its position":
try expect_error("func f() -> i64:\n return missing\n", "test:2:12: unknown name")
test "a mismatched return is reported":
try expect_error("func f() -> i64:\n return \"x\"\n", "expected `i64`, got `str`")
test "widening is implicit and narrowing is not":
try expect_ok("func f(a: u8) -> u32:\n return a\n")
try expect_error("func f(a: u32) -> u8:\n return a\n", "expected `u8`, got `u32`")
test "a let cannot be assigned":
try expect_error("func f():\n let x = 1\n x = 2\n", "cannot assign to a `let`")
test "try needs a fallible function":
try expect_error("func g() -> i64!:\n return 1\nfunc f() -> i64:\n return try g()\n", "only valid in a fallible function")
test "an unhandled fallible call is an error":
try expect_error("func g() -> !:\n return\nfunc f():\n g()\n", "must be handled")
test "else recovers a fallible result without a fallible caller":
try expect_ok("func g() -> i64!:\n return 1\nfunc f() -> i64:\n return g() else 0\n")
test "else needs an optional or a fallible operand":
try expect_error("func f() -> i64:\n return 5 else 0\n", "an optional or a fallible result")
test "structs construct by name and expose fields":
try expect_ok("struct P:\n var x: i64\n var y: i64\n func sum() -> i64:\n return self.x + self.y\nfunc f() -> i64:\n let p = P(x = 1, y = 2)\n return p.sum() + p.x\n")
test "a method that changes its receiver needs a var receiver, found from its body":
try expect_error("struct C:\n var n: i64\n func bump():\n self.n += 1\nfunc f():\n let c = C(n = 0)\n c.bump()\n", "`bump` changes its receiver, so it needs a `var` here")
try expect_error("func f() -> i64:\n let c = C(n = 0)\n c.bump()\n return c.n\nstruct C:\n var n: i64\n func bump():\n self.step()\n func step():\n self.n += 1\n", "needs a `var` here")
try expect_error("func touch(p: i64*):\n *p = 2\nfunc f() -> i64:\n let c = C(n = 0)\n c.poke()\n return c.n\nstruct C:\n var n: i64\n func poke():\n touch(&self.n)\n", "`poke` changes its receiver, so it needs a `var` here")
try expect_ok("struct C:\n var n: i64\n func peek() -> i64:\n let p = &self.n\n return *p\nfunc f() -> i64:\n let c = C(n = 1)\n return c.peek()\n")
try expect_error("struct P:\n var x: i64\n static func origin() -> P:\n return P(x = 0)\nfunc f() -> P:\n let p = P(x = 1)\n return p.origin()\n", "`origin` is `static`, a function of the type: call it as `P.origin()`")
test "enums match by case":
try expect_ok("enum K as u8:\n a = 1\n b = 2\nfunc f(k: K) -> i64:\n match k:\n .a:\n return 1\n .b:\n return 2\n _:\n return 0\n")
try expect_error("enum K as u8:\n a = 1\n b = 2\nfunc f(k: K) -> i64:\n match k:\n .a:\n return 1\n .b:\n return 2\n", "needs a `_` arm")
test "a memberwise initialiser is positional or named, each field once":
try expect_ok("struct P:\n var x: i64\n var y: i64\nfunc f() -> i64:\n let p = P(1, 2)\n let q = P(1, y = 2)\n return p.x + q.y\n")
try expect_error("struct P:\n var x: i64\n var y: i64\nfunc f() -> i64:\n let p = P(x = 1, x = 2)\n return p.x\n", "given twice")
try expect_error("struct P:\n var x: i64\n var y: i64\nfunc f() -> i64:\n let p = P(x = 1, 2)\n return p.x\n", "cannot follow a named one")
try expect_error("struct P:\n var x: i64\nfunc f() -> i64:\n let p = P(1, 2)\n return p.x\n", "too many values")
test "an init assigns every field once and reads none early":
try expect_ok("struct P:\n let a: i64\n let b: i64\n pub func init(n: i64) -> !:\n if n < 0:\n error(1, \"neg\")\n self.a = n\n self.b = n * 2\n _ = self.a + self.b\nfunc f() -> i64!:\n let p = try P(1)\n return p.b\n")
try expect_error("struct P:\n let a: i64\n let b: i64\n pub func init(n: i64):\n self.a = n\nfunc f() -> i64:\n return P(1).a\n", "not assigned")
try expect_error("struct P:\n let a: i64\n pub func init(n: i64):\n self.a = n\n self.a = n + 1\nfunc f() -> i64:\n return P(1).a\n", "assigned twice")
try expect_error("struct P:\n let a: i64\n let b: i64\n pub func init(n: i64):\n self.a = n\n self.b = self.a * 2\nfunc f() -> i64:\n return P(1).a\n", "before every field is assigned")
try expect_error("struct P:\n let a: i64\n pub func init(n: i64):\n while n > 0:\n self.a = n\nfunc f() -> i64:\n return P(1).a\n", "assigned twice")
try expect_error("struct P:\n let a: i64\n pub func init(n: i64) -> i64:\n self.a = n\n return n\nfunc f() -> i64:\n return 0\n", "`init` returns")
test "a struct cannot contain itself by value":
try expect_error("struct N:\n var next: N\nfunc f() -> i64:\n return 0\n", "contains itself")
try expect_error("struct A:\n var b: B\nstruct B:\n var a: A\nfunc f() -> i64:\n return 0\n", "contains itself")
test "an enum cannot contain itself by value through a payload":
try expect_error("enum T:\n leaf(value: i64)\n pair(left: T?, right: T?)\nfunc f() -> i64:\n return 0\n", "enum contains itself")
try expect_error("enum C:\n end\n link(pair: (i64, C))\nfunc f() -> i64:\n return 0\n", "enum contains itself")
try expect_error("enum T:\n leaf(value: i64)\n node(cell: Cell)\nstruct Cell:\n var inner: T?\nfunc f() -> i64:\n return 0\n", "enum contains itself")
try expect_ok("struct N:\n var value: i64\n var next: N*?\nfunc f() -> i64:\n let n = N(value = 1, next = none)\n return n.value\n")
test "integer-backed enums: values for every case, distinct, and the bit operators":
try expect_ok("enum A as u32:\n r = 1\n w = 2\nfunc f() -> u32:\n return (u32)(~A.r & (A.r | A.w))\n")
try expect_error("enum A as u8:\n a = 1\n b = 1\nfunc f() -> i64:\n return 0\n", "share one value")
try expect_error("enum A as u8:\n a\n b\nfunc f() -> i64:\n return 0\n", "every case its value")
try expect_ok("enum L as i8:\n low = -1\n high = 1\nfunc f() -> i64:\n return (i64)(i8)L.low\n")
test "equality needs it in every component; a union has a member":
try expect_error("union U:\n a: i64\n b: f64\nstruct S:\n var u: U\nfunc f() -> bool:\n var x: S\n var y: S\n return x == y\n", "no equality")
try expect_error("union U:\n func g() -> i64:\n return 1\nfunc f() -> i64:\n return 0\n", "at least one member")
test "a catch handler for a value recovers or leaves":
try expect_error("func g() -> i64!:\n return 1\nfunc f() -> i64:\n let v = g() catch e:\n _ = e\n return v\n", "must `recover`")
try expect_ok("func g() -> i64!:\n return 1\nfunc f() -> i64:\n let v = g() catch e:\n recover 2\n return v\n")
try expect_ok("func g() -> !:\n return\nfunc f() -> i64:\n g() catch e:\n _ = e\n return 1\n")
test "a module-level assert is decided at compile time":
try expect_ok("import memory\n\nassert(memory.size_of(i64) == 8, \"a word\")\nfunc f() -> i64:\n return 0\n")
try expect_error("import memory\n\nassert(memory.size_of(i64) == 4, \"a word\")\nfunc f() -> i64:\n return 0\n", "`assert` failed: a word")
try expect_error("assert(not (1 < 2 and true))\nfunc f() -> i64:\n return 0\n", "`assert` failed")
test "an error message may be formatted on a local buffer: error copies it":
try expect_ok("import strings\n\nlet code = ErrorCode.package(1)\nfunc fail(n: i64) -> !:\n var buffer: u8[64]\n let text = try strings.format(buffer, f\"bad {n}\")\n error(code, text)\n")
try expect_ok("import strings\n\nlet code = ErrorCode.package(1)\nfunc fail(n: i64, buffer: u8[]) -> !:\n let text = try strings.format(buffer, f\"bad {n}\")\n error(code, text)\n")
test "a caught failure's message stays in its handler unless copied":
let raises = "import strings\n\nlet code = ErrorCode.package(1)\nfunc g() -> i64!:\n error(code, \"no\")\n"
var text: u8[512]
try expect_error(try strings.format(text, f"{raises}func f() -> str:\n _ = g() catch failure:\n return failure.message\n return \"\"\n"), "must not be returned")
try expect_error(try strings.format(text, f"{raises}var last: str = \"\"\nfunc f():\n _ = g() catch failure:\n last = failure.message\n recover 0\n"), "must not be stored")
try expect_ok(try strings.format(text, f"{raises}func f() -> str!:\n _ = g() catch failure:\n return try strings.copy(failure.message)\n return \"\"\n"))
try expect_ok(try strings.format(text, f"{raises}func f() -> !:\n _ = g() catch failure:\n let m = failure.message\n error(failure.code, m)\n"))
test "two constants of one package do not share an error code":
try expect_error("let first = ErrorCode.package(1)\nlet second = ErrorCode.package(1)\nfunc f() -> i64:\n return 0\n", "share this error code")
test "a result is not a storable type":
try expect_error("func take(r: i64!) -> i64:\n return 0\n", "not a storable type")
try expect_error("struct S:\n var r: i64!\nfunc f() -> i64:\n return 0\n", "not a storable type")
try expect_error("func may() -> i64!:\n return 1\nfunc f() -> i64:\n var r: i64! = may()\n return 0\n", "not a storable type")
test "error needs a fallible function, in a handler too":
try expect_error("func may() -> i64!:\n return 1\nfunc f() -> i64:\n let v = may() catch e:\n error(e.code, e.message)\n return v\n", "only valid in a fallible function")
test "sizeof takes every type form":
try expect_ok("import memory\n\nstruct P:\n var x: i64\nfunc f() -> usize:\n return memory.size_of(i64*) + memory.size_of(i64?) + memory.size_of(P*?) + memory.size_of(i64[4]) + memory.size_of((i64?)[2]) + memory.size_of(func(i64) -> i64) + memory.align_of(P)\n")
test "memory exhaustion keeps its standard error identity":
assert(exhausted_code() == 208273409)
test "new zeroes its elements and allocates no result":
try expect_error("func f() -> !:\n let p = try new (i64*)[4]\n _ = p.length\n", "must be zeroable")
try expect_error("func f() -> !:\n let p = try new (i64!)\n _ = p\n", "not a storable type")
try expect_ok("func f() -> !:\n let p = try new (i64*)[4] ---\n free(p)\n")
test "the allocator named by in binds below catch":
try expect_ok("import memory\nfunc f() -> usize:\n var backing: u8[64]\n var arena = memory.FixedBuffer.over(backing)\n let block = new u8[8] in arena catch e:\n recover backing[..<0]\n return block.length\n")
test "a type argument satisfies its constraints":
try expect_error("from luce import Comparable\nstruct P:\n var x: i64\nfunc largest[T: Comparable](a: T, b: T) -> T:\n return a if a.compare(b) >= 0 else b\nfunc f() -> i64:\n return largest(P(x = 1), P(x = 2)).x\n", "does not satisfy `Comparable`")
try expect_error("from luce import Equatable\nunion U:\n a: i64\n b: f64\nfunc same[T: Equatable](a: T, b: T) -> bool:\n return a == b\nfunc f() -> bool:\n var x: U\n var y: U\n return same(x, y)\n", "does not satisfy `Equatable`")
try expect_ok("from luce import Display\nfunc show[T: Display](a: T):\n print(f\"{a}\")\nfunc f():\n show(1)\n show(\"x\")\n")
test "an unconstrained type parameter has no equality, hash, or display":
try expect_error("func same[T](a: T, b: T) -> bool:\n return a == b\n", "no equality")
try expect_error("func h[T](a: T) -> u64:\n return a.hash()\n", "only under `Hashable`")
try expect_error("func show[T](a: T):\n print(f\"{a}\")\n", "cannot be formatted")
try expect_ok("from luce import Equatable\nfrom luce import Hashable\nfunc both[T: Equatable & Hashable](a: T, b: T) -> bool:\n return a == b and a.hash() == b.hash()\n")
test "a type parameter may not take the name of a type in scope":
try expect_error("struct Point:\n var x: i64\nfunc f[Point](a: Point) -> Point:\n return a\n", "name of a type in scope")
test "a generic that nests its own parameter in a recursive call is an infinite chain":
try expect_error("struct Pair[A, B]:\n var first: A\n var second: B\nfunc grow[T](depth: T) -> i64:\n return grow(Pair[T, T](first = depth, second = depth))\n", "infinite chain")
test "a mutating view needs a var; a view comes from a pointer; a temporary has no address":
try expect_error("interface Shape:\n func scale(k: f64)\nstruct Q: Shape:\n var s: f64\n func scale(k: f64):\n self.s = k\nfunc f() -> unit:\n let q = Q(s = 1.0)\n let v: Shape = &q\n v.scale(2.0)\n", "`scale` changes its receiver, so a view of it needs a mutable pointer")
try expect_ok("interface Shape:\n func area() -> f64\nstruct Q: Shape:\n var s: f64\n func area() -> f64:\n return self.s\nfunc f() -> f64:\n let q = Q(s = 1.0)\n let v: Shape = &q\n return v.area()\n")
try expect_error("struct Q:\n var s: f64\nfunc f() -> Q*:\n return &Q(s = 1.0)\n", "address of a temporary")
test "interfaces have no generic methods; Equatable is not written by hand; what changes its receiver needs a mutable one":
try expect_error("interface Shape:\n func scaled[T](f: T) -> f64\n", "no generic methods")
try expect_error("from luce import Equatable\nstruct P: Equatable:\n var x: i64\n func equals(other: P) -> bool:\n return true\n", "not implemented by hand")
try expect_ok("interface Sink:\n func put(v: i64)\nstruct S: Sink:\n var n: i64\n func put(v: i64):\n _ = v\nfunc f():\n let s = S(n = 0)\n let view: Sink = &s\n view.put(1)\n")
try expect_error("interface Shape:\n func grow()\nstruct Sq: Shape:\n var s: i64\n func grow():\n self.s += 1\nfunc bigger[S: Shape](shape: const S*):\n shape.grow()\nfunc f():\n var q = Sq(s = 2)\n bigger(&q)\n", "`Sq.grow` changes its receiver, and `bigger` calls it on a value it may not change")
test "an atomic takes its payload as initial value and reads as it in expressions":
try expect_ok("struct C:\n var hits: @u64\n var flag: @bool\nfunc f() -> u64:\n var byte: @u8 = 250\n var c = C(hits = 1, flag = false)\n var head: @i64*? = none\n let same = c.hits == 1 and byte == 250 and head == none\n return 1 if same else 0\n")
try expect_ok("struct N:\n var v: i64\nfunc f(head: (@N*?)*) -> i64:\n if let n = *head:\n return n.v\n return 0\n")
test "atomic compound assignments are the five instructions and never checked arithmetic":
try expect_error("func f() -> unit:\n var hits: @u64\n hits *= 2\n", "atomic compound assignment")
try expect_error("func f() -> u64:\n var hits: @u64\n return hits +? 1\n", "does not apply to an atomic")
test "cas orderings: no release on failure, and failure no stronger than success":
try expect_error("func f() -> unit:\n var hits: @u64\n let (ok, seen) = hits.cas(0, 1, .acq_rel, .release)\n _ = ok\n", "may not be `release`")
try expect_error("func f() -> unit:\n var hits: @u64\n let (ok, seen) = hits.cas(0, 1, .relaxed, .acquire)\n _ = ok\n", "stronger than the success")
try expect_ok("func f() -> bool:\n var hits: @u64\n let (ok, seen) = hits.cas(0, 1, .acq_rel, .acquire)\n return ok and seen == 0\n")
test "generics infer from arguments and substitute results":
try expect_ok("func first[T](values: const T[]) -> T?:\n if values.length == 0:\n return none\n return values[0]\nfunc f() -> i64:\n let xs: i64[3] = [1, 2, 3]\n let v = first(xs) else return 0\n return v\n")
test "a generic optional parameter learns its argument from a plain value":
try expect_ok("struct Node:\n var value: i64\nfunc first_or_zero[T](node: T*?) -> i64:\n if node == none:\n return 0\n return 1\nfunc f() -> i64:\n var n = Node(value = 1)\n let p: Node* = &n\n return first_or_zero(p) + first_or_zero[Node](none)\n")
try expect_ok("func or_default[T](value: T?, fallback: T) -> T:\n return value else fallback\nfunc f() -> i64:\n let x: i64 = 3\n return or_default(x, 4)\n")
test "an else handles its operand's failure under a surrounding try":
try expect_ok("func g() -> i32!:\n return 1\nfunc f(x: i32) -> i32!:\n return x\nfunc with_try() -> i32!:\n return try f(g() else trap(\"x\"))\nfunc inner() -> i32!:\n return try f(f(g()) else 0)\nfunc maybe() -> i32?!:\n return 2\nfunc both() -> i32!:\n return try maybe() else 0\n")
test "a pointer to an atomic is spelled with parentheses, apart from an atomic pointer":
try expect_error("var flag: @u64\nfunc read(p: @u64*) -> u64:\n return 0\nfunc f() -> u64:\n return read(&flag)\n", "expected `@u64*`, got `(@u64)*`")
try expect_ok("var flag: @u64\nfunc read(p: (@u64)*) -> u64:\n return p.load(.acquire)\nfunc f() -> u64:\n return read(&flag)\n")
test "a generic struct instantiates and its methods substitute":
try expect_ok("struct Box[T]:\n var item: T\n func get() -> T:\n return self.item\nfunc f() -> i64:\n let b = Box[i64](item = 3)\n return b.get()\n")
test "the standard modules need an import":
try expect_ok("import io\nimport strings\nfunc f() -> !:\n let out = io.stdout()\n try out.write(\"hi\")\n var buf: u8[16]\n let s = try strings.format(buf, f\"{buf.length}\")\n _ = s.length\n")
try expect_error("func f() -> !:\n let out = io.stdout()\n try out.write(\"hi\")\n", "unknown name")
try expect_ok("from io import Writer\nfunc f(w: Writer) -> !:\n _ = try w.write(\"hi\".bytes)\n")
try expect_error("func f(w: Writer) -> !:\n _ = try w.write(\"hi\".bytes)\n", "unknown type")
test "interfaces form views from pointers":
try expect_ok("from io import Writer\nstruct W: Writer:\n var n: usize\n pub func write(bytes: const u8[]) -> usize!:\n self.n += bytes.length\n return bytes.length\nfunc f() -> !:\n var w = W(n = 0)\n let v: Writer = &w\n _ = try v.write(\"abc\")\n")
test "none needs an optional and if let unwraps":
try expect_error("func f() -> i64:\n let x = none\n return 0\n", "`none` needs a written type")
try expect_ok("func f(x: i64?) -> i64:\n if let v = x:\n return v\n return 0\n")
test "error and catch handle failure":
try expect_ok("let bad: ErrorCode = ErrorCode.package(1)\nfunc g(n: i64) -> i64!:\n if n < 0:\n error(bad, \"negative\")\n return n\nfunc f() -> i64:\n let v = g(-1) catch e:\n if e.code == bad:\n recover 0\n recover 1\n return v\n")
test "modules import and qualify names":
let capacity = try test_arena_size()
let backing = try new u8[capacity] --- in memory.heap
defer free(backing) in memory.heap
var arena = memory.FixedBuffer.over(backing)
var scratch: u8[1024]
with arena:
var checker = try Checker.create(scratch)
try checker.add_prelude()
let a = try source.Source.over("a", "pub struct Point:\n pub var x: i64\npub func origin() -> Point:\n return Point(x = 0)\n".bytes)
try checker.add_module("a", a, false)
let b = try source.Source.over("b", "import a\nfunc f() -> i64:\n let p = a.origin()\n return p.x\n".bytes)
try checker.add_module("b", b, false)
try checker.check_program()
test "a function that may fall off its end is rejected":
try expect_error("func f(b: bool) -> i64:\n if b:\n return 1\n", "may reach its end")
test "a diagnostic quoting a literal longer than its buffer is cut short and keeps its position":
# `0b1.000…` asks the integer 0b1 for a member named by 300 digits (a fuzzing finding)
var text: u8[400]
let head = "func f() -> i64:\n return 0b1."
for k in 0..<head.length:
text[k] = head.bytes[k]
for k in head.length..<head.length + 300:
text[k] = '0'
text[head.length + 300] = '\n'
try expect_error((str)text[..<head.length + 301], "test:2:16: a `<integer>` has no members, so no `000")
## A binding leaving scope that nothing read: marked for the block to prune (§19.6). Names
## beginning with `_` say the silence is intended; a tuple's names are not pruned.
func mark_if_unused(b: Binding):
if b.used or b.depth == 0 or b.name.length == 0 or b.name.bytes[0] == '_':
return
let d = b.decl else return
if (d.kind == ast.Kind.let_ or d.kind == ast.Kind.var_) and d.text == b.name:
# `let d = x else return ...` is a guard: the binding is the condition, not a value
if let init = d.left:
if init.kind == ast.Kind.else_:
return
d.flags |= ast.flag_unused
## Whether constant expression `e` is built only from literals, constants, casts, and
## operators whose result bits do not depend on signedness, so its `u64` fold is exact.
func sign_agnostic(e: ast.Node*, depth: u32) -> bool:
if depth > 64:
return false
match e.kind:
.literal:
return true
.group, .cast:
let inner = e.left else return false
return sign_agnostic(inner, depth + 1)
.unary:
let inner = e.left else return false
return (e.text == "-" or e.text == "-%" or e.text == "~" or e.text == "+") and sign_agnostic(inner, depth + 1)
.binary:
let l = e.left else return false
let r = e.right else return false
let agnostic = e.text == "+" or e.text == "-" or e.text == "*" or e.text == "+%" or e.text == "-%" or e.text == "*%" or e.text == "&" or e.text == "|" or e.text == "^" or e.text == "<<"
return agnostic and sign_agnostic(l, depth + 1) and sign_agnostic(r, depth + 1)
.name, .member:
let d = e.resolved else return false
if d.kind != ast.Kind.constant:
return false
let init = d.left else return false
return sign_agnostic(init, depth + 1)
_:
return false