[ty] Infer type of implicit self in properties

Author: sharkdp

crates/ruff_benchmark/benches/ty_walltime.rs

@@ -226,7 +226,7 @@ static STATIC_FRAME: Benchmark = Benchmark::new(
         max_dep_date: "2025-08-09",
         python_version: PythonVersion::PY311,
     },
-    750,
+    800,
 );
 
 #[track_caller]

crates/ty_ide/src/semantic_tokens.rs

@@ -1413,7 +1413,7 @@ u = List.__name__        # __name__ should be variable<CURSOR>
         "property" @ 168..176: Decorator
         "prop" @ 185..189: Method [definition]
         "self" @ 190..194: SelfParameter
-        "self" @ 212..216: Variable
+        "self" @ 212..216: TypeParameter
         "CONSTANT" @ 217..225: Variable [readonly]
         "obj" @ 227..230: Variable
         "MyClass" @ 233..240: Class

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

@@ -116,7 +116,7 @@ A.implicit_self(1)
 Passing `self` implicitly also verifies the type:
 
 ```py
-from typing import Never
+from typing import Never, Callable
 
 class Strange:
     def can_not_be_called(self: Never) -> None: ...
@@ -139,6 +139,9 @@ The first parameter of instance methods always has type `Self`, if it is not exp
 The name `self` is not special in any way.
 
 ```py
+def some_decorator(f: Callable) -> Callable:
+    return f
+
 class B:
     def name_does_not_matter(this) -> Self:
         reveal_type(this)  # revealed: Self@name_does_not_matter
@@ -153,18 +156,47 @@ class B:
         reveal_type(self)  # revealed: Self@keyword_only
         return self
 
+    @some_decorator
+    def decorated_method(self) -> Self:
+        reveal_type(self)  # revealed: Self@decorated_method
+        return self
+
     @property
     def a_property(self) -> Self:
-        # TODO: Should reveal Self@a_property
-        reveal_type(self)  # revealed: Unknown
+        reveal_type(self)  # revealed: Self@a_property
         return self
 
+    async def async_method(self) -> Self:
+        reveal_type(self)  # revealed: Self@async_method
+        return self
+
+    @staticmethod
+    def static_method(self):
+        # The parameter can be called `self`, but it is not treated as `Self`
+        reveal_type(self)  # revealed: Unknown
+
+    @staticmethod
+    @some_decorator
+    def decorated_static_method(self):
+        # TODO: this should be Unknown
+        reveal_type(self)  # revealed: Self@decorated_static_method
+
+    @some_decorator
+    @staticmethod
+    def decorated_static_method_2(self):
+        # TODO: this should be Unknown
+        reveal_type(self)  # revealed: Self@decorated_static_method_2
+
 reveal_type(B().name_does_not_matter())  # revealed: B
 reveal_type(B().positional_only(1))  # revealed: B
 reveal_type(B().keyword_only(x=1))  # revealed: B
+reveal_type(B().decorated_method())  # revealed: Unknown
 
 # TODO: this should be B
 reveal_type(B().a_property)  # revealed: Unknown
+
+async def _():
+    reveal_type(await B().async_method())  # revealed: B
 ```
 
 This also works for generic classes:

crates/ty_python_semantic/src/types/infer/builder.rs

@@ -2583,12 +2583,12 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
         let method = infer_definition_types(db, method_definition)
             .declaration_type(method_definition)
             .inner_type()
-            .as_function_literal()?;
+            .as_function_literal();
 
-        if method.is_classmethod(db) {
+        if method.is_some_and(|m| m.is_classmethod(db)) {
             // TODO: set the type for `cls` argument
             return None;
-        } else if method.is_staticmethod(db) {
+        } else if method.is_some_and(|m| m.is_staticmethod(db)) {
             return None;
         }