add staticmethod

Author: med1844

crates/ty_python_semantic/resources/mdtest/call/methods.md

@@ -397,6 +397,33 @@ The `owner` argument takes precedence over the `instance` argument:
 reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: bound method <class 'C'>.f() -> Unknown
 ```
 
+### Accessing the staticmethod as a static member
+
+```py
+from inspect import getattr_static
+
+class C:
+    @staticmethod
+    def f(): ...
+```
+
+Accessing the staticmethod as a static member. This will reveal the raw function, as staticmethod is
+transparent when accessed via `getattr_static`.
+
+```py
+reveal_type(getattr_static(C, "f"))  # revealed: def f() -> Unknown
+```
+
+The `__get__` of a `staticmethod` object simply returns the underlying function. It ignores both the
+instance and owner arguments.
+
+```py
+reveal_type(getattr_static(C, "f").__get__(None, C))  # revealed: def f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__(C(), C))  # revealed: def f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__(C()))  # revealed: def f() -> Unknown
+reveal_type(getattr_static(C, "f").__get__("dummy", C))  # revealed: def f() -> Unknown
+```
+
 ### Classmethods mixed with other decorators
 
 ```toml

crates/ty_python_semantic/resources/mdtest/descriptor_protocol.md

@@ -549,6 +549,19 @@ reveal_type(C.get_name())  # revealed: str
 reveal_type(C("42").get_name())  # revealed: str
 ```
 
+### Built-in `staticmethod` descriptor
+
+```py
+class C:
+    @staticmethod
+    def helper(value: str) -> str:
+        return value
+
+reveal_type(C.helper("42"))  # revealed: str
+c = C()
+reveal_type(c.helper("string"))  # revealed: str
+```
+
 ### Functions as descriptors
 
 Functions are descriptors because they implement a `__get__` method. This is crucial in making sure

crates/ty_python_semantic/resources/mdtest/overloads.md

@@ -449,30 +449,32 @@ from __future__ import annotations
 from typing import overload
 
 class CheckStaticMethod:
-    # TODO: error because `@staticmethod` does not exist on all overloads
     @overload
     def method1(x: int) -> int: ...
     @overload
     def method1(x: str) -> str: ...
     @staticmethod
+    # error: [invalid-overload] "Overloaded function `method1` does not use the `@staticmethod` decorator consistently"
     def method1(x: int | str) -> int | str:
         return x
-    # TODO: error because `@staticmethod` does not exist on all overloads
+
     @overload
     def method2(x: int) -> int: ...
     @overload
     @staticmethod
     def method2(x: str) -> str: ...
     @staticmethod
+    # error: [invalid-overload]
     def method2(x: int | str) -> int | str:
         return x
-    # TODO: error because `@staticmethod` does not exist on the implementation
+
     @overload
     @staticmethod
     def method3(x: int) -> int: ...
     @overload
     @staticmethod
     def method3(x: str) -> str: ...
+    # error: [invalid-overload]
     def method3(x: int | str) -> int | str:
         return x
 

crates/ty_python_semantic/src/types/call/bind.rs

@@ -279,6 +279,9 @@ impl<'db> Bindings<'db> {
                                 }
                                 _ => {}
                             }
+                        } else if function.has_known_decorator(db, FunctionDecorators::STATICMETHOD)
+                        {
+                            overload.set_return_type(Type::FunctionLiteral(function));
                         } else if let [Some(first), _] = overload.parameter_types() {
                             if first.is_none(db) {
                                 overload.set_return_type(Type::FunctionLiteral(function));
@@ -314,6 +317,10 @@ impl<'db> Bindings<'db> {
 
                                     _ => {}
                                 }
+                            } else if function
+                                .has_known_decorator(db, FunctionDecorators::STATICMETHOD)
+                            {
+                                overload.set_return_type(*function_ty);
                             } else {
                                 match overload.parameter_types() {
                                     [_, Some(instance), _] if instance.is_none(db) => {

crates/ty_python_semantic/src/types/infer.rs

@@ -1223,8 +1223,10 @@ impl<'db, 'ast> TypeInferenceBuilder<'db, 'ast> {
                 }
             }
 
-            // TODO: Add `@staticmethod`
-            for (decorator, name) in [(FunctionDecorators::CLASSMETHOD, "classmethod")] {
+            for (decorator, name) in [
+                (FunctionDecorators::CLASSMETHOD, "classmethod"),
+                (FunctionDecorators::STATICMETHOD, "staticmethod"),
+            ] {
                 let mut decorator_present = false;
                 let mut decorator_missing = vec![];