Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.45.0

0.45.0 / src / back / ir / lower / expressions.lucb

#==============================================================================================
#
#   lower/expressions - Expressions
#
#   DESCRIPTION:
#       `value`, the one place a conversion the checker allowed is lowered, and literals
#       and names.
#
#==============================================================================================
extend Lowerer:
    # mark: Expressions ========================================================================

    ## `e` as a value of type `want`, converting where the checker allowed it.
    func value(e: ast.Node*, want: u32) -> LowerValue!:
        let have = try self.ty(e)
        if want == types.none_id or have == want or have == types.never_id or have == types.error_id:
            return try self.expr(e)
        let w = self.c.table.get(want)
        let h = self.c.table.get(have)
        if e.kind == ast.Kind.literal and e.text == "none":
            return try self.none_of(want)
        if w.kind == types.Kind.interface_ and h.kind == types.Kind.pointer:
            let p = try self.expr(e)
            return try self.iface_view(p.ref, h.elem, want)
        if w.kind == types.Kind.interface_ and h.kind == types.Kind.interface_:
            return try self.expr(e)
        if w.kind == types.Kind.optional:
            if h.kind == types.Kind.optional:
                return try self.expr(e)
            if self.is_nullable_ptr(want):
                # the same word as the payload, converted as the niche type asks (§5.3)
                let p = try self.value(e, w.elem)
                return LowerValue(ref = p.ref, type_id = want, in_memory = false)
            if self.is_nullable_view(want):
                # the view itself: its data word is never null when present (§14.3)
                let view = try self.value(e, w.elem)
                return LowerValue(ref = view.ref, type_id = want, in_memory = true)
            let inner = try self.value(e, w.elem)
            let slot = try self.new_slot(want)
            let a = try self.slot_address(slot)
            try self.store_to(a, inner)
            try self.f.store(ir.Op.storeb, ir.const_ref(1), try self.offset_address(a, self.c.table.size_of(w.elem)))
            return LowerValue(ref = a, type_id = want, in_memory = true)
        if w.kind == types.Kind.span:
            if h.kind == types.Kind.array:
                if let owner = self.literal_owner:
                    if e.kind == ast.Kind.array_lit:
                        return try self.static_literal(e, want, owner)
                let arr = try self.expr(e)
                return try self.span_of(arr.ref, ir.const_ref((i64)h.length), want)
            if have == types.str_id or have == types.fmt_id:
                let text = try self.expr(e)
                return LowerValue(ref = text.ref, type_id = want, in_memory = true)
            return try self.expr(e)
        if (want == types.cstr_id or (w.kind == types.Kind.optional and w.elem == types.cstr_id)) and have == types.str_id:
            let text = try self.expr(e)
            let data = try self.f.load(ir.Op.loadl, ir.Class.l, text.ref)
            return LowerValue(ref = data, type_id = want, in_memory = false)
        if want == types.fmt_id and have == types.str_id:
            return try self.expr(e)
        if w.kind == types.Kind.atomic:
            return try self.value(e, w.elem)
        if h.kind == types.Kind.atomic:
            let v = try self.expr(e)
            return LowerValue(ref = v.ref, type_id = want, in_memory = v.in_memory)
        if w.kind == types.Kind.func_ and h.kind == types.Kind.func_:
            let v = try self.expr(e)
            return LowerValue(ref = v.ref, type_id = want, in_memory = false)
        if self.is_int(want) and (self.is_int(have) or have == types.untyped_int_id):
            let v = try self.expr(e)
            return LowerValue(ref = try self.widen(v.ref, have, want), type_id = want, in_memory = false)
        if self.is_float(want) and (have == types.untyped_int_id or have == types.untyped_float_id or self.is_float(have)):
            let v = try self.expr(e)
            if have == types.untyped_int_id:
                return LowerValue(ref = try self.f.unary(ir.Op.sltof, self.class_of(want), v.ref), type_id = want, in_memory = false)
            return LowerValue(ref = try self.convert_float(v.ref, have, want), type_id = want, in_memory = false)
        let v = try self.expr(e)
        return LowerValue(ref = v.ref, type_id = want, in_memory = v.in_memory)

    ## A float temporary of `have` as the float `want`: itself when the widths agree, else
    ## extended or rounded once, directly between the two widths. An untyped literal is a double.
    func convert_float(r: ir.Ref, have: u32, want: u32) -> ir.Ref!:
        let source = self.c.table.bits(have)
        let target = self.c.table.bits(want)
        if source == target:
            return r
        if source < target:
            return try self.f.unary(ir.Op.exth if source == 16 else ir.Op.exts, self.class_of(want), r)
        return try self.f.unary(ir.Op.truncs if source == 32 else ir.Op.truncd, self.class_of(want), r)

    ## An integer temporary widened from `have` to `want` (§7.5 implicit widening).
    func widen(r: ir.Ref, have: u32, want: u32) -> ir.Ref!:
        if have == types.untyped_int_id or have == types.none_id:
            return r
        let from_size = self.scalar_size(have)
        let to_size = self.scalar_size(want)
        if to_size <= 4 and from_size <= 4:
            return r
        if to_size > 4 and from_size <= 4:
            return try self.f.unary(ir.Op.extsw if self.signed_of(have) else ir.Op.extuw, ir.Class.l, r)
        return r

    ## A tagged optional without a value, or a null pointer.
    func none_of(t: u32) -> LowerValue!:
        if self.is_scalar(t):
            return LowerValue(ref = ir.const_ref(0), type_id = t, in_memory = false)
        let slot = try self.new_slot(t)
        let a = try self.slot_address(slot)
        try self.f.zero_bytes(a, self.size(t))
        return LowerValue(ref = a, type_id = t, in_memory = true)

    ## `{ pointer, &vtable }` as a two-word view in memory.
    func iface_view(pointer: ir.Ref, record: u32, iface: u32) -> LowerValue!:
        let i = self.decl_of(iface) else return try self.fail(self.entry, "no interface")
        try self.note_vtable(record, iface)
        let name = try self.vtable_name(record, i)
        let slot = try self.f.slot(16, 8)
        let a = try self.slot_address(slot)
        try self.f.store(ir.Op.storel, pointer, a)
        let table = try self.f.address_of(ir.global_ref(name))
        try self.f.store(ir.Op.storel, table, try self.offset_address(a, 8))
        return LowerValue(ref = a, type_id = iface, in_memory = true)

    ## The `Writer` view of an `io.FormatSink` over the buffer a formatted string is built in.
    func format_sink_view() -> LowerValue!:
        let sink_type = self.c.standard_type("io", "FormatSink")
        let slot = try self.new_slot(sink_type)
        let a = try self.slot_address(slot)
        try self.f.store(ir.Op.storel, self.format_sink, a)
        return try self.iface_view(a, sink_type, self.c.standard_type("io", "Writer"))

    ## `{ data, length }` in memory.
    func span_of(data: ir.Ref, length: ir.Ref, t: u32) -> LowerValue!:
        let slot = try self.f.slot(16, 8)
        let a = try self.slot_address(slot)
        try self.f.store(ir.Op.storel, data, a)
        try self.f.store(ir.Op.storel, length, try self.offset_address(a, 8))
        return LowerValue(ref = a, type_id = t, in_memory = true)

    func expr(e: ast.Node*) -> LowerValue!:
        match e.kind:
            .literal:
                return try self.literal(e)
            .name:
                return try self.name(e)
            .self_:
                let p = try self.f.load(ir.Op.loadl, ir.Class.l, try self.slot_address(self.self_slot))
                let st = self.elem(try self.ty(e))
                _ = st
                return try self.load_from(p, try self.ty(e))
            .unit_:
                return LowerValue(ref = ir.const_ref(0), type_id = types.unit_id, in_memory = false)
            .group:
                let inner = e.left else return try self.fail(e, "empty group")
                return try self.expr(inner)
            .unary:
                return try self.unary(e)
            .propagate:
                return try self.try_expr(e)
            .binary:
                return try self.binary(e)
            .conditional:
                return try self.conditional(e)
            .call:
                return try self.call(e)
            .member:
                return try self.member(e)
            .index:
                let t = try self.ty(e)
                return try self.load_from(try self.index_address(e), t)
            .slice:
                return try self.slice(e)
            .tuple:
                return try self.tuple(e)
            .array_lit:
                return try self.array_literal(e)
            .lambda:
                let d = e.resolved else return try self.fail(e, "a lambda without its function")
                return try self.func_value(e, d)
            .else_:
                return try self.else_expr(e)
            .catch_:
                return try self.catch_expr(e)
            .cast:
                let inner = e.left else return try self.fail(e, "empty cast")
                return try self.conversion(inner, try self.ty(e), false)
            .case_value:
                return try self.enum_value(e)
            .formatted:
                return try self.formatted_value(e)
            .new_:
                return try self.new_expr(e)
            .new_unwritten:
                return try self.unwritten_expr(e)
            .span_make:
                let first = e.body else return try self.fail(e, "empty span")
                let p = first.left else return try self.fail(e, "empty span")
                let second = first.next else return try self.fail(e, "empty span")
                let count = second.left else return try self.fail(e, "empty span")
                let pv = try self.expr(p)
                let cv = try self.value(count, types.usize_id)
                return try self.span_of(pv.ref, cv.ref, try self.ty(e))
            .match_expr:
                return try self.match_expr(e)
            .return_:
                try self.return_stmt(e)
                return LowerValue(ref = ir.const_ref(0), type_id = types.never_id, in_memory = false)
            .break_, .continue_:
                try self.jump(e)
                return LowerValue(ref = ir.const_ref(0), type_id = types.never_id, in_memory = false)
            _:
                return try self.fail(e, "native_unsupported expression in the native backend")

    # -- literals and names ---------------------------------------------------------------

    func literal(e: ast.Node*) -> LowerValue!:
        let t = try self.ty(e)
        if e.text == "true":
            return LowerValue(ref = ir.const_ref(1), type_id = types.bool_id, in_memory = false)
        if e.text == "false":
            return LowerValue(ref = ir.const_ref(0), type_id = types.bool_id, in_memory = false)
        if e.text == "none":
            return try self.none_of(t)
        let b = e.text.bytes
        if b[0] == '\'':
            return LowerValue(ref = ir.const_ref((i64)literals.decode_char(e.text)), type_id = t, in_memory = false)
        if b[0] == '"' or b[0] == 'r' or b[0] == 'b':
            let text = literals.decode_text(e.text)
            let index = try self.program_unit.text(text)
            let data = try self.f.address_of(ir.text_ref(index))
            if t == types.cstr_id or (self.c.table.kind(t) == types.Kind.optional and self.c.table.get(t).elem == types.cstr_id):
                return LowerValue(ref = data, type_id = t, in_memory = false)
            let span_type = try self.c.table.span(types.u8_id, true) if b[0] == 'b' else types.str_id
            return try self.span_of(data, ir.const_ref((i64)text.length), span_type)
        if literals.is_float_literal(e.text):
            let digits = literals.literal_body(e.text)
            let bits = float_bits(digits)
            if t == types.f16_id:
                let h = try self.f.unary(ir.Op.cast, ir.Class.h, ir.const_ref((i64)float16_bits(digits)))
                return LowerValue(ref = h, type_id = t, in_memory = false)
            if t == types.f32_id:
                let w = try self.f.unary(ir.Op.cast, ir.Class.s, ir.const_ref((i64)float32_bits(digits)))
                return LowerValue(ref = w, type_id = t, in_memory = false)
            let d = try self.f.unary(ir.Op.cast, ir.Class.d, ir.const_ref((i64)bits))
            return LowerValue(ref = d, type_id = types.f64_id if t == types.untyped_float_id else t, in_memory = false)
        let v = try literals.decode_integer(e.text)
        let it = types.i64_id if t == types.untyped_int_id else t
        return LowerValue(ref = ir.const_ref((i64)v), type_id = it, in_memory = false)

    func name(e: ast.Node*) -> LowerValue!:
        if e.has(ast.flag_format_sink):
            return try self.format_sink_view()
        let t = try self.ty(e)
        if let d = e.resolved:
            if d.kind == ast.Kind.enum_case:
                return try self.enum_value(e)
            if d.kind == ast.Kind.func_ or d.kind == ast.Kind.extern_func:
                return try self.func_value(e, d)
            if d.kind == ast.Kind.constant:
                if let v = try self.folded_constant(e, t):
                    return v
            if d.kind == ast.Kind.global or d.kind == ast.Kind.constant or d.kind == ast.Kind.extern_var:
                return try self.load_from(try self.global_address(d), t)
            if let slot = self.find_local(d):
                return try self.load_from(try self.slot_address(slot), t)
        return try self.fail(e, "a name without a place")

    ## A constant read as the literal it denotes, `platform.windows` or `os.name`: a bool,
    ## an integer or a text, so no initialiser depends on another library member's having
    ## run first (§17.6); none for the rest.
    func folded_constant(e: ast.Node*, t: u32) -> LowerValue?!:
        if self.is_int(t):
            if let v = self.folded_integer(e, t):
                return LowerValue(ref = ir.const_ref(v), type_id = t, in_memory = false)
        let leaf = self.c.constant_leaf(e) else return none
        let b = leaf.text.bytes
        if t == types.bool_id:
            if leaf.text != "true" and leaf.text != "false":
                return none
            return LowerValue(ref = ir.const_ref(1 if leaf.text == "true" else 0), type_id = t, in_memory = false)
        if self.is_int(t):
            if b.length == 0 or b[0] < '0' or b[0] > '9':
                return none
            let v = try literals.decode_integer(leaf.text)
            return LowerValue(ref = ir.const_ref((i64)v), type_id = t, in_memory = false)
        if t == types.str_id:
            if b.length == 0 or b[0] != '"':
                return none
            let text = literals.decode_text(leaf.text)
            let index = try self.program_unit.text(text)
            let data = try self.f.address_of(ir.text_ref(index))
            return try self.span_of(data, ir.const_ref((i64)text.length), types.str_id)
        return none

    ## An integer constant whose initialiser is arithmetic on constants, `3 << 4`, as the value
    ## of its type (§6.4), when the checker folds it exactly (`check.exact_integer`).
    func folded_integer(e: ast.Node*, t: u32) -> i64?:
        let d = e.resolved else return none
        if d.kind != ast.Kind.constant:
            return none
        let init = d.left else return none
        return self.c.exact_integer(init, self.scalar_size(t) * 8, self.is_signed(t))

    func global_address(d: ast.Node*) -> ir.Ref!:
        let name = try self.global_name(d)
        if d.has(ast.flag_thread_local):
            let t = try self.temp(ir.Class.l)
            try self.f.emit(ir.Op.addr_tls, ir.Class.l, t.index, ir.global_ref(name), ir.none_ref(), 0)
            return t
        if d.kind == ast.Kind.extern_var:
            return try self.f.address_of(ir.import_ref(name))
        return try self.f.address_of(ir.global_ref(name))

    func func_value(e: ast.Node*, d: ast.Node*) -> LowerValue!:
        let t = try self.ty(e)
        if d.kind == ast.Kind.extern_func:
            return LowerValue(ref = try self.f.address_of(ir.function_ref(names.c_symbol(d))), type_id = t, in_memory = false)
        var args = try types.no_args()
        if let holder = e.ty:
            args = try self.type_args(holder)
        _ = try self.add_func(d, args, none, try types.no_args())
        let name = try self.function_name(d, args, none, try types.no_args())
        return LowerValue(ref = try self.f.address_of(ir.function_ref(name)), type_id = t, in_memory = false)

    ## An enum case: the integer, or the tagged record with its payload.
    func enum_value(e: ast.Node*) -> LowerValue!:
        let c = e.resolved else return try self.fail(e, "no case")
        let t = try self.ty(e)
        let d = self.decl_of(t) else return try self.fail(e, "no enum")
        if self.c.is_backed_enum(t):
            return LowerValue(ref = ir.const_ref((i64)types.case_value(d, c)), type_id = t, in_memory = false)
        let slot = try self.new_slot(t)
        let a = try self.slot_address(slot)
        try self.f.zero_bytes(a, self.size(t))
        try self.f.store(ir.Op.storew, ir.const_ref((i64)instances.case_tag(d, c)), a)
        if e.body != none and c.body != none:
            let base = self.payload_offset(t)
            var offset: u64 = 0
            var param = c.body
            var arg = e.body
            let instance = self.c.table.get(t)
            while let p = param:
                let a_node = arg else break
                let v = a_node.left else break
                let pt = try self.map(try self.c.substitute(p.type_id, d, instance.args))
                offset = lower_round_up(offset, self.c.table.align_of(pt))
                let pv = try self.value(v, pt)
                try self.store_to(try self.offset_address(a, base + offset), pv)
                offset += self.c.table.size_of(pt)
                param = p.next
                arg = a_node.next
        return LowerValue(ref = a, type_id = t, in_memory = true)

    ## Where a payload enum's union starts: after the tag, at the widest payload alignment.
    func payload_offset(t: u32) -> u64:
        let d = self.decl_of(t) else return 4
        var widest: u64 = 4
        var cursor = d.body
        while let c = cursor:
            if c.kind == ast.Kind.enum_case:
                var p = c.body
                while let q = p:
                    let a = self.c.table.align_of(q.type_id)
                    widest = a if a > widest else widest
                    p = q.next
            cursor = c.next
        return lower_round_up(4, widest)