moar tests

Author: AlexWaygood

crates/ty_python_semantic/resources/mdtest/liskov.md

@@ -455,7 +455,17 @@ class Bad:
         return self.x == other.x
 ```
 
-## Bad override of a synthesized method
+## Synthesized methods
+
+`NamedTuple` classes and dataclasses both have methods generated at runtime that do not have
+source-code definitions. There are several scenarios to consider here:
+
+1. A synthesized method on a superclass is overridden by a "normal" (not synthesized) method on a
+    subclass
+1. A "normal" method on a superclass is overridden by a synthesized method on a subclass
+1. A synthesized method on a superclass is overridden by a synthesized method on a subclass
+1. No methods are overridden, but the Liskov Substitution Principle is arguably violated anyway
+    because a generated method on a superclass is incompatible with subclassing(!)
 
 <!-- snapshot-diagnostics -->
 
@@ -470,6 +480,36 @@ class Foo:
 class Bar(Foo):
     def __lt__(self, other: Bar) -> bool: ...  # error: [invalid-method-override]
 
+# TODO: specifying `order=True` on the subclass means that a `__lt__` method is
+# generated that is incompatible with the generated `__lt__` method on the superclass.
+# We could consider detecting this and emitting a diagnostic, though maybe it shouldn't
+# be `invalid-method-override` since we'd emit it on the class definition rather than
+# on any method definition. Note also that no other type checker complains about this
+# as of 2025-11-21.
+@dataclass(order=True)
+class Bar2(Foo):
+    y: str
+
+# TODO: Although this class does not override any methods of `Foo`, it nonetheless
+# arguably violates the Liskov Substitution Principle. Instances of `Bar3` cannot be
+# substituted wherever an instance of `Foo` is expected, because the generated
+# `__lt__` method on `Foo` raises an error unless the r.h.s. and `l.h.s.` have exactly
+# the same `__class__` (it does not permit instances of `Foo` to be compared with
+# instances of subclasses of `Foo`). We could therefore consider treating all
+# `order=True` dataclasses as implicitly `@final` in order to enforce Liskov soundness.
+# Note that no other type checker catches this error as of 2025-11-21.
+class Bar3(Foo): ...
+
+class Eggs:
+    def __lt__(self, other: Eggs) -> bool: ...
+
+# TODO: the generated `Ham.__lt__` method here incompatibly overrides `Eggs.__lt__`.
+# We could consider emitting a diagnostic here. As of 2025-11-21, mypy reports a
+# diagnostic here but pyright and pyrefly do not.
+@dataclass(order=True)
+class Ham(Eggs):
+    x: int
+
 class Baz(NamedTuple):
     x: int
 

crates/ty_python_semantic/resources/mdtest/snapshots/liskov.md_-_The_Liskov_Substitut…_-_Bad_override_of_a_sy…_(b723f1988e2e7bf2).snap

@@ -0,0 +1,107 @@
+---
+source: crates/ty_test/src/lib.rs
+expression: snapshot
+---
+---
+mdtest name: liskov.md - The Liskov Substitution Principle - Synthesized methods
+mdtest path: crates/ty_python_semantic/resources/mdtest/liskov.md
+---
+
+# Python source files
+
+## mdtest_snippet.pyi
+
+```
+ 1 | from dataclasses import dataclass
+ 2 | from typing import NamedTuple
+ 3 | 
+ 4 | @dataclass(order=True)
+ 5 | class Foo:
+ 6 |     x: int
+ 7 | 
+ 8 | class Bar(Foo):
+ 9 |     def __lt__(self, other: Bar) -> bool: ...  # error: [invalid-method-override]
+10 | 
+11 | # TODO: specifying `order=True` on the subclass means that a `__lt__` method is
+12 | # generated that is incompatible with the generated `__lt__` method on the superclass.
+13 | # We could consider detecting this and emitting a diagnostic, though maybe it shouldn't
+14 | # be `invalid-method-override` since we'd emit it on the class definition rather than
+15 | # on any method definition. Note also that no other type checker complains about this
+16 | # as of 2025-11-21.
+17 | @dataclass(order=True)
+18 | class Bar2(Foo):
+19 |     y: str
+20 | 
+21 | # TODO: Although this class does not override any methods of `Foo`, it nonetheless
+22 | # arguably violates the Liskov Substitution Principle. Instances of `Bar3` cannot be
+23 | # substituted wherever an instance of `Foo` is expected, because the generated
+24 | # `__lt__` method on `Foo` raises an error unless the r.h.s. and `l.h.s.` have exactly
+25 | # the same `__class__` (it does not permit instances of `Foo` to be compared with
+26 | # instances of subclasses of `Foo`). We could therefore consider treating all
+27 | # `order=True` dataclasses as implicitly `@final` in order to enforce Liskov soundness.
+28 | # Note that no other type checker catches this error as of 2025-11-21.
+29 | class Bar3(Foo): ...
+30 | 
+31 | class Eggs:
+32 |     def __lt__(self, other: Eggs) -> bool: ...
+33 | 
+34 | # TODO: the generated `Ham.__lt__` method here incompatibly overrides `Eggs.__lt__`.
+35 | # We could consider emitting a diagnostic here. As of 2025-11-21, mypy reports a
+36 | # diagnostic here but pyright and pyrefly do not.
+37 | @dataclass(order=True)
+38 | class Ham(Eggs):
+39 |     x: int
+40 | 
+41 | class Baz(NamedTuple):
+42 |     x: int
+43 | 
+44 | class Spam(Baz):
+45 |     def _asdict(self) -> tuple[int, ...]: ...  # error: [invalid-method-override]
+```
+
+# Diagnostics
+
+```
+error[invalid-method-override]: Invalid override of method `__lt__`
+  --> src/mdtest_snippet.pyi:9:9
+   |
+ 8 | class Bar(Foo):
+ 9 |     def __lt__(self, other: Bar) -> bool: ...  # error: [invalid-method-override]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Definition is incompatible with `Foo.__lt__`
+10 |
+11 | # TODO: specifying `order=True` on the subclass means that a `__lt__` method is
+   |
+info: This violates the Liskov Substitution Principle
+info: `Foo.__lt__` is a generated method created because `Foo` is a dataclass
+ --> src/mdtest_snippet.pyi:5:7
+  |
+4 | @dataclass(order=True)
+5 | class Foo:
+  |       ^^^ Definition of `Foo`
+6 |     x: int
+  |
+info: rule `invalid-method-override` is enabled by default
+
+```
+
+```
+error[invalid-method-override]: Invalid override of method `_asdict`
+  --> src/mdtest_snippet.pyi:45:9
+   |
+44 | class Spam(Baz):
+45 |     def _asdict(self) -> tuple[int, ...]: ...  # error: [invalid-method-override]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Definition is incompatible with `Baz._asdict`
+   |
+info: This violates the Liskov Substitution Principle
+info: `Baz._asdict` is a generated method created because `Baz` inherits from `typing.NamedTuple`
+  --> src/mdtest_snippet.pyi:41:7
+   |
+39 |     x: int
+40 |
+41 | class Baz(NamedTuple):
+   |       ^^^^^^^^^^^^^^^ Definition of `Baz`
+42 |     x: int
+   |
+info: rule `invalid-method-override` is enabled by default
+
+```