Make sure the type reference is removed from the seen references (#11145)

Viicos · kc0506 · web-flow · commit ea69e695f27f · 2024-12-18T17:50:38.000+01:00
When parametrizing generic models, the `generic_recursion_self_type`
context manager is entered, and is used to avoid infinite recursions
if the same generic model happens to be parametrized again with the
same args during the first parametrization.

However, upon exiting the context manager (and thus when the parametrized
model is fully created), we forgot to remove the type ref from the set.
This happened only if we were already in the process of parametrizing
another model, as otherwise the `_generic_recursion_cache` would
be reset (see the `if token` condition).

In theory, this couldn't cause issues because parametrized models are
cached, and the cache is checked *before* entering the context manager.
However, because we have custom `mro()` implementation on the `BaseModel`
metaclass, this ends up causing issues is some really specific scenarios.

Co-authored-by: kc0506 &lt;kchong0506@gmail.com&gt;
diff --git a/pydantic/_internal/_generics.py b/pydantic/_internal/_generics.py
@@ -426,7 +426,8 @@ def generic_recursion_self_type(
             yield self_type
         else:
             previously_seen_type_refs.add(type_ref)
-            yield None
+            yield
+            previously_seen_type_refs.remove(type_ref)
     finally:
         if token:
             _generic_recursion_cache.reset(token)
diff --git a/tests/test_generics.py b/tests/test_generics.py
@@ -3099,3 +3099,41 @@ class Holder(BaseModel, Generic[T]):
     holder2 = Holder(inner=Inner(inner=1))
     # implies that validation succeeds for both
     assert holder1 == holder2
+
+
+def test_generic_mro_multi_level():
+    """Pass another generic model as an arg.
+
+    See https://github.com/pydantic/pydantic/issues/11024.
+    """
+
+    T = TypeVar('T')
+
+    class GenericBaseModel(BaseModel, Generic[T]): ...
+
+    class EnumerableModel(GenericBaseModel[T]):
+        values: List[T]
+
+    T1 = TypeVar('T1')
+    T2 = TypeVar('T2')
+
+    class CombineModel(BaseModel, Generic[T1, T2]):
+        field_1: T1
+        field_2: T2
+
+    class EnumerableCombineModel(EnumerableModel[CombineModel[T1, T2]]): ...
+
+    m = EnumerableCombineModel[int, int]
+
+    mro = (
+        EnumerableCombineModel[int, int],
+        EnumerableCombineModel,
+        EnumerableModel[CombineModel[int, int]],
+        EnumerableModel,
+        GenericBaseModel[CombineModel[int, int]],
+        GenericBaseModel,
+        BaseModel,
+        Generic,
+        object,
+    )
+    assert m.__mro__ == tuple(HasRepr(repr(m)) for m in mro)
