revert unnecessary changes for the purpose of this PR

Author: mtshiba

crates/ty_python_semantic/resources/corpus/divergent.py

@@ -57,6 +57,9 @@ def unwrap(value):
     else:
         raise TypeError()
 
+# TODO: If this is commented out, that is, if `infer_scope_types` is called before `infer_return_type`, it will panic.
+reveal_type(unwrap(Foo()))
+
 def descent(x: int, y: int):
     if x > y:
         y, x = descent(y, x)
@@ -67,3 +70,6 @@ def descent(x: int, y: int):
         return (0, 1)
     else:
         return descent(x-1, y-1)
+
+# TODO: If this is commented out, that is, if `infer_scope_types` is called before `infer_return_type`, it will panic.
+reveal_type(descent(5, 3))

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -2281,24 +2281,6 @@ class B:
 
 reveal_type(B().x)  # revealed: Unknown | Literal[1]
 reveal_type(A().x)  # revealed: Unknown | Literal[1]
-
-class Base:
-    def flip(self) -> "Sub":
-        return Sub()
-
-class Sub(Base):
-    # TODO invalid override error
-    def flip(self) -> "Base":
-        return Base()
-
-class C2:
-    def __init__(self, x: Sub):
-        self.x = x
-
-    def replace_with(self, other: "C2"):
-        self.x = other.x.flip()
-
-reveal_type(C2(Sub()).x)  # revealed: Unknown | Base
 ```
 
 This case additionally tests our union/intersection simplification logic:

crates/ty_python_semantic/resources/mdtest/cycle.md

@@ -31,28 +31,3 @@ p = Point()
 reveal_type(p.x)  # revealed: Unknown | int
 reveal_type(p.y)  # revealed: Unknown | int
 ```
-
-## Self-referential bare type alias
-
-```py
-A = list["A" | None]
-
-def f(x: A):
-    # TODO: should be `list[A | None]`?
-    reveal_type(x)  # revealed: list[Divergent]
-    # TODO: should be `A | None`?
-    reveal_type(x[0])  # revealed: Divergent
-```
-
-## Self-referential type variables
-
-```py
-from typing import Generic, TypeVar
-
-B = TypeVar("B", bound="Base")
-
-# TODO: no error
-# error: [invalid-argument-type] "`typing.TypeVar | typing.TypeVar` is not a valid argument to `Generic`"
-class Base(Generic[B]):
-    pass
-```

crates/ty_python_semantic/src/types.rs

@@ -39,7 +39,6 @@ use crate::semantic_index::scope::ScopeId;
 use crate::semantic_index::{imported_modules, place_table, semantic_index};
 use crate::suppression::check_suppressions;
 use crate::types::call::{Binding, Bindings, CallArguments, CallableBinding};
-use crate::types::class::MethodDecorator;
 pub(crate) use crate::types::class_base::ClassBase;
 use crate::types::constraints::{
     ConstraintSet, IteratorConstraintsExtension, OptionConstraintsExtension,
@@ -62,15 +61,14 @@ pub use crate::types::ide_support::{
     definitions_for_keyword_argument, definitions_for_name, find_active_signature_from_details,
     inlay_hint_function_argument_details,
 };
-use crate::types::infer::InferExpression;
 use crate::types::mro::{Mro, MroError, MroIterator};
 pub(crate) use crate::types::narrow::infer_narrowing_constraint;
 pub(crate) use crate::types::signatures::{Parameter, Parameters};
 use crate::types::signatures::{ParameterForm, walk_signature};
 use crate::types::tuple::TupleSpec;
 pub(crate) use crate::types::typed_dict::{TypedDictParams, TypedDictType, walk_typed_dict_type};
 use crate::types::variance::{TypeVarVariance, VarianceInferable};
-use crate::unpack::{EvaluationMode, Unpack};
+use crate::unpack::EvaluationMode;
 pub use crate::util::diagnostics::add_inferred_python_version_hint_to_diagnostic;
 use crate::{Db, FxOrderSet, Module, Program};
 pub(crate) use class::{ClassLiteral, ClassType, GenericAlias, KnownClass};
@@ -121,16 +119,13 @@ fn return_type_cycle_recover<'db>(
 }
 
 fn return_type_cycle_initial<'db>(db: &'db dyn Db, method: BoundMethodType<'db>) -> Type<'db> {
-    Type::divergent(DivergentType::new(
-        db,
-        DivergenceKind::InferReturnType(
-            method
-                .function(db)
-                .literal(db)
-                .last_definition(db)
-                .body_scope(db),
-        ),
-    ))
+    Type::divergent(
+        method
+            .function(db)
+            .literal(db)
+            .last_definition(db)
+            .body_scope(db),
+    )
 }
 
 pub fn check_types(db: &dyn Db, file: File) -> Vec<Diagnostic> {
@@ -287,7 +282,11 @@ pub(crate) struct RecursiveTypeNormalizedVisitor<'db> {
 
 impl<'db> RecursiveTypeNormalizedVisitor<'db> {
     fn new(div: Type<'db>) -> Self {
-        debug_assert!(matches!(div, Type::Dynamic(DynamicType::Divergent(_))));
+        // TODO: Divergent only
+        debug_assert!(matches!(
+            div,
+            Type::Never | Type::Dynamic(DynamicType::Divergent(_))
+        ));
         Self {
             transformer: NormalizedVisitor::default(),
             div,
@@ -446,22 +445,13 @@ fn member_lookup_cycle_recover<'db>(
     salsa::CycleRecoveryAction::Iterate
 }
 
-#[allow(clippy::needless_pass_by_value)]
 fn member_lookup_cycle_initial<'db>(
-    db: &'db dyn Db,
-    self_type: Type<'db>,
-    name: Name,
-    policy: MemberLookupPolicy,
+    _db: &'db dyn Db,
+    _self: Type<'db>,
+    _name: Name,
+    _policy: MemberLookupPolicy,
 ) -> PlaceAndQualifiers<'db> {
-    Place::bound(Type::divergent(DivergentType::new(
-        db,
-        DivergenceKind::MemberLookupWithPolicy {
-            self_type,
-            name,
-            policy,
-        },
-    )))
-    .into()
+    Place::bound(Type::Never).into()
 }
 
 fn class_lookup_cycle_recover<'db>(
@@ -475,22 +465,13 @@ fn class_lookup_cycle_recover<'db>(
     salsa::CycleRecoveryAction::Iterate
 }
 
-#[allow(clippy::needless_pass_by_value)]
 fn class_lookup_cycle_initial<'db>(
-    db: &'db dyn Db,
-    self_type: Type<'db>,
-    name: Name,
-    policy: MemberLookupPolicy,
+    _db: &'db dyn Db,
+    _self: Type<'db>,
+    _name: Name,
+    _policy: MemberLookupPolicy,
 ) -> PlaceAndQualifiers<'db> {
-    Place::bound(Type::divergent(DivergentType::new(
-        db,
-        DivergenceKind::ClassLookupWithPolicy {
-            self_type,
-            name,
-            policy,
-        },
-    )))
-    .into()
+    Place::bound(Type::Never).into()
 }
 
 #[allow(clippy::trivially_copy_pass_by_ref)]
@@ -909,8 +890,8 @@ impl<'db> Type<'db> {
         Self::Dynamic(DynamicType::Unknown)
     }
 
-    pub(crate) fn divergent(divergent: DivergentType<'db>) -> Self {
-        Self::Dynamic(DynamicType::Divergent(divergent))
+    pub(crate) fn divergent(scope: ScopeId<'db>) -> Self {
+        Self::Dynamic(DynamicType::Divergent(DivergentType { scope }))
     }
 
     pub const fn is_unknown(&self) -> bool {
@@ -3169,7 +3150,7 @@ impl<'db> Type<'db> {
         policy: MemberLookupPolicy,
     ) -> PlaceAndQualifiers<'db> {
         tracing::trace!("class_member: {}.{}", self.display(db), name);
-        let result = match self {
+        match self {
             Type::Union(union) => union.map_with_boundness_and_qualifiers(db, |elem| {
                 elem.class_member_with_policy(db, name.clone(), policy)
             }),
@@ -3187,30 +3168,7 @@ impl<'db> Type<'db> {
                 .expect(
                     "`Type::find_name_in_mro()` should return `Some()` when called on a meta-type",
                 ),
-        };
-        result.map_type(|ty| {
-            // In fixed-point iteration of type inference, the member type must be monotonically widened and not "oscillate".
-            // Here, monotonicity is guaranteed by pre-unioning the type of the previous iteration into the current result.
-            let previous_cycle_value = self.class_member_with_policy(db, name.clone(), policy);
-
-            let ty = if let Some(previous_ty) = previous_cycle_value.place.ignore_possibly_unbound()
-            {
-                UnionType::from_elements(db, [ty, previous_ty])
-            } else {
-                ty
-            };
-
-            let div = Type::divergent(DivergentType::new(
-                db,
-                DivergenceKind::ClassLookupWithPolicy {
-                    self_type: self,
-                    name,
-                    policy,
-                },
-            ));
-            let visitor = RecursiveTypeNormalizedVisitor::new(div);
-            ty.recursive_type_normalized(db, &visitor)
-        })
+        }
     }
 
     /// This function roughly corresponds to looking up an attribute in the `__dict__` of an object.
@@ -3664,7 +3622,7 @@ impl<'db> Type<'db> {
 
         let name_str = name.as_str();
 
-        let result = match self {
+        match self {
             Type::Union(union) => union.map_with_boundness_and_qualifiers(db, |elem| {
                 elem.member_lookup_with_policy(db, name_str.into(), policy)
             }),
@@ -4003,30 +3961,7 @@ impl<'db> Type<'db> {
                     .try_call_dunder_get_on_attribute(db, owner_attr.clone())
                     .unwrap_or(owner_attr)
             }
-        };
-        result.map_type(|ty| {
-            // In fixed-point iteration of type inference, the member type must be monotonically widened and not "oscillate".
-            // Here, monotonicity is guaranteed by pre-unioning the type of the previous iteration into the current result.
-            let previous_cycle_value = self.member_lookup_with_policy(db, name.clone(), policy);
-
-            let ty = if let Some(previous_ty) = previous_cycle_value.place.ignore_possibly_unbound()
-            {
-                UnionType::from_elements(db, [ty, previous_ty])
-            } else {
-                ty
-            };
-
-            let div = Type::divergent(DivergentType::new(
-                db,
-                DivergenceKind::MemberLookupWithPolicy {
-                    self_type: self,
-                    name,
-                    policy,
-                },
-            ));
-            let visotor = RecursiveTypeNormalizedVisitor::new(div);
-            ty.recursive_type_normalized(db, &visotor)
-        })
+        }
     }
 
     /// Resolves the boolean value of the type and falls back to [`Truthiness::Ambiguous`] if the type doesn't implement `__bool__` correctly.
@@ -7485,59 +7420,17 @@ impl<'db> KnownInstanceType<'db> {
     }
 }
 
-#[allow(private_interfaces)]
-#[derive(Clone, Debug, Eq, Hash, PartialEq, salsa::Update, get_size2::GetSize)]
-pub enum DivergenceKind<'db> {
-    /// Divergence from `{FunctionLiteral, BoundMethodType}::infer_return_type`.
-    InferReturnType(ScopeId<'db>),
-    /// Divergence from `ClassLiteral::implicit_attribute_inner`.
-    ImplicitAttribute {
-        class_body_scope: ScopeId<'db>,
-        name: String,
-        target_method_decorator: MethodDecorator,
-    },
-    /// Divergence from `Type::member_lookup_with_policy`.
-    MemberLookupWithPolicy {
-        self_type: Type<'db>,
-        name: Name,
-        policy: MemberLookupPolicy,
-    },
-    /// Divergence from `Type::class_lookup_with_policy`.
-    ClassLookupWithPolicy {
-        self_type: Type<'db>,
-        name: Name,
-        policy: MemberLookupPolicy,
-    },
-    /// Divergence from `infer_expression_type_impl`.
-    InferExpression(InferExpression<'db>),
-    /// Divergence from `infer_expression_types_impl`.
-    InferExpressionTypes(InferExpression<'db>),
-    /// Divergence from `infer_definition_types`.
-    InferDefinitionTypes(Definition<'db>),
-    /// Divergence from `infer_scope_types`.
-    InferScopeTypes(ScopeId<'db>),
-    /// Divergence from `infer_unpack_types`.
-    InferUnpackTypes(Unpack<'db>),
-}
-
-pub(crate) type CycleRecoveryType<'db> = Type<'db>;
-
 /// A type that is determined to be divergent during recursive type inference.
 /// This type must never be eliminated by dynamic type reduction
 /// (e.g. `Divergent` is assignable to `@Todo`, but `@Todo | Divergent` must not be reducted to `@Todo`).
 /// Otherwise, type inference cannot converge properly.
 /// For detailed properties of this type, see the unit test at the end of the file.
-#[salsa::interned(debug, heap_size=ruff_memory_usage::heap_size)]
-#[derive(PartialOrd, Ord)]
+#[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, salsa::Update, get_size2::GetSize)]
 pub struct DivergentType<'db> {
-    /// The kind of divergence.
-    #[returns(ref)]
-    kind: DivergenceKind<'db>,
+    /// The scope where this divergence was detected.
+    scope: ScopeId<'db>,
 }
 
-// The Salsa heap is tracked separately.
-impl get_size2::GetSize for DivergentType<'_> {}
-
 #[derive(Copy, Clone, Debug, Eq, Hash, PartialEq, salsa::Update, get_size2::GetSize)]
 pub enum DynamicType<'db> {
     /// An explicitly annotated `typing.Any`
@@ -12000,11 +11893,7 @@ pub(crate) mod tests {
         let file = system_path_to_file(&db, "src/foo.py").unwrap();
         let file_scope_id = FileScopeId::global();
         let scope = file_scope_id.to_scope_id(&db, file);
-
-        let div = Type::divergent(DivergentType::new(
-            &db,
-            DivergenceKind::InferReturnType(scope),
-        ));
+        let div = Type::divergent(scope);
 
         // The `Divergent` type must not be eliminated in union with other dynamic types,
         // as this would prevent detection of divergent type inference using `Divergent`.