Add suggestion for self

Author: SurenNihalani

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,69 @@ 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 != 0 || argcount == 0) {
+        return 0;
+    }
+
+    PyObject *self = PyStackRef_AsPyObjectBorrow(args[0]);
+    if (self == NULL) {
+        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 +1773,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 +1917,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;
     }