Check for compatibility when inherting from multiple classes

This diff is an attempt to address the issue in #943.

When a class inherits from multiple base classes, we check whether the
intersection of the types of the fields is never. If that's the case, we
raise an error.

Note 1:
There are some errors when type checking the builtins (which is
reflected by errors in scrut tests). They seem to be caused by
subtyping checks of self types in functions and generic function types.

Note 2:
Should this be a new error category? I'm currently reusing the closest
error category for inconsistent overloads, but that looks very specific.

Author: fangyi-zhou

pyrefly/lib/alt/narrow.rs

@@ -101,7 +101,8 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
         self.intersect_with_fallback(left, right, Type::never)
     }
 
-    fn intersects(&self, ts: &[Type]) -> Type {
+    /// Calculate the intersection of a number of types
+    pub fn intersects(&self, ts: &[Type]) -> Type {
         match ts {
             [] => Type::ClassType(self.stdlib.object().clone()),
             [ty] => ty.clone(),

pyrefly/lib/alt/solve.rs

@@ -9,6 +9,7 @@ use std::iter;
 use std::sync::Arc;
 
 use dupe::Dupe;
+use itertools::Itertools;
 use pyrefly_python::ast::Ast;
 use pyrefly_python::dunder;
 use pyrefly_python::short_identifier::ShortIdentifier;
@@ -72,6 +73,7 @@ use crate::binding::binding::FunctionParameter;
 use crate::binding::binding::FunctionStubOrImpl;
 use crate::binding::binding::IsAsync;
 use crate::binding::binding::Key;
+use crate::binding::binding::KeyClassField;
 use crate::binding::binding::KeyExport;
 use crate::binding::binding::KeyUndecoratedFunction;
 use crate::binding::binding::LastStmt;
@@ -1533,6 +1535,52 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                     errors,
                 );
             }
+
+            // If we are inheriting from multiple base types, we should
+            // check whether the multiple inheritance is consistent
+            if class_bases.as_ref().base_type_count() > 1 {
+                // Maps field from inherited class
+                let mro = self.get_mro_for_class(cls);
+                let mut inherited_fields: SmallMap<&Name, Vec<(&Name, Type)>> = SmallMap::new();
+
+                for parent_cls in mro.ancestors_no_object().iter() {
+                    let class_fields = parent_cls.class_object().fields();
+                    for field in class_fields {
+                        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() {
+                            inherited_fields
+                                .entry(field)
+                                .or_default()
+                                .push((parent_cls.name(), field_entry.ty()));
+                        }
+                    }
+                }
+
+                for (field_name, class_and_types) in inherited_fields.iter() {
+                    if class_and_types.len() > 1 {
+                        let types: Vec<Type> =
+                            class_and_types.iter().map(|(_, ty)| ty.clone()).collect();
+                        let intersect = self.intersects(&types);
+                        if matches!(intersect, Type::Never(_)) {
+                            let class_and_types_str = class_and_types
+                                .iter()
+                                .map(|(cls, ty)| {
+                                    format!("`{}` from `{}`", self.for_display(ty.clone()), cls)
+                                })
+                                .join(", ");
+                            self.error(
+                                errors,
+                                cls.range(),
+                                ErrorInfo::Kind(ErrorKind::InconsistentOverload),
+                                format!(
+                                    "Inconsistent types for field `{field_name}` inherited from multiple base classes: {class_and_types_str}",
+                                ),
+                            );
+                        }
+                    }
+                }
+            }
         }
         Arc::new(EmptyAnswer)
     }

pyrefly/lib/alt/types/class_bases.rs

@@ -58,6 +58,10 @@ impl ClassBases {
     pub fn iter(&self) -> impl Iterator<Item = &ClassType> {
         self.base_types.iter()
     }
+
+    pub fn base_type_count(&self) -> usize {
+        self.base_types.len()
+    }
 }
 
 impl fmt::Display for ClassBases {

pyrefly/lib/alt/types/class_metadata.rs

@@ -401,7 +401,7 @@ pub struct TotalOrderingMetadata {
 /// If a class is present in multiple places of the inheritance tree (and is
 /// linearizable using C3 linearization), it is possible it appears with
 /// different type arguments. The type arguments computed here will always be
-/// those coming from the instance that was selected during lineariation.
+/// those coming from the instance that was selected during linearization.
 #[derive(Clone, Debug, VisitMut, TypeEq, PartialEq, Eq)]
 pub enum ClassMro {
     Resolved(Vec<ClassType>),

pyrefly/lib/test/class_subtyping.rs

@@ -261,3 +261,16 @@ class B(type(A)):  # E: Invalid expression form for base class: `type(A)`
 assert_type(B.x, Any)
     "#,
 );
+
+testcase!(
+    test_multiple_inheritance_incompatible_field,
+    r#"
+class Foo:
+    p: int
+class Bar:
+    p: str
+
+class Both(Foo, Bar): # E: Inconsistent types for field `p` inherited from multiple base classes: `int` from `Foo`, `str` from `Bar`
+    ...
+"#,
+);