sonolus.py 0.10.7__py3-none-any.whl → 0.12.5__py3-none-any.whl

sonolus/backend/finalize.py

@@ -1,7 +1,7 @@
 from math import isfinite, isinf, isnan
 
 from sonolus.backend.ir import IRConst, IRGet, IRInstr, IRPureInstr, IRSet
-from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
+from sonolus.backend.node import EngineNode, FunctionNode
 from sonolus.backend.ops import Op
 from sonolus.backend.optimize.flow import BasicBlock, traverse_cfg_reverse_postorder
 from sonolus.backend.place import BlockPlace
@@ -18,18 +18,18 @@ def cfg_to_engine_node(entry: BasicBlock):
         }
         match outgoing:
             case {**other} if not other:
-                statements.append(ConstantNode(value=len(block_indexes)))
+                statements.append(len(block_indexes))
             case {None: target, **other} if not other:
-                statements.append(ConstantNode(value=block_indexes[target]))
+                statements.append(block_indexes[target])
             case {0: f_branch, None: t_branch, **other} if not other:
                 statements.append(
                     FunctionNode(
                         func=Op.If,
-                        args=[
+                        args=(
                             ir_to_engine_node(block.test),
-                            ConstantNode(value=block_indexes[t_branch]),
-                            ConstantNode(value=block_indexes[f_branch]),
-                        ],
+                            block_indexes[t_branch],
+                            block_indexes[f_branch],
+                        ),
                     )
                 )
             case {None: default_branch, **other} if len(other) == 1:
@@ -37,11 +37,11 @@ def cfg_to_engine_node(entry: BasicBlock):
                 statements.append(
                     FunctionNode(
                         func=Op.If,
-                        args=[
+                        args=(
                             ir_to_engine_node(IRPureInstr(Op.Equal, args=[block.test, IRConst(cond)])),
-                            ConstantNode(value=block_indexes[cond_branch]),
-                            ConstantNode(value=block_indexes[default_branch]),
-                        ],
+                            block_indexes[cond_branch],
+                            block_indexes[default_branch],
+                        ),
                     )
                 )
             case dict() as targets:
@@ -49,23 +49,31 @@ def cfg_to_engine_node(entry: BasicBlock):
                 default = len(block_indexes)
                 conds = [cond for cond in targets if cond is not None]
                 if min(conds) == 0 and max(conds) == len(conds) - 1 and all(int(cond) == cond for cond in conds):
-                    args.extend(ConstantNode(value=block_indexes[targets[cond]]) for cond in range(len(conds)))
+                    args.extend(block_indexes[targets[cond]] for cond in range(len(conds)))
                     if None in targets:
                         default = block_indexes[targets[None]]
-                    args.append(ConstantNode(value=default))
-                    statements.append(FunctionNode(Op.SwitchIntegerWithDefault, args))
+                    args.append(default)
+                    statements.append(FunctionNode(Op.SwitchIntegerWithDefault, tuple(args)))
                 else:
                     for cond, target in targets.items():
                         if cond is None:
                             default = block_indexes[target]
                             continue
-                        args.append(ConstantNode(value=cond))
-                        args.append(ConstantNode(value=block_indexes[target]))
-                    args.append(ConstantNode(value=default))
-                    statements.append(FunctionNode(Op.SwitchWithDefault, args))
-        block_statements.append(FunctionNode(Op.Execute, statements))
-    block_statements.append(ConstantNode(value=0))
-    return FunctionNode(Op.Block, [FunctionNode(Op.JumpLoop, block_statements)])
+                        args.append(cond)
+                        args.append(block_indexes[target])
+                    args.append(default)
+                    statements.append(FunctionNode(Op.SwitchWithDefault, tuple(args)))
+        block_statements.append(FunctionNode(Op.Execute, tuple(statements)))
+    block_statements.append(0)
+    result = FunctionNode(Op.Block, (FunctionNode(Op.JumpLoop, tuple(block_statements)),))
+    for block in block_indexes:
+        # Clean up without relying on gc
+        del block.incoming
+        del block.outgoing
+        del block.phis
+        del block.statements
+        del block.test
+    return result
 
 
 def ir_to_engine_node(stmt) -> EngineNode:
@@ -73,32 +81,30 @@ def ir_to_engine_node(stmt) -> EngineNode:
         case int(value) | float(value) | IRConst(value=int(value) | float(value)):
             value = float(value)
             if value.is_integer():
-                return ConstantNode(value=int(value))
+                return int(value)
             elif isfinite(value):
-                return ConstantNode(value=value)
+                return value
             elif isinf(value):
                 # Read values from ROM
-                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=1 if value > 0 else 2)])
+                return FunctionNode(Op.Get, args=(3000, 1 if value > 0 else 2))
             elif isnan(value):
                 # Read value from ROM
-                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=0)])
+                return FunctionNode(Op.Get, args=(3000, 0))
             else:
                 raise ValueError(f"Invalid constant value: {value}")
         case IRPureInstr(op=op, args=args) | IRInstr(op=op, args=args):
-            return FunctionNode(func=op, args=[ir_to_engine_node(arg) for arg in args])
+            return FunctionNode(func=op, args=tuple(ir_to_engine_node(arg) for arg in args))
         case IRGet(place=place):
             return ir_to_engine_node(place)
         case BlockPlace() as place:
             if place.offset == 0:
                 index = ir_to_engine_node(place.index)
             elif place.index == 0:
-                index = ConstantNode(value=place.offset)
+                index = place.offset
             else:
-                index = FunctionNode(
-                    func=Op.Add, args=[ir_to_engine_node(place.index), ConstantNode(value=place.offset)]
-                )
-            return FunctionNode(func=Op.Get, args=[ir_to_engine_node(place.block), index])
+                index = FunctionNode(func=Op.Add, args=(ir_to_engine_node(place.index), place.offset))
+            return FunctionNode(func=Op.Get, args=(ir_to_engine_node(place.block), index))
         case IRSet(place=place, value=value):
-            return FunctionNode(func=Op.Set, args=[*ir_to_engine_node(place).args, ir_to_engine_node(value)])
+            return FunctionNode(func=Op.Set, args=(*ir_to_engine_node(place).args, ir_to_engine_node(value)))
         case _:
             raise TypeError(f"Unsupported IR statement: {stmt}")

sonolus/backend/interpret.py

@@ -2,7 +2,7 @@ import math
 import operator
 import random
 
-from sonolus.backend.node import ConstantNode, EngineNode
+from sonolus.backend.node import EngineNode, FunctionNode
 from sonolus.backend.ops import Op
 
 
@@ -24,8 +24,8 @@ class Interpreter:
         self.log = []
 
     def run(self, node: EngineNode) -> float:
-        if isinstance(node, ConstantNode):
-            return node.value
+        if not isinstance(node, FunctionNode):
+            return node
         func = node.func
         args = node.args
         match func:

sonolus/backend/node.py

@@ -1,40 +1,18 @@
 import textwrap
-from dataclasses import dataclass, field
+from typing import NamedTuple
 
 from sonolus.backend.ops import Op
 
-type EngineNode = ConstantNode | FunctionNode
+type EngineNode = int | float | FunctionNode
 
 
-@dataclass(slots=True)
-class ConstantNode:
-    value: float
-    _hash: int = field(init=False, repr=False)
-
-    def __post_init__(self):
-        self._hash = hash(self.value)
-
-    def __hash__(self):
-        return hash(self.value)
-
-
-@dataclass(slots=True)
-class FunctionNode:
+class FunctionNode(NamedTuple):
     func: Op
-    args: list[EngineNode]
-    _hash: int = field(init=False, repr=False)
-
-    def __post_init__(self):
-        self._hash = hash((self.func, tuple(self.args)))
-
-    def __hash__(self):
-        return self._hash
+    args: tuple[EngineNode, ...]
 
 
 def format_engine_node(node: EngineNode) -> str:
-    if isinstance(node, ConstantNode):
-        return str(node.value)
-    elif isinstance(node, FunctionNode):
+    if isinstance(node, FunctionNode):
         match len(node.args):
             case 0:
                 return f"{node.func.name}()"
@@ -45,4 +23,4 @@ def format_engine_node(node: EngineNode) -> str:
                     textwrap.indent('\n'.join(format_engine_node(arg) for arg in node.args), '  ')
                 }\n)"
     else:
-        raise ValueError(f"Invalid engine node: {node}")
+        return str(node)

sonolus/backend/optimize/liveness.py

@@ -24,15 +24,18 @@ class LivenessAnalysis(CompilerPass):
             block.live_phi_targets = set()
             block.array_defs_in = set()
             block.array_defs_out = None
+            last_live_set = set()
             for statement in block.statements:
-                statement.live = set()
+                if isinstance(statement, IRSet):
+                    last_live_set = set()
+                statement.live = last_live_set
                 statement.visited = False
                 statement.uses = self.get_uses(statement, set())
                 statement.defs = self.get_defs(statement)
                 statement.is_array_init = False  # True if this may be the first assignment to an array
                 statement.array_defs = self.get_array_defs(statement)
             if not isinstance(block.test, IRConst):
-                block.test.live = set()
+                block.test.live = last_live_set
                 block.test.uses = self.get_uses(block.test, set())
         self.preprocess_arrays(entry)
 

sonolus/backend/visitor.py

@@ -319,7 +319,6 @@ class Visitor(ast.NodeVisitor):
             with using_ctx(before_ctx):
                 state_var._set_(0)
             with using_ctx(return_ctx):
-                state_var._set_(len(self.return_ctxs) + 1)
                 is_present_var._set_(0)
             del before_ctx.outgoing[None]  # Unlink the state machine body from the call site
             entry = before_ctx.new_empty_disconnected()
@@ -1007,7 +1006,9 @@ class Visitor(ast.NodeVisitor):
         return validate_value({self.visit(k): self.visit(v) for k, v in zip(node.keys, node.values, strict=True)})
 
     def visit_Set(self, node):
-        raise NotImplementedError("Set literals are not supported")
+        from sonolus.script.containers import FrozenNumSet
+
+        return self.handle_call(node, FrozenNumSet.of, *(self.visit(elt) for elt in node.elts))
 
     def visit_ListComp(self, node):
         raise NotImplementedError("List comprehensions are not supported")
@@ -1307,6 +1308,7 @@ class Visitor(ast.NodeVisitor):
         raise NotImplementedError(f"Unsupported syntax: {type(node).__name__}")
 
     def handle_getattr(self, node: ast.stmt | ast.expr, target: Value, key: str) -> Value:
+        # If this is changed, remember to update the getattr impl too
         with self.reporting_errors_at_node(node):
             if isinstance(target, ConstantValue):
                 # Unwrap so we can access fields
@@ -1327,6 +1329,7 @@ class Visitor(ast.NodeVisitor):
                     raise TypeError(f"Unsupported field or descriptor {key}")
 
     def handle_setattr(self, node: ast.stmt | ast.expr, target: Value, key: str, value: Value):
+        # If this is changed, remember to update the setattr impl too
         with self.reporting_errors_at_node(node):
             if target._is_py_():
                 target = target._as_py_()

sonolus/build/cli.py

@@ -1,4 +1,5 @@
 import argparse
+import gc
 import importlib
 import json
 import shutil
@@ -129,6 +130,7 @@ def get_config(args: argparse.Namespace) -> BuildConfig:
         build_preview=build_preview,
         build_tutorial=build_tutorial,
         runtime_checks=get_runtime_checks(args),
+        verbose=hasattr(args, "verbose") and args.verbose,
     )
 
 
@@ -164,12 +166,18 @@ def main():
             help="Runtime error checking mode (default: none for build, notify for dev)",
         )
 
+        gc_group = parser.add_mutually_exclusive_group()
+        gc_group.add_argument("--no-gc", action="store_true", default=True, help="Disable garbage collection (default)")
+        gc_group.add_argument("--gc", action="store_true", help="Enable garbage collection")
+
         build_components = parser.add_argument_group("build components")
         build_components.add_argument("--play", action="store_true", help="Build play component")
         build_components.add_argument("--watch", action="store_true", help="Build watch component")
         build_components.add_argument("--preview", action="store_true", help="Build preview component")
         build_components.add_argument("--tutorial", action="store_true", help="Build tutorial component")
 
+        parser.add_argument("-v", "--verbose", action="store_true", help="Enable verbose output")
+
     build_parser = subparsers.add_parser("build")
     build_parser.add_argument(
         "module",
@@ -219,6 +227,12 @@ def main():
         else:
             parser.error("Module argument is required when multiple or no modules are found")
 
+    if args.command in {"build", "check", "dev"}:
+        if hasattr(args, "gc") and args.gc:
+            gc.enable()
+        elif hasattr(args, "no_gc") and args.no_gc:
+            gc.disable()
+
     if no_gil():
         print("Multithreading is enabled")
     if hasattr(sys, "_jit") and sys._jit.is_enabled():
@@ -254,5 +268,9 @@ def main():
             end_time = perf_counter()
             print(f"Project validation completed successfully in {end_time - start_time:.2f}s")
     except CompilationError:
+        if args.verbose:
+            raise
         exc_info = sys.exc_info()
         print_simple_traceback(*exc_info)
+        print("\nFor more details, run with the --verbose (-v) flag.")
+        sys.exit(1)

sonolus/build/compile.py

@@ -32,9 +32,11 @@ class CompileCache:
         self._cache = {}
         self._lock = Lock()
         self._event = Event()
+        self._accessed_hashes = set()
 
     def get(self, entry_hash: int) -> EngineNode | None:
         with self._lock:
+            self._accessed_hashes.add(entry_hash)
             if entry_hash not in self._cache:
                 self._cache[entry_hash] = None  # Mark as being compiled
                 return None
@@ -47,10 +49,21 @@ class CompileCache:
 
     def set(self, entry_hash: int, node: EngineNode) -> None:
         with self._lock:
+            self._accessed_hashes.add(entry_hash)
             self._cache[entry_hash] = node
             self._event.set()
             self._event.clear()
 
+    def reset_accessed(self) -> None:
+        with self._lock:
+            self._accessed_hashes.clear()
+
+    def prune_unaccessed(self) -> None:
+        with self._lock:
+            unaccessed_hashes = set(self._cache.keys()) - self._accessed_hashes
+            for h in unaccessed_hashes:
+                del self._cache[h]
+
 
 def compile_mode(
     mode: Mode,
@@ -67,7 +80,7 @@ def compile_mode(
 
     mode_state = ModeContextState(
         mode,
-        {a: i for i, a in enumerate(archetypes)} if archetypes is not None else None,
+        archetypes,
     )
     nodes = OutputNodeGenerator()
     results = {}
@@ -134,9 +147,10 @@ def compile_mode(
                 archetype_data["exports"] = [*archetype._exported_keys_]
 
             callback_items = [
-                (cb_name, cb_info, getattr(archetype, cb_name))
+                (cb_name, cb_info, archetype._callbacks_[cb_name])
                 for cb_name, cb_info in archetype._supported_callbacks_.items()
-                if getattr(archetype, cb_name) not in archetype._default_callbacks_
+                if cb_name in archetype._callbacks_
+                and archetype._callbacks_[cb_name] not in archetype._default_callbacks_
             ]
 
             if thread_pool is not None:

sonolus/build/dev_server.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 import argparse
 import contextlib
+import gc
 import http.server
 import importlib
 import queue
@@ -118,6 +119,7 @@ class RebuildCommand:
         print("Rebuilding...")
         try:
             start_time = perf_counter()
+            server_state.cache.reset_accessed()
             server_state.project_state = ProjectContextState.from_build_config(server_state.config)
             server_state.project = project_module.project
             build_collection(
@@ -127,11 +129,16 @@ class RebuildCommand:
                 cache=server_state.cache,
                 project_state=server_state.project_state,
             )
+            server_state.cache.prune_unaccessed()
             end_time = perf_counter()
             print(f"Rebuild completed in {end_time - start_time:.2f} seconds")
         except CompilationError:
             exc_info = sys.exc_info()
-            print_simple_traceback(*exc_info)
+            if server_state.config.verbose:
+                print(traceback.format_exc())
+            else:
+                print_simple_traceback(*exc_info)
+                print("\nFor more details, run with the --verbose (-v) flag.")
 
 
 @dataclass
@@ -331,6 +338,7 @@ def run_server(
                     cmd = command_queue.get()
                     try:
                         cmd.execute(server_state)
+                        gc.collect()
                     except Exception:
                         print(f"{traceback.format_exc()}\n")
                     prompt_event.set()

sonolus/build/node.py

@@ -1,7 +1,7 @@
 from threading import Lock
 from typing import TypedDict
 
-from sonolus.backend.node import ConstantNode, EngineNode, FunctionNode
+from sonolus.backend.node import EngineNode, FunctionNode
 
 
 class ValueOutputNode(TypedDict):
@@ -32,19 +32,17 @@ class OutputNodeGenerator:
             return self.indexes[node]
 
         match node:
-            case ConstantNode(value):
-                index = len(self.nodes)
-                self.nodes.append({"value": value})
-                self.indexes[node] = index
-                return index
             case FunctionNode(func, args):
                 arg_indexes = [self._add(arg) for arg in args]
                 index = len(self.nodes)
                 self.nodes.append({"func": func.value, "args": arg_indexes})
                 self.indexes[node] = index
                 return index
-            case _:
-                raise ValueError("Invalid node")
+            case constant:
+                index = len(self.nodes)
+                self.nodes.append({"value": constant})
+                self.indexes[node] = index
+                return index
 
     def get(self):
         return self.nodes