Review feedback

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/directives/cast.md

@@ -81,6 +81,22 @@ def f(x: Any, y: Unknown, z: Any | str | int):
     e = cast(str | int | Any, z)  # error: [redundant-cast]
 ```
 
+Recursive aliases that fall back to `Divergent` should not trigger `redundant-cast`.
+
+```toml
+[environment]
+python-version = "3.12"
+```
+
+```py
+from typing import cast
+
+RecursiveAlias = list["RecursiveAlias | None"]
+
+def f(x: RecursiveAlias):
+    cast(RecursiveAlias, x)
+```
+
 ## Diagnostic snapshots
 
 <!-- snapshot-diagnostics -->

crates/ty_python_semantic/resources/mdtest/ide_support/all_members.md

@@ -108,6 +108,29 @@ static_assert(has_member(C(), "static_method"))
 static_assert(not has_member(C(), "non_existent"))
 ```
 
+Recursive attribute inference can fall back to `Divergent`, but should still preserve members that
+were available before the cycle was introduced:
+
+```py
+from ty_extensions import has_member, static_assert
+
+class Base:
+    def flip(self) -> "Base":
+        return Base()
+
+class Sub(Base):
+    pass
+
+class C:
+    def __init__(self, x: Sub):
+        self.x = [x]
+
+    def replace_with(self, other: "C"):
+        self.x = [self.x[0].flip()]
+
+static_assert(has_member(C(Sub()).x[0], "flip"))
+```
+
 ### Class objects
 
 ```toml

crates/ty_python_semantic/resources/mdtest/typed_dict.md

@@ -1508,17 +1508,24 @@ _ = cast(Bar2, foo)  # error: [redundant-cast]
 ```py
 from typing import TypedDict, Final, Literal, Any
 
+RecursiveKey = list["RecursiveKey | None"]
+
 class Person(TypedDict):
     name: str
     age: int | None
 
 class Animal(TypedDict):
     name: str
 
+class Movie(TypedDict):
+    name: str
+
 NAME_FINAL: Final = "name"
 AGE_FINAL: Final[Literal["age"]] = "age"
 
 def _(
+    recursive_key: RecursiveKey,
+    movie: Movie,
     person: Person,
     animal: Animal,
     being: Person | Animal,
@@ -1546,6 +1553,8 @@ def _(
     # No error here:
     reveal_type(person[unknown_key])  # revealed: Unknown
 
+    reveal_type(movie[recursive_key[0]])  # revealed: Unknown
+
     # error: [invalid-key] "Unknown key "anything" for TypedDict `Animal`"
     reveal_type(animal["anything"])  # revealed: Unknown
 

crates/ty_python_semantic/src/types.rs

@@ -6461,10 +6461,6 @@ pub enum DynamicType<'db> {
     TodoStarredExpression,
     /// A special Todo-variant for `TypeVarTuple` instances encountered in type expressions
     TodoTypeVarTuple,
-    /// A special Todo-variant for functional `TypedDict`s.
-    TodoFunctionalTypedDict,
-    /// A type that is determined to be divergent during recursive type inference.
-    Divergent(DivergentType),
 }
 
 impl DynamicType<'_> {
@@ -6489,8 +6485,6 @@ impl std::fmt::Display for DynamicType<'_> {
             DynamicType::TodoUnpack => f.write_str("@Todo(typing.Unpack)"),
             DynamicType::TodoStarredExpression => f.write_str("@Todo(StarredExpression)"),
             DynamicType::TodoTypeVarTuple => f.write_str("@Todo(TypeVarTuple)"),
-            DynamicType::TodoFunctionalTypedDict => f.write_str("@Todo(Functional TypedDicts)"),
-            DynamicType::Divergent(_) => f.write_str("Divergent"),
         }
     }
 }

crates/ty_python_semantic/src/types/function.rs

@@ -2043,11 +2043,23 @@ impl KnownFunction {
                 let [Some(casted_type), Some(source_type)] = parameter_types else {
                     return;
                 };
-                let contains_unknown_or_todo =
-                    |ty| matches!(ty, Type::Dynamic(dynamic) if dynamic != DynamicType::Any);
+                let contains_unknown_or_todo_or_divergent = |ty: Type<'_>| {
+                    matches!(ty, Type::Divergent(_))
+                        || (ty.is_dynamic() && !matches!(ty, Type::Dynamic(DynamicType::Any)))
+                };
                 if source_type.is_equivalent_to(db, *casted_type)
-                    && !any_over_type(db, *source_type, true, contains_unknown_or_todo)
-                    && !any_over_type(db, *casted_type, true, contains_unknown_or_todo)
+                    && !any_over_type(
+                        db,
+                        *source_type,
+                        true,
+                        contains_unknown_or_todo_or_divergent,
+                    )
+                    && !any_over_type(
+                        db,
+                        *casted_type,
+                        true,
+                        contains_unknown_or_todo_or_divergent,
+                    )
                 {
                     if let Some(builder) = context.report_lint(&REDUNDANT_CAST, call_expression) {
                         let source_display = source_type.display(db).to_string();

crates/ty_python_semantic/src/types/infer/builder/subscript.rs

@@ -1213,7 +1213,7 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                     // types like `LiteralString & Any` to pass, but it does not need to be perfect. We would just
                     // fail to provide the "can only be subscripted with a string literal key" hint in that case.
 
-                    if slice_ty.is_dynamic() {
+                    if slice_ty.is_dynamic() || slice_ty.is_divergent() {
                         return true;
                     }
 

crates/ty_python_semantic/src/types/list_members.rs

@@ -170,10 +170,12 @@ impl<'db> AllMembers<'db> {
                     // `Type` guarantees that unions/intersections
                     // are kept in DNF (i.e., they are flattened).
                     ty.is_dynamic()
+                        || ty.is_divergent()
                         || match ty {
-                            Type::Intersection(intersection) => {
-                                intersection.positive(db).iter().any(Type::is_dynamic)
-                            }
+                            Type::Intersection(intersection) => intersection
+                                .positive(db)
+                                .iter()
+                                .any(|ty| ty.is_dynamic() || ty.is_divergent()),
                             _ => false,
                         }
                 }

crates/ty_python_semantic/src/types/subscript.rs

@@ -439,7 +439,7 @@ fn typed_dict_subscript<'db>(
     typed_dict: TypedDictType<'db>,
     slice_ty: Type<'db>,
 ) -> Result<Type<'db>, SubscriptError<'db>> {
-    if slice_ty.is_dynamic() {
+    if slice_ty.is_dynamic() || slice_ty.is_divergent() {
         return Ok(Type::unknown());
     }