Inconsistent inheritance check follow ups (#1298)

Summary:
This PR is a series of minor diffs building up to the correct handling of multiple inheritance checks for methods, following up from #1196.

Main changes:
- [Skip multiple inheritance check for fields that are overridden](6fccf4a): this diff prevents repeated error reporting when a field gets overridden -- in those cases we don't report inconsistent multiple inheritance
- [Skip multiple inheritance checks for "special" fields](b290fd1): this diff skips checks for multiple inheritances for some special fields like constructors.
- Cherry picking fixes for some problematic function types in stdlib in vendored typeshed

Next steps:
We're close to handle multiple inheritance checks for methods. We still have some errors on stdlib due to handling of type variables (#1196 (comment) item 2), which I consider as a blocker.

Pull Request resolved: #1298

Reviewed By: kinto0

Differential Revision: D85053799

Pulled By: yangdanny97

fbshipit-source-id: 2e6c22916886dc4c760931cf49522a057c7b42aa

Author: fangyi-zhou

pyrefly/lib/alt/class/class_field.rs

@@ -1780,30 +1780,18 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
             .is_some_and(|metadata| metadata.fields.contains_key(field_name))
     }
 
-    pub fn check_consistent_override_for_field(
-        &self,
-        cls: &Class,
-        field_name: &Name,
-        class_field: &ClassField,
-        bases: &ClassBases,
-        errors: &ErrorCollector,
-    ) {
-        let is_override = class_field.is_override();
-        if matches!(class_field.1, IsInherited::No) && !is_override {
-            return;
-        }
-
+    fn should_check_field_for_override_consistency(&self, field_name: &Name) -> bool {
         // Object construction (`__new__`, `__init__`, `__init_subclass__`) should not participate in override checks
         if field_name == &dunder::NEW
             || field_name == &dunder::INIT
             || field_name == &dunder::INIT_SUBCLASS
         {
-            return;
+            return false;
         }
 
         // `__hash__` is often overridden to `None` to signal hashability
         if field_name == &dunder::HASH {
-            return;
+            return false;
         }
 
         // TODO(grievejia): In principle we should not really skip `__call__`. But the reality is that
@@ -1815,21 +1803,46 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // -- any overrider must be able to take ANY arguments which can't be practical. We need to either
         // special-case typeshed or special-case callable subtyping to make `__call__` override check more usable.
         if field_name == &dunder::CALL {
-            return;
+            return false;
         }
 
-        // Private attributes should not participate in overrload checks
+        // Private attributes should not participate in override checks
         if field_name.starts_with("__") && !field_name.ends_with("__") {
-            return;
+            return false;
         }
 
         // TODO: This should only be ignored when `cls` is a dataclass
         if field_name == &dunder::POST_INIT {
-            return;
+            return false;
         }
 
         // TODO: This should only be ignored when `_ignore_` is defined on enums
         if field_name.as_str() == "_ignore_" {
+            return false;
+        }
+
+        // TODO: skipping slots for now to unblock typeshed upgrade
+        if field_name == &dunder::SLOTS {
+            return false;
+        }
+
+        true
+    }
+
+    pub fn check_consistent_override_for_field(
+        &self,
+        cls: &Class,
+        field_name: &Name,
+        class_field: &ClassField,
+        bases: &ClassBases,
+        errors: &ErrorCollector,
+    ) {
+        let is_override = class_field.is_override();
+        if matches!(class_field.1, IsInherited::No) && !is_override {
+            return;
+        }
+
+        if !self.should_check_field_for_override_consistency(field_name) {
             return;
         }
 
@@ -1995,17 +2008,24 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         // Maps field from inherited class
         let mro = self.get_mro_for_class(cls);
         let mut inherited_fields: SmallMap<&Name, Vec<(&Name, Type)>> = SmallMap::new();
+        let current_class_fields: SmallSet<_> = cls.fields().collect();
 
         for parent_cls in mro.ancestors_no_object().iter() {
             let class_fields = parent_cls.class_object().fields();
             for field in class_fields {
-                // Skip `__slots__` for now
-                if field == &dunder::SLOTS {
+                // Skip fields that are not relevant for override consistency checks
+                if !self.should_check_field_for_override_consistency(field) {
                     continue;
                 }
                 let key = KeyClassField(parent_cls.class_object().index(), field.clone());
                 let field_entry = self.get_from_class(cls, &key);
                 if let Some(field_entry) = field_entry.as_ref() {
+                    // Skip fields that are overridden in the current class,
+                    // they will have been checked by
+                    // `check_consistent_override_for_field` already
+                    if current_class_fields.contains(field) {
+                        continue;
+                    }
                     inherited_fields
                         .entry(field)
                         .or_default()

pyrefly/lib/test/class_subtyping.rs

@@ -300,7 +300,7 @@ class A:
     x: int
 class B:
     x: str
-class C(A, B): # E: Field `x` has inconsistent types inherited from multiple base classes
+class C(A, B):
     x: int # E: Class member `C.x` overrides parent class `B` in an inconsistent manner
 class D:
     x: int
@@ -324,3 +324,16 @@ class Both(Foo, Bar): # Expect error here
     ...
 "#,
 );
+
+testcase!(
+    test_multiple_inheritance_special_methods,
+    r#"
+class Foo:
+    def __init__(self, x: int) -> None: ...
+class Bar:
+    def __init__(self, x: str) -> None: ...
+
+class Both(Foo, Bar): # No error here, because __init__ is special
+    ...
+"#,
+);