dymokomi/luce-base
Source of release 0.44.0
0.44.0 / src / sema / check / expressions.lucb
#==============================================================================================
#
# check/expressions - Expressions
#
# DESCRIPTION:
# `check_expr` and the expressions with no family of their own: literals, names,
# tuples and arrays, enum cases, and `else` and `catch` (§7, §11).
#
#==============================================================================================
extend Checker:
# mark: Expressions ========================================================================
## The type of `e`, recorded on the node. `hint` is the type the context wants,
## used by literals, `none`, `.case`, array literals, and lambdas; it is a hint,
## not a requirement, so callers `coerce` afterwards.
pub func check_expr(e: ast.Node*, hint: u32) -> u32!:
let id = try self.expr_type(e, hint)
e.type_id = id
# The formatter handles its synthetic Display call itself; user operands
# inside that call still use the surrounding expression's effect context.
if self.expression_effect and self.table.kind(id) == types.Kind.fallible and not e.has(ast.flag_format_sink) and not self.else_handles(e, id):
let inner = try ast.Node.make(e.kind, e.text, e.start, e.line)
*inner = *e
inner.next = none
e.kind = ast.Kind.propagate
e.text = "try"
e.left = inner
e.right = none
e.body = none
e.ty = none
e.resolved = none
e.type_id = self.table.get(id).elem
if self.calls_another_package(inner):
e.flags |= ast.flag_crossing
self.effect_count += 1
return e.type_id
return id
## Whether `e` calls a function or method of another package by name, so that a failure
## it passes comes into this package across the call (§11.3's `called_at`). A call through
## a function value or an interface names no package and does not count.
func calls_another_package(e: ast.Node*) -> bool:
if e.kind != ast.Kind.call:
return false
let callee = e.left else return false
let d = callee.resolved else return false
if d.kind != ast.Kind.func_:
return false
# a top-level function knows its module; a method's is its type's
var tree = d.resolved
if let known = tree:
if known.kind != ast.Kind.module:
tree = none
if tree == none and callee.kind == ast.Kind.member:
let owner = callee.left else return false
var t = owner.type_id
if self.table.kind(t) == types.Kind.pointer:
t = self.table.get(t).elem
let k = self.table.kind(t)
if k != types.Kind.struct_ and k != types.Kind.enum_ and k != types.Kind.union_:
return false
let owner_decl = self.table.get(t).decl else return false
tree = owner_decl.resolved
let module = tree else return false
if module.kind != ast.Kind.module or self.current >= self.modules.count:
return false
if module == self.modules.get(self.current).tree:
return false
return self.package_of_tree(module) != self.package_of(self.current)
## The package of module `index`: `luce` for the standard modules, as their error codes
## are (§11.3).
func package_of(index: usize) -> str:
let m = self.modules.get(index)
if m.is_prelude:
return "luce"
return m.package_name if m.package_name.length > 0 else self.package_name
## The package of the module whose tree is `tree`.
func package_of_tree(tree: ast.Node*) -> str:
var i: usize = 0
while i < self.modules.count:
if self.modules.get(i).tree == tree:
return self.package_of(i)
i += 1
return self.package_of(self.current)
func expr_type(e: ast.Node*, hint: u32) -> u32!:
match e.kind:
.propagate:
self.effect_count += 1
return e.type_id
.literal:
return try self.literal_type(e, hint)
.name:
return try self.generic_function_value(e, try self.name_type(e), hint)
.self_:
if self.self_type == types.none_id:
return try self.fail(e, "`self` outside a method")
return self.self_type
.unit_:
return types.unit_id
.group:
let inner = e.left else return try self.fail(e, "empty group")
return try self.check_expr(inner, hint)
.unary:
return try self.unary_type(e, hint)
.binary:
return try self.binary_type(e, hint)
.conditional:
let cond = e.ty else return try self.fail(e, "a conditional needs a condition")
_ = try self.expect(cond, types.bool_id)
let l = e.left else return try self.fail(e, "a conditional needs a value")
let r = e.right else return try self.fail(e, "a conditional needs an alternative")
let lt = try self.check_expr(l, hint)
let rt = try self.check_expr(r, hint if hint != types.none_id else lt)
# a `never` branch takes the other branch's type: its value never exists (§5.1)
if lt == types.never_id:
return rt
if rt == types.never_id:
return lt
# `none if c else 3` is an `i64?` whatever the context asked (§5.8)
if lt == types.none_id and rt != types.none_id:
let whole = try self.table.optional(concrete(rt))
_ = try self.coerce(l, lt, whole)
_ = try self.coerce(r, rt, whole)
return whole
if rt == types.none_id and lt != types.none_id:
let whole = try self.table.optional(concrete(lt))
_ = try self.coerce(l, lt, whole)
_ = try self.coerce(r, rt, whole)
return whole
return try self.unify(l, lt, r, rt)
.call:
return try self.call_type(e, hint)
.member:
return try self.member_type(e)
.index:
if self.names_instantiation(e):
# `negate[Point]`: a generic function and a type, the instance (§13)
let owner = e.left else return try self.fail(e, "missing operand")
let arg = e.body else return try self.fail(e, "missing index")
let holder = try ast.Node.make(ast.Kind.type_, "", e.start, e.line)
let named = try ast.Node.make(ast.Kind.type_, arg.text, arg.start, arg.line)
holder.body = named
e.kind = ast.Kind.name
e.text = owner.text
e.ty = holder
e.left = none
e.body = none
return try self.generic_function_value(e, try self.name_type(e), hint)
return try self.index_type(e)
.slice:
return try self.slice_type(e, hint)
.tuple:
let t = try self.tuple_type(e, hint)
mark_if_member_local(e)
return t
.array_lit:
let t = try self.array_type(e, hint)
mark_if_member_local(e)
return t
.lambda:
return try self.lambda_type(e, hint)
.else_:
return try self.else_type(e, hint)
.catch_:
return try self.catch_type(e, hint)
.cast:
return try self.cast_type(e)
.case_value:
return try self.case_type(e, hint)
.formatted:
var part = e.body
while let p = part:
if p.kind == ast.Kind.format_field:
let v = p.left else return try self.fail(p, "empty field")
let vt = try self.check_expr(v, types.none_id)
_ = try self.settle(v, vt)
if p.text.length > 0:
try self.display_by_spec(p, v, concrete(vt))
elif not self.printable(vt):
if self.displays_itself(vt):
try self.display_through_sink(p)
else:
try self.fail(v, "this value cannot be formatted")
part = p.next
return types.fmt_id
.new_:
return try self.new_type(e)
.new_unwritten:
return try self.unwritten_type(e)
.span_make:
let t = e.ty else return try self.fail(e, "a span constructor needs a type")
let span = try self.resolve_type(t)
let elem = self.table.get(span).elem
let pointer = try self.table.pointer(elem, self.table.get(span).is_const, false)
var args = e.body
let p = args else return try self.fail(e, "a span constructor takes a pointer and a count")
let pv = p.left else return try self.fail(e, "empty argument")
_ = try self.expect(pv, pointer)
let second = p.next else return try self.fail(e, "a span constructor takes a pointer and a count")
let cv = second.left else return try self.fail(e, "empty argument")
_ = try self.expect(cv, types.usize_id)
return span
.match_expr:
return try self.match_type(e, hint, true)
.return_, .break_, .continue_:
try self.check_stmt(e)
return types.never_id
_:
return try self.fail(e, "unsupported expression")
## A struct that is `Display` (§14.4) shows itself in a formatted string.
func displays_itself(id: u32) -> bool:
let iface = self.standard_type("luce", "Display")
if iface == types.none_id:
return false
if self.table.kind(id) == types.Kind.param:
# a parameter bound by `Display` writes itself through the sink; the instantiation
# supplies the how, a struct's own `display` or the compiler's for a scalar
return self.has_written_constraint(id, iface)
if self.table.kind(id) != types.Kind.struct_:
return false
return self.conforms(id, iface)
## The type of a standard module's declaration, `io.Writer`; `none_id` when absent.
pub func standard_type(module: str, name: str) -> u32:
let index = self.find_module(module) else return types.none_id
let d = find_decl(self.modules.get(index).tree, name) else return types.none_id
return d.type_id
## A field whose value writes itself becomes the call `value.display(__sink)`, where
## `__sink` stands for the string's own sink (`flag_format_sink`); the backends supply
## that sink where they build the string.
func display_through_sink(field: ast.Node*) -> !:
let v = field.left else return
let sink = try ast.Node.make(ast.Kind.name, "__sink", field.start, field.line)
sink.flags |= ast.flag_format_sink
let argument = try ast.Node.make(ast.Kind.argument, "", field.start, field.line)
argument.left = sink
let call = try method_call(v, "display", field)
call.body = argument
call.flags |= ast.flag_format_sink
field.left = call
field.flags |= ast.flag_format_sink
_ = try self.check_expr(call, types.none_id)
## A field `{value:spec}` (§5.5): a number or text, and a specification that reads and
## fits it. The field becomes the call `strings.write_i64(__sink, value, "spec")`, or the
## writer of the value's kind, which `numerals` lays the value out for.
func display_by_spec(field: ast.Node*, v: ast.Node*, got: u32) -> !:
var id = got
if self.table.kind(id) == types.Kind.atomic:
id = self.table.get(id).elem
var category = numerals.Category.text
var writer = "write_text"
var target = id
var target_name = ""
if self.table.is_integer(id):
category = numerals.Category.integer
let signed = self.table.is_signed(id)
writer = "write_i64" if signed else "write_u64"
target = types.i64_id if signed else types.u64_id
target_name = "i64" if signed else "u64"
elif self.table.is_float(id):
category = numerals.Category.floating
writer = "write_f64" if id == types.f64_id else "write_f32"
target = types.f64_id if id == types.f64_id else types.f32_id
target_name = "f64" if id == types.f64_id else "f32"
elif id == types.char_id:
writer = "write_char"
elif id == types.bool_id:
writer = "write_bool"
elif id != types.str_id:
return try self.fail(v, "a format specification lays out a number, a `str`, a `char`, or a `bool`; this value shows itself, `{value}` (§5.5)")
let reading = numerals.read(field.text)
var text: u8[512]
if reading.problem.length > 0:
return try self.fail(field, said(text, f"this format specification does not read: {reading.problem} (§5.5)"))
let problem = numerals.misfit(reading.spec, category)
if problem.length > 0:
return try self.fail(field, said(text, f"this format specification does not fit the value: {problem} (§5.5)"))
let decl = self.standard_decl("strings", writer) else return try self.fail(field, "the standard library's `strings` has no field writers")
var value = v
if got != target:
value = try ast.Node.make(ast.Kind.cast, "", v.start, v.line)
value.ty = try ast.Node.make(ast.Kind.type_, target_name, v.start, v.line)
value.left = v
_ = try self.check_expr(value, target)
let sink = try ast.Node.make(ast.Kind.name, "__sink", field.start, field.line)
sink.flags |= ast.flag_format_sink
sink.type_id = self.standard_type("io", "Writer")
var quoted = try new u8[field.text.length + 2] ---
let spec = try ast.Node.make(ast.Kind.literal, try strings.format(quoted, f"\"{field.text}\""), field.start, field.line)
spec.type_id = types.str_id
let callee = try ast.Node.make(ast.Kind.name, decl.text, field.start, field.line)
callee.resolved = decl
callee.type_id = decl.type_id
let call = try ast.Node.make(ast.Kind.call, "", field.start, field.line)
call.left = callee
call.resolved = decl
call.flags |= ast.flag_format_sink
call.type_id = try self.table.fallible(types.unit_id)
var args: ast.Node*? = none
var tail: ast.Node*? = none
for part in [sink, value, spec]:
let a = try ast.Node.make(ast.Kind.argument, "", field.start, field.line)
a.left = part
a.type_id = part.type_id
ast.append(&args, &tail, a)
call.body = args
field.left = call
field.flags |= ast.flag_format_sink
## Values a formatted string or `print` can show.
func printable(id: u32) -> bool:
let t = self.table.get(id)
if t.kind == types.Kind.atomic:
# a plain read of `@T` is a load (§15.1): the value displays as its `T`
return self.printable(t.elem)
if self.table.is_numeric(id) or id == types.untyped_int_id or id == types.untyped_float_id:
return true
if id == types.bool_id or id == types.char_id or id == types.str_id or id == types.cstr_id or id == types.fmt_id:
return true
if t.kind == types.Kind.pointer or t.kind == types.Kind.enum_:
return true
return false
func literal_type(e: ast.Node*, hint: u32) -> u32!:
let b = e.text.bytes
let first = b[0]
if e.text == "true" or e.text == "false":
return types.bool_id
if e.text == "none":
if self.table.kind(hint) == types.Kind.optional:
return hint
return types.none_id
if first == '\'':
# an ASCII character adapts to a byte (§4.4); any other is a `char`
if hint == types.u8_id and literals.decode_char(e.text) < 128:
return types.u8_id
return types.char_id
if first == '"':
if hint == types.cstr_id:
return types.cstr_id
return types.str_id
if first == 'r' or first == 'b':
if first == 'b':
if self.table.kind(hint) == types.Kind.array and self.table.get(hint).elem == types.u8_id:
return try self.bytes_as_array(e, hint)
return try self.table.span(types.u8_id, true)
return types.str_id
let suffix = literals.literal_suffix(e.text)
if suffix.length > 0:
return try self.suffixed_literal(e, suffix)
if literals.is_float_literal(e.text):
# finite as an `f64` at least; a narrower context checks again
try self.check_float_fits(e, types.f64_id)
return types.untyped_float_id
# a `u64` at most; the context checks again
let value = literals.decode_integer(e.text) catch failure:
return try self.fail(e, "integer literal does not fit")
_ = value
return types.untyped_int_id
## `let magic: u8[4] = b"\x89PNG"`: a byte literal where a byte array is expected is an
## array literal of its bytes, and must have the array's length (§4.4). The node becomes
## that array literal, so every backend builds it as it builds `[0x89, 0x50, ...]`.
func bytes_as_array(e: ast.Node*, hint: u32) -> u32!:
let length = self.table.get(hint).length
let bytes = literals.decode_text(e.text).bytes
if (u64)bytes.length != length:
var said22: u8[256]
return try self.fail(e, try self.with_type(said(said22, f"a byte literal of {bytes.length} bytes cannot initialise `"), hint, "`: the lengths differ"))
if bytes.length == 0:
return try self.fail(e, "an empty byte literal cannot initialise an array: an array literal needs at least one element (§5.4)")
var head: ast.Node*? = none
var tail: ast.Node*? = none
for byte in bytes:
var room = try new u8[4] ---
let spelled = try strings.format(room, f"{byte}")
let element = try ast.Node.make(ast.Kind.literal, spelled, e.start, e.line)
if let last = tail:
last.next = element
else:
head = element
tail = element
e.kind = ast.Kind.array_lit
e.text = ""
e.body = head
return try self.array_type(e, hint)
## `255u8`, `0.5f32`: the suffix names the literal's exact type (§4.2, §4.3), and the
## literal must fit it.
func suffixed_literal(e: ast.Node*, suffix: str) -> u32!:
let id = scalar_id(suffix)
if id == types.none_id or not self.table.is_numeric(id):
return try self.fail(e, "a literal suffix names an integer or float type")
if self.table.is_float(id) != literals.is_float_literal(e.text):
return try self.fail(e, "a float suffix needs a float literal, an integer suffix an integer literal")
if self.table.is_integer(id):
try self.check_fits(e, id, false)
else:
try self.check_float_fits(e, id)
return id
## Whether `name[Name]` names a generic function and a type: an instantiation, not an
## index (the parser reads a single capitalised name as either).
func names_instantiation(e: ast.Node*) -> bool:
let owner = e.left else return false
let arg = e.body else return false
if owner.kind != ast.Kind.name or arg.kind != ast.Kind.name:
return false
let fb = self.lookup(owner.text) else return false
let f = fb.decl else return false
if f.kind != ast.Kind.func_ or generic_params_of(f) == none:
return false
let tb = self.lookup(arg.text) else return false
let t = tb.decl else return false
return is_type_decl(t) or t.kind == ast.Kind.type_alias or t.kind == ast.Kind.generic_param
## A name is a local, a declaration, a module, or a type used as a value.
## A generic function named where a function type is expected, `let f: func(i64) -> bool
## = negate` (§13): the instance whose type that is, its arguments inferred from the
## expected type and recorded on the name as a call records its own.
func generic_function_value(e: ast.Node*, t: u32, hint: u32) -> u32!:
let d = e.resolved else return t
if d.kind != ast.Kind.func_:
return t
let generics = generic_params_of(d) else return t
if let written = e.ty:
# `negate[i64]`, `pick[i32, u64]`: the instance the written arguments name, for a
# function type that does not mention every type parameter too
let n = ast.count(generics)
if ast.count(written.body) != n:
return try self.fail(e, "wrong number of type arguments")
var args = try new u32[n] ---
var j: usize = 0
var cursor = written.body
while let a = cursor:
args[j] = try self.resolve_type(a)
a.type_id = args[j]
j += 1
cursor = a.next
try self.check_constraints(d, args, e)
return try self.substitute(d.type_id, d, args)
var target = hint
if self.table.kind(hint) == types.Kind.optional:
target = self.table.get(hint).elem
if self.table.kind(target) != types.Kind.func_:
return t
let n = ast.count(generics)
var inferred = try new u32[n] ---
for j in 0..<n:
inferred[j] = types.none_id
try self.infer(d.type_id, target, d, inferred)
let holder = try ast.Node.make(ast.Kind.type_, "", e.start, e.line)
var tail: ast.Node*? = none
for j in 0..<n:
if inferred[j] == types.none_id:
return try self.fail(e, "a type argument of this generic function is not in the expected function type")
let a = try ast.Node.make(ast.Kind.type_, "", e.start, e.line)
a.type_id = inferred[j]
ast.append(&holder.body, &tail, a)
try self.check_constraints(d, inferred, e)
e.ty = holder
return try self.substitute(d.type_id, d, inferred)
func name_type(e: ast.Node*) -> u32!:
if e.has(ast.flag_format_sink):
return self.standard_type("io", "Writer")
if e.ty != none and try self.index_reading(e):
return try self.index_type(e)
let scalar = scalar_id(e.text)
if scalar != types.none_id:
e.flags |= ast.flag_type_ref
return scalar
let b = self.lookup(e.text) else return try self.unknown_name(e)
e.resolved = b.decl
note_origin(b)
self.mark_used(e.text)
if let d = b.decl:
if d.kind == ast.Kind.func_:
d.flags |= ast.flag_referenced
if b.from_local:
mark_local(e)
let d = b.decl else return b.type_id
match d.kind:
.func_, .extern_func:
return d.type_id
.struct_, .enum_, .union_, .interface_, .extern_type, .extern_struct, .extern_union, .generic_param:
e.flags |= ast.flag_type_ref
if e.ty != none:
# `Map[str, u32]` before a static member
let t = e.ty else return d.type_id
let named = try ast.Node.make(ast.Kind.type_, e.text, e.start, e.line)
named.body = t.body
return try self.resolve_type(named)
return d.type_id
.type_alias:
e.flags |= ast.flag_type_ref
if d.type_id == types.none_id:
let target = d.ty else return try self.fail(e, "an alias needs a type")
d.type_id = try self.resolve_type(target)
return d.type_id
.module:
return b.type_id
.constant:
if d.type_id == types.none_id:
try self.check_constant(d)
if let f = self.function_alias(d):
e.resolved = f
return d.type_id
_:
return b.type_id
## An unresolved name; inside a lambda, a local of the enclosing function is the usual
## cause, and a lambda captures nothing (§9.6).
func unknown_name(e: ast.Node*) -> u32!:
if e.text == "_":
return try self.fail(e, "`_` is the wildcard; it binds nothing to read (§3.4)")
if self.lambda_floor > 0:
var i = self.lambda_floor
while i > 0:
i -= 1
if self.scope.get(i).name == e.text:
return try self.fail(e, "a lambda captures nothing; pass the value as a parameter (§9.6)")
var said8: u8[256]
return try self.fail(e, said(said8, f"unknown name `{e.text}`"))
func tuple_type(e: ast.Node*, hint: u32) -> u32!:
let n = ast.count(e.body)
# `(u32, u32)?` expected: the members take the tuple's types, `(r.index, 0)` a u32 0
let h = self.table.get(self.inside_optional(hint))
var members = try new u32[n] ---
var i: usize = 0
var cursor = e.body
while let m = cursor:
var mh = types.none_id
if h.kind == types.Kind.tuple and i < h.args.length:
mh = h.args[i]
let mt = try self.check_expr(m, mh)
members[i] = try self.coerce(m, mt, mh) if mh != types.none_id else try self.settle(m, mt)
if members[i] == types.none_id:
return try self.fail(m, "`none` needs a type")
i += 1
cursor = m.next
return try self.table.tuple(members)
func array_type(e: ast.Node*, hint: u32) -> u32!:
let n = ast.count(e.body)
if n == 0:
return try self.fail(e, "an array literal needs at least one element (§5.4)")
let h = self.table.get(self.inside_optional(hint))
var elem = types.none_id
if h.kind == types.Kind.array or h.kind == types.Kind.span:
elem = h.elem
var cursor = e.body
while let m = cursor:
let mt = try self.check_expr(m, elem)
if elem == types.none_id:
elem = try self.settle(m, mt)
if elem == types.none_id:
return try self.fail(m, "`none` needs a type")
_ = try self.coerce(m, mt, elem)
cursor = m.next
return try self.table.array(elem, (u64)n)
## `(a, b) => body`: parameters come from the written types or the expected function type.
## The type an optional or fallible `hint` holds, or `hint`: what a literal inside it takes
## its members' types from.
func inside_optional(hint: u32) -> u32:
var at = hint
while self.table.kind(at) == types.Kind.optional or self.table.kind(at) == types.Kind.fallible:
at = self.table.get(at).elem
return at
## Whether `e`, of type `id`, is the operand of an `x else y` that handles its failure
## itself: a fallible `T!` whose payload is no optional. A `T?!` under a `try` keeps the
## `try` for its failure and the `else` for its absence.
func else_handles(e: ast.Node*, id: u32) -> bool:
return self.else_operand == e and self.table.kind(self.table.get(id).elem) != types.Kind.optional
## `x else y`: the payload of an optional or fallible `x`, or `y` (§11.1).
func else_type(e: ast.Node*, hint: u32) -> u32!:
let l = e.left else return try self.fail(e, "missing operand")
let r = e.right else return try self.fail(e, "`else` needs an alternative")
let saved_operand = self.else_operand
self.else_operand = l
let checked = self.check_expr(l, try self.table.optional(hint) if hint != types.none_id else types.none_id) catch failure:
self.else_operand = saved_operand
error(failure.code, failure.message)
self.else_operand = saved_operand
var lt = self.plain_read(checked)
let t = self.table.get(lt)
# An optional's absence, or a fallible result's failure, takes the alternative: the
# operand's own failure is this `else`'s even under a surrounding `try` (`try f(g()
# else 0)`), while a fallible call inside the operand is still the `try`'s.
if t.kind != types.Kind.optional and t.kind != types.Kind.fallible:
return try self.fail(l, "`else` needs an optional or a fallible result")
if t.kind == types.Kind.fallible and is_local_value(l):
mark_local(e) # the recovered value still views what the operand viewed (§6.6)
let payload = t.elem
if r.kind == ast.Kind.return_ or r.kind == ast.Kind.break_ or r.kind == ast.Kind.continue_:
try self.check_stmt(r)
r.type_id = types.never_id
return payload
let rt = try self.check_expr(r, payload)
_ = try self.coerce(r, rt, payload)
return payload
## `x catch name:` handles the failure of `x`; the handler recovers or leaves.
## `e catch name: handler`: the handled value's type, or the `T?` expected of it when
## the value is a `T`, so that a handler may `recover none` (§11.4).
func catch_type(e: ast.Node*, hint: u32) -> u32!:
let l = e.left else return try self.fail(e, "missing operand")
let body = e.body else return try self.fail(e, "`catch` needs a handler")
let saved_effect = self.expression_effect
let before = self.effect_count
self.expression_effect = true
# a failure in the operand must not leave the state set for the rest of the module
let lt = self.check_expr(l, types.none_id) catch failure:
self.expression_effect = saved_effect
error(failure.code, failure.message)
self.expression_effect = saved_effect
if self.effect_count == before:
return try self.fail(l, "`catch` needs a fallible value")
if is_local_value(l):
mark_local(e) # the handled value still views what it viewed (§6.6)
var result = lt
if hint != types.none_id and self.table.kind(hint) == types.Kind.optional and self.table.get(hint).elem == lt:
result = hint
self.push_scope()
if e.text.length > 0:
try self.bind(e, e.text, types.error_value_id, e, false)
self.set_handled(e.text, self.depth) # its message lives as long as the handler
let saved_in = self.in_catch
let saved_result = self.catch_result
let saved_node = self.catch_node
let saved_depth = self.catch_depth
self.in_catch = true
self.catch_result = result
self.catch_node = e
self.catch_depth = self.depth
self.check_block(body) catch failure:
self.in_catch = saved_in
self.catch_result = saved_result
self.catch_node = saved_node
self.catch_depth = saved_depth
self.pop_scope()
error(failure.code, failure.message)
self.in_catch = saved_in
self.catch_result = saved_result
self.catch_node = saved_node
self.catch_depth = saved_depth
self.pop_scope()
# a handler for a value recovers one or leaves; one for `unit`, or for a value `_ =`
# drops, may fall through (§7.9, §11.4)
if lt != types.unit_id and self.dropped_catch != e and not handler_leaves(body):
try self.fail(e, "a `catch` handler must `recover` a value or leave with `return`, `error`, `trap`, `break`, or `continue`")
return result
## `.case` or `.case(args)` of the enum the context expects.
func case_type(e: ast.Node*, hint: u32) -> u32!:
let h = self.table.get(hint)
var enum_id = hint
if h.kind == types.Kind.optional:
enum_id = h.elem
if self.table.kind(enum_id) != types.Kind.enum_:
return try self.fail(e, "`.case` needs an enum type from the context")
let d = self.table.get(enum_id).decl else return try self.fail(e, "no enum here")
let case_decl = find_member(d, e.text, ast.Kind.enum_case) else return try self.fail(e, "no such case")
e.resolved = case_decl
if case_decl.body != none or e.body != none:
try self.check_payload(e, case_decl, enum_id, d)
return enum_id
## The arguments of a payload case against its declared parameters.
func check_payload(at: ast.Node*, case_decl: ast.Node*, enum_id: u32, d: ast.Node*) -> !:
let instance = self.table.get(enum_id)
var param = case_decl.body
var arg = at.body
while let p = param:
let a = arg else return try self.fail(at, "this case needs more arguments")
let v = a.left else return try self.fail(a, "empty argument")
if a.text.length > 0 and a.text != p.text:
try self.fail(a, "argument name does not match the case")
let want = try self.substitute(p.type_id, d, instance.args)
_ = try self.expect(v, want)
param = p.next
arg = a.next
if arg != none:
try self.fail(at, "too many arguments for this case")