dymokomi/luce-base
Source of release 0.42.0
0.42.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