ensure info is cached

Author: provinzkraut

src/msgspec/_core.c

@@ -4958,11 +4958,36 @@ convert_types_generic_alias(TypeNodeCollectState *state, PyObject *obj, PyObject
     // built-in container generic, such as 'collections.abc.Mapping'
 
     if (MS_UNLIKELY(Py_TYPE(obj) == (PyTypeObject *)state->mod->types_generic_alias)) {
-        PyObject *genericAliasArgsList = Py_BuildValue("OO", origin, args);
+        // subscribed typing._GenericAlias instances are cached within the typing module
+        // we make use of this fact, by storing a __msgspec_cache__ attribute on the
+        // subscribed instance. only subscribed types are cache, so
+        // 'typing._GenericAlias(list, int) is typing._GenericAlias(list, int)' would be
+        // false.
+        // to achieve the same behaviour when re-creating a typing._GenericAlias from a
+        // types.GenericAlias, we first construct a temporary *unbound*
+        // typing._GenericAlias, on which we then call __getattr__. effectively doing
+        // typing._GenericAlias(list, T)[int], for which
+        // 'typing._GenericAlias(list, T)[int] is typing._GenericAlias(list, T)[int]'
+        // holds true
+        PyObject *params = PyObject_GetAttrString(origin, "__parameters__");
+        if (params == NULL) {
+            Py_DECREF(origin);
+            return NULL;
+        }
+
+        // create a new typing._GenericAlias with the unbound type params of the
+        // original types.GenericAlias.
+        // given a Mapping[str, int], this would produce a _GenericAlias(Mapping, (~K, ~V))
+        PyObject *new_alias = PyObject_CallFunctionObjArgs(state->mod->typing_generic_alias, origin, params, NULL);
+        if (new_alias == NULL) {
+            return NULL;
+        }
 
-        PyObject *newGenericAlias = PyObject_CallObject(state->mod->typing_generic_alias, genericAliasArgsList);
-        Py_DECREF(genericAliasArgsList);
-        return newGenericAlias;
+        // bind it to the concrete types.
+        // given a _GenericAlias(Mapping, (~K, ~V)), produce a Mapping[str, int] again
+        PyObject *result = PyObject_CallMethod(new_alias, "__getitem__", "O", args);
+        Py_DECREF(new_alias);
+        return result;
     }
     return obj;
 }

tests/unit/test_common.py

@@ -56,6 +56,13 @@
 T = TypeVar("T")
 
 
+def make_new_alias(alias):
+    """Replicate the logic to produce a types._GenericAlias from a typing.GenericAlias"""
+    return typing._GenericAlias(
+        alias.__origin__, alias.__origin__.__parameters__
+    ).__getitem__(*alias.__args__)
+
+
 def assert_eq(x, y):
     assert x == y
     assert type(x) is type(y)
@@ -1634,6 +1641,49 @@ def __iter__(self):
             msgspec.msgpack.encode(mod.Foo({"x": 1})), type=mod.Foo[int]
         )
 
+    @pytest.mark.parametrize(
+        "mapping_type", ["collections.abc.Mapping", "typing.Mapping"]
+    )
+    @py312_plus
+    def test_inherited_builtin_generic_typevar_syntax_info_cached(
+        self, mapping_type: str
+    ):
+        source = f"""
+            from msgspec import Struct, StructMeta
+            import collections
+            import abc
+            import typing
+
+            class CombinedMeta(StructMeta, abc.ABCMeta):
+                pass
+
+            class Foo[T]({mapping_type}[str, T], Struct, metaclass=CombinedMeta):
+                data: dict[str, T]
+
+                def __getitem__(self, x):
+                    return self.data[x]
+
+                def __len__(self):
+                    return len(self.data)
+
+                def __iter__(self):
+                    return iter(self.data)
+            """
+
+        with temp_module(source) as mod:
+            typ = mod.Foo[int]
+            dec = msgspec.json.Decoder(typ)
+            info = make_new_alias(typ).__msgspec_cache__
+            assert info is not None
+            assert sys.getrefcount(info) <= 4  # info + attr + decoder + func call
+            dec2 = msgspec.json.Decoder(typ)
+            assert make_new_alias(typ).__msgspec_cache__ is info
+            assert sys.getrefcount(info) <= 5
+
+            del dec
+            del dec2
+            assert sys.getrefcount(info) <= 3
+
 
 class TestStructPostInit:
     @pytest.mark.parametrize("array_like", [False, True])
@@ -1953,6 +2003,46 @@ def __iter__(self):
             msgspec.msgpack.encode(mod.Foo({"x": 1})), type=mod.Foo[int]
         )
 
+    @pytest.mark.parametrize(
+        "mapping_type", ["collections.abc.Mapping", "typing.Mapping"]
+    )
+    @py312_plus
+    def test_inherited_builtin_generic_typevar_syntax_info_cached(
+        self, mapping_type: str
+    ):
+        source = f"""
+        import dataclasses
+        import collections
+        import typing
+
+        @dataclasses.dataclass
+        class Foo[T]({mapping_type}[str, T]):
+            data: dict[str, T]
+
+            def __getitem__(self, x):
+                return self.data[x]
+
+            def __len__(self):
+                return len(self.data)
+
+            def __iter__(self):
+                return iter(self.data)
+        """
+
+        with temp_module(source) as mod:
+            typ = mod.Foo[int]
+            dec = msgspec.json.Decoder(typ)
+            info = make_new_alias(typ).__msgspec_cache__
+            assert info is not None
+            assert sys.getrefcount(info) <= 4  # info + attr + decoder + func call
+            dec2 = msgspec.json.Decoder(typ)
+            assert make_new_alias(typ).__msgspec_cache__ is info
+            assert sys.getrefcount(info) <= 5
+
+            del dec
+            del dec2
+            assert sys.getrefcount(info) <= 3
+
 
 class TestStructOmitDefaults:
     def test_omit_defaults(self, proto):