more compile errors after rebase

Author: AlexWaygood

crates/ty_python_semantic/src/types.rs

@@ -5027,7 +5027,7 @@ impl<'db> Type<'db> {
             ),
 
             Type::ProtocolInstance(instance) => {
-                Type::ProtocolInstance(instance.apply_specialization(db, specialization))
+                Type::ProtocolInstance(instance.apply_specialization(db, type_mapping))
             }
 
             Type::MethodWrapper(MethodWrapperKind::FunctionTypeDunderGet(function)) => {

crates/ty_python_semantic/src/types/instance.rs

@@ -247,17 +247,17 @@ impl<'db> ProtocolInstanceType<'db> {
         }
     }
 
-    pub(super) fn apply_specialization(
+    pub(super) fn apply_specialization<'a>(
         self,
         db: &'db dyn Db,
-        specialization: Specialization<'db>,
+        type_mapping: TypeMapping<'a, 'db>,
     ) -> Self {
         match self.0 {
             Protocol::FromClass(class) => Self(Protocol::FromClass(
-                class.apply_specialization(db, specialization),
+                class.apply_type_mapping(db, type_mapping),
             )),
             Protocol::Synthesized(synthesized) => Self(Protocol::Synthesized(
-                synthesized.apply_specialization(db, specialization),
+                synthesized.apply_type_mapping(db, type_mapping),
             )),
         }
     }
@@ -288,7 +288,7 @@ impl<'db> Protocol<'db> {
 
 mod synthesized_protocol {
     use crate::db::Db;
-    use crate::types::generics::Specialization;
+    use crate::types::generics::TypeMapping;
     use crate::types::protocol_class::ProtocolInterface;
 
     /// A "synthesized" protocol type that is dissociated from a class definition in source code.
@@ -308,12 +308,12 @@ mod synthesized_protocol {
             Self(interface.normalized(db))
         }
 
-        pub(super) fn apply_specialization(
+        pub(super) fn apply_type_mapping<'a>(
             self,
             db: &'db dyn Db,
-            specialization: Specialization<'db>,
+            type_mapping: TypeMapping<'a, 'db>,
         ) -> Self {
-            Self(self.0.specialized_and_normalized(db, specialization))
+            Self(self.0.specialized_and_normalized(db, type_mapping))
         }
 
         pub(in crate::types) fn interface(self) -> ProtocolInterface<'db> {

crates/ty_python_semantic/src/types/protocol_class.rs

@@ -8,7 +8,7 @@ use crate::{
     db::Db,
     semantic_index::{symbol_table, use_def_map},
     symbol::{symbol_from_bindings, symbol_from_declarations},
-    types::{ClassBase, ClassLiteral, KnownFunction, Specialization, Type, TypeQualifiers},
+    types::{ClassBase, ClassLiteral, KnownFunction, Type, TypeMapping, TypeQualifiers},
 };
 
 impl<'db> ClassLiteral<'db> {
@@ -117,10 +117,10 @@ impl<'db> ProtocolInterface<'db> {
         )
     }
 
-    pub(super) fn specialized_and_normalized(
+    pub(super) fn specialized_and_normalized<'a>(
         self,
         db: &'db dyn Db,
-        specialization: Specialization<'db>,
+        type_mapping: TypeMapping<'a, 'db>,
     ) -> Self {
         Self::new(
             db,
@@ -129,7 +129,7 @@ impl<'db> ProtocolInterface<'db> {
                 .map(|(name, data)| {
                     (
                         name.clone(),
-                        data.apply_specialization(db, specialization).normalized(db),
+                        data.apply_type_mapping(db, type_mapping).normalized(db),
                     )
                 })
                 .collect::<BTreeMap<_, _>>(),
@@ -151,9 +151,9 @@ impl<'db> ProtocolMemberData<'db> {
         }
     }
 
-    fn apply_specialization(&self, db: &'db dyn Db, specialization: Specialization<'db>) -> Self {
+    fn apply_type_mapping<'a>(&self, db: &'db dyn Db, type_mapping: TypeMapping<'a, 'db>) -> Self {
         Self {
-            ty: self.ty.apply_specialization(db, specialization),
+            ty: self.ty.apply_type_mapping(db, type_mapping),
             qualifiers: self.qualifiers,
         }
     }