fix compile error after merging in main

Author: AlexWaygood

crates/ruff_benchmark/benches/ty.rs

@@ -59,7 +59,29 @@ type KeyDiagnosticFields = (
     Severity,
 );
 
-static EXPECTED_TOMLLIB_DIAGNOSTICS: &[KeyDiagnosticFields] = &[];
+static EXPECTED_TOMLLIB_DIAGNOSTICS: &[KeyDiagnosticFields] = &[
+    (
+        DiagnosticId::lint("invalid-argument-type"),
+        Some("/src/tomllib/_parser.py"),
+        Some(8224..8254),
+        "Argument to this function is incorrect",
+        Severity::Error,
+    ),
+    (
+        DiagnosticId::lint("invalid-argument-type"),
+        Some("/src/tomllib/_parser.py"),
+        Some(16914..16948),
+        "Argument to this function is incorrect",
+        Severity::Error,
+    ),
+    (
+        DiagnosticId::lint("invalid-argument-type"),
+        Some("/src/tomllib/_parser.py"),
+        Some(17319..17363),
+        "Argument to this function is incorrect",
+        Severity::Error,
+    ),
+];
 
 fn tomllib_path(file: &TestFile) -> SystemPathBuf {
     SystemPathBuf::from("src").join(file.name())

crates/ty_python_semantic/resources/mdtest/annotations/self.md

@@ -33,7 +33,9 @@ class Shape:
         reveal_type(self)  # revealed: Unknown
         return self
 
-reveal_type(Shape().nested_type())  # revealed: @Todo(specialized non-generic class)
+# TODO: should be `list[Shape]`
+reveal_type(Shape().nested_type())  # revealed: list[Self]
+
 reveal_type(Shape().nested_func())  # revealed: Shape
 
 class Circle(Shape):

crates/ty_python_semantic/resources/mdtest/annotations/stdlib_typing_aliases.md

@@ -43,9 +43,9 @@ def f(
     reveal_type(set_parametrized)  # revealed: set[Unknown]
 
     # TODO: revealed: frozenset[Unknown]
-    reveal_type(frozen_set_bare)  # revealed: frozenset
+    reveal_type(frozen_set_bare)  # revealed: frozenset[Unknown]
     # TODO: revealed: frozenset[str]
-    reveal_type(frozen_set_parametrized)  # revealed: frozenset
+    reveal_type(frozen_set_parametrized)  # revealed: frozenset[Unknown]
 
     reveal_type(chain_map_bare)  # revealed: ChainMap[Unknown, Unknown]
     # TODO: revealed: ChainMap[str, int]
@@ -97,8 +97,7 @@ reveal_type(SetSubclass.__mro__)
 
 class FrozenSetSubclass(typing.FrozenSet): ...
 
-# TODO: generic protocols
-# revealed: tuple[<class 'FrozenSetSubclass'>, <class 'frozenset'>, <class 'AbstractSet'>, <class 'Collection'>, <class 'Iterable'>, <class 'Container'>, @Todo(`Protocol[]` subscript), typing.Generic, <class 'object'>]
+# revealed: tuple[<class 'FrozenSetSubclass'>, <class 'frozenset[Unknown]'>, <class 'AbstractSet[Unknown]'>, <class 'Collection[Unknown]'>, <class 'Iterable[Unknown]'>, <class 'Container[Unknown]'>, typing.Protocol[_T_co], typing.Generic[_T_co], <class 'object'>]
 reveal_type(FrozenSetSubclass.__mro__)
 
 ####################

crates/ty_python_semantic/resources/mdtest/import/dunder_all.md

@@ -785,7 +785,7 @@ from subexporter import *
 
 # TODO: Should be `list[str]`
 # TODO: Should we avoid including `Unknown` for this case?
-reveal_type(__all__)  # revealed: Unknown | list
+reveal_type(__all__)  # revealed: Unknown | list[Unknown]
 
 __all__.append("B")
 

crates/ty_python_semantic/resources/mdtest/subscript/tuple.md

@@ -83,7 +83,8 @@ python-version = "3.9"
 ```py
 class A(tuple[int, str]): ...
 
-reveal_type(A.__mro__)  # revealed: tuple[<class 'A'>, <class 'tuple[@Todo(Generic tuple specializations), ...]'>, <class 'Sequence[@Todo(Generic tuple specializations)]'>, <class 'Reversible[@Todo(Generic tuple specializations)]'>, <class 'Collection[@Todo(Generic tuple specializations)]'>, <class 'Iterable[@Todo(Generic tuple specializations)]'>, <class 'Container[@Todo(Generic tuple specializations)]'>, typing.Protocol[_T_co], typing.Generic[_T_co], <class 'object'>]
+# revealed: tuple[<class 'A'>, <class 'tuple[@Todo(Generic tuple specializations), ...]'>, <class 'Sequence[@Todo(Generic tuple specializations)]'>, <class 'Reversible[@Todo(Generic tuple specializations)]'>, <class 'Collection[@Todo(Generic tuple specializations)]'>, <class 'Iterable[@Todo(Generic tuple specializations)]'>, <class 'Container[@Todo(Generic tuple specializations)]'>, typing.Protocol[_T_co], typing.Generic[_T_co], <class 'object'>]
+reveal_type(A.__mro__)
 ```
 
 ## `typing.Tuple`

crates/ty_python_semantic/resources/mdtest/type_properties/is_subtype_of.md

@@ -151,7 +151,8 @@ static_assert(not is_subtype_of(tuple[B1, B2], tuple[()]))
 static_assert(not is_subtype_of(tuple[B1, B2], tuple[A1]))
 static_assert(not is_subtype_of(tuple[B1, B2], tuple[A1, A2, Unrelated]))
 
-static_assert(is_subtype_of(tuple[int], tuple))
+# TODO: should pass
+static_assert(is_subtype_of(tuple[int], tuple[object, ...]))  # error: [static-assert-error]
 ```
 
 ## Union types

crates/ty_python_semantic/src/types/instance.rs

@@ -256,15 +256,9 @@ impl<'db> ProtocolInstanceType<'db> {
             Protocol::FromClass(class) => Self(Protocol::FromClass(
                 class.apply_specialization(db, specialization),
             )),
-            Protocol::Synthesized(synthesized) => {
-                Self(Protocol::Synthesized(SynthesizedProtocolType::new(
-                    db,
-                    synthesized
-                        .interface(db)
-                        .clone()
-                        .apply_specialization(db, specialization),
-                )))
-            }
+            Protocol::Synthesized(synthesized) => Self(Protocol::Synthesized(
+                synthesized.apply_specialization(db, specialization),
+            )),
         }
     }
 }
@@ -294,6 +288,7 @@ impl<'db> Protocol<'db> {
 
 mod synthesized_protocol {
     use crate::db::Db;
+    use crate::types::generics::Specialization;
     use crate::types::protocol_class::ProtocolInterface;
 
     /// A "synthesized" protocol type that is dissociated from a class definition in source code.
@@ -313,6 +308,14 @@ mod synthesized_protocol {
             Self(interface.normalized(db))
         }
 
+        pub(super) fn apply_specialization(
+            self,
+            db: &'db dyn Db,
+            specialization: Specialization<'db>,
+        ) -> Self {
+            Self(self.0.specialized_and_normalized(db, specialization))
+        }
+
         pub(in crate::types) fn interface(self) -> ProtocolInterface<'db> {
             self.0
         }

crates/ty_python_semantic/src/types/protocol_class.rs

@@ -117,16 +117,22 @@ impl<'db> ProtocolInterface<'db> {
         )
     }
 
-    pub(super) fn apply_specialization(
+    pub(super) fn specialized_and_normalized(
         self,
         db: &'db dyn Db,
         specialization: Specialization<'db>,
     ) -> Self {
-        Self(
-            self.0
-                .into_iter()
-                .map(|(name, data)| (name, data.apply_specialization(db, specialization)))
-                .collect(),
+        Self::new(
+            db,
+            self._members(db)
+                .iter()
+                .map(|(name, data)| {
+                    (
+                        name.clone(),
+                        data.apply_specialization(db, specialization).normalized(db),
+                    )
+                })
+                .collect::<BTreeMap<_, _>>(),
         )
     }
 }
@@ -145,7 +151,7 @@ impl<'db> ProtocolMemberData<'db> {
         }
     }
 
-    fn apply_specialization(self, db: &'db dyn Db, specialization: Specialization<'db>) -> Self {
+    fn apply_specialization(&self, db: &'db dyn Db, specialization: Specialization<'db>) -> Self {
         Self {
             ty: self.ty.apply_specialization(db, specialization),
             qualifiers: self.qualifiers,