sonolus.py 0.3.1__tar.gz → 0.3.3__tar.gz

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/.github/workflows/publish.yaml

@@ -13,16 +13,16 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v3
         with:
-          version: 0.5.2
+          version: 0.7.16
       - name: Install Python
         run: |
-          uv python install 3.12 3.13
+          uv python install 3.12 3.13 3.14
       - name: Install project
         run: |
           uv sync --all-extras --dev
       - name: Run tests
         run: |
-          uv run tox
+          CI=true uv run tox
       - name: Build
         run: |
           uv build

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/.gitignore

@@ -7,7 +7,7 @@ wheels/
 *.egg-info
 
 # Virtual environments
-.venv
+.venv*
 
 .idea/
 

sonolus_py-0.3.3/.python-version

@@ -0,0 +1 @@
+3.14.0b3t

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sonolus.py
-Version: 0.3.1
+Version: 0.3.3
 Summary: Sonolus engine development in Python
 License-File: LICENSE
 Requires-Python: >=3.12

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/docs/concepts/builtins.md

@@ -2,7 +2,7 @@
 Sonolus.py comes with support for a number of built-in functions.
 
 - `abs(x)`
-- `bool(object)` (for a num argument)
+- `bool(object)`
 - `callable(object)`
 - `enumerate(iterable, start=0)`
 - `filter(function, iterable)`
@@ -38,6 +38,10 @@ Sonolus.py also comes with support for some standard library modules.
 - `ceil(x)`
 - `trunc(x)`
 - `log(x[, base])`
+- `pi`
+- `e`
+- `tau`
+- `inf`
 
 ### random
 - `randrange(stop)`, `random.randrange(start, stop[, step])`

sonolus_py-0.3.3/docs/concepts/index.md

@@ -0,0 +1,6 @@
+# Concepts
+This section provides a reference for the concepts and features of Sonolus.py.
+
+It is not intended to serve as a tutorial or introduction, and assumes familiarity with Python and Sonolus.py.
+
+For information on how to get started with Sonolus.py, see the [home page](../index.md).

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/docs/concepts/project.md

@@ -80,9 +80,16 @@ play_mode = PlayMode(
 
 ```
 
-Play mode archetypes subclass [`PlayArchetype`][sonolus.script.archetype.PlayArchetype] and should implement the [`should_spawn`][sonolus.script.archetype.PlayArchetype.should_spawn] callback. They may also implement 
-the [`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess], [`spawn_order`][sonolus.script.archetype.PlayArchetype.spawn_order], [`initialize`][sonolus.script.archetype.PlayArchetype.initialize], [`update_sequential`][sonolus.script.archetype.PlayArchetype.update_sequential], [`update_parallel`][sonolus.script.archetype.PlayArchetype.update_parallel], [`touch`][sonolus.script.archetype.PlayArchetype.touch], and 
-[`terminate`][sonolus.script.archetype.PlayArchetype.terminate] callbacks.
+Play mode archetypes subclass [`PlayArchetype`][sonolus.script.archetype.PlayArchetype] and implement the following callbacks:
+
+- [`should_spawn`][sonolus.script.archetype.PlayArchetype.should_spawn] (required)
+- [`preprocess`][sonolus.script.archetype.PlayArchetype.preprocess]
+- [`spawn_order`][sonolus.script.archetype.PlayArchetype.spawn_order]
+- [`initialize`][sonolus.script.archetype.PlayArchetype.initialize]
+- [`update_sequential`][sonolus.script.archetype.PlayArchetype.update_sequential]
+- [`update_parallel`][sonolus.script.archetype.PlayArchetype.update_parallel]
+- [`touch`][sonolus.script.archetype.PlayArchetype.touch]
+- [`terminate`][sonolus.script.archetype.PlayArchetype.terminate]
 
 Archetypes for scored notes should have the [`is_scored`][sonolus.script.archetype.PlayArchetype.is_scored] class variable set to `True`.
 
@@ -110,9 +117,15 @@ watch_mode = WatchMode(
 )
 ```
 
-Watch mode archetypes subclass [`WatchArchetype`][sonolus.script.archetype.WatchArchetype] and should implement the [`spawn_time`][sonolus.script.archetype.WatchArchetype.spawn_time] and [`despawn_time`][sonolus.script.archetype.WatchArchetype.despawn_time] callbacks. 
-They may also implement the [`preprocess`][sonolus.script.archetype.WatchArchetype.preprocess], [`initialize`][sonolus.script.archetype.WatchArchetype.initialize], [`update_sequential`][sonolus.script.archetype.WatchArchetype.update_sequential], [`update_parallel`][sonolus.script.archetype.WatchArchetype.update_parallel], and 
-[`terminate`][sonolus.script.archetype.WatchArchetype.terminate] callbacks.
+Watch mode archetypes subclass [`WatchArchetype`][sonolus.script.archetype.WatchArchetype] and implement the following callbacks:
+
+- [`spawn_time`][sonolus.script.archetype.WatchArchetype.spawn_time] (required)
+- [`despawn_time`][sonolus.script.archetype.WatchArchetype.despawn_time] (required)
+- [`preprocess`][sonolus.script.archetype.WatchArchetype.preprocess]
+- [`initialize`][sonolus.script.archetype.WatchArchetype.initialize]
+- [`update_sequential`][sonolus.script.archetype.WatchArchetype.update_sequential]
+- [`update_parallel`][sonolus.script.archetype.WatchArchetype.update_parallel]
+- [`terminate`][sonolus.script.archetype.WatchArchetype.terminate]
 
 Watch mode also has the `update_spawn` global callback, which is invoked every frame and should return the reference
 time to compare against spawn and despawn times of archetypes. Typically, this can be either the current time or the
@@ -135,7 +148,10 @@ preview_mode = PreviewMode(
 )
 ```
 
-Preview mode archetypes subclass [`PreviewArchetype`][sonolus.script.archetype.PreviewArchetype] and may implement the [`preprocess`][sonolus.script.archetype.PreviewArchetype.preprocess] and [`render`][sonolus.script.archetype.PreviewArchetype.render] callbacks.
+Preview mode archetypes subclass [`PreviewArchetype`][sonolus.script.archetype.PreviewArchetype] and implement the following callbacks:
+
+- [`preprocess`][sonolus.script.archetype.PreviewArchetype.preprocess]
+- [`render`][sonolus.script.archetype.PreviewArchetype.render]
 
 ### Tutorial Mode
 
@@ -162,13 +178,11 @@ tutorial_mode = TutorialMode(
 )
 ```
 
-Tutorial mode does not have archetypes, but it has `preprocess`, `navigate`, and `update` global callbacks.
-
-`preprocess` is invoked once before the tutorial starts.
-
-`navigate` is invoked when the player navigates forward or backward in the tutorial.
+Tutorial mode does not have archetypes, but has the following global callbacks:
 
-`update` is invoked every frame and should handle most of the drawing logic.
+- `preprocess` - Invoked once before the tutorial starts
+- `navigate` - Invoked when the player navigates forward or backward in the tutorial  
+- `update` - Invoked every frame and should handle most of the drawing logic
 
 ## Levels
 Levels are defined using the [`Level`][sonolus.script.level.Level] class:

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/docs/concepts/resources.md

@@ -1,32 +1,133 @@
 # Resources & Declarations
 
-## Level Memory & Level Data
-Level memory and level data are defined with the [`@level_memory`][sonolus.script.globals.level_memory] and [`@level_data`][sonolus.script.globals.level_data] class decorators, respectively:
+## Global Variables
+
+### Level Memory
+Level memory is defined with the [`@level_memory`][sonolus.script.globals.level_memory] class decorator:
 
 ```python
-from sonolus.script.globals import level_memory, level_data
+from sonolus.script.globals import level_memory
 
 
 @level_memory
 class LevelMemory:
     value: int
-    
+```
+
+Alternatively, it may be called as a function as well by passing the type as an argument:
+
+```python
+from sonolus.script.globals import level_memory
+from sonolus.script.vec import Vec2
+
+
+level_memory_value = level_memory(Vec2)
+```
+
+Level memory may be modified in sequential callbacks:
+
+- `preprocess`
+- `update_sequential`
+- `touch`
+
+and may be read in any callback.
+
+### Level Data
+Level data is defined with the [`@level_data`][sonolus.script.globals.level_data] class decorator:
+
+```python
+from sonolus.script.globals import level_data
+
 
 @level_data
 class LevelData:
     value: int
 ```
 
-Alternatively, they may be called as functions as well by passing the type as an argument:
+Alternatively, it may be called as a function as well by passing the type as an argument:
+
 ```python
-from sonolus.script.globals import level_memory, level_data
+from sonolus.script.globals import level_data
 from sonolus.script.vec import Vec2
 
 
-level_memory_value = level_memory(Vec2)
 level_data_value = level_data(Vec2)
 ```
 
+Level data may only be modified in the `preprocess` callback and may be read in any callback.
+
+## Archetype Variables
+
+### Imported
+Imported fields are declared with [`imported()`][sonolus.script.archetype.imported]:
+
+```python
+from sonolus.script.archetype import PlayArchetype, imported
+
+class MyArchetype(PlayArchetype):
+    field: int = imported()
+    field_with_explicit_name: int = imported(name="field_name")
+```
+
+Imported fields may be loaded from the level data. In watch mode, data may also be loaded from a corresponding exported field in play mode.
+
+Imported fields may only be updated in the `preprocess` callback, and are read-only in other callbacks.
+
+### Exported
+Exported fields are declared with [`exported()`][sonolus.script.archetype.exported]:
+
+```python
+from sonolus.script.archetype import PlayArchetype, exported
+
+class MyArchetype(PlayArchetype):
+    field: int = exported()
+    field_with_explicit_name: int = exported(name="#FIELD")
+```
+
+This is only usable in play mode to export data to be loaded in watch mode. Exported fields are write-only.
+
+### Entity Data
+Entity data fields are declared with [`entity_data()`][sonolus.script.archetype.entity_data]:
+
+```python
+from sonolus.script.archetype import PlayArchetype, entity_data
+
+class MyArchetype(PlayArchetype):
+    field: int = entity_data()
+```
+
+Entity data is accessible from other entities, but may only be updated in the `preprocess` callback and is read-only in other callbacks.
+
+It functions like [`imported()`][sonolus.script.archetype.imported] and shares the same underlying storage, except that it is not loaded from a level.
+
+### Entity Memory
+Entity memory fields are declared with [`entity_memory()`][sonolus.script.archetype.entity_memory]:
+
+```python
+from sonolus.script.archetype import PlayArchetype, entity_memory
+
+class MyArchetype(PlayArchetype):
+    field: int = entity_memory()
+```
+
+Entity memory is private to the entity and is not accessible from other entities. It may be read or updated in any callback associated with the entity.
+
+Entity memory fields may also be set when an entity is spawned using the [`spawn()`][sonolus.script.archetype.PlayArchetype.spawn] method.
+
+### Shared Memory
+Shared memory fields are declared with [`shared_memory()`][sonolus.script.archetype.shared_memory]:
+
+```python
+from sonolus.script.archetype import PlayArchetype, shared_memory
+
+class MyArchetype(PlayArchetype):
+    field: int = shared_memory()
+```
+
+Shared memory is accessible from other entities.
+
+Shared memory may be read in any callback, but may only be updated by sequential callbacks (`preprocess`, `update_sequential`, and `touch`).
+
 ## Streams
 Streams are defined with the [`@streams`][sonolus.script.stream.streams] decorator:
 

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/docs/concepts/types.md

@@ -1,5 +1,3 @@
-from sonolus.script.archetype import PlayArchetype
-
 # Types
 Sonolus.py has 3 core types: [`Num`](#num), [`Array`](#array), and [`Record`](#record). representing numeric values, fixed-size arrays, 
 and custom data structures, respectively. Arrays and records can be nested within each other to create complex data
@@ -16,7 +14,7 @@ Sonolus.py will treat any of these types as `Num`, but it's recommended to use w
 The Sonolus app uses 32-bit floating-point numbers for all numeric values, so precision may be lower compared to Python
 when running on Sonolus.
 
-Infinity, NaN, and values outside the range of 32-bit floating-point numbers are not supported.
+NaN and values outside the range of 32-bit floating-point numbers are not supported.
 
 You can import `Num` from `sonolus.script.num`:
 
@@ -44,8 +42,10 @@ Nums support most of the standard Python operations:
     Floating point precision may be lower when running on Sonolus compared to Python.
     Care should be taken when performing precision-sensitive operations.
 
-Nums are the only supported type for boolean operations and control flow conditions.
-As a condition, any nonzero value is considered true, and `0` is considered false.
+As in regular Python, `0` is considered `False`, while any non-zero value is considered `True`.
+
+Objects with an explicit `__bool__` method may also be used in `if`, `while`, `case ... if` expressions as well as with
+the `not` operator. However, the operands of the `and` and `or` operators must be of type `Num`.
 
 - Logical operators: `and`, `or`, `not`
 - Ternary expressions: `... if <condition> else ...`
@@ -106,11 +106,12 @@ from sonolus.script.array import Array
 
 ### Declaration
 
-Arrays can be created using its constructor:
+Arrays can be created using its constructor or the unary `+` operator.
 
 ```python
 a1 = Array[int, 3](1, 2, 3)
 a2 = Array[int, 0]()
+a3 = +Array[int, 3]  # Create a zero-initialized array
 ```
 
 If at least one element is provided, the element type and size can be inferred:
@@ -152,6 +153,14 @@ assert a[0] == Pair(1, 2)  # The value in the array is independent of the origin
 
 ### Operations
 
+An array can be copied with the unary `+` operator, which creates a new array with the same elements:
+
+```python
+a = Array(1, 2, 3)
+b = +a
+assert b == Array(1, 2, 3)
+```
+
 The value of an array can be copied from another array using the copy from operator (`@=`)[^1]:
 
 ```python
@@ -299,11 +308,13 @@ class MyPairSubclass(MyPair):
 
 ### Instantiation
 
-A constructor is automatically generated for the [`Record`][sonolus.script.record.Record] class:
+A constructor is automatically generated for the [`Record`][sonolus.script.record.Record] class and the unary `+` 
+operator can also be used to create a zero-initialized record.
 
 ```python
 pair_1 = MyPair(1, 2)
 pair_2 = MyPair(first=1, second=2)
+pair_3 = +MyPair  # Create a zero-initialized record
 ```
 
 ### Generics
@@ -342,6 +353,14 @@ assert MyGenericRecord(1).my_type() == Num
 
 ### Operations
 
+A record can be copied with the unary `+` operator, which creates a new record with the same field values:
+
+```python
+pair = MyPair(1, 2)
+copy_pair = +pair
+assert copy_pair == MyPair(1, 2)
+```
+
 The value of a record can be copied from another record using the copy from operator (`@=`)[^1]:
 
 ```python

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.3.1"
+version = "0.3.3"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -13,12 +13,12 @@ default-groups = ["dev", "docs"]
 
 [tool.ruff]
 line-length = 120
-target-version = "py313"
+target-version = "py312"
 
 [tool.ruff.lint]
 preview = true
 select = ["F", "E", "W", "I", "N", "D", "UP", "YTT", "B", "A", "COM", "C4", "DTZ", "PIE", "PT", "Q", "SLOT", "SIM", "PTH", "PL", "PERF", "FURB", "LOG", "RUF"]
-ignore = ["E402", "D1", "COM812", "PLW2901", "PLW3201", "PLR6301", "PLC0415", "PLR2004", "PLR09", "SIM108", "FURB113", "A005"]
+ignore = ["E402", "D1", "COM812", "PLW2901", "PLW3201", "PLR6301", "PLC0415", "PLR2004", "PLR09", "SIM108", "FURB113", "A005", "B903"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
@@ -49,13 +49,15 @@ packages = ["sonolus"]
 
 [tool.tox]
 requires = ["tox>=4.19"]
-env_list = ["py312", "py313"]
+env_list = ["py312", "py313", "py314"]
 
 [tool.tox.env_run_base]
 description = "Run tests"
+passenv = ["CI"]
 deps = [
     "hypothesis>=6.115.3",
     "pytest-xdist>=3.6.1",
     "pytest>=8.3.3",
 ]
+uv_python_preference = "managed"
 commands = [["pytest", "tests", "-n", "auto"]]

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/scripts/generate.py

@@ -51,11 +51,9 @@ def block(name: str, f: TextIO, out: TextIO):
         readable = block["readable"]
         writable = block["writable"]
         out.write(
-            f'    {name} = ({id_}, {{{
-            ", ".join(f'"{e}"' for e in readable)
-            }}}, {{{
-            ", ".join(f'"{e}"' for e in writable)
-            }}})\n'
+            f"    {name} = ({id_}, {{{', '.join(f'"{e}"' for e in readable)}}}, {{{
+                ', '.join(f'"{e}"' for e in writable)
+            }}})\n"
         )
 
 
@@ -78,7 +76,7 @@ def blocks():
                 (runtimes_dir / file).open("r", encoding="utf-8") as f,
             ):
                 block(name, f, out)
-        out.write(f"\n" f"\n" f"type Block = {" | ".join(f'{name}Block' for name in block_files)}\n")
+        out.write(f"\n\ntype Block = {' | '.join(f'{name}Block' for name in block_files)}\n")
 
 
 def main():

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/sonolus/backend/finalize.py

@@ -1,3 +1,5 @@
+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.ops import Op
@@ -54,10 +56,20 @@ def cfg_to_engine_node(entry: BasicBlock):
 
 def ir_to_engine_node(stmt) -> EngineNode:
     match stmt:
-        case int() | float():
-            return ConstantNode(value=float(stmt))
-        case IRConst(value=int(value) | float(value)):
-            return ConstantNode(value=value)
+        case int(value) | float(value) | IRConst(value=int(value) | float(value)):
+            value = float(value)
+            if value.is_integer():
+                return ConstantNode(value=int(value))
+            elif isfinite(value):
+                return ConstantNode(value=value)
+            elif isinf(value):
+                # Read values from ROM
+                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=1 if value > 0 else 2)])
+            elif isnan(value):
+                # Read value from ROM
+                return FunctionNode(Op.Get, args=[ConstantNode(value=3000), ConstantNode(value=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])
         case IRGet(place=place):

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/sonolus/backend/node.py

@@ -1,26 +1,34 @@
 import textwrap
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 
 from sonolus.backend.ops import Op
 
 type EngineNode = ConstantNode | FunctionNode
 
 
-@dataclass
+@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
+@dataclass(slots=True)
 class FunctionNode:
     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 hash((self.func, tuple(self.args)))
+        return self._hash
 
 
 def format_engine_node(node: EngineNode) -> str:
@@ -34,7 +42,7 @@ def format_engine_node(node: EngineNode) -> str:
                 return f"{node.func.name}({format_engine_node(node.args[0])})"
             case _:
                 return f"{node.func.name}(\n{
-                    textwrap.indent("\n".join(format_engine_node(arg) for arg in node.args), "  ")
+                    textwrap.indent('\n'.join(format_engine_node(arg) for arg in node.args), '  ')
                 }\n)"
     else:
         raise ValueError(f"Invalid engine node: {node}")

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/sonolus/backend/optimize/allocate.py

@@ -65,7 +65,8 @@ class Allocate(CompilerPass):
     def run(self, entry: BasicBlock):
         mapping = self.get_mapping(entry)
         for block in traverse_cfg_preorder(entry):
-            block.statements = [self.update_stmt(statement, mapping) for statement in block.statements]
+            updated_statements = [self.update_stmt(statement, mapping) for statement in block.statements]
+            block.statements = [stmt for stmt in updated_statements if stmt is not None]
             block.test = self.update_stmt(block.test, mapping)
         return entry
 
@@ -80,7 +81,19 @@ class Allocate(CompilerPass):
             case IRGet(place=place):
                 return IRGet(place=self.update_stmt(place, mapping))
             case IRSet(place=place, value=value):
-                return IRSet(place=self.update_stmt(place, mapping), value=self.update_stmt(value, mapping))
+                # Do some dead code elimination here which is pretty much free since we already have liveness analysis,
+                # and prevents an error from the dead block place being missing from the mapping.
+                live = get_live(stmt)
+                is_live = not (
+                    (isinstance(place, BlockPlace) and isinstance(place.block, TempBlock) and place.block not in live)
+                    or (isinstance(value, IRGet) and place == value.place)
+                )
+                if is_live:
+                    return IRSet(place=self.update_stmt(place, mapping), value=self.update_stmt(value, mapping))
+                elif isinstance(value, IRInstr) and value.op.side_effects:
+                    return self.update_stmt(value, mapping)
+                else:
+                    return None
             case BlockPlace(block=block, index=index, offset=offset):
                 if isinstance(block, TempBlock):
                     if block.size == 0:
@@ -119,8 +132,32 @@ class Allocate(CompilerPass):
     def get_interference(self, entry: BasicBlock) -> dict[TempBlock, set[TempBlock]]:
         result = {}
         for block in traverse_cfg_preorder(entry):
-            for stmt in [*block.statements, block.test]:
+            for stmt in block.statements:
+                if not isinstance(stmt, IRSet):
+                    continue
                 live = {p for p in get_live(stmt) if isinstance(p, TempBlock) and p.size > 0}
                 for place in live:
-                    result.setdefault(place, set()).update(live - {place})
+                    if place not in result:
+                        result[place] = set(live)
+                    else:
+                        result[place].update(live)
         return result
+
+
+class AllocateFast(Allocate):
+    """A bit faster than Allocate but a bit less optimal."""
+
+    def get_mapping(self, entry: BasicBlock) -> dict[TempBlock, int]:
+        interference = self.get_interference(entry)
+        offsets: dict[TempBlock, int] = dict.fromkeys(interference, 0)
+        end_offsets: dict[TempBlock, int] = dict.fromkeys(interference, 0)
+
+        for block, others in interference.items():
+            size = block.size
+            offset = max((end_offsets[other] for other in others), default=0)
+            if offset + size > TEMP_SIZE:
+                raise ValueError("Temporary memory limit exceeded")
+            offsets[block] = offset
+            end_offsets[block] = offset + size
+
+        return offsets

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/sonolus/backend/optimize/flow.py

@@ -91,12 +91,29 @@ def cfg_to_mermaid(entry: BasicBlock):
 
     lines = ["Entry([Entry]) --> 0"]
     for block, index in block_indexes.items():
-        lines.append(f"{index}[{pre(fmt([f'#{index}', *(
-            f"{dst} := phi({", ".join(f"{block_indexes.get(src_block, "<dead>")}: {src_place}"
-                                      for src_block, src_place
-                                      in sorted(phis.items(), key=lambda x: block_indexes.get(x[0])))})"
-            for dst, phis in block.phis.items()
-        ), *block.statements]))}]")
+        lines.append(
+            f"{index}[{
+                pre(
+                    fmt(
+                        [
+                            f'#{index}',
+                            *(
+                                f'{dst} := phi({
+                                    ", ".join(
+                                        f"{block_indexes.get(src_block, '<dead>')}: {src_place}"
+                                        for src_block, src_place in sorted(
+                                            phis.items(), key=lambda x: block_indexes.get(x[0])
+                                        )
+                                    )
+                                })'
+                                for dst, phis in block.phis.items()
+                            ),
+                            *block.statements,
+                        ]
+                    )
+                )
+            }]"
+        )
 
         outgoing = {edge.cond: edge.dst for edge in block.outgoing}
         match outgoing:
@@ -114,7 +131,7 @@ def cfg_to_mermaid(entry: BasicBlock):
                 lines.append(f"{index} --> {index}_")
                 for cond, target in tgt.items():
                     lines.append(
-                        f"{index}_ --> |{pre(fmt([cond if cond is not None else "default"]))}| {block_indexes[target]}"
+                        f"{index}_ --> |{pre(fmt([cond if cond is not None else 'default']))}| {block_indexes[target]}"
                     )
     lines.append("Exit([Exit])")
 

{sonolus_py-0.3.1 → sonolus_py-0.3.3}/sonolus/backend/optimize/optimize.py

@@ -1,4 +1,4 @@
-from sonolus.backend.optimize.allocate import Allocate, AllocateBasic
+from sonolus.backend.optimize.allocate import Allocate, AllocateBasic, AllocateFast
 from sonolus.backend.optimize.constant_evaluation import SparseConditionalConstantPropagation
 from sonolus.backend.optimize.copy_coalesce import CopyCoalesce
 from sonolus.backend.optimize.dead_code import (
@@ -6,9 +6,7 @@ from sonolus.backend.optimize.dead_code import (
     DeadCodeElimination,
     UnreachableCodeElimination,
 )
-from sonolus.backend.optimize.flow import BasicBlock
 from sonolus.backend.optimize.inlining import InlineVars
-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
 
@@ -21,9 +19,8 @@ MINIMAL_PASSES = (
 FAST_PASSES = (
     CoalesceFlow(),
     UnreachableCodeElimination(),
-    AdvancedDeadCodeElimination(),
+    AllocateFast(),  # Does dead code elimination too, so no need for a separate pass
     CoalesceFlow(),
-    Allocate(),
 )
 
 STANDARD_PASSES = (
@@ -46,7 +43,3 @@ STANDARD_PASSES = (
     NormalizeSwitch(),
     Allocate(),
 )
-
-
-def optimize_and_allocate(cfg: BasicBlock):
-    return run_passes(cfg, STANDARD_PASSES)