Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.44.0

0.44.0 / src / sema / check / lambdas.lucb

#==============================================================================================
#
#   check/lambdas - Lambdas
#
#   DESCRIPTION:
#       Lambdas hoisted to functions of their own, and functions wrapped to fail (§9.6).
#
#==============================================================================================
extend Checker:
    # mark: Lambdas ============================================================================

    func lambda_type(e: ast.Node*, hint: u32) -> u32!:
        # a lambda where `(func(i64) -> i64)?` is expected takes the function's shape (§9.6)
        var target = hint
        if self.table.kind(hint) == types.Kind.optional and self.table.kind(self.table.get(hint).elem) == types.Kind.func_:
            target = self.table.get(hint).elem
        let h = self.table.get(target)
        let n = ast.count(e.right)
        var params = try types.no_args()
        if n > 0:
            params = try new u32[n] ---
        let saved_floor = self.lambda_floor
        let saved_self = self.self_type
        self.lambda_floor = self.scope.count
        self.self_type = types.none_id
        self.push_scope()
        var i: usize = 0
        var cursor = e.right
        while let p = cursor:
            var pt = types.none_id
            if let t = p.ty:
                pt = try self.resolve_type(t)
            elif h.kind == types.Kind.func_ and i < h.args.length:
                pt = h.args[i]
            else:
                return try self.fail(p, "this parameter needs a type")
            p.type_id = pt
            params[i] = pt
            try self.bind(p, p.text, pt, p, false)
            i += 1
            cursor = p.next
        let body = e.body else return try self.fail(e, "a lambda needs a body")
        var want = types.none_id
        if h.kind == types.Kind.func_:
            want = h.elem
        let saved_result = self.result_type
        let saved_fallible = self.fallible
        self.result_type = want
        let saved_effect = self.expression_effect
        let saved_count = self.effect_count
        # a lambda's body is a function of its own, even written in a deferred block
        let saved_defer = self.in_defer
        self.in_defer = false
        # nor the test it is written in: an `assert` in it traps (§16.5)
        let saved_test = self.in_test
        self.in_test = false
        self.expression_effect = false
        self.fallible = self.table.kind(want) == types.Kind.fallible
        let bt = try self.check_expr(body, want)
        self.in_defer = saved_defer
        self.in_test = saved_test
        var result = concrete(bt)
        if want == types.none_id:
            result = try self.settle(body, bt)
        else:
            result = try self.coerce(body, bt, want)
            result = want
        self.result_type = saved_result
        self.fallible = saved_fallible
        self.pop_scope()
        self.expression_effect = saved_effect
        self.effect_count = saved_count
        self.lambda_floor = saved_floor
        self.self_type = saved_self
        let fn_type = try self.table.function(params, result, false)
        e.resolved = try self.hoist_lambda(e, body, fn_type)
        return fn_type

    ## A lambda is a hidden module function (§9.6): its parameters, a body of one `return`,
    ## and no captures. The backends emit it as any other function of the module.
    func hoist_lambda(e: ast.Node*, body: ast.Node*, fn_type: u32) -> ast.Node*!:
        let fn = try ast.Node.make(ast.Kind.func_, try self.lambda_name(), e.start, e.line)
        fn.flags |= ast.flag_lambda | ast.flag_referenced
        fn.right = e.right
        fn.type_id = fn_type
        let ret = try ast.Node.make(ast.Kind.return_, "", body.start, body.line)
        ret.left = body
        ret.type_id = types.never_id
        let block = try ast.Node.make(ast.Kind.block, "", body.start, body.line)
        block.body = ret
        fn.body = block
        self.hoist(fn)
        return fn

    ## A synthesised function joins the module's declarations, after the last one.
    func hoist(fn: ast.Node*):
        let tree = self.modules.get(self.current).tree
        var cursor = tree.body
        var last: ast.Node*? = none
        while let d = cursor:
            last = d
            cursor = d.next
        if let l = last:
            l.next = fn
        else:
            tree.body = fn

    ## A named function where a fallible function type is wanted (§9.4): the name comes to
    ## mean a hoisted function of the wanted type that calls the named one and answers its
    ## result as success. Its parameters have the wanted types, so a function reading
    ## through `const T*` is wrapped as one taking `T*` too; a method's receiver is the
    ## first, and the method is called on it. Only a declaration can be wrapped this way; a
    ## function value held in a variable has no name to wrap.
    func wrap_as_fallible(e: ast.Node*, want: u32) -> !:
        if not names_function(e):
            return try self.fail(e, "only a named function converts to a fallible function type")
        let f = e.resolved else return
        let wanted = self.table.get(want).args
        var method = false
        if let owner = e.left:
            method = e.kind == ast.Kind.member and owner.has(ast.flag_type_ref) and not f.has(ast.flag_static)
        let fn = try ast.Node.make(ast.Kind.func_, try self.hidden_name("__thunk"), e.start, e.line)
        fn.flags |= ast.flag_lambda | ast.flag_referenced | ast.flag_fallible
        fn.type_id = want
        var params: ast.Node*? = none
        var params_tail: ast.Node*? = none
        var args: ast.Node*? = none
        var args_tail: ast.Node*? = none
        var receiver: ast.Node*? = none
        var i: usize = 0
        var cursor = f.right
        while i < wanted.length:
            var name: str = "__receiver"
            if not method or i > 0:
                let p = cursor else return try self.fail(e, "the function's parameters differ from the wanted type's")
                name = p.text
                cursor = p.next
            let np = try ast.Node.make(ast.Kind.param, name, e.start, e.line)
            np.type_id = wanted[i]
            ast.append(&params, &params_tail, np)
            let use = try ast.Node.make(ast.Kind.name, name, e.start, e.line)
            use.type_id = wanted[i]
            use.resolved = np
            if method and i == 0:
                receiver = use
            else:
                let a = try ast.Node.make(ast.Kind.argument, "", e.start, e.line)
                a.left = use
                a.type_id = wanted[i]
                ast.append(&args, &args_tail, a)
            i += 1
        fn.right = params
        # the method on the receiver, `__receiver.name(...)`; else the name as written
        let callee = try ast.Node.make(e.kind, f.text, e.start, e.line)
        callee.left = receiver if method else e.left
        callee.ty = e.ty
        callee.type_id = f.type_id
        callee.resolved = f
        let call = try ast.Node.make(ast.Kind.call, "", e.start, e.line)
        call.left = callee
        call.body = args
        call.resolved = f
        call.type_id = self.table.get(f.type_id).elem
        let ret = try ast.Node.make(ast.Kind.return_, "", e.start, e.line)
        ret.left = call
        ret.type_id = types.never_id
        let block = try ast.Node.make(ast.Kind.block, "", e.start, e.line)
        block.body = ret
        fn.body = block
        self.hoist(fn)
        # the expression now names the hoisted function, unqualified
        e.kind = ast.Kind.name
        e.left = none
        e.ty = none
        e.resolved = fn
        e.text = fn.text
        e.type_id = want

    ## `__lambda1`, `__lambda2`, ...: names no source can spell.
    func lambda_name() -> str!:
        return try self.hidden_name("__lambda")

    ## `prefix` followed by a fresh number: a name no source can spell.
    func hidden_name(prefix: str) -> str!:
        self.lambda_count += 1
        var digits: u8[12]
        var n = self.lambda_count
        var k: usize = 0
        while true:
            digits[k] = (u8)48 + (u8)(n % 10)
            k += 1
            n = n // 10
            if n == 0:
                break
        var out = try new u8[prefix.length + k] ---
        memory.copy(out, prefix.bytes, prefix.length)
        var j: usize = 0
        while j < k:
            out[prefix.length + j] = digits[k - 1 - j]
            j += 1
        return (str)out[..<prefix.length + k]