sonolus.py 0.3.4__tar.gz → 0.4.1__tar.gz

sonolus_py-0.4.1/.gitattributes

@@ -0,0 +1 @@
+tests/regressions/data/* linguist-generated=true

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/.github/workflows/publish.yaml

@@ -13,7 +13,7 @@ jobs:
       - name: Install uv
         uses: astral-sh/setup-uv@v3
         with:
-          version: 0.7.16
+          version: 0.8.3
       - name: Install Python
         run: |
           uv python install 3.12 3.13 3.14

sonolus_py-0.4.1/.python-version

@@ -0,0 +1 @@
+3.14.0rc1

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/PKG-INFO

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

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/doc_stubs/builtins.pyi

@@ -31,6 +31,20 @@ def any(iterable: Iterable[builtins.bool]) -> builtins.bool:
     """
     ...
 
+def sum(
+    iterable: Iterable[builtins.int | builtins.float], /, start: builtins.int | builtins.float = 0
+) -> builtins.int | builtins.float:
+    """Return the sum of a 'start' value (default: 0) and an iterable of numbers.
+
+    Args:
+        iterable: The iterable of numbers to sum.
+        start: The starting value to add to the sum.
+
+    Returns:
+        The total sum.
+    """
+    ...
+
 def abs(x: builtins.int | builtins.float) -> builtins.int | builtins.float:
     """Return the absolute value of a number.
 
@@ -134,6 +148,17 @@ def issubclass(cls: type, classinfo: type | tuple[type, ...]) -> builtins.bool:
     """
     ...
 
+def iter[T](iterable: Iterable[T]) -> Iterator[T]:
+    """Return an iterator for the given iterable.
+
+    Args:
+        iterable: The iterable to convert to an iterator.
+
+    Returns:
+        An iterator over the elements of the iterable.
+    """
+    ...
+
 def len(s: object) -> builtins.int:
     """Return the number of items in a container.
 
@@ -148,9 +173,6 @@ def len(s: object) -> builtins.int:
 def map[T, S](function: Callable[[T], S], iterable: Iterable[T]) -> Iterator[S]:
     """Apply a function to every item of an iterable and return an iterator.
 
-    Unlike the standard Python map function, it is possible that the function may be called more than once on the
-    same item.
-
     Args:
         function: The function to apply.
         iterable: The iterable to process.
@@ -161,84 +183,74 @@ def map[T, S](function: Callable[[T], S], iterable: Iterable[T]) -> Iterator[S]:
     ...
 
 @overload
-def max[T](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the largest item in an iterable or the largest of two or more arguments.
-
-    Args:
-        iterable: The iterable to evaluate.
-        key: A function of one argument that is used to extract a comparison key from each element.
-
-    Returns:
-        The largest item.
-    """
-    ...
-
+def max[T](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T: ...
 @overload
-def max[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the largest item in an iterable or the largest of two or more arguments.
-
-    Args:
-        arg1: First argument.
-        arg2: Second argument.
-        *args: Additional arguments.
-        key: A function of one argument that is used to extract a comparison key from each element.
-
-    Returns:
-        The largest item.
-    """
-    ...
-
+def max(
+    iterable: Iterable[builtins.int | builtins.float],
+    *,
+    default: builtins.int | builtins.float = ...,
+    key: Callable[[builtins.int | builtins.float], Any] | None = ...,
+) -> builtins.int | builtins.float: ...
 @overload
-def min[T](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the smallest item in an iterable or the smallest of two or more arguments.
+def max[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) -> T: ...
+def max(*args, **kwargs):
+    """Return the largest item in an iterable or the largest of multiple arguments.
 
-    Args:
-        iterable: The iterable to evaluate.
-        key: A function of one argument that is used to extract a comparison key from each element.
+    When called with a single iterable, returns the largest item from that iterable.
+    When called with multiple arguments, returns the largest argument.
 
-    Returns:
-        The smallest item.
+    Use the `key` parameter to specify a function that transforms each element
+    before comparison. Use the `default` parameter to specify a value to return
+    if the iterable is empty (supported only for numeric values).
     """
     ...
 
 @overload
-def min[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the smallest item in an iterable or the smallest of two or more arguments.
+def min[T](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T: ...
+@overload
+def min(
+    iterable: Iterable[builtins.int | builtins.float],
+    *,
+    default: builtins.int | builtins.float = ...,
+    key: Callable[[builtins.int | builtins.float], Any] | None = ...,
+) -> builtins.int | builtins.float: ...
+@overload
+def min[T](arg1: T, arg2: T, *args: T, key: Callable[[T], Any] | None = ...) -> T: ...
+def min(*args, **kwargs):
+    """Return the smallest item in an iterable or the smallest of multiple arguments.
 
-    Args:
-        arg1: First argument.
-        arg2: Second argument.
-        *args: Additional arguments.
-        key: A function of one argument that is used to extract a comparison key from each element.
+    When called with a single iterable, returns the smallest item from that iterable.
+    When called with multiple arguments, returns the smallest argument.
 
-    Returns:
-        The smallest item.
+    Use the `key` parameter to specify a function that transforms each element
+    before comparison. Use the `default` parameter to specify a value to return
+    if the iterable is empty (supported only for numeric values).
     """
     ...
 
-@overload
-def range(stop: builtins.int) -> builtins.range:
-    """Return an immutable sequence of numbers from 0 to stop.
+def next[T](iterator: Iterator[T]) -> T:
+    """Retrieve the next item from an iterator.
+
+    Errors if the iterator is exhausted.
 
     Args:
-        stop: Stop value.
+        iterator: The iterator to retrieve the next item from.
 
     Returns:
-        The range object.
+        The next item from the iterator.
     """
     ...
 
 @overload
-def range(start: builtins.int, stop: builtins.int, step: builtins.int = ...) -> builtins.range:
-    """Return an immutable sequence of numbers from start to stop by step.
-
-    Args:
-        start: Start value.
-        stop: Stop value.
-        step: Step value.
+def range(stop: builtins.int) -> builtins.range: ...
+@overload
+def range(start: builtins.int, stop: builtins.int, step: builtins.int = ...) -> builtins.range: ...
+def range(*args) -> builtins.range:
+    """Return an immutable sequence of numbers.
 
-    Returns:
-        The range object.
+    When called with one argument, creates a sequence from 0 to that number (exclusive).
+    When called with two arguments, creates a sequence from the first to the second (exclusive).
+    When called with three arguments, the third argument specifies the step size.
     """
     ...
 

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/docs/concepts/builtins.md

@@ -1,5 +1,6 @@
 # Builtins
 Sonolus.py comes with support for a number of built-in functions.
+The supported functions and parameters are listed below.
 
 - `abs(x)`
 - `bool(object)`
@@ -10,11 +11,13 @@ Sonolus.py comes with support for a number of built-in functions.
 - `int(x)` (for a num argument)
 - `isinstance(object, classinfo)`
 - `issubclass(class, classinfo)`
+- `iter(iterable)`
 - `len(s)`
-- `map(function, iterable)` (note: may differ from standard Python behavior, see 
-  [`map`](../reference/builtins.md#doc_stubs.builtins.map))
-- `max(iterable, *, key=None)`, `max(arg1, arg2, *args, key=None)`
-- `min(iterable, *, key=None)`, `min(arg1, arg2, *args, key=None)`
+- `map(function, iterable)`
+- `max(iterable, *, default=..., key=None)`, `max(arg1, arg2, *args, key=None)`
+- `min(iterable, *, default=..., key=None)`, `min(arg1, arg2, *args, key=None)`
+- `next(iterator)`
+- `sum(iterable, start=0)`
 - `range(stop)`, `range(start, stop[, step])`
 - `reversed(seq)`
 - `round(number[, ndigits])`

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/docs/concepts/cli.md

@@ -15,6 +15,13 @@ To build the project, run the following command in the root directory of your pr
 sonolus-py build
 ```
 
+## Checking for errors without building
+To check for errors, run the following command in the root directory of your project:
+
+```bash
+sonolus-py check
+```
+
 ## Outputting the level schema
 To output the level schema of the project, run the following command in the root directory of your project:
 

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/docs/concepts/constructs.md

@@ -33,13 +33,14 @@ The following constructs are supported in Sonolus.py:
         - Binary: `+`, `-`, `*`, `/`, `//`, `%`, `**`, `&`, `|`, `^`, `<<`, `>>`
         - Comparison: `==`, `!=`, `>`, `<`, `>=`, `<=`, `is`, `is not`, `in`, `not in`
         - Logical: `and`, `or` (for [`Num`](types.md#num) arguments only)
-        - Ternary: `a if <condition> else b` (for [`Num`](types.md#num) conditions only)
+        - Ternary: `a if <condition> else b`
         - Attribute: `a.b`
         - Indexing: `a[b]`
         - Call: `f(a, b, c)`
     - Variables: `a`, `b`, `c`
-    - Lambda: `lambda a, b: a + b`
+    - Lambda: `lambda a, b: a + b` (if not on the same line as another lambda or function definition)
     - Assignment Expression: `(a := b)`
+    - Generator Expression: `(x for x in iterable if condition)`
 - Statements:
     - Simple Statements:
         - Assignments:
@@ -55,6 +56,7 @@ The following constructs are supported in Sonolus.py:
         - Break: `break`
         - Continue: `continue`
         - Return: `return <value>`
+        - Yield: `yield <value>`, `yield from <iterable>`
         - Import: `import <module>`, `from <module> import <name>` (only outside of functions)
     - Compound Statements:
         - If: `if <condition>:`, `elif <condition>:`, `else:`

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/docs/concepts/types.md

@@ -118,6 +118,16 @@ a2 = Array[int, 0]()
 a3 = +Array[int, 3]  # Create a zero-initialized array
 ```
 
+For type checker compatibility, `Literal` or [`Dim`][sonolus.script.array.Dim] can also be used to specify the size of
+the array:
+
+```python
+from sonolus.script.array import Dim
+
+a1 = Array[int, Dim(3)](1, 2, 3)
+a2 = Array[int, Literal[3]](1, 2, 3)
+```
+
 If at least one element is provided, the element type and size can be inferred:
 
 ```python
@@ -613,18 +623,14 @@ class _FilteringIterator[T, Fn](Record, SonolusIterator):
     fn: Fn
     iterator: T
 
-    def has_next(self) -> bool:
-        while self.iterator.has_next():
-            if self.fn(self.iterator.get()):
-                return True
-            self.iterator.advance()
-        return False
-
-    def get(self) -> Any:
-        return self.iterator.get()
-
-    def advance(self):
-        self.iterator.advance()
+    def next(self) -> Maybe[T]:
+        while True:
+            value = self.iterator.next()
+            if value.is_nothing:
+                return Nothing
+            inside = value.get()
+            if self.fn(inside):
+                return Some(inside)
 
 
 def my_filter[T, Fn](iterable: T, fn: Fn) -> T:

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/docs/overview.md

@@ -4,15 +4,15 @@ Sonolus.py is a Python library for creating Sonolus engines. This page provides
 available in the library. For more detailed information, see the [Concepts](concepts/index.md) and 
 [Reference](reference/index.md) sections.
 
-## Features
+## Language
+
 Sonolus.py functions by compiling Python code into Sonolus nodes. As such, it supports a subset of Python including
 most syntax and a portion of the standard library. Additionally, Sonolus.py provides its own library of types and
 functions that are specifically designed for use in Sonolus engines.
 
-### Language
+### Syntax
 
-#### Syntax
-Most Python syntax is supported, but there are a few limitations:
+Most Python syntax is supported, but there are a few limitations. The primary restrictions are:
 
 - Destructuring assignment with the `*` operator is unsupported.
 - Sequence (list and array) `match` patterns with the `*` operator are unsupported.
@@ -21,7 +21,8 @@ Most Python syntax is supported, but there are a few limitations:
 - The `global` and `nonlocal` keywords are unsupported.
 - Exception related statements (`try`, `except`, `finally`, `raise`) are unsupported.
 
-#### Compile Time Evaluation
+### Compile Time Evaluation
+
 Sonolus.py will evaluate some expressions at compile time such as basic arithmetic operations on constants,
 boolean logical operations (`and`, `or`, `not`) on constants, and type checks (`isinstance`, `issubclass`).
 
@@ -38,7 +39,8 @@ else:
     debug_log(a)
 ```
 
-#### Variables
+### Variables
+
 Numeric (`int`, `float`, `bool`) variables are fully supported and can be freely assigned and modified.
 
 All other variables have the restriction that if the compiler finds multiple possible values for a variable, it may
@@ -53,7 +55,8 @@ else:
 debug_log(a.x)
 ```
 
-#### Function Returns
+### Function Returns
+
 Similar to variables, functions returning `int`, `float`, or `bool` can have any number of return statements. Functions
 returning `None` may also have any number of `return` or `return None` statements.
 
@@ -71,26 +74,25 @@ def fn(a: int | Vec2):
 fn(123)
 ```
 
-### Types
+## Types
+
+### Numbers
 
-#### Numbers
 Sonolus.py supports `int`, `float`, and `bool` types and most of the standard operations such as mathematical operations
 (`+`, `-`, `*`, `/`, `//`, `%`), comparisons (`<`, `<=`, `>`, `>=`, `==`, `!=`), and boolean operations 
 (`and`, `or`, `not`).
 
-#### Record
-[`Record`](reference/sonolus.script.record.md) is the main way to define custom types in Sonolus.py. It functions similarly to a data class and
-provides a way to define a type with named fields:
+### Record
+
+[`Record`](reference/sonolus.script.record.md) is the main way to define custom types in Sonolus.py. 
+It functions similarly to a data class and provides a way to define a type with named fields:
 
 ```python
 class MyRecord(Record):
     a: int
     b: float
 
-my_record = MyRecord(1, b=2.5)
-my_zero_record = +MyRecord  # Short for MyRecord(0, 0.0)
-my_record_copy = +my_record  # Create a copy of my_record with the same values
-my_record.a = 123  # Modify a field of the record
+record_1 = MyRecord(1, b=2.3)
 ```
 
 Records may also be generic:
@@ -99,26 +101,101 @@ Records may also be generic:
 class MyGenericRecord[T](Record):
     value: T
 
-my_generic_record = MyGenericRecord[int](42)
-my_generic_record_2 = MyGenericRecord(MyRecord(1, 3.5))  # Type arguments are inferred
+record_1 = MyGenericRecord[int](123)
+record_2 = MyGenericRecord(MyRecord(4, 5.6))  # Type arguments are inferred
+```
+
+Record arguments are retained by reference, so modifying the original record will also modify the record in the array:
+
+```python
+record_1 = MyRecord(1, 2.3)
+record_2 = MyGenericRecord(record_1)
+record_2.value.a = 789  # This also affects `record_1` since they're the same object.
+assert record_1.a == record_2.value.a == 789
+```
+
+### Array
+
+[`Array`](reference/sonolus.script.array.md) is a type that represents a fixed-size array of elements of a 
+specific type:
+
+```python
+array_1 = Array[int, 3](1, 2, 3)
+array_2 = Array(4, 5, 6)  # Type arguments are inferred
+```
+
+When given record or array values as arguments, the array constructor will copy them:
+
+```python
+record_1 = MyRecord(1, 2.5)
+array_1 = Array(record_1)
+array_1[0].a = 789  # This has no effect on `record_1` since it was copied.
+assert record_1.a == 1
+```
+
+### Operations
+
+This section is an overview of the operations available for records and arrays. For full details see the
+[Record documentation](reference/sonolus.script.record.md) and [Array documentation](reference/sonolus.script.array.md).
+
+Records and arrays come with the `==` and `!=` operators predefined to compare their values for equality:
+
+```python
+assert MyRecord(1, 2.3) == MyRecord(1, 2.3)
+assert Array(1, 2, 3) != Array(4, 5, 6)
+```
+
+The unary `+` operator makes a copy of a record or array, creating a new instance with the same values:
+
+```python
+record_2 = +record_1
+array_2 = +array_1
+```
+
+Similarly, a new zero initialized value can be created using the unary `+` operator on a record or array type:
+
+```python
+record_1 = +MyRecord
+record_2 = +Array[int, 3]
+```
+
+Records and arrays can be mutated in-place using the `@=` operator:
+
+```python
+record_1 @= MyRecord(1, 2.3) 
+array_1 @= Array(4, 5, 6)
+```
+
+Record fields and array elements of numeric types can be set using the `=` operator:
+
+```python
+record_1.a = 123
+array_1[1] = 456
+```
+
+Setting a record field that's a record or array using the `=` operator will modify the field in-place:
+
+```python
+record_1 = MyRecord(1, 2.3)
+record_2 = MyGenericRecord(record_1)
+record_2.value = MyRecord(4, 5.6)  # This modifies `record_1` in-place.
+assert record_1 == record_2.value == MyRecord(4, 5.6)
 ```
 
-#### Array
-[`Array`](reference/sonolus.script.array.md) is a type that represents a fixed-size array of elements of a specific type.
+Setting an array element that's a record or array using the `=` operator will also modify the element in-place:
 
 ```python
-my_array = Array[int, 3](1, 2, 3)
-my_array_2 = Array(4, 5, 6)  # Type arguments are inferred
-my_zero_array = +Array[int, 3]  # Short for Array[int, 3](0, 0, 0)
-my_array_copy = +my_array  # Create a copy of my_array with the same values
-my_array[2] = 10  # Modify an element of the array
+array_1 = Array(MyRecord(1, 2.3))
+record_1 = array_1[0]
+array_1[0] = MyRecord(4, 5.6)  # This modifies `record_1` in-place.
+assert record_1 == array_1[0] == MyRecord(4, 5.6)
 ```
 
-#### Other Types
+### Other Types
 Sonolus.py has limited support for other types of values such as strings, tuples, and functions. These have restrictions
 such as not being valid as Record field types or Array element types.
 
-### Modules
+## Modules
 Sonolus.py provides a number of built-in modules that can be used in Sonolus engines. These include:
 
 - Project
@@ -155,6 +232,7 @@ Sonolus.py provides a number of built-in modules that can be used in Sonolus eng
     - [Easing](reference/sonolus.script.easing.md): Easing functions for animations.
     - [Interval](reference/sonolus.script.interval.md): Mathematical intervals.
     - [Iterator](reference/sonolus.script.iterator.md): Iterators over collections.
+    - [Maybe](reference/sonolus.script.maybe.md): Optional function return values.
     - [Printing](reference/sonolus.script.printing.md): Preview mode number printing.
     - [Quad](reference/sonolus.script.quad.md): Quadrilaterals.
     - [Transform](reference/sonolus.script.transform.md): Transformations like translation, rotation, and scaling.

sonolus_py-0.4.1/docs/reference/sonolus.script.maybe.md

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

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/mkdocs.yml

@@ -98,6 +98,7 @@ nav:
       - reference/sonolus.script.interval.md
       - reference/sonolus.script.iterator.md
       - reference/sonolus.script.level.md
+      - reference/sonolus.script.maybe.md
       - reference/sonolus.script.metadata.md
       - reference/sonolus.script.num.md
       - reference/sonolus.script.options.md

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.3.4"
+version = "0.4.1"
 description = "Sonolus engine development in Python"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -18,7 +18,7 @@ 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", "B903"]
+ignore = ["E402", "D1", "COM812", "PLW2901", "PLW3201", "PLR6301", "PLC0415", "PLR2004", "PLR09", "SIM108", "FURB113", "A005", "B903", "FURB118"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"
@@ -29,6 +29,7 @@ build-backend = "hatchling.build"
 
 [dependency-groups]
 dev = [
+    "uv>=0.8.3",
     "hypothesis>=6.115.3",
     "pre-commit>=4.0.1",
     "pytest-xdist>=3.6.1",
@@ -37,6 +38,7 @@ dev = [
     "pytest-cov>=6.0.0",
     "tox>=4.23.2",
     "tox-uv>=1.16.0",
+    "ty"
 ]
 docs = [
     "mkdocs-material>=9.5.45",
@@ -61,3 +63,9 @@ deps = [
 ]
 uv_python_preference = "managed"
 commands = [["pytest", "tests", "-n", "auto"]]
+
+[tool.ty.environment]
+root = ["./sonolus"]
+
+[tool.ty.src]
+include = ["sonolus/script"]

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/sonolus/backend/excepthook.py

@@ -16,6 +16,10 @@ def is_compiler_internal(tb: TracebackType):
     )
 
 
+def is_traceback_root(tb: TracebackType | None) -> bool:
+    return tb.tb_frame.f_locals.get("_traceback_root_", False) or tb.tb_frame.f_globals.get("_traceback_root_", False)
+
+
 def filter_traceback(tb: TracebackType | None) -> TracebackType | None:
     if tb is None:
         return None
@@ -25,6 +29,17 @@ def filter_traceback(tb: TracebackType | None) -> TracebackType | None:
     return tb
 
 
+def truncate_traceback(tb: TracebackType | None) -> TracebackType | None:
+    if tb is None:
+        return None
+    if is_compiler_internal(tb):
+        return truncate_traceback(tb.tb_next)
+    if is_traceback_root(tb):
+        return tb
+    else:
+        return truncate_traceback(tb.tb_next)
+
+
 def excepthook(exc, value, tb):
     import traceback
 
@@ -33,5 +48,20 @@ def excepthook(exc, value, tb):
     traceback.print_exception(exc, value, tb)
 
 
+def print_simple_traceback(exc, value, tb):
+    import traceback
+
+    if should_filter_traceback(tb):
+        tb = filter_traceback(tb)
+        truncated = truncate_traceback(tb)
+        tb = truncated if truncated is not None else tb
+        cause = value.__cause__
+        value.__cause__ = None
+        traceback.print_exception(exc, value, tb)
+        value.__cause__ = cause
+    else:
+        traceback.print_exception(exc, value, tb)
+
+
 def install_excepthook():
     sys.excepthook = excepthook

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/sonolus/backend/finalize.py

@@ -13,7 +13,9 @@ def cfg_to_engine_node(entry: BasicBlock):
     for block in block_indexes:
         statements = []
         statements.extend(ir_to_engine_node(stmt) for stmt in block.statements)
-        outgoing = {edge.cond: edge.dst for edge in block.outgoing}
+        outgoing = {
+            edge.cond: edge.dst for edge in sorted(block.outgoing, key=lambda edge: (edge.cond is None, edge.cond))
+        }
         match outgoing:
             case {**other} if not other:
                 statements.append(ConstantNode(value=len(block_indexes)))
@@ -30,6 +32,18 @@ def cfg_to_engine_node(entry: BasicBlock):
                         ],
                     )
                 )
+            case {None: default_branch, **other} if len(other) == 1:
+                cond, cond_branch = next(iter(other.items()))
+                statements.append(
+                    FunctionNode(
+                        func=Op.If,
+                        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]),
+                        ],
+                    )
+                )
             case dict() as targets:
                 args = [ir_to_engine_node(block.test)]
                 default = len(block_indexes)

{sonolus_py-0.3.4 → sonolus_py-0.4.1}/sonolus/backend/ops.py

@@ -2,6 +2,10 @@ from enum import StrEnum
 
 
 class Op(StrEnum):
+    side_effects: bool
+    pure: bool
+    control_flow: bool
+
     def __new__(cls, name: str, side_effects: bool, pure: bool, control_flow: bool):
         obj = str.__new__(cls, name)
         obj._value_ = name