dymokomi/luce-base
Source of release 0.43.0
0.43.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