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

tpyc/test_macro_loader.py

@@ -0,0 +1,76 @@
+"""Tests for macro_loader.validate_and_call_macro."""
+
+import pytest
+
+from .macro_loader import validate_and_call_macro
+from .diagnostics import SemanticError
+
+
+class _FakeLoc:
+    """Minimal loc object for test errors."""
+    def __init__(self):
+        self.lineno = 1
+        self.col_offset = 0
+        self.end_lineno = 1
+        self.end_col_offset = 0
+
+
+_LOC = _FakeLoc()
+
+
+def _make_macro(fn):
+    fn._is_class_macro = True
+    return fn
+
+
+class TestValidateAndCallMacro:
+    def test_unknown_kwarg(self):
+        def my_macro(cls, *, x: int = 0):
+            pass
+        with pytest.raises(SemanticError, match="unknown keyword argument 'y'"):
+            validate_and_call_macro(my_macro, None, {"y": 1}, "test.my_macro", _LOC)
+
+    def test_unknown_kwarg_no_params(self):
+        def my_macro(cls):
+            pass
+        with pytest.raises(SemanticError, match="takes no keyword arguments"):
+            validate_and_call_macro(my_macro, None, {"x": 1}, "test.my_macro", _LOC)
+
+    def test_missing_required_kwarg(self):
+        def my_macro(cls, *, required: str):
+            pass
+        with pytest.raises(SemanticError, match="missing required keyword argument 'required'"):
+            validate_and_call_macro(my_macro, None, {}, "test.my_macro", _LOC)
+
+    def test_type_mismatch(self):
+        def my_macro(cls, *, flag: bool = False):
+            pass
+        with pytest.raises(SemanticError, match="'flag' must be bool, got str"):
+            validate_and_call_macro(my_macro, None, {"flag": "yes"}, "test.my_macro", _LOC)
+
+    def test_unexpected_exception_wrapped(self):
+        def my_macro(cls):
+            raise ValueError("something broke")
+        with pytest.raises(SemanticError, match="macro raised ValueError: something broke"):
+            validate_and_call_macro(my_macro, None, {}, "test.my_macro", _LOC)
+
+    def test_semantic_error_not_wrapped(self):
+        def my_macro(cls):
+            raise SemanticError("custom error", _LOC)
+        with pytest.raises(SemanticError, match="custom error"):
+            validate_and_call_macro(my_macro, None, {}, "test.my_macro", _LOC)
+
+    def test_var_keyword_allows_unknown(self):
+        received = {}
+        def my_macro(cls, **kw):
+            received.update(kw)
+        validate_and_call_macro(my_macro, None, {"anything": 42}, "test.my_macro", _LOC)
+        assert received == {"anything": 42}
+
+    def test_valid_call(self):
+        results = {}
+        def my_macro(cls, *, frozen: bool = False, order: bool = False):
+            results["frozen"] = frozen
+            results["order"] = order
+        validate_and_call_macro(my_macro, "fake_cls", {"frozen": True}, "test.my_macro", _LOC)
+        assert results == {"frozen": True, "order": False}

tpyc/test_method_expansion.py

@@ -0,0 +1,254 @@
+"""Tests for sema.method_expansion.
+
+The per-record entry point (`expand_methods_for_record`) is invoked from
+`register_record` after macros run, so macro-added methods flow through
+the same self-flag derivation / wrapping / cloning pipeline as
+source-authored methods (Phase F.3b.6.5). These tests pin the
+idempotency contract that the per-record call relies on.
+"""
+
+from __future__ import annotations
+
+import pytest
+
+from .parse.nodes import TpyFunction, TpyRecord, RecordLinkage
+from .diagnostics import SemanticError
+from .sema.method_expansion import expand_methods_for_record
+from .typesys import (
+    AutoReadonlyType,
+    AutoOwnType,
+    OwnType,
+    SelfType,
+    NominalType,
+    SELF,
+    VOID,
+    INT32,
+)
+
+
+def _make_record(methods: list[TpyFunction]) -> TpyRecord:
+    return TpyRecord(
+        name="R",
+        fields=[],
+        methods=methods,
+        bases=[],
+        linkage=RecordLinkage.DEFAULT,
+    )
+
+
+def _make_method(**kwargs) -> TpyFunction:
+    return TpyFunction(
+        name=kwargs.pop("name", "m"),
+        params=kwargs.pop("params", []),
+        return_type=kwargs.pop("return_type", VOID),
+        body=[],
+        is_method=True,
+        **kwargs,
+    )
+
+
+class TestAutoReadonlyDecoratorExpansion:
+    def test_decorator_expands_to_mutable_and_const_clones(self):
+        method = _make_method(
+            name="get",
+            return_type=INT32,
+            has_auto_readonly_decorator=True,
+        )
+        record = _make_record([method])
+
+        expand_methods_for_record(record)
+
+        assert len(record.methods) == 2
+        mutable, const = record.methods
+        assert mutable.is_auto_readonly_mutable_clone
+        assert not mutable.is_readonly
+        assert not const.is_auto_readonly_mutable_clone
+        assert const.is_readonly
+        # Both clones are "expansion done" and carry no derivation source.
+        assert mutable.self_annotation is None
+        assert const.self_annotation is None
+        assert not mutable.has_auto_readonly_decorator
+        assert not const.has_auto_readonly_decorator
+
+    def test_decorator_expansion_is_idempotent(self):
+        method = _make_method(
+            name="get",
+            return_type=INT32,
+            has_auto_readonly_decorator=True,
+        )
+        record = _make_record([method])
+
+        expand_methods_for_record(record)
+        first_count = len(record.methods)
+        expand_methods_for_record(record)
+        assert len(record.methods) == first_count
+
+
+class TestAutoReadonlySelfExpansion:
+    def test_self_auto_readonly_clones_and_strips_annotation(self):
+        method = _make_method(
+            name="m",
+            self_annotation=AutoReadonlyType(SELF),
+        )
+        record = _make_record([method])
+
+        expand_methods_for_record(record)
+
+        assert len(record.methods) == 2
+        # A second expansion must not re-clone -- self_annotation is nulled
+        # on both halves so _derive_self_flags doesn't re-set auto_readonly.
+        expand_methods_for_record(record)
+        assert len(record.methods) == 2
+
+
+class TestAutoOwnSelfExpansion:
+    def test_self_auto_own_clones_and_strips_annotation(self):
+        method = _make_method(
+            name="take",
+            self_annotation=AutoOwnType(SELF),
+            return_type=AutoOwnType(NominalType("R")),
+        )
+        record = _make_record([method])
+
+        expand_methods_for_record(record)
+
+        assert len(record.methods) == 2
+        borrowing, consuming = record.methods
+        assert borrowing.is_auto_own_borrowing_clone
+        assert not borrowing.is_consuming
+        assert consuming.is_consuming
+        assert borrowing.self_annotation is None
+        assert consuming.self_annotation is None
+
+        expand_methods_for_record(record)
+        assert len(record.methods) == 2
+
+
+class TestConsumingSelfNotCloned:
+    def test_own_self_sets_is_consuming_no_clone(self):
+        method = _make_method(
+            name="take",
+            self_annotation=OwnType(SELF),
+        )
+        record = _make_record([method])
+
+        expand_methods_for_record(record)
+
+        assert len(record.methods) == 1
+        assert record.methods[0].is_consuming
+        # self_annotation is cleared after derivation so a second pass
+        # doesn't re-fire `_derive_self_flags` on it (symmetric with the
+        # clone paths).
+        assert record.methods[0].self_annotation is None
+
+        expand_methods_for_record(record)
+        assert len(record.methods) == 1
+        assert record.methods[0].is_consuming
+
+
+class TestSelfAnnotationValidation:
+    def test_own_self_on_init_raises_semantic_error(self):
+        method = _make_method(
+            name="__init__",
+            self_annotation=OwnType(SELF),
+        )
+        record = _make_record([method])
+
+        with pytest.raises(SemanticError, match="Own\\[Self\\] is not allowed on '__init__'"):
+            expand_methods_for_record(record)
+
+    def test_own_self_on_del_raises_semantic_error(self):
+        method = _make_method(
+            name="__del__",
+            self_annotation=OwnType(SELF),
+        )
+        record = _make_record([method])
+
+        with pytest.raises(SemanticError, match="Own\\[Self\\] is not allowed on '__del__'"):
+            expand_methods_for_record(record)
+
+    def test_auto_readonly_self_on_init_raises_semantic_error(self):
+        method = _make_method(
+            name="__init__",
+            self_annotation=AutoReadonlyType(SELF),
+        )
+        record = _make_record([method])
+
+        with pytest.raises(SemanticError, match="auto_readonly\\[Self\\] is not allowed on '__init__'"):
+            expand_methods_for_record(record)
+
+    def test_own_self_with_readonly_raises_semantic_error(self):
+        method = _make_method(
+            name="m",
+            self_annotation=OwnType(SELF),
+            is_readonly=True,
+        )
+        record = _make_record([method])
+
+        with pytest.raises(SemanticError, match="Own\\[Self\\] cannot be combined with @readonly"):
+            expand_methods_for_record(record)
+
+
+class TestPerParamAutoReadonlyTriggersCloning:
+    """Per-param `auto_readonly[T]` annotation alone (no decorator, no self:
+    auto_readonly[Self]) must still set `auto_readonly=True` in sema and
+    trigger cloning. Regression path for F.3b.6.2 which moved the per-param
+    detection out of the parser.
+    """
+
+    def test_per_param_auto_readonly_clones(self):
+        # Method with a param whose type carries AutoReadonlyType.
+        method = _make_method(
+            name="pick",
+            params=[("x", AutoReadonlyType(NominalType("T")))],
+            return_type=INT32,
+        )
+        record = _make_record([method])
+
+        expand_methods_for_record(record)
+
+        # Cloned into mutable + const halves.
+        assert len(record.methods) == 2
+        mutable, const = record.methods
+        assert mutable.is_auto_readonly_mutable_clone
+        assert not mutable.is_readonly
+        assert not const.is_auto_readonly_mutable_clone
+        assert const.is_readonly
+        # Mutable clone strips the AutoReadonlyType; const clone applies it.
+        from .typesys import ReadonlyType, strip_auto_readonly, apply_auto_readonly
+        _, mut_ptype = mutable.params[0]
+        _, const_ptype = const.params[0]
+        assert not isinstance(mut_ptype, AutoReadonlyType)
+        assert isinstance(const_ptype, ReadonlyType)
+
+
+class TestMacroAddedMethodExpansion:
+    """Simulates the macro-added method flow: add a method post-parse and
+    verify it flows through the same pipeline when the per-record entry
+    point runs. This is the regression the F.3b.6.5 change protects.
+    """
+
+    def test_method_added_after_initial_expansion_gets_expanded(self):
+        # First method: already expanded form (simulates parser output
+        # that the module-level caller might have processed before
+        # macros add theirs). It stays put.
+        existing = _make_method(name="existing", return_type=INT32)
+        record = _make_record([existing])
+        expand_methods_for_record(record)
+        assert len(record.methods) == 1
+
+        # Macro adds a new method with @auto_readonly decorator flag.
+        new_method = _make_method(
+            name="new_method",
+            return_type=INT32,
+            has_auto_readonly_decorator=True,
+        )
+        record.methods.append(new_method)
+
+        expand_methods_for_record(record)
+
+        # existing stays as 1 method; new_method cloned into 2. Total 3.
+        assert len(record.methods) == 3
+        names = [m.name for m in record.methods]
+        assert names.count("existing") == 1
+        assert names.count("new_method") == 2

tpyc/test_nominal_identity.py

@@ -0,0 +1,182 @@
+"""Pin the qname-aware nominal identity invariants.
+
+Three concerns the test guards against:
+
+1. `NominalType` equality + hash includes `_module_qname` -- two
+   records with the same short name from different modules are
+   distinct in sets / dicts / unions, and set dedup is insertion-
+   order independent (proper equivalence relation).
+2. `TypeRegistry.get_record_for_type` is qname-first -- when the
+   NominalType carries a qname, the lookup routes to the matching
+   record even if a locally-registered record shadows the short name.
+   Covers both records registered via `register_record(info, name)`
+   and records that land in the registry only via `register_module`.
+3. `TypeRegistry.is_subclass_of` works for cross-module child/base
+   pairs whose short names are shadowed by local records.
+"""
+from __future__ import annotations
+
+import pytest
+
+from tpyc.typesys import (
+    ModuleInfo, NominalType, RecordInfo, TypeRegistry,
+    make_union, UnionType, same_nominal_symbol_loose,
+)
+from tpyc.type_def_registry import (
+    attach_dynamic_type_def, TypeCategory, clear_dynamic_type_defs,
+)
+
+
+@pytest.fixture(autouse=True)
+def _cleanup():
+    yield
+    clear_dynamic_type_defs()
+
+
+def _attach_record_td(info: RecordInfo) -> None:
+    """Attach a TypeDef.record entry so `is_user_record` resolves --
+    mirrors what sema's `register_record` does in production."""
+    attach_dynamic_type_def(
+        info.qualified_name(),
+        TypeCategory.RECORD,
+        record=info,
+        is_value_type=False,
+    )
+
+
+# ---------------------------------------------------------------------------
+# 1. Equality / hash invariant
+# ---------------------------------------------------------------------------
+
+class TestNominalEquality:
+    def test_cross_module_same_name_unequal(self) -> None:
+        a = NominalType("Foo", _module_qname="pkg_a.Foo")
+        b = NominalType("Foo", _module_qname="pkg_b.Foo")
+        assert a != b
+        assert hash(a) != hash(b) or a != b  # hashes may collide, equality must not
+
+    def test_bare_and_qname_bearing_unequal(self) -> None:
+        # Strict contract: bare != qname-bearing.  Transitional sites
+        # that want the loose bridge must call
+        # `same_nominal_symbol_loose` explicitly.
+        bare = NominalType("Foo")
+        qn = NominalType("Foo", _module_qname="mod.Foo")
+        assert bare != qn
+
+    def test_set_dedup_order_independent(self) -> None:
+        a = NominalType("Foo", _module_qname="pkg_a.Foo")
+        b = NominalType("Foo", _module_qname="pkg_b.Foo")
+        c = NominalType("Foo")
+        # Three pairwise-unequal elements -> always 3 in the set
+        # regardless of insertion order (guards against the non-
+        # transitive-equality trap).
+        assert len({a, b, c}) == 3
+        assert len({c, a, b}) == 3
+        assert len({b, c, a}) == 3
+
+    def test_make_union_keeps_cross_module_distinct(self) -> None:
+        a = NominalType("Foo", _module_qname="pkg_a.Foo")
+        b = NominalType("Foo", _module_qname="pkg_b.Foo")
+        u = make_union(a, b)
+        assert isinstance(u, UnionType)
+        assert len(u.members) == 2
+
+    def test_same_qname_equal(self) -> None:
+        a = NominalType("Foo", _module_qname="mod.Foo")
+        b = NominalType("Foo", _module_qname="mod.Foo")
+        assert a == b
+        assert hash(a) == hash(b)
+
+
+# ---------------------------------------------------------------------------
+# 2. same_nominal_symbol_loose -- transitional bridging helper
+# ---------------------------------------------------------------------------
+
+class TestLooseBridging:
+    def test_bare_matches_qname_bearing(self) -> None:
+        bare = NominalType("Foo")
+        qn = NominalType("Foo", _module_qname="mod.Foo")
+        assert same_nominal_symbol_loose(bare, qn)
+        assert same_nominal_symbol_loose(qn, bare)
+
+    def test_different_qnames_still_unequal(self) -> None:
+        # loose must NOT paper over cross-module collisions.
+        a = NominalType("Foo", _module_qname="pkg_a.Foo")
+        b = NominalType("Foo", _module_qname="pkg_b.Foo")
+        assert not same_nominal_symbol_loose(a, b)
+
+    def test_rejects_structural_differences(self) -> None:
+        # Different name / type_args / is_protocol -> False regardless
+        # of qname state.
+        bare_a = NominalType("Foo")
+        bare_b = NominalType("Bar")
+        assert not same_nominal_symbol_loose(bare_a, bare_b)
+
+
+# ---------------------------------------------------------------------------
+# 3. Qname-aware lookup on TypeRegistry
+# ---------------------------------------------------------------------------
+
+class TestRegistryLookup:
+    def _make_registry_with_shadow(self) -> tuple[TypeRegistry, RecordInfo, RecordInfo]:
+        """A registry where short name "Foo" is shadowed:
+        - `__main__.Foo` registered via `register_record` (local).
+        - `pkg.Foo` registered via `register_module` (import-only).
+        """
+        reg = TypeRegistry()
+        main_foo = RecordInfo(name="Foo", fields=[], module="__main__")
+        pkg_foo = RecordInfo(name="Foo", fields=[], module="pkg")
+        reg.register_record(main_foo)
+        reg.register_module(ModuleInfo(name="pkg", records={"Foo": pkg_foo}))
+        _attach_record_td(main_foo)
+        _attach_record_td(pkg_foo)
+        return reg, main_foo, pkg_foo
+
+    def test_qname_routes_to_cross_module_record(self) -> None:
+        reg, main_foo, pkg_foo = self._make_registry_with_shadow()
+        n = NominalType("Foo", _module_qname="pkg.Foo")
+        assert reg.get_record_for_type(n) is pkg_foo
+
+    def test_qname_routes_to_local_record(self) -> None:
+        reg, main_foo, pkg_foo = self._make_registry_with_shadow()
+        n = NominalType("Foo", _module_qname="__main__.Foo")
+        assert reg.get_record_for_type(n) is main_foo
+
+    def test_bare_falls_back_to_short_name(self) -> None:
+        reg, main_foo, pkg_foo = self._make_registry_with_shadow()
+        # Bare placeholder still resolves to whatever is in
+        # `self.records[name]` (here: the local __main__.Foo).  This
+        # is the transient parse/resolve behavior; callers that need
+        # stricter semantics should pass a qname-bearing NominalType.
+        n = NominalType("Foo")
+        assert reg.get_record_for_type(n) is main_foo
+
+    def test_is_subclass_of_cross_module(self) -> None:
+        # Local `Base` shadows `pkg.Base`, and `pkg.Child` extends
+        # `pkg.Base`.  Qname-aware lookup must walk the pkg chain
+        # rather than the locally-registered `Base`.
+        reg = TypeRegistry()
+        main_base = RecordInfo(name="Base", fields=[], module="__main__")
+        reg.register_record(main_base)
+        _attach_record_td(main_base)
+
+        pkg_base = RecordInfo(name="Base", fields=[], module="pkg")
+        base_ref = NominalType("Base", _module_qname="pkg.Base")
+        pkg_child = RecordInfo(
+            name="Child", fields=[], module="pkg",
+            parents=[base_ref],
+            mro_ancestors=[base_ref],
+        )
+        reg.register_module(ModuleInfo(
+            name="pkg", records={"Base": pkg_base, "Child": pkg_child},
+        ))
+        _attach_record_td(pkg_base)
+        _attach_record_td(pkg_child)
+
+        child_n = NominalType("Child", _module_qname="pkg.Child")
+        base_n = NominalType("Base", _module_qname="pkg.Base")
+        assert reg.is_subclass_of(child_n, base_n)
+
+        # Sanity: local __main__.Base is NOT a parent of pkg.Child.
+        main_base_n = NominalType("Base", _module_qname="__main__.Base")
+        assert not reg.is_subclass_of(child_n, main_base_n)