Implement multiple inheritance checks for instance methods (#1452)

Summary:
Follow up from #1196. Closes #943.

When getting the field type from the parent field, we now check for instance method types first before using the raw types.

When using the raw types, the type parameters are not initialised, hence causing issues with functions that use type variables during subtyping checks. This diff adds a regression test for these cases.

Pull Request resolved: #1452

Reviewed By: stroxler

Differential Revision: D86374052

Pulled By: yangdanny97

fbshipit-source-id: 32bb6f9cdfcedcde0a6c310804ddbb6df4be18bb

Author: fangyi-zhou

pyrefly/lib/alt/class/class_field.rs

@@ -2185,14 +2185,22 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                 };
                 if let Some(parent_member) = self.get_class_member(class_object, field) {
                     let parent_field = Arc::unwrap_or_clone(parent_member.value.clone());
+                    // Get instance method types for fields that are methods, otherwise use the field type directly.
+                    let ty = self
+                        .as_instance_attribute(
+                            &parent_field,
+                            &Instance::of_protocol(parent_cls, self.instantiate(cls)),
+                        )
+                        .as_instance_method()
+                        .unwrap_or(field_entry.ty());
                     inherited_fields
                         .entry(field)
                         .or_default()
                         .push(InheritedFieldInfo {
                             class: class_object.dupe(),
                             metadata: parent_metadata.clone(),
                             field: parent_field,
-                            ty: field_entry.ty(),
+                            ty,
                         });
                 }
             }
@@ -2206,19 +2214,6 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     .iter()
                     .map(|info| info.ty.clone())
                     .collect();
-                if types.iter().any(|ty| {
-                    matches!(
-                        ty,
-                        Type::BoundMethod(..)
-                            | Type::Function(..)
-                            | Type::Forall(_)
-                            | Type::Overload(_)
-                    )
-                }) {
-                    // TODO(fangyizhou): Handle bound methods and functions properly
-                    // This is a leftover from https://github.com/facebook/pyrefly/pull/1196
-                    continue;
-                }
                 let intersect = self.intersects(&types);
                 if matches!(intersect, Type::Never(_)) {
                     let mut error_msg = vec1![

pyrefly/lib/test/class_subtyping.rs

@@ -312,15 +312,27 @@ class E(C, D): # E: Field `x` has inconsistent types inherited from multiple bas
 );
 
 testcase!(
-    bug = "This is currently not handled",
     test_multiple_inheritance_incompatible_methods,
     r#"
 class Foo:
     def foo(self) -> int: ...
 class Bar:
     def foo(self) -> str: ...
 
-class Both(Foo, Bar): # Expect error here
+class Both(Foo, Bar): # E: Field `foo` has inconsistent types inherited from multiple base classes
+    ...
+"#,
+);
+
+testcase!(
+    test_multiple_inheritance_compatible_generic_methods,
+    r#"
+class Foo[T1]:
+    def foo(self) -> T1: ...
+class Bar[T2]:
+    def foo(self) -> T2: ...
+
+class Both[T](Foo[T], Bar[T]): # Should have no error here
     ...
 "#,
 );