Method 2: alter in signatures method

Author: Glyphack

crates/ty_python_semantic/src/types.rs

@@ -3456,7 +3456,14 @@ impl<'db> Type<'db> {
                 let signature = bound_method.function(db).signature(db);
                 Signatures::single(match signature {
                     FunctionSignature::Single(signature) => {
-                        CallableSignature::single(self, signature.clone())
+                        let mut params = signature.parameters().clone();
+                        params = params.set_first_type(
+                            Self::KnownInstance(KnownInstanceType::TypingSelf)
+                                .in_type_expression(db, bound_method.function(db).body_scope(db))
+                                .unwrap(),
+                        );
+                        let new_sig = Signature::new(params, signature.return_ty.clone());
+                        CallableSignature::single(self, new_sig)
                             .with_bound_type(bound_method.self_instance(db))
                     }
                     FunctionSignature::Overloaded(signatures, _) => {

crates/ty_python_semantic/src/types/signatures.rs

@@ -935,6 +935,24 @@ impl<'db> Parameters<'db> {
         }
     }
 
+    pub(crate) fn set_first_type(&mut self, ty: Type<'db>) -> Self {
+        Self {
+            value: self
+                .value
+                .iter()
+                .enumerate()
+                .map(|(i, param)| {
+                    if i == 0 {
+                        param.clone().with_annotated_type(ty)
+                    } else {
+                        param.clone()
+                    }
+                })
+                .collect(),
+            is_gradual: self.is_gradual,
+        }
+    }
+
     pub(crate) fn as_slice(&self) -> &[Parameter<'db>] {
         self.value.as_slice()
     }
@@ -1032,32 +1050,16 @@ impl<'db> Parameters<'db> {
                 },
             )
         });
-        let positional_or_keyword = args.iter().enumerate().map(|(index, arg)| {
-            // TODO: Check for classmethod decorator
-            if index == 0 && arg.name() == "self" {
-                Parameter {
-                    annotated_type: Some(
-                        Type::KnownInstance(KnownInstanceType::TypingSelf)
-                            .in_type_expression(db, definition.scope(db))
-                            .unwrap(),
-                    ),
-                    kind: ParameterKind::PositionalOrKeyword {
-                        name: arg.parameter.name.id.clone(),
-                        default_type: default_type(arg),
-                    },
-                    form: ParameterForm::Value,
-                }
-            } else {
-                Parameter::from_node_and_kind(
-                    db,
-                    definition,
-                    &arg.parameter,
-                    ParameterKind::PositionalOrKeyword {
-                        name: arg.parameter.name.id.clone(),
-                        default_type: default_type(arg),
-                    },
-                )
-            }
+        let positional_or_keyword = args.iter().enumerate().map(|(_, arg)| {
+            Parameter::from_node_and_kind(
+                db,
+                definition,
+                &arg.parameter,
+                ParameterKind::PositionalOrKeyword {
+                    name: arg.parameter.name.id.clone(),
+                    default_type: default_type(arg),
+                },
+            )
         });
         let variadic = vararg.as_ref().map(|arg| {
             Parameter::from_node_and_kind(