tpy-lang 0.3.0.dev0__py3-none-any.whl

tpyc/test_ref_type.py

@@ -0,0 +1,216 @@
+"""Tests for RefType and make_ref."""
+
+from .typesys import (
+    RefType, make_ref, unwrap_ref_type, is_ref_type,
+    OwnType, ReadonlyType, OptionalType, UnionType,
+    VoidType, NoneType, TypeParamRef, TypeParamKind,
+    INT32, STR, BOOL, VOID, FLOAT,
+    NominalType, make_list,
+)
+
+
+class TestRefTypeConstruction:
+    def test_basic(self):
+        point = NominalType("Point")
+        ref = RefType(point)
+        assert ref.wrapped is point
+        assert str(ref) == "Ref[Point]"
+
+    def test_is_value_type(self):
+        ref = RefType(NominalType("Point"))
+        assert not ref.is_value_type()
+
+    def test_is_ref_param(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.is_ref_param()
+
+    def test_inner_types(self):
+        point = NominalType("Point")
+        ref = RefType(point)
+        assert ref.inner_types() == (point,)
+
+    def test_with_inner_types(self):
+        point = NominalType("Point")
+        dog = NominalType("Dog")
+        ref = RefType(point)
+        ref2 = ref.with_inner_types((dog,))
+        assert isinstance(ref2, RefType)
+        assert ref2.wrapped is dog
+
+    def test_equality(self):
+        a = RefType(NominalType("Point"))
+        b = RefType(NominalType("Point"))
+        assert a == b
+
+    def test_inequality(self):
+        a = RefType(NominalType("Point"))
+        b = RefType(NominalType("Dog"))
+        assert a != b
+
+
+class TestRefTypeToCpp:
+    """Verify RefType produces the same C++ as the current non-value type methods."""
+
+    def test_to_cpp_concrete(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.to_cpp() == "Point&"
+
+    def test_to_cpp_return(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.to_cpp_return() == "Point&"
+
+    def test_to_cpp_return_const(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.to_cpp_return_const() == "const Point&"
+
+    def test_to_cpp_param_type(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.to_cpp_param_type() == "Point&"
+
+    def test_to_cpp_param(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.to_cpp_param("x") == "Point& x"
+
+    def test_to_cpp_const_param(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.to_cpp_const_param("x") == "const Point& x"
+
+    def test_to_cpp_stored(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.to_cpp_stored() == "::tpy::val_or_ref<Point>"
+
+    def test_to_cpp_stored_list(self):
+        ref = RefType(make_list(INT32))
+        assert ref.to_cpp_stored() == "::tpy::val_or_ref<std::vector<int32_t>>"
+
+
+class TestRefTypeParamRef:
+    """Verify RefType with TypeParamRef uses C++ trait aliases."""
+
+    def test_to_cpp(self):
+        ref = RefType(TypeParamRef("T"))
+        assert ref.to_cpp() == "::tpy::val_or_ref_t<T>"
+
+    def test_to_cpp_return(self):
+        ref = RefType(TypeParamRef("T"))
+        assert ref.to_cpp_return() == "::tpy::val_or_ref_t<T>"
+
+    def test_to_cpp_return_const(self):
+        ref = RefType(TypeParamRef("T"))
+        assert ref.to_cpp_return_const() == "::tpy::val_or_cref_t<T>"
+
+    def test_to_cpp_param_type(self):
+        ref = RefType(TypeParamRef("T"))
+        assert ref.to_cpp_param_type() == "::tpy::param_val_or_ref_t<T>"
+
+    def test_to_cpp_stored(self):
+        ref = RefType(TypeParamRef("T"))
+        assert ref.to_cpp_stored() == "::tpy::val_or_ref<T>"
+
+
+class TestMakeRef:
+    """Test the smart constructor that decides when to wrap."""
+
+    def test_non_value_type_wrapped(self):
+        point = NominalType("Point")
+        result = make_ref(point)
+        assert isinstance(result, RefType)
+        assert result.wrapped is point
+
+    def test_list_wrapped(self):
+        lst = make_list(INT32)
+        result = make_ref(lst)
+        assert isinstance(result, RefType)
+        assert result.wrapped is lst
+
+    def test_value_type_not_wrapped(self):
+        assert make_ref(INT32) is INT32
+        assert make_ref(STR) is STR
+        assert make_ref(BOOL) is BOOL
+        assert make_ref(FLOAT) is FLOAT
+
+    def test_own_not_wrapped(self):
+        own = OwnType(NominalType("Point"))
+        assert make_ref(own) is own
+
+    def test_readonly_not_wrapped(self):
+        ro = ReadonlyType(NominalType("Point"))
+        assert make_ref(ro) is ro
+
+    def test_optional_not_wrapped(self):
+        opt = OptionalType(NominalType("Point"))
+        assert make_ref(opt) is opt
+
+    def test_union_not_wrapped(self):
+        union = UnionType((NominalType("Dog"), NominalType("Cat")))
+        assert make_ref(union) is union
+
+    def test_void_not_wrapped(self):
+        assert make_ref(VOID) is VOID
+
+    def test_none_not_wrapped(self):
+        none = NoneType()
+        assert make_ref(none) is none
+
+    def test_ref_not_double_wrapped(self):
+        ref = RefType(NominalType("Point"))
+        assert make_ref(ref) is ref
+
+    def test_type_param_ref_wrapped(self):
+        tpr = TypeParamRef("T")
+        result = make_ref(tpr)
+        assert isinstance(result, RefType)
+        assert result.wrapped is tpr
+
+    def test_type_param_ref_int_kind_not_wrapped(self):
+        tpr = TypeParamRef("N", kind=TypeParamKind.INT)
+        assert make_ref(tpr) is tpr
+
+    def test_type_param_ref_value_bound_not_wrapped(self):
+        bound = NominalType("ValueType", is_protocol=True,
+                          _module_qname="tpy.ValueType")
+        tpr = TypeParamRef("T", bound=bound)
+        # is_value_type() returns True when bounded to tpy.ValueType
+        assert tpr.is_value_type()
+        assert make_ref(tpr) is tpr
+
+
+class TestUnwrapRefType:
+    def test_unwrap_ref(self):
+        point = NominalType("Point")
+        ref = RefType(point)
+        assert unwrap_ref_type(ref) is point
+
+    def test_unwrap_non_ref(self):
+        point = NominalType("Point")
+        assert unwrap_ref_type(point) is point
+
+    def test_unwrap_value_type(self):
+        assert unwrap_ref_type(INT32) is INT32
+
+
+class TestIsRefType:
+    def test_ref(self):
+        assert is_ref_type(RefType(NominalType("Point")))
+
+    def test_non_ref(self):
+        assert not is_ref_type(NominalType("Point"))
+        assert not is_ref_type(INT32)
+        assert not is_ref_type(OwnType(NominalType("Point")))
+
+
+class TestToCppStored:
+    """Test base class to_cpp_stored() default behavior."""
+
+    def test_value_type_stored_same_as_to_cpp(self):
+        assert INT32.to_cpp_stored() == INT32.to_cpp()
+        assert STR.to_cpp_stored() == STR.to_cpp()
+
+    def test_non_value_type_stored_same_as_to_cpp(self):
+        point = NominalType("Point")
+        assert point.to_cpp_stored() == point.to_cpp()
+
+    def test_ref_type_stored_uses_val_or_ref(self):
+        ref = RefType(NominalType("Point"))
+        assert ref.to_cpp_stored() == "::tpy::val_or_ref<Point>"
+        assert ref.to_cpp_stored() != ref.to_cpp()

tpyc/test_send_sync_substitution.py

@@ -0,0 +1,276 @@
+"""Unit tests for NominalType.is_send / is_sync substitution at use sites.
+
+`RecordInfo.is_send` / `is_sync` are computed at registration with any
+field whose type mentions a TypeParamRef treated as conservatively-OK.
+The use site re-walks fields and parents under concrete `type_args`,
+so the answer is correct in both directions: types wrapping a non-Send
+concrete arg report False, and types wrapping a Send concrete arg
+report True even when the registration-time bool was conservative.
+"""
+
+import pytest
+
+from .typesys import (
+    INT32, FieldInfo, NominalType, OptionalType, PtrType, RecordInfo,
+    TypeParamRef, make_list,
+)
+from .type_def_registry import (
+    TypeCategory, attach_dynamic_type_def, clear_dynamic_type_defs,
+)
+
+
+@pytest.fixture
+def _box_recordinfo():
+    """Register Box[T] with `data: T` (a bare TypeParamRef field).
+
+    At registration, the disjunction in sema/registration.py accepts the
+    TypeParamRef-typed field as conservatively-OK, so `is_send` /
+    `is_sync` would be True. We set those flags manually here because
+    the unit test bypasses sema.
+    """
+    info = RecordInfo(
+        name="Box",
+        fields=[FieldInfo(name="data", type=TypeParamRef("T"))],
+        type_params=["T"],
+        is_send=True,
+        is_sync=True,
+    )
+    attach_dynamic_type_def("Box", TypeCategory.RECORD, record=info)
+    try:
+        yield info
+    finally:
+        clear_dynamic_type_defs()
+
+
+@pytest.fixture
+def _wrapper_with_send_int_field():
+    """Register Wrapper[T] with a `tag: Int32` field plus `data: T`.
+
+    Exercises that concrete-typed fields keep their definition-time
+    answer (Int32 is Send) while the TypeParamRef field is re-checked
+    under substitution.
+    """
+    info = RecordInfo(
+        name="Wrapper",
+        fields=[
+            FieldInfo(name="tag", type=INT32),
+            FieldInfo(name="data", type=TypeParamRef("T")),
+        ],
+        type_params=["T"],
+        is_send=True,
+        is_sync=True,
+    )
+    attach_dynamic_type_def("Wrapper", TypeCategory.RECORD, record=info)
+    try:
+        yield info
+    finally:
+        clear_dynamic_type_defs()
+
+
+def _box(arg) -> NominalType:
+    return NominalType("Box", type_args=(arg,), _module_qname="Box")
+
+
+def _wrapper(arg) -> NominalType:
+    return NominalType("Wrapper", type_args=(arg,), _module_qname="Wrapper")
+
+
+def _buf() -> NominalType:
+    # Stand-in for a user record. No registration needed -- its is_send /
+    # is_sync defaults (value-type fallback returning False for an
+    # unregistered nominal) are fine; PtrType.is_send is unconditionally
+    # False which is the only fact this test relies on.
+    return NominalType("Buf", _module_qname="user.Buf")
+
+
+class TestGenericRecordSendSync:
+    def test_box_of_int_is_send(self, _box_recordinfo) -> None:
+        """Int32 is Send -> Box[Int32] is Send (record bool stays True)."""
+        assert _box(INT32).is_send() is True
+        assert _box(INT32).is_sync() is True
+
+    def test_box_of_ptr_is_not_send(self, _box_recordinfo) -> None:
+        """Ptr[Buf] is not Send -> Box[Ptr[Buf]] is not Send despite the
+        registration-time bool being True."""
+        ptr_buf = PtrType(_buf())
+        assert ptr_buf.is_send() is False
+        assert _box(ptr_buf).is_send() is False
+
+    def test_box_of_ptr_is_not_sync(self, _box_recordinfo) -> None:
+        """Same shape for is_sync."""
+        ptr_buf = PtrType(_buf())
+        assert ptr_buf.is_sync() is False
+        assert _box(ptr_buf).is_sync() is False
+
+    def test_wrapper_concrete_field_preserved(
+        self, _wrapper_with_send_int_field,
+    ) -> None:
+        """Concrete-typed fields that were Send at registration stay Send;
+        only the TypeParamRef-typed field flips under substitution."""
+        assert _wrapper(INT32).is_send() is True
+        assert _wrapper(PtrType(_buf())).is_send() is False
+
+    def test_concrete_non_send_field_stays_false(self) -> None:
+        """A generic record whose concrete-typed field is non-Send fails
+        the walker regardless of the type_args. The cached bool from
+        registration is False, but the walker reproduces the same answer
+        by walking the concrete field and finding it non-Send."""
+        info = RecordInfo(
+            name="Holder",
+            fields=[FieldInfo(name="p", type=PtrType(_buf()))],
+            type_params=["T"],
+            is_send=False,
+            is_sync=False,
+        )
+        attach_dynamic_type_def("Holder", TypeCategory.RECORD, record=info)
+        try:
+            holder = NominalType("Holder", type_args=(INT32,),
+                                 _module_qname="Holder")
+            assert holder.is_send() is False
+            assert holder.is_sync() is False
+        finally:
+            clear_dynamic_type_defs()
+
+    def test_non_generic_record_unaffected(self) -> None:
+        """Non-generic records (no type_params) take the same path but
+        the substitution helper no-ops; the record-level bool wins."""
+        info = RecordInfo(
+            name="Plain",
+            fields=[FieldInfo(name="x", type=INT32)],
+            is_send=True,
+            is_sync=True,
+        )
+        attach_dynamic_type_def("Plain", TypeCategory.RECORD, record=info)
+        try:
+            plain = NominalType("Plain", _module_qname="Plain")
+            assert plain.is_send() is True
+            assert plain.is_sync() is True
+        finally:
+            clear_dynamic_type_defs()
+
+    def test_list_of_typeparam_flips_true(self) -> None:
+        """`class W[T]: c: list[T]` -- at registration `list[T].is_send()`
+        evaluates to False because the TypeDef callable propagates
+        `T.is_send() == False`. The use-site walker substitutes the
+        concrete `type_args`, so W[Int32] correctly reports True."""
+        info = RecordInfo(
+            name="W",
+            fields=[FieldInfo(
+                name="c", type=make_list(element_type=TypeParamRef("T")),
+            )],
+            type_params=["T"],
+        )
+        attach_dynamic_type_def("W", TypeCategory.RECORD, record=info)
+        try:
+            assert NominalType(
+                "W", type_args=(INT32,), _module_qname="W",
+            ).is_send() is True
+            assert NominalType(
+                "W", type_args=(PtrType(_buf()),), _module_qname="W",
+            ).is_send() is False
+            # Mirror for is_sync to exercise _evaluating_sync.
+            # `list[T].is_sync()` is always False (mutable container), so
+            # the answer for W[anything] is False regardless of the arg.
+            assert NominalType(
+                "W", type_args=(INT32,), _module_qname="W",
+            ).is_sync() is False
+        finally:
+            clear_dynamic_type_defs()
+
+    def test_self_recursive_generic(self) -> None:
+        """`class Tree[T]: value: T; children: list[Tree[T]]` is the
+        canonical self-recursive generic. The cycle guard returns True
+        (greatest fixed point) on re-entry, so the answer is decided by
+        the non-recursive value field: Tree[Int32] is Send (Int32 is
+        Send), Tree[Ptr[Buf]] is not."""
+        info = RecordInfo(
+            name="Tree",
+            fields=[
+                FieldInfo(name="value", type=TypeParamRef("T")),
+                FieldInfo(
+                    name="children",
+                    type=make_list(element_type=NominalType(
+                        "Tree", type_args=(TypeParamRef("T"),),
+                        _module_qname="Tree",
+                    )),
+                ),
+            ],
+            type_params=["T"],
+        )
+        attach_dynamic_type_def("Tree", TypeCategory.RECORD, record=info)
+        try:
+            assert NominalType(
+                "Tree", type_args=(INT32,), _module_qname="Tree",
+            ).is_send() is True
+            assert NominalType(
+                "Tree", type_args=(PtrType(_buf()),), _module_qname="Tree",
+            ).is_send() is False
+        finally:
+            clear_dynamic_type_defs()
+
+    def test_self_recursive_generic_sync_via_optional(self) -> None:
+        """Counterpart to test_self_recursive_generic for is_sync.
+
+        `list[T]` short-circuits is_sync to False (mutable container), so
+        the prior test never re-enters the walker for is_sync and
+        `_evaluating_sync` never fires. Optional[T] passes is_sync
+        through to T, so a Tree whose recursive field is Optional[Tree[T]]
+        forces the walker to re-enter Tree[Int32].is_sync() recursively,
+        exercising the greatest-fixed-point branch."""
+        info = RecordInfo(
+            name="Tree",
+            fields=[
+                FieldInfo(name="value", type=TypeParamRef("T")),
+                FieldInfo(
+                    name="child",
+                    type=OptionalType(NominalType(
+                        "Tree", type_args=(TypeParamRef("T"),),
+                        _module_qname="Tree",
+                    )),
+                ),
+            ],
+            type_params=["T"],
+        )
+        attach_dynamic_type_def("Tree", TypeCategory.RECORD, record=info)
+        try:
+            assert NominalType(
+                "Tree", type_args=(INT32,), _module_qname="Tree",
+            ).is_sync() is True
+            assert NominalType(
+                "Tree", type_args=(PtrType(_buf()),), _module_qname="Tree",
+            ).is_sync() is False
+        finally:
+            clear_dynamic_type_defs()
+
+    def test_generic_parent_substituted(self) -> None:
+        """A child record inheriting from a generic parent must also have
+        its parent re-walked under substitution -- otherwise Child[T]'s
+        registration True latches in even when Parent[T] would be False
+        at the use site."""
+        parent = RecordInfo(
+            name="Parent",
+            fields=[FieldInfo(name="val", type=TypeParamRef("U"))],
+            type_params=["U"],
+            is_send=True,
+            is_sync=True,
+        )
+        attach_dynamic_type_def("Parent", TypeCategory.RECORD, record=parent)
+        child = RecordInfo(
+            name="Child",
+            fields=[],
+            type_params=["T"],
+            parents=[NominalType("Parent", type_args=(TypeParamRef("T"),),
+                                 _module_qname="Parent")],
+            is_send=True,
+            is_sync=True,
+        )
+        attach_dynamic_type_def("Child", TypeCategory.RECORD, record=child)
+        try:
+            assert NominalType(
+                "Child", type_args=(INT32,), _module_qname="Child",
+            ).is_send() is True
+            assert NominalType(
+                "Child", type_args=(PtrType(_buf()),), _module_qname="Child",
+            ).is_send() is False
+        finally:
+            clear_dynamic_type_defs()

tpyc/test_tuple_mutation_propagation.py

@@ -0,0 +1,206 @@
+"""Phase 0 RED tests: mutation propagation through tuple destructure
+and through call edges where the param is a tuple/Optional.
+
+These pin the prerequisite facts that the const-inference work depends on.
+They were RED before the Phase 0 fixes (predicate at calls.py:2470 +
+borrow-tracker edges in _analyze_tuple_unpack).
+
+If any of these regresses, the const-inference downstream becomes unsound:
+a body that mutates through a slot would be silently inferred read-only
+and emitted with const slots.
+"""
+
+from . import get_lib_dir
+from .compiler import Compiler
+
+_STDLIB_DIRS = [get_lib_dir() / "tpy"]
+
+
+def _compile(source: str):
+    compiler = Compiler.from_source(source, lib_dirs=_STDLIB_DIRS)
+    modules = compiler.compile()
+    entry = [m for m in modules if m.is_entry_point][0]
+    return entry
+
+
+def _get_func(module, name: str):
+    fi_list = module.exports.functions[name]
+    assert len(fi_list) == 1, f"expected single overload of {name}, got {len(fi_list)}"
+    return fi_list[0]
+
+
+class TestTupleDestructureMutationPropagation:
+    """`a, b = p; a.x = ...` must mark `p` mutated."""
+
+    def test_tuple_of_record_destructure_field_write(self):
+        source = """
+from tpy import Int32
+
+class T:
+    x: Int32
+    def __init__(self, x: Int32) -> None:
+        self.x = x
+
+def f(p: tuple[T, T]) -> None:
+    a, b = p
+    a.x = Int32(1)
+"""
+        module = _compile(source)
+        f = _get_func(module, "f")
+        assert f.mutated_params is not None
+        assert 0 in f.mutated_params, (
+            f"`p` should be marked mutated after destructure+field-write, "
+            f"got mutated_params={f.mutated_params}"
+        )
+
+    def test_tuple_of_optional_record_destructure_narrowing_field_write(self):
+        source = """
+from tpy import Int32
+
+class T:
+    x: Int32
+    def __init__(self, x: Int32) -> None:
+        self.x = x
+
+def f(p: tuple[T | None, T | None]) -> None:
+    a, b = p
+    if a is not None:
+        a.x = Int32(1)
+"""
+        module = _compile(source)
+        f = _get_func(module, "f")
+        assert f.mutated_params is not None
+        assert 0 in f.mutated_params, (
+            f"`p` should be marked mutated after destructure+narrowing+field-write, "
+            f"got mutated_params={f.mutated_params}"
+        )
+
+    def test_tuple_of_record_destructure_no_write_not_mutated(self):
+        """Negative: pure read through destructure must not mark mutated."""
+        source = """
+from tpy import Int32
+
+class T:
+    x: Int32
+    def __init__(self, x: Int32) -> None:
+        self.x = x
+
+def f(p: tuple[T, T]) -> Int32:
+    a, b = p
+    return a.x + b.x
+"""
+        module = _compile(source)
+        f = _get_func(module, "f")
+        assert f.mutated_params is not None
+        assert 0 not in f.mutated_params, (
+            f"`p` should NOT be marked mutated for pure read access, "
+            f"got mutated_params={f.mutated_params}"
+        )
+
+
+class TestTupleTransitiveMutationPropagation:
+    """Phase-2 propagation: if inner mutates a tuple param, outer's matching
+    param must also be marked mutated when it forwards through inner."""
+
+    def test_transitive_through_tuple_param(self):
+        source = """
+from tpy import Int32
+
+class T:
+    x: Int32
+    def __init__(self, x: Int32) -> None:
+        self.x = x
+
+def inner(p: tuple[T, T]) -> None:
+    a, b = p
+    a.x = Int32(1)
+
+def outer(p: tuple[T, T]) -> None:
+    inner(p)
+"""
+        module = _compile(source)
+        inner = _get_func(module, "inner")
+        outer = _get_func(module, "outer")
+        assert inner.mutated_params is not None and 0 in inner.mutated_params
+        assert outer.mutated_params is not None and 0 in outer.mutated_params, (
+            f"outer's `p` should be transitively marked mutated, "
+            f"got mutated_params={outer.mutated_params}"
+        )
+
+    def test_transitive_through_optional_tuple_param(self):
+        source = """
+from tpy import Int32
+
+class T:
+    x: Int32
+    def __init__(self, x: Int32) -> None:
+        self.x = x
+
+def inner(p: tuple[T | None, T | None]) -> None:
+    a, b = p
+    if a is not None:
+        a.x = Int32(1)
+
+def outer(p: tuple[T | None, T | None]) -> None:
+    inner(p)
+"""
+        module = _compile(source)
+        inner = _get_func(module, "inner")
+        outer = _get_func(module, "outer")
+        assert inner.mutated_params is not None and 0 in inner.mutated_params
+        assert outer.mutated_params is not None and 0 in outer.mutated_params, (
+            f"outer's `p` should be transitively marked mutated, "
+            f"got mutated_params={outer.mutated_params}"
+        )
+
+    def test_no_propagation_when_inner_does_not_mutate(self):
+        """Negative: if inner only reads the tuple, outer is not marked."""
+        source = """
+from tpy import Int32
+
+class T:
+    x: Int32
+    def __init__(self, x: Int32) -> None:
+        self.x = x
+
+def inner(p: tuple[T, T]) -> Int32:
+    a, b = p
+    return a.x + b.x
+
+def outer(p: tuple[T, T]) -> Int32:
+    return inner(p)
+"""
+        module = _compile(source)
+        outer = _get_func(module, "outer")
+        assert outer.mutated_params is not None
+        assert 0 not in outer.mutated_params
+
+
+class TestTupleLiteralRhsDestructure:
+    """`a, b = (x, y)` should also propagate mutation through the borrow
+    edges from x/y to a/b."""
+
+    def test_tuple_literal_rhs_propagates(self):
+        source = """
+from tpy import Int32
+
+class T:
+    x: Int32
+    def __init__(self, x: Int32) -> None:
+        self.x = x
+
+def f(x: T, y: T) -> None:
+    a, b = (x, y)
+    a.x = Int32(1)
+"""
+        module = _compile(source)
+        f = _get_func(module, "f")
+        assert f.mutated_params is not None
+        assert 0 in f.mutated_params, (
+            f"`x` should be marked mutated through tuple-literal destructure, "
+            f"got mutated_params={f.mutated_params}"
+        )
+        # `y` is destructured into b but b is never written through.
+        assert 1 not in f.mutated_params, (
+            f"`y` should NOT be marked mutated, got mutated_params={f.mutated_params}"
+        )