[ty] Check inherited attribute conflicts (astral-sh#28559)

## Summary

We now report incompatible attributes inherited from different bases,
even when the subclass does not override them:

```python
class Integer:
    value: int

class String:
    value: str

class Combined(Integer, String): ...  # invalid-attribute-override
```

We check the member selected by the MRO against the base declarations,
including properties and annotations on `self`. Conflicts already
present in a parent are not reported again.

Part of astral-sh/ty#2158.

Author: charliermarsh

crates/ty_python_semantic/resources/mdtest/abstract.md

@@ -414,8 +414,7 @@ Concrete()  # no diagnostic
 
 ## Slots and abstract properties in the MRO
 
-A slot inherited from a mixin overrides an abstract property only if the mixin comes before the
-property's defining class in the MRO.
+A slot inherited from a mixin overrides an abstract property when the mixin comes first in the MRO.
 
 ```py
 from abc import ABC, abstractmethod
@@ -429,9 +428,16 @@ class SlotMixin:
     __slots__ = ("value",)
 
 class Concrete(SlotMixin, Abstract): ...
-class StillAbstract(Abstract, SlotMixin): ...
 
 Concrete()  # no diagnostic
+```
+
+With the bases reversed, the class remains abstract. The getter-only property also removes writes
+permitted by the mixin's slot, so the class definition receives an override error.
+
+```py
+class StillAbstract(Abstract, SlotMixin): ...  # error: [invalid-property-type-override]
+
 StillAbstract()  # error: [call-non-callable]
 ```
 

crates/ty_python_semantic/resources/mdtest/attributes.md

@@ -2115,11 +2115,9 @@ The attribute stored by the metaclass also shadows a descriptor inherited from a
 that non-data class attribute and an instance assignment remain possible:
 
 ```py
-from typing import Literal
-
 class InheritedGeneratedProperty:
     @property
-    def generated(self) -> Literal["property"]:
+    def generated(self) -> object:
         return "property"
 
 class StringStoringMeta(type):
@@ -2144,6 +2142,8 @@ If the metaclass instead stores a data descriptor on the new class, the descript
 over an instance assignment:
 
 ```py
+from typing import Literal
+
 class GeneratedDescriptor:
     def __get__(self, instance: object, owner: type | None = None) -> Literal["descriptor"]:
         return "descriptor"

crates/ty_python_semantic/resources/mdtest/cycle/implicit_instance_attributes.md

@@ -662,3 +662,39 @@ class ChildContext(Context):
             # TODO: Report an invalid-assignment error for assigning `ChildContext` to `int`.
             cls.current = ChildContext()
 ```
+
+## Lazy initialization in a class property
+
+The metaclass initializes `_name` to `None`. Reading the class property can therefore enter the
+branch that fills the cache, including on a class with multiple bases.
+
+```toml
+[rules]
+redundant-condition-strict = "error"
+```
+
+```py
+def module_name(module: str) -> str:
+    return module
+
+class ClassProperty:
+    def __init__(self, getter):
+        self.getter = getter
+
+    def __get__(self, instance, owner):
+        return self.getter(owner)
+
+class Meta(type):
+    def __new__(cls, name, bases, namespace):
+        namespace["_name"] = None
+        return super(Meta, cls).__new__(cls, name, bases, namespace)
+
+class Left: ...
+class Right: ...
+
+class Package(Left, Right, metaclass=Meta):
+    @ClassProperty
+    def name(cls):
+        if cls._name is None:  # no diagnostic
+            cls._name = module_name(cls.__module__)
+```

crates/ty_python_semantic/resources/mdtest/generics/legacy/classes.md

@@ -4185,5 +4185,39 @@ def narrow_intersection_bounded(value: Intersection[Parent[BoundedS], Other[Boun
         reveal_type(value)  # revealed: ChildBoth[BoundedS@narrow_intersection_bounded]
 ```
 
+## Inheriting different specializations of a property
+
+`String` can return `str` for the property inherited from `Base[Any]`. Combining it with `Integer`
+also requires the property to return `int`, so the new subclass is invalid.
+
+```py
+from typing import Any, Generic, TypeVar
+
+T = TypeVar("T")
+
+class Base(Generic[T]):
+    @property
+    def value(self) -> T:
+        raise NotImplementedError
+
+class String(Base[Any]):  # no diagnostic
+    @property
+    def value(self) -> str:
+        return ""
+
+class Integer(Base[int]): ...
+class Conflict(String, Integer): ...  # error: [invalid-property-type-override]
+```
+
+An explicit override is also checked against `Base[int]`, and the error is reported only at the
+override.
+
+```py
+class Explicit(String, Integer):
+    @property
+    def value(self) -> str:  # error: [invalid-property-type-override]
+        return ""
+```
+
 [crtp]: https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
 [f-bound]: https://en.wikipedia.org/wiki/Bounded_quantification#F-bounded_quantification

crates/ty_python_semantic/resources/mdtest/generics/legacy/functions.md

@@ -1731,10 +1731,10 @@ from typing import TypeVar, Generic
 T = TypeVar("T")
 
 class P(Generic[T]):
-    x: T
+    p: T
 
 class Q(Generic[T]):
-    x: T
+    q: T
 
 def extract_t(x: P[T] | Q[T]) -> T:
     raise NotImplementedError

crates/ty_python_semantic/resources/mdtest/generics/pep695/classes.md

@@ -3226,5 +3226,37 @@ def narrow_intersection_bounded[S: str](value: Intersection[Parent[S], Other[S]]
         reveal_type(value)  # revealed: ChildBoth[S@narrow_intersection_bounded]
 ```
 
+## Inheriting different specializations of a property
+
+`String` can return `str` for the property inherited from `Base[Any]`. Combining it with `Integer`
+also requires the property to return `int`, so the new subclass is invalid.
+
+```py
+from typing import Any
+
+class Base[T]:
+    @property
+    def value(self) -> T:
+        raise NotImplementedError
+
+class String(Base[Any]):  # no diagnostic
+    @property
+    def value(self) -> str:
+        return ""
+
+class Integer(Base[int]): ...
+class Conflict(String, Integer): ...  # error: [invalid-property-type-override]
+```
+
+An explicit override is also checked against `Base[int]`, and the error is reported only at the
+override.
+
+```py
+class Explicit(String, Integer):
+    @property
+    def value(self) -> str:  # error: [invalid-property-type-override]
+        return ""
+```
+
 [crtp]: https://en.wikipedia.org/wiki/Curiously_recurring_template_pattern
 [f-bound]: https://en.wikipedia.org/wiki/Bounded_quantification#F-bounded_quantification

crates/ty_python_semantic/resources/mdtest/generics/pep695/functions.md

@@ -2893,10 +2893,10 @@ the actual argument even for non-final classes.
 
 ```py
 class P[T]:
-    x: T  # invariant
+    p: T  # invariant
 
 class Q[T]:
-    x: T  # invariant
+    q: T  # invariant
 
 def extract_t[T](x: P[T] | Q[T]) -> T:
     raise NotImplementedError