revert unnecessary changes

Author: mtshiba

crates/ty_python_semantic/src/types.rs

@@ -10775,10 +10775,10 @@ fn walk_bound_method_type<'db, V: visitor::TypeVisitor<'db> + ?Sized>(
 
 fn into_callable_type_cycle_initial<'db>(
     db: &'db dyn Db,
-    id: salsa::Id,
+    _id: salsa::Id,
     _self: BoundMethodType<'db>,
 ) -> CallableType<'db> {
-    CallableType::divergent(db, id)
+    CallableType::bottom(db)
 }
 
 #[salsa::tracked]
@@ -10977,14 +10977,6 @@ impl<'db> CallableType<'db> {
         Self::new(db, CallableSignature::bottom(), false)
     }
 
-    /// Create a callable type which represents a divergent "bottom" callable.
-    ///
-    /// Specifically, this represents a callable type with a single signature:
-    /// `(*args: object, **kwargs: object) -> Divergent`.
-    pub(crate) fn divergent(db: &'db dyn Db, id: salsa::Id) -> CallableType<'db> {
-        Self::new(db, CallableSignature::divergent(id), false)
-    }
-
     /// Return a "normalized" version of this `Callable` type.
     ///
     /// See [`Type::normalized`] for more details.
@@ -11948,11 +11940,11 @@ impl<'db> PEP695TypeAliasType<'db> {
 
 #[allow(clippy::unnecessary_wraps)]
 fn generic_context_cycle_initial<'db>(
-    db: &'db dyn Db,
-    id: salsa::Id,
+    _db: &'db dyn Db,
+    _id: salsa::Id,
     _self: PEP695TypeAliasType<'db>,
 ) -> Option<GenericContext<'db>> {
-    Some(GenericContext::cycle_initial(db, id))
+    None
 }
 
 fn value_type_cycle_initial<'db>(

crates/ty_python_semantic/src/types/class.rs

@@ -70,36 +70,18 @@ use ruff_text_size::{Ranged, TextRange};
 use rustc_hash::FxHashSet;
 
 fn explicit_bases_cycle_initial<'db>(
-    db: &'db dyn Db,
-    id: salsa::Id,
-    class: ClassLiteral<'db>,
+    _db: &'db dyn Db,
+    _id: salsa::Id,
+    _class: ClassLiteral<'db>,
 ) -> Box<[Type<'db>]> {
-    let module = parsed_module(db, class.file(db)).load(db);
-    let class_stmt = class.node(db, &module);
-
-    if class.is_known(db, KnownClass::VersionInfo) {
-        let tuple_type = TupleType::new(db, &TupleSpec::version_info_spec(db))
-            .expect("sys.version_info tuple spec should always be a valid tuple");
-
-        Box::new([
-            Type::divergent(id),
-            Type::from(tuple_type.to_class_type(db)),
-        ])
-    } else {
-        class_stmt
-            .bases()
-            .iter()
-            .map(|_| Type::divergent(id))
-            .collect()
-    }
+    Box::default()
 }
 
 fn inheritance_cycle_initial<'db>(
     _db: &'db dyn Db,
     _id: salsa::Id,
     _self: ClassLiteral<'db>,
 ) -> Option<InheritanceCycle> {
-    // Some(InheritanceCycle::Participant)?
     None
 }
 
@@ -1272,10 +1254,10 @@ impl<'db> ClassType<'db> {
 
 fn into_callable_cycle_initial<'db>(
     db: &'db dyn Db,
-    id: salsa::Id,
+    _id: salsa::Id,
     _self: ClassType<'db>,
 ) -> Type<'db> {
-    Type::Callable(CallableType::divergent(db, id))
+    Type::Callable(CallableType::bottom(db))
 }
 
 impl<'db> From<GenericAlias<'db>> for ClassType<'db> {
@@ -1425,11 +1407,11 @@ impl get_size2::GetSize for ClassLiteral<'_> {}
 
 #[allow(clippy::unnecessary_wraps)]
 fn generic_context_cycle_initial<'db>(
-    db: &'db dyn Db,
-    id: salsa::Id,
+    _db: &'db dyn Db,
+    _id: salsa::Id,
     _self: ClassLiteral<'db>,
 ) -> Option<GenericContext<'db>> {
-    Some(GenericContext::cycle_initial(db, id))
+    None
 }
 
 #[salsa::tracked]

crates/ty_python_semantic/src/types/function.rs

@@ -1236,18 +1236,18 @@ fn is_mode_with_nontrivial_return_type<'db>(db: &'db dyn Db, mode: Type<'db>) ->
 
 fn signature_cycle_initial<'db>(
     _db: &'db dyn Db,
-    id: salsa::Id,
+    _id: salsa::Id,
     _function: FunctionType<'db>,
 ) -> CallableSignature<'db> {
-    CallableSignature::single(Signature::divergent(id))
+    CallableSignature::single(Signature::bottom())
 }
 
 fn last_definition_signature_cycle_initial<'db>(
     _db: &'db dyn Db,
-    id: salsa::Id,
+    _id: salsa::Id,
     _function: FunctionType<'db>,
 ) -> Signature<'db> {
-    Signature::divergent(id)
+    Signature::bottom()
 }
 
 /// Non-exhaustive enumeration of known functions (e.g. `builtins.reveal_type`, ...) that might

crates/ty_python_semantic/src/types/generics.rs

@@ -212,7 +212,6 @@ impl<'db> GenericContextTypeVar<'db> {
 pub struct GenericContext<'db> {
     #[returns(ref)]
     variables_inner: FxOrderMap<BoundTypeVarIdentity<'db>, GenericContextTypeVar<'db>>,
-    cycle_recovery: Option<Type<'db>>,
 }
 
 pub(super) fn walk_generic_context<'db, V: super::visitor::TypeVisitor<'db> + ?Sized>(
@@ -229,10 +228,6 @@ pub(super) fn walk_generic_context<'db, V: super::visitor::TypeVisitor<'db> + ?S
 impl get_size2::GetSize for GenericContext<'_> {}
 
 impl<'db> GenericContext<'db> {
-    pub(crate) fn cycle_initial(db: &'db dyn Db, id: salsa::Id) -> Self {
-        Self::new_internal(db, FxOrderMap::default(), Some(Type::divergent(id)))
-    }
-
     fn from_variables(
         db: &'db dyn Db,
         variables: impl IntoIterator<Item = GenericContextTypeVar<'db>>,
@@ -243,7 +238,6 @@ impl<'db> GenericContext<'db> {
                 .into_iter()
                 .map(|variable| (variable.bound_typevar.identity(db), variable))
                 .collect::<FxOrderMap<_, _>>(),
-            None,
         )
     }
 
@@ -630,14 +624,9 @@ impl<'db> GenericContext<'db> {
     }
 
     fn heap_size(
-        (variables, cycle_recovery): &(
-            FxOrderMap<BoundTypeVarIdentity<'db>, GenericContextTypeVar<'db>>,
-            Option<Type<'db>>,
-        ),
+        (variables,): &(FxOrderMap<BoundTypeVarIdentity<'db>, GenericContextTypeVar<'db>>,),
     ) -> usize {
-        use get_size2::GetSize;
-
-        ruff_memory_usage::order_map_heap_size(variables) + cycle_recovery.get_heap_size()
+        ruff_memory_usage::order_map_heap_size(variables)
     }
 }
 

crates/ty_python_semantic/src/types/signatures.rs

@@ -137,10 +137,6 @@ impl<'db> CallableSignature<'db> {
         Self::single(Signature::bottom())
     }
 
-    pub(crate) fn divergent(id: salsa::Id) -> Self {
-        Self::single(Signature::divergent(id))
-    }
-
     /// Creates a new `CallableSignature` from an iterator of [`Signature`]s. Returns a
     /// non-callable signature if the iterator is empty.
     pub(crate) fn from_overloads<I>(overloads: I) -> Self
@@ -519,10 +515,6 @@ impl<'db> Signature<'db> {
         Self::new(Parameters::object(), Some(Type::Never))
     }
 
-    pub(crate) fn divergent(id: salsa::Id) -> Self {
-        Self::new(Parameters::object(), Some(Type::divergent(id)))
-    }
-
     pub(crate) fn with_inherited_generic_context(
         mut self,
         db: &'db dyn Db,