sonolus.py 0.4.0__tar.gz → 0.4.2__tar.gz

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/PKG-INFO

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

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/doc_stubs/builtins.pyi

@@ -183,95 +183,48 @@ 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(
     iterable: Iterable[builtins.int | builtins.float],
     *,
     default: builtins.int | builtins.float = ...,
     key: Callable[[builtins.int | builtins.float], Any] | None = ...,
-) -> builtins.int | builtins.float:
-    """Return the largest item in an iterable or the largest of two or more arguments.
-
-    Args:
-        iterable: The iterable to evaluate.
-        default: The default value to return if the iterable is empty.
-        key: A function of one argument that is used to extract a comparison key from each element.
-
-    Returns:
-        The largest item, or the default value if the iterable is empty.
-    """
-
+) -> builtins.int | builtins.float: ...
 @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.
+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:
-        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 largest item from that iterable.
+    When called with multiple arguments, returns the largest argument.
 
-    Returns:
-        The largest 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](iterable: Iterable[T], *, key: Callable[[T], Any] | None = ...) -> T:
-    """Return the smallest item in an iterable or the smallest 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 smallest item.
-    """
-    ...
-
+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:
-    """Return the smallest item in an iterable or the smallest of two or more arguments.
-
-    Args:
-        iterable: The iterable to evaluate.
-        default: The default value to return if the iterable is empty.
-        key: A function of one argument that is used to extract a comparison key from each element.
-
-    Returns:
-        The smallest item, or the default value if the iterable is empty.
-    """
-    ...
-
+) -> builtins.int | builtins.float: ...
 @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](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).
     """
     ...
 
@@ -289,28 +242,15 @@ def next[T](iterator: Iterator[T]) -> T:
     ...
 
 @overload
-def range(stop: builtins.int) -> builtins.range:
-    """Return an immutable sequence of numbers from 0 to stop.
-
-    Args:
-        stop: Stop value.
-
-    Returns:
-        The range object.
-    """
-    ...
-
+def range(stop: builtins.int) -> builtins.range: ...
 @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.
+def range(start: builtins.int, stop: builtins.int, step: builtins.int = ...) -> builtins.range: ...
+def range(*args) -> builtins.range:
+    """Return an immutable sequence of numbers.
 
-    Args:
-        start: Start value.
-        stop: Stop value.
-        step: Step value.
-
-    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.4.0 → sonolus_py-0.4.2}/docs/concepts/constructs.md

@@ -33,12 +33,12 @@ 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:
@@ -394,7 +394,9 @@ def g(a):
 
 Function returns follow the same rules as variable access. If a function returns a non-num value, it most only
 return that value. If the function always returns a num, it may have any number of returns. Similarly, if a function
-always returns None (`return None` or just `return`), it may have any number of returns.
+always returns None (`return None` or just `return`), it may have any number of returns. 
+The [`Maybe`][sonolus.script.maybe.Maybe] is also an exception, see the 
+[Maybe documentation](../reference/sonolus.script.maybe.md) for details
 
 The following are allowed:
 

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/docs/concepts/types.md

@@ -118,13 +118,10 @@ 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:
-
+For type checker compatibility, the Python builtin `typing.Literal` or [`Dim`][sonolus.script.array.Dim] may be used
+for an array's size:
 ```python
-from sonolus.script.array import Dim
-
-a1 = Array[int, Dim(3)](1, 2, 3)
+a1 = Array[int, Dim[3]](1, 2, 3)
 a2 = Array[int, Literal[3]](1, 2, 3)
 ```
 

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/docs/index.md

@@ -13,12 +13,17 @@ Sonolus.py is available on PyPI and can be installed using a package manager lik
     uv add sonolus.py
     ```
 
+
 ## Getting Started
-Example Projects:
 
-- [pydori](https://github.com/qwewqa/pydori): A Bandori-like engine designed to be an example project for Sonolus.py.
+Before making a new Sonolus.py engine or even reading through the rest of this documentation, it may be helpful to look 
+at some examples to get a sense of how Sonolus.py is used.
+
+The [pydori](https://github.com/qwewqa/pydori) engine is an example Sonolus.py engine that implements a Bandori-style
+(vertical scrolling rhythm game) engine.
 
-New Project Template: [sonolus.py-template-project](https://github.com/qwewqa/sonolus.py-template-project)
+Once you're ready to start a new project, you may want to use the
+[new project template](https://github.com/qwewqa/sonolus.py-template-project).
 
 ## Documentation
 

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/docs/overview.md

@@ -1,14 +1,14 @@
 # Overview
 
-Sonolus.py is a Python library for creating Sonolus engines. This page provides an overview of the key functionality 
-available in the library. For more detailed information, see the [Concepts](concepts/index.md) and 
+Sonolus.py is a Python library for creating Sonolus engines. This page provides an overview of the key functionality
+available in the library. For detailed information, see the [Concepts](concepts/index.md) and
 [Reference](reference/index.md) sections.
 
 ## Language
 
-Sonolus.py functions by compiling Python code into Sonolus nodes. As such, it supports a subset of Python including
+Sonolus.py compiles Python code into Sonolus nodes. 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.
+functions that are designed for use in Sonolus engines.
 
 ### Syntax
 
@@ -26,7 +26,7 @@ Most Python syntax is supported, but there are a few limitations. The primary re
 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`).
 
-In control flow constructs like `if` and `match`, Sonolus.py may determine some branches to be unreachable at compile 
+In control flow constructs like `if` and `match`, Sonolus.py may determine some branches to be unreachable at compile
 and eliminate them without evaluating them. This allows code like the following to compile successfully:
 
 ```python
@@ -60,16 +60,16 @@ debug_log(a.x)
 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.
 
-Functions returning any other type must have exactly one `return` statement, and it must be the only exit point of the 
-function. It is ok, however, for a function to have other `return` statements that are eliminated at compile time. 
+Functions returning any other type must have exactly one `return` statement, and it must be the only exit point of the
+function [^1]. It is ok, however, for a function to have other `return` statements that are eliminated at compile time.
 For example, the following code will compile successfully:
 
 ```python
 def fn(a: int | Vec2):
     if isinstance(a, Vec2):
-        return a.x + a.y
+        return Vec2(a.x, a.y)
     else:
-        return a * 2
+        return Vec2(a, a)
 
 fn(123)
 ```
@@ -79,12 +79,12 @@ fn(123)
 ### Numbers
 
 Sonolus.py supports `int`, `float`, and `bool` types and most of the standard operations such as mathematical operations
-(`+`, `-`, `*`, `/`, `//`, `%`), comparisons (`<`, `<=`, `>`, `>=`, `==`, `!=`), and boolean 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. 
+[`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
@@ -116,7 +116,7 @@ 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 
+[`Array`](reference/sonolus.script.array.md) is a type that represents a fixed-size array of elements of a
 specific type:
 
 ```python
@@ -162,7 +162,7 @@ record_2 = +Array[int, 3]
 Records and arrays can be mutated in-place using the `@=` operator:
 
 ```python
-record_1 @= MyRecord(1, 2.3) 
+record_1 @= MyRecord(1, 2.3)
 array_1 @= Array(4, 5, 6)
 ```
 
@@ -192,10 +192,12 @@ assert record_1 == array_1[0] == MyRecord(4, 5.6)
 ```
 
 ### 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
+
 Sonolus.py provides a number of built-in modules that can be used in Sonolus engines. These include:
 
 - Project
@@ -227,7 +229,7 @@ Sonolus.py provides a number of built-in modules that can be used in Sonolus eng
     - [random](reference/random.md): Supported random functions.
 - Utilities
     - [ArrayLike](reference/sonolus.script.array_like.md): Mixin for array functionality.
-    - [Containers](reference/sonolus.script.containers.md): Additional container types like `VarArray` and `ArrayMap`.
+    - [Containers](reference/sonolus.script.containers.md): Additional container types like [`VarArray`][sonolus.script.containers.VarArray] and [`ArrayMap`][sonolus.script.containers.ArrayMap].
     - [Debug](reference/sonolus.script.debug.md): Debugging utilities.
     - [Easing](reference/sonolus.script.easing.md): Easing functions for animations.
     - [Interval](reference/sonolus.script.interval.md): Mathematical intervals.
@@ -241,12 +243,6 @@ Sonolus.py provides a number of built-in modules that can be used in Sonolus eng
 
 For more details, see the [Reference](reference/index.md) section.
 
-## Getting Started
-
-Before making a new Sonolus.py engine, it may be helpful to look at some existing projects to see how they use
-the library:
-
-- [pydori](https://github.com/qwewqa/pydori): A Bandori-like engine designed to be an example project for Sonolus.py.
-
-If you're starting a new project, you'll probably want to use the
-[new project template](https://github.com/qwewqa/sonolus.py-template-project).
+[^1]:
+    The [`Maybe`][sonolus.script.maybe.Maybe] type is an exception to this rule. 
+    See the [`Maybe` documentation](reference/sonolus.script.maybe.md) for details.

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "sonolus.py"
-version = "0.4.0"
+version = "0.4.2"
 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", "FURB118"]
+ignore = ["E402", "D1", "COM812", "PLW2901", "PLW3201", "PLR6301", "PLC0415", "PLR2004", "PLR09", "SIM108", "FURB113", "A005", "B903", "FURB118", "E501"]
 
 [tool.ruff.lint.pydocstyle]
 convention = "google"

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/sonolus/backend/utils.py

@@ -23,29 +23,48 @@ def get_tree_from_file(file: str | Path) -> ast.Module:
 class FindFunction(ast.NodeVisitor):
     def __init__(self, line):
         self.line = line
-        self.node: ast.FunctionDef | None = None
+        self.results: list[ast.FunctionDef | ast.Lambda] = []
+        self.current_fn = None
 
     def visit_FunctionDef(self, node: ast.FunctionDef):
-        if node.lineno == self.line or (
-            node.decorator_list and (node.decorator_list[-1].end_lineno <= self.line <= node.lineno)
-        ):
-            self.node = node
-        else:
-            self.generic_visit(node)
+        self.results.append(node)
+        outer_fn = self.current_fn
+        self.current_fn = node
+        self.generic_visit(node)
+        self.current_fn = outer_fn
 
     def visit_Lambda(self, node: ast.Lambda):
-        if node.lineno == self.line:
-            if self.node is not None:
-                raise ValueError("Multiple functions defined on the same line are not supported")
-            self.node = node
-        else:
-            self.generic_visit(node)
+        self.results.append(node)
+        outer_fn = self.current_fn
+        self.current_fn = node
+        self.generic_visit(node)
+        self.current_fn = outer_fn
 
+    # Visitors have high overhead, so we detect generators here rather than in a separate pass.
 
-def find_function(tree: ast.Module, line: int):
-    visitor = FindFunction(line)
+    def visit_Yield(self, node):
+        self.current_fn.has_yield = True
+
+    def visit_YieldFrom(self, node):
+        self.current_fn.has_yield = True
+
+
+@cache
+def get_functions(tree: ast.Module) -> list[ast.FunctionDef | ast.Lambda]:
+    visitor = FindFunction(0)
     visitor.visit(tree)
-    return visitor.node
+    return visitor.results
+
+
+def find_function(tree: ast.Module, line: int):
+    for node in get_functions(tree):
+        if node.lineno == line or (
+            isinstance(node, ast.FunctionDef)
+            and node.decorator_list
+            and (node.decorator_list[-1].end_lineno <= line <= node.lineno)
+        ):
+            return node
+    raise ValueError("Function not found")
 
 
 class ScanWrites(ast.NodeVisitor):
@@ -61,27 +80,3 @@ def scan_writes(node: ast.AST) -> set[str]:
     visitor = ScanWrites()
     visitor.visit(node)
     return set(visitor.writes)
-
-
-class HasDirectYield(ast.NodeVisitor):
-    def __init__(self):
-        self.started = False
-        self.has_yield = False
-
-    def visit_Yield(self, node: ast.Yield):
-        self.has_yield = True
-
-    def visit_YieldFrom(self, node: ast.YieldFrom):
-        self.has_yield = True
-
-    def visit_FunctionDef(self, node: ast.FunctionDef):
-        if self.started:
-            return
-        self.started = True
-        self.generic_visit(node)
-
-
-def has_yield(node: ast.AST) -> bool:
-    visitor = HasDirectYield()
-    visitor.visit(node)
-    return visitor.has_yield

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/sonolus/backend/visitor.py

@@ -11,7 +11,7 @@ from types import FunctionType, MethodType, MethodWrapperType
 from typing import Any, Never
 
 from sonolus.backend.excepthook import install_excepthook
-from sonolus.backend.utils import get_function, has_yield, scan_writes
+from sonolus.backend.utils import get_function, scan_writes
 from sonolus.script.debug import assert_true
 from sonolus.script.internal.builtin_impls import BUILTIN_IMPLS, _bool, _float, _int, _len
 from sonolus.script.internal.constant import ConstantValue
@@ -39,6 +39,8 @@ def compile_and_call[**P, R](fn: Callable[P, R], /, *args: P.args, **kwargs: P.k
 def compile_and_call_at_definition[**P, R](fn: Callable[P, R], /, *args: P.args, **kwargs: P.kwargs) -> R:
     if not ctx():
         return fn(*args, **kwargs)
+    if ctx().no_eval:
+        return compile_and_call(fn, *args, **kwargs)
     source_file, node = get_function(fn)
     location_args = {
         "lineno": node.lineno,
@@ -261,11 +263,26 @@ class Visitor(ast.NodeVisitor):
                 result = self.visit(body)
                 ctx().scope.set_value("$return", result)
             case ast.GeneratorExp(elt=elt, generators=generators):
-                self.construct_genexpr(generators, elt)
+                first_generator = generators[0]
+                iterable = self.visit(first_generator.iter)
+                if isinstance(iterable, TupleImpl):
+                    initial_iterator = iterable
+                else:
+                    if not hasattr(iterable, "__iter__"):
+                        raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
+                    initial_iterator = self.handle_call(first_generator.iter, iterable.__iter__)
+                    if not isinstance(initial_iterator, SonolusIterator):
+                        raise ValueError("Unsupported iterator")
+                # The initial iterator is evaluated eagerly in Python
+                before_ctx = ctx().branch_with_scope(None, before_ctx.scope.copy())
+                start_ctx = before_ctx.branch_with_scope(None, Scope())
+                set_ctx(start_ctx)
+                self.construct_genexpr(generators, elt, initial_iterator)
                 ctx().scope.set_value("$return", validate_value(None))
             case _:
                 raise NotImplementedError("Unsupported syntax")
-        if has_yield(node) or isinstance(node, ast.GeneratorExp):
+        # has_yield is set by the find_function visitor
+        if getattr(node, "has_yield", False) or isinstance(node, ast.GeneratorExp):
             return_ctx = Context.meet([*self.return_ctxs, ctx()])
             result_binding = return_ctx.scope.get_binding("$return")
             if not isinstance(result_binding, ValueBinding):
@@ -323,7 +340,9 @@ class Visitor(ast.NodeVisitor):
         set_ctx(after_ctx.branch_with_scope(None, before_ctx.scope.copy()))
         return result_binding.value
 
-    def construct_genexpr(self, generators: Iterable[ast.comprehension], elt: ast.expr):
+    def construct_genexpr(
+        self, generators: Iterable[ast.comprehension], elt: ast.expr, initial_iterator: Value | None = None
+    ):
         if not generators:
             # Note that there may effectively be multiple yields in an expression since
             # tuples are unrolled.
@@ -335,14 +354,22 @@ class Visitor(ast.NodeVisitor):
             set_ctx(resume_ctx)
             return
         generator, *others = generators
-        iterable = self.visit(generator.iter)
+        if initial_iterator is not None:
+            iterable = initial_iterator
+        else:
+            iterable = self.visit(generator.iter)
         if isinstance(iterable, TupleImpl):
             for value in iterable.value:
                 set_ctx(ctx().branch(None))
                 self.handle_assign(generator.target, validate_value(value))
                 self.construct_genexpr(others, elt)
         else:
-            iterator = self.handle_call(generator.iter, iterable.__iter__)
+            if initial_iterator is not None:
+                iterator = initial_iterator
+            else:
+                if not hasattr(iterable, "__iter__"):
+                    raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
+                iterator = self.handle_call(generator.iter, iterable.__iter__)
             if not isinstance(iterator, SonolusIterator):
                 raise ValueError("Unsupported iterator")
             header_ctx = ctx().branch(None)
@@ -493,6 +520,8 @@ class Visitor(ast.NodeVisitor):
             if break_ctxs:
                 set_ctx(Context.meet([*break_ctxs, ctx()]))
             return
+        if not hasattr(iterable, "__iter__"):
+            raise TypeError(f"Object of type '{type(iterable).__name__}' is not iterable")
         iterator = self.handle_call(node, iterable.__iter__)
         if not isinstance(iterator, SonolusIterator):
             raise ValueError("Unsupported iterator")
@@ -980,6 +1009,8 @@ class Visitor(ast.NodeVisitor):
                 self.resume_ctxs.append(resume_ctx)
                 set_ctx(resume_ctx)
             return validate_value(None)
+        if not hasattr(value, "__iter__"):
+            raise TypeError(f"Object of type '{type(value).__name__}' is not iterable")
         iterator = self.handle_call(node, value.__iter__)
         if not isinstance(iterator, SonolusIterator):
             raise ValueError("Expected a SonolusIterator")
@@ -1395,6 +1426,9 @@ class Visitor(ast.NodeVisitor):
         self, node: ast.stmt | ast.expr, fn: Callable[P, R], /, *args: P.args, **kwargs: P.kwargs
     ) -> R:
         """Executes the given function at the given node for a better traceback."""
+        if ctx().no_eval:
+            return fn(*args, **kwargs)
+
         location_args = {
             "lineno": node.lineno,
             "col_offset": node.col_offset,

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/sonolus/build/cli.py

@@ -166,13 +166,13 @@ def main():
     def add_common_arguments(parser):
         optimization_group = parser.add_mutually_exclusive_group()
         optimization_group.add_argument(
-            "-o0", "--optimize-minimal", action="store_true", help="Use minimal optimization passes"
+            "-O0", "--optimize-minimal", action="store_true", help="Use minimal optimization passes"
         )
         optimization_group.add_argument(
-            "-o1", "--optimize-fast", action="store_true", help="Use fast optimization passes"
+            "-O1", "--optimize-fast", action="store_true", help="Use fast optimization passes"
         )
         optimization_group.add_argument(
-            "-o2", "--optimize-standard", action="store_true", help="Use standard optimization passes"
+            "-O2", "--optimize-standard", action="store_true", help="Use standard optimization passes"
         )
 
         build_components = parser.add_argument_group("build components")

{sonolus_py-0.4.0 → sonolus_py-0.4.2}/sonolus/build/compile.py

@@ -21,6 +21,7 @@ from sonolus.script.internal.context import (
     ctx,
     using_ctx,
 )
+from sonolus.script.internal.error import CompilationError
 from sonolus.script.num import _is_num
 
 
@@ -140,7 +141,21 @@ def callback_to_cfg(
     name: str,
     archetype: type[_BaseArchetype] | None = None,
 ) -> BasicBlock:
-    callback_state = CallbackContextState(name)
+    try:
+        # Default to no_eval=True for performance unless there's an error.
+        return _callback_to_cfg(global_state, callback, name, archetype, no_eval=True)
+    except CompilationError:
+        return _callback_to_cfg(global_state, callback, name, archetype, no_eval=False)
+
+
+def _callback_to_cfg(
+    global_state: GlobalContextState,
+    callback: Callable,
+    name: str,
+    archetype: type[_BaseArchetype] | None,
+    no_eval: bool,
+) -> BasicBlock:
+    callback_state = CallbackContextState(name, no_eval=no_eval)
     context = Context(global_state, callback_state)
     with using_ctx(context):
         if archetype is not None: