Only consider inferred constructor specializations from class, not base classes

Author: dcreager

crates/red_knot_python_semantic/resources/mdtest/generics/legacy/classes.md

@@ -194,7 +194,7 @@ If the type of a constructor parameter is a class typevar, we can use that to in
 parameter. The types inferred from a type context and from a constructor parameter must be
 consistent with each other.
 
-## `__new__` only
+### `__new__` only
 
 ```py
 from typing import Generic, TypeVar
@@ -211,7 +211,7 @@ reveal_type(C(1))  # revealed: C[Literal[1]]
 wrong_innards: C[int] = C("five")
 ```
 
-## `__init__` only
+### `__init__` only
 
 ```py
 from typing import Generic, TypeVar
@@ -227,7 +227,7 @@ reveal_type(C(1))  # revealed: C[Literal[1]]
 wrong_innards: C[int] = C("five")
 ```
 
-## Identical `__new__` and `__init__` signatures
+### Identical `__new__` and `__init__` signatures
 
 ```py
 from typing import Generic, TypeVar
@@ -246,7 +246,7 @@ reveal_type(C(1))  # revealed: C[Literal[1]]
 wrong_innards: C[int] = C("five")
 ```
 
-## Compatible `__new__` and `__init__` signatures
+### Compatible `__new__` and `__init__` signatures
 
 ```py
 from typing import Generic, TypeVar
@@ -276,9 +276,29 @@ reveal_type(D(1))  # revealed: D[Literal[1]]
 wrong_innards: D[int] = D("five")
 ```
 
-## `__init__` is itself generic
+### Both present, `__new__` inherited from a generic base class fwomp
 
-TODO: These do not currently work yet, because we don't correctly model the nested generic contexts.
+If either method comes from a generic base class, we don't currently use its inferred specialization
+to specialize the class.
+
+```py
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+U = TypeVar("U")
+V = TypeVar("V")
+
+class C(Generic[T, U]):
+    def __new__(cls, *args, **kwargs) -> "C[T, U]":
+        return object.__new__(cls)
+
+class D(C[V, int]):
+    def __init__(self, x: V) -> None: ...
+
+reveal_type(D(1))  # revealed: D[Literal[1]]
+```
+
+### `__init__` is itself generic
 
 ```py
 from typing import Generic, TypeVar

crates/red_knot_python_semantic/resources/mdtest/generics/pep695/classes.md

@@ -171,7 +171,7 @@ If the type of a constructor parameter is a class typevar, we can use that to in
 parameter. The types inferred from a type context and from a constructor parameter must be
 consistent with each other.
 
-## `__new__` only
+### `__new__` only
 
 ```py
 class C[T]:
@@ -184,7 +184,7 @@ reveal_type(C(1))  # revealed: C[Literal[1]]
 wrong_innards: C[int] = C("five")
 ```
 
-## `__init__` only
+### `__init__` only
 
 ```py
 class C[T]:
@@ -196,7 +196,7 @@ reveal_type(C(1))  # revealed: C[Literal[1]]
 wrong_innards: C[int] = C("five")
 ```
 
-## Identical `__new__` and `__init__` signatures
+### Identical `__new__` and `__init__` signatures
 
 ```py
 class C[T]:
@@ -211,7 +211,7 @@ reveal_type(C(1))  # revealed: C[Literal[1]]
 wrong_innards: C[int] = C("five")
 ```
 
-## Compatible `__new__` and `__init__` signatures
+### Compatible `__new__` and `__init__` signatures
 
 ```py
 class C[T]:
@@ -237,9 +237,23 @@ reveal_type(D(1))  # revealed: D[Literal[1]]
 wrong_innards: D[int] = D("five")
 ```
 
-## `__init__` is itself generic
+### Both present, `__new__` inherited from a generic base class fwomp
 
-TODO: These do not currently work yet, because we don't correctly model the nested generic contexts.
+If either method comes from a generic base class, we don't currently use its inferred specialization
+to specialize the class.
+
+```py
+class C[T, U]:
+    def __new__(cls, *args, **kwargs) -> "C[T, U]":
+        return object.__new__(cls)
+
+class D[V](C[V, int]):
+    def __init__(self, x: V) -> None: ...
+
+reveal_type(D(1))  # revealed: D[Literal[1]]
+```
+
+### `__init__` is itself generic
 
 ```py
 class C[T]:

crates/red_knot_python_semantic/src/types.rs

@@ -4423,18 +4423,19 @@ impl<'db> Type<'db> {
         // have the class's typevars still in the method signature when we attempt to call it. To
         // do this, we instead use the _identity_ specialization, which maps each of the class's
         // generic typevars to itself.
-        let (generic_origin, self_type) = match self {
+        let (generic_origin, generic_context, self_type) = match self {
             Type::ClassLiteral(class) => match class.generic_context(db) {
                 Some(generic_context) => {
                     let specialization = generic_context.identity_specialization(db);
                     (
                         Some(class),
+                        Some(generic_context),
                         Type::GenericAlias(GenericAlias::new(db, class, specialization)),
                     )
                 }
-                _ => (None, self),
+                _ => (None, None, self),
             },
-            _ => (None, self),
+            _ => (None, None, self),
         };
 
         // As of now we do not model custom `__call__` on meta-classes, so the code below
@@ -4550,12 +4551,18 @@ impl<'db> Type<'db> {
                     .and_then(Result::ok)
                     .as_ref()
                     .and_then(Bindings::single_element)
-                    .and_then(|binding| combine_binding_specialization(db, binding));
+                    .and_then(|binding| combine_binding_specialization(db, binding))
+                    .filter(|specialization| {
+                        Some(specialization.generic_context(db)) == generic_context
+                    });
                 let init_specialization = init_call_outcome
                     .and_then(Result::ok)
                     .as_ref()
                     .and_then(Bindings::single_element)
-                    .and_then(|binding| combine_binding_specialization(db, binding));
+                    .and_then(|binding| combine_binding_specialization(db, binding))
+                    .filter(|specialization| {
+                        Some(specialization.generic_context(db)) == generic_context
+                    });
                 let specialization =
                     combine_specializations(db, new_specialization, init_specialization);
                 let specialized = specialization