Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.42.0

0.42.0 / src / sema / check / calls.lucb

#==============================================================================================
#
#   check/calls - Calls
#
#   DESCRIPTION:
#       Calls to functions, methods, and function values, their arguments bound to parameters,
#       generic arguments inferred (§9, §13), and `luce` facts expanded at the call site (§6.4).
#
#==============================================================================================

## A call's generic arguments while it is checked: the generic function (`template`, none
## for a plain one), its count of type parameters, and the arguments written or inferred so
## far, `types.none_id` until known.
struct CallGenerics:
    var template: ast.Node*?
    var count: usize
    var inferred: u32[]

extend Checker:
    # mark: Calls ==============================================================================

    ## `f(args)`: an intrinsic, a conversion, a construction, or a call of a
    ## function, method, or function value.
    func call_type(e: ast.Node*, hint: u32) -> u32!:
        let callee = e.left else return try self.fail(e, "missing callee")
        # a call checked again (a constant read twice) keeps the name its first check gave it
        if callee.kind == ast.Kind.name and callee.has(ast.flag_builtin):
            return try self.intrinsic_type(e, callee.text)
        if callee.kind == ast.Kind.name and self.lookup(callee.text) == none:
            if is_intrinsic(callee.text):
                return try self.intrinsic_type(e, callee.text)
        let intrinsic = self.standard_intrinsic(callee)
        if intrinsic.length > 0:
            return try self.intrinsic_type(e, intrinsic)
        if callee.kind == ast.Kind.member:
            if let receiver = callee.left:
                if receiver.kind != ast.Kind.name or self.lookup(receiver.text) != none:
                    let rt = try self.check_expr(receiver, types.none_id)
                    if self.table.kind(self.deref(rt)) == types.Kind.atomic:
                        return try self.atomic_call(e, callee, self.deref(rt))
                    if try self.derived_hash_call(e, callee, receiver, rt):
                        return try self.intrinsic_type(e, "hash")
        if callee.kind == ast.Kind.index:
            if let base = callee.left:
                if base.kind == ast.Kind.name and is_lane_type_name(base.text) and self.lookup(base.text) == none:
                    return try self.splat_type(e, callee, base)
        self.calling = callee.kind == ast.Kind.member
        let ct = try self.check_expr(callee, types.none_id)
        self.calling = false
        if callee.kind == ast.Kind.member and callee.has(ast.flag_static) and callee.text == "package" and is_error_code_type(callee.left):
            let answered = try self.check_call(e, ct, none, none, none, try types.no_args(), hint)
            try self.fold_package_code(e)
            return answered
        if let resolved = callee.resolved:
            if resolved.kind == ast.Kind.enum_case and callee.kind == ast.Kind.member:
                # `Kind.case(args)`: the payload's parameters take named or positional arguments
                let enum_id = self.table.get(ct).elem
                let d = self.table.get(enum_id).decl else return try self.fail(e, "no enum")
                e.resolved = resolved
                try self.check_payload(e, resolved, enum_id, d)
                return enum_id
        if callee.has(ast.flag_type_ref):
            return try self.construct_or_convert(e, callee, ct)
        let t = self.table.get(ct)
        if t.kind != types.Kind.func_:
            return try self.fail(callee, "this is not callable")
        # the declaration behind the callee, for names, defaults, and generics
        var decl: ast.Node*? = callee.resolved
        var owner_args = try types.no_args()
        var owner: ast.Node*? = none
        if callee.kind == ast.Kind.member:
            if let receiver = callee.left:
                let rt = self.table.get(self.deref(receiver.type_id))
                if rt.kind == types.Kind.struct_ or rt.kind == types.Kind.enum_ or rt.kind == types.Kind.union_ or rt.kind == types.Kind.interface_:
                    owner = rt.decl
                    owner_args = rt.args
                if let m = callee.resolved:
                    if m.kind == ast.Kind.func_ and not callee.has(ast.flag_static):
                        if m.has(ast.flag_mutating):
                            try self.require_mutable_receiver(receiver, m)
                        elif not self.receiver_may_change(receiver):
                            if self.table.kind(self.deref(receiver.type_id)) == types.Kind.param:
                                try self.note_read_only_use(self.deref(receiver.type_id), m.text)
                            elif let o = owner:
                                try self.keep_pending_change(receiver, m, o)
                if callee.has(ast.flag_static) and callee.resolved == none:
                    decl = none
        if callee.kind != ast.Kind.name and callee.kind != ast.Kind.member:
            # a call, an index, or a lambda answers a function value; the declaration a
            # call's callee resolved to is that callee's, not this call's
            decl = none
        if let d = decl:
            if d.kind != ast.Kind.func_ and d.kind != ast.Kind.extern_func:
                decl = none
        e.resolved = decl
        let answered = try self.check_call(e, ct, decl, e.ty if e.ty != none else callee.ty, owner, owner_args, hint)
        if let d = decl:
            if self.is_memory_frame(d):
                try self.frame_call(e, answered)
        return answered

    ## Whether `d` is the standard `memory.frame` (§12.7), whose storage the call itself takes.
    pub func is_memory_frame(d: ast.Node*) -> bool:
        if d.text != "frame" or d.kind != ast.Kind.func_:
            return false
        let index = self.find_module("memory") else return false
        let module = self.modules.get(index)
        return module.is_prelude and find_decl(module.tree, "frame") == d

    ## The rules of a `memory.frame` call beyond its signature: `most` is a constant, the
    ## bytes it allows at most 4096, and the span is a local's address (§6.6).
    func frame_call(e: ast.Node*, span: u32) -> !:
        let first = e.body else return
        let second = first.next else return
        let most_node = second.left else return
        let constant = self.constant_u64(most_node)
        if constant == none:
            try self.fail(most_node, "`memory.frame`'s most is a constant (§12.7)")
        let most = constant else return
        let bytes = most *? self.table.size_of(self.table.get(span).elem) else 4097
        if bytes > 4096:
            try self.fail(most_node, "`memory.frame` may take at most 4096 bytes (§12.7)")
        mark_local(e)

    ## The operations of an `@T` (§15.1): read-modify-write methods returning the
    ## previous value, `load`, `store`, `cas`, `wait`, and `wake`. An omitted
    ## ordering is `seq_cst`.
    func atomic_call(e: ast.Node*, callee: ast.Node*, atomic_id: u32) -> u32!:
        let name = callee.text
        let elem = self.table.get(atomic_id).elem
        let ordering = try self.ordering_type()
        callee.flags |= ast.flag_static
        callee.type_id = atomic_id
        # an operation that stores is a change of the receiver whose atomic it is (§9.5)
        if name != "load" and name != "wait":
            if let place = callee.left:
                if not self.is_mutable_place(place):
                    _ = self.changes_receiver(place)
        if name == "load":
            try self.place_atomic_arguments(e, ["order"])
        elif name == "cas":
            try self.place_atomic_arguments(e, ["expected", "desired", "success", "failure", "weak"])
        elif name == "wait":
            try self.place_atomic_arguments(e, ["expected"])
        elif name == "wake":
            try self.place_atomic_arguments(e, ["count"])
        else:
            try self.place_atomic_arguments(e, ["value", "order"])
        var args = e.body
        var given: usize = 0
        while let a = args:
            given += 1
            if let v = a.left:
                if v.kind == ast.Kind.case_value and v.text == "signal":
                    return try self.fail(v, "`.signal` orders a fence alone, `atomic.fence(.signal)` (§15.1)")
            args = a.next
        if name == "load":
            if given > 1:
                return try self.fail(e, "`load(order)` takes at most one argument")
            if given == 1:
                try self.expect_argument(e, 0, ordering)
            return elem
        if name == "store":
            if given < 1 or given > 2:
                return try self.fail(e, "`store(value, order)` takes one or two arguments")
            try self.expect_argument(e, 0, elem)
            if given == 2:
                try self.expect_argument(e, 1, ordering)
            return types.unit_id
        if name == "add" or name == "sub" or name == "set" or name == "clear" or name == "flip" or name == "max" or name == "min" or name == "swap":
            if given < 1 or given > 2:
                return try self.fail(e, "this atomic method takes a value and an optional ordering")
            if name != "swap" and not self.table.is_integer(elem):
                return try self.fail(e, "this atomic method needs an integer atomic")
            try self.expect_argument(e, 0, elem)
            if given == 2:
                try self.expect_argument(e, 1, ordering)
            return elem
        if name == "cas":
            if given < 2 or given > 5:
                return try self.fail(e, "`cas(expected, desired, success, failure, weak)` takes two to five arguments")
            try self.expect_argument(e, 0, elem)
            try self.expect_argument(e, 1, elem)
            if given >= 3:
                try self.expect_argument(e, 2, ordering)
            if given >= 4:
                try self.expect_argument(e, 3, ordering)
                # the failure ordering is never `release` or `acq_rel`, nor stronger than success
                let failure = argument_at(e, 3) else return try self.fail(e, "no failure ordering")
                if failure.kind == ast.Kind.case_value and (failure.text == "release" or failure.text == "acq_rel"):
                    return try self.fail(failure, "the failure ordering of `cas` may not be `release` or `acq_rel` (§15.1)")
                if let success = argument_at(e, 2):
                    if ordering_rank(failure) > ordering_rank(success):
                        return try self.fail(failure, "the failure ordering of `cas` may not be stronger than the success ordering (§15.1)")
            if given == 5:
                try self.expect_argument(e, 4, types.bool_id)
            var pair = try new u32[2] ---
            pair[0] = types.bool_id
            pair[1] = elem
            return try self.table.tuple(pair)
        if name == "wait":
            if given != 1:
                return try self.fail(e, "`wait(expected)` takes one argument")
            try self.expect_argument(e, 0, elem)
            return types.unit_id
        if name == "wake":
            if given != 1:
                return try self.fail(e, "`wake(count)` takes one argument")
            try self.expect_argument(e, 0, types.u32_id)
            return types.unit_id
        return try self.fail(callee, "an atomic has add, sub, set, clear, flip, max, min, swap, load, store, cas, wait, and wake")

    ## An atomic method's arguments in their places (§15.1): the positional ones first, then
    ## each named one in the place `names` gives its name, an ordering skipped before a
    ## later one written as `.seq_cst`, as an omitted ordering is. The names are then
    ## dropped, so the method's check reads every argument by its position.
    func place_atomic_arguments(e: ast.Node*, names: const str[]) -> !:
        var slots: ast.Node*?[5]
        var named = false
        var position: usize = 0
        var cursor = e.body
        while let a = cursor:
            cursor = a.next
            if a.text.length == 0:
                if named:
                    return try self.fail(a, "a positional argument comes before the named ones")
                if position >= names.length:
                    return
                slots[position] = a
                position += 1
                continue
            named = true
            var place = names.length
            for k in 0..<names.length:
                if names[k] == a.text:
                    place = k
            if place == names.length:
                return try self.fail(a, "this atomic method has no argument of this name")
            if slots[place] != none:
                return try self.fail(a, "this argument is given twice")
            slots[place] = a
        if not named:
            return
        var last: usize = 0
        for k in 0..<names.length:
            if slots[k] != none:
                last = k
        var first: ast.Node*? = none
        var tail: ast.Node*? = none
        for k in 0..<last + 1:
            var a = slots[k]
            if a == none:
                if names[k] != "order" and names[k] != "success" and names[k] != "failure":
                    return try self.fail(e, "an argument before a named one is missing")
                let filled = try ast.Node.make(ast.Kind.argument, "", e.start, e.line)
                filled.left = try ast.Node.make(ast.Kind.case_value, "seq_cst", e.start, e.line)
                a = filled
            let placed = a else return
            placed.text = ""
            placed.next = none
            ast.append(&first, &tail, placed)
        e.body = first

    ## The `atomic.Ordering` enum from the prelude.
    func ordering_type() -> u32!:
        let ai = self.find_module("atomic") else return try fail_now("the `atomic` module is missing")
        let tree = self.modules.get(ai).tree
        let d = find_decl(tree, "Ordering") else return try fail_now("`atomic.Ordering` is missing")
        return d.type_id

    ## Check the `index`th argument of a call against `want`.
    func expect_argument(e: ast.Node*, index: usize, want: u32) -> !:
        var i: usize = 0
        var args = e.body
        while let a = args:
            if i == index:
                if a.text.length > 0:
                    try self.fail(a, "this argument is positional")
                let v = a.left else return try self.fail(a, "empty argument")
                _ = try self.expect(v, want)
                return
            i += 1
            args = a.next
        try self.fail(e, "missing argument")

    ## A call of a method that changes its receiver needs a `var`, a mutable pointer, or a
    ## mutable element (§9.5).
    func require_mutable_receiver(receiver: ast.Node*, method: ast.Node*) -> !:
        let rt = self.table.get(receiver.type_id)
        var text: u8[256]
        if rt.kind == types.Kind.pointer:
            if rt.is_const:
                try self.fail(receiver, said(text, f"`{method.text}` changes its receiver, so it needs a mutable pointer here (§9.5)"))
            return
        if rt.kind == types.Kind.interface_:
            return
        if not self.is_mutable_place(receiver) and not self.changes_receiver(receiver):
            try self.fail(receiver, said(text, f"`{method.text}` changes its receiver, so it needs a `var` here (§9.5)"))

    ## Whether a method may change `receiver`: a mutable pointer, a view, or a mutable place.
    func receiver_may_change(receiver: ast.Node*) -> bool:
        let rt = self.table.get(receiver.type_id)
        if rt.kind == types.Kind.pointer:
            return not rt.is_const
        return rt.kind == types.Kind.interface_ or self.is_mutable_place(receiver)

    ## Match arguments to parameters, infer generic arguments, and yield the result.
    func check_call(e: ast.Node*, fn: u32, decl: ast.Node*?, explicit: ast.Node*?, owner: ast.Node*?, owner_args: u32[], hint: u32) -> u32!:
        let f = self.table.get(fn)
        let g = try self.call_generics(decl, explicit)
        # first pass: bind positional and named arguments to parameters and type them
        let slots = try self.bind_arguments(e, f, decl)
        try self.type_arguments(e, f, decl, explicit != none, g, slots)
        if let t = g.template:
            try self.check_inferred(e, t, g)
        # second pass: coerce each argument to its (substituted) parameter type
        var i: usize = 0
        while i < f.args.length:
            var want = f.args[i]
            if let t = g.template:
                want = try self.substitute(want, t, g.inferred)
            if let a = slots[i]:
                let v = a.left else return try self.fail(a, "empty argument")
                if v.type_id == types.none_id or v.type_id == types.untyped_int_id or v.type_id == types.untyped_float_id or self.mentions_param(want) == false:
                    _ = try self.coerce(v, v.type_id if v.type_id != types.none_id else try self.check_expr(v, want), want)
                if owner_args.length > 0:
                    if let d = decl:
                        try self.handled_kept(e, d, v, self.table.get(d.type_id).args[i], want)
            i += 1
        var result = f.elem
        if let t = g.template:
            result = try self.substitute(result, t, g.inferred)
            # the instance the backend must build: the arguments as type nodes on the call
            if explicit == none:
                let holder = try ast.Node.make(ast.Kind.type_, "", e.start, e.line)
                var tail: ast.Node*? = none
                var j: usize = 0
                while j < g.count:
                    let a = try ast.Node.make(ast.Kind.type_, "", e.start, e.line)
                    a.type_id = g.inferred[j]
                    ast.append(&holder.body, &tail, a)
                    j += 1
                e.ty = holder
        _ = owner
        _ = hint
        return result

    ## The generic arguments of a call of `decl`: none for a plain function, else the ones
    ## `explicit` writes, or all still to infer.
    func call_generics(decl: ast.Node*?, explicit: ast.Node*?) -> CallGenerics!:
        var g = CallGenerics(template = none, count = 0, inferred = try types.no_args())
        if let d = decl:
            g.count = ast.count(generic_params_of(d))
            if g.count > 0:
                g.template = d
        if g.count == 0:
            return g
        g.inferred = try new u32[g.count] ---
        var i: usize = 0
        while i < g.count:
            g.inferred[i] = types.none_id
            i += 1
        if let ex = explicit:
            let n = ast.count(ex.body)
            if n != g.count:
                return try self.fail(ex, "wrong number of type arguments")
            var cursor = ex.body
            var j: usize = 0
            while let a = cursor:
                g.inferred[j] = try self.resolve_type(a)
                j += 1
                cursor = a.next
        return g

    ## The argument bound to each parameter of `f`, positional or named, `none` for one
    ## left to its default; the arguments past a C variadic's parameters are checked here.
    func bind_arguments(e: ast.Node*, f: types.Type, decl: ast.Node*?) -> ast.Node*?[]!:
        let n_params = f.args.length
        var slots = try new ast.Node*?[n_params + 1] ---
        var i: usize = 0
        while i <= n_params:
            slots[i] = none
            i += 1
        var position: usize = 0
        var cursor = e.body
        while let a = cursor:
            if a.text.length > 0:
                let d = decl else return try self.fail(a, "named arguments need a declared function")
                var said17: u8[256]
                let index = param_index(d, a.text) else return try self.fail(a, said(said17, f"`{d.text}` has no parameter `{a.text}`"))
                if slots[index] != none:
                    return try self.fail(a, "this argument is given twice")
                slots[index] = a
            elif position < n_params:
                slots[position] = a
                position += 1
            elif f.variadic:
                try self.variadic_argument(a)
            else:
                return try self.fail(a, "too many arguments")
            cursor = a.next
        return slots

    ## An argument in a C variadic's `...`: a scalar or a pointer, a text literal passing
    ## as `c.str`, an untyped integer as `i32`.
    func variadic_argument(a: ast.Node*) -> !:
        let v = a.left else return try self.fail(a, "empty argument")
        let vt = try self.check_expr(v, types.none_id)
        let ck = self.table.kind(vt)
        if vt == types.str_id and v.kind == ast.Kind.literal and v.text.bytes[0] == '"':
            # a text literal passes as `c.str`, the way C's own literals do (§17.2)
            _ = try self.coerce(v, vt, types.cstr_id)
        elif ck == types.Kind.span or ck == types.Kind.interface_ or ck == types.Kind.tuple or ck == types.Kind.array or ck == types.Kind.struct_ or ck == types.Kind.union_ or vt == types.str_id or vt == types.fmt_id or (ck == types.Kind.optional and not self.table.is_nullable_pointer(vt)):
            # C's `...` carries scalars and pointers only (§17.2)
            return try self.fail(v, "this type cannot be a variadic argument; C has no shape for it; text goes as `c.str`")
        else:
            _ = try self.coerce(v, vt, types.i32_id if vt == types.untyped_int_id else concrete(vt))

    ## Types each bound argument against its parameter, inferring generic arguments from
    ## those whose parameter still names one; a parameter with no argument takes its
    ## default, a `luce` fact expanded at the call.
    func type_arguments(e: ast.Node*, f: types.Type, decl: ast.Node*?, explicit: bool, g: CallGenerics, slots: ast.Node*?[]) -> !:
        var i: usize = 0
        while i < f.args.length:
            var want = f.args[i]
            if let t = g.template:
                if self.mentions_param(want):
                    # written type arguments, or earlier arguments that fixed every parameter
                    # this one names, give it its type, so the argument is checked against it
                    # (`count[i64?]([none, 2])`, `put(&box, .number(1))`); otherwise it is inferred
                    want = try self.substitute(want, t, g.inferred) if explicit or self.all_inferred(want, t, g.inferred) else types.none_id
            if let a = slots[i]:
                let v = a.left else return try self.fail(a, "empty argument")
                var hint = want
                if want == types.none_id and (v.kind == ast.Kind.unary or v.kind == ast.Kind.slice) and self.wants_change(f.args[i]):
                    # `put(&self.box, value)` for `put[T](box: Box[T]*, ...)`: the address is
                    # taken where a mutable one is wanted, though `T` is still to infer (§9.5)
                    hint = f.args[i]
                var got = try self.check_expr(v, hint)
                if let t = g.template:
                    if want == types.none_id:
                        got = concrete(got) if got != types.none_id else got
                        try self.infer(f.args[i], got, t, g.inferred)
            else:
                let d = decl else return try self.fail(e, "too few arguments")
                let p = param_at(d, i) else return try self.fail(e, "too few arguments")
                let default = p.left else return try self.fail(e, "a required argument is missing")
                if is_luce_fact(default):
                    try self.expand_fact_argument(e, p, default)
            i += 1

    ## Every generic argument of a call of `t` is known and meets its constraints, and a
    ## call of `t` inside itself does not nest its own parameter without end.
    func check_inferred(e: ast.Node*, t: ast.Node*, g: CallGenerics) -> !:
        var j: usize = 0
        while j < g.count:
            if g.inferred[j] == types.none_id:
                return try self.fail(e, "a type argument could not be inferred; write it")
            j += 1
        try self.check_constraints(t, g.inferred, e)
        let here = self.current_func else return
        if here != t:
            return
        var k: usize = 0
        var own = generic_params_of(t)
        while let p = own:
            if k < g.count and g.inferred[k] != p.type_id and self.mentions_param(g.inferred[k]):
                return try self.fail(e, "an infinite chain of instantiations: the call nests its own type parameter")
            k += 1
            own = p.next

    ## Is every generic parameter of `decl` that `id` mentions already bound in `inferred`?
    ## An enclosing generic's parameter is not this call's to infer.
    func all_inferred(id: u32, decl: ast.Node*, inferred: u32[]) -> bool:
        let t = self.table.get(id)
        match t.kind:
            .param:
                var i: usize = 0
                var cursor = generic_params_of(decl)
                while let g = cursor:
                    if g.type_id == id:
                        return i < inferred.length and inferred[i] != types.none_id
                    i += 1
                    cursor = g.next
                return true
            .pointer, .span, .array, .optional, .fallible, .atomic:
                return self.all_inferred(t.elem, decl, inferred)
            .tuple, .func_, .struct_, .enum_, .union_, .interface_:
                var i: usize = 0
                while i < t.args.length:
                    if not self.all_inferred(t.args[i], decl, inferred):
                        return false
                    i += 1
                return t.kind != types.Kind.func_ or self.all_inferred(t.elem, decl, inferred)
            _:
                return true

    ## Does `id` mention a generic parameter type anywhere?
    func mentions_param(id: u32) -> bool:
        let t = self.table.get(id)
        match t.kind:
            .param:
                return true
            .pointer, .span, .array, .optional, .fallible, .atomic:
                return self.mentions_param(t.elem)
            .tuple, .func_, .struct_, .enum_, .union_, .interface_:
                var i: usize = 0
                while i < t.args.length:
                    if self.mentions_param(t.args[i]):
                        return true
                    i += 1
                if t.kind == types.Kind.func_:
                    return self.mentions_param(t.elem)
                return false
            _:
                return false

    ## `T(x)` on a type: a checked conversion for scalars and integer-backed enums,
    ## a construction for structs, a payload case for enums.
    func construct_or_convert(e: ast.Node*, callee: ast.Node*, id: u32) -> u32!:
        var target = id
        if let ex = callee.ty:
            if callee.kind == ast.Kind.name:
                target = id
        if let ex = e.ty:
            # `List[T](...)`: the type arguments sit on the call
            let d = self.table.get(id).decl else return try self.fail(e, "this type takes no type arguments")
            let named = try ast.Node.make(ast.Kind.type_, callee.text, e.start, e.line)
            named.body = ex.body
            target = try self.instantiate_node(named, d)
            callee.type_id = target
        let t = self.table.get(target)
        if self.table.is_numeric(target) or target == types.char_id:
            let arg = try self.single_argument(e)
            let got = try self.check_expr(arg, types.none_id)
            let have = concrete(got)
            if got == types.untyped_int_id or got == types.untyped_float_id:
                _ = try self.coerce(arg, got, have)
            if not (self.table.is_numeric(have) or have == types.char_id or have == types.bool_id):
                return try self.fail(arg, "a checked conversion takes a number")
            if is_negative_literal(arg) and self.table.is_integer(target) and not self.table.is_signed(target):
                # a conversion the compiler can prove impossible is an error (§7.5)
                return try self.fail(arg, "a negative literal never fits an unsigned type")
            return target
        if target == types.str_id:
            let arg = try self.single_argument(e)
            let got = try self.check_expr(arg, types.none_id)
            let s = self.table.get(got)
            if (s.kind == types.Kind.span or s.kind == types.Kind.array) and s.elem == types.u8_id:
                return try self.table.fallible(types.str_id)
            if got == types.cstr_id:
                return try self.table.fallible(types.str_id)
            return try self.fail(arg, "`str(x)` takes bytes or a C string")
        if t.kind == types.Kind.enum_ and self.is_backed_enum(target):
            let arg = try self.single_argument(e)
            let got = try self.check_expr(arg, types.none_id)
            if not (got == types.untyped_int_id or self.table.is_integer(got)):
                return try self.fail(arg, "an enum conversion takes an integer")
            _ = try self.coerce(arg, got, concrete(got))
            return target
        if t.kind == types.Kind.struct_:
            let d = t.decl else return try self.fail(e, "no declaration")
            let generic_count = ast.count(generic_params_of(d))
            if generic_count > 0 and t.args.length == 0 and not self.inside(d):
                return try self.fail(e, "this type needs type arguments, `Name[T](...)`")
            if generic_count > 0 and e.ty == none and not self.inside(d) and self.all_params(t.args):
                # `Pair(key = 1, value = 2)`: the arguments come from the fields' values
                let instance = try self.infer_construction(e, d, generic_count)
                callee.type_id = instance
                return try self.construct(e, instance, e.body)
            return try self.construct(e, target, e.body)
        if t.kind == types.Kind.union_:
            return try self.fail(e, "a union is built by assigning one member")
        return try self.fail(e, "this type cannot be called")

    func single_argument(e: ast.Node*) -> ast.Node*!:
        let a = e.body else return try self.fail(e, "one argument is needed")
        if a.next != none:
            return try self.fail(e, "one argument is needed")
        let v = a.left else return try self.fail(e, "empty argument")
        return v

    ## `Name(field = value, ...)`: the memberwise initialiser, positional or named,
    ## or the struct's own `init` (§10.1). Yields the struct, or `Name!` when
    ## `init` is fallible.
    func construct(e: ast.Node*, id: u32, args: ast.Node*?) -> u32!:
        let t = self.table.get(id)
        let d = t.decl else return try self.fail(e, "no declaration")
        if let init = find_member(d, "init", ast.Kind.func_):
            e.resolved = init
            let fn = try self.substitute(init.type_id, d, t.args)
            _ = try self.check_call(e, fn, init, none, d, t.args, types.none_id)
            if init.has(ast.flag_fallible):
                return try self.table.fallible(id)
            return id
        var cursor = args
        var positional = d.body
        var named = false
        while let a = cursor:
            let v = a.left else return try self.fail(a, "empty argument")
            var field: ast.Node*? = none
            if a.text.length > 0:
                named = true
                field = find_member(d, a.text, ast.Kind.field)
                var said18: u8[256]
                if field == none:
                    return try self.fail(a, said(said18, f"`{d.text}` has no field `{a.text}`"))
                var earlier = args
                while let o = earlier:
                    if o == a:
                        break
                    if o.text == a.text:
                        return try self.fail(a, "this field is given twice")
                    earlier = o.next
            else:
                if named:
                    return try self.fail(a, "a positional value cannot follow a named one")
                while let p = positional:
                    if p.kind == ast.Kind.field:
                        break
                    positional = p.next
                let p = positional else return try self.fail(a, "too many values for this struct")
                field = p
                positional = p.next
            let f = field else return try self.fail(a, "no field")
            a.text = f.text
            if not f.has(ast.flag_pub) and not self.same_module(d) and not self.inside(d):
                var said19: u8[256]
                return try self.fail(a, said(said19, f"field `{f.text}` of `{d.text}` is not public"))
            let want = try self.substitute(f.type_id, d, t.args)
            _ = try self.expect(v, want)
            a.resolved = f
            cursor = a.next
        # a field with a default or a zero value may be omitted, a struct field that has a
        # zero value by its own defaults receiving `Field()`; every other field is required
        var member = d.body
        while let f = member:
            member = f.next
            if f.kind != ast.Kind.field or f.left != none:
                continue
            let ft = try self.substitute(f.type_id, d, t.args)
            if self.table.zeroable(ft) or argument_names(args, f, d):
                continue
            if not try self.has_zero_value(ft):
                var said20: u8[256]
                return try self.fail(e, said(said20, f"field `{f.text}` of `{d.text}` is required: it has no default and its type no zero value"))
            let argument = try ast.Node.make(ast.Kind.argument, f.text, e.start, e.line)
            argument.left = try self.zero_construction(ft, e)
            argument.resolved = f
            argument.type_id = ft
            append_argument(e, argument)
        return id

    ## Whether `T` has a zero value, which `var x: T` holds (§6.1): a zeroable type, or a
    ## struct with no `init` of its own whose every field has a default or a zero value.
    pub func has_zero_value(id: u32) -> bool!:
        if self.table.zeroable(id):
            return true
        return try self.undefaulted_field(id) == none and self.table.kind(id) == types.Kind.struct_

    ## The first field of struct `id` with neither a default nor a zero value, which keeps
    ## the struct from having a zero value; none when every field has one, or when `id` is
    ## no struct or has its own `init` (the struct itself is then what has none).
    pub func undefaulted_field(id: u32) -> ast.Node*?!:
        let t = self.table.get(id)
        if t.kind != types.Kind.struct_:
            return none
        let d = t.decl else return none
        if find_member(d, "init", ast.Kind.func_) != none:
            return none
        var member = d.body
        while let f = member:
            member = f.next
            if f.kind == ast.Kind.field and f.left == none and not try self.has_zero_value(try self.substitute(f.type_id, d, t.args)):
                return f
        return none

    ## `T()` for a struct `T` that has a zero value by its defaults, checked: the value
    ## a `var` without one, or an omitted field, holds (§6.1).
    pub func zero_construction(id: u32, at: ast.Node*) -> ast.Node*!:
        let d = self.table.get(id).decl else return try self.fail(at, "no declaration")
        let callee = try ast.Node.make(ast.Kind.name, d.text, at.start, at.line)
        callee.flags |= ast.flag_type_ref
        callee.resolved = d
        callee.type_id = id
        let call = try ast.Node.make(ast.Kind.call, "", at.start, at.line)
        call.left = callee
        call.type_id = try self.construct(call, id, none)
        return call

    ## A default argument that is `luce.line`, `luce.file`, or `luce.function` expands at
    ## the call site (§6.4): the call gains a named argument holding the fact as a literal.
    func expand_fact_argument(call: ast.Node*, p: ast.Node*, fact: ast.Node*) -> !:
        if fact.text == "location":
            # `luce.location` itself, re-spelled at the call so the backends read its line there
            let owner = fact.left else return
            let module = try ast.Node.make(ast.Kind.name, owner.text, call.start, call.line)
            module.type_id = owner.type_id
            module.resolved = owner.resolved
            let here = try ast.Node.make(ast.Kind.member, fact.text, call.start, call.line)
            here.left = module
            here.type_id = p.type_id
            here.resolved = fact.resolved
            let argument = try ast.Node.make(ast.Kind.argument, p.text, call.start, call.line)
            argument.left = here
            argument.type_id = p.type_id
            append_argument(call, argument)
            return
        var text = ""
        var id = types.str_id
        if fact.text == "line":
            var digits = try new u8[12] ---
            text = try strings.format(digits, f"{call.line}")
            id = types.u32_id
        elif fact.text == "file":
            let path = self.modules.get(self.current).src.path
            var spelled = try new u8[path.length + 2] ---
            text = try strings.format(spelled, f"\"{path}\"")
        else:
            var name = "main"
            if let f = self.current_func:
                name = f.text
            var spelled = try new u8[name.length + 2] ---
            text = try strings.format(spelled, f"\"{name}\"")
        let literal = try ast.Node.make(ast.Kind.literal, text, call.start, call.line)
        literal.type_id = id
        let argument = try ast.Node.make(ast.Kind.argument, p.text, call.start, call.line)
        argument.left = literal
        argument.type_id = id
        append_argument(call, argument)

func append_argument(call: ast.Node*, argument: ast.Node*):
    var tail: ast.Node*? = none
    var cursor = call.body
    while let a = cursor:
        tail = a
        cursor = a.next
    if let last = tail:
        last.next = argument
    else:
        call.body = argument