Let total_ordering see comparison methods generated on ancestors

Summary:
`functools.total_ordering` only fills in ordering methods that a class doesn't already have, whether they're defined directly or inherited. Pyrefly decided what was missing using a lookup that skips every synthesized member in the MRO, so it couldn't see ordering methods generated on an ancestor dataclass. For a subclass of `dataclass(order=True)`, that caused two problems:
- `total_ordering class B(D): pass` reported a false "must define at least one of the rich comparison methods" error.
- With a hand-written `__lt__`, pyrefly made up `__gt__`/`__le__`/`__ge__` on the subclass from it. At runtime the subclass keeps `D`'s methods.

The same blind spot applied to methods that `total_ordering` filled in on an ancestor. The lookup only needs to skip members synthesized on the class itself, because those are what's being computed. Members synthesized on ancestors are already settled, so a new lookup ignores only the class's own synthesized fields, and `total_ordering` uses it.

___

landed-with-radar-review

Differential Revision: D126992833

fbshipit-source-id: ccc366ab1e9c0399165e02fe3ed6996eacf33324

Author: connernilsen

pyrefly/lib/alt/class/class_field.rs

@@ -4944,6 +4944,23 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
         })
     }
 
+    /// Look up a member while ignoring fields synthesized on `cls` itself, but not those
+    /// synthesized on its ancestors. Use this while computing `cls`'s own synthesized fields.
+    pub fn get_class_member_ignoring_own_synthesized(
+        &self,
+        cls: &Class,
+        name: &Name,
+    ) -> Option<WithDefiningClass<Cow<'_, ClassField>>> {
+        self.get_field_from_mro(cls, name, &|c, name| {
+            if c == cls {
+                self.get_non_synthesized_field_from_current_class_only(c, name)
+            } else {
+                self.get_field_from_current_class_only(c, name)
+            }
+        })
+        .filter(|field| !field.value.is_init_var())
+    }
+
     pub(crate) fn get_synthesized_field_from_current_class_only(
         &self,
         cls: &Class,

pyrefly/lib/alt/class/total_ordering.rs

@@ -40,7 +40,7 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
         // The first field in the conversion order is the one that we will use to synthesize the method.
         for other_cmp in conversion_order {
             if let Some(other_cmp_field) = self
-                .get_non_synthesized_class_member_and_defining_class(cls, other_cmp)
+                .get_class_member_ignoring_own_synthesized(cls, other_cmp)
                 .filter(|field| !field.defining_class.is_builtin("object"))
             {
                 let ty = other_cmp_field.value.as_named_tuple_type();
@@ -61,7 +61,7 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
         }
         // The class must have one of the rich comparison dunder methods defined
         if !dunder::RICH_CMPS_TOTAL_ORDERING.iter().any(|cmp| {
-            self.get_non_synthesized_class_member_and_defining_class(cls, cmp)
+            self.get_class_member_ignoring_own_synthesized(cls, cmp)
                 .is_some_and(|field| !field.defining_class.is_builtin("object"))
         }) {
             let total_ordering_metadata = metadata.total_ordering_metadata().unwrap();
@@ -79,7 +79,7 @@ impl<'ctx, 'answer, Ans: LookupAnswer> AnswersSolver<'ctx, 'answer, Ans> {
         let rich_cmps_to_synthesize: Vec<_> = dunder::RICH_CMPS_TOTAL_ORDERING
             .iter()
             .filter(|cmp| {
-                self.get_non_synthesized_class_member_and_defining_class(cls, cmp)
+                self.get_class_member_ignoring_own_synthesized(cls, cmp)
                     .is_none_or(|field| field.defining_class.is_builtin("object"))
             })
             .collect();

pyrefly/lib/test/decorators.rs

@@ -567,6 +567,54 @@ class A:
 "#,
 );
 
+// `total_ordering` only fills in methods the class doesn't already have, including methods
+// generated on an ancestor dataclass.
+testcase!(
+    test_total_ordering_on_ordered_dataclass_subclass,
+    r#"
+from dataclasses import dataclass
+from functools import total_ordering
+from typing import reveal_type
+
+@dataclass(order=True)
+class D:
+    x: int
+
+@total_ordering
+class NoOwnMethods(D):  # E: Cannot safely extend dataclass `D` with `order=True`
+    pass
+
+# `OwnLt` keeps `D`'s generated `__gt__`, so `OwnLt(1) > D(1)` fails.
+@total_ordering
+class OwnLt(D):  # E: Cannot safely extend dataclass `D` with `order=True`
+    def __lt__(self, other: object) -> bool:
+        return True
+
+reveal_type(OwnLt.__gt__)  # E: revealed type: (self: OwnLt, other: OwnLt) -> bool
+"#,
+);
+
+// Methods that `total_ordering` filled in on an ancestor count as defined, so `B` gets nothing new.
+testcase!(
+    test_total_ordering_on_total_ordering_subclass,
+    r#"
+from functools import total_ordering
+from typing import reveal_type
+
+@total_ordering
+class A:
+    def __lt__(self, other: "A") -> bool:
+        return True
+
+@total_ordering
+class B(A):
+    def __gt__(self, other: object) -> bool:
+        return True
+
+reveal_type(B.__ge__)  # E: revealed type: (self: B, other: A) -> bool
+"#,
+);
+
 testcase!(
     test_total_ordering_inherited_rich_cmp,
     r#"