Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.44.0

0.44.0 / src / sema / check / intrinsics.lucb

#==============================================================================================
#
#   check/intrinsics - What the compiler answers where it is written
#
#   DESCRIPTION:
#       The core functions (§3.5), `print`, `assert`, `trap`, and `error`; the standard
#       functions answered at the call, `strings.format` (§5.5) and `memory.size_of`,
#       `align_of`, and `offset_of` (§5.11); and `value.hash()` (§7.4). A call of one has
#       its callee rewritten to the bare name the backends know it by.
#
#==============================================================================================
extend Checker:
    # mark: Intrinsics ===========================================================================

    ## The standard function `callee` names when the compiler answers it where it is written:
    ## `strings.format`, `memory.size_of`, `memory.align_of`, or `memory.offset_of`, by
    ## their module or imported by name; empty for anything else.
    func standard_intrinsic(callee: ast.Node*) -> str:
        if callee.kind == ast.Kind.member:
            let owner = callee.left else return ""
            if owner.kind != ast.Kind.name:
                return ""
            let b = self.lookup(owner.text) else return ""
            let tree = b.decl else return ""
            if tree.kind != ast.Kind.module:
                return ""
            let named = intrinsic_of(self.standard_module_name(tree), callee.text)
            if named.length > 0:
                note_origin(b)
            return named
        if callee.kind != ast.Kind.name:
            return ""
        # inside `memory` itself its own measures are named bare
        let b = self.lookup(callee.text) else return intrinsic_of(self.current_standard_module(), callee.text)
        let item = b.decl else return ""
        # `from memory import size_of` binds the import's own item, `from strings import
        # format` the declaration
        if item.kind == ast.Kind.name:
            let tree = item.resolved else return ""
            note_origin(b)
            return intrinsic_of(self.standard_module_name(tree), item.text)
        if item.kind == ast.Kind.func_ and item.text == "format" and self.standard_decl("strings", "format") == item:
            note_origin(b)
            return "format"
        return ""

    ## The name of the standard module being checked; empty for a program's module.
    func current_standard_module() -> str:
        let m = self.modules.get(self.current)
        return m.name if m.is_prelude else ""

    ## The name of the standard module whose tree is `tree`; empty for any other module.
    func standard_module_name(tree: ast.Node*) -> str:
        for m in self.modules.span():
            if m.tree == tree:
                return m.name if m.is_prelude else ""
        return ""

    ## The declaration `name` of standard module `module`; none when absent.
    func standard_decl(module: str, name: str) -> ast.Node*?:
        let index = self.find_module(module) else return none
        return find_decl(self.modules.get(index).tree, name)

    ## A call of a core function, or of a standard one the compiler answers, typed here.
    ## The callee becomes the bare name the backends know the call by (`size_of`, `format`).
    func intrinsic_type(e: ast.Node*, name: str) -> u32!:
        let callee = e.left else return try self.fail(e, "missing callee")
        callee.kind = ast.Kind.name
        callee.text = name
        callee.left = none
        callee.resolved = none
        callee.flags |= ast.flag_builtin
        if name == "print":
            let arg = try self.single_argument(e)
            let got = try self.check_expr(arg, types.none_id)
            if got != types.str_id and got != types.fmt_id:
                return try self.fail(arg, "`print` takes text or a formatted string")
            return types.unit_id
        if name == "format":
            return try self.format_type(e)
        if name == "assert":
            let first = e.body else return try self.fail(e, "`assert` needs a condition")
            let cv = first.left else return try self.fail(e, "empty argument")
            _ = try self.expect(cv, types.bool_id)
            if let second = first.next:
                let mv = second.left else return try self.fail(e, "empty argument")
                _ = try self.expect(mv, types.str_id)
            # in a test's own body a false condition fails the test (§16.5); in a deferred
            # block, which cannot fail, it traps
            if self.in_test and not self.in_defer:
                e.flags |= ast.flag_test_assert
            return types.unit_id
        if name == "trap":
            if let first = e.body:
                let mv = first.left else return try self.fail(e, "empty argument")
                let got = try self.check_expr(mv, types.none_id)
                if got != types.str_id and got != types.fmt_id:
                    return try self.fail(mv, "`trap` takes text")
            return types.never_id
        if name == "error":
            return try self.error_type(e)
        if name == "hash":
            return try self.hash_type(e)
        if name == "size_of" or name == "align_of":
            let arg = try self.single_argument(e)
            let id = try self.type_of_argument(arg)
            if name == "align_of" and not arg.has(ast.flag_type_ref):
                return try self.fail(arg, "`memory.align_of` takes a type")
            e.resolved = arg
            _ = id
            return types.usize_id
        if name == "offset_of":
            return try self.offset_of_type(e)
        return try self.fail(e, "unknown core function")

    ## `value.hash()` (§7.4): the hash of a value whose type hashes by its fields; the call
    ## becomes `hash(value)` for the backends.
    func hash_type(e: ast.Node*) -> u32!:
        let arg = try self.single_argument(e)
        let got = try self.check_expr(arg, types.none_id)
        if self.table.kind(got) == types.Kind.param:
            if not self.has_written_constraint(got, self.standard_type("luce", "Hashable")):
                return try self.fail(arg, "a type parameter hashes only under `Hashable`")
        elif not self.comparable(got, hashing = true):
            return try self.fail(arg, "this value is not hashable")
        _ = try self.coerce(arg, got, concrete(got))
        return types.u64_id

    ## `value.hash()` where `value` hashes by its fields and its type declares no `hash`
    ## of its own: true, with the call rewritten to `hash(value)` and typed (§7.4).
    func derived_hash_call(e: ast.Node*, callee: ast.Node*, receiver: ast.Node*, receiver_type: u32) -> bool!:
        if callee.text != "hash" or e.body != none or e.ty != none:
            return false
        # a pointer hashes its address; a pointee's own `hash` method is called through it
        let t = self.table.get(receiver_type)
        let record = self.table.get(t.elem) if t.kind == types.Kind.pointer else t
        if record.kind == types.Kind.struct_ or record.kind == types.Kind.enum_ or record.kind == types.Kind.union_:
            if let d = record.decl:
                if find_member(d, "hash", ast.Kind.func_) != none:
                    return false
        if t.kind == types.Kind.module or t.kind == types.Kind.interface_:
            return false
        if t.kind != types.Kind.param and not self.comparable(receiver_type, hashing = true):
            return try self.fail(receiver, "this value is not hashable (§7.4)")
        let argument = try ast.Node.make(ast.Kind.argument, "", receiver.start, receiver.line)
        argument.left = receiver
        e.body = argument
        return true

    ## `strings.format(buffer, text)`: text viewing the bytes it was formatted into, or a
    ## failure when they are too few.
    func format_type(e: ast.Node*) -> u32!:
        let first = e.body else return try self.fail(e, "`strings.format(buffer, text)` takes two arguments")
        let bv = first.left else return try self.fail(e, "empty argument")
        _ = try self.expect(bv, try self.table.span(types.u8_id, false))
        let second = first.next else return try self.fail(e, "`strings.format(buffer, text)` takes two arguments")
        let tv = second.left else return try self.fail(e, "empty argument")
        let got = try self.check_expr(tv, types.none_id)
        if got != types.str_id and got != types.fmt_id:
            return try self.fail(tv, "`strings.format` takes text or a formatted string")
        # the returned text views the buffer: a local array, or a span derived from one, makes
        # the result local (§6.6); a span variable or parameter views memory elsewhere
        if is_local_value(bv) or (self.table.kind(bv.type_id) == types.Kind.array and self.place_is_local(bv)):
            mark_local(e)
        return try self.table.fallible(types.str_id)

    ## `error(code, message)`: leaves a fallible function or a handler with that failure,
    ## raised here; the message is copied as it is raised (§11.3), so it may view a local.
    ## `error(failure)` passes a caught failure on whole, where it was raised included.
    func error_type(e: ast.Node*) -> u32!:
        if self.in_defer and not self.fallible and not self.expression_effect:
            return try self.fail(e, "a failure cannot escape a deferred block (§8.8)")
        if not self.fallible and not self.expression_effect:
            return try self.fail(e, "`error` is only valid in a fallible function, in a handler or not")
        let first = e.body else return try self.fail(e, "`error` takes a code and a message, or a caught failure to pass on")
        let cv = first.left else return try self.fail(e, "empty argument")
        if first.next == none:
            if try self.check_expr(cv, types.none_id) != types.error_value_id:
                return try self.fail(cv, "`error` takes a code and a message, or a caught failure to pass on")
            return types.never_id
        _ = try self.expect(cv, types.error_code_id)
        let second = first.next else return try self.fail(e, "`error` takes a code and a message, or a caught failure to pass on")
        let mv = second.left else return try self.fail(e, "empty argument")
        _ = try self.expect(mv, types.str_id)
        return types.never_id

    ## `memory.offset_of(T, field)`: a struct's field, resolved on the name, at a `usize`
    ## offset.
    func offset_of_type(e: ast.Node*) -> u32!:
        let first = e.body else return try self.fail(e, "`memory.offset_of(T, field)` takes two arguments")
        let tv = first.left else return try self.fail(e, "empty argument")
        let id = try self.type_of_argument(tv)
        let second = first.next else return try self.fail(e, "`memory.offset_of(T, field)` takes two arguments")
        let fv = second.left else return try self.fail(e, "empty argument")
        if fv.kind != ast.Kind.name:
            return try self.fail(fv, "`memory.offset_of` names a field")
        let d = self.table.get(id).decl else return try self.fail(tv, "`memory.offset_of` takes a struct")
        var said20: u8[256]
        let f = find_member(d, fv.text, ast.Kind.field) else return try self.fail(fv, said(said20, f"`{d.text}` has no field `{fv.text}`"))
        fv.resolved = f
        return types.usize_id

## The intrinsic standard function `name` of standard module `module` is, as the backends
## know it; empty when it is none.
func intrinsic_of(module: str, name: str) -> str:
    if module == "memory" and (name == "size_of" or name == "align_of" or name == "offset_of"):
        return name
    if module == "strings" and name == "format":
        return name
    return ""