fix class_metadata and regression test (#2379)

Summary:
This PR addresses issue #2371 by reporting inconsistent type args when the same direct base class appears with different type parameters across inheritance paths. It also adds a regression test

Fixes #2371

Pull Request resolved: #2379

Test Plan: python3 test.py

Reviewed By: stroxler

Differential Revision: D92869958

Pulled By: migeed-z

fbshipit-source-id: f282f8b53700cea7db503f9c269bdaeadc806eba

Author: oopscompiled

conformance/third_party/conformance.exp

@@ -5322,6 +5322,17 @@
       "severity": "error",
       "stop_column": 29,
       "stop_line": 68
+    },
+    {
+      "code": -2,
+      "column": 7,
+      "concise_description": "Class `BadChild` has inconsistent type arguments for base class `Grandparent`: `Grandparent[T1, T2]` and `Grandparent[T2, T1]`",
+      "description": "Class `BadChild` has inconsistent type arguments for base class `Grandparent`: `Grandparent[T1, T2]` and `Grandparent[T2, T1]`",
+      "line": 98,
+      "name": "invalid-inheritance",
+      "severity": "error",
+      "stop_column": 15,
+      "stop_line": 98
     }
   ],
   "generics_basic.py": [

conformance/third_party/conformance.result

@@ -94,9 +94,7 @@
     "Line 50: Unexpected errors ['assert_type(str, int | str) failed']",
     "Line 57: Unexpected errors ['assert_type(str, int | str) failed']"
   ],
-  "generics_base_class.py": [
-    "Line 98: Expected 1 errors"
-  ],
+  "generics_base_class.py": [],
   "generics_basic.py": [
     "Line 34: Unexpected errors ['`+` is not supported between `AnyStr` and `AnyStr`\\n  Argument `AnyStr` is not assignable to parameter `value` with type `Buffer` in function `bytes.__add__`\\n  Protocol `Buffer` requires attribute `__buffer__`', '`+` is not supported between `AnyStr` and `AnyStr`\\n  No matching overload found for function `str.__add__` called with arguments: (AnyStr)\\n  Possible overloads:\\n  (value: LiteralString, /) -> LiteralString\\n  (value: str, /) -> str [closest match]']",
     "Line 67: Unexpected errors ['assert_type(MyStr, str) failed']",

conformance/third_party/results.json

@@ -1,9 +1,9 @@
 {
   "total": 138,
-  "pass": 114,
-  "fail": 24,
+  "pass": 115,
+  "fail": 23,
   "pass_rate": 0.83,
-  "differences": 89,
+  "differences": 88,
   "passing": [
     "aliases_explicit.py",
     "aliases_newtype.py",
@@ -54,6 +54,7 @@
     "enums_member_names.py",
     "enums_member_values.py",
     "enums_members.py",
+    "generics_base_class.py",
     "generics_defaults_referential.py",
     "generics_defaults_specialization.py",
     "generics_paramspec_basic.py",
@@ -129,7 +130,6 @@
     "dataclasses_descriptors.py": 6,
     "dataclasses_slots.py": 2,
     "exceptions_context_managers.py": 2,
-    "generics_base_class.py": 1,
     "generics_basic.py": 3,
     "generics_defaults.py": 1,
     "generics_paramspec_components.py": 1,

pyrefly/lib/alt/types/class_bases.rs

@@ -350,27 +350,10 @@ impl<'a, Ans: LookupAnswer> AnswersSolver<'a, Ans> {
                         "Second argument to NewType cannot be an unbound generic".to_owned(),
                     );
                 }
-                if let Some(base_tuple_ancestor) = base_class_bases.tuple_ancestor() {
-                    if let Some(existing_tuple_ancestor) = &tuple_ancestor {
-                        if existing_tuple_ancestor.is_any_tuple() {
-                            tuple_ancestor = Some(base_tuple_ancestor.clone());
-                        } else if !base_tuple_ancestor.is_any_tuple()
-                            && base_tuple_ancestor != existing_tuple_ancestor
-                        {
-                            self.error(
-                                errors,
-                                range,
-                                ErrorInfo::Kind(ErrorKind::InvalidInheritance),
-                                format!(
-                                    "Cannot extend multiple incompatible tuples: `{}` and `{}`",
-                                    self.for_display(Type::Tuple(existing_tuple_ancestor.clone())),
-                                    self.for_display(Type::Tuple(base_tuple_ancestor.clone())),
-                                ),
-                            );
-                        }
-                    } else {
-                        tuple_ancestor = Some(base_tuple_ancestor.clone());
-                    }
+                if let Some(base_tuple_ancestor) = base_class_bases.tuple_ancestor()
+                    && tuple_ancestor.as_ref().is_none_or(|t| t.is_any_tuple())
+                {
+                    tuple_ancestor = Some(base_tuple_ancestor.clone());
                 }
                 (base_class_type, range)
             })

pyrefly/lib/alt/types/class_metadata.rs

@@ -621,6 +621,7 @@ impl Linearization {
             Err(_) => return Linearization::empty(),
         };
         let mut ancestor_chains = Vec::new();
+        let mut seen_ancestors: SmallMap<Class, ClassType> = SmallMap::new();
         for (base, mro) in bases_with_mro {
             match &*mro {
                 ClassMro::Resolved(ancestors) => {
@@ -629,6 +630,44 @@ impl Linearization {
                         .map(|ancestor| ancestor.substitute_with(&base.substitution()))
                         .rev()
                         .collect::<Vec<_>>();
+                    let mut check_conflicting_targs = |ctype: &ClassType| -> bool {
+                        if let Some(prev) = seen_ancestors.get(ctype.class_object())
+                            && (prev.targs().len() != ctype.targs().len()
+                                || prev
+                                    .targs()
+                                    .as_slice()
+                                    .iter()
+                                    .zip(ctype.targs().as_slice())
+                                    .any(|(ta, tb)| ta != tb && !ta.is_any() && !tb.is_any()))
+                        {
+                            let ctx = ClassDisplayContext::new(&[cls, ctype.class_object()]);
+                            // TODO: Extend this error message to say where in the class bases the mismatch comes from
+                            // we will need to wire additional information for this.
+                            errors.add(
+                                cls.range(),
+                                ErrorInfo::Kind(ErrorKind::InvalidInheritance),
+                                vec1![format!(
+                                    "Class `{}` has inconsistent type arguments for base class `{}`: `{}` and `{}`",
+                                    ctx.display(cls),
+                                    ctx.display(ctype.class_object()),
+                                    Type::ClassType(prev.clone()),
+                                    Type::ClassType(ctype.clone()),
+                                )],
+                            );
+                            true
+                        } else {
+                            seen_ancestors.insert(ctype.class_object().dupe(), ctype.clone());
+                            false
+                        }
+                    };
+
+                    for ancestor in ancestors_through_base.iter() {
+                        if check_conflicting_targs(ancestor) {
+                            break;
+                        }
+                    }
+                    check_conflicting_targs(base);
+
                     ancestor_chains.push(AncestorChain::from_base_and_ancestors(
                         base.clone(),
                         ancestors_through_base,

pyrefly/lib/test/generic_basic.rs

@@ -592,7 +592,6 @@ def g(t: type):
 );
 
 testcase!(
-    bug = "conformance: Should error on inconsistent type variable ordering in base classes",
     test_inconsistent_type_var_ordering_in_bases,
     r#"
 from typing import Generic, TypeVar
@@ -602,7 +601,28 @@ T2 = TypeVar("T2")
 
 class Grandparent(Generic[T1, T2]): ...
 class Parent(Grandparent[T1, T2]): ...
-class BadChild(Parent[T1, T2], Grandparent[T2, T1]): ...  # should be an error
+class BadChild(Parent[T1, T2], Grandparent[T2, T1]): ...  # E: Class `BadChild` has inconsistent type arguments for base class `Grandparent`: `Grandparent[T1, T2]` and `Grandparent[T2, T1]`
+"#,
+);
+
+testcase!(
+    test_indirect_diamond_inconsistent_targs,
+    r#"
+from typing import Generic, TypeVar
+
+T = TypeVar("T")
+T1 = TypeVar("T1")
+T2 = TypeVar("T2")
+
+class A(Generic[T]): ...
+class B(A[int]): ...
+class C(A[str]): ...
+class D(B, C): ...  # E: Class `D` has inconsistent type arguments for base class `A`: `A[int]` and `A[str]`
+
+class F(Generic[T1, T2]): ...
+class G(F[int, str]): ...
+class H(F[str, int]): ...
+class I(G, H): ...  # E: Class `I` has inconsistent type arguments for base class `F`: `F[int, str]` and `F[str, int]`
 "#,
 );
 

pyrefly/lib/test/tuple.rs

@@ -88,8 +88,8 @@ class Base4(tuple[str, int]): ...
 
 class Child1(Base1, Base2): ...
 class Child2(Base1, Base3): ...
-class Child3(Base3, Base4): ...  # E: Cannot extend multiple incompatible tuples
-class Child4(Base2, Base3): ...  # E: Cannot extend multiple incompatible tuples
+class Child3(Base3, Base4): ...  # E: Class `Child3` has inconsistent type arguments for base class `Container`
+class Child4(Base2, Base3): ...
 "#,
 );