sonolus.py 0.3.4__py3-none-any.whl → 0.4.1__py3-none-any.whl

sonolus/script/debug.py

@@ -4,18 +4,9 @@ from typing import Any, Literal, Never
 
 from sonolus.backend.mode import Mode
 from sonolus.backend.ops import Op
-from sonolus.backend.optimize.constant_evaluation import SparseConditionalConstantPropagation
-from sonolus.backend.optimize.copy_coalesce import CopyCoalesce
-from sonolus.backend.optimize.dead_code import (
-    AdvancedDeadCodeElimination,
-    DeadCodeElimination,
-    UnreachableCodeElimination,
-)
 from sonolus.backend.optimize.flow import cfg_to_mermaid
-from sonolus.backend.optimize.inlining import InlineVars
-from sonolus.backend.optimize.passes import CompilerPass, run_passes
-from sonolus.backend.optimize.simplify import CoalesceFlow, NormalizeSwitch, RewriteToSwitch
-from sonolus.backend.optimize.ssa import FromSSA, ToSSA
+from sonolus.backend.optimize.passes import CompilerPass, OptimizerConfig, run_passes
+from sonolus.backend.optimize.simplify import RenumberVars
 from sonolus.script.internal.context import GlobalContextState, ReadOnlyMemory, ctx, set_ctx
 from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.native import native_function
@@ -26,13 +17,13 @@ debug_log_callback = ContextVar[Callable[[Num], None]]("debug_log_callback")
 
 
 @meta_fn
-def error(message: str | None = None) -> Never:
+def error(message: str | None = None) -> Never:  # type: ignore
     """Raise an error.
 
     This function is used to raise an error during runtime.
     When this happens, the game will pause in debug mode. The current callback will also immediately return 0.
     """
-    message = validate_value(message)._as_py_() if message is not None else "Error"
+    message = validate_value(message)._as_py_() or "Error"  # type: ignore
     if not isinstance(message, str):
         raise ValueError("Expected a string")
     if ctx():
@@ -50,7 +41,7 @@ def static_error(message: str | None = None) -> Never:
     This function is used to raise an error during compile-time if the compiler cannot guarantee that
     this function will not be called during runtime.
     """
-    message = validate_value(message)._as_py_() if message is not None else "Error"
+    message = validate_value(message)._as_py_() or "Error"  # type: ignore
     if not isinstance(message, str):
         raise ValueError("Expected a string")
     raise RuntimeError(message)
@@ -60,7 +51,7 @@ def static_error(message: str | None = None) -> Never:
 def debug_log(value: int | float | bool):
     """Log a value in debug mode."""
     if debug_log_callback.get(None):
-        return debug_log_callback.get()(value)
+        return debug_log_callback.get()(value)  # type: ignore
     else:
         return _debug_log(value)
 
@@ -91,7 +82,7 @@ def assert_false(value: int | float | bool, message: str | None = None):
 
 @meta_fn
 def assert_unreachable(message: str | None = None) -> Never:
-    message = validate_value(message)._as_py_() or "Unreachable code reached"
+    message = validate_value(message)._as_py_() or "Unreachable code reached"  # type: ignore
     raise RuntimeError(message)
 
 
@@ -108,43 +99,29 @@ def visualize_cfg(
     /,
     *,
     mode: Mode = Mode.PLAY,
+    callback: str = "",
     archetype: type | None = None,
-    archetypes: list[type] | None,
-    passes: Sequence[CompilerPass] | Literal["minimal", "basic", "standard"] = "basic",
+    archetypes: list[type] | None = None,
+    passes: Sequence[CompilerPass] | Literal["minimal", "fast", "standard"] = "fast",
 ) -> str:
+    from sonolus.backend.optimize.optimize import FAST_PASSES, MINIMAL_PASSES, STANDARD_PASSES
     from sonolus.build.compile import callback_to_cfg
 
     match passes:
         case "minimal":
             passes = [
-                CoalesceFlow(),
+                *MINIMAL_PASSES[:-1],
+                RenumberVars(),
             ]
-        case "basic":
+        case "fast":
             passes = [
-                CoalesceFlow(),
-                UnreachableCodeElimination(),
-                AdvancedDeadCodeElimination(),
-                CoalesceFlow(),
+                *FAST_PASSES[:-1],
+                RenumberVars(),
             ]
         case "standard":
             passes = [
-                CoalesceFlow(),
-                UnreachableCodeElimination(),
-                DeadCodeElimination(),
-                ToSSA(),
-                SparseConditionalConstantPropagation(),
-                UnreachableCodeElimination(),
-                DeadCodeElimination(),
-                CoalesceFlow(),
-                InlineVars(),
-                DeadCodeElimination(),
-                RewriteToSwitch(),
-                FromSSA(),
-                CoalesceFlow(),
-                CopyCoalesce(),
-                AdvancedDeadCodeElimination(),
-                CoalesceFlow(),
-                NormalizeSwitch(),
+                *STANDARD_PASSES[:-1],
+                RenumberVars(),
             ]
 
     global_state = GlobalContextState(
@@ -153,8 +130,8 @@ def visualize_cfg(
         ReadOnlyMemory(),
     )
 
-    cfg = callback_to_cfg(global_state, fn, "", archetype=archetype)
-    cfg = run_passes(cfg, passes)
+    cfg = callback_to_cfg(global_state, fn, callback, archetype=archetype)  # type: ignore
+    cfg = run_passes(cfg, passes, OptimizerConfig(mode=mode))
     return cfg_to_mermaid(cfg)
 
 

sonolus/script/effect.py

@@ -134,7 +134,7 @@ def effect(name: str) -> Any:
     return EffectInfo(name)
 
 
-type Effects = NewType("Effects", Any)
+type Effects = NewType("Effects", Any)  # type: ignore
 
 
 @dataclass_transform()

sonolus/script/globals.py

@@ -39,7 +39,7 @@ class _GlobalField(SonolusDescriptor):
         if not ctx():
             raise RuntimeError("Global field access outside of compilation")
         base = ctx().get_global_base(info)
-        return self.type._from_place_(base.add_offset(self.offset))._get_()
+        return self.type._from_place_(base.add_offset(self.offset))._get_readonly_()
 
     def __set__(self, instance, value):
         from sonolus.script.internal.context import ctx
@@ -96,8 +96,8 @@ def _create_global(cls: type, blocks: dict[Mode, Block], offset: int | None):
         type_ = validate_concrete_type(annotation)
         setattr(cls, name, _GlobalField(name, type_, i, field_offset))
         field_offset += type_._size_()
-    cls._global_info_ = _GlobalInfo(cls.__name__, field_offset, blocks, offset)
-    cls._is_comptime_value_ = True
+    cls._global_info_ = _GlobalInfo(cls.__name__, field_offset, blocks, offset)  # type: ignore
+    cls._is_comptime_value_ = True  # type: ignore
     return cls()
 
 

sonolus/script/instruction.py

@@ -70,8 +70,8 @@ def instruction_icon(name: str) -> Any:
     return _InstructionIconInfo(name=name)
 
 
-type TutorialInstructions = NewType("TutorialInstructions", Any)
-type TutorialInstructionIcons = NewType("TutorialInstructionIcons", Any)
+type TutorialInstructions = NewType("TutorialInstructions", Any)  # type: ignore
+type TutorialInstructionIcons = NewType("TutorialInstructionIcons", Any)  # type: ignore
 
 
 @dataclass_transform()

sonolus/script/internal/builtin_impls.py

@@ -1,12 +1,12 @@
-from collections.abc import Iterable
-from typing import overload
-
+from sonolus.backend.ops import Op
 from sonolus.script.array import Array
 from sonolus.script.array_like import ArrayLike
+from sonolus.script.debug import error
 from sonolus.script.internal.context import ctx
 from sonolus.script.internal.dict_impl import DictImpl
 from sonolus.script.internal.impl import meta_fn, validate_value
 from sonolus.script.internal.math_impls import MATH_BUILTIN_IMPLS, _trunc
+from sonolus.script.internal.native import native_function
 from sonolus.script.internal.random import RANDOM_BUILTIN_IMPLS
 from sonolus.script.internal.range import Range
 from sonolus.script.internal.tuple_impl import TupleImpl
@@ -21,6 +21,8 @@ from sonolus.script.iterator import (
 )
 from sonolus.script.num import Num, _is_num
 
+_empty = object()
+
 
 @meta_fn
 def _isinstance(value, type_):
@@ -44,7 +46,7 @@ def _len(value):
     value = validate_value(value)
     if not hasattr(value, "__len__"):
         raise TypeError(f"object of type '{type(value).__name__}' has no len()")
-    return compile_and_call(value.__len__)
+    return compile_and_call(value.__len__)  # type: ignore
 
 
 @meta_fn
@@ -59,7 +61,7 @@ def _enumerate(iterable, start=0):
     elif isinstance(iterable, ArrayLike):
         return compile_and_call(iterable._enumerate_, start)
     else:
-        iterator = compile_and_call(iterable.__iter__)
+        iterator = compile_and_call(iterable.__iter__)  # type: ignore
         if not isinstance(iterator, SonolusIterator):
             raise TypeError("Only subclasses of SonolusIterator are supported as iterators")
         return _Enumerator(0, start, iterator)
@@ -104,25 +106,20 @@ def _abs(value):
     value = validate_value(value)
     if not hasattr(value, "__abs__"):
         raise TypeError(f"bad operand type for abs(): '{type(value).__name__}'")
-    return compile_and_call(value.__abs__)
+    return compile_and_call(value.__abs__)  # type: ignore
 
 
 def _identity(value):
     return value
 
 
-@overload
-def _max[T](iterable: Iterable[T], *, key: callable = ...) -> T: ...
-
-
-@overload
-def _max[T](a: T, b: T, *args: T, key: callable = ...) -> T: ...
-
-
 @meta_fn
-def _max(*args, key: callable = _identity):
+def _max(*args, default=_empty, key=None):
     from sonolus.backend.visitor import compile_and_call
 
+    if key is None:
+        key = _identity
+
     args = tuple(validate_value(arg) for arg in args)
     if len(args) == 0:
         raise ValueError("Expected at least one argument to max")
@@ -131,40 +128,91 @@ def _max(*args, key: callable = _identity):
         if isinstance(iterable, ArrayLike):
             return compile_and_call(iterable._max_, key=key)
         elif isinstance(iterable, TupleImpl) and all(_is_num(v) for v in iterable.value):
+            if len(iterable.value) == 0:
+                if default is not _empty:
+                    return default
+                raise ValueError("max() arg is an empty sequence")
             return compile_and_call(Array(*iterable.value)._max_, key=key)
+        elif isinstance(iterable, SonolusIterator):
+            if not (default is _empty or Num._accepts_(default)):
+                raise TypeError("default argument must be a number")
+            return compile_and_call(
+                _max_num_iterator,
+                iterable,
+                Num._accept_(default) if default is not _empty else None,
+                key=key if key is not _identity else None,
+            )
         else:
             raise TypeError(f"Unsupported type: {type(iterable)} for max")
     else:
+        if default is not _empty:
+            raise TypeError("default argument is not supported for max with multiple arguments")
         if not all(_is_num(arg) for arg in args):
             raise TypeError("Arguments to max must be numbers")
         if ctx():
-            result = compile_and_call(_max2, args[0], args[1], key=key)
+            result = _max2(args[0], args[1], key=key)
             for arg in args[2:]:
-                result = compile_and_call(_max2, result, arg, key=key)
+                result = _max2(result, arg, key=key)
             return result
         else:
             return max(arg._as_py_() for arg in args)
 
 
 def _max2(a, b, key=_identity):
-    if key(a) > key(b):
+    from sonolus.backend.visitor import compile_and_call
+
+    a = validate_value(a)
+    b = validate_value(b)
+    if _is_num(a) and _is_num(b) and key == _identity:
+        return compile_and_call(_max2_num, a, b)
+    return compile_and_call(_max2_generic, a, b, key=key)
+
+
+@native_function(Op.Max)
+def _max2_num(a, b):
+    if a > b:
         return a
     else:
         return b
 
 
-@overload
-def _min[T](iterable: Iterable[T], *, key: callable = ...) -> T: ...
+def _max2_generic(a, b, key=_identity):
+    if key(a) > key(b):
+        return a
+    else:
+        return b
 
 
-@overload
-def _min[T](a: T, b: T, *args: T, key: callable = ...) -> T: ...
+def _max_num_iterator(iterable, default, key):
+    iterator = iterable.__iter__()  # noqa: PLC2801
+    initial = iterator.next()
+    if initial.is_nothing:
+        assert default is not None
+        return default
+    if key is not None:
+        result = initial.get_unsafe()
+        best_key = key(result)
+        for value in iterator:
+            new_key = key(value)
+            if new_key > best_key:
+                result = value
+                best_key = new_key
+        return result
+    else:
+        result = initial.get_unsafe()
+        for value in iterator:
+            if value > result:  # noqa: PLR1730
+                result = value
+        return result
 
 
 @meta_fn
-def _min(*args, key: callable = _identity):
+def _min(*args, default=_empty, key=None):
     from sonolus.backend.visitor import compile_and_call
 
+    if key is None:
+        key = _identity
+
     args = tuple(validate_value(arg) for arg in args)
     if len(args) == 0:
         raise ValueError("Expected at least one argument to min")
@@ -173,34 +221,92 @@ def _min(*args, key: callable = _identity):
         if isinstance(iterable, ArrayLike):
             return compile_and_call(iterable._min_, key=key)
         elif isinstance(iterable, TupleImpl) and all(_is_num(v) for v in iterable.value):
+            if len(iterable.value) == 0:
+                if default is not _empty:
+                    return default
+                raise ValueError("min() arg is an empty sequence")
             return compile_and_call(Array(*iterable.value)._min_, key=key)
+        elif isinstance(iterable, SonolusIterator):
+            if not (default is _empty or Num._accepts_(default)):
+                raise TypeError("default argument must be a number")
+            return compile_and_call(
+                _min_num_iterator,
+                iterable,
+                Num._accept_(default) if default is not _empty else None,
+                key=key if key is not _identity else None,
+            )
         else:
             raise TypeError(f"Unsupported type: {type(iterable)} for min")
     else:
+        if default is not _empty:
+            raise TypeError("default argument is not supported for min with multiple arguments")
         if not all(_is_num(arg) for arg in args):
             raise TypeError("Arguments to min must be numbers")
         if ctx():
-            result = compile_and_call(_min2, args[0], args[1], key=key)
+            result = _min2(args[0], args[1], key=key)
             for arg in args[2:]:
-                result = compile_and_call(_min2, result, arg, key=key)
+                result = _min2(result, arg, key=key)
             return result
         else:
             return min(arg._as_py_() for arg in args)
 
 
 def _min2(a, b, key=_identity):
+    from sonolus.backend.visitor import compile_and_call
+
+    a = validate_value(a)
+    b = validate_value(b)
+    if _is_num(a) and _is_num(b) and key == _identity:
+        return compile_and_call(_min2_num, a, b)
+    return compile_and_call(_min2_generic, a, b, key=key)
+
+
+@native_function(Op.Min)
+def _min2_num(a, b):
+    if a < b:
+        return a
+    else:
+        return b
+
+
+def _min2_generic(a, b, key=_identity):
     if key(a) < key(b):
         return a
     else:
         return b
 
 
+def _min_num_iterator(iterable, default, key):
+    iterator = iterable.__iter__()  # noqa: PLC2801
+    initial = iterator.next()
+    if initial.is_nothing:
+        assert default is not None
+        return default
+    if key is not None:
+        result = initial.get_unsafe()
+        best_key = key(result)
+        for value in iterator:
+            new_key = key(value)
+            if new_key < best_key:
+                result = value
+                best_key = new_key
+        return result
+    else:
+        result = initial.get_unsafe()
+        for value in iterator:
+            if value < result:  # noqa: PLR1730
+                result = value
+        return result
+
+
 @meta_fn
 def _callable(value):
     return callable(value)
 
 
 def _map(fn, iterable, *iterables):
+    if len(iterables) == 0:
+        return _MappingIterator(fn, iterable.__iter__())  # noqa: PLC2801
     return _MappingIterator(lambda args: fn(*args), zip(iterable, *iterables))  # noqa: B905
 
 
@@ -234,9 +340,9 @@ def _bool(value=False):
         return False
 
 
-_int._type_mapping_ = Num
-_float._type_mapping_ = Num
-_bool._type_mapping_ = Num
+_int._type_mapping_ = Num  # type: ignore
+_float._type_mapping_ = Num  # type: ignore
+_bool._type_mapping_ = Num  # type: ignore
 
 
 def _any(iterable):
@@ -253,12 +359,31 @@ def _all(iterable):
     return True
 
 
+def _sum(iterable, /, start=0):
+    for value in iterable:
+        start += value
+    return start
+
+
+def _next(iterator):
+    assert isinstance(iterator, SonolusIterator)
+    value = iterator.next()
+    if value.is_some:
+        return value.get_unsafe()
+    error("Iterator has been exhausted")
+
+
+def _iter(iterable):
+    return iterable.__iter__()  # type: ignore # noqa: PLC2801
+
+
 # classmethod, property, staticmethod are supported as decorators, but not within functions
 
 BUILTIN_IMPLS = {
     id(abs): _abs,
     id(all): _all,
     id(any): _any,
+    id(sum): _sum,
     id(bool): _bool,
     id(callable): _callable,
     id(enumerate): _enumerate,
@@ -266,10 +391,12 @@ BUILTIN_IMPLS = {
     id(float): _float,
     id(int): _int,
     id(isinstance): _isinstance,
+    id(iter): _iter,
     id(len): _len,
     id(map): _map,
     id(max): _max,
     id(min): _min,
+    id(next): _next,
     id(range): Range,
     id(reversed): _reversed,
     id(zip): _zip,

sonolus/script/internal/constant.py

@@ -48,8 +48,8 @@ class ConstantValue(Value):
         class Parameterized(cls):
             _value = (parameter,)
 
-        Parameterized.__name__ = f"{parameter}"
-        Parameterized.__qualname__ = f"{parameter}"
+        Parameterized.__name__ = f"Const[{object.__repr__(parameter)}]"  # noqa: PLC2801
+        Parameterized.__qualname__ = Parameterized.__name__
         Parameterized.__module__ = cls.__module__
         Parameterized.instance = object.__new__(Parameterized)
         return Parameterized
@@ -113,7 +113,7 @@ class ConstantValue(Value):
         if value is not self:
             raise ValueError(f"{type(self).__name__} is immutable")
 
-    def _copy_from_(self, value: Self):
+    def _copy_from_(self, value: Any):
         if value is not self:
             raise ValueError(f"{type(self).__name__} is immutable")
 
@@ -143,3 +143,13 @@ class ConstantValue(Value):
 
 class BasicConstantValue(ConstantValue):
     """For constants without any special behavior."""
+
+
+class TypingSpecialFormConstant(ConstantValue):
+    """For constants that are typing special forms that have a [] operator."""
+
+    @meta_fn
+    def __getitem__(self, item: Any) -> Self:
+        if not item._is_py_():
+            raise TypeError(f"Invalid value for type parameter: {item}")
+        return self.value()[item._as_py_()]