[ty] Support @classmethod and @staticmethod protocol members

crates/ruff_benchmark/benches/ty.rs

@@ -1534,7 +1534,7 @@ fn hydra(criterion: &mut Criterion) {
             max_dep_date: TY_ECOSYSTEM_PIN,
             python_version: SupportedPythonVersion::Py311,
         },
-        510,
+        520,
     );
 
     bench_project(&benchmark, criterion);

crates/ty_python_semantic/resources/lint_docs/final-without-value.md

@@ -8,6 +8,7 @@ assigned a value in their scope.
 A `Final` symbol must be initialized with a value at the time of declaration
 or in a subsequent assignment. At module or function scope, the assignment must
 occur in the same scope. In a class body, the assignment may occur in `__init__`.
+Protocol members are declarations of an interface and do not require a value.
 
 ## Examples
 

crates/ty_python_semantic/resources/lint_docs/redundant-final-classvar.md

@@ -7,8 +7,8 @@ Checks for redundant combinations of the `ClassVar` and `Final` type qualifiers.
 An attribute that is marked `Final` in a class body is implicitly a class variable.
 Marking it as `ClassVar` is therefore redundant.
 
-Note that this diagnostic is not emitted for dataclass fields, where
-`ClassVar[Final[int]]` has a distinct meaning from `Final[int]`.
+Note that this diagnostic is not emitted for dataclass fields or protocol members,
+where `ClassVar[Final[int]]` has a distinct meaning from `Final[int]`.
 
 ## Examples
 

crates/ty_python_semantic/resources/mdtest/annotations/callable.md

@@ -488,8 +488,6 @@ If users want to read/write to attributes such as `__qualname__`, they need to c
 of the attribute first:
 
 ```py
-from inspect import getattr_static
-
 def f_okay(c: Callable[[], None]):
     if hasattr(c, "__qualname__"):
         reveal_type(c.__qualname__)  # revealed: object
@@ -503,10 +501,14 @@ def f_okay(c: Callable[[], None]):
         # error: [invalid-assignment] "Object of type `Literal["my_callable"]` is not assignable to attribute `__qualname__` on type `(() -> None) & <Protocol with members '__qualname__'>`"
         c.__qualname__ = "my_callable"
 
-        result = getattr_static(c, "__qualname__")
-        reveal_type(result)  # revealed: property
-        if isinstance(result, property) and result.fset:
-            c.__qualname__ = "my_callable"  # okay
+        # TODO: should we have some way for users to narrow a read-only attribute
+        # into a writable attribute...? What would that look like? Something like this?
+        if (
+            hasattr(type(c), "__qualname__")
+            and isinstance(type(c).__qualname__, property)
+            and type(c).__qualname__.fset is not None
+        ):
+            c.__qualname__ = "my_callable"  # error: [invalid-assignment]
 ```
 
 ## From a class

crates/ty_python_semantic/resources/mdtest/dataclasses/dataclass_transform.md

@@ -1945,6 +1945,23 @@ def _(obj: BasicAlias):
     obj.a = 3  # error: [invalid-assignment]
 ```
 
+A converted field satisfies a writable property protocol using the converter input type as its write
+type:
+
+```py
+from typing import Protocol
+from ty_extensions import is_assignable_to, is_subtype_of, static_assert
+
+class HasConvertedField(Protocol):
+    @property
+    def a(self) -> int: ...
+    @a.setter
+    def a(self, value: str) -> None: ...
+
+static_assert(is_subtype_of(Basic, HasConvertedField))
+static_assert(is_assignable_to(Basic, HasConvertedField))
+```
+
 The default parameter for a converter field should also be verified against the converter's input
 type:
 

crates/ty_python_semantic/resources/mdtest/dataclasses/dataclasses.md

@@ -1781,6 +1781,7 @@ class Foo:
 foo = Foo(1)
 
 reveal_type(foo.__dataclass_fields__)  # revealed: dict[str, Field[Any]]
+reveal_type(type(foo).__dataclass_fields__)  # revealed: dict[str, Field[Any]]
 reveal_type(fields(Foo))  # revealed: tuple[Field[Any], ...]
 reveal_type(asdict(foo))  # revealed: dict[str, Any]
 ```
@@ -1801,8 +1802,7 @@ reveal_type(fields(Foo))  # revealed: tuple[Field[Any], ...]
 But calling `asdict` on the class object is not allowed:
 
 ```py
-# TODO: this should be a invalid-argument-type error, but we don't properly check the
-# types (and more importantly, the `ClassVar` type qualifier) of protocol members yet.
+# error: [invalid-argument-type] "Argument to function `asdict` is incorrect: Expected `DataclassInstance`, found `<class 'Foo'>`"
 asdict(Foo)
 ```