sonolus.py 0.1.8__tar.gz → 0.2.0__tar.gz

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/PKG-INFO

@@ -1,7 +1,8 @@
-Metadata-Version: 2.3
+Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.1.8
+Version: 0.2.0
 Summary: Sonolus engine development in Python
+License-File: LICENSE
 Requires-Python: >=3.12
 Description-Content-Type: text/markdown
 

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/doc_stubs/builtins.pyi

@@ -9,6 +9,28 @@ from typing import (
     overload,
 )
 
+def all(iterable: Iterable[builtins.bool]) -> builtins.bool:
+    """Return True if all elements of the iterable are true.
+
+    Args:
+        iterable: The iterable to evaluate.
+
+    Returns:
+        True if all elements are true, False otherwise.
+    """
+    ...
+
+def any(iterable: Iterable[builtins.bool]) -> builtins.bool:
+    """Return True if any element of the iterable is true.
+
+    Args:
+        iterable: The iterable to evaluate.
+
+    Returns:
+        True if any element is true, False otherwise.
+    """
+    ...
+
 def abs(x: builtins.int | builtins.float) -> builtins.int | builtins.float:
     """Return the absolute value of a number.
 

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/docs/concepts/resources.md

@@ -4,11 +4,13 @@
 Skins are defined with the `@skin` decorator:
 
 ```python
-from sonolus.script.sprite import skin, StandardSprite, sprite, Sprite
+from sonolus.script.sprite import skin, StandardSprite, sprite, Sprite, RenderMode
 
 
 @skin
 class Skin:
+    render_mode: RenderMode = RenderMode.DEFAULT
+
     note: StandardSprite.NOTE_HEAD_RED
     other: Sprite = sprite("other")
 ```
@@ -17,6 +19,8 @@ Standard sprites are defined by annotating the field with the corresponding valu
 
 Custom sprites are defined by annotating the field with `Sprite` and calling `skin_sprite` with the sprite name.
 
+To set the render mode for the skin, set the `render_mode` field to the desired value from `RenderMode`.
+
 ## Sound Effects
 Sound effects are defined with the `@effects` decorator:
 

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/docs/concepts/types.md

@@ -242,6 +242,20 @@ assert not isinstance(a, Array[int, 2])
 assert not isinstance(a, Array[Pair, 3])
 ```
 
+### Enums
+
+There is limited support for enums containing `Num` values. Methods on enums are not supported. 
+When used as a type, any enum class is treated as `Num` and no enforcement is done on the values.
+
+```python
+class MyEnum(IntEnum):
+    A = 1
+    B = 2
+    
+a = Array[MyEnum, 2](MyEnum.A, MyEnum.B)
+b = Array[MyEnum, 2](1, 2)
+```
+
 ## Record
 
 `Record` is the base class for user-defined types in Sonolus.py. It functions similarly to dataclasses.

sonolus_py-0.2.0/docs/reference/sonolus.script.metadata.md

@@ -0,0 +1,3 @@
+# sonolus.script.metadata
+
+::: sonolus.script.metadata

sonolus_py-0.2.0/docs/reference/sonolus.script.printing.md

@@ -0,0 +1,3 @@
+# sonolus.script.printing
+
+::: sonolus.script.printing

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/mkdocs.yml

@@ -96,10 +96,11 @@ nav:
       - reference/sonolus.script.interval.md
       - reference/sonolus.script.iterator.md
       - reference/sonolus.script.level.md
+      - reference/sonolus.script.metadata.md
       - reference/sonolus.script.num.md
       - reference/sonolus.script.options.md
       - reference/sonolus.script.particle.md
-      - reference/sonolus.script.print.md
+      - reference/sonolus.script.printing.md
       - reference/sonolus.script.project.md
       - reference/sonolus.script.quad.md
       - reference/sonolus.script.record.md

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.1.8"
+version = "0.2.0"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.12"

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/sonolus/backend/finalize.py

@@ -42,6 +42,7 @@ def cfg_to_engine_node(entry: BasicBlock):
                     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))
@@ -55,7 +56,7 @@ def ir_to_engine_node(stmt) -> EngineNode:
     match stmt:
         case int() | float():
             return ConstantNode(value=float(stmt))
-        case IRConst(value=value):
+        case IRConst(value=int(value) | float(value)):
             return ConstantNode(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])

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/sonolus/backend/optimize/constant_evaluation.py

@@ -315,8 +315,8 @@ class SparseConditionalConstantPropagation(CompilerPass):
                             return 1
                         return functools.reduce(operator.pow, args)
                     case Op.Log:
-                        assert len(args) == 2
-                        return math.log(args[0], args[1])
+                        assert len(args) == 1
+                        return math.log(args[0])
                     case Op.Ceil:
                         assert len(args) == 1
                         return math.ceil(args[0])

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/sonolus/backend/optimize/copy_coalesce.py

@@ -39,20 +39,29 @@ class CopyCoalesce(CompilerPass):
         interference = self.get_interference(entry)
         copies = self.get_copies(entry)
 
-        mapping = {}
+        mapping: dict[TempBlock, set[TempBlock]] = {}
 
         for target, sources in copies.items():
             for source in sources:
-                if source in mapping:
-                    continue
                 if source in interference.get(target, set()):
                     continue
-                mapping[source] = mapping.get(target, target)
+                combined_mapping = mapping.get(target, {target}) | mapping.get(source, {source})
                 combined_interference = interference.get(target, set()) | interference.get(source, set())
-                interference[source] = combined_interference
-                interference[target] = combined_interference
+                for place in combined_mapping:
+                    mapping[place] = combined_mapping
+                    interference[place] = combined_interference
+                for place in combined_interference:
+                    interference[place].update(combined_mapping)
+
+        canonical_mapping = {}
+        for place, group in mapping.items():
+            if place in canonical_mapping:
+                continue
+            canonical = min(group)
+            for member in group:
+                canonical_mapping[member] = canonical
 
-        return mapping
+        return canonical_mapping
 
     def get_interference(self, entry: BasicBlock) -> dict[TempBlock, set[TempBlock]]:
         result = {}

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/sonolus/backend/optimize/optimize.py

@@ -12,13 +12,21 @@ from sonolus.backend.optimize.passes import run_passes
 from sonolus.backend.optimize.simplify import CoalesceFlow, NormalizeSwitch, RewriteToSwitch
 from sonolus.backend.optimize.ssa import FromSSA, ToSSA
 
-MINIMAL_PASSES = [
+MINIMAL_PASSES = (
     CoalesceFlow(),
     UnreachableCodeElimination(),
     AllocateBasic(),
-]
+)
 
-STANDARD_PASSES = [
+FAST_PASSES = (
+    CoalesceFlow(),
+    UnreachableCodeElimination(),
+    AdvancedDeadCodeElimination(),
+    CoalesceFlow(),
+    Allocate(),
+)
+
+STANDARD_PASSES = (
     CoalesceFlow(),
     UnreachableCodeElimination(),
     DeadCodeElimination(),
@@ -37,7 +45,7 @@ STANDARD_PASSES = [
     CoalesceFlow(),
     NormalizeSwitch(),
     Allocate(),
-]
+)
 
 
 def optimize_and_allocate(cfg: BasicBlock):

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/sonolus/backend/optimize/passes.py

@@ -2,6 +2,7 @@ from __future__ import annotations
 
 from abc import ABC, abstractmethod
 from collections import deque
+from collections.abc import Sequence
 
 from sonolus.backend.optimize.flow import BasicBlock
 
@@ -35,7 +36,7 @@ class CompilerPass(ABC):
         pass
 
 
-def run_passes(entry: BasicBlock, passes: list[CompilerPass]) -> BasicBlock:
+def run_passes(entry: BasicBlock, passes: Sequence[CompilerPass]) -> BasicBlock:
     active_passes = set()
     queue = deque(passes)
     while queue:

sonolus_py-0.2.0/sonolus/backend/place.py

@@ -0,0 +1,163 @@
+from collections.abc import Iterator
+from typing import Self
+
+from sonolus.backend.blocks import Block
+
+type Place = BlockPlace | SSAPlace
+type BlockValue = Block | int | TempBlock | Place
+type IndexValue = int | Place
+
+
+class TempBlock:
+    __slots__ = ("__hash", "name", "size")
+
+    def __init__(self, name: str, size: int = 1):
+        self.name = name
+        self.size = size
+        self.__hash = hash(name)  # Precompute hash based on name alone
+
+    def __repr__(self):
+        return f"TempBlock(name={self.name!r}, size={self.size!r})"
+
+    def __str__(self):
+        return f"{self.name}"
+
+    def __getitem__(self, item) -> "BlockPlace":
+        return BlockPlace(self, item)
+
+    def __iter__(self) -> "Iterator[BlockPlace]":
+        for i in range(self.size):
+            yield self[i]
+
+    def __eq__(self, other):
+        return isinstance(other, TempBlock) and self.name == other.name and self.size == other.size
+
+    def __lt__(self, other):
+        if not isinstance(other, TempBlock):
+            return NotImplemented
+        return str(self) < str(other)
+
+    def __le__(self, other):
+        if not isinstance(other, TempBlock):
+            return NotImplemented
+        return str(self) <= str(other)
+
+    def __gt__(self, other):
+        if not isinstance(other, TempBlock):
+            return NotImplemented
+        return str(self) > str(other)
+
+    def __ge__(self, other):
+        if not isinstance(other, TempBlock):
+            return NotImplemented
+        return str(self) >= str(other)
+
+    def __hash__(self):
+        return self.__hash
+
+
+class BlockPlace:
+    __slots__ = ("__hash", "block", "index", "offset")
+
+    def __init__(self, block: BlockValue, index: IndexValue = 0, offset: int = 0):
+        self.block = block
+        self.index = index
+        self.offset = offset
+        self.__hash = hash((block, index, offset))
+
+    def __repr__(self):
+        return f"BlockPlace(block={self.block!r}, index={self.index!r}, offset={self.offset!r})"
+
+    def __str__(self):
+        if isinstance(self.block, TempBlock) and self.block.size == 1 and self.index == 0 and self.offset == 0:
+            return f"{self.block}"
+        elif isinstance(self.index, int):
+            return f"{self.block}[{self.index + self.offset}]"
+        elif self.offset == 0:
+            return f"{self.block}[{self.index}]"
+        else:
+            return f"{self.block}[{self.index} + {self.offset}]"
+
+    def add_offset(self, offset: int) -> Self:
+        return BlockPlace(self.block, self.index, self.offset + offset)
+
+    def __eq__(self, other):
+        return (
+            isinstance(other, BlockPlace)
+            and self.block == other.block
+            and self.index == other.index
+            and self.offset == other.offset
+        )
+
+    def __lt__(self, other):
+        if not isinstance(other, BlockPlace):
+            return NotImplemented
+        return str(self) < str(other)
+
+    def __le__(self, other):
+        if not isinstance(other, BlockPlace):
+            return NotImplemented
+        return str(self) <= str(other)
+
+    def __gt__(self, other):
+        if not isinstance(other, BlockPlace):
+            return NotImplemented
+        return str(self) > str(other)
+
+    def __ge__(self, other):
+        if not isinstance(other, BlockPlace):
+            return NotImplemented
+        return str(self) >= str(other)
+
+    def __hash__(self):
+        return self.__hash
+
+    def __iter__(self):
+        yield self.block
+        yield self.index
+        yield self.offset
+
+
+class SSAPlace:
+    __slots__ = ("__hash", "name", "num")
+
+    def __init__(self, name: str, num: int):
+        self.name = name
+        self.num = num
+        self.__hash = hash((name, num))
+
+    def __repr__(self):
+        return f"SSAPlace(name={self.name!r}, num={self.num!r})"
+
+    def __str__(self):
+        return f"{self.name}.{self.num}"
+
+    def __eq__(self, other):
+        return isinstance(other, SSAPlace) and self.name == other.name and self.num == other.num
+
+    def __lt__(self, other):
+        if not isinstance(other, SSAPlace):
+            return NotImplemented
+        return str(self) < str(other)
+
+    def __le__(self, other):
+        if not isinstance(other, SSAPlace):
+            return NotImplemented
+        return str(self) <= str(other)
+
+    def __gt__(self, other):
+        if not isinstance(other, SSAPlace):
+            return NotImplemented
+        return str(self) > str(other)
+
+    def __ge__(self, other):
+        if not isinstance(other, SSAPlace):
+            return NotImplemented
+        return str(self) >= str(other)
+
+    def __hash__(self):
+        return self.__hash
+
+    def __iter__(self):
+        yield self.name
+        yield self.num

{sonolus_py-0.1.8 → sonolus_py-0.2.0}/sonolus/backend/visitor.py

@@ -172,7 +172,9 @@ class Visitor(ast.NodeVisitor):
     bound_args: inspect.BoundArguments
     used_names: dict[str, int]
     return_ctxs: list[Context]  # Contexts at return statements, which will branch to the exit
-    loop_head_ctxs: list[Context]  # Contexts at loop heads, from outer to inner
+    loop_head_ctxs: list[
+        Context | list[Context]
+    ]  # Contexts at loop heads, from outer to inner. Contains a list for unrolled (tuple) loops
     break_ctxs: list[list[Context]]  # Contexts at break statements, from outer to inner
     active_ctx: Context | None  # The active context for use in nested functions=
     parent: Self | None  # The parent visitor for use in nested functions
@@ -203,6 +205,8 @@ class Visitor(ast.NodeVisitor):
             case ast.FunctionDef(body=body):
                 ctx().scope.set_value("$return", validate_value(None))
                 for stmt in body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
             case ast.Lambda(body=body):
                 result = self.visit(body)
@@ -318,11 +322,21 @@ class Visitor(ast.NodeVisitor):
         iterable = self.visit(node.iter)
         if isinstance(iterable, TupleImpl):
             # Unroll the loop
+            break_ctxs = []
             for value in iterable.value:
                 set_ctx(ctx().branch(None))
+                self.loop_head_ctxs.append([])
+                self.break_ctxs.append([])
                 self.handle_assign(node.target, validate_value(value))
                 for stmt in node.body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
+                continue_ctxs = [*self.loop_head_ctxs.pop(), ctx()]
+                break_ctxs.extend(self.break_ctxs.pop())
+                set_ctx(Context.meet(continue_ctxs))
+            if break_ctxs:
+                set_ctx(Context.meet([*break_ctxs, ctx()]))
             return
         iterator = self.handle_call(node, iterable.__iter__)
         if not isinstance(iterator, SonolusIterator):
@@ -335,7 +349,11 @@ class Visitor(ast.NodeVisitor):
         has_next = self.ensure_boolean_num(self.handle_call(node, iterator.has_next))
         if has_next._is_py_() and not has_next._as_py_():
             # The loop will never run, continue after evaluating the condition
+            self.loop_head_ctxs.pop()
+            self.break_ctxs.pop()
             for stmt in node.orelse:
+                if not ctx().live:
+                    break
                 self.visit(stmt)
             return
         ctx().test = has_next.ir()
@@ -345,16 +363,21 @@ class Visitor(ast.NodeVisitor):
         set_ctx(body_ctx)
         self.handle_assign(node.target, self.handle_call(node, iterator.next))
         for stmt in node.body:
+            if not ctx().live:
+                break
             self.visit(stmt)
         ctx().branch_to_loop_header(header_ctx)
 
+        self.loop_head_ctxs.pop()
+        break_ctxs = self.break_ctxs.pop()
+
         set_ctx(else_ctx)
         for stmt in node.orelse:
+            if not ctx().live:
+                break
             self.visit(stmt)
         else_end_ctx = ctx()
 
-        self.loop_head_ctxs.pop()
-        break_ctxs = self.break_ctxs.pop()
         after_ctx = Context.meet([else_end_ctx, *break_ctxs])
         set_ctx(after_ctx)
 
@@ -365,27 +388,55 @@ class Visitor(ast.NodeVisitor):
         self.break_ctxs.append([])
         set_ctx(header_ctx)
         test = self.ensure_boolean_num(self.visit(node.test))
-        if test._is_py_() and not test._as_py_():
-            # The loop will never run, continue after evaluating the condition
-            for stmt in node.orelse:
-                self.visit(stmt)
-            return
+        if test._is_py_():
+            if test._as_py_():
+                # The loop will run until a break / return
+                body_ctx = ctx().branch(None)
+                set_ctx(body_ctx)
+                for stmt in node.body:
+                    if not ctx().live:
+                        break
+                    self.visit(stmt)
+                ctx().branch_to_loop_header(header_ctx)
+
+                self.loop_head_ctxs.pop()
+                break_ctxs = self.break_ctxs.pop()
+
+                # Skip the else block
+
+                after_ctx = Context.meet([ctx().into_dead(), *break_ctxs])
+                set_ctx(after_ctx)
+                return
+            else:
+                # The loop will never run, continue after evaluating the condition
+                self.loop_head_ctxs.pop()
+                self.break_ctxs.pop()
+                for stmt in node.orelse:
+                    if not ctx().live:
+                        break
+                    self.visit(stmt)
+                return
         ctx().test = test.ir()
         body_ctx = ctx().branch(None)
         else_ctx = ctx().branch(0)
 
         set_ctx(body_ctx)
         for stmt in node.body:
+            if not ctx().live:
+                break
             self.visit(stmt)
         ctx().branch_to_loop_header(header_ctx)
 
+        self.loop_head_ctxs.pop()
+        break_ctxs = self.break_ctxs.pop()
+
         set_ctx(else_ctx)
         for stmt in node.orelse:
+            if not ctx().live:
+                break
             self.visit(stmt)
         else_end_ctx = ctx()
 
-        self.loop_head_ctxs.pop()
-        break_ctxs = self.break_ctxs.pop()
         after_ctx = Context.meet([else_end_ctx, *break_ctxs])
         set_ctx(after_ctx)
 
@@ -395,9 +446,13 @@ class Visitor(ast.NodeVisitor):
         if test._is_py_():
             if test._as_py_():
                 for stmt in node.body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
             else:
                 for stmt in node.orelse:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
             return
 
@@ -408,11 +463,15 @@ class Visitor(ast.NodeVisitor):
 
         set_ctx(true_ctx)
         for stmt in node.body:
+            if not ctx().live:
+                break
             self.visit(stmt)
         true_end_ctx = ctx()
 
         set_ctx(false_ctx)
         for stmt in node.orelse:
+            if not ctx().live:
+                break
             self.visit(stmt)
         false_end_ctx = ctx()
 
@@ -439,6 +498,8 @@ class Visitor(ast.NodeVisitor):
             if guard._is_py_():
                 if guard._as_py_():
                     for stmt in case.body:
+                        if not ctx().live:
+                            break
                         self.visit(stmt)
                     end_ctxs.append(ctx())
                 else:
@@ -450,6 +511,8 @@ class Visitor(ast.NodeVisitor):
                 guard_false_ctx = ctx().branch(0)
                 set_ctx(guard_true_ctx)
                 for stmt in case.body:
+                    if not ctx().live:
+                        break
                     self.visit(stmt)
                 end_ctxs.append(ctx())
                 false_ctx = Context.meet([false_ctx, guard_false_ctx])
@@ -610,7 +673,11 @@ class Visitor(ast.NodeVisitor):
         set_ctx(ctx().into_dead())
 
     def visit_Continue(self, node):
-        ctx().branch_to_loop_header(self.loop_head_ctxs[-1])
+        loop_head = self.loop_head_ctxs[-1]
+        if isinstance(loop_head, list):
+            loop_head.append(ctx())
+        else:
+            ctx().branch_to_loop_header(loop_head)
         set_ctx(ctx().into_dead())
 
     def visit_BoolOp(self, node) -> Value:
@@ -959,7 +1026,11 @@ class Visitor(ast.NodeVisitor):
             if isinstance(target, ConstantValue):
                 # Unwrap so we can access fields
                 target = target._as_py_()
-            descriptor = type(target).__dict__.get(key)
+            descriptor = None
+            for cls in type.mro(type(target)):
+                descriptor = cls.__dict__.get(key, None)
+                if descriptor is not None:
+                    break
             match descriptor:
                 case property(fget=getter):
                     return self.handle_call(node, getter, target)