Luce packages
LuceLuce BaseLuciaOS

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