jbwdevries/phasm
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Various cleanup to type system

Browse Source 
- Make struct into a type constuctor
- Rework placeholders
- Got rid of 'PrimitiveType' as a concept

Still in idea form [skip-ci]
This commit is contained in:
Johan B.W. de Vries 2025-04-21 12:32:47 +02:00
parent d6b483581b
commit c9850e6638
10 changed files with 335 additions and 304 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
phasm/codestyle.py
View File

@ -6,8 +6,8 @@ It's intented to be a "any color, as long as it's black" kind of renderer
from typing import Generator from typing import Generator
from . import ourlang from . import ourlang
from .type3 import placeholders as type3placeholders
from .type3 import types as type3types from .type3 import types as type3types
from .type3.types import TYPE3_ASSERTION_ERROR, Type3, Type3OrPlaceholder
def phasm_render(inp: ourlang.Module) -> str: def phasm_render(inp: ourlang.Module) -> str:
@ -18,11 +18,12 @@ def phasm_render(inp: ourlang.Module) -> str:
Statements = Generator[str, None, None] Statements = Generator[str, None, None]
def type3(inp: Type3OrPlaceholder) -> str: def type3(inp: type3placeholders.Type3OrPlaceholder) -> str:
""" """
Render: type's name Render: type's name
""" """
assert isinstance(inp, Type3), TYPE3_ASSERTION_ERROR if isinstance(inp, type3placeholders.PlaceholderForType):
raise NotImplementedError
if inp is type3types.none: if inp is type3types.none:
return 'None' return 'None'
@ -33,8 +34,11 @@ def struct_definition(inp: ourlang.StructDefinition) -> str:
""" """
Render: TypeStruct's definition Render: TypeStruct's definition
""" """
st_args = type3types.struct.did_construct(inp.struct_type3)
assert st_args is not None
result = f'class {inp.struct_type3.name}:\n' result = f'class {inp.struct_type3.name}:\n'
for mem, typ in inp.struct_type3.members.items(): for mem, typ in st_args.items():
result += f' {mem}: {type3(typ)}\n' result += f' {mem}: {type3(typ)}\n'
return result return result

97
phasm/compiler.py
View File

@ -8,6 +8,7 @@ from . import codestyle, ourlang, wasm
from .runtime import calculate_alloc_size, calculate_member_offset from .runtime import calculate_alloc_size, calculate_member_offset
from .stdlib import alloc as stdlib_alloc from .stdlib import alloc as stdlib_alloc
from .stdlib import types as stdlib_types from .stdlib import types as stdlib_types
from .type3 import placeholders as type3placeholders
from .type3 import typeclasses as type3classes from .type3 import typeclasses as type3classes
from .type3 import types as type3types from .type3 import types as type3types
from .wasmgenerator import Generator as WasmGenerator from .wasmgenerator import Generator as WasmGenerator
@ -241,14 +242,14 @@ def phasm_compile(inp: ourlang.Module) -> wasm.Module:
""" """
return module(inp) return module(inp)
def type3(inp: type3types.Type3OrPlaceholder) -> wasm.WasmType: def type3(inp: type3placeholders.Type3OrPlaceholder) -> wasm.WasmType:
""" """
Compile: type Compile: type
Types are used for example in WebAssembly function parameters Types are used for example in WebAssembly function parameters
and return types. and return types.
""" """
assert isinstance(inp, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(inp, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
if inp == type3types.none: if inp == type3types.none:
return wasm.WasmTypeNone() return wasm.WasmTypeNone()
@ -291,10 +292,6 @@ def type3(inp: type3types.Type3OrPlaceholder) -> wasm.WasmType:
# And pointers are i32 # And pointers are i32
return wasm.WasmTypeInt32() return wasm.WasmTypeInt32()
if isinstance(inp, type3types.StructType3):
# Structs are passed as pointer, which are i32
return wasm.WasmTypeInt32()
if type3classes.InternalPassAsPointer in inp.classes: if type3classes.InternalPassAsPointer in inp.classes:
return wasm.WasmTypeInt32() return wasm.WasmTypeInt32()
@ -304,9 +301,9 @@ def tuple_instantiation(wgn: WasmGenerator, inp: ourlang.TupleInstantiation) ->
""" """
Compile: Instantiation (allocation) of a tuple Compile: Instantiation (allocation) of a tuple
""" """
assert isinstance(inp.type3, type3types.PrimitiveType3) assert isinstance(inp.type3, type3types.Type3)
args: list[type3types.PrimitiveType3] = [] args: list[type3types.Type3] = []
sa_args = type3types.static_array.did_construct(inp.type3) sa_args = type3types.static_array.did_construct(inp.type3)
if sa_args is not None: if sa_args is not None:
@ -322,7 +319,7 @@ def tuple_instantiation(wgn: WasmGenerator, inp: ourlang.TupleInstantiation) ->
comment_elements = '' comment_elements = ''
for element in inp.elements: for element in inp.elements:
assert isinstance(element.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(element.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
comment_elements += f'{element.type3.name}, ' comment_elements += f'{element.type3.name}, '
tmp_var = wgn.temp_var_i32('tuple_adr') tmp_var = wgn.temp_var_i32('tuple_adr')
@ -336,19 +333,17 @@ def tuple_instantiation(wgn: WasmGenerator, inp: ourlang.TupleInstantiation) ->
# Store each element individually # Store each element individually
offset = 0 offset = 0
for element, exp_type3 in zip(inp.elements, args): for element, exp_type3 in zip(inp.elements, args):
if isinstance(exp_type3, type3types.PlaceholderForType): if isinstance(exp_type3, type3placeholders.PlaceholderForType):
assert exp_type3.resolve_as is not None assert exp_type3.resolve_as is not None
assert isinstance(exp_type3.resolve_as, type3types.PrimitiveType3) assert isinstance(exp_type3.resolve_as, type3types.Type3)
exp_type3 = exp_type3.resolve_as exp_type3 = exp_type3.resolve_as
assert element.type3 == exp_type3 assert element.type3 == exp_type3
if type3classes.InternalPassAsPointer in exp_type3.classes: if type3classes.InternalPassAsPointer in exp_type3.classes:
mtyp = 'i32' mtyp = 'i32'
elif isinstance(exp_type3, type3types.StructType3):
mtyp = 'i32'
else: else:
assert isinstance(exp_type3, type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs') assert isinstance(exp_type3, type3types.Type3), NotImplementedError('Tuple of applied types / structs')
mtyp = LOAD_STORE_TYPE_MAP[exp_type3.name] mtyp = LOAD_STORE_TYPE_MAP[exp_type3.name]
wgn.add_statement('nop', comment='PRE') wgn.add_statement('nop', comment='PRE')
@ -371,7 +366,7 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
raise Exception raise Exception
if isinstance(inp, ourlang.ConstantPrimitive): if isinstance(inp, ourlang.ConstantPrimitive):
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(inp.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
if inp.type3 in (type3types.i8, type3types.u8, ): if inp.type3 in (type3types.i8, type3types.u8, ):
# No native u8 type - treat as i32, with caution # No native u8 type - treat as i32, with caution
@ -412,34 +407,18 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
return return
if isinstance(inp.variable, ourlang.ModuleConstantDef): if isinstance(inp.variable, ourlang.ModuleConstantDef):
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(inp.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
if type3classes.InternalPassAsPointer in inp.type3.classes: if type3classes.InternalPassAsPointer in inp.type3.classes:
# FIXME: Artifact from older version # FIXME: Artifact from older version
assert isinstance(inp.variable.constant, ourlang.ConstantTuple) assert isinstance(inp.variable.constant, (ourlang.ConstantTuple, ourlang.ConstantStruct, ))
address = inp.variable.constant.data_block.address address = inp.variable.constant.data_block.address
assert address is not None, 'Value not allocated' assert address is not None, 'Value not allocated'
wgn.i32.const(address) wgn.i32.const(address)
return return
if inp.type3 is type3types.bytes_: if isinstance(inp.type3, type3types.Type3):
assert isinstance(inp.variable.constant, ourlang.ConstantBytes)
address = inp.variable.constant.data_block.address
assert address is not None, 'Value not allocated'
wgn.i32.const(address)
return
if isinstance(inp.type3, type3types.StructType3):
assert isinstance(inp.variable.constant, ourlang.ConstantStruct)
address = inp.variable.constant.data_block.address
assert address is not None, 'Value not allocated'
wgn.i32.const(address)
return
if isinstance(inp.type3, type3types.PrimitiveType3):
expression(wgn, inp.variable.constant) expression(wgn, inp.variable.constant)
return return
@ -451,7 +430,7 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
expression(wgn, inp.left) expression(wgn, inp.left)
expression(wgn, inp.right) expression(wgn, inp.right)
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(inp.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
type_var_map: Dict[type3classes.TypeVariable, type3types.Type3] = {} type_var_map: Dict[type3classes.TypeVariable, type3types.Type3] = {}
@ -460,7 +439,7 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
# Fixed type, not part of the lookup requirements # Fixed type, not part of the lookup requirements
continue continue
assert isinstance(arg_expr.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(arg_expr.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
type_var_map[type_var] = arg_expr.type3 type_var_map[type_var] = arg_expr.type3
instance_key = ','.join( instance_key = ','.join(
@ -478,7 +457,7 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
if isinstance(inp, ourlang.UnaryOp): if isinstance(inp, ourlang.UnaryOp):
expression(wgn, inp.right) expression(wgn, inp.right)
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(inp.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
if inp.type3 == type3types.u32: if inp.type3 == type3types.u32:
if inp.operator == 'len': if inp.operator == 'len':
@ -506,7 +485,7 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
# Fixed type, not part of the lookup requirements # Fixed type, not part of the lookup requirements
continue continue
assert isinstance(arg_expr.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(arg_expr.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
type_var_map[type_var] = arg_expr.type3 type_var_map[type_var] = arg_expr.type3
instance_key = ','.join( instance_key = ','.join(
@ -529,7 +508,7 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
return return
if isinstance(inp, ourlang.Subscript): if isinstance(inp, ourlang.Subscript):
assert isinstance(inp.varref.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(inp.varref.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
if inp.varref.type3 is type3types.bytes_: if inp.varref.type3 is type3types.bytes_:
expression(wgn, inp.varref) expression(wgn, inp.varref)
@ -537,7 +516,7 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
wgn.call(stdlib_types.__subscript_bytes__) wgn.call(stdlib_types.__subscript_bytes__)
return return
assert isinstance(inp.varref.type3, type3types.PrimitiveType3) assert isinstance(inp.varref.type3, type3types.Type3)
sa_args = type3types.static_array.did_construct(inp.varref.type3) sa_args = type3types.static_array.did_construct(inp.varref.type3)
if sa_args is not None: if sa_args is not None:
@ -563,7 +542,7 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
wgn.i32.mul() wgn.i32.mul()
wgn.i32.add() wgn.i32.add()
assert isinstance(el_type, type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs') assert isinstance(el_type, type3types.Type3), NotImplementedError('Tuple of applied types / structs')
mtyp = LOAD_STORE_TYPE_MAP[el_type.name] mtyp = LOAD_STORE_TYPE_MAP[el_type.name]
wgn.add_statement(f'{mtyp}.load') wgn.add_statement(f'{mtyp}.load')
@ -576,20 +555,18 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
offset = 0 offset = 0
for el_type in tp_args[0:inp.index.value]: for el_type in tp_args[0:inp.index.value]:
assert isinstance(el_type, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(el_type, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
offset += calculate_alloc_size(el_type) offset += calculate_alloc_size(el_type)
el_type = tp_args[inp.index.value] el_type = tp_args[inp.index.value]
assert isinstance(el_type, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(el_type, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
expression(wgn, inp.varref) expression(wgn, inp.varref)
if isinstance(el_type, type3types.StructType3): if type3classes.InternalPassAsPointer in el_type.classes:
mtyp = 'i32'
elif type3classes.InternalPassAsPointer in el_type.classes:
mtyp = 'i32' mtyp = 'i32'
else: else:
assert isinstance(el_type, type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs') assert isinstance(el_type, type3types.Type3), NotImplementedError('Tuple of applied types / structs')
mtyp = LOAD_STORE_TYPE_MAP[el_type.name] mtyp = LOAD_STORE_TYPE_MAP[el_type.name]
wgn.add_statement(f'{mtyp}.load', f'offset={offset}') wgn.add_statement(f'{mtyp}.load', f'offset={offset}')
@ -598,12 +575,19 @@ def expression(wgn: WasmGenerator, inp: ourlang.Expression) -> None:
raise NotImplementedError(expression, inp, inp.varref.type3) raise NotImplementedError(expression, inp, inp.varref.type3)
if isinstance(inp, ourlang.AccessStructMember): if isinstance(inp, ourlang.AccessStructMember):
assert isinstance(inp.struct_type3.members[inp.member], type3types.PrimitiveType3), NotImplementedError('Tuple of applied types / structs') assert isinstance(inp.struct_type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
mtyp = LOAD_STORE_TYPE_MAP[inp.struct_type3.members[inp.member].name]
st_args = type3types.struct.did_construct(inp.struct_type3)
assert st_args is not None
member_type = st_args[inp.member]
assert isinstance(member_type, type3types.Type3), NotImplementedError('Tuple of applied types / structs')
mtyp = LOAD_STORE_TYPE_MAP[member_type.name]
expression(wgn, inp.varref) expression(wgn, inp.varref)
wgn.add_statement(f'{mtyp}.load', 'offset=' + str(calculate_member_offset( wgn.add_statement(f'{mtyp}.load', 'offset=' + str(calculate_member_offset(
inp.struct_type3, inp.member inp.struct_type3.name, st_args, inp.member
))) )))
return return
@ -617,7 +601,7 @@ def expression_fold(wgn: WasmGenerator, inp: ourlang.Fold) -> None:
""" """
Compile: Fold expression Compile: Fold expression
""" """
assert isinstance(inp.type3, type3types.Type3), type3types.TYPE3_ASSERTION_ERROR assert isinstance(inp.type3, type3types.Type3), type3placeholders.TYPE3_ASSERTION_ERROR
if inp.iter.type3 is not type3types.bytes_: if inp.iter.type3 is not type3types.bytes_:
raise NotImplementedError(expression_fold, inp, inp.iter.type3) raise NotImplementedError(expression_fold, inp, inp.iter.type3)
@ -848,7 +832,7 @@ def module_data(inp: ourlang.ModuleData) -> bytes:
data_list: List[bytes] = [] data_list: List[bytes] = []
for constant in block.data: for constant in block.data:
assert isinstance(constant.type3, type3types.Type3), (id(constant), type3types.TYPE3_ASSERTION_ERROR) assert isinstance(constant.type3, type3types.Type3), (id(constant), type3placeholders.TYPE3_ASSERTION_ERROR)
if isinstance(constant, ourlang.ConstantMemoryStored) and block is not constant.data_block: if isinstance(constant, ourlang.ConstantMemoryStored) and block is not constant.data_block:
# It's stored in a different block # It's stored in a different block
@ -978,6 +962,9 @@ def module(inp: ourlang.Module) -> wasm.Module:
return result return result
def _generate_struct_constructor(wgn: WasmGenerator, inp: ourlang.StructConstructor) -> None: def _generate_struct_constructor(wgn: WasmGenerator, inp: ourlang.StructConstructor) -> None:
st_args = type3types.struct.did_construct(inp.struct_type3)
assert st_args is not None
tmp_var = wgn.temp_var_i32('struct_adr') tmp_var = wgn.temp_var_i32('struct_adr')
# Allocated the required amounts of bytes in memory # Allocated the required amounts of bytes in memory
@ -986,12 +973,10 @@ def _generate_struct_constructor(wgn: WasmGenerator, inp: ourlang.StructConstruc
wgn.local.set(tmp_var) wgn.local.set(tmp_var)
# Store each member individually # Store each member individually
for memname, mtyp3 in inp.struct_type3.members.items(): for memname, mtyp3 in st_args.items():
mtyp: Optional[str] mtyp: Optional[str]
if type3classes.InternalPassAsPointer in mtyp3.classes: if type3classes.InternalPassAsPointer in mtyp3.classes:
mtyp = 'i32' mtyp = 'i32'
elif isinstance(mtyp3, type3types.StructType3):
mtyp = 'i32'
else: else:
mtyp = LOAD_STORE_TYPE_MAP.get(mtyp3.name) mtyp = LOAD_STORE_TYPE_MAP.get(mtyp3.name)
@ -1001,7 +986,7 @@ def _generate_struct_constructor(wgn: WasmGenerator, inp: ourlang.StructConstruc
wgn.local.get(tmp_var) wgn.local.get(tmp_var)
wgn.add_statement('local.get', f'${memname}') wgn.add_statement('local.get', f'${memname}')
wgn.add_statement(f'{mtyp}.store', 'offset=' + str(calculate_member_offset( wgn.add_statement(f'{mtyp}.store', 'offset=' + str(calculate_member_offset(
inp.struct_type3, memname inp.struct_type3.name, st_args, memname
))) )))
# Return the allocated address # Return the allocated address

19
phasm/ourlang.py
View File

@ -8,7 +8,8 @@ from typing_extensions import Final
from .type3 import typeclasses as type3typeclasses from .type3 import typeclasses as type3typeclasses
from .type3 import types as type3types from .type3 import types as type3types
from .type3.types import PlaceholderForType, StructType3, Type3, Type3OrPlaceholder from .type3.placeholders import PlaceholderForType, Type3OrPlaceholder
from .type3.types import Type3
WEBASSEMBLY_BUILTIN_BYTES_OPS: Final = ('len', ) WEBASSEMBLY_BUILTIN_BYTES_OPS: Final = ('len', )
@ -214,10 +215,10 @@ class AccessStructMember(Expression):
__slots__ = ('varref', 'struct_type3', 'member', ) __slots__ = ('varref', 'struct_type3', 'member', )
varref: VariableReference varref: VariableReference
struct_type3: StructType3 struct_type3: Type3OrPlaceholder
member: str member: str
def __init__(self, varref: VariableReference, struct_type3: StructType3, member: str) -> None: def __init__(self, varref: VariableReference, struct_type3: Type3OrPlaceholder, member: str) -> None:
super().__init__() super().__init__()
self.varref = varref self.varref = varref
@ -335,10 +336,10 @@ class StructDefinition:
""" """
__slots__ = ('struct_type3', 'lineno', ) __slots__ = ('struct_type3', 'lineno', )
struct_type3: StructType3 struct_type3: Type3
lineno: int lineno: int
def __init__(self, struct_type3: StructType3, lineno: int) -> None: def __init__(self, struct_type3: Type3, lineno: int) -> None:
self.struct_type3 = struct_type3 self.struct_type3 = struct_type3
self.lineno = lineno self.lineno = lineno
@ -351,14 +352,16 @@ class StructConstructor(Function):
""" """
__slots__ = ('struct_type3', ) __slots__ = ('struct_type3', )
struct_type3: StructType3 struct_type3: Type3
def __init__(self, struct_type3: StructType3) -> None: def __init__(self, struct_type3: Type3) -> None:
super().__init__(f'@{struct_type3.name}@__init___@', -1) super().__init__(f'@{struct_type3.name}@__init___@', -1)
self.returns_type3 = struct_type3 self.returns_type3 = struct_type3
for mem, typ in struct_type3.members.items(): st_args = type3types.struct.did_construct(struct_type3)
assert st_args is not None
for mem, typ in st_args.items():
self.posonlyargs.append(FunctionParam(mem, typ, )) self.posonlyargs.append(FunctionParam(mem, typ, ))
self.struct_type3 = struct_type3 self.struct_type3 = struct_type3

25
phasm/parser.py
View File

@ -55,6 +55,20 @@ PRELUDE_METHODS = {
**type3typeclasses.NatNum.methods, **type3typeclasses.NatNum.methods,
} }
PRELUDE_TYPES: Dict[str, type3types.Type3] = {
'none': type3types.none,
'bool': type3types.bool_,
'u8': type3types.u8,
'u32': type3types.u32,
'u64': type3types.u64,
'i8': type3types.i8,
'i32': type3types.i32,
'i64': type3types.i64,
'f32': type3types.f32,
'f64': type3types.f64,
'bytes': type3types.bytes_,
}
def phasm_parse(source: str) -> Module: def phasm_parse(source: str) -> Module:
""" """
Public method for parsing Phasm code into a Phasm Module Public method for parsing Phasm code into a Phasm Module
@ -252,7 +266,7 @@ class OurVisitor:
members[stmt.target.id] = self.visit_type(module, stmt.annotation) members[stmt.target.id] = self.visit_type(module, stmt.annotation)
return StructDefinition(type3types.StructType3(node.name, members), node.lineno) return StructDefinition(type3types.struct(node.name, members, set()), node.lineno)
def pre_visit_Module_AnnAssign(self, module: Module, node: ast.AnnAssign) -> ModuleConstantDef: def pre_visit_Module_AnnAssign(self, module: Module, node: ast.AnnAssign) -> ModuleConstantDef:
if not isinstance(node.target, ast.Name): if not isinstance(node.target, ast.Name):
@ -570,9 +584,6 @@ class OurVisitor:
if not isinstance(varref, VariableReference): if not isinstance(varref, VariableReference):
_raise_static_error(node.value, 'Must refer to variable') _raise_static_error(node.value, 'Must refer to variable')
if not isinstance(varref.variable.type3, type3types.StructType3):
_raise_static_error(node.value, 'Must refer to struct')
return AccessStructMember( return AccessStructMember(
varref, varref,
varref.variable.type3, varref.variable.type3,
@ -664,7 +675,7 @@ class OurVisitor:
raise NotImplementedError(f'{node.value} as constant') raise NotImplementedError(f'{node.value} as constant')
def visit_type(self, module: Module, node: ast.expr) -> type3types.PrimitiveType3: def visit_type(self, module: Module, node: ast.expr) -> type3types.Type3:
if isinstance(node, ast.Constant): if isinstance(node, ast.Constant):
if node.value is None: if node.value is None:
return type3types.none return type3types.none
@ -675,8 +686,8 @@ class OurVisitor:
if not isinstance(node.ctx, ast.Load): if not isinstance(node.ctx, ast.Load):
_raise_static_error(node, 'Must be load context') _raise_static_error(node, 'Must be load context')
if node.id in type3types.LOOKUP_TABLE: if node.id in PRELUDE_TYPES:
return type3types.LOOKUP_TABLE[node.id] return PRELUDE_TYPES[node.id]
if node.id in module.struct_definitions: if node.id in module.struct_definitions:
return module.struct_definitions[node.id].struct_type3 return module.struct_definitions[node.id].struct_type3

21
phasm/runtime.py
View File

@ -17,18 +17,17 @@ def calculate_alloc_size(typ: type3types.Type3, is_member: bool = False) -> int:
raise NotImplementedError # When does this happen? raise NotImplementedError # When does this happen?
if isinstance(typ, type3types.StructType3): st_args = type3types.struct.did_construct(typ)
if st_args is not None:
if is_member: if is_member:
# Structs referred to by other structs or tuples are pointers # Structs referred to by other structs or tuples are pointers
return 4 return 4
return sum( return sum(
calculate_alloc_size(x, is_member=True) calculate_alloc_size(x, is_member=True)
for x in typ.members.values() for x in st_args.values()
) )
assert isinstance(typ, type3types.PrimitiveType3)
sa_args = type3types.static_array.did_construct(typ) sa_args = type3types.static_array.did_construct(typ)
if sa_args is not None: if sa_args is not None:
if is_member: if is_member:
@ -47,25 +46,19 @@ def calculate_alloc_size(typ: type3types.Type3, is_member: bool = False) -> int:
size = 0 size = 0
for arg in tp_args: for arg in tp_args:
assert not isinstance(arg, type3types.IntType3)
if isinstance(arg, type3types.PlaceholderForType):
assert isinstance(arg.resolve_as, type3types.PrimitiveType3)
arg = arg.resolve_as
size += calculate_alloc_size(arg, is_member=True) size += calculate_alloc_size(arg, is_member=True)
return size return size
raise NotImplementedError(calculate_alloc_size, typ) raise NotImplementedError(calculate_alloc_size, typ)
def calculate_member_offset(struct_type3: type3types.StructType3, member: str) -> int: def calculate_member_offset(st_name: str, st_args: dict[str, type3types.Type3], needle: str) -> int:
result = 0 result = 0
for mem, memtyp in struct_type3.members.items(): for memnam, memtyp in st_args.items():
if member == mem: if needle == memnam:
return result return result
result += calculate_alloc_size(memtyp, is_member=True) result += calculate_alloc_size(memtyp, is_member=True)
raise Exception(f'{member} not in {struct_type3}') raise Exception(f'{needle} not in {st_name}')

60
phasm/type3/constraints.py
View File

@ -6,7 +6,7 @@ These need to be resolved before the program can be compiled.
from typing import Dict, List, Optional, Tuple, Union from typing import Dict, List, Optional, Tuple, Union
from .. import ourlang from .. import ourlang
from . import typeclasses, types from . import placeholders, typeclasses, types
class Error: class Error:
@ -32,13 +32,13 @@ class RequireTypeSubstitutes:
typing of the program, so this constraint can be updated. typing of the program, so this constraint can be updated.
""" """
SubstitutionMap = Dict[types.PlaceholderForType, types.Type3] SubstitutionMap = Dict[placeholders.PlaceholderForType, types.Type3]
NewConstraintList = List['ConstraintBase'] NewConstraintList = List['ConstraintBase']
CheckResult = Union[None, SubstitutionMap, Error, NewConstraintList, RequireTypeSubstitutes] CheckResult = Union[None, SubstitutionMap, Error, NewConstraintList, RequireTypeSubstitutes]
HumanReadableRet = Tuple[str, Dict[str, Union[str, ourlang.Expression, types.Type3, types.PlaceholderForType]]] HumanReadableRet = Tuple[str, Dict[str, Union[str, ourlang.Expression, types.Type3, placeholders.PlaceholderForType]]]
class Context: class Context:
""" """
@ -92,9 +92,9 @@ class SameTypeConstraint(ConstraintBase):
""" """
__slots__ = ('type_list', ) __slots__ = ('type_list', )
type_list: List[types.Type3OrPlaceholder] type_list: List[placeholders.Type3OrPlaceholder]
def __init__(self, *type_list: types.Type3OrPlaceholder, comment: Optional[str] = None) -> None: def __init__(self, *type_list: placeholders.Type3OrPlaceholder, comment: Optional[str] = None) -> None:
super().__init__(comment=comment) super().__init__(comment=comment)
assert len(type_list) > 1 assert len(type_list) > 1
@ -108,11 +108,11 @@ class SameTypeConstraint(ConstraintBase):
known_types.append(typ) known_types.append(typ)
continue continue
if isinstance(typ, (types.PrimitiveType3, types.StructType3, )): if isinstance(typ, (types.Type3, types.StructType3, )):
known_types.append(typ) known_types.append(typ)
continue continue
if isinstance(typ, types.PlaceholderForType): if isinstance(typ, placeholders.PlaceholderForType):
if typ.resolve_as is not None: if typ.resolve_as is not None:
known_types.append(typ.resolve_as) known_types.append(typ.resolve_as)
else: else:
@ -163,7 +163,7 @@ class SameTypeConstraint(ConstraintBase):
return f'SameTypeConstraint({args}, comment={repr(self.comment)})' return f'SameTypeConstraint({args}, comment={repr(self.comment)})'
class TupleMatchConstraint(ConstraintBase): class TupleMatchConstraint(ConstraintBase):
def __init__(self, exp_type: types.Type3OrPlaceholder, args: List[types.Type3OrPlaceholder], comment: str): def __init__(self, exp_type: placeholders.Type3OrPlaceholder, args: List[placeholders.Type3OrPlaceholder], comment: str):
super().__init__(comment=comment) super().__init__(comment=comment)
self.exp_type = exp_type self.exp_type = exp_type
@ -171,13 +171,13 @@ class TupleMatchConstraint(ConstraintBase):
def check(self) -> CheckResult: def check(self) -> CheckResult:
exp_type = self.exp_type exp_type = self.exp_type
if isinstance(exp_type, types.PlaceholderForType): if isinstance(exp_type, placeholders.PlaceholderForType):
if exp_type.resolve_as is None: if exp_type.resolve_as is None:
return RequireTypeSubstitutes() return RequireTypeSubstitutes()
exp_type = exp_type.resolve_as exp_type = exp_type.resolve_as
assert isinstance(exp_type, types.PrimitiveType3) assert isinstance(exp_type, types.Type3)
sa_args = types.static_array.did_construct(exp_type) sa_args = types.static_array.did_construct(exp_type)
if sa_args is not None: if sa_args is not None:
@ -209,10 +209,10 @@ class CastableConstraint(ConstraintBase):
""" """
__slots__ = ('from_type3', 'to_type3', ) __slots__ = ('from_type3', 'to_type3', )
from_type3: types.Type3OrPlaceholder from_type3: placeholders.Type3OrPlaceholder
to_type3: types.Type3OrPlaceholder to_type3: placeholders.Type3OrPlaceholder
def __init__(self, from_type3: types.Type3OrPlaceholder, to_type3: types.Type3OrPlaceholder, comment: Optional[str] = None) -> None: def __init__(self, from_type3: placeholders.Type3OrPlaceholder, to_type3: placeholders.Type3OrPlaceholder, comment: Optional[str] = None) -> None:
super().__init__(comment=comment) super().__init__(comment=comment)
self.from_type3 = from_type3 self.from_type3 = from_type3
@ -220,14 +220,14 @@ class CastableConstraint(ConstraintBase):
def check(self) -> CheckResult: def check(self) -> CheckResult:
ftyp = self.from_type3 ftyp = self.from_type3
if isinstance(ftyp, types.PlaceholderForType) and ftyp.resolve_as is not None: if isinstance(ftyp, placeholders.PlaceholderForType) and ftyp.resolve_as is not None:
ftyp = ftyp.resolve_as ftyp = ftyp.resolve_as
ttyp = self.to_type3 ttyp = self.to_type3
if isinstance(ttyp, types.PlaceholderForType) and ttyp.resolve_as is not None: if isinstance(ttyp, placeholders.PlaceholderForType) and ttyp.resolve_as is not None:
ttyp = ttyp.resolve_as ttyp = ttyp.resolve_as
if isinstance(ftyp, types.PlaceholderForType) or isinstance(ttyp, types.PlaceholderForType): if isinstance(ftyp, placeholders.PlaceholderForType) or isinstance(ttyp, placeholders.PlaceholderForType):
return RequireTypeSubstitutes() return RequireTypeSubstitutes()
if ftyp is types.u8 and ttyp is types.u32: if ftyp is types.u8 and ttyp is types.u32:
@ -254,13 +254,13 @@ class MustImplementTypeClassConstraint(ConstraintBase):
__slots__ = ('type_class3', 'type3', ) __slots__ = ('type_class3', 'type3', )
type_class3: Union[str, typeclasses.Type3Class] type_class3: Union[str, typeclasses.Type3Class]
type3: types.Type3OrPlaceholder type3: placeholders.Type3OrPlaceholder
DATA = { DATA = {
'bytes': {'Foldable', 'Sized'}, 'bytes': {'Foldable', 'Sized'},
} }
def __init__(self, type_class3: Union[str, typeclasses.Type3Class], type3: types.Type3OrPlaceholder, comment: Optional[str] = None) -> None: def __init__(self, type_class3: Union[str, typeclasses.Type3Class], type3: placeholders.Type3OrPlaceholder, comment: Optional[str] = None) -> None:
super().__init__(comment=comment) super().__init__(comment=comment)
self.type_class3 = type_class3 self.type_class3 = type_class3
@ -268,10 +268,10 @@ class MustImplementTypeClassConstraint(ConstraintBase):
def check(self) -> CheckResult: def check(self) -> CheckResult:
typ = self.type3 typ = self.type3
if isinstance(typ, types.PlaceholderForType) and typ.resolve_as is not None: if isinstance(typ, placeholders.PlaceholderForType) and typ.resolve_as is not None:
typ = typ.resolve_as typ = typ.resolve_as
if isinstance(typ, types.PlaceholderForType): if isinstance(typ, placeholders.PlaceholderForType):
return RequireTypeSubstitutes() return RequireTypeSubstitutes()
if isinstance(self.type_class3, typeclasses.Type3Class): if isinstance(self.type_class3, typeclasses.Type3Class):
@ -301,12 +301,12 @@ class LiteralFitsConstraint(ConstraintBase):
""" """
__slots__ = ('type3', 'literal', ) __slots__ = ('type3', 'literal', )
type3: types.Type3OrPlaceholder type3: placeholders.Type3OrPlaceholder
literal: Union[ourlang.ConstantPrimitive, ourlang.ConstantBytes, ourlang.ConstantTuple, ourlang.ConstantStruct] literal: Union[ourlang.ConstantPrimitive, ourlang.ConstantBytes, ourlang.ConstantTuple, ourlang.ConstantStruct]
def __init__( def __init__(
self, self,
type3: types.Type3OrPlaceholder, type3: placeholders.Type3OrPlaceholder,
literal: Union[ourlang.ConstantPrimitive, ourlang.ConstantBytes, ourlang.ConstantTuple, ourlang.ConstantStruct], literal: Union[ourlang.ConstantPrimitive, ourlang.ConstantBytes, ourlang.ConstantTuple, ourlang.ConstantStruct],
comment: Optional[str] = None, comment: Optional[str] = None,
) -> None: ) -> None:
@ -330,7 +330,7 @@ class LiteralFitsConstraint(ConstraintBase):
'f64': None, 'f64': None,
} }
if isinstance(self.type3, types.PlaceholderForType): if isinstance(self.type3, placeholders.PlaceholderForType):
if self.type3.resolve_as is None: if self.type3.resolve_as is None:
return RequireTypeSubstitutes() return RequireTypeSubstitutes()
@ -367,7 +367,7 @@ class LiteralFitsConstraint(ConstraintBase):
res: NewConstraintList res: NewConstraintList
assert isinstance(self.type3, types.PrimitiveType3) assert isinstance(self.type3, types.Type3)
tp_args = types.tuple_.did_construct(self.type3) tp_args = types.tuple_.did_construct(self.type3)
if tp_args is not None: if tp_args is not None:
@ -457,12 +457,12 @@ class CanBeSubscriptedConstraint(ConstraintBase):
""" """
__slots__ = ('ret_type3', 'type3', 'index', 'index_type3', ) __slots__ = ('ret_type3', 'type3', 'index', 'index_type3', )
ret_type3: types.Type3OrPlaceholder ret_type3: placeholders.Type3OrPlaceholder
type3: types.Type3OrPlaceholder type3: placeholders.Type3OrPlaceholder
index: ourlang.Expression index: ourlang.Expression
index_type3: types.Type3OrPlaceholder index_type3: placeholders.Type3OrPlaceholder
def __init__(self, ret_type3: types.Type3OrPlaceholder, type3: types.Type3OrPlaceholder, index: ourlang.Expression, comment: Optional[str] = None) -> None: def __init__(self, ret_type3: placeholders.Type3OrPlaceholder, type3: placeholders.Type3OrPlaceholder, index: ourlang.Expression, comment: Optional[str] = None) -> None:
super().__init__(comment=comment) super().__init__(comment=comment)
self.ret_type3 = ret_type3 self.ret_type3 = ret_type3
@ -472,13 +472,13 @@ class CanBeSubscriptedConstraint(ConstraintBase):
def check(self) -> CheckResult: def check(self) -> CheckResult:
exp_type = self.type3 exp_type = self.type3
if isinstance(exp_type, types.PlaceholderForType): if isinstance(exp_type, placeholders.PlaceholderForType):
if exp_type.resolve_as is None: if exp_type.resolve_as is None:
return RequireTypeSubstitutes() return RequireTypeSubstitutes()
exp_type = exp_type.resolve_as exp_type = exp_type.resolve_as
assert isinstance(exp_type, types.PrimitiveType3) assert isinstance(exp_type, types.Type3)
sa_args = types.static_array.did_construct(exp_type) sa_args = types.static_array.did_construct(exp_type)
if sa_args is not None: if sa_args is not None:

9
phasm/type3/entry.py
View File

@ -12,14 +12,11 @@ from .constraints import (
SubstitutionMap, SubstitutionMap,
) )
from .constraintsgenerator import phasm_type3_generate_constraints from .constraintsgenerator import phasm_type3_generate_constraints
from .types import ( from .placeholders import (
IntType3,
PlaceholderForType, PlaceholderForType,
PrimitiveType3,
StructType3,
Type3,
Type3OrPlaceholder, Type3OrPlaceholder,
) )
from .types import Type3
MAX_RESTACK_COUNT = 100 MAX_RESTACK_COUNT = 100
@ -143,7 +140,7 @@ def print_constraint(placeholder_id_map: Dict[int, str], constraint: ConstraintB
print('- ' + txt.format(**act_fmt)) print('- ' + txt.format(**act_fmt))
def get_printable_type_name(inp: Type3OrPlaceholder, placeholder_id_map: Dict[int, str]) -> str: def get_printable_type_name(inp: Type3OrPlaceholder, placeholder_id_map: Dict[int, str]) -> str:
if isinstance(inp, (PrimitiveType3, StructType3, IntType3, )): if isinstance(inp, Type3):
return inp.name return inp.name
if isinstance(inp, PlaceholderForType): if isinstance(inp, PlaceholderForType):

67
phasm/type3/placeholders.py Normal file
View File

@ -0,0 +1,67 @@
"""
Contains the placeholder for types for use in Phasm.
These are temporary while the compiler is calculating all the types and validating them.
"""
from typing import Any, Iterable, List, Optional, Protocol, Union
from .types import Type3
TYPE3_ASSERTION_ERROR = 'You must call phasm_type3 after calling phasm_parse before you can call any other method'
class ExpressionProtocol(Protocol):
"""
A protocol for classes that should be updated on substitution
"""
type3: 'Type3OrPlaceholder'
"""
The type to update
"""
class PlaceholderForType:
"""
A placeholder type, for when we don't know the final type yet
"""
__slots__ = ('update_on_substitution', 'resolve_as', )
update_on_substitution: List[ExpressionProtocol]
resolve_as: Optional[Type3]
def __init__(self, update_on_substitution: Iterable[ExpressionProtocol]) -> None:
self.update_on_substitution = [*update_on_substitution]
self.resolve_as = None
def __repr__(self) -> str:
uos = ', '.join(repr(x) for x in self.update_on_substitution)
return f'PlaceholderForType({id(self)}, [{uos}])'
def __str__(self) -> str:
return f'PhFT_{id(self)}'
def __format__(self, format_spec: str) -> str:
if format_spec != 's':
raise TypeError('unsupported format string passed to Type3.__format__')
return str(self)
def __eq__(self, other: Any) -> bool:
if isinstance(other, Type3):
return False
if not isinstance(other, PlaceholderForType):
raise NotImplementedError
return self is other
def __ne__(self, other: Any) -> bool:
return not self.__eq__(other)
def __hash__(self) -> int:
return 0 # Valid but performs badly
def __bool__(self) -> bool:
raise NotImplementedError
Type3OrPlaceholder = Union[Type3, PlaceholderForType]

241
phasm/type3/types.py
View File

@ -1,21 +1,13 @@
""" """
Contains the final types for use in Phasm Contains the final types for use in Phasm, as well as construtors.
These are actual, instantiated types; not the abstract types that the
constraint generator works with.
""" """
from typing import ( from typing import (
Any, Any,
Dict,
Generic, Generic,
Iterable, Iterable,
List,
Optional,
Protocol,
Set, Set,
Tuple, Tuple,
TypeVar, TypeVar,
Union,
) )
from .typeclasses import ( from .typeclasses import (
@ -31,21 +23,16 @@ from .typeclasses import (
Type3Class, Type3Class,
) )
TYPE3_ASSERTION_ERROR = 'You must call phasm_type3 after calling phasm_parse before you can call any other method'
class ExpressionProtocol(Protocol): class KindArgument:
""" pass
A protocol for classes that should be updated on substitution
"""
type3: 'Type3OrPlaceholder' class Type3(KindArgument):
"""
The type to update
"""
class Type3:
""" """
Base class for the type3 types Base class for the type3 types
(Having a separate name makes it easier to distinguish from
Python's Type)
""" """
__slots__ = ('name', 'classes', ) __slots__ = ('name', 'classes', )
@ -84,9 +71,6 @@ class Type3:
return str(self) return str(self)
def __eq__(self, other: Any) -> bool: def __eq__(self, other: Any) -> bool:
if isinstance(other, PlaceholderForType):
return False
if not isinstance(other, Type3): if not isinstance(other, Type3):
raise NotImplementedError raise NotImplementedError
@ -101,19 +85,15 @@ class Type3:
def __bool__(self) -> bool: def __bool__(self) -> bool:
raise NotImplementedError raise NotImplementedError
class PrimitiveType3(Type3): class IntType3(KindArgument):
""" """
Intermediate class to tell primitive types from others Sometimes you can have an int on the type level, e.g. when using static arrays
"""
__slots__ = ()
class IntType3(Type3):
"""
Sometimes you can have an int as type, e.g. when using static arrays
This is not the same as an int on the language level. This is not the same as an int on the language level.
[1.0, 1.2] :: Float[2] :: * -> Int -> * [1.0, 1.2] :: f32[2] :: * -> Int -> *
That is to say, you can create a static array of size two with each element
a f32 using f32[2].
""" """
__slots__ = ('value', ) __slots__ = ('value', )
@ -121,15 +101,13 @@ class IntType3(Type3):
value: int value: int
def __init__(self, value: int) -> None: def __init__(self, value: int) -> None:
super().__init__(str(value), [])
self.value = value self.value = value
def __eq__(self, other: Any) -> bool: def __eq__(self, other: Any) -> bool:
if isinstance(other, IntType3): if isinstance(other, IntType3):
return self.value == other.value return self.value == other.value
if isinstance(other, Type3): if isinstance(other, KindArgument):
return False return False
raise NotImplementedError raise NotImplementedError
@ -137,53 +115,6 @@ class IntType3(Type3):
def __hash__(self) -> int: def __hash__(self) -> int:
return hash(self.value) return hash(self.value)
class PlaceholderForType:
"""
A placeholder type, for when we don't know the final type yet
"""
__slots__ = ('update_on_substitution', 'resolve_as', )
update_on_substitution: List[ExpressionProtocol]
resolve_as: Optional[Type3]
def __init__(self, update_on_substitution: Iterable[ExpressionProtocol]) -> None:
self.update_on_substitution = [*update_on_substitution]
self.resolve_as = None
def __repr__(self) -> str:
uos = ', '.join(repr(x) for x in self.update_on_substitution)
return f'PlaceholderForType({id(self)}, [{uos}])'
def __str__(self) -> str:
return f'PhFT_{id(self)}'
def __format__(self, format_spec: str) -> str:
if format_spec != 's':
raise TypeError('unsupported format string passed to Type3.__format__')
return str(self)
def __eq__(self, other: Any) -> bool:
if isinstance(other, Type3):
return False
if not isinstance(other, PlaceholderForType):
raise NotImplementedError
return self is other
def __ne__(self, other: Any) -> bool:
return not self.__eq__(other)
def __hash__(self) -> int:
return 0 # Valid but performs badly
def __bool__(self) -> bool:
raise NotImplementedError
Type3OrPlaceholder = Union[Type3, PlaceholderForType]
T = TypeVar('T') T = TypeVar('T')
class TypeConstructor(Generic[T]): class TypeConstructor(Generic[T]):
@ -207,13 +138,13 @@ class TypeConstructor(Generic[T]):
The type classes that the constructed types implement The type classes that the constructed types implement
""" """
_cache: dict[T, PrimitiveType3] _cache: dict[T, Type3]
""" """
When constructing a type with the same arguments, When constructing a type with the same arguments,
it should produce the exact same result. it should produce the exact same result.
""" """
_reverse_cache: dict[PrimitiveType3, T] _reverse_cache: dict[Type3, T]
""" """
Sometimes we need to know the key that created a type. Sometimes we need to know the key that created a type.
""" """
@ -227,115 +158,165 @@ class TypeConstructor(Generic[T]):
self._reverse_cache = {} self._reverse_cache = {}
def make_name(self, key: T) -> str: def make_name(self, key: T) -> str:
"""
Renders the type's name based on the given arguments
"""
raise NotImplementedError raise NotImplementedError
def did_construct(self, typ: PrimitiveType3) -> T | None: def did_construct(self, typ: Type3) -> T | None:
"""
Was the given type constructed by this constructor?
If so, which arguments where used?
"""
return self._reverse_cache.get(typ) return self._reverse_cache.get(typ)
def construct(self, key: T) -> PrimitiveType3: def construct(self, key: T) -> Type3:
"""
Constructs the type by applying the given arguments to this
constructor.
"""
result = self._cache.get(key, None) result = self._cache.get(key, None)
if result is None: if result is None:
self._cache[key] = result = PrimitiveType3(self.make_name(key), self.type_classes) self._cache[key] = result = Type3(self.make_name(key), self.type_classes)
self._reverse_cache[result] = key self._reverse_cache[result] = key
return result return result
class TypeConstructor_Type(TypeConstructor[PrimitiveType3]): class TypeConstructor_Type(TypeConstructor[Type3]):
""" """
Base class type constructors of kind: * -> * Base class type constructors of kind: * -> *
""" """
__slots__ = () __slots__ = ()
def __call__(self, arg: PrimitiveType3) -> PrimitiveType3: def __call__(self, arg: Type3) -> Type3:
raise NotImplementedError raise NotImplementedError
class TypeConstructor_TypeInt(TypeConstructor[Tuple[PrimitiveType3, IntType3]]): class TypeConstructor_TypeInt(TypeConstructor[Tuple[Type3, IntType3]]):
""" """
Base class type constructors of kind: * -> Int -> * Base class type constructors of kind: * -> Int -> *
Notably, static array.
""" """
__slots__ = () __slots__ = ()
def make_name(self, key: Tuple[PrimitiveType3, IntType3]) -> str: def make_name(self, key: Tuple[Type3, IntType3]) -> str:
return f'{self.name} {key[0].name} {key[1].value}' return f'{self.name} {key[0].name} {key[1].value}'
def __call__(self, arg0: PrimitiveType3, arg1: IntType3) -> PrimitiveType3: def __call__(self, arg0: Type3, arg1: IntType3) -> Type3:
return self.construct((arg0, arg1)) return self.construct((arg0, arg1))
class TypeConstructor_TypeStar(TypeConstructor[Tuple[PrimitiveType3, ...]]): class TypeConstructor_TypeStar(TypeConstructor[Tuple[Type3, ...]]):
""" """
Base class type constructors of variadic kind Base class type constructors of variadic kind
Notably, tuple.
""" """
def __call__(self, *args: PrimitiveType3) -> PrimitiveType3: def __call__(self, *args: Type3) -> Type3:
key: Tuple[PrimitiveType3, ...] = tuple(args) key: Tuple[Type3, ...] = tuple(args)
return self.construct(key) return self.construct(key)
class TypeConstructor_StaticArray(TypeConstructor_TypeInt): class TypeConstructor_StaticArray(TypeConstructor_TypeInt):
def make_name(self, key: Tuple[PrimitiveType3, IntType3]) -> str: def make_name(self, key: Tuple[Type3, IntType3]) -> str:
return f'{key[0].name}[{key[1].value}]' return f'{key[0].name}[{key[1].value}]'
class TypeConstructor_Tuple(TypeConstructor_TypeStar): class TypeConstructor_Tuple(TypeConstructor_TypeStar):
def make_name(self, key: Tuple[PrimitiveType3, ...]) -> str: def make_name(self, key: Tuple[Type3, ...]) -> str:
return '(' + ', '.join(x.name for x in key) + ', )' return '(' + ', '.join(x.name for x in key) + ', )'
class StructType3(PrimitiveType3): class TypeConstructor_Struct:
""" """
A Type3 struct with named members Base class for type construtors
""" """
__slots__ = ('name', 'members', ) __slots__ = ('name', 'classes', 'type_classes', '_cache', '_reverse_cache')
name: str name: str
""" """
The structs fully qualified name The name of the type constructor
""" """
members: Dict[str, Type3] classes: Set[Type3Class]
""" """
The struct's field definitions The type classes that this constructor implements
""" """
def __init__(self, name: str, members: Dict[str, Type3]) -> None: type_classes: Set[Type3Class]
super().__init__(name, []) """
The type classes that the constructed types implement
"""
_cache: dict[str, Type3]
"""
When constructing a type with the same arguments,
it should produce the exact same result.
"""
_reverse_cache: dict[Type3, dict[str, Type3]]
"""
After construction you may need to look up the arguments
used for making the type
"""
def __init__(self, name: str, classes: Iterable[Type3Class], type_classes: Iterable[Type3Class]) -> None:
self.name = name self.name = name
self.members = dict(members) self.classes = set(classes)
self.type_classes = set(type_classes)
def __repr__(self) -> str: self._cache = {}
return f'StructType3(repr({self.name}), repr({self.members}))' self._reverse_cache = {}
none = PrimitiveType3('none', []) def did_construct(self, typ: Type3) -> dict[str, Type3] | None:
"""
Was the given type constructed by this constructor?
If so, which arguments where used?
"""
return self._reverse_cache.get(typ)
def __call__(self, name: str, args: dict[str, Type3], classes: Set[Type3Class]) -> Type3:
result = self._cache.get(name)
if result is not None:
raise Exception('Duplicate struct name detected')
self._cache[name] = result = Type3(name, classes | self.type_classes)
self._reverse_cache[result] = args
return result
none = Type3('none', [])
""" """
The none type, for when functions simply don't return anything. e.g., IO(). The none type, for when functions simply don't return anything. e.g., IO().
""" """
bool_ = PrimitiveType3('bool', []) bool_ = Type3('bool', [])
""" """
The bool type, either True or False The bool type, either True or False
Suffixes with an underscores, as it's a Python builtin Suffixes with an underscores, as it's a Python builtin
""" """
u8 = PrimitiveType3('u8', [Bits, Eq, Ord]) u8 = Type3('u8', [Bits, Eq, Ord])
""" """
The unsigned 8-bit integer type. The unsigned 8-bit integer type.
Operations on variables employ modular arithmetic, with modulus 2^8. Operations on variables employ modular arithmetic, with modulus 2^8.
""" """
u32 = PrimitiveType3('u32', [Bits, Eq, Integral, NatNum, Ord]) u32 = Type3('u32', [Bits, Eq, Integral, NatNum, Ord])
""" """
The unsigned 32-bit integer type. The unsigned 32-bit integer type.
Operations on variables employ modular arithmetic, with modulus 2^32. Operations on variables employ modular arithmetic, with modulus 2^32.
""" """
u64 = PrimitiveType3('u64', [Bits, Eq, Integral, NatNum, Ord]) u64 = Type3('u64', [Bits, Eq, Integral, NatNum, Ord])
""" """
The unsigned 64-bit integer type. The unsigned 64-bit integer type.
Operations on variables employ modular arithmetic, with modulus 2^64. Operations on variables employ modular arithmetic, with modulus 2^64.
""" """
i8 = PrimitiveType3('i8', [Eq, Ord]) i8 = Type3('i8', [Eq, Ord])
""" """
The signed 8-bit integer type. The signed 8-bit integer type.
@ -343,7 +324,7 @@ Operations on variables employ modular arithmetic, with modulus 2^8, but
with the middel point being 0. with the middel point being 0.
""" """
i32 = PrimitiveType3('i32', [Eq, Integral, IntNum, NatNum, Ord]) i32 = Type3('i32', [Eq, Integral, IntNum, NatNum, Ord])
""" """
The unsigned 32-bit integer type. The unsigned 32-bit integer type.
@ -351,7 +332,7 @@ Operations on variables employ modular arithmetic, with modulus 2^32, but
with the middel point being 0. with the middel point being 0.
""" """
i64 = PrimitiveType3('i64', [Eq, Integral, IntNum, NatNum, Ord]) i64 = Type3('i64', [Eq, Integral, IntNum, NatNum, Ord])
""" """
The unsigned 64-bit integer type. The unsigned 64-bit integer type.
@ -359,17 +340,17 @@ Operations on variables employ modular arithmetic, with modulus 2^64, but
with the middel point being 0. with the middel point being 0.
""" """
f32 = PrimitiveType3('f32', [Eq, Floating, Fractional, IntNum, NatNum, Ord]) f32 = Type3('f32', [Eq, Floating, Fractional, IntNum, NatNum, Ord])
""" """
A 32-bits IEEE 754 float, of 32 bits width. A 32-bits IEEE 754 float, of 32 bits width.
""" """
f64 = PrimitiveType3('f64', [Eq, Floating, Fractional, IntNum, NatNum, Ord]) f64 = Type3('f64', [Eq, Floating, Fractional, IntNum, NatNum, Ord])
""" """
A 32-bits IEEE 754 float, of 64 bits width. A 32-bits IEEE 754 float, of 64 bits width.
""" """
bytes_ = PrimitiveType3('bytes', []) bytes_ = Type3('bytes', [InternalPassAsPointer])
""" """
This is a runtime-determined length piece of memory that can be indexed at runtime. This is a runtime-determined length piece of memory that can be indexed at runtime.
""" """
@ -397,16 +378,10 @@ It should be applied with zero or more arguments. It has a compile time
determined length, and each argument can be different. determined length, and each argument can be different.
""" """
LOOKUP_TABLE: Dict[str, PrimitiveType3] = { struct = TypeConstructor_Struct('struct', [], [
'none': none, InternalPassAsPointer,
'bool': bool_, ])
'u8': u8, """
'u32': u32, This is like a tuple, but each argument is named, so that developers
'u64': u64, can get and set fields by name.
'i8': i8, """
'i32': i32,
'i64': i64,
'f32': f32,
'f64': f64,
'bytes': bytes_,
}

62
tests/integration/helpers.py
View File

@ -5,6 +5,7 @@ from typing import Any, Generator, Iterable, List, TextIO, Union
from phasm import compiler from phasm import compiler
from phasm.codestyle import phasm_render from phasm.codestyle import phasm_render
from phasm.runtime import calculate_alloc_size from phasm.runtime import calculate_alloc_size
from phasm.type3 import placeholders as type3placeholders
from phasm.type3 import typeclasses as type3classes from phasm.type3 import typeclasses as type3classes
from phasm.type3 import types as type3types from phasm.type3 import types as type3types
@ -65,7 +66,7 @@ class Suite:
runner.interpreter_dump_memory(sys.stderr) runner.interpreter_dump_memory(sys.stderr)
for arg, arg_typ in zip(args, func_args): for arg, arg_typ in zip(args, func_args):
assert not isinstance(arg_typ, type3types.PlaceholderForType), \ assert not isinstance(arg_typ, type3placeholders.PlaceholderForType), \
'Cannot call polymorphic function from outside' 'Cannot call polymorphic function from outside'
if arg_typ in (type3types.u8, type3types.u32, type3types.u64, ): if arg_typ in (type3types.u8, type3types.u32, type3types.u64, ):
@ -88,7 +89,7 @@ class Suite:
wasm_args.append(adr) wasm_args.append(adr)
continue continue
assert isinstance(arg_typ, type3types.PrimitiveType3) assert isinstance(arg_typ, type3types.Type3)
sa_args = type3types.static_array.did_construct(arg_typ) sa_args = type3types.static_array.did_construct(arg_typ)
if sa_args is not None: if sa_args is not None:
adr = _allocate_memory_stored_value(runner, arg_typ, arg) adr = _allocate_memory_stored_value(runner, arg_typ, arg)
@ -101,7 +102,8 @@ class Suite:
wasm_args.append(adr) wasm_args.append(adr)
continue continue
if isinstance(arg_typ, type3types.StructType3): st_args = type3types.struct.did_construct(arg_typ)
if st_args is not None:
adr = _allocate_memory_stored_value(runner, arg_typ, arg) adr = _allocate_memory_stored_value(runner, arg_typ, arg)
wasm_args.append(adr) wasm_args.append(adr)
continue continue
@ -150,12 +152,12 @@ def _write_memory_stored_value(
runner.interpreter_write_memory(adr, compiler.module_data_u32(adr2)) runner.interpreter_write_memory(adr, compiler.module_data_u32(adr2))
return 4 return 4
if isinstance(val_typ, type3types.StructType3): st_args = type3types.struct.did_construct(val_typ)
if st_args is not None:
adr2 = _allocate_memory_stored_value(runner, val_typ, val) adr2 = _allocate_memory_stored_value(runner, val_typ, val)
runner.interpreter_write_memory(adr, compiler.module_data_u32(adr2)) runner.interpreter_write_memory(adr, compiler.module_data_u32(adr2))
return 4 return 4
if isinstance(val_typ, type3types.PrimitiveType3):
sa_args = type3types.static_array.did_construct(val_typ) sa_args = type3types.static_array.did_construct(val_typ)
if sa_args is not None: if sa_args is not None:
adr2 = _allocate_memory_stored_value(runner, val_typ, val) adr2 = _allocate_memory_stored_value(runner, val_typ, val)
@ -172,8 +174,6 @@ def _write_memory_stored_value(
runner.interpreter_write_memory(adr, to_write) runner.interpreter_write_memory(adr, to_write)
return len(to_write) return len(to_write)
raise NotImplementedError(val_typ, val)
def _allocate_memory_stored_value( def _allocate_memory_stored_value(
runner: runners.RunnerBase, runner: runners.RunnerBase,
val_typ: type3types.Type3, val_typ: type3types.Type3,
@ -189,7 +189,6 @@ def _allocate_memory_stored_value(
runner.interpreter_write_memory(adr + 4, val) runner.interpreter_write_memory(adr + 4, val)
return adr return adr
assert isinstance(val_typ, type3types.PrimitiveType3)
sa_args = type3types.static_array.did_construct(val_typ) sa_args = type3types.static_array.did_construct(val_typ)
if sa_args is not None: if sa_args is not None:
assert isinstance(val, tuple) assert isinstance(val, tuple)
@ -224,12 +223,13 @@ def _allocate_memory_stored_value(
offset = adr offset = adr
for val_el_val, val_el_typ in zip(val, tp_args): for val_el_val, val_el_typ in zip(val, tp_args):
assert not isinstance(val_el_typ, type3types.PlaceholderForType) assert not isinstance(val_el_typ, type3placeholders.PlaceholderForType)
offset += _write_memory_stored_value(runner, offset, val_el_typ, val_el_val) offset += _write_memory_stored_value(runner, offset, val_el_typ, val_el_val)
return adr return adr
if isinstance(val_typ, type3types.StructType3): st_args = type3types.struct.did_construct(val_typ)
if st_args is not None:
assert isinstance(val, dict) assert isinstance(val, dict)
alloc_size = calculate_alloc_size(val_typ) alloc_size = calculate_alloc_size(val_typ)
@ -237,11 +237,11 @@ def _allocate_memory_stored_value(
assert isinstance(adr, int) assert isinstance(adr, int)
sys.stderr.write(f'Allocation 0x{adr:08x} {repr(val)}\n') sys.stderr.write(f'Allocation 0x{adr:08x} {repr(val)}\n')
assert list(val.keys()) == list(val_typ.members.keys()) assert list(val.keys()) == list(st_args)
offset = adr offset = adr
for val_el_name, val_el_typ in val_typ.members.items(): for val_el_name, val_el_typ in st_args.items():
assert not isinstance(val_el_typ, type3types.PlaceholderForType) assert not isinstance(val_el_typ, type3placeholders.PlaceholderForType)
val_el_val = val[val_el_name] val_el_val = val[val_el_name]
offset += _write_memory_stored_value(runner, offset, val_el_typ, val_el_val) offset += _write_memory_stored_value(runner, offset, val_el_typ, val_el_val)
@ -293,7 +293,7 @@ def _load_memory_stored_returned_value(
return _load_bytes_from_address(runner, ret_type3, wasm_value) return _load_bytes_from_address(runner, ret_type3, wasm_value)
assert isinstance(ret_type3, type3types.PrimitiveType3) # Type hint assert isinstance(ret_type3, type3types.Type3) # Type hint
sa_args = type3types.static_array.did_construct(ret_type3) sa_args = type3types.static_array.did_construct(ret_type3)
if sa_args is not None: if sa_args is not None:
@ -307,8 +307,9 @@ def _load_memory_stored_returned_value(
return _load_tuple_from_address(runner, tp_args, wasm_value) return _load_tuple_from_address(runner, tp_args, wasm_value)
if isinstance(ret_type3, type3types.StructType3): st_args = type3types.struct.did_construct(ret_type3)
return _load_struct_from_address(runner, ret_type3, wasm_value) if st_args is not None:
return _load_struct_from_address(runner, st_args, wasm_value)
raise NotImplementedError(ret_type3, wasm_value) raise NotImplementedError(ret_type3, wasm_value)
@ -359,7 +360,7 @@ def _unpack(runner: runners.RunnerBase, typ: type3types.Type3, inp: bytes) -> An
assert len(inp) == 4 assert len(inp) == 4
adr = struct.unpack('<I', inp)[0] adr = struct.unpack('<I', inp)[0]
assert isinstance(typ, type3types.PrimitiveType3) assert isinstance(typ, type3types.Type3)
sa_args = type3types.static_array.did_construct(typ) sa_args = type3types.static_array.did_construct(typ)
if sa_args is not None: if sa_args is not None:
@ -370,12 +371,13 @@ def _unpack(runner: runners.RunnerBase, typ: type3types.Type3, inp: bytes) -> An
if tp_args is not None: if tp_args is not None:
return _load_tuple_from_address(runner, tp_args, adr) return _load_tuple_from_address(runner, tp_args, adr)
if isinstance(typ, type3types.StructType3): st_args = type3types.struct.did_construct(typ)
if st_args is not None:
# Note: For structs, inp should contain a 4 byte pointer # Note: For structs, inp should contain a 4 byte pointer
assert len(inp) == 4 assert len(inp) == 4
adr = struct.unpack('<I', inp)[0] adr = struct.unpack('<I', inp)[0]
return _load_struct_from_address(runner, typ, adr) return _load_struct_from_address(runner, st_args, adr)
raise NotImplementedError(typ, inp) raise NotImplementedError(typ, inp)
@ -393,10 +395,10 @@ def _split_read_bytes(all_bytes: bytes, split_sizes: Iterable[int]) -> Generator
yield all_bytes[offset:offset + size] yield all_bytes[offset:offset + size]
offset += size offset += size
def _load_static_array_from_address(runner: runners.RunnerBase, sub_typ: type3types.PrimitiveType3, len_typ: type3types.IntType3, adr: int) -> Any: def _load_static_array_from_address(runner: runners.RunnerBase, sub_typ: type3types.Type3, len_typ: type3types.IntType3, adr: int) -> Any:
sys.stderr.write(f'Reading 0x{adr:08x} {sub_typ:s} {len_typ:s}\n') sys.stderr.write(f'Reading 0x{adr:08x} {sub_typ:s} {len_typ:s}\n')
assert not isinstance(sub_typ, type3types.PlaceholderForType) assert not isinstance(sub_typ, type3placeholders.PlaceholderForType)
assert isinstance(len_typ, type3types.IntType3) assert isinstance(len_typ, type3types.IntType3)
sa_len = len_typ.value sa_len = len_typ.value
@ -411,7 +413,7 @@ def _load_static_array_from_address(runner: runners.RunnerBase, sub_typ: type3ty
for arg_bytes in _split_read_bytes(read_bytes, arg_sizes) for arg_bytes in _split_read_bytes(read_bytes, arg_sizes)
) )
def _load_tuple_from_address(runner: runners.RunnerBase, typ_args: tuple[type3types.PrimitiveType3, ...], adr: int) -> Any: def _load_tuple_from_address(runner: runners.RunnerBase, typ_args: tuple[type3types.Type3, ...], adr: int) -> Any:
sys.stderr.write(f'Reading 0x{adr:08x} tuple {len(typ_args)}\n') sys.stderr.write(f'Reading 0x{adr:08x} tuple {len(typ_args)}\n')
arg_sizes = [ arg_sizes = [
@ -426,19 +428,13 @@ def _load_tuple_from_address(runner: runners.RunnerBase, typ_args: tuple[type3ty
for arg_typ, arg_bytes in zip(typ_args, _split_read_bytes(read_bytes, arg_sizes)) for arg_typ, arg_bytes in zip(typ_args, _split_read_bytes(read_bytes, arg_sizes))
) )
def _load_struct_from_address(runner: runners.RunnerBase, typ: type3types.Type3, adr: int) -> Any: def _load_struct_from_address(runner: runners.RunnerBase, st_args: dict[str, type3types.Type3], adr: int) -> Any:
sys.stderr.write(f'Reading 0x{adr:08x} {typ:s}\n') sys.stderr.write(f'Reading 0x{adr:08x} struct {list(st_args)}\n')
assert isinstance(typ, type3types.StructType3) name_list = list(st_args)
name_list = list(typ.members) typ_list = list(st_args.values())
assert len(typ_list) == len(st_args)
typ_list = [
x
for x in typ.members.values()
if not isinstance(x, type3types.PlaceholderForType)
]
assert len(typ_list) == len(typ.members)
arg_sizes = [ arg_sizes = [
calculate_alloc_size(x, is_member=True) calculate_alloc_size(x, is_member=True)