Suggest missing 'self' when a method is called with too many positional argumen

Author: SurenNihalani

Lib/test/test_call.py

@@ -910,6 +910,12 @@ def static_no_args():
     def positional_only(arg, /):
         pass
 
+    def missing_self(another_arg):
+        pass
+
+    def missing_self_no_args():
+        pass
+
 @cpython_only
 class TestErrorMessagesUseQualifiedName(unittest.TestCase):
 
@@ -919,6 +925,16 @@ def check_raises_type_error(self, message):
             yield
         self.assertEqual(str(cm.exception), message)
 
+    def test_too_many_positional_but_missing_self(self):
+        msg = "A.missing_self() takes 1 positional argument but 2 were given. Did you forget to declare 'self' as the first parameter?"
+        with self.check_raises_type_error(msg):
+            A().missing_self("another_arg")
+
+    def test_too_many_positional_but_missing_self_no_args(self):
+        msg = "A.missing_self_no_args() takes 0 positional arguments but 1 was given. Did you forget to declare 'self' as the first parameter?"
+        with self.check_raises_type_error(msg):
+            A().missing_self_no_args()
+
     def test_missing_arguments(self):
         msg = "A.method_two_args() missing 1 required positional argument: 'y'"
         with self.check_raises_type_error(msg):

Python/ceval.c

@@ -1574,12 +1574,13 @@ missing_arguments(PyThreadState *tstate, PyCodeObject *co,
 static void
 too_many_positional(PyThreadState *tstate, PyCodeObject *co,
                     Py_ssize_t given, PyObject *defaults,
-                    _PyStackRef *localsplus, PyObject *qualname)
+                    _PyStackRef *localsplus, PyObject *qualname,
+                    int suggest_missing_self)
 {
     int plural;
     Py_ssize_t kwonly_given = 0;
     Py_ssize_t i;
-    PyObject *sig, *kwonly_sig;
+    PyObject *sig, *kwonly_sig, *self_hint = Py_GetConstant(Py_CONSTANT_EMPTY_STR);
     Py_ssize_t co_argcount = co->co_argcount;
 
     assert((co->co_flags & CO_VARARGS) == 0);
@@ -1617,18 +1618,71 @@ too_many_positional(PyThreadState *tstate, PyCodeObject *co,
         kwonly_sig = Py_GetConstant(Py_CONSTANT_EMPTY_STR);
         assert(kwonly_sig != NULL);
     }
+    if (suggest_missing_self) {
+        self_hint = PyUnicode_FromString(
+            ". Did you forget to declare 'self' as the first parameter?");
+        if (self_hint == NULL) {
+            Py_DECREF(sig);
+            Py_DECREF(kwonly_sig);
+            return;
+        }
+    }
     _PyErr_Format(tstate, PyExc_TypeError,
-                  "%U() takes %U positional argument%s but %zd%U %s given",
+                  "%U() takes %U positional argument%s but %zd%U %s given%U",
                   qualname,
                   sig,
                   plural ? "s" : "",
                   given,
                   kwonly_sig,
-                  given == 1 && !kwonly_given ? "was" : "were");
+                  given == 1 && !kwonly_given ? "was" : "were",
+                  self_hint
+                );
+    Py_DECREF(self_hint);
     Py_DECREF(sig);
     Py_DECREF(kwonly_sig);
 }
 
+static int
+suggest_missing_self(PyFunctionObject *func, PyCodeObject *co,
+                     _PyStackRef const *args, Py_ssize_t argcount)
+{
+    if (co->co_argcount >= argcount) {
+        // When declared count is more than provided, there is nothing to add
+        return 0;
+    }
+
+    PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]);
+    if (self == NULL) {
+        // When first arg is NULL, its not really about self
+        return 0;
+    }
+
+    Py_ssize_t qualname_len;
+    const char *qualname = PyUnicode_AsUTF8AndSize(
+        func->func_qualname, &qualname_len);
+    if (qualname == NULL) {
+        PyErr_Clear();
+        return 0;
+    }
+
+    const char *method_dot = strrchr(qualname, '.');
+    if (method_dot == NULL) {
+        return 0;
+    }
+
+    const char *class_start = qualname;
+    for (const char *p = qualname; p < method_dot; p++) {
+        if (*p == '.') {
+            class_start = p + 1;
+        }
+    }
+    Py_ssize_t class_len = method_dot - class_start;
+    const char *type_name = Py_TYPE(self)->tp_name;
+
+    return (strlen(type_name) == (size_t)class_len
+            && strncmp(type_name, class_start, (size_t)class_len) == 0);
+}
+
 static int
 positional_only_passed_as_keyword(PyThreadState *tstate, PyCodeObject *co,
                                   Py_ssize_t kwcount, PyObject* kwnames,
@@ -1721,6 +1775,7 @@ initialize_locals(PyThreadState *tstate, PyFunctionObject *func,
 
     /* Copy all positional arguments into local variables */
     Py_ssize_t j, n;
+    int missing_self_hint = suggest_missing_self(func, co, args, argcount);
     if (argcount > co->co_argcount) {
         n = co->co_argcount;
     }
@@ -1864,7 +1919,7 @@ initialize_locals(PyThreadState *tstate, PyFunctionObject *func,
     /* Check the number of positional arguments */
     if ((argcount > co->co_argcount) && !(co->co_flags & CO_VARARGS)) {
         too_many_positional(tstate, co, argcount, func->func_defaults, localsplus,
-                            func->func_qualname);
+                            func->func_qualname, missing_self_hint);
         goto fail_post_args;
     }