Fix Self type not bound in class body expressions

Summary:
When `Self` was used in a class body expression (not an annotation), it was
not being properly bound to the current class. For example:

```python
class SomeClass:
    cache = dict[int, Self]()  # Self was unbound here

    def get_instance(self) -> Self:
        x = self.cache[0]
        if x:
            return x  # Error: Self not assignable to Self@SomeClass
        raise RuntimeError()
```

The root cause was that `ensure_expr` (used for regular expressions) did not
call `track_potential_typing_self()`, while `ensure_type_internal` (used for
annotations) did. This meant that `Self` usages in expressions never got a
`SelfTypeLiteral` binding created, so during solving the `Self` remained as
an unbound `SpecialForm::SelfType` instead of being resolved to
`Type::SelfType(ClassType)`.

The fix adds the call to `track_potential_typing_self()` in `ensure_expr`.

Fixes #2250

Reviewed By: migeed-z

Differential Revision: D91745916

fbshipit-source-id: d6e6aee90b451784de33a29fe0391edc5807f44a

Author: grievejia

pyrefly/lib/binding/expr.rs

@@ -538,6 +538,10 @@ impl<'a> BindingsBuilder<'a> {
     pub fn ensure_expr(&mut self, x: &mut Expr, usage: &mut Usage) {
         self.with_semantic_checker(|semantic, context| semantic.visit_expr(x, context));
 
+        // Track uses of `typing.Self` in class bodies so they can be properly bound
+        // to the current class during the solving phase.
+        self.track_potential_typing_self(x);
+
         match x {
             Expr::Attribute(attr) => {
                 self.check_private_attribute_usage(attr);

pyrefly/lib/test/typing_self.rs

@@ -209,3 +209,23 @@ class Shape:
         return Shape()  # should error: returns Shape, not Self
 "#,
 );
+
+testcase!(
+    test_self_in_class_body_expression,
+    r#"
+from typing import Self, assert_type
+
+class SomeClass:
+    # Self in inferred class variable type
+    cache = dict[int, Self]()
+
+    def get_instance(self) -> Self:
+        x = self.cache[0]
+        if x:
+            return x
+        raise RuntimeError()
+
+assert_type(SomeClass().cache, dict[int, SomeClass])
+assert_type(SomeClass().get_instance(), SomeClass)
+"#,
+);