diff --git a/Modules/_multiprocessing/multiprocessing.c b/Modules/_multiprocessing/multiprocessing.c
index 2e6d8eb68c0243..d768d9921d2784 100644
--- a/Modules/_multiprocessing/multiprocessing.c
+++ b/Modules/_multiprocessing/multiprocessing.c
@@ -14,7 +14,7 @@ class HANDLE_converter(CConverter):
     type = "HANDLE"
     format_unit = '"F_HANDLE"'
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         return self.format_code("""
             {paramname} = PyLong_AsVoidPtr({argname});
             if (!{paramname} && PyErr_Occurred()) {{{{
@@ -24,7 +24,7 @@ class HANDLE_converter(CConverter):
             argname=argname)
 
 [python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=3cf0318efc6a8772]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=256fe1883e186bbe]*/
 
 /*[clinic input]
 module _multiprocessing
diff --git a/Modules/_posixsubprocess.c b/Modules/_posixsubprocess.c
index 2898eedc3e3a8f..c209430542c731 100644
--- a/Modules/_posixsubprocess.c
+++ b/Modules/_posixsubprocess.c
@@ -87,7 +87,7 @@ class pid_t_converter(CConverter):
     type = 'pid_t'
     format_unit = '" _Py_PARSE_PID "'
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         return self.format_code("""
             {paramname} = PyLong_AsPid({argname});
             if ({paramname} == -1 && PyErr_Occurred()) {{{{
@@ -96,7 +96,7 @@ class pid_t_converter(CConverter):
             """,
             argname=argname)
 [python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=c94349aa1aad151d]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=b582c628f43ebe2a]*/
 
 #include "clinic/_posixsubprocess.c.h"
 
diff --git a/Modules/_struct.c b/Modules/_struct.c
index ff1bf4e96c5f21..fffd932c72c916 100644
--- a/Modules/_struct.c
+++ b/Modules/_struct.c
@@ -109,7 +109,7 @@ class cache_struct_converter(CConverter):
     c_default = "NULL"
     broken_limited_capi = True
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         assert not limited_capi
         return self.format_code("""
             if (!{converter}(module, {argname}, &{paramname})) {{{{
@@ -122,7 +122,7 @@ class cache_struct_converter(CConverter):
     def cleanup(self):
         return "Py_XDECREF(%s);\n" % self.name
 [python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=c33b27d6b06006c6]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=06483ea83abe39fb]*/
 
 static int cache_struct_converter(PyObject *, PyObject *, PyStructObject **);
 
diff --git a/Modules/overlapped.c b/Modules/overlapped.c
index e23db22dadb18b..41c660c2013973 100644
--- a/Modules/overlapped.c
+++ b/Modules/overlapped.c
@@ -38,7 +38,7 @@
 class pointer_converter(CConverter):
     format_unit = '"F_POINTER"'
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         return self.format_code("""
             {paramname} = PyLong_AsVoidPtr({argname});
             if (!{paramname} && PyErr_Occurred()) {{{{
@@ -56,7 +56,7 @@ class HANDLE_converter(pointer_converter):
 class ULONG_PTR_converter(pointer_converter):
     type = 'ULONG_PTR'
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         return self.format_code("""
             {paramname} = (uintptr_t)PyLong_AsVoidPtr({argname});
             if (!{paramname} && PyErr_Occurred()) {{{{
@@ -71,7 +71,7 @@ class DWORD_converter(unsigned_long_converter):
 class BOOL_converter(int_converter):
     type = 'BOOL'
 [python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=436f4440630a304c]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=422287c842b7eba8]*/
 
 /*[clinic input]
 module _overlapped
diff --git a/Modules/resource.c b/Modules/resource.c
index c973008aaa6bd4..e330dbbba77270 100644
--- a/Modules/resource.c
+++ b/Modules/resource.c
@@ -26,7 +26,7 @@ class pid_t_converter(CConverter):
     type = 'pid_t'
     format_unit = '" _Py_PARSE_PID "'
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         return self.format_code("""
             {paramname} = PyLong_AsPid({argname});
             if ({paramname} == -1 && PyErr_Occurred()) {{{{
@@ -35,7 +35,7 @@ class pid_t_converter(CConverter):
             """,
             argname=argname)
 [python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=c94349aa1aad151d]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=b582c628f43ebe2a]*/
 
 #include "clinic/resource.c.h"
 
diff --git a/PC/_testconsole.c b/PC/_testconsole.c
index 1dc0d230c4d7c3..bcb4997a436501 100644
--- a/PC/_testconsole.c
+++ b/PC/_testconsole.c
@@ -40,7 +40,7 @@ class HANDLE_converter(CConverter):
     type = 'void *'
     format_unit = '"_Py_PARSE_UINTPTR"'
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         return self.format_code("""
             {paramname} = PyLong_AsVoidPtr({argname});
             if (!{paramname} && PyErr_Occurred()) {{{{
@@ -49,7 +49,7 @@ class HANDLE_converter(CConverter):
             """,
             argname=argname)
 [python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=380aa5c91076742b]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=6519570cd567ce54]*/
 /*[python end generated code:]*/
 
 /*[clinic input]
diff --git a/PC/msvcrtmodule.c b/PC/msvcrtmodule.c
index 5ff703217b421f..8948f59bff4dc9 100644
--- a/PC/msvcrtmodule.c
+++ b/PC/msvcrtmodule.c
@@ -38,7 +38,7 @@ class HANDLE_converter(CConverter):
     type = 'void *'
     format_unit = '"_Py_PARSE_UINTPTR"'
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         return self.format_code("""
             {paramname} = PyLong_AsVoidPtr({argname});
             if (!{paramname} && PyErr_Occurred()) {{{{
@@ -75,7 +75,7 @@ class wchar_t_return_converter(CReturnConverter):
         data.return_conversion.append(
             'return_value = PyUnicode_FromOrdinal(_return_value);\n')
 [python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=ff031be44ab3250d]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=6cfb201e0745c7f7]*/
 
 /*[clinic input]
 module msvcrt
diff --git a/PC/winreg.c b/PC/winreg.c
index 77b80217ac0ab1..b8ae8605e02f13 100644
--- a/PC/winreg.c
+++ b/PC/winreg.c
@@ -222,7 +222,7 @@ class HKEY_converter(CConverter):
     converter = 'clinic_HKEY_converter'
     broken_limited_capi = True
 
-    def parse_arg(self, argname, displayname, *, limited_capi):
+    def parse_arg(self, argname, displayname, *, clinic, limited_capi):
         assert not limited_capi
         return self.format_code("""
             if (!{converter}(_PyModule_GetState(module), {argname}, &{paramname})) {{{{
@@ -252,7 +252,7 @@ class self_return_converter(CReturnConverter):
         data.return_conversion.append(
             'return_value = (PyObject *)_return_value;\n')
 [python start generated code]*/
-/*[python end generated code: output=da39a3ee5e6b4b0d input=4979f33998ffb6f8]*/
+/*[python end generated code: output=da39a3ee5e6b4b0d input=5d9a391867dbe35a]*/
 
 #include "clinic/winreg.c.h"
 
diff --git a/Tools/clinic/clinic.py b/Tools/clinic/clinic.py
index 5dd7900851550a..b10a7f97b6a625 100755
--- a/Tools/clinic/clinic.py
+++ b/Tools/clinic/clinic.py
@@ -1267,7 +1267,8 @@ def parser_body(
                     """ % argname)
 
                 displayname = parameters[0].get_displayname(0)
-                parsearg = converters[0].parse_arg(argname, displayname, limited_capi=limited_capi)
+                parsearg = converters[0].parse_arg(argname, displayname,
+                                                   clinic=clinic, limited_capi=limited_capi)
                 if parsearg is None:
                     parsearg = """
                         if (!PyArg_Parse(%s, "{format_units}:{name}", {parse_arguments})) {{
@@ -1383,7 +1384,8 @@ def parser_body(
 
                 displayname = p.get_displayname(i+1)
                 argname = argname_fmt % i
-                parsearg = p.converter.parse_arg(argname, displayname, limited_capi=limited_capi)
+                parsearg = p.converter.parse_arg(argname, displayname,
+                                                 clinic=clinic, limited_capi=limited_capi)
                 if parsearg is None:
                     parser_code = None
                     break
@@ -1512,7 +1514,8 @@ def parser_body(
                         raise ValueError("defining_class should be the first "
                                         "parameter (after self)")
                     displayname = p.get_displayname(i+1)
-                    parsearg = p.converter.parse_arg(argname_fmt % i, displayname, limited_capi=limited_capi)
+                    parsearg = p.converter.parse_arg(argname_fmt % i, displayname,
+                                                     clinic=clinic, limited_capi=limited_capi)
                     if parsearg is None:
                         parser_code = None
                         break
@@ -3505,7 +3508,9 @@ def pre_render(self) -> None:
         """
         pass
 
-    def bad_argument(self, displayname: str, expected: str, *, limited_capi: bool, expected_literal: bool = True) -> str:
+    def bad_argument(self, displayname: str, expected: str,
+                     *, clinic: Clinic,
+                     limited_capi: bool, expected_literal: bool = True) -> str:
         assert '"' not in expected
         if limited_capi:
             if expected_literal:
@@ -3520,8 +3525,7 @@ def bad_argument(self, displayname: str, expected: str, *, limited_capi: bool, e
         else:
             if expected_literal:
                 expected = f'"{expected}"'
-            if clinic is not None:
-                clinic.add_include('pycore_modsupport.h', '_PyArg_BadArgument()')
+            clinic.add_include('pycore_modsupport.h', '_PyArg_BadArgument()')
             return f'_PyArg_BadArgument("{{{{name}}}}", "{displayname}", {expected}, {{argname}});'
 
     def format_code(self, fmt: str, *,
@@ -3539,7 +3543,8 @@ def format_code(self, fmt: str, *,
             fmt = fmt.replace('{bad_argument2}', bad_argument2)
         return fmt.format(argname=argname, paramname=self.parser_name, **kwargs)
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'O&':
             return self.format_code("""
                 if (!{converter}({argname}, &{paramname})) {{{{
@@ -3560,7 +3565,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                     {paramname} = {cast}{argname};
                     """,
                     argname=argname,
-                    bad_argument=self.bad_argument(displayname, typename, limited_capi=limited_capi),
+                    bad_argument=self.bad_argument(displayname, typename,
+                                                   clinic=clinic, limited_capi=limited_capi),
                     typecheck=typecheck, typename=typename, cast=cast)
             return self.format_code("""
                 if (!PyObject_TypeCheck({argname}, {subclass_of})) {{{{
@@ -3571,7 +3577,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 """,
                 argname=argname,
                 bad_argument=self.bad_argument(displayname, '({subclass_of})->tp_name',
-                                               expected_literal=False, limited_capi=limited_capi),
+                                               clinic=clinic, expected_literal=False,
+                                               limited_capi=limited_capi),
                 subclass_of=self.subclass_of, cast=cast)
         if self.format_unit == 'O':
             cast = '(%s)' % self.type if self.type != 'PyObject *' else ''
@@ -3653,7 +3660,8 @@ def converter_init(self, *, accept: TypeSet = {object}) -> None:
             self.default = bool(self.default)
             self.c_default = str(int(self.default))
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'i':
             return self.format_code("""
                 {paramname} = PyLong_AsInt({argname});
@@ -3670,7 +3678,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class defining_class_converter(CConverter):
     """
@@ -3706,7 +3715,8 @@ def converter_init(self) -> None:
             if self.c_default == '"\'"':
                 self.c_default = r"'\''"
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'c':
             return self.format_code("""
                 if (PyBytes_Check({argname}) && PyBytes_GET_SIZE({argname}) == 1) {{{{
@@ -3721,9 +3731,11 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'a byte string of length 1', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'a byte string of length 1',
+                                               clinic=clinic, limited_capi=limited_capi),
             )
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 
 @add_legacy_c_converter('B', bitwise=True)
@@ -3737,7 +3749,8 @@ def converter_init(self, *, bitwise: bool = False) -> None:
         if bitwise:
             self.format_unit = 'B'
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'b':
             return self.format_code("""
                 {{{{
@@ -3774,7 +3787,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class byte_converter(unsigned_char_converter): pass
 
@@ -3784,7 +3798,8 @@ class short_converter(CConverter):
     format_unit = 'h'
     c_ignored_default = "0"
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'h':
             return self.format_code("""
                 {{{{
@@ -3808,7 +3823,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class unsigned_short_converter(CConverter):
     type = 'unsigned short'
@@ -3823,7 +3839,8 @@ def converter_init(self, *, bitwise: bool = False) -> None:
             self.add_include('pycore_long.h',
                              '_PyLong_UnsignedShort_Converter()')
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'H':
             return self.format_code("""
                 {paramname} = (unsigned short)PyLong_AsUnsignedLongMask({argname});
@@ -3833,7 +3850,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 """,
                 argname=argname)
         if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+            return super().parse_arg(argname, displayname,
+                                     clinic=clinic, limited_capi=limited_capi)
         # NOTE: Raises OverflowError for negative integer.
         return self.format_code("""
             {{{{
@@ -3868,7 +3886,8 @@ def converter_init(
         if type is not None:
             self.type = type
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'i':
             return self.format_code("""
                 {paramname} = PyLong_AsInt({argname});
@@ -3890,9 +3909,11 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 {paramname} = PyUnicode_READ_CHAR({argname}, 0);
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'a unicode character', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'a unicode character',
+                                               clinic=clinic, limited_capi=limited_capi),
             )
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class unsigned_int_converter(CConverter):
     type = 'unsigned int'
@@ -3907,7 +3928,8 @@ def converter_init(self, *, bitwise: bool = False) -> None:
             self.add_include('pycore_long.h',
                              '_PyLong_UnsignedInt_Converter()')
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'I':
             return self.format_code("""
                 {paramname} = (unsigned int)PyLong_AsUnsignedLongMask({argname});
@@ -3917,7 +3939,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 """,
                 argname=argname)
         if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+            return super().parse_arg(argname, displayname,
+                                     clinic=clinic, limited_capi=limited_capi)
         # NOTE: Raises OverflowError for negative integer.
         return self.format_code("""
             {{{{
@@ -3941,7 +3964,8 @@ class long_converter(CConverter):
     format_unit = 'l'
     c_ignored_default = "0"
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'l':
             return self.format_code("""
                 {paramname} = PyLong_AsLong({argname});
@@ -3950,7 +3974,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class unsigned_long_converter(CConverter):
     type = 'unsigned long'
@@ -3965,7 +3990,8 @@ def converter_init(self, *, bitwise: bool = False) -> None:
             self.add_include('pycore_long.h',
                              '_PyLong_UnsignedLong_Converter()')
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'k':
             return self.format_code("""
                 if (!PyLong_Check({argname})) {{{{
@@ -3975,10 +4001,12 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 {paramname} = PyLong_AsUnsignedLongMask({argname});
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'int', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'int',
+                                               clinic=clinic, limited_capi=limited_capi),
             )
         if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+            return super().parse_arg(argname, displayname,
+                                     clinic=clinic, limited_capi=limited_capi)
         # NOTE: Raises OverflowError for negative integer.
         return self.format_code("""
             {paramname} = PyLong_AsUnsignedLong({argname});
@@ -3994,7 +4022,8 @@ class long_long_converter(CConverter):
     format_unit = 'L'
     c_ignored_default = "0"
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'L':
             return self.format_code("""
                 {paramname} = PyLong_AsLongLong({argname});
@@ -4003,7 +4032,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class unsigned_long_long_converter(CConverter):
     type = 'unsigned long long'
@@ -4018,7 +4048,8 @@ def converter_init(self, *, bitwise: bool = False) -> None:
             self.add_include('pycore_long.h',
                              '_PyLong_UnsignedLongLong_Converter()')
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'K':
             return self.format_code("""
                 if (!PyLong_Check({argname})) {{{{
@@ -4028,10 +4059,12 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 {paramname} = PyLong_AsUnsignedLongLongMask({argname});
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'int', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'int',
+                                               clinic=clinic, limited_capi=limited_capi),
             )
         if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+            return super().parse_arg(argname, displayname,
+                                     clinic=clinic, limited_capi=limited_capi)
         # NOTE: Raises OverflowError for negative integer.
         return self.format_code("""
             {paramname} = PyLong_AsUnsignedLongLong({argname});
@@ -4057,7 +4090,8 @@ def converter_init(self, *, accept: TypeSet = {int}) -> None:
         else:
             fail(f"Py_ssize_t_converter: illegal 'accept' argument {accept!r}")
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'n':
             if limited_capi:
                 PyNumber_Index = 'PyNumber_Index'
@@ -4080,7 +4114,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 argname=argname,
                 PyNumber_Index=PyNumber_Index)
         if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+            return super().parse_arg(argname, displayname,
+                                     clinic=clinic, limited_capi=limited_capi)
         return self.format_code("""
             if ({argname} != Py_None) {{{{
                 if (PyIndex_Check({argname})) {{{{
@@ -4096,7 +4131,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
             }}}}
             """,
             argname=argname,
-            bad_argument=self.bad_argument(displayname, 'integer or None', limited_capi=limited_capi),
+            bad_argument=self.bad_argument(displayname, 'integer or None',
+                                           clinic=clinic, limited_capi=limited_capi),
         )
 
 
@@ -4113,9 +4149,11 @@ def converter_init(self, *, accept: TypeSet = {int, NoneType}) -> None:
         else:
             fail(f"slice_index_converter: illegal 'accept' argument {accept!r}")
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+            return super().parse_arg(argname, displayname,
+                                     clinic=clinic, limited_capi=limited_capi)
         if self.nullable:
             return self.format_code("""
                 if (!Py_IsNone({argname})) {{{{
@@ -4160,7 +4198,8 @@ def converter_init(self, *, accept: TypeSet = {int, NoneType}) -> None:
         self.add_include('pycore_long.h',
                          '_PyLong_Size_t_Converter()')
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'n':
             return self.format_code("""
                 {paramname} = PyNumber_AsSsize_t({argname}, PyExc_OverflowError);
@@ -4170,7 +4209,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 """,
                 argname=argname)
         if not limited_capi:
-            return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+            return super().parse_arg(argname, displayname,
+                                     clinic=clinic, limited_capi=limited_capi)
         # NOTE: Raises OverflowError for negative integer.
         return self.format_code("""
             {paramname} = PyLong_AsSize_t({argname});
@@ -4205,7 +4245,8 @@ class float_converter(CConverter):
     format_unit = 'f'
     c_ignored_default = "0.0"
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'f':
             return self.format_code("""
                 if (PyFloat_CheckExact({argname})) {{{{
@@ -4220,7 +4261,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class double_converter(CConverter):
     type = 'double'
@@ -4228,7 +4270,8 @@ class double_converter(CConverter):
     format_unit = 'd'
     c_ignored_default = "0.0"
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'd':
             return self.format_code("""
                 if (PyFloat_CheckExact({argname})) {{{{
@@ -4243,7 +4286,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 
 class Py_complex_converter(CConverter):
@@ -4252,7 +4296,8 @@ class Py_complex_converter(CConverter):
     format_unit = 'D'
     c_ignored_default = "{0.0, 0.0}"
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'D':
             return self.format_code("""
                 {paramname} = PyComplex_AsCComplex({argname});
@@ -4261,7 +4306,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 
 class object_converter(CConverter):
@@ -4346,7 +4392,8 @@ def post_parsing(self) -> str:
         else:
             return ""
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 's':
             return self.format_code("""
                 if (!PyUnicode_Check({argname})) {{{{
@@ -4364,7 +4411,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'str', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'str',
+                                               clinic=clinic, limited_capi=limited_capi),
                 length_name=self.length_name)
         if self.format_unit == 'z':
             return self.format_code("""
@@ -4388,9 +4436,11 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'str or None', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'str or None',
+                                               clinic=clinic, limited_capi=limited_capi),
                 length_name=self.length_name)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 #
 # This is the fourth or fifth rewrite of registering all the
@@ -4452,7 +4502,8 @@ class PyBytesObject_converter(CConverter):
     format_unit = 'S'
     # accept = {bytes}
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'S':
             return self.format_code("""
                 if (!PyBytes_Check({argname})) {{{{
@@ -4462,16 +4513,19 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 {paramname} = ({type}){argname};
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'bytes', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'bytes',
+                                               clinic=clinic, limited_capi=limited_capi),
                 type=self.type)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class PyByteArrayObject_converter(CConverter):
     type = 'PyByteArrayObject *'
     format_unit = 'Y'
     # accept = {bytearray}
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'Y':
             return self.format_code("""
                 if (!PyByteArray_Check({argname})) {{{{
@@ -4481,16 +4535,19 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 {paramname} = ({type}){argname};
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'bytearray', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'bytearray',
+                                               clinic=clinic, limited_capi=limited_capi),
                 type=self.type)
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 class unicode_converter(CConverter):
     type = 'PyObject *'
     default_type = (str, Null, NoneType)
     format_unit = 'U'
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'U':
             return self.format_code("""
                 if (!PyUnicode_Check({argname})) {{{{
@@ -4500,9 +4557,11 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 {paramname} = {argname};
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'str', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'str',
+                                               clinic=clinic, limited_capi=limited_capi),
             )
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 @add_legacy_c_converter('u')
 @add_legacy_c_converter('u#', zeroes=True)
@@ -4538,7 +4597,8 @@ def cleanup(self) -> str:
         else:
             return f"""PyMem_Free((void *){self.parser_name});\n"""
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if not self.length:
             if self.accept == {str}:
                 return self.format_code("""
@@ -4552,7 +4612,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                     }}}}
                     """,
                     argname=argname,
-                    bad_argument=self.bad_argument(displayname, 'str', limited_capi=limited_capi),
+                    bad_argument=self.bad_argument(displayname, 'str',
+                                                   clinic=clinic, limited_capi=limited_capi),
                 )
             elif self.accept == {str, NoneType}:
                 return self.format_code("""
@@ -4571,9 +4632,11 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                     }}}}
                     """,
                     argname=argname,
-                    bad_argument=self.bad_argument(displayname, 'str or None', limited_capi=limited_capi),
+                    bad_argument=self.bad_argument(displayname, 'str or None',
+                                                   clinic=clinic, limited_capi=limited_capi),
                 )
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 @add_legacy_c_converter('s*', accept={str, buffer})
 @add_legacy_c_converter('z*', accept={str, buffer, NoneType})
@@ -4607,7 +4670,8 @@ def cleanup(self) -> str:
         name = self.name
         return "".join(["if (", name, ".obj) {\n   PyBuffer_Release(&", name, ");\n}\n"])
 
-    def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> str | None:
+    def parse_arg(self, argname: str, displayname: str,
+                  *, clinic: Clinic, limited_capi: bool) -> str | None:
         if self.format_unit == 'y*':
             return self.format_code("""
                 if (PyObject_GetBuffer({argname}, &{paramname}, PyBUF_SIMPLE) != 0) {{{{
@@ -4619,7 +4683,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'contiguous buffer', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'contiguous buffer',
+                                               clinic=clinic, limited_capi=limited_capi),
             )
         elif self.format_unit == 's*':
             return self.format_code("""
@@ -4642,7 +4707,8 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'contiguous buffer', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'contiguous buffer',
+                                               clinic=clinic, limited_capi=limited_capi),
             )
         elif self.format_unit == 'w*':
             return self.format_code("""
@@ -4656,10 +4722,13 @@ def parse_arg(self, argname: str, displayname: str, *, limited_capi: bool) -> st
                 }}}}
                 """,
                 argname=argname,
-                bad_argument=self.bad_argument(displayname, 'read-write bytes-like object', limited_capi=limited_capi),
-                bad_argument2=self.bad_argument(displayname, 'contiguous buffer', limited_capi=limited_capi),
+                bad_argument=self.bad_argument(displayname, 'read-write bytes-like object',
+                                               clinic=clinic, limited_capi=limited_capi),
+                bad_argument2=self.bad_argument(displayname, 'contiguous buffer',
+                                                clinic=clinic, limited_capi=limited_capi),
             )
-        return super().parse_arg(argname, displayname, limited_capi=limited_capi)
+        return super().parse_arg(argname, displayname,
+                                 clinic=clinic, limited_capi=limited_capi)
 
 
 def correct_name_for_self(