regression

Author: asukaminato0721

pyrefly/lib/alt/class/class_field.rs

@@ -626,11 +626,55 @@ impl ClassField {
 
     fn instantiate_for(&self, heap: &TypeHeap, instance: &Instance) -> Self {
         self.instantiate_helper(&mut |ty| {
-            ty.subst_self_type_mut(&instance.to_type(heap));
+            if let Some(self_type) = instance.self_return_type_override() {
+                Self::subst_callable_return_self_type_mut(ty, self_type, &instance.to_type(heap));
+            } else {
+                ty.subst_self_type_mut(&instance.to_type(heap));
+            }
             instance.instantiate_member(ty)
         })
     }
 
+    fn subst_callable_return_self_type_mut(
+        ty: &mut Type,
+        self_type: &Type,
+        fallback_self_type: &Type,
+    ) {
+        let subst_callable = |callable: &mut Callable| {
+            callable.ret.subst_self_type_mut(self_type);
+            callable
+                .params
+                .visit_mut(&mut |ty| ty.subst_self_type_mut(fallback_self_type));
+        };
+        match ty {
+            Type::Callable(callable) => subst_callable(callable),
+            Type::Function(func) => subst_callable(&mut func.signature),
+            Type::Forall(forall) => match &mut forall.body {
+                Forallable::Callable(callable) => subst_callable(callable),
+                Forallable::Function(func) => subst_callable(&mut func.signature),
+                _ => ty.subst_self_type_mut(fallback_self_type),
+            },
+            Type::Overload(overload) => {
+                for sig in overload.signatures.iter_mut() {
+                    match sig {
+                        OverloadType::Function(func) => subst_callable(&mut func.signature),
+                        OverloadType::Forall(forall) => subst_callable(&mut forall.body.signature),
+                    }
+                }
+            }
+            Type::Union(union) => {
+                for member in union.members.iter_mut() {
+                    Self::subst_callable_return_self_type_mut(
+                        member,
+                        self_type,
+                        fallback_self_type,
+                    );
+                }
+            }
+            _ => ty.subst_self_type_mut(fallback_self_type),
+        }
+    }
+
     fn instantiate_for_class_targs(
         &self,
         targs: &TArgs,
@@ -3822,7 +3866,11 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
     ) -> Option<ClassAttribute> {
         self.get_class_member(cls.class_object(), name)
             .map(|field| {
-                self.as_instance_attribute(name, &field, &Instance::of_protocol(cls, self_type))
+                self.as_instance_attribute(
+                    name,
+                    &field,
+                    &Instance::of_class_with_self_type(cls, self_type),
+                )
             })
     }
 

pyrefly/lib/alt/types/instance.rs

@@ -27,6 +27,7 @@ pub enum InstanceKind {
     TypedDict,
     TypeVar(Quantified),
     SelfType,
+    ClassWithSelfType(Type),
     Protocol(Type),
     Metaclass(ClassBase),
     LiteralString,
@@ -83,6 +84,14 @@ impl<'a> Instance<'a> {
         }
     }
 
+    pub fn of_class_with_self_type(cls: &'a ClassType, self_type: Type) -> Self {
+        Self {
+            kind: InstanceKind::ClassWithSelfType(self_type),
+            class: cls.class_object(),
+            targs: cls.targs(),
+        }
+    }
+
     pub fn of_protocol(cls: &'a ClassType, self_type: Type) -> Self {
         Self {
             kind: InstanceKind::Protocol(self_type),
@@ -113,9 +122,16 @@ impl<'a> Instance<'a> {
         self.targs.substitute_into_mut(raw_member)
     }
 
+    pub fn self_return_type_override(&self) -> Option<&Type> {
+        match &self.kind {
+            InstanceKind::ClassWithSelfType(self_type) => Some(self_type),
+            _ => None,
+        }
+    }
+
     pub fn to_type(&self, heap: &TypeHeap) -> Type {
         match &self.kind {
-            InstanceKind::ClassType => {
+            InstanceKind::ClassType | InstanceKind::ClassWithSelfType(_) => {
                 heap.mk_class_type(ClassType::new(self.class.dupe(), self.targs.clone()))
             }
             InstanceKind::TypedDict => {
@@ -161,6 +177,7 @@ impl<'a> Instance<'a> {
                 self.targs.clone(),
             ))),
             InstanceKind::ClassType
+            | InstanceKind::ClassWithSelfType(_)
             | InstanceKind::Protocol(..)
             | InstanceKind::Metaclass(..)
             | InstanceKind::TypeVar(..)

pyrefly/lib/test/narrow.rs

@@ -1548,6 +1548,20 @@ def test[T: ParentModel](value: T) -> T:
     "#,
 );
 
+testcase!(
+    test_non_self_method_on_generic_typevar_intersection,
+    r#"
+class Mixin[T]:
+    def remove_all_commands(self) -> None: ...
+
+class Command[T]: ...
+
+def test[CogT](command: Command[CogT]) -> None:
+    if isinstance(command, Mixin):
+        command.remove_all_commands()
+    "#,
+);
+
 testcase!(
     test_issubclass_typevar_nondisjoint_classes,
     r#"