fix stack overflow on protocols that use Self

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/protocols.md

@@ -1753,6 +1753,28 @@ if isinstance(obj, (B, A)):
     reveal_type(obj)  # revealed: (Unknown & B) | (Unknown & A)
 ```
 
+### Protocols that use `Self`
+
+`Self` is a `TypeVar` with an upper bound of the class in which it is defined. This means that
+`Self` annotations in protocols can also be tricky to handle without infinite recursion and stack
+overflows.
+
+```py
+from typing_extensions import Protocol, Self
+from ty_extensions import static_assert, is_fully_static
+
+class _HashObject(Protocol):
+    def copy(self) -> Self: ...
+
+class Foo: ...
+
+# Attempting to build this union caused us to overflow on an early version of
+# <https://github.com/astral-sh/ruff/pull/18659>
+x: Foo | _HashObject
+
+static_assert(is_fully_static(_HashObject))
+```
+
 ## TODO
 
 Add tests for:

crates/ty_python_semantic/src/types.rs

@@ -771,9 +771,10 @@ impl<'db> Type<'db> {
             ),
 
             Self::Callable(callable) => Self::Callable(callable.replace_self_reference(db, class)),
+            Self::TypeVar(type_var) => Self::TypeVar(type_var.replace_self_reference(db, class)),
 
-            Self::GenericAlias(_) | Self::TypeVar(_) => {
-                // TODO: replace self-references in generic aliases and typevars
+            Self::GenericAlias(_) => {
+                // TODO: replace self-references in generic aliases
                 *self
             }
 
@@ -6126,6 +6127,20 @@ impl<'db> TypeVarInstance<'db> {
             self.kind(db),
         )
     }
+
+    fn replace_self_reference(self, db: &'db dyn Db, class: ClassLiteral<'db>) -> Self {
+        Self::new(
+            db,
+            self.name(db),
+            self.definition(db),
+            self.bound_or_constraints(db)
+                .map(|b| b.replace_self_reference(db, class)),
+            self.variance(db),
+            self.default_ty(db)
+                .map(|d| d.replace_self_reference(db, class)),
+            self.kind(db),
+        )
+    }
 }
 
 #[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, salsa::Update)]
@@ -6186,6 +6201,24 @@ impl<'db> TypeVarBoundOrConstraints<'db> {
             }
         }
     }
+
+    fn replace_self_reference(self, db: &'db dyn Db, class: ClassLiteral<'db>) -> Self {
+        match self {
+            TypeVarBoundOrConstraints::UpperBound(bound) => {
+                TypeVarBoundOrConstraints::UpperBound(bound.replace_self_reference(db, class))
+            }
+            TypeVarBoundOrConstraints::Constraints(constraints) => {
+                let constraints = constraints.map(db, |ty| ty.replace_self_reference(db, class));
+                match constraints {
+                    Type::Union(constraints) => TypeVarBoundOrConstraints::Constraints(constraints),
+                    _ => TypeVarBoundOrConstraints::Constraints(UnionType::new(
+                        db,
+                        Box::from([constraints]),
+                    )),
+                }
+            }
+        }
+    }
 }
 
 /// Error returned if a type is not (or may not be) a context manager.