Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-base

Source of release 0.46.0

0.46.0 / src / sema / check / allocation.lucb

#==============================================================================================
#
#   check/allocation - Allocation
#
#   DESCRIPTION:
#       `new`, `new T[count] ---`, and the allocator a call names (§12).
#
#==============================================================================================
extend Checker:
    # mark: Allocation =========================================================================

    ## `new T(...)`, `new T`, `new T[n]`, `new Kind.case(...)`, with `in allocator`.
    func new_type(e: ast.Node*) -> u32!:
        let t = e.ty else return try self.fail(e, "`new` needs a type")
        if let alloc_in = e.right:
            try self.check_allocator(alloc_in)
        if t.has(ast.flag_array):
            let inner = t.left else return try self.fail(t, "an array needs an element type")
            let count = t.right else return try self.fail(t, "`new T[n]` needs a count")
            let elem = try self.resolve_type(inner)
            try self.storable(elem, inner)
            if not self.table.zeroable(elem):
                return try self.fail(t, "`new T[count]` zeroes its elements, so `T` must be zeroable; `new T[count] ---` leaves them unwritten")
            _ = try self.expect(count, types.usize_id)
            t.type_id = try self.table.span(elem, false)
            return try self.table.fallible(t.type_id)
        let id = try self.resolve_type(t)
        try self.storable(id, t)
        let pointer = try self.table.pointer(id, false, false)
        if e.text == "()":
            _ = try self.construct(e, id, e.body)
        elif let body = e.body:
            if body.kind == ast.Kind.case_value:
                body.type_id = try self.case_type(body, id)
            else:
                _ = try self.construct(e, id, e.body)
        elif not self.table.zeroable(id):
            return try self.fail(e, "`new T` needs a zeroable type; give it arguments")
        return try self.table.fallible(pointer)

    ## `new T[count] ---`: `count` elements of any `T`, left unwritten (§12.2).
    func unwritten_type(e: ast.Node*) -> u32!:
        if let alloc_in = e.right:
            try self.check_allocator(alloc_in)
        let t = e.ty else return try self.fail(e, "`new` needs a type")
        if not t.has(ast.flag_array):
            return try self.fail(t, "`---` leaves the elements of `new T[count]` unwritten; one value is `new T`")
        let inner = t.left else return try self.fail(t, "an array needs an element type")
        let count = t.right else return try self.fail(t, "`new T[count] ---` needs a count")
        let elem = try self.resolve_type(inner)
        try self.storable(elem, inner)
        _ = try self.expect(count, types.usize_id)
        t.type_id = try self.table.span(elem, false)
        return try self.table.fallible(t.type_id)

    ## `in x` and `with x:` name an allocator: a `var` implementing `Allocator`,
    ## a pointer to one, or an `Allocator` view.
    func check_allocator(e: ast.Node*) -> !:
        let got = try self.check_expr(e, types.none_id)
        let t = self.table.get(got)
        if t.kind == types.Kind.interface_:
            let d = t.decl else return
            if d.text == "Allocator":
                return
        var conc = got
        if t.kind == types.Kind.pointer:
            conc = t.elem
        let concrete_type = self.table.get(conc)
        if concrete_type.kind == types.Kind.struct_ or concrete_type.kind == types.Kind.param:
            let d = concrete_type.decl else return try self.fail(e, "this is not an allocator")
            if self.implements_named(conc, "Allocator"):
                if t.kind != types.Kind.pointer and not self.is_mutable_place(e) and not self.changes_receiver(e):
                    try self.fail(e, "an allocator must be a `var`")
                return
        try self.fail(e, "this is not an allocator")

    func implements_named(id: u32, name: str) -> bool:
        let t = self.table.get(id)
        let d = t.decl else return false
        if t.kind == types.Kind.param:
            let g = self.generic_param_node(id) else return false
            var bound = g.body
            while let constraint = bound:
                if let cd = self.table.get(constraint.type_id).decl:
                    if cd.text == name:
                        return true
                bound = constraint.next
            return false
        var listed = d.ty if d.kind != ast.Kind.enum_ else d.right
        while let l = listed:
            if let ld = self.table.get(l.type_id).decl:
                if ld.text == name:
                    return true
            listed = l.next
        return false