METH_FASTCALL changes to .inc files

done via python's Argument Clinic tool,
refer python/cpython@259f0e4437

third_party/python/Modules/_io/clinic/_iomodule.inc

@@ -130,6 +130,11 @@ PyDoc_STRVAR(_io_open__doc__,
 #define _IO_OPEN_METHODDEF    \
     {"open", (PyCFunction)_io_open, METH_FASTCALL, _io_open__doc__},
 
+static PyObject *
+_io_open_impl(PyObject *module, PyObject *file, const char *mode,
+              int buffering, const char *encoding, const char *errors,
+              const char *newline, int closefd, PyObject *opener);
+
 static PyObject *
 _io_open(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
@@ -154,4 +159,4 @@ _io_open(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=c5b8fc8b83102bbf input=a9049054013a1b77]*/
+/*[clinic end generated code: output=79fd04d9c9d8f28f input=a9049054013a1b77]*/

third_party/python/Modules/_io/clinic/bufferedio.inc

@@ -11,6 +11,8 @@ PyDoc_STRVAR(_io__BufferedIOBase_readinto__doc__,
 #define _IO__BUFFEREDIOBASE_READINTO_METHODDEF    \
     {"readinto", (PyCFunction)_io__BufferedIOBase_readinto, METH_O, _io__BufferedIOBase_readinto__doc__},
 
+static PyObject *
+_io__BufferedIOBase_readinto_impl(PyObject *self, Py_buffer *buffer);
 
 static PyObject *
 _io__BufferedIOBase_readinto(PyObject *self, PyObject *arg)
@@ -90,21 +92,25 @@ PyDoc_STRVAR(_io__Buffered_peek__doc__,
 "\n");
 
 #define _IO__BUFFERED_PEEK_METHODDEF    \
-    {"peek", (PyCFunction)_io__Buffered_peek, METH_VARARGS, _io__Buffered_peek__doc__},
+    {"peek", (PyCFunction)_io__Buffered_peek, METH_FASTCALL, _io__Buffered_peek__doc__},
 
 static PyObject *
 _io__Buffered_peek_impl(buffered *self, Py_ssize_t size);
 
 static PyObject *
-_io__Buffered_peek(buffered *self, PyObject *args)
+_io__Buffered_peek(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t size = 0;
 
-    if (!PyArg_ParseTuple(args, "|n:peek",
+    if (!_PyArg_ParseStack(args, nargs, "|n:peek",
         &size)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("peek", kwnames)) {
+        goto exit;
+    }
     return_value = _io__Buffered_peek_impl(self, size);
 
 exit:
@@ -117,21 +123,25 @@ PyDoc_STRVAR(_io__Buffered_read__doc__,
 "\n");
 
 #define _IO__BUFFERED_READ_METHODDEF    \
-    {"read", (PyCFunction)_io__Buffered_read, METH_VARARGS, _io__Buffered_read__doc__},
+    {"read", (PyCFunction)_io__Buffered_read, METH_FASTCALL, _io__Buffered_read__doc__},
 
 static PyObject *
 _io__Buffered_read_impl(buffered *self, Py_ssize_t n);
 
 static PyObject *
-_io__Buffered_read(buffered *self, PyObject *args)
+_io__Buffered_read(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t n = -1;
 
-    if (!PyArg_ParseTuple(args, "|O&:read",
+    if (!_PyArg_ParseStack(args, nargs, "|O&:read",
         _PyIO_ConvertSsize_t, &n)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("read", kwnames)) {
+        goto exit;
+    }
     return_value = _io__Buffered_read_impl(self, n);
 
 exit:
@@ -232,21 +242,25 @@ PyDoc_STRVAR(_io__Buffered_readline__doc__,
 "\n");
 
 #define _IO__BUFFERED_READLINE_METHODDEF    \
-    {"readline", (PyCFunction)_io__Buffered_readline, METH_VARARGS, _io__Buffered_readline__doc__},
+    {"readline", (PyCFunction)_io__Buffered_readline, METH_FASTCALL, _io__Buffered_readline__doc__},
 
 static PyObject *
 _io__Buffered_readline_impl(buffered *self, Py_ssize_t size);
 
 static PyObject *
-_io__Buffered_readline(buffered *self, PyObject *args)
+_io__Buffered_readline(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t size = -1;
 
-    if (!PyArg_ParseTuple(args, "|O&:readline",
+    if (!_PyArg_ParseStack(args, nargs, "|O&:readline",
         _PyIO_ConvertSsize_t, &size)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("readline", kwnames)) {
+        goto exit;
+    }
     return_value = _io__Buffered_readline_impl(self, size);
 
 exit:
@@ -259,22 +273,26 @@ PyDoc_STRVAR(_io__Buffered_seek__doc__,
 "\n");
 
 #define _IO__BUFFERED_SEEK_METHODDEF    \
-    {"seek", (PyCFunction)_io__Buffered_seek, METH_VARARGS, _io__Buffered_seek__doc__},
+    {"seek", (PyCFunction)_io__Buffered_seek, METH_FASTCALL, _io__Buffered_seek__doc__},
 
 static PyObject *
 _io__Buffered_seek_impl(buffered *self, PyObject *targetobj, int whence);
 
 static PyObject *
-_io__Buffered_seek(buffered *self, PyObject *args)
+_io__Buffered_seek(buffered *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *targetobj;
     int whence = 0;
 
-    if (!PyArg_ParseTuple(args, "O|i:seek",
+    if (!_PyArg_ParseStack(args, nargs, "O|i:seek",
         &targetobj, &whence)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("seek", kwnames)) {
+        goto exit;
+    }
     return_value = _io__Buffered_seek_impl(self, targetobj, whence);
 
 exit:
@@ -474,4 +492,4 @@ _io_BufferedRandom___init__(PyObject *self, PyObject *args, PyObject *kwargs)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=a956f394ecde4cf9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=c1127ca3a3f57d06 input=a9049054013a1b77]*/

third_party/python/Modules/_io/clinic/bytesio.inc

@@ -339,22 +339,26 @@ PyDoc_STRVAR(_io_BytesIO_seek__doc__,
 "Returns the new absolute position.");
 
 #define _IO_BYTESIO_SEEK_METHODDEF    \
-    {"seek", (PyCFunction)_io_BytesIO_seek, METH_VARARGS, _io_BytesIO_seek__doc__},
+    {"seek", (PyCFunction)_io_BytesIO_seek, METH_FASTCALL, _io_BytesIO_seek__doc__},
 
 static PyObject *
 _io_BytesIO_seek_impl(bytesio *self, Py_ssize_t pos, int whence);
 
 static PyObject *
-_io_BytesIO_seek(bytesio *self, PyObject *args)
+_io_BytesIO_seek(bytesio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t pos;
     int whence = 0;
 
-    if (!PyArg_ParseTuple(args, "n|i:seek",
+    if (!_PyArg_ParseStack(args, nargs, "n|i:seek",
         &pos, &whence)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("seek", kwnames)) {
+        goto exit;
+    }
     return_value = _io_BytesIO_seek_impl(self, pos, whence);
 
 exit:
@@ -429,4 +433,4 @@ _io_BytesIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=6382e8eb578eea64 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=2b2b78d39cdf6846 input=a9049054013a1b77]*/

third_party/python/Modules/_io/clinic/fileio.inc

@@ -15,6 +15,9 @@ PyDoc_STRVAR(_io_FileIO_close__doc__,
 #define _IO_FILEIO_CLOSE_METHODDEF    \
     {"close", (PyCFunction)_io_FileIO_close, METH_NOARGS, _io_FileIO_close__doc__},
 
+static PyObject *
+_io_FileIO_close_impl(fileio *self);
+
 static PyObject *
 _io_FileIO_close(fileio *self, PyObject *Py_UNUSED(ignored))
 {
@@ -39,6 +42,10 @@ PyDoc_STRVAR(_io_FileIO___init____doc__,
 "*opener* must return an open file descriptor (passing os.open as *opener*\n"
 "results in functionality similar to passing None).");
 
+static int
+_io_FileIO___init___impl(fileio *self, PyObject *nameobj, const char *mode,
+                         int closefd, PyObject *opener);
+
 static int
 _io_FileIO___init__(PyObject *self, PyObject *args, PyObject *kwargs)
 {
@@ -196,21 +203,25 @@ PyDoc_STRVAR(_io_FileIO_read__doc__,
 "Return an empty bytes object at EOF.");
 
 #define _IO_FILEIO_READ_METHODDEF    \
-    {"read", (PyCFunction)_io_FileIO_read, METH_VARARGS, _io_FileIO_read__doc__},
+    {"read", (PyCFunction)_io_FileIO_read, METH_FASTCALL, _io_FileIO_read__doc__},
 
 static PyObject *
 _io_FileIO_read_impl(fileio *self, Py_ssize_t size);
 
 static PyObject *
-_io_FileIO_read(fileio *self, PyObject *args)
+_io_FileIO_read(fileio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t size = -1;
 
-    if (!PyArg_ParseTuple(args, "|O&:read",
+    if (!_PyArg_ParseStack(args, nargs, "|O&:read",
         _PyIO_ConvertSsize_t, &size)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("read", kwnames)) {
+        goto exit;
+    }
     return_value = _io_FileIO_read_impl(self, size);
 
 exit:
@@ -268,22 +279,26 @@ PyDoc_STRVAR(_io_FileIO_seek__doc__,
 "Note that not all file objects are seekable.");
 
 #define _IO_FILEIO_SEEK_METHODDEF    \
-    {"seek", (PyCFunction)_io_FileIO_seek, METH_VARARGS, _io_FileIO_seek__doc__},
+    {"seek", (PyCFunction)_io_FileIO_seek, METH_FASTCALL, _io_FileIO_seek__doc__},
 
 static PyObject *
 _io_FileIO_seek_impl(fileio *self, PyObject *pos, int whence);
 
 static PyObject *
-_io_FileIO_seek(fileio *self, PyObject *args)
+_io_FileIO_seek(fileio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *pos;
     int whence = 0;
 
-    if (!PyArg_ParseTuple(args, "O|i:seek",
+    if (!_PyArg_ParseStack(args, nargs, "O|i:seek",
         &pos, &whence)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("seek", kwnames)) {
+        goto exit;
+    }
     return_value = _io_FileIO_seek_impl(self, pos, whence);
 
 exit:
@@ -367,4 +382,4 @@ _io_FileIO_isatty(fileio *self, PyObject *Py_UNUSED(ignored))
 #ifndef _IO_FILEIO_TRUNCATE_METHODDEF
     #define _IO_FILEIO_TRUNCATE_METHODDEF
 #endif /* !defined(_IO_FILEIO_TRUNCATE_METHODDEF) */
-/*[clinic end generated code: output=51924bc0ee11d58e input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5c2a0b493c0af58b input=a9049054013a1b77]*/

third_party/python/Modules/_io/clinic/iobase.inc

@@ -12,6 +12,9 @@ PyDoc_STRVAR(_io__IOBase_tell__doc__,
 #define _IO__IOBASE_TELL_METHODDEF    \
     {"tell", (PyCFunction)_io__IOBase_tell, METH_NOARGS, _io__IOBase_tell__doc__},
 
+static PyObject *
+_io__IOBase_tell_impl(PyObject *self);
+
 static PyObject *
 _io__IOBase_tell(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
@@ -29,6 +32,9 @@ PyDoc_STRVAR(_io__IOBase_flush__doc__,
 #define _IO__IOBASE_FLUSH_METHODDEF    \
     {"flush", (PyCFunction)_io__IOBase_flush, METH_NOARGS, _io__IOBase_flush__doc__},
 
+static PyObject *
+_io__IOBase_flush_impl(PyObject *self);
+
 static PyObject *
 _io__IOBase_flush(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
@@ -46,6 +52,9 @@ PyDoc_STRVAR(_io__IOBase_close__doc__,
 #define _IO__IOBASE_CLOSE_METHODDEF    \
     {"close", (PyCFunction)_io__IOBase_close, METH_NOARGS, _io__IOBase_close__doc__},
 
+static PyObject *
+_io__IOBase_close_impl(PyObject *self);
+
 static PyObject *
 _io__IOBase_close(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
@@ -64,6 +73,9 @@ PyDoc_STRVAR(_io__IOBase_seekable__doc__,
 #define _IO__IOBASE_SEEKABLE_METHODDEF    \
     {"seekable", (PyCFunction)_io__IOBase_seekable, METH_NOARGS, _io__IOBase_seekable__doc__},
 
+static PyObject *
+_io__IOBase_seekable_impl(PyObject *self);
+
 static PyObject *
 _io__IOBase_seekable(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
@@ -81,6 +93,9 @@ PyDoc_STRVAR(_io__IOBase_readable__doc__,
 #define _IO__IOBASE_READABLE_METHODDEF    \
     {"readable", (PyCFunction)_io__IOBase_readable, METH_NOARGS, _io__IOBase_readable__doc__},
 
+static PyObject *
+_io__IOBase_readable_impl(PyObject *self);
+
 static PyObject *
 _io__IOBase_readable(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
@@ -98,6 +113,9 @@ PyDoc_STRVAR(_io__IOBase_writable__doc__,
 #define _IO__IOBASE_WRITABLE_METHODDEF    \
     {"writable", (PyCFunction)_io__IOBase_writable, METH_NOARGS, _io__IOBase_writable__doc__},
 
+static PyObject *
+_io__IOBase_writable_impl(PyObject *self);
+
 static PyObject *
 _io__IOBase_writable(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
@@ -115,6 +133,9 @@ PyDoc_STRVAR(_io__IOBase_fileno__doc__,
 #define _IO__IOBASE_FILENO_METHODDEF    \
     {"fileno", (PyCFunction)_io__IOBase_fileno, METH_NOARGS, _io__IOBase_fileno__doc__},
 
+static PyObject *
+_io__IOBase_fileno_impl(PyObject *self);
+
 static PyObject *
 _io__IOBase_fileno(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
@@ -132,6 +153,9 @@ PyDoc_STRVAR(_io__IOBase_isatty__doc__,
 #define _IO__IOBASE_ISATTY_METHODDEF    \
     {"isatty", (PyCFunction)_io__IOBase_isatty, METH_NOARGS, _io__IOBase_isatty__doc__},
 
+static PyObject *
+_io__IOBase_isatty_impl(PyObject *self);
+
 static PyObject *
 _io__IOBase_isatty(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
@@ -151,18 +175,25 @@ PyDoc_STRVAR(_io__IOBase_readline__doc__,
 "terminator(s) recognized.");
 
 #define _IO__IOBASE_READLINE_METHODDEF    \
-    {"readline", (PyCFunction)_io__IOBase_readline, METH_VARARGS, _io__IOBase_readline__doc__},
+    {"readline", (PyCFunction)_io__IOBase_readline, METH_FASTCALL, _io__IOBase_readline__doc__},
 
 static PyObject *
-_io__IOBase_readline(PyObject *self, PyObject *args)
+_io__IOBase_readline_impl(PyObject *self, Py_ssize_t limit);
+
+static PyObject *
+_io__IOBase_readline(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t limit = -1;
 
-    if (!PyArg_ParseTuple(args, "|O&:readline",
+    if (!_PyArg_ParseStack(args, nargs, "|O&:readline",
         _PyIO_ConvertSsize_t, &limit)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("readline", kwnames)) {
+        goto exit;
+    }
     return_value = _io__IOBase_readline_impl(self, limit);
 
 exit:
@@ -180,18 +211,25 @@ PyDoc_STRVAR(_io__IOBase_readlines__doc__,
 "lines so far exceeds hint.");
 
 #define _IO__IOBASE_READLINES_METHODDEF    \
-    {"readlines", (PyCFunction)_io__IOBase_readlines, METH_VARARGS, _io__IOBase_readlines__doc__},
+    {"readlines", (PyCFunction)_io__IOBase_readlines, METH_FASTCALL, _io__IOBase_readlines__doc__},
 
 static PyObject *
-_io__IOBase_readlines(PyObject *self, PyObject *args)
+_io__IOBase_readlines_impl(PyObject *self, Py_ssize_t hint);
+
+static PyObject *
+_io__IOBase_readlines(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t hint = -1;
 
-    if (!PyArg_ParseTuple(args, "|O&:readlines",
+    if (!_PyArg_ParseStack(args, nargs, "|O&:readlines",
         _PyIO_ConvertSsize_t, &hint)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("readlines", kwnames)) {
+        goto exit;
+    }
     return_value = _io__IOBase_readlines_impl(self, hint);
 
 exit:
@@ -212,21 +250,25 @@ PyDoc_STRVAR(_io__RawIOBase_read__doc__,
 "\n");
 
 #define _IO__RAWIOBASE_READ_METHODDEF    \
-    {"read", (PyCFunction)_io__RawIOBase_read, METH_VARARGS, _io__RawIOBase_read__doc__},
+    {"read", (PyCFunction)_io__RawIOBase_read, METH_FASTCALL, _io__RawIOBase_read__doc__},
 
 static PyObject *
 _io__RawIOBase_read_impl(PyObject *self, Py_ssize_t n);
 
 static PyObject *
-_io__RawIOBase_read(PyObject *self, PyObject *args)
+_io__RawIOBase_read(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t n = -1;
 
-    if (!PyArg_ParseTuple(args, "|n:read",
+    if (!_PyArg_ParseStack(args, nargs, "|n:read",
         &n)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("read", kwnames)) {
+        goto exit;
+    }
     return_value = _io__RawIOBase_read_impl(self, n);
 
 exit:
@@ -250,4 +292,4 @@ _io__RawIOBase_readall(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
     return _io__RawIOBase_readall_impl(self);
 }
-/*[clinic end generated code: output=0f53fed928d8e02f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=1bcece367fc7b0cd input=a9049054013a1b77]*/

third_party/python/Modules/_io/clinic/stringio.inc

@@ -12,6 +12,9 @@ PyDoc_STRVAR(_io_StringIO_getvalue__doc__,
 #define _IO_STRINGIO_GETVALUE_METHODDEF    \
     {"getvalue", (PyCFunction)_io_StringIO_getvalue, METH_NOARGS, _io_StringIO_getvalue__doc__},
 
+static PyObject *
+_io_StringIO_getvalue_impl(stringio *self);
+
 static PyObject *
 _io_StringIO_getvalue(stringio *self, PyObject *Py_UNUSED(ignored))
 {
@@ -145,22 +148,26 @@ PyDoc_STRVAR(_io_StringIO_seek__doc__,
 "Returns the new absolute position.");
 
 #define _IO_STRINGIO_SEEK_METHODDEF    \
-    {"seek", (PyCFunction)_io_StringIO_seek, METH_VARARGS, _io_StringIO_seek__doc__},
+    {"seek", (PyCFunction)_io_StringIO_seek, METH_FASTCALL, _io_StringIO_seek__doc__},
 
 static PyObject *
 _io_StringIO_seek_impl(stringio *self, Py_ssize_t pos, int whence);
 
 static PyObject *
-_io_StringIO_seek(stringio *self, PyObject *args)
+_io_StringIO_seek(stringio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t pos;
     int whence = 0;
 
-    if (!PyArg_ParseTuple(args, "n|i:seek",
+    if (!_PyArg_ParseStack(args, nargs, "n|i:seek",
         &pos, &whence)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("seek", kwnames)) {
+        goto exit;
+    }
     return_value = _io_StringIO_seek_impl(self, pos, whence);
 
 exit:
@@ -287,4 +294,4 @@ _io_StringIO_seekable(stringio *self, PyObject *Py_UNUSED(ignored))
 {
     return _io_StringIO_seekable_impl(self);
 }
-/*[clinic end generated code: output=5dd5c2a213e75405 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=69bf262268745061 input=a9049054013a1b77]*/

third_party/python/Modules/_io/clinic/textio.inc

@@ -1,9 +1,3 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Python 3                                                                     │
-│ https://docs.python.org/3/license.html                                       │
-╚─────────────────────────────────────────────────────────────────────────────*/
 /* clang-format off */
 /*[clinic input]
 preserve
@@ -232,21 +226,25 @@ PyDoc_STRVAR(_io_TextIOWrapper_read__doc__,
 "\n");
 
 #define _IO_TEXTIOWRAPPER_READ_METHODDEF    \
-    {"read", (PyCFunction)_io_TextIOWrapper_read, METH_VARARGS, _io_TextIOWrapper_read__doc__},
+    {"read", (PyCFunction)_io_TextIOWrapper_read, METH_FASTCALL, _io_TextIOWrapper_read__doc__},
 
 static PyObject *
 _io_TextIOWrapper_read_impl(textio *self, Py_ssize_t n);
 
 static PyObject *
-_io_TextIOWrapper_read(textio *self, PyObject *args)
+_io_TextIOWrapper_read(textio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t n = -1;
 
-    if (!PyArg_ParseTuple(args, "|O&:read",
+    if (!_PyArg_ParseStack(args, nargs, "|O&:read",
         _PyIO_ConvertSsize_t, &n)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("read", kwnames)) {
+        goto exit;
+    }
     return_value = _io_TextIOWrapper_read_impl(self, n);
 
 exit:
@@ -259,21 +257,25 @@ PyDoc_STRVAR(_io_TextIOWrapper_readline__doc__,
 "\n");
 
 #define _IO_TEXTIOWRAPPER_READLINE_METHODDEF    \
-    {"readline", (PyCFunction)_io_TextIOWrapper_readline, METH_VARARGS, _io_TextIOWrapper_readline__doc__},
+    {"readline", (PyCFunction)_io_TextIOWrapper_readline, METH_FASTCALL, _io_TextIOWrapper_readline__doc__},
 
 static PyObject *
 _io_TextIOWrapper_readline_impl(textio *self, Py_ssize_t size);
 
 static PyObject *
-_io_TextIOWrapper_readline(textio *self, PyObject *args)
+_io_TextIOWrapper_readline(textio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t size = -1;
 
-    if (!PyArg_ParseTuple(args, "|n:readline",
+    if (!_PyArg_ParseStack(args, nargs, "|n:readline",
         &size)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("readline", kwnames)) {
+        goto exit;
+    }
     return_value = _io_TextIOWrapper_readline_impl(self, size);
 
 exit:
@@ -286,22 +288,26 @@ PyDoc_STRVAR(_io_TextIOWrapper_seek__doc__,
 "\n");
 
 #define _IO_TEXTIOWRAPPER_SEEK_METHODDEF    \
-    {"seek", (PyCFunction)_io_TextIOWrapper_seek, METH_VARARGS, _io_TextIOWrapper_seek__doc__},
+    {"seek", (PyCFunction)_io_TextIOWrapper_seek, METH_FASTCALL, _io_TextIOWrapper_seek__doc__},
 
 static PyObject *
 _io_TextIOWrapper_seek_impl(textio *self, PyObject *cookieObj, int whence);
 
 static PyObject *
-_io_TextIOWrapper_seek(textio *self, PyObject *args)
+_io_TextIOWrapper_seek(textio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *cookieObj;
     int whence = 0;
 
-    if (!PyArg_ParseTuple(args, "O|i:seek",
+    if (!_PyArg_ParseStack(args, nargs, "O|i:seek",
         &cookieObj, &whence)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("seek", kwnames)) {
+        goto exit;
+    }
     return_value = _io_TextIOWrapper_seek_impl(self, cookieObj, whence);
 
 exit:
@@ -471,4 +477,4 @@ _io_TextIOWrapper_close(textio *self, PyObject *Py_UNUSED(ignored))
 {
     return _io_TextIOWrapper_close_impl(self);
 }
-/*[clinic end generated code: output=78ad14eba1667254 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=1f8367c7a3301670 input=a9049054013a1b77]*/

third_party/python/Modules/_io/clinic/winconsoleio.inc

@@ -3,8 +3,6 @@
 preserve
 [clinic start generated code]*/
 
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_close__doc__,
 "close($self, /)\n"
 "--\n"
@@ -26,10 +24,6 @@ _io__WindowsConsoleIO_close(winconsoleio *self, PyObject *Py_UNUSED(ignored))
     return _io__WindowsConsoleIO_close_impl(self);
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO___init____doc__,
 "_WindowsConsoleIO(file, mode=\'r\', closefd=True, opener=None)\n"
 "--\n"
@@ -66,10 +60,6 @@ exit:
     return return_value;
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_fileno__doc__,
 "fileno($self, /)\n"
 "--\n"
@@ -91,10 +81,6 @@ _io__WindowsConsoleIO_fileno(winconsoleio *self, PyObject *Py_UNUSED(ignored))
     return _io__WindowsConsoleIO_fileno_impl(self);
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_readable__doc__,
 "readable($self, /)\n"
 "--\n"
@@ -113,10 +99,6 @@ _io__WindowsConsoleIO_readable(winconsoleio *self, PyObject *Py_UNUSED(ignored))
     return _io__WindowsConsoleIO_readable_impl(self);
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_writable__doc__,
 "writable($self, /)\n"
 "--\n"
@@ -135,10 +117,6 @@ _io__WindowsConsoleIO_writable(winconsoleio *self, PyObject *Py_UNUSED(ignored))
     return _io__WindowsConsoleIO_writable_impl(self);
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_readinto__doc__,
 "readinto($self, buffer, /)\n"
 "--\n"
@@ -171,10 +149,6 @@ exit:
     return return_value;
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_readall__doc__,
 "readall($self, /)\n"
 "--\n"
@@ -195,10 +169,6 @@ _io__WindowsConsoleIO_readall(winconsoleio *self, PyObject *Py_UNUSED(ignored))
     return _io__WindowsConsoleIO_readall_impl(self);
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_read__doc__,
 "read($self, size=-1, /)\n"
 "--\n"
@@ -210,31 +180,31 @@ PyDoc_STRVAR(_io__WindowsConsoleIO_read__doc__,
 "Return an empty bytes object at EOF.");
 
 #define _IO__WINDOWSCONSOLEIO_READ_METHODDEF    \
-    {"read", (PyCFunction)_io__WindowsConsoleIO_read, METH_VARARGS, _io__WindowsConsoleIO_read__doc__},
+    {"read", (PyCFunction)_io__WindowsConsoleIO_read, METH_FASTCALL, _io__WindowsConsoleIO_read__doc__},
 
 static PyObject *
 _io__WindowsConsoleIO_read_impl(winconsoleio *self, Py_ssize_t size);
 
 static PyObject *
-_io__WindowsConsoleIO_read(winconsoleio *self, PyObject *args)
+_io__WindowsConsoleIO_read(winconsoleio *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t size = -1;
 
-    if (!PyArg_ParseTuple(args, "|O&:read",
+    if (!_PyArg_ParseStack(args, nargs, "|O&:read",
         _PyIO_ConvertSsize_t, &size)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("read", kwnames)) {
+        goto exit;
+    }
     return_value = _io__WindowsConsoleIO_read_impl(self, size);
 
 exit:
     return return_value;
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_write__doc__,
 "write($self, b, /)\n"
 "--\n"
@@ -270,10 +240,6 @@ exit:
     return return_value;
 }
 
-#endif /* defined(MS_WINDOWS) */
-
-#if defined(MS_WINDOWS)
-
 PyDoc_STRVAR(_io__WindowsConsoleIO_isatty__doc__,
 "isatty($self, /)\n"
 "--\n"
@@ -291,42 +257,4 @@ _io__WindowsConsoleIO_isatty(winconsoleio *self, PyObject *Py_UNUSED(ignored))
 {
     return _io__WindowsConsoleIO_isatty_impl(self);
 }
-
+/*[clinic end generated code: output=b097ceeb54d6e15e input=a9049054013a1b77]*/
-#endif /* defined(MS_WINDOWS) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_CLOSE_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_CLOSE_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_CLOSE_METHODDEF) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_FILENO_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_FILENO_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_FILENO_METHODDEF) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_READABLE_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_READABLE_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_READABLE_METHODDEF) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_WRITABLE_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_WRITABLE_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_WRITABLE_METHODDEF) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_READINTO_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_READINTO_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_READINTO_METHODDEF) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_READALL_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_READALL_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_READALL_METHODDEF) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_READ_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_READ_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_READ_METHODDEF) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_WRITE_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_WRITE_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_WRITE_METHODDEF) */
-
-#ifndef _IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF
-    #define _IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF
-#endif /* !defined(_IO__WINDOWSCONSOLEIO_ISATTY_METHODDEF) */
-/*[clinic end generated code: output=9eba916f8537fff7 input=a9049054013a1b77]*/

third_party/python/Modules/_io/winconsoleio.c

@@ -1179,5 +1179,3 @@ PyTypeObject PyWindowsConsoleIO_Type = {
 };
 
 PyAPI_DATA(PyObject *) _PyWindowsConsoleIO_Type = (PyObject*)&PyWindowsConsoleIO_Type;
-
-#endif /* MS_WINDOWS */

third_party/python/Modules/audioop.c

@@ -7,6 +7,7 @@
 #define PY_SSIZE_T_CLEAN
 #include "dsp/core/core.h"
 #include "libc/math.h"
+#include "third_party/python/Include/abstract.h"
 #include "third_party/python/Include/dictobject.h"
 #include "third_party/python/Include/floatobject.h"
 #include "third_party/python/Include/import.h"

third_party/python/Modules/clinic/_asynciomodule.inc

@@ -518,4 +518,4 @@ _asyncio_Task__wakeup(TaskObj *self, PyObject **args, Py_ssize_t nargs, PyObject
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=7441872b13652085 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=1f2f5bbc35bc3c4e input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_bz2module.inc

@@ -175,4 +175,4 @@ _bz2_BZ2Decompressor___init__(PyObject *self, PyObject *args, PyObject *kwargs)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=7e57af0b368d3e55 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=0e97a1d716b35a14 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_cryptmodule.inc

@@ -15,25 +15,29 @@ PyDoc_STRVAR(crypt_crypt__doc__,
 "results for a given *word*.");
 
 #define CRYPT_CRYPT_METHODDEF    \
-    {"crypt", (PyCFunction)crypt_crypt, METH_VARARGS, crypt_crypt__doc__},
+    {"crypt", (PyCFunction)crypt_crypt, METH_FASTCALL, crypt_crypt__doc__},
 
 static PyObject *
 crypt_crypt_impl(PyObject *module, const char *word, const char *salt);
 
 static PyObject *
-crypt_crypt(PyObject *module, PyObject *args)
+crypt_crypt(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     const char *word;
     const char *salt;
 
-    if (!PyArg_ParseTuple(args, "ss:crypt",
+    if (!_PyArg_ParseStack(args, nargs, "ss:crypt",
         &word, &salt)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("crypt", kwnames)) {
+        goto exit;
+    }
     return_value = crypt_crypt_impl(module, word, salt);
 
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=8dfc88264e662df4 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=3fd5d3625a6f32fe input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_datetimemodule.inc

@@ -37,4 +37,4 @@ datetime_datetime_now(PyTypeObject *type, PyObject **args, Py_ssize_t nargs, PyO
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=8aaac0705add61ca input=a9049054013a1b77]*/
+/*[clinic end generated code: output=ff78f2f51687e9a9 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_dbmmodule.inc

@@ -46,24 +46,28 @@ PyDoc_STRVAR(_dbm_dbm_get__doc__,
 "Return the value for key if present, otherwise default.");
 
 #define _DBM_DBM_GET_METHODDEF    \
-    {"get", (PyCFunction)_dbm_dbm_get, METH_VARARGS, _dbm_dbm_get__doc__},
+    {"get", (PyCFunction)_dbm_dbm_get, METH_FASTCALL, _dbm_dbm_get__doc__},
 
 static PyObject *
 _dbm_dbm_get_impl(dbmobject *self, const char *key,
                   Py_ssize_clean_t key_length, PyObject *default_value);
 
 static PyObject *
-_dbm_dbm_get(dbmobject *self, PyObject *args)
+_dbm_dbm_get(dbmobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     const char *key;
     Py_ssize_clean_t key_length;
     PyObject *default_value = Py_None;
 
-    if (!PyArg_ParseTuple(args, "s#|O:get",
+    if (!_PyArg_ParseStack(args, nargs, "s#|O:get",
         &key, &key_length, &default_value)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("get", kwnames)) {
+        goto exit;
+    }
     return_value = _dbm_dbm_get_impl(self, key, key_length, default_value);
 
 exit:
@@ -79,7 +83,7 @@ PyDoc_STRVAR(_dbm_dbm_setdefault__doc__,
 "If key is not in the database, it is inserted with default as the value.");
 
 #define _DBM_DBM_SETDEFAULT_METHODDEF    \
-    {"setdefault", (PyCFunction)_dbm_dbm_setdefault, METH_VARARGS, _dbm_dbm_setdefault__doc__},
+    {"setdefault", (PyCFunction)_dbm_dbm_setdefault, METH_FASTCALL, _dbm_dbm_setdefault__doc__},
 
 static PyObject *
 _dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
@@ -87,17 +91,21 @@ _dbm_dbm_setdefault_impl(dbmobject *self, const char *key,
                          PyObject *default_value);
 
 static PyObject *
-_dbm_dbm_setdefault(dbmobject *self, PyObject *args)
+_dbm_dbm_setdefault(dbmobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     const char *key;
     Py_ssize_clean_t key_length;
     PyObject *default_value = NULL;
 
-    if (!PyArg_ParseTuple(args, "s#|O:setdefault",
+    if (!_PyArg_ParseStack(args, nargs, "s#|O:setdefault",
         &key, &key_length, &default_value)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("setdefault", kwnames)) {
+        goto exit;
+    }
     return_value = _dbm_dbm_setdefault_impl(self, key, key_length, default_value);
 
 exit:
@@ -119,27 +127,31 @@ PyDoc_STRVAR(dbmopen__doc__,
 "    (e.g. os.O_RDWR).");
 
 #define DBMOPEN_METHODDEF    \
-    {"open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
+    {"open", (PyCFunction)dbmopen, METH_FASTCALL, dbmopen__doc__},
 
 static PyObject *
 dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
              int mode);
 
 static PyObject *
-dbmopen(PyObject *module, PyObject *args)
+dbmopen(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *filename;
     const char *flags = "r";
     int mode = 438;
 
-    if (!PyArg_ParseTuple(args, "U|si:open",
+    if (!_PyArg_ParseStack(args, nargs, "U|si:open",
         &filename, &flags, &mode)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("open", kwnames)) {
+        goto exit;
+    }
     return_value = dbmopen_impl(module, filename, flags, mode);
 
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=919cc4337be4a5d3 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=60482e924110a70a input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_elementtree.inc

@@ -357,23 +357,27 @@ PyDoc_STRVAR(_elementtree_Element_insert__doc__,
 "\n");
 
 #define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF    \
-    {"insert", (PyCFunction)_elementtree_Element_insert, METH_VARARGS, _elementtree_Element_insert__doc__},
+    {"insert", (PyCFunction)_elementtree_Element_insert, METH_FASTCALL, _elementtree_Element_insert__doc__},
 
 static PyObject *
 _elementtree_Element_insert_impl(ElementObject *self, Py_ssize_t index,
                                  PyObject *subelement);
 
 static PyObject *
-_elementtree_Element_insert(ElementObject *self, PyObject *args)
+_elementtree_Element_insert(ElementObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t index;
     PyObject *subelement;
 
-    if (!PyArg_ParseTuple(args, "nO!:insert",
+    if (!_PyArg_ParseStack(args, nargs, "nO!:insert",
         &index, &Element_Type, &subelement)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("insert", kwnames)) {
+        goto exit;
+    }
     return_value = _elementtree_Element_insert_impl(self, index, subelement);
 
 exit:
@@ -703,4 +707,4 @@ _elementtree_XMLParser__setevents(XMLParserObject *self, PyObject *args)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=b4a571a98ced3163 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=4e3d22c6f6d832b2 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_gdbmmodule.inc

@@ -232,27 +232,31 @@ PyDoc_STRVAR(dbmopen__doc__,
 "when the database has to be created.  It defaults to octal 0o666.");
 
 #define DBMOPEN_METHODDEF    \
-    {"open", (PyCFunction)dbmopen, METH_VARARGS, dbmopen__doc__},
+    {"open", (PyCFunction)dbmopen, METH_FASTCALL, dbmopen__doc__},
 
 static PyObject *
 dbmopen_impl(PyObject *module, PyObject *filename, const char *flags,
              int mode);
 
 static PyObject *
-dbmopen(PyObject *module, PyObject *args)
+dbmopen(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *filename;
     const char *flags = "r";
     int mode = 438;
 
-    if (!PyArg_ParseTuple(args, "U|si:open",
+    if (!_PyArg_ParseStack(args, nargs, "U|si:open",
         &filename, &flags, &mode)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("open", kwnames)) {
+        goto exit;
+    }
     return_value = dbmopen_impl(module, filename, flags, mode);
 
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=afb99364ac420d10 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=16874d4acd7e7749 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_lzmamodule.inc

@@ -230,23 +230,27 @@ PyDoc_STRVAR(_lzma__decode_filter_properties__doc__,
 "The result does not include the filter ID itself, only the options.");
 
 #define _LZMA__DECODE_FILTER_PROPERTIES_METHODDEF    \
-    {"_decode_filter_properties", (PyCFunction)_lzma__decode_filter_properties, METH_VARARGS, _lzma__decode_filter_properties__doc__},
+    {"_decode_filter_properties", (PyCFunction)_lzma__decode_filter_properties, METH_FASTCALL, _lzma__decode_filter_properties__doc__},
 
 static PyObject *
 _lzma__decode_filter_properties_impl(PyObject *module, lzma_vli filter_id,
                                      Py_buffer *encoded_props);
 
 static PyObject *
-_lzma__decode_filter_properties(PyObject *module, PyObject *args)
+_lzma__decode_filter_properties(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     lzma_vli filter_id;
     Py_buffer encoded_props = {NULL, NULL};
 
-    if (!PyArg_ParseTuple(args, "O&y*:_decode_filter_properties",
+    if (!_PyArg_ParseStack(args, nargs, "O&y*:_decode_filter_properties",
         lzma_vli_converter, &filter_id, &encoded_props)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("_decode_filter_properties", kwnames)) {
+        goto exit;
+    }
     return_value = _lzma__decode_filter_properties_impl(module, filter_id, &encoded_props);
 
 exit:
@@ -257,4 +261,4 @@ exit:
 
     return return_value;
 }
-/*[clinic end generated code: output=f27abae460122706 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5f7a915fb7e41453 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_opcode.inc

@@ -10,23 +10,27 @@ PyDoc_STRVAR(_opcode_stack_effect__doc__,
 "Compute the stack effect of the opcode.");
 
 #define _OPCODE_STACK_EFFECT_METHODDEF    \
-    {"stack_effect", (PyCFunction)_opcode_stack_effect, METH_VARARGS, _opcode_stack_effect__doc__},
+    {"stack_effect", (PyCFunction)_opcode_stack_effect, METH_FASTCALL, _opcode_stack_effect__doc__},
 
 static int
 _opcode_stack_effect_impl(PyObject *module, int opcode, PyObject *oparg);
 
 static PyObject *
-_opcode_stack_effect(PyObject *module, PyObject *args)
+_opcode_stack_effect(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int opcode;
     PyObject *oparg = Py_None;
     int _return_value;
 
-    if (!PyArg_ParseTuple(args, "i|O:stack_effect",
+    if (!_PyArg_ParseStack(args, nargs, "i|O:stack_effect",
         &opcode, &oparg)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("stack_effect", kwnames)) {
+        goto exit;
+    }
     _return_value = _opcode_stack_effect_impl(module, opcode, oparg);
     if ((_return_value == -1) && PyErr_Occurred()) {
         goto exit;
@@ -36,4 +40,4 @@ _opcode_stack_effect(PyObject *module, PyObject *args)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=4d91c6a765097853 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=62858005ac85baa9 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_pickle.inc

@@ -561,4 +561,4 @@ _pickle_loads(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=82be137b3c09cb9f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d7222d1219039fbd input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_sre.inc

@@ -36,23 +36,27 @@ PyDoc_STRVAR(_sre_getlower__doc__,
 "\n");
 
 #define _SRE_GETLOWER_METHODDEF    \
-    {"getlower", (PyCFunction)_sre_getlower, METH_VARARGS, _sre_getlower__doc__},
+    {"getlower", (PyCFunction)_sre_getlower, METH_FASTCALL, _sre_getlower__doc__},
 
 static int
 _sre_getlower_impl(PyObject *module, int character, int flags);
 
 static PyObject *
-_sre_getlower(PyObject *module, PyObject *args)
+_sre_getlower(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int character;
     int flags;
     int _return_value;
 
-    if (!PyArg_ParseTuple(args, "ii:getlower",
+    if (!_PyArg_ParseStack(args, nargs, "ii:getlower",
         &character, &flags)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("getlower", kwnames)) {
+        goto exit;
+    }
     _return_value = _sre_getlower_impl(module, character, flags);
     if ((_return_value == -1) && PyErr_Occurred()) {
         goto exit;
@@ -729,4 +733,4 @@ _sre_SRE_Scanner_search(ScannerObject *self, PyObject *Py_UNUSED(ignored))
 {
     return _sre_SRE_Scanner_search_impl(self);
 }
-/*[clinic end generated code: output=a4a246bca1963bc9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b347a5bd7e21cfd4 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/_weakref.inc

@@ -38,26 +38,30 @@ PyDoc_STRVAR(_weakref__remove_dead_weakref__doc__,
 "Atomically remove key from dict if it points to a dead weakref.");
 
 #define _WEAKREF__REMOVE_DEAD_WEAKREF_METHODDEF    \
-    {"_remove_dead_weakref", (PyCFunction)_weakref__remove_dead_weakref, METH_VARARGS, _weakref__remove_dead_weakref__doc__},
+    {"_remove_dead_weakref", (PyCFunction)_weakref__remove_dead_weakref, METH_FASTCALL, _weakref__remove_dead_weakref__doc__},
 
 static PyObject *
 _weakref__remove_dead_weakref_impl(PyObject *module, PyObject *dct,
                                    PyObject *key);
 
 static PyObject *
-_weakref__remove_dead_weakref(PyObject *module, PyObject *args)
+_weakref__remove_dead_weakref(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *dct;
     PyObject *key;
 
-    if (!PyArg_ParseTuple(args, "O!O:_remove_dead_weakref",
+    if (!_PyArg_ParseStack(args, nargs, "O!O:_remove_dead_weakref",
         &PyDict_Type, &dct, &key)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("_remove_dead_weakref", kwnames)) {
+        goto exit;
+    }
     return_value = _weakref__remove_dead_weakref_impl(module, dct, key);
 
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=e860dd818a44bc9b input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b686303486bdfefd input=a9049054013a1b77]*/

third_party/python/Modules/clinic/arraymodule.inc

@@ -66,21 +66,25 @@ PyDoc_STRVAR(array_array_pop__doc__,
 "i defaults to -1.");
 
 #define ARRAY_ARRAY_POP_METHODDEF    \
-    {"pop", (PyCFunction)array_array_pop, METH_VARARGS, array_array_pop__doc__},
+    {"pop", (PyCFunction)array_array_pop, METH_FASTCALL, array_array_pop__doc__},
 
 static PyObject *
 array_array_pop_impl(arrayobject *self, Py_ssize_t i);
 
 static PyObject *
-array_array_pop(arrayobject *self, PyObject *args)
+array_array_pop(arrayobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t i = -1;
 
-    if (!PyArg_ParseTuple(args, "|n:pop",
+    if (!_PyArg_ParseStack(args, nargs, "|n:pop",
         &i)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("pop", kwnames)) {
+        goto exit;
+    }
     return_value = array_array_pop_impl(self, i);
 
 exit:
@@ -103,22 +107,26 @@ PyDoc_STRVAR(array_array_insert__doc__,
 "Insert a new item v into the array before position i.");
 
 #define ARRAY_ARRAY_INSERT_METHODDEF    \
-    {"insert", (PyCFunction)array_array_insert, METH_VARARGS, array_array_insert__doc__},
+    {"insert", (PyCFunction)array_array_insert, METH_FASTCALL, array_array_insert__doc__},
 
 static PyObject *
 array_array_insert_impl(arrayobject *self, Py_ssize_t i, PyObject *v);
 
 static PyObject *
-array_array_insert(arrayobject *self, PyObject *args)
+array_array_insert(arrayobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t i;
     PyObject *v;
 
-    if (!PyArg_ParseTuple(args, "nO:insert",
+    if (!_PyArg_ParseStack(args, nargs, "nO:insert",
         &i, &v)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("insert", kwnames)) {
+        goto exit;
+    }
     return_value = array_array_insert_impl(self, i, v);
 
 exit:
@@ -201,22 +209,26 @@ PyDoc_STRVAR(array_array_fromfile__doc__,
 "Read n objects from the file object f and append them to the end of the array.");
 
 #define ARRAY_ARRAY_FROMFILE_METHODDEF    \
-    {"fromfile", (PyCFunction)array_array_fromfile, METH_VARARGS, array_array_fromfile__doc__},
+    {"fromfile", (PyCFunction)array_array_fromfile, METH_FASTCALL, array_array_fromfile__doc__},
 
 static PyObject *
 array_array_fromfile_impl(arrayobject *self, PyObject *f, Py_ssize_t n);
 
 static PyObject *
-array_array_fromfile(arrayobject *self, PyObject *args)
+array_array_fromfile(arrayobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *f;
     Py_ssize_t n;
 
-    if (!PyArg_ParseTuple(args, "On:fromfile",
+    if (!_PyArg_ParseStack(args, nargs, "On:fromfile",
         &f, &n)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("fromfile", kwnames)) {
+        goto exit;
+    }
     return_value = array_array_fromfile_impl(self, f, n);
 
 exit:
@@ -444,7 +456,7 @@ PyDoc_STRVAR(array__array_reconstructor__doc__,
 "Internal. Used for pickling support.");
 
 #define ARRAY__ARRAY_RECONSTRUCTOR_METHODDEF    \
-    {"_array_reconstructor", (PyCFunction)array__array_reconstructor, METH_VARARGS, array__array_reconstructor__doc__},
+    {"_array_reconstructor", (PyCFunction)array__array_reconstructor, METH_FASTCALL, array__array_reconstructor__doc__},
 
 static PyObject *
 array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype,
@@ -453,7 +465,7 @@ array__array_reconstructor_impl(PyObject *module, PyTypeObject *arraytype,
                                 PyObject *items);
 
 static PyObject *
-array__array_reconstructor(PyObject *module, PyObject *args)
+array__array_reconstructor(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyTypeObject *arraytype;
@@ -461,10 +473,14 @@ array__array_reconstructor(PyObject *module, PyObject *args)
     enum machine_format_code mformat_code;
     PyObject *items;
 
-    if (!PyArg_ParseTuple(args, "OCiO:_array_reconstructor",
+    if (!_PyArg_ParseStack(args, nargs, "OCiO:_array_reconstructor",
         &arraytype, &typecode, &mformat_code, &items)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("_array_reconstructor", kwnames)) {
+        goto exit;
+    }
     return_value = array__array_reconstructor_impl(module, arraytype, typecode, mformat_code, items);
 
 exit:
@@ -506,4 +522,4 @@ PyDoc_STRVAR(array_arrayiterator___setstate____doc__,
 
 #define ARRAY_ARRAYITERATOR___SETSTATE___METHODDEF    \
     {"__setstate__", (PyCFunction)array_arrayiterator___setstate__, METH_O, array_arrayiterator___setstate____doc__},
-/*[clinic end generated code: output=b2054fb764c8cc64 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=d186a7553c1f1a41 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/audioop.inc

@@ -1,8 +1,6 @@
-/* clang-format off */
 /*[clinic input]
 preserve
 [clinic start generated code]*/
-#include "third_party/python/Include/abstract.h"
 
 PyDoc_STRVAR(audioop_getsample__doc__,
 "getsample($module, fragment, width, index, /)\n"
@@ -11,24 +9,28 @@ PyDoc_STRVAR(audioop_getsample__doc__,
 "Return the value of sample index from the fragment.");
 
 #define AUDIOOP_GETSAMPLE_METHODDEF    \
-    {"getsample", (PyCFunction)audioop_getsample, METH_VARARGS, audioop_getsample__doc__},
+    {"getsample", (PyCFunction)audioop_getsample, METH_FASTCALL, audioop_getsample__doc__},
 
 static PyObject *
 audioop_getsample_impl(PyObject *module, Py_buffer *fragment, int width,
                        Py_ssize_t index);
 
 static PyObject *
-audioop_getsample(PyObject *module, PyObject *args)
+audioop_getsample(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
     Py_ssize_t index;
 
-    if (!PyArg_ParseTuple(args, "y*in:getsample",
+    if (!_PyArg_ParseStack(args, nargs, "y*in:getsample",
         &fragment, &width, &index)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("getsample", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_getsample_impl(module, &fragment, width, index);
 
 exit:
@@ -47,22 +49,26 @@ PyDoc_STRVAR(audioop_max__doc__,
 "Return the maximum of the absolute value of all samples in a fragment.");
 
 #define AUDIOOP_MAX_METHODDEF    \
-    {"max", (PyCFunction)audioop_max, METH_VARARGS, audioop_max__doc__},
+    {"max", (PyCFunction)audioop_max, METH_FASTCALL, audioop_max__doc__},
 
 static PyObject *
 audioop_max_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_max(PyObject *module, PyObject *args)
+audioop_max(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:max",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:max",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("max", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_max_impl(module, &fragment, width);
 
 exit:
@@ -81,22 +87,26 @@ PyDoc_STRVAR(audioop_minmax__doc__,
 "Return the minimum and maximum values of all samples in the sound fragment.");
 
 #define AUDIOOP_MINMAX_METHODDEF    \
-    {"minmax", (PyCFunction)audioop_minmax, METH_VARARGS, audioop_minmax__doc__},
+    {"minmax", (PyCFunction)audioop_minmax, METH_FASTCALL, audioop_minmax__doc__},
 
 static PyObject *
 audioop_minmax_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_minmax(PyObject *module, PyObject *args)
+audioop_minmax(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:minmax",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:minmax",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("minmax", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_minmax_impl(module, &fragment, width);
 
 exit:
@@ -115,22 +125,26 @@ PyDoc_STRVAR(audioop_avg__doc__,
 "Return the average over all samples in the fragment.");
 
 #define AUDIOOP_AVG_METHODDEF    \
-    {"avg", (PyCFunction)audioop_avg, METH_VARARGS, audioop_avg__doc__},
+    {"avg", (PyCFunction)audioop_avg, METH_FASTCALL, audioop_avg__doc__},
 
 static PyObject *
 audioop_avg_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_avg(PyObject *module, PyObject *args)
+audioop_avg(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:avg",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:avg",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("avg", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_avg_impl(module, &fragment, width);
 
 exit:
@@ -149,22 +163,26 @@ PyDoc_STRVAR(audioop_rms__doc__,
 "Return the root-mean-square of the fragment, i.e. sqrt(sum(S_i^2)/n).");
 
 #define AUDIOOP_RMS_METHODDEF    \
-    {"rms", (PyCFunction)audioop_rms, METH_VARARGS, audioop_rms__doc__},
+    {"rms", (PyCFunction)audioop_rms, METH_FASTCALL, audioop_rms__doc__},
 
 static PyObject *
 audioop_rms_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_rms(PyObject *module, PyObject *args)
+audioop_rms(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:rms",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:rms",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("rms", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_rms_impl(module, &fragment, width);
 
 exit:
@@ -183,23 +201,27 @@ PyDoc_STRVAR(audioop_findfit__doc__,
 "Try to match reference as well as possible to a portion of fragment.");
 
 #define AUDIOOP_FINDFIT_METHODDEF    \
-    {"findfit", (PyCFunction)audioop_findfit, METH_VARARGS, audioop_findfit__doc__},
+    {"findfit", (PyCFunction)audioop_findfit, METH_FASTCALL, audioop_findfit__doc__},
 
 static PyObject *
 audioop_findfit_impl(PyObject *module, Py_buffer *fragment,
                      Py_buffer *reference);
 
 static PyObject *
-audioop_findfit(PyObject *module, PyObject *args)
+audioop_findfit(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     Py_buffer reference = {NULL, NULL};
 
-    if (!PyArg_ParseTuple(args, "y*y*:findfit",
+    if (!_PyArg_ParseStack(args, nargs, "y*y*:findfit",
         &fragment, &reference)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("findfit", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_findfit_impl(module, &fragment, &reference);
 
 exit:
@@ -222,23 +244,27 @@ PyDoc_STRVAR(audioop_findfactor__doc__,
 "Return a factor F such that rms(add(fragment, mul(reference, -F))) is minimal.");
 
 #define AUDIOOP_FINDFACTOR_METHODDEF    \
-    {"findfactor", (PyCFunction)audioop_findfactor, METH_VARARGS, audioop_findfactor__doc__},
+    {"findfactor", (PyCFunction)audioop_findfactor, METH_FASTCALL, audioop_findfactor__doc__},
 
 static PyObject *
 audioop_findfactor_impl(PyObject *module, Py_buffer *fragment,
                         Py_buffer *reference);
 
 static PyObject *
-audioop_findfactor(PyObject *module, PyObject *args)
+audioop_findfactor(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     Py_buffer reference = {NULL, NULL};
 
-    if (!PyArg_ParseTuple(args, "y*y*:findfactor",
+    if (!_PyArg_ParseStack(args, nargs, "y*y*:findfactor",
         &fragment, &reference)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("findfactor", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_findfactor_impl(module, &fragment, &reference);
 
 exit:
@@ -261,23 +287,27 @@ PyDoc_STRVAR(audioop_findmax__doc__,
 "Search fragment for a slice of specified number of samples with maximum energy.");
 
 #define AUDIOOP_FINDMAX_METHODDEF    \
-    {"findmax", (PyCFunction)audioop_findmax, METH_VARARGS, audioop_findmax__doc__},
+    {"findmax", (PyCFunction)audioop_findmax, METH_FASTCALL, audioop_findmax__doc__},
 
 static PyObject *
 audioop_findmax_impl(PyObject *module, Py_buffer *fragment,
                      Py_ssize_t length);
 
 static PyObject *
-audioop_findmax(PyObject *module, PyObject *args)
+audioop_findmax(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     Py_ssize_t length;
 
-    if (!PyArg_ParseTuple(args, "y*n:findmax",
+    if (!_PyArg_ParseStack(args, nargs, "y*n:findmax",
         &fragment, &length)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("findmax", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_findmax_impl(module, &fragment, length);
 
 exit:
@@ -296,22 +326,26 @@ PyDoc_STRVAR(audioop_avgpp__doc__,
 "Return the average peak-peak value over all samples in the fragment.");
 
 #define AUDIOOP_AVGPP_METHODDEF    \
-    {"avgpp", (PyCFunction)audioop_avgpp, METH_VARARGS, audioop_avgpp__doc__},
+    {"avgpp", (PyCFunction)audioop_avgpp, METH_FASTCALL, audioop_avgpp__doc__},
 
 static PyObject *
 audioop_avgpp_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_avgpp(PyObject *module, PyObject *args)
+audioop_avgpp(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:avgpp",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:avgpp",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("avgpp", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_avgpp_impl(module, &fragment, width);
 
 exit:
@@ -330,22 +364,26 @@ PyDoc_STRVAR(audioop_maxpp__doc__,
 "Return the maximum peak-peak value in the sound fragment.");
 
 #define AUDIOOP_MAXPP_METHODDEF    \
-    {"maxpp", (PyCFunction)audioop_maxpp, METH_VARARGS, audioop_maxpp__doc__},
+    {"maxpp", (PyCFunction)audioop_maxpp, METH_FASTCALL, audioop_maxpp__doc__},
 
 static PyObject *
 audioop_maxpp_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_maxpp(PyObject *module, PyObject *args)
+audioop_maxpp(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:maxpp",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:maxpp",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("maxpp", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_maxpp_impl(module, &fragment, width);
 
 exit:
@@ -364,22 +402,26 @@ PyDoc_STRVAR(audioop_cross__doc__,
 "Return the number of zero crossings in the fragment passed as an argument.");
 
 #define AUDIOOP_CROSS_METHODDEF    \
-    {"cross", (PyCFunction)audioop_cross, METH_VARARGS, audioop_cross__doc__},
+    {"cross", (PyCFunction)audioop_cross, METH_FASTCALL, audioop_cross__doc__},
 
 static PyObject *
 audioop_cross_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_cross(PyObject *module, PyObject *args)
+audioop_cross(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:cross",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:cross",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("cross", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_cross_impl(module, &fragment, width);
 
 exit:
@@ -398,24 +440,28 @@ PyDoc_STRVAR(audioop_mul__doc__,
 "Return a fragment that has all samples in the original fragment multiplied by the floating-point value factor.");
 
 #define AUDIOOP_MUL_METHODDEF    \
-    {"mul", (PyCFunction)audioop_mul, METH_VARARGS, audioop_mul__doc__},
+    {"mul", (PyCFunction)audioop_mul, METH_FASTCALL, audioop_mul__doc__},
 
 static PyObject *
 audioop_mul_impl(PyObject *module, Py_buffer *fragment, int width,
                  double factor);
 
 static PyObject *
-audioop_mul(PyObject *module, PyObject *args)
+audioop_mul(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
     double factor;
 
-    if (!PyArg_ParseTuple(args, "y*id:mul",
+    if (!_PyArg_ParseStack(args, nargs, "y*id:mul",
         &fragment, &width, &factor)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("mul", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_mul_impl(module, &fragment, width, factor);
 
 exit:
@@ -434,14 +480,14 @@ PyDoc_STRVAR(audioop_tomono__doc__,
 "Convert a stereo fragment to a mono fragment.");
 
 #define AUDIOOP_TOMONO_METHODDEF    \
-    {"tomono", (PyCFunction)audioop_tomono, METH_VARARGS, audioop_tomono__doc__},
+    {"tomono", (PyCFunction)audioop_tomono, METH_FASTCALL, audioop_tomono__doc__},
 
 static PyObject *
 audioop_tomono_impl(PyObject *module, Py_buffer *fragment, int width,
                     double lfactor, double rfactor);
 
 static PyObject *
-audioop_tomono(PyObject *module, PyObject *args)
+audioop_tomono(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
@@ -449,10 +495,14 @@ audioop_tomono(PyObject *module, PyObject *args)
     double lfactor;
     double rfactor;
 
-    if (!PyArg_ParseTuple(args, "y*idd:tomono",
+    if (!_PyArg_ParseStack(args, nargs, "y*idd:tomono",
         &fragment, &width, &lfactor, &rfactor)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("tomono", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_tomono_impl(module, &fragment, width, lfactor, rfactor);
 
 exit:
@@ -471,14 +521,14 @@ PyDoc_STRVAR(audioop_tostereo__doc__,
 "Generate a stereo fragment from a mono fragment.");
 
 #define AUDIOOP_TOSTEREO_METHODDEF    \
-    {"tostereo", (PyCFunction)audioop_tostereo, METH_VARARGS, audioop_tostereo__doc__},
+    {"tostereo", (PyCFunction)audioop_tostereo, METH_FASTCALL, audioop_tostereo__doc__},
 
 static PyObject *
 audioop_tostereo_impl(PyObject *module, Py_buffer *fragment, int width,
                       double lfactor, double rfactor);
 
 static PyObject *
-audioop_tostereo(PyObject *module, PyObject *args)
+audioop_tostereo(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
@@ -486,10 +536,14 @@ audioop_tostereo(PyObject *module, PyObject *args)
     double lfactor;
     double rfactor;
 
-    if (!PyArg_ParseTuple(args, "y*idd:tostereo",
+    if (!_PyArg_ParseStack(args, nargs, "y*idd:tostereo",
         &fragment, &width, &lfactor, &rfactor)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("tostereo", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_tostereo_impl(module, &fragment, width, lfactor, rfactor);
 
 exit:
@@ -508,24 +562,28 @@ PyDoc_STRVAR(audioop_add__doc__,
 "Return a fragment which is the addition of the two samples passed as parameters.");
 
 #define AUDIOOP_ADD_METHODDEF    \
-    {"add", (PyCFunction)audioop_add, METH_VARARGS, audioop_add__doc__},
+    {"add", (PyCFunction)audioop_add, METH_FASTCALL, audioop_add__doc__},
 
 static PyObject *
 audioop_add_impl(PyObject *module, Py_buffer *fragment1,
                  Py_buffer *fragment2, int width);
 
 static PyObject *
-audioop_add(PyObject *module, PyObject *args)
+audioop_add(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment1 = {NULL, NULL};
     Py_buffer fragment2 = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*y*i:add",
+    if (!_PyArg_ParseStack(args, nargs, "y*y*i:add",
         &fragment1, &fragment2, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("add", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_add_impl(module, &fragment1, &fragment2, width);
 
 exit:
@@ -548,23 +606,27 @@ PyDoc_STRVAR(audioop_bias__doc__,
 "Return a fragment that is the original fragment with a bias added to each sample.");
 
 #define AUDIOOP_BIAS_METHODDEF    \
-    {"bias", (PyCFunction)audioop_bias, METH_VARARGS, audioop_bias__doc__},
+    {"bias", (PyCFunction)audioop_bias, METH_FASTCALL, audioop_bias__doc__},
 
 static PyObject *
 audioop_bias_impl(PyObject *module, Py_buffer *fragment, int width, int bias);
 
 static PyObject *
-audioop_bias(PyObject *module, PyObject *args)
+audioop_bias(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
     int bias;
 
-    if (!PyArg_ParseTuple(args, "y*ii:bias",
+    if (!_PyArg_ParseStack(args, nargs, "y*ii:bias",
         &fragment, &width, &bias)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("bias", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_bias_impl(module, &fragment, width, bias);
 
 exit:
@@ -583,22 +645,26 @@ PyDoc_STRVAR(audioop_reverse__doc__,
 "Reverse the samples in a fragment and returns the modified fragment.");
 
 #define AUDIOOP_REVERSE_METHODDEF    \
-    {"reverse", (PyCFunction)audioop_reverse, METH_VARARGS, audioop_reverse__doc__},
+    {"reverse", (PyCFunction)audioop_reverse, METH_FASTCALL, audioop_reverse__doc__},
 
 static PyObject *
 audioop_reverse_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_reverse(PyObject *module, PyObject *args)
+audioop_reverse(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:reverse",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:reverse",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("reverse", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_reverse_impl(module, &fragment, width);
 
 exit:
@@ -617,22 +683,26 @@ PyDoc_STRVAR(audioop_byteswap__doc__,
 "Convert big-endian samples to little-endian and vice versa.");
 
 #define AUDIOOP_BYTESWAP_METHODDEF    \
-    {"byteswap", (PyCFunction)audioop_byteswap, METH_VARARGS, audioop_byteswap__doc__},
+    {"byteswap", (PyCFunction)audioop_byteswap, METH_FASTCALL, audioop_byteswap__doc__},
 
 static PyObject *
 audioop_byteswap_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_byteswap(PyObject *module, PyObject *args)
+audioop_byteswap(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:byteswap",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:byteswap",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("byteswap", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_byteswap_impl(module, &fragment, width);
 
 exit:
@@ -651,24 +721,28 @@ PyDoc_STRVAR(audioop_lin2lin__doc__,
 "Convert samples between 1-, 2-, 3- and 4-byte formats.");
 
 #define AUDIOOP_LIN2LIN_METHODDEF    \
-    {"lin2lin", (PyCFunction)audioop_lin2lin, METH_VARARGS, audioop_lin2lin__doc__},
+    {"lin2lin", (PyCFunction)audioop_lin2lin, METH_FASTCALL, audioop_lin2lin__doc__},
 
 static PyObject *
 audioop_lin2lin_impl(PyObject *module, Py_buffer *fragment, int width,
                      int newwidth);
 
 static PyObject *
-audioop_lin2lin(PyObject *module, PyObject *args)
+audioop_lin2lin(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
     int newwidth;
 
-    if (!PyArg_ParseTuple(args, "y*ii:lin2lin",
+    if (!_PyArg_ParseStack(args, nargs, "y*ii:lin2lin",
         &fragment, &width, &newwidth)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("lin2lin", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_lin2lin_impl(module, &fragment, width, newwidth);
 
 exit:
@@ -688,7 +762,7 @@ PyDoc_STRVAR(audioop_ratecv__doc__,
 "Convert the frame rate of the input fragment.");
 
 #define AUDIOOP_RATECV_METHODDEF    \
-    {"ratecv", (PyCFunction)audioop_ratecv, METH_VARARGS, audioop_ratecv__doc__},
+    {"ratecv", (PyCFunction)audioop_ratecv, METH_FASTCALL, audioop_ratecv__doc__},
 
 static PyObject *
 audioop_ratecv_impl(PyObject *module, Py_buffer *fragment, int width,
@@ -696,7 +770,7 @@ audioop_ratecv_impl(PyObject *module, Py_buffer *fragment, int width,
                     int weightA, int weightB);
 
 static PyObject *
-audioop_ratecv(PyObject *module, PyObject *args)
+audioop_ratecv(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
@@ -708,10 +782,14 @@ audioop_ratecv(PyObject *module, PyObject *args)
     int weightA = 1;
     int weightB = 0;
 
-    if (!PyArg_ParseTuple(args, "y*iiiiO|ii:ratecv",
+    if (!_PyArg_ParseStack(args, nargs, "y*iiiiO|ii:ratecv",
         &fragment, &width, &nchannels, &inrate, &outrate, &state, &weightA, &weightB)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("ratecv", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_ratecv_impl(module, &fragment, width, nchannels, inrate, outrate, state, weightA, weightB);
 
 exit:
@@ -730,22 +808,26 @@ PyDoc_STRVAR(audioop_lin2ulaw__doc__,
 "Convert samples in the audio fragment to u-LAW encoding.");
 
 #define AUDIOOP_LIN2ULAW_METHODDEF    \
-    {"lin2ulaw", (PyCFunction)audioop_lin2ulaw, METH_VARARGS, audioop_lin2ulaw__doc__},
+    {"lin2ulaw", (PyCFunction)audioop_lin2ulaw, METH_FASTCALL, audioop_lin2ulaw__doc__},
 
 static PyObject *
 audioop_lin2ulaw_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_lin2ulaw(PyObject *module, PyObject *args)
+audioop_lin2ulaw(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:lin2ulaw",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:lin2ulaw",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("lin2ulaw", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_lin2ulaw_impl(module, &fragment, width);
 
 exit:
@@ -764,22 +846,26 @@ PyDoc_STRVAR(audioop_ulaw2lin__doc__,
 "Convert sound fragments in u-LAW encoding to linearly encoded sound fragments.");
 
 #define AUDIOOP_ULAW2LIN_METHODDEF    \
-    {"ulaw2lin", (PyCFunction)audioop_ulaw2lin, METH_VARARGS, audioop_ulaw2lin__doc__},
+    {"ulaw2lin", (PyCFunction)audioop_ulaw2lin, METH_FASTCALL, audioop_ulaw2lin__doc__},
 
 static PyObject *
 audioop_ulaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_ulaw2lin(PyObject *module, PyObject *args)
+audioop_ulaw2lin(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:ulaw2lin",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:ulaw2lin",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("ulaw2lin", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_ulaw2lin_impl(module, &fragment, width);
 
 exit:
@@ -798,22 +884,26 @@ PyDoc_STRVAR(audioop_lin2alaw__doc__,
 "Convert samples in the audio fragment to a-LAW encoding.");
 
 #define AUDIOOP_LIN2ALAW_METHODDEF    \
-    {"lin2alaw", (PyCFunction)audioop_lin2alaw, METH_VARARGS, audioop_lin2alaw__doc__},
+    {"lin2alaw", (PyCFunction)audioop_lin2alaw, METH_FASTCALL, audioop_lin2alaw__doc__},
 
 static PyObject *
 audioop_lin2alaw_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_lin2alaw(PyObject *module, PyObject *args)
+audioop_lin2alaw(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
 
-    if (!PyArg_ParseTuple(args, "y*i:lin2alaw",
+    if (!_PyArg_ParseStack(args, nargs, "y*i:lin2alaw",
         &fragment, &width)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("lin2alaw", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_lin2alaw_impl(module, &fragment, width);
 
 exit:
@@ -832,26 +922,34 @@ PyDoc_STRVAR(audioop_alaw2lin__doc__,
 "Convert sound fragments in a-LAW encoding to linearly encoded sound fragments.");
 
 #define AUDIOOP_ALAW2LIN_METHODDEF    \
-    {"alaw2lin", (PyCFunction)audioop_alaw2lin, METH_VARARGS, audioop_alaw2lin__doc__},
+    {"alaw2lin", (PyCFunction)audioop_alaw2lin, METH_FASTCALL, audioop_alaw2lin__doc__},
 
 static PyObject *
 audioop_alaw2lin_impl(PyObject *module, Py_buffer *fragment, int width);
 
 static PyObject *
-audioop_alaw2lin(PyObject *module, PyObject *args)
+audioop_alaw2lin(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
-    if (!PyArg_ParseTuple(args, "y*i:alaw2lin", &fragment, &width)) {
+
+    if (!_PyArg_ParseStack(args, nargs, "y*i:alaw2lin",
+        &fragment, &width)) {
+        goto exit;
+    }
+
+    if (!_PyArg_NoStackKeywords("alaw2lin", kwnames)) {
         goto exit;
     }
     return_value = audioop_alaw2lin_impl(module, &fragment, width);
+
 exit:
     /* Cleanup for fragment */
     if (fragment.obj) {
        PyBuffer_Release(&fragment);
     }
+
     return return_value;
 }
 
@@ -862,24 +960,28 @@ PyDoc_STRVAR(audioop_lin2adpcm__doc__,
 "Convert samples to 4 bit Intel/DVI ADPCM encoding.");
 
 #define AUDIOOP_LIN2ADPCM_METHODDEF    \
-    {"lin2adpcm", (PyCFunction)audioop_lin2adpcm, METH_VARARGS, audioop_lin2adpcm__doc__},
+    {"lin2adpcm", (PyCFunction)audioop_lin2adpcm, METH_FASTCALL, audioop_lin2adpcm__doc__},
 
 static PyObject *
 audioop_lin2adpcm_impl(PyObject *module, Py_buffer *fragment, int width,
                        PyObject *state);
 
 static PyObject *
-audioop_lin2adpcm(PyObject *module, PyObject *args)
+audioop_lin2adpcm(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
     PyObject *state;
 
-    if (!PyArg_ParseTuple(args, "y*iO:lin2adpcm",
+    if (!_PyArg_ParseStack(args, nargs, "y*iO:lin2adpcm",
         &fragment, &width, &state)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("lin2adpcm", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_lin2adpcm_impl(module, &fragment, width, state);
 
 exit:
@@ -898,24 +1000,28 @@ PyDoc_STRVAR(audioop_adpcm2lin__doc__,
 "Decode an Intel/DVI ADPCM coded fragment to a linear fragment.");
 
 #define AUDIOOP_ADPCM2LIN_METHODDEF    \
-    {"adpcm2lin", (PyCFunction)audioop_adpcm2lin, METH_VARARGS, audioop_adpcm2lin__doc__},
+    {"adpcm2lin", (PyCFunction)audioop_adpcm2lin, METH_FASTCALL, audioop_adpcm2lin__doc__},
 
 static PyObject *
 audioop_adpcm2lin_impl(PyObject *module, Py_buffer *fragment, int width,
                        PyObject *state);
 
 static PyObject *
-audioop_adpcm2lin(PyObject *module, PyObject *args)
+audioop_adpcm2lin(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer fragment = {NULL, NULL};
     int width;
     PyObject *state;
 
-    if (!PyArg_ParseTuple(args, "y*iO:adpcm2lin",
+    if (!_PyArg_ParseStack(args, nargs, "y*iO:adpcm2lin",
         &fragment, &width, &state)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("adpcm2lin", kwnames)) {
+        goto exit;
+    }
     return_value = audioop_adpcm2lin_impl(module, &fragment, width, state);
 
 exit:
@@ -926,4 +1032,4 @@ exit:
 
     return return_value;
 }
-/*[clinic end generated code: output=e0ab74c3fa57c39c input=a9049054013a1b77]*/
+/*[clinic end generated code: output=ee7c63ec28a11b78 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/binascii.inc

@@ -267,23 +267,27 @@ PyDoc_STRVAR(binascii_crc_hqx__doc__,
 "Compute CRC-CCITT incrementally.");
 
 #define BINASCII_CRC_HQX_METHODDEF    \
-    {"crc_hqx", (PyCFunction)binascii_crc_hqx, METH_VARARGS, binascii_crc_hqx__doc__},
+    {"crc_hqx", (PyCFunction)binascii_crc_hqx, METH_FASTCALL, binascii_crc_hqx__doc__},
 
 static unsigned int
 binascii_crc_hqx_impl(PyObject *module, Py_buffer *data, unsigned int crc);
 
 static PyObject *
-binascii_crc_hqx(PyObject *module, PyObject *args)
+binascii_crc_hqx(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer data = {NULL, NULL};
     unsigned int crc;
     unsigned int _return_value;
 
-    if (!PyArg_ParseTuple(args, "y*I:crc_hqx",
+    if (!_PyArg_ParseStack(args, nargs, "y*I:crc_hqx",
         &data, &crc)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("crc_hqx", kwnames)) {
+        goto exit;
+    }
     _return_value = binascii_crc_hqx_impl(module, &data, crc);
     if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
         goto exit;
@@ -306,23 +310,27 @@ PyDoc_STRVAR(binascii_crc32__doc__,
 "Compute CRC-32 incrementally.");
 
 #define BINASCII_CRC32_METHODDEF    \
-    {"crc32", (PyCFunction)binascii_crc32, METH_VARARGS, binascii_crc32__doc__},
+    {"crc32", (PyCFunction)binascii_crc32, METH_FASTCALL, binascii_crc32__doc__},
 
 static unsigned int
 binascii_crc32_impl(PyObject *module, Py_buffer *data, unsigned int crc);
 
 static PyObject *
-binascii_crc32(PyObject *module, PyObject *args)
+binascii_crc32(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer data = {NULL, NULL};
     unsigned int crc = 0;
     unsigned int _return_value;
 
-    if (!PyArg_ParseTuple(args, "y*|I:crc32",
+    if (!_PyArg_ParseStack(args, nargs, "y*|I:crc32",
         &data, &crc)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("crc32", kwnames)) {
+        goto exit;
+    }
     _return_value = binascii_crc32_impl(module, &data, crc);
     if ((_return_value == (unsigned int)-1) && PyErr_Occurred()) {
         goto exit;
@@ -551,4 +559,4 @@ exit:
 
     return return_value;
 }
-/*[clinic end generated code: output=458eb09731cb7877 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=4a418f883ccc79fe input=a9049054013a1b77]*/

third_party/python/Modules/clinic/cmathmodule.inc

@@ -642,22 +642,26 @@ PyDoc_STRVAR(cmath_log__doc__,
 "If the base not specified, returns the natural logarithm (base e) of z.");
 
 #define CMATH_LOG_METHODDEF    \
-    {"log", (PyCFunction)cmath_log, METH_VARARGS, cmath_log__doc__},
+    {"log", (PyCFunction)cmath_log, METH_FASTCALL, cmath_log__doc__},
 
 static PyObject *
 cmath_log_impl(PyObject *module, Py_complex x, PyObject *y_obj);
 
 static PyObject *
-cmath_log(PyObject *module, PyObject *args)
+cmath_log(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_complex x;
     PyObject *y_obj = NULL;
 
-    if (!PyArg_ParseTuple(args, "D|O:log",
+    if (!_PyArg_ParseStack(args, nargs, "D|O:log",
         &x, &y_obj)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("log", kwnames)) {
+        goto exit;
+    }
     return_value = cmath_log_impl(module, x, y_obj);
 
 exit:
@@ -727,22 +731,26 @@ PyDoc_STRVAR(cmath_rect__doc__,
 "Convert from polar coordinates to rectangular coordinates.");
 
 #define CMATH_RECT_METHODDEF    \
-    {"rect", (PyCFunction)cmath_rect, METH_VARARGS, cmath_rect__doc__},
+    {"rect", (PyCFunction)cmath_rect, METH_FASTCALL, cmath_rect__doc__},
 
 static PyObject *
 cmath_rect_impl(PyObject *module, double r, double phi);
 
 static PyObject *
-cmath_rect(PyObject *module, PyObject *args)
+cmath_rect(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     double r;
     double phi;
 
-    if (!PyArg_ParseTuple(args, "dd:rect",
+    if (!_PyArg_ParseStack(args, nargs, "dd:rect",
         &r, &phi)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("rect", kwnames)) {
+        goto exit;
+    }
     return_value = cmath_rect_impl(module, r, phi);
 
 exit:
@@ -883,4 +891,4 @@ cmath_isclose(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwn
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=978f59702b41655f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=93eff5d4c242ee57 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/fcntlmodule.inc

@@ -20,23 +20,27 @@ PyDoc_STRVAR(fcntl_fcntl__doc__,
 "corresponding to the return value of the fcntl call in the C code.");
 
 #define FCNTL_FCNTL_METHODDEF    \
-    {"fcntl", (PyCFunction)fcntl_fcntl, METH_VARARGS, fcntl_fcntl__doc__},
+    {"fcntl", (PyCFunction)fcntl_fcntl, METH_FASTCALL, fcntl_fcntl__doc__},
 
 static PyObject *
 fcntl_fcntl_impl(PyObject *module, int fd, int code, PyObject *arg);
 
 static PyObject *
-fcntl_fcntl(PyObject *module, PyObject *args)
+fcntl_fcntl(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int fd;
     int code;
     PyObject *arg = NULL;
 
-    if (!PyArg_ParseTuple(args, "O&i|O:fcntl",
+    if (!_PyArg_ParseStack(args, nargs, "O&i|O:fcntl",
         conv_descriptor, &fd, &code, &arg)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("fcntl", kwnames)) {
+        goto exit;
+    }
     return_value = fcntl_fcntl_impl(module, fd, code, arg);
 
 exit:
@@ -77,14 +81,14 @@ PyDoc_STRVAR(fcntl_ioctl__doc__,
 "code.");
 
 #define FCNTL_IOCTL_METHODDEF    \
-    {"ioctl", (PyCFunction)fcntl_ioctl, METH_VARARGS, fcntl_ioctl__doc__},
+    {"ioctl", (PyCFunction)fcntl_ioctl, METH_FASTCALL, fcntl_ioctl__doc__},
 
 static PyObject *
 fcntl_ioctl_impl(PyObject *module, int fd, unsigned int code,
                  PyObject *ob_arg, int mutate_arg);
 
 static PyObject *
-fcntl_ioctl(PyObject *module, PyObject *args)
+fcntl_ioctl(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int fd;
@@ -92,10 +96,14 @@ fcntl_ioctl(PyObject *module, PyObject *args)
     PyObject *ob_arg = NULL;
     int mutate_arg = 1;
 
-    if (!PyArg_ParseTuple(args, "O&I|Op:ioctl",
+    if (!_PyArg_ParseStack(args, nargs, "O&I|Op:ioctl",
         conv_descriptor, &fd, &code, &ob_arg, &mutate_arg)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("ioctl", kwnames)) {
+        goto exit;
+    }
     return_value = fcntl_ioctl_impl(module, fd, code, ob_arg, mutate_arg);
 
 exit:
@@ -112,22 +120,26 @@ PyDoc_STRVAR(fcntl_flock__doc__,
 "function is emulated using fcntl()).");
 
 #define FCNTL_FLOCK_METHODDEF    \
-    {"flock", (PyCFunction)fcntl_flock, METH_VARARGS, fcntl_flock__doc__},
+    {"flock", (PyCFunction)fcntl_flock, METH_FASTCALL, fcntl_flock__doc__},
 
 static PyObject *
 fcntl_flock_impl(PyObject *module, int fd, int code);
 
 static PyObject *
-fcntl_flock(PyObject *module, PyObject *args)
+fcntl_flock(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int fd;
     int code;
 
-    if (!PyArg_ParseTuple(args, "O&i:flock",
+    if (!_PyArg_ParseStack(args, nargs, "O&i:flock",
         conv_descriptor, &fd, &code)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("flock", kwnames)) {
+        goto exit;
+    }
     return_value = fcntl_flock_impl(module, fd, code);
 
 exit:
@@ -162,14 +174,14 @@ PyDoc_STRVAR(fcntl_lockf__doc__,
 "    2 - relative to the end of the file (SEEK_END)");
 
 #define FCNTL_LOCKF_METHODDEF    \
-    {"lockf", (PyCFunction)fcntl_lockf, METH_VARARGS, fcntl_lockf__doc__},
+    {"lockf", (PyCFunction)fcntl_lockf, METH_FASTCALL, fcntl_lockf__doc__},
 
 static PyObject *
 fcntl_lockf_impl(PyObject *module, int fd, int code, PyObject *lenobj,
                  PyObject *startobj, int whence);
 
 static PyObject *
-fcntl_lockf(PyObject *module, PyObject *args)
+fcntl_lockf(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int fd;
@@ -178,13 +190,17 @@ fcntl_lockf(PyObject *module, PyObject *args)
     PyObject *startobj = NULL;
     int whence = 0;
 
-    if (!PyArg_ParseTuple(args, "O&i|OOi:lockf",
+    if (!_PyArg_ParseStack(args, nargs, "O&i|OOi:lockf",
         conv_descriptor, &fd, &code, &lenobj, &startobj, &whence)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("lockf", kwnames)) {
+        goto exit;
+    }
     return_value = fcntl_lockf_impl(module, fd, code, lenobj, startobj, whence);
 
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=36cff76a8fb2c9a6 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b67e9579722e6d4f input=a9049054013a1b77]*/

third_party/python/Modules/clinic/grpmodule.inc

@@ -87,4 +87,4 @@ grp_getgrall(PyObject *module, PyObject *Py_UNUSED(ignored))
 {
     return grp_getgrall_impl(module);
 }
-/*[clinic end generated code: output=d6417ae0a7298e0e input=a9049054013a1b77]*/
+/*[clinic end generated code: output=fb690db5e676d378 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/pyexpat.inc

@@ -12,23 +12,27 @@ PyDoc_STRVAR(pyexpat_xmlparser_Parse__doc__,
 "`isfinal\' should be true at end of input.");
 
 #define PYEXPAT_XMLPARSER_PARSE_METHODDEF    \
-    {"Parse", (PyCFunction)pyexpat_xmlparser_Parse, METH_VARARGS, pyexpat_xmlparser_Parse__doc__},
+    {"Parse", (PyCFunction)pyexpat_xmlparser_Parse, METH_FASTCALL, pyexpat_xmlparser_Parse__doc__},
 
 static PyObject *
 pyexpat_xmlparser_Parse_impl(xmlparseobject *self, PyObject *data,
                              int isfinal);
 
 static PyObject *
-pyexpat_xmlparser_Parse(xmlparseobject *self, PyObject *args)
+pyexpat_xmlparser_Parse(xmlparseobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *data;
     int isfinal = 0;
 
-    if (!PyArg_ParseTuple(args, "O|i:Parse",
+    if (!_PyArg_ParseStack(args, nargs, "O|i:Parse",
         &data, &isfinal)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("Parse", kwnames)) {
+        goto exit;
+    }
     return_value = pyexpat_xmlparser_Parse_impl(self, data, isfinal);
 
 exit:
@@ -117,7 +121,7 @@ PyDoc_STRVAR(pyexpat_xmlparser_ExternalEntityParserCreate__doc__,
 "Create a parser for parsing an external entity based on the information passed to the ExternalEntityRefHandler.");
 
 #define PYEXPAT_XMLPARSER_EXTERNALENTITYPARSERCREATE_METHODDEF    \
-    {"ExternalEntityParserCreate", (PyCFunction)pyexpat_xmlparser_ExternalEntityParserCreate, METH_VARARGS, pyexpat_xmlparser_ExternalEntityParserCreate__doc__},
+    {"ExternalEntityParserCreate", (PyCFunction)pyexpat_xmlparser_ExternalEntityParserCreate, METH_FASTCALL, pyexpat_xmlparser_ExternalEntityParserCreate__doc__},
 
 static PyObject *
 pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
@@ -125,16 +129,20 @@ pyexpat_xmlparser_ExternalEntityParserCreate_impl(xmlparseobject *self,
                                                   const char *encoding);
 
 static PyObject *
-pyexpat_xmlparser_ExternalEntityParserCreate(xmlparseobject *self, PyObject *args)
+pyexpat_xmlparser_ExternalEntityParserCreate(xmlparseobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     const char *context;
     const char *encoding = NULL;
 
-    if (!PyArg_ParseTuple(args, "z|s:ExternalEntityParserCreate",
+    if (!_PyArg_ParseStack(args, nargs, "z|s:ExternalEntityParserCreate",
         &context, &encoding)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("ExternalEntityParserCreate", kwnames)) {
+        goto exit;
+    }
     return_value = pyexpat_xmlparser_ExternalEntityParserCreate_impl(self, context, encoding);
 
 exit:
@@ -186,21 +194,25 @@ PyDoc_STRVAR(pyexpat_xmlparser_UseForeignDTD__doc__,
 "information to the parser. \'flag\' defaults to True if not provided.");
 
 #define PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF    \
-    {"UseForeignDTD", (PyCFunction)pyexpat_xmlparser_UseForeignDTD, METH_VARARGS, pyexpat_xmlparser_UseForeignDTD__doc__},
+    {"UseForeignDTD", (PyCFunction)pyexpat_xmlparser_UseForeignDTD, METH_FASTCALL, pyexpat_xmlparser_UseForeignDTD__doc__},
 
 static PyObject *
 pyexpat_xmlparser_UseForeignDTD_impl(xmlparseobject *self, int flag);
 
 static PyObject *
-pyexpat_xmlparser_UseForeignDTD(xmlparseobject *self, PyObject *args)
+pyexpat_xmlparser_UseForeignDTD(xmlparseobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int flag = 1;
 
-    if (!PyArg_ParseTuple(args, "|p:UseForeignDTD",
+    if (!_PyArg_ParseStack(args, nargs, "|p:UseForeignDTD",
         &flag)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("UseForeignDTD", kwnames)) {
+        goto exit;
+    }
     return_value = pyexpat_xmlparser_UseForeignDTD_impl(self, flag);
 
 exit:
@@ -290,4 +302,4 @@ exit:
 #ifndef PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF
     #define PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF
 #endif /* !defined(PYEXPAT_XMLPARSER_USEFOREIGNDTD_METHODDEF) */
-/*[clinic end generated code: output=e889f7c6af6cc42f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=0548a6b12157e29b input=a9049054013a1b77]*/

third_party/python/Modules/clinic/signalmodule.inc

@@ -75,22 +75,26 @@ PyDoc_STRVAR(signal_signal__doc__,
 "the first is the signal number, the second is the interrupted stack frame.");
 
 #define SIGNAL_SIGNAL_METHODDEF    \
-    {"signal", (PyCFunction)signal_signal, METH_VARARGS, signal_signal__doc__},
+    {"signal", (PyCFunction)signal_signal, METH_FASTCALL, signal_signal__doc__},
 
 static PyObject *
 signal_signal_impl(PyObject *module, int signalnum, PyObject *handler);
 
 static PyObject *
-signal_signal(PyObject *module, PyObject *args)
+signal_signal(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int signalnum;
     PyObject *handler;
 
-    if (!PyArg_ParseTuple(args, "iO:signal",
+    if (!_PyArg_ParseStack(args, nargs, "iO:signal",
         &signalnum, &handler)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("signal", kwnames)) {
+        goto exit;
+    }
     return_value = signal_signal_impl(module, signalnum, handler);
 
 exit:
@@ -142,22 +146,26 @@ PyDoc_STRVAR(signal_siginterrupt__doc__,
 "signal sig, else system calls will be interrupted.");
 
 #define SIGNAL_SIGINTERRUPT_METHODDEF    \
-    {"siginterrupt", (PyCFunction)signal_siginterrupt, METH_VARARGS, signal_siginterrupt__doc__},
+    {"siginterrupt", (PyCFunction)signal_siginterrupt, METH_FASTCALL, signal_siginterrupt__doc__},
 
 static PyObject *
 signal_siginterrupt_impl(PyObject *module, int signalnum, int flag);
 
 static PyObject *
-signal_siginterrupt(PyObject *module, PyObject *args)
+signal_siginterrupt(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int signalnum;
     int flag;
 
-    if (!PyArg_ParseTuple(args, "ii:siginterrupt",
+    if (!_PyArg_ParseStack(args, nargs, "ii:siginterrupt",
         &signalnum, &flag)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("siginterrupt", kwnames)) {
+        goto exit;
+    }
     return_value = signal_siginterrupt_impl(module, signalnum, flag);
 
 exit:
@@ -180,24 +188,28 @@ PyDoc_STRVAR(signal_setitimer__doc__,
 "Returns old values as a tuple: (delay, interval).");
 
 #define SIGNAL_SETITIMER_METHODDEF    \
-    {"setitimer", (PyCFunction)signal_setitimer, METH_VARARGS, signal_setitimer__doc__},
+    {"setitimer", (PyCFunction)signal_setitimer, METH_FASTCALL, signal_setitimer__doc__},
 
 static PyObject *
 signal_setitimer_impl(PyObject *module, int which, double seconds,
                       double interval);
 
 static PyObject *
-signal_setitimer(PyObject *module, PyObject *args)
+signal_setitimer(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int which;
     double seconds;
     double interval = 0.0;
 
-    if (!PyArg_ParseTuple(args, "id|d:setitimer",
+    if (!_PyArg_ParseStack(args, nargs, "id|d:setitimer",
         &which, &seconds, &interval)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("setitimer", kwnames)) {
+        goto exit;
+    }
     return_value = signal_setitimer_impl(module, which, seconds, interval);
 
 exit:
@@ -246,22 +258,26 @@ PyDoc_STRVAR(signal_pthread_sigmask__doc__,
 "Fetch and/or change the signal mask of the calling thread.");
 
 #define SIGNAL_PTHREAD_SIGMASK_METHODDEF    \
-    {"pthread_sigmask", (PyCFunction)signal_pthread_sigmask, METH_VARARGS, signal_pthread_sigmask__doc__},
+    {"pthread_sigmask", (PyCFunction)signal_pthread_sigmask, METH_FASTCALL, signal_pthread_sigmask__doc__},
 
 static PyObject *
 signal_pthread_sigmask_impl(PyObject *module, int how, PyObject *mask);
 
 static PyObject *
-signal_pthread_sigmask(PyObject *module, PyObject *args)
+signal_pthread_sigmask(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int how;
     PyObject *mask;
 
-    if (!PyArg_ParseTuple(args, "iO:pthread_sigmask",
+    if (!_PyArg_ParseStack(args, nargs, "iO:pthread_sigmask",
         &how, &mask)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("pthread_sigmask", kwnames)) {
+        goto exit;
+    }
     return_value = signal_pthread_sigmask_impl(module, how, mask);
 
 exit:
@@ -373,22 +389,26 @@ PyDoc_STRVAR(signal_pthread_kill__doc__,
 "Send a signal to a thread.");
 
 #define SIGNAL_PTHREAD_KILL_METHODDEF    \
-    {"pthread_kill", (PyCFunction)signal_pthread_kill, METH_VARARGS, signal_pthread_kill__doc__},
+    {"pthread_kill", (PyCFunction)signal_pthread_kill, METH_FASTCALL, signal_pthread_kill__doc__},
 
 static PyObject *
 signal_pthread_kill_impl(PyObject *module, long thread_id, int signalnum);
 
 static PyObject *
-signal_pthread_kill(PyObject *module, PyObject *args)
+signal_pthread_kill(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     long thread_id;
     int signalnum;
 
-    if (!PyArg_ParseTuple(args, "li:pthread_kill",
+    if (!_PyArg_ParseStack(args, nargs, "li:pthread_kill",
         &thread_id, &signalnum)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("pthread_kill", kwnames)) {
+        goto exit;
+    }
     return_value = signal_pthread_kill_impl(module, thread_id, signalnum);
 
 exit:
@@ -440,4 +460,4 @@ exit:
 #ifndef SIGNAL_PTHREAD_KILL_METHODDEF
     #define SIGNAL_PTHREAD_KILL_METHODDEF
 #endif /* !defined(SIGNAL_PTHREAD_KILL_METHODDEF) */
-/*[clinic end generated code: output=c6990ef0d0ba72b6 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=b49f7bfff44d1256 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/unicodedata.inc

@@ -14,23 +14,27 @@ PyDoc_STRVAR(unicodedata_UCD_decimal__doc__,
 "ValueError is raised.");
 
 #define UNICODEDATA_UCD_DECIMAL_METHODDEF    \
-    {"decimal", (PyCFunction)unicodedata_UCD_decimal, METH_VARARGS, unicodedata_UCD_decimal__doc__},
+    {"decimal", (PyCFunction)unicodedata_UCD_decimal, METH_FASTCALL, unicodedata_UCD_decimal__doc__},
 
 static PyObject *
 unicodedata_UCD_decimal_impl(PyObject *self, int chr,
                              PyObject *default_value);
 
 static PyObject *
-unicodedata_UCD_decimal(PyObject *self, PyObject *args)
+unicodedata_UCD_decimal(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int chr;
     PyObject *default_value = NULL;
 
-    if (!PyArg_ParseTuple(args, "C|O:decimal",
+    if (!_PyArg_ParseStack(args, nargs, "C|O:decimal",
         &chr, &default_value)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("decimal", kwnames)) {
+        goto exit;
+    }
     return_value = unicodedata_UCD_decimal_impl(self, chr, default_value);
 
 exit:
@@ -48,22 +52,26 @@ PyDoc_STRVAR(unicodedata_UCD_digit__doc__,
 "ValueError is raised.");
 
 #define UNICODEDATA_UCD_DIGIT_METHODDEF    \
-    {"digit", (PyCFunction)unicodedata_UCD_digit, METH_VARARGS, unicodedata_UCD_digit__doc__},
+    {"digit", (PyCFunction)unicodedata_UCD_digit, METH_FASTCALL, unicodedata_UCD_digit__doc__},
 
 static PyObject *
 unicodedata_UCD_digit_impl(PyObject *self, int chr, PyObject *default_value);
 
 static PyObject *
-unicodedata_UCD_digit(PyObject *self, PyObject *args)
+unicodedata_UCD_digit(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int chr;
     PyObject *default_value = NULL;
 
-    if (!PyArg_ParseTuple(args, "C|O:digit",
+    if (!_PyArg_ParseStack(args, nargs, "C|O:digit",
         &chr, &default_value)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("digit", kwnames)) {
+        goto exit;
+    }
     return_value = unicodedata_UCD_digit_impl(self, chr, default_value);
 
 exit:
@@ -81,23 +89,27 @@ PyDoc_STRVAR(unicodedata_UCD_numeric__doc__,
 "ValueError is raised.");
 
 #define UNICODEDATA_UCD_NUMERIC_METHODDEF    \
-    {"numeric", (PyCFunction)unicodedata_UCD_numeric, METH_VARARGS, unicodedata_UCD_numeric__doc__},
+    {"numeric", (PyCFunction)unicodedata_UCD_numeric, METH_FASTCALL, unicodedata_UCD_numeric__doc__},
 
 static PyObject *
 unicodedata_UCD_numeric_impl(PyObject *self, int chr,
                              PyObject *default_value);
 
 static PyObject *
-unicodedata_UCD_numeric(PyObject *self, PyObject *args)
+unicodedata_UCD_numeric(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int chr;
     PyObject *default_value = NULL;
 
-    if (!PyArg_ParseTuple(args, "C|O:numeric",
+    if (!_PyArg_ParseStack(args, nargs, "C|O:numeric",
         &chr, &default_value)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("numeric", kwnames)) {
+        goto exit;
+    }
     return_value = unicodedata_UCD_numeric_impl(self, chr, default_value);
 
 exit:
@@ -294,23 +306,27 @@ PyDoc_STRVAR(unicodedata_UCD_normalize__doc__,
 "Valid values for form are \'NFC\', \'NFKC\', \'NFD\', and \'NFKD\'.");
 
 #define UNICODEDATA_UCD_NORMALIZE_METHODDEF    \
-    {"normalize", (PyCFunction)unicodedata_UCD_normalize, METH_VARARGS, unicodedata_UCD_normalize__doc__},
+    {"normalize", (PyCFunction)unicodedata_UCD_normalize, METH_FASTCALL, unicodedata_UCD_normalize__doc__},
 
 static PyObject *
 unicodedata_UCD_normalize_impl(PyObject *self, const char *form,
                                PyObject *input);
 
 static PyObject *
-unicodedata_UCD_normalize(PyObject *self, PyObject *args)
+unicodedata_UCD_normalize(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     const char *form;
     PyObject *input;
 
-    if (!PyArg_ParseTuple(args, "sO!:normalize",
+    if (!_PyArg_ParseStack(args, nargs, "sO!:normalize",
         &form, &PyUnicode_Type, &input)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("normalize", kwnames)) {
+        goto exit;
+    }
     return_value = unicodedata_UCD_normalize_impl(self, form, input);
 
 exit:
@@ -327,22 +343,26 @@ PyDoc_STRVAR(unicodedata_UCD_name__doc__,
 "ValueError is raised.");
 
 #define UNICODEDATA_UCD_NAME_METHODDEF    \
-    {"name", (PyCFunction)unicodedata_UCD_name, METH_VARARGS, unicodedata_UCD_name__doc__},
+    {"name", (PyCFunction)unicodedata_UCD_name, METH_FASTCALL, unicodedata_UCD_name__doc__},
 
 static PyObject *
 unicodedata_UCD_name_impl(PyObject *self, int chr, PyObject *default_value);
 
 static PyObject *
-unicodedata_UCD_name(PyObject *self, PyObject *args)
+unicodedata_UCD_name(PyObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int chr;
     PyObject *default_value = NULL;
 
-    if (!PyArg_ParseTuple(args, "C|O:name",
+    if (!_PyArg_ParseStack(args, nargs, "C|O:name",
         &chr, &default_value)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("name", kwnames)) {
+        goto exit;
+    }
     return_value = unicodedata_UCD_name_impl(self, chr, default_value);
 
 exit:
@@ -380,4 +400,4 @@ unicodedata_UCD_lookup(PyObject *self, PyObject *arg)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=5313ce129da87b2f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=badeb811d1caec40 input=a9049054013a1b77]*/

third_party/python/Modules/clinic/zlibmodule.inc

@@ -17,6 +17,9 @@ PyDoc_STRVAR(zlib_compress__doc__,
 #define ZLIB_COMPRESS_METHODDEF    \
     {"compress", (PyCFunction)zlib_compress, METH_FASTCALL, zlib_compress__doc__},
 
+static PyObject *
+zlib_compress_impl(PyObject *module, Py_buffer *data, int level);
+
 static PyObject *
 zlib_compress(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
@@ -289,21 +292,25 @@ PyDoc_STRVAR(zlib_Compress_flush__doc__,
 "    can still be compressed.");
 
 #define ZLIB_COMPRESS_FLUSH_METHODDEF    \
-    {"flush", (PyCFunction)zlib_Compress_flush, METH_VARARGS, zlib_Compress_flush__doc__},
+    {"flush", (PyCFunction)zlib_Compress_flush, METH_FASTCALL, zlib_Compress_flush__doc__},
 
 static PyObject *
 zlib_Compress_flush_impl(compobject *self, int mode);
 
 static PyObject *
-zlib_Compress_flush(compobject *self, PyObject *args)
+zlib_Compress_flush(compobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int mode = Z_FINISH;
 
-    if (!PyArg_ParseTuple(args, "|i:flush",
+    if (!_PyArg_ParseStack(args, nargs, "|i:flush",
         &mode)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("flush", kwnames)) {
+        goto exit;
+    }
     return_value = zlib_Compress_flush_impl(self, mode);
 
 exit:
@@ -364,21 +371,25 @@ PyDoc_STRVAR(zlib_Decompress_flush__doc__,
 "    the initial size of the output buffer.");
 
 #define ZLIB_DECOMPRESS_FLUSH_METHODDEF    \
-    {"flush", (PyCFunction)zlib_Decompress_flush, METH_VARARGS, zlib_Decompress_flush__doc__},
+    {"flush", (PyCFunction)zlib_Decompress_flush, METH_FASTCALL, zlib_Decompress_flush__doc__},
 
 static PyObject *
 zlib_Decompress_flush_impl(compobject *self, Py_ssize_t length);
 
 static PyObject *
-zlib_Decompress_flush(compobject *self, PyObject *args)
+zlib_Decompress_flush(compobject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t length = DEF_BUF_SIZE;
 
-    if (!PyArg_ParseTuple(args, "|O&:flush",
+    if (!_PyArg_ParseStack(args, nargs, "|O&:flush",
         ssize_t_converter, &length)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("flush", kwnames)) {
+        goto exit;
+    }
     return_value = zlib_Decompress_flush_impl(self, length);
 
 exit:
@@ -397,22 +408,26 @@ PyDoc_STRVAR(zlib_adler32__doc__,
 "The returned checksum is an integer.");
 
 #define ZLIB_ADLER32_METHODDEF    \
-    {"adler32", (PyCFunction)zlib_adler32, METH_VARARGS, zlib_adler32__doc__},
+    {"adler32", (PyCFunction)zlib_adler32, METH_FASTCALL, zlib_adler32__doc__},
 
 static PyObject *
 zlib_adler32_impl(PyObject *module, Py_buffer *data, unsigned int value);
 
 static PyObject *
-zlib_adler32(PyObject *module, PyObject *args)
+zlib_adler32(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer data = {NULL, NULL};
     unsigned int value = 1;
 
-    if (!PyArg_ParseTuple(args, "y*|I:adler32",
+    if (!_PyArg_ParseStack(args, nargs, "y*|I:adler32",
         &data, &value)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("adler32", kwnames)) {
+        goto exit;
+    }
     return_value = zlib_adler32_impl(module, &data, value);
 
 exit:
@@ -436,22 +451,26 @@ PyDoc_STRVAR(zlib_crc32__doc__,
 "The returned checksum is an integer.");
 
 #define ZLIB_CRC32_METHODDEF    \
-    {"crc32", (PyCFunction)zlib_crc32, METH_VARARGS, zlib_crc32__doc__},
+    {"crc32", (PyCFunction)zlib_crc32, METH_FASTCALL, zlib_crc32__doc__},
 
 static PyObject *
 zlib_crc32_impl(PyObject *module, Py_buffer *data, unsigned int value);
 
 static PyObject *
-zlib_crc32(PyObject *module, PyObject *args)
+zlib_crc32(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer data = {NULL, NULL};
     unsigned int value = 0;
 
-    if (!PyArg_ParseTuple(args, "y*|I:crc32",
+    if (!_PyArg_ParseStack(args, nargs, "y*|I:crc32",
         &data, &value)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("crc32", kwnames)) {
+        goto exit;
+    }
     return_value = zlib_crc32_impl(module, &data, value);
 
 exit:
@@ -466,8 +485,4 @@ exit:
 #ifndef ZLIB_COMPRESS_COPY_METHODDEF
     #define ZLIB_COMPRESS_COPY_METHODDEF
 #endif /* !defined(ZLIB_COMPRESS_COPY_METHODDEF) */
-
+/*[clinic end generated code: output=c6cb10ed66f226b2 input=a9049054013a1b77]*/
-#ifndef ZLIB_DECOMPRESS_COPY_METHODDEF
-    #define ZLIB_DECOMPRESS_COPY_METHODDEF
-#endif /* !defined(ZLIB_DECOMPRESS_COPY_METHODDEF) */
-/*[clinic end generated code: output=497dad1132c962e2 input=a9049054013a1b77]*/

third_party/python/Modules/zlibmodule.c

@@ -503,7 +503,7 @@ Return a compressor object.
 static PyObject *
 zlib_compressobj_impl(PyObject *module, int level, int method, int wbits,
                       int memLevel, int strategy, Py_buffer *zdict)
-/*[clinic end generated code: output=8b5bed9c8fc3814d input=2fa3d026f90ab8d5]*/
+/*[clinic end generated code: output=8b5bed9c8fc3814d input=b5a08c304c3bae52]*/
 {
     compobject *self = NULL;
     int err;

third_party/python/Objects/clinic/bytearrayobject.inc

@@ -1,11 +1,4 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Python 3                                                                     │
-│ https://docs.python.org/3/license.html                                       │
-╚─────────────────────────────────────────────────────────────────────────────*/
 /* clang-format off */
-
 /*[clinic input]
 preserve
 [clinic start generated code]*/
@@ -96,22 +89,26 @@ PyDoc_STRVAR(bytearray_maketrans__doc__,
 "The bytes objects frm and to must be of the same length.");
 
 #define BYTEARRAY_MAKETRANS_METHODDEF    \
-    {"maketrans", (PyCFunction)bytearray_maketrans, METH_VARARGS|METH_STATIC, bytearray_maketrans__doc__},
+    {"maketrans", (PyCFunction)bytearray_maketrans, METH_FASTCALL|METH_STATIC, bytearray_maketrans__doc__},
 
 static PyObject *
 bytearray_maketrans_impl(Py_buffer *frm, Py_buffer *to);
 
 static PyObject *
-bytearray_maketrans(void *null, PyObject *args)
+bytearray_maketrans(void *null, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer frm = {NULL, NULL};
     Py_buffer to = {NULL, NULL};
 
-    if (!PyArg_ParseTuple(args, "y*y*:maketrans",
+    if (!_PyArg_ParseStack(args, nargs, "y*y*:maketrans",
         &frm, &to)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("maketrans", kwnames)) {
+        goto exit;
+    }
     return_value = bytearray_maketrans_impl(&frm, &to);
 
 exit:
@@ -141,24 +138,28 @@ PyDoc_STRVAR(bytearray_replace__doc__,
 "replaced.");
 
 #define BYTEARRAY_REPLACE_METHODDEF    \
-    {"replace", (PyCFunction)bytearray_replace, METH_VARARGS, bytearray_replace__doc__},
+    {"replace", (PyCFunction)bytearray_replace, METH_FASTCALL, bytearray_replace__doc__},
 
 static PyObject *
 bytearray_replace_impl(PyByteArrayObject *self, Py_buffer *old,
                        Py_buffer *new, Py_ssize_t count);
 
 static PyObject *
-bytearray_replace(PyByteArrayObject *self, PyObject *args)
+bytearray_replace(PyByteArrayObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer old = {NULL, NULL};
     Py_buffer new = {NULL, NULL};
     Py_ssize_t count = -1;
 
-    if (!PyArg_ParseTuple(args, "y*y*|n:replace",
+    if (!_PyArg_ParseStack(args, nargs, "y*y*|n:replace",
         &old, &new, &count)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("replace", kwnames)) {
+        goto exit;
+    }
     return_value = bytearray_replace_impl(self, &old, &new, count);
 
 exit:
@@ -222,10 +223,10 @@ PyDoc_STRVAR(bytearray_partition__doc__,
 "\n"
 "This will search for the separator sep in the bytearray. If the separator is\n"
 "found, returns a 3-tuple containing the part before the separator, the\n"
-"separator itself, and the part after it as new bytearray objects.\n"
+"separator itself, and the part after it.\n"
 "\n"
-"If the separator is not found, returns a 3-tuple containing the copy of the\n"
+"If the separator is not found, returns a 3-tuple containing the original\n"
-"original bytearray object and two empty bytearray objects.");
+"bytearray object and two empty bytearray objects.");
 
 #define BYTEARRAY_PARTITION_METHODDEF    \
     {"partition", (PyCFunction)bytearray_partition, METH_O, bytearray_partition__doc__},
@@ -234,15 +235,14 @@ PyDoc_STRVAR(bytearray_rpartition__doc__,
 "rpartition($self, sep, /)\n"
 "--\n"
 "\n"
-"Partition the bytearray into three parts using the given separator.\n"
+"Partition the bytes into three parts using the given separator.\n"
 "\n"
-"This will search for the separator sep in the bytearray, starting at the end.\n"
+"This will search for the separator sep in the bytearray, starting and the end.\n"
 "If the separator is found, returns a 3-tuple containing the part before the\n"
-"separator, the separator itself, and the part after it as new bytearray\n"
+"separator, the separator itself, and the part after it.\n"
-"objects.\n"
 "\n"
 "If the separator is not found, returns a 3-tuple containing two empty bytearray\n"
-"objects and the copy of the original bytearray object.");
+"objects and the original bytearray object.");
 
 #define BYTEARRAY_RPARTITION_METHODDEF    \
     {"rpartition", (PyCFunction)bytearray_rpartition, METH_O, bytearray_rpartition__doc__},
@@ -319,22 +319,26 @@ PyDoc_STRVAR(bytearray_insert__doc__,
 "    The item to be inserted.");
 
 #define BYTEARRAY_INSERT_METHODDEF    \
-    {"insert", (PyCFunction)bytearray_insert, METH_VARARGS, bytearray_insert__doc__},
+    {"insert", (PyCFunction)bytearray_insert, METH_FASTCALL, bytearray_insert__doc__},
 
 static PyObject *
 bytearray_insert_impl(PyByteArrayObject *self, Py_ssize_t index, int item);
 
 static PyObject *
-bytearray_insert(PyByteArrayObject *self, PyObject *args)
+bytearray_insert(PyByteArrayObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t index;
     int item;
 
-    if (!PyArg_ParseTuple(args, "nO&:insert",
+    if (!_PyArg_ParseStack(args, nargs, "nO&:insert",
         &index, _getbytevalue, &item)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("insert", kwnames)) {
+        goto exit;
+    }
     return_value = bytearray_insert_impl(self, index, item);
 
 exit:
@@ -396,21 +400,25 @@ PyDoc_STRVAR(bytearray_pop__doc__,
 "If no index argument is given, will pop the last item.");
 
 #define BYTEARRAY_POP_METHODDEF    \
-    {"pop", (PyCFunction)bytearray_pop, METH_VARARGS, bytearray_pop__doc__},
+    {"pop", (PyCFunction)bytearray_pop, METH_FASTCALL, bytearray_pop__doc__},
 
 static PyObject *
 bytearray_pop_impl(PyByteArrayObject *self, Py_ssize_t index);
 
 static PyObject *
-bytearray_pop(PyByteArrayObject *self, PyObject *args)
+bytearray_pop(PyByteArrayObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_ssize_t index = -1;
 
-    if (!PyArg_ParseTuple(args, "|n:pop",
+    if (!_PyArg_ParseStack(args, nargs, "|n:pop",
         &index)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("pop", kwnames)) {
+        goto exit;
+    }
     return_value = bytearray_pop_impl(self, index);
 
 exit:
@@ -682,21 +690,25 @@ PyDoc_STRVAR(bytearray_reduce_ex__doc__,
 "Return state information for pickling.");
 
 #define BYTEARRAY_REDUCE_EX_METHODDEF    \
-    {"__reduce_ex__", (PyCFunction)bytearray_reduce_ex, METH_VARARGS, bytearray_reduce_ex__doc__},
+    {"__reduce_ex__", (PyCFunction)bytearray_reduce_ex, METH_FASTCALL, bytearray_reduce_ex__doc__},
 
 static PyObject *
 bytearray_reduce_ex_impl(PyByteArrayObject *self, int proto);
 
 static PyObject *
-bytearray_reduce_ex(PyByteArrayObject *self, PyObject *args)
+bytearray_reduce_ex(PyByteArrayObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     int proto = 0;
 
-    if (!PyArg_ParseTuple(args, "|i:__reduce_ex__",
+    if (!_PyArg_ParseStack(args, nargs, "|i:__reduce_ex__",
         &proto)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("__reduce_ex__", kwnames)) {
+        goto exit;
+    }
     return_value = bytearray_reduce_ex_impl(self, proto);
 
 exit:
@@ -720,4 +732,4 @@ bytearray_sizeof(PyByteArrayObject *self, PyObject *Py_UNUSED(ignored))
 {
     return bytearray_sizeof_impl(self);
 }
-/*[clinic end generated code: output=8f022100f059226c input=a9049054013a1b77]*/
+/*[clinic end generated code: output=e6c057d1cd7c2496 input=a9049054013a1b77]*/

third_party/python/Objects/clinic/bytesobject.inc

@@ -1,11 +1,4 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Python 3                                                                     │
-│ https://docs.python.org/3/license.html                                       │
-╚─────────────────────────────────────────────────────────────────────────────*/
 /* clang-format off */
-
 /*[clinic input]
 preserve
 [clinic start generated code]*/
@@ -94,7 +87,7 @@ PyDoc_STRVAR(bytes_rpartition__doc__,
 "\n"
 "Partition the bytes into three parts using the given separator.\n"
 "\n"
-"This will search for the separator sep in the bytes, starting at the end. If\n"
+"This will search for the separator sep in the bytes, starting and the end. If\n"
 "the separator is found, returns a 3-tuple containing the part before the\n"
 "separator, the separator itself, and the part after it.\n"
 "\n"
@@ -326,22 +319,26 @@ PyDoc_STRVAR(bytes_maketrans__doc__,
 "The bytes objects frm and to must be of the same length.");
 
 #define BYTES_MAKETRANS_METHODDEF    \
-    {"maketrans", (PyCFunction)bytes_maketrans, METH_VARARGS|METH_STATIC, bytes_maketrans__doc__},
+    {"maketrans", (PyCFunction)bytes_maketrans, METH_FASTCALL|METH_STATIC, bytes_maketrans__doc__},
 
 static PyObject *
 bytes_maketrans_impl(Py_buffer *frm, Py_buffer *to);
 
 static PyObject *
-bytes_maketrans(void *null, PyObject *args)
+bytes_maketrans(void *null, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer frm = {NULL, NULL};
     Py_buffer to = {NULL, NULL};
 
-    if (!PyArg_ParseTuple(args, "y*y*:maketrans",
+    if (!_PyArg_ParseStack(args, nargs, "y*y*:maketrans",
         &frm, &to)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("maketrans", kwnames)) {
+        goto exit;
+    }
     return_value = bytes_maketrans_impl(&frm, &to);
 
 exit:
@@ -371,24 +368,28 @@ PyDoc_STRVAR(bytes_replace__doc__,
 "replaced.");
 
 #define BYTES_REPLACE_METHODDEF    \
-    {"replace", (PyCFunction)bytes_replace, METH_VARARGS, bytes_replace__doc__},
+    {"replace", (PyCFunction)bytes_replace, METH_FASTCALL, bytes_replace__doc__},
 
 static PyObject *
 bytes_replace_impl(PyBytesObject *self, Py_buffer *old, Py_buffer *new,
                    Py_ssize_t count);
 
 static PyObject *
-bytes_replace(PyBytesObject *self, PyObject *args)
+bytes_replace(PyBytesObject *self, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     Py_buffer old = {NULL, NULL};
     Py_buffer new = {NULL, NULL};
     Py_ssize_t count = -1;
 
-    if (!PyArg_ParseTuple(args, "y*y*|n:replace",
+    if (!_PyArg_ParseStack(args, nargs, "y*y*|n:replace",
         &old, &new, &count)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("replace", kwnames)) {
+        goto exit;
+    }
     return_value = bytes_replace_impl(self, &old, &new, count);
 
 exit:
@@ -507,4 +508,4 @@ bytes_fromhex(PyTypeObject *type, PyObject *arg)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=4ac7e35150d47467 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=2b8d3cff7e11045e input=a9049054013a1b77]*/

third_party/python/Objects/clinic/dictobject.inc

@@ -1,35 +1,30 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Python 3                                                                     │
-│ https://docs.python.org/3/license.html                                       │
-╚─────────────────────────────────────────────────────────────────────────────*/
 /* clang-format off */
-
 /*[clinic input]
 preserve
 [clinic start generated code]*/
 
-PyDoc_STRVAR(
+PyDoc_STRVAR(dict_fromkeys__doc__,
-    dict_fromkeys__doc__,
 "fromkeys($type, iterable, value=None, /)\n"
 "--\n"
 "\n"
 "Returns a new dict with keys from iterable and values equal to value.");
 
 #define DICT_FROMKEYS_METHODDEF    \
-  {"fromkeys", (PyCFunction)dict_fromkeys, METH_VARARGS | METH_CLASS, \
+    {"fromkeys", (PyCFunction)dict_fromkeys, METH_VARARGS|METH_CLASS, dict_fromkeys__doc__},
-   dict_fromkeys__doc__},
 
-static PyObject *dict_fromkeys_impl(PyTypeObject *type, PyObject *iterable,
+static PyObject *
-                                    PyObject *value);
+dict_fromkeys_impl(PyTypeObject *type, PyObject *iterable, PyObject *value);
 
-static PyObject *dict_fromkeys(PyTypeObject *type, PyObject *args) {
+static PyObject *
+dict_fromkeys(PyTypeObject *type, PyObject *args)
+{
     PyObject *return_value = NULL;
     PyObject *iterable;
     PyObject *value = Py_None;
 
-  if (!PyArg_UnpackTuple(args, "fromkeys", 1, 2, &iterable, &value)) {
+    if (!PyArg_UnpackTuple(args, "fromkeys",
+        1, 2,
+        &iterable, &value)) {
         goto exit;
     }
     return_value = dict_fromkeys_impl(type, iterable, value);
@@ -38,12 +33,12 @@ exit:
     return return_value;
 }
 
-PyDoc_STRVAR(dict___contains____doc__, "__contains__($self, key, /)\n"
+PyDoc_STRVAR(dict___contains____doc__,
+"__contains__($self, key, /)\n"
 "--\n"
 "\n"
 "True if D has a key k, else False.");
 
 #define DICT___CONTAINS___METHODDEF    \
-  {"__contains__", (PyCFunction)dict___contains__, METH_O | METH_COEXIST, \
+    {"__contains__", (PyCFunction)dict___contains__, METH_O|METH_COEXIST, dict___contains____doc__},
-   dict___contains____doc__},
 /*[clinic end generated code: output=926326109e3d9839 input=a9049054013a1b77]*/

third_party/python/Python/clinic/bltinmodule.inc

@@ -1,11 +1,4 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
-│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Python 3                                                                     │
-│ https://docs.python.org/3/license.html                                       │
-╚─────────────────────────────────────────────────────────────────────────────*/
 /* clang-format off */
-
 /*[clinic input]
 preserve
 [clinic start generated code]*/
@@ -90,22 +83,26 @@ PyDoc_STRVAR(builtin_format__doc__,
 "details.");
 
 #define BUILTIN_FORMAT_METHODDEF    \
-    {"format", (PyCFunction)builtin_format, METH_VARARGS, builtin_format__doc__},
+    {"format", (PyCFunction)builtin_format, METH_FASTCALL, builtin_format__doc__},
 
 static PyObject *
 builtin_format_impl(PyObject *module, PyObject *value, PyObject *format_spec);
 
 static PyObject *
-builtin_format(PyObject *module, PyObject *args)
+builtin_format(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
 {
     PyObject *return_value = NULL;
     PyObject *value;
     PyObject *format_spec = NULL;
 
-    if (!PyArg_ParseTuple(args, "O|U:format",
+    if (!_PyArg_ParseStack(args, nargs, "O|U:format",
         &value, &format_spec)) {
         goto exit;
     }
+
+    if (!_PyArg_NoStackKeywords("format", kwnames)) {
+        goto exit;
+    }
     return_value = builtin_format_impl(module, value, format_spec);
 
 exit:
@@ -127,9 +124,16 @@ builtin_chr_impl(PyObject *module, int i);
 static PyObject *
 builtin_chr(PyObject *module, PyObject *arg)
 {
+    PyObject *return_value = NULL;
     int i;
-    if (!PyArg_Parse(arg, "i:chr", &i)) return 0;
+
-    return builtin_chr_impl(module, i);
+    if (!PyArg_Parse(arg, "i:chr", &i)) {
+        goto exit;
+    }
+    return_value = builtin_chr_impl(module, i);
+
+exit:
+    return return_value;
 }
 
 PyDoc_STRVAR(builtin_compile__doc__,
@@ -677,4 +681,4 @@ builtin_issubclass(PyObject *module, PyObject *args)
 exit:
     return return_value;
 }
-/*[clinic end generated code: output=2ef82846acdfa0f5 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=c0201eb152977af0 input=a9049054013a1b77]*/

third_party/python/Python/clinic/import.inc

@@ -1,11 +1,4 @@
-/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:4;tab-width:8;coding:utf-8 -*-│
+/* clang-format off */
-│vi: set net ft=c ts=4 sts=4 sw=4 fenc=utf-8                                :vi│
-╞══════════════════════════════════════════════════════════════════════════════╡
-│ Python 3                                                                     │
-│ https://docs.python.org/3/license.html                                       │
-╚─────────────────────────────────────────────────────────────────────────────*/
-#include "third_party/python/Include/pymacro.h"
-
 /*[clinic input]
 preserve
 [clinic start generated code]*/
@@ -19,35 +12,35 @@ PyDoc_STRVAR(_imp_lock_held__doc__,
 "On platforms without threads, return False.");
 
 #define _IMP_LOCK_HELD_METHODDEF    \
-  {"lock_held", (PyCFunction)_imp_lock_held, METH_NOARGS, \
+    {"lock_held", (PyCFunction)_imp_lock_held, METH_NOARGS, _imp_lock_held__doc__},
-   _imp_lock_held__doc__},
 
-static PyObject *_imp_lock_held_impl(PyObject *module);
+static PyObject *
+_imp_lock_held_impl(PyObject *module);
 
-static PyObject *_imp_lock_held(PyObject *module,
+static PyObject *
-                                PyObject *Py_UNUSED(ignored)) {
+_imp_lock_held(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
     return _imp_lock_held_impl(module);
 }
 
-PyDoc_STRVAR(
+PyDoc_STRVAR(_imp_acquire_lock__doc__,
-    _imp_acquire_lock__doc__,
 "acquire_lock($module, /)\n"
 "--\n"
 "\n"
 "Acquires the interpreter\'s import lock for the current thread.\n"
 "\n"
-    "This lock should be used by import hooks to ensure thread-safety when "
+"This lock should be used by import hooks to ensure thread-safety when importing\n"
-    "importing\n"
 "modules. On platforms without threads, this function does nothing.");
 
 #define _IMP_ACQUIRE_LOCK_METHODDEF    \
-  {"acquire_lock", (PyCFunction)_imp_acquire_lock, METH_NOARGS, \
+    {"acquire_lock", (PyCFunction)_imp_acquire_lock, METH_NOARGS, _imp_acquire_lock__doc__},
-   _imp_acquire_lock__doc__},
 
-static PyObject *_imp_acquire_lock_impl(PyObject *module);
+static PyObject *
+_imp_acquire_lock_impl(PyObject *module);
 
-static PyObject *_imp_acquire_lock(PyObject *module,
+static PyObject *
-                                   PyObject *Py_UNUSED(ignored)) {
+_imp_acquire_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
     return _imp_acquire_lock_impl(module);
 }
 
@@ -60,13 +53,14 @@ PyDoc_STRVAR(_imp_release_lock__doc__,
 "On platforms without threads, this function does nothing.");
 
 #define _IMP_RELEASE_LOCK_METHODDEF    \
-  {"release_lock", (PyCFunction)_imp_release_lock, METH_NOARGS, \
+    {"release_lock", (PyCFunction)_imp_release_lock, METH_NOARGS, _imp_release_lock__doc__},
-   _imp_release_lock__doc__},
 
-static PyObject *_imp_release_lock_impl(PyObject *module);
+static PyObject *
+_imp_release_lock_impl(PyObject *module);
 
-static PyObject *_imp_release_lock(PyObject *module,
+static PyObject *
-                                   PyObject *Py_UNUSED(ignored)) {
+_imp_release_lock(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
     return _imp_release_lock_impl(module);
 }
 
@@ -82,19 +76,25 @@ PyDoc_STRVAR(_imp__fix_co_filename__doc__,
 "    File path to use.");
 
 #define _IMP__FIX_CO_FILENAME_METHODDEF    \
-  {"_fix_co_filename", (PyCFunction)_imp__fix_co_filename, METH_VARARGS, \
+    {"_fix_co_filename", (PyCFunction)_imp__fix_co_filename, METH_FASTCALL, _imp__fix_co_filename__doc__},
-   _imp__fix_co_filename__doc__},
 
-static PyObject *_imp__fix_co_filename_impl(PyObject *module,
+static PyObject *
-                                            PyCodeObject *code, PyObject *path);
+_imp__fix_co_filename_impl(PyObject *module, PyCodeObject *code,
+                           PyObject *path);
 
-static PyObject *_imp__fix_co_filename(PyObject *module, PyObject *args) {
+static PyObject *
+_imp__fix_co_filename(PyObject *module, PyObject **args, Py_ssize_t nargs, PyObject *kwnames)
+{
     PyObject *return_value = NULL;
     PyCodeObject *code;
     PyObject *path;
 
-  if (!PyArg_ParseTuple(args, "O!U:_fix_co_filename", &PyCode_Type, &code,
+    if (!_PyArg_ParseStack(args, nargs, "O!U:_fix_co_filename",
-                        &path)) {
+        &PyCode_Type, &code, &path)) {
+        goto exit;
+    }
+
+    if (!_PyArg_NoStackKeywords("_fix_co_filename", kwnames)) {
         goto exit;
     }
     return_value = _imp__fix_co_filename_impl(module, code, path);
@@ -103,45 +103,48 @@ exit:
     return return_value;
 }
 
-PyDoc_STRVAR(_imp_create_builtin__doc__, "create_builtin($module, spec, /)\n"
+PyDoc_STRVAR(_imp_create_builtin__doc__,
+"create_builtin($module, spec, /)\n"
 "--\n"
 "\n"
 "Create an extension module.");
 
 #define _IMP_CREATE_BUILTIN_METHODDEF    \
-  {"create_builtin", (PyCFunction)_imp_create_builtin, METH_O, \
+    {"create_builtin", (PyCFunction)_imp_create_builtin, METH_O, _imp_create_builtin__doc__},
-   _imp_create_builtin__doc__},
 
-PyDoc_STRVAR(
+PyDoc_STRVAR(_imp_extension_suffixes__doc__,
-    _imp_extension_suffixes__doc__,
 "extension_suffixes($module, /)\n"
 "--\n"
 "\n"
 "Returns the list of file suffixes used to identify extension modules.");
 
 #define _IMP_EXTENSION_SUFFIXES_METHODDEF    \
-  {"extension_suffixes", (PyCFunction)_imp_extension_suffixes, METH_NOARGS, \
+    {"extension_suffixes", (PyCFunction)_imp_extension_suffixes, METH_NOARGS, _imp_extension_suffixes__doc__},
-   _imp_extension_suffixes__doc__},
 
-static PyObject *_imp_extension_suffixes_impl(PyObject *module);
+static PyObject *
+_imp_extension_suffixes_impl(PyObject *module);
 
-static PyObject *_imp_extension_suffixes(PyObject *module,
+static PyObject *
-                                         PyObject *Py_UNUSED(ignored)) {
+_imp_extension_suffixes(PyObject *module, PyObject *Py_UNUSED(ignored))
+{
     return _imp_extension_suffixes_impl(module);
 }
 
-PyDoc_STRVAR(_imp_init_frozen__doc__, "init_frozen($module, name, /)\n"
+PyDoc_STRVAR(_imp_init_frozen__doc__,
+"init_frozen($module, name, /)\n"
 "--\n"
 "\n"
 "Initializes a frozen module.");
 
 #define _IMP_INIT_FROZEN_METHODDEF    \
-  {"init_frozen", (PyCFunction)_imp_init_frozen, METH_O, \
+    {"init_frozen", (PyCFunction)_imp_init_frozen, METH_O, _imp_init_frozen__doc__},
-   _imp_init_frozen__doc__},
 
-static PyObject *_imp_init_frozen_impl(PyObject *module, PyObject *name);
+static PyObject *
+_imp_init_frozen_impl(PyObject *module, PyObject *name);
 
-static PyObject *_imp_init_frozen(PyObject *module, PyObject *arg) {
+static PyObject *
+_imp_init_frozen(PyObject *module, PyObject *arg)
+{
     PyObject *return_value = NULL;
     PyObject *name;
 
@@ -161,12 +164,14 @@ PyDoc_STRVAR(_imp_get_frozen_object__doc__,
 "Create a code object for a frozen module.");
 
 #define _IMP_GET_FROZEN_OBJECT_METHODDEF    \
-  {"get_frozen_object", (PyCFunction)_imp_get_frozen_object, METH_O, \
+    {"get_frozen_object", (PyCFunction)_imp_get_frozen_object, METH_O, _imp_get_frozen_object__doc__},
-   _imp_get_frozen_object__doc__},
 
-static PyObject *_imp_get_frozen_object_impl(PyObject *module, PyObject *name);
+static PyObject *
+_imp_get_frozen_object_impl(PyObject *module, PyObject *name);
 
-static PyObject *_imp_get_frozen_object(PyObject *module, PyObject *arg) {
+static PyObject *
+_imp_get_frozen_object(PyObject *module, PyObject *arg)
+{
     PyObject *return_value = NULL;
     PyObject *name;
 
@@ -186,12 +191,14 @@ PyDoc_STRVAR(_imp_is_frozen_package__doc__,
 "Returns True if the module name is of a frozen package.");
 
 #define _IMP_IS_FROZEN_PACKAGE_METHODDEF    \
-  {"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_O, \
+    {"is_frozen_package", (PyCFunction)_imp_is_frozen_package, METH_O, _imp_is_frozen_package__doc__},
-   _imp_is_frozen_package__doc__},
 
-static PyObject *_imp_is_frozen_package_impl(PyObject *module, PyObject *name);
+static PyObject *
+_imp_is_frozen_package_impl(PyObject *module, PyObject *name);
 
-static PyObject *_imp_is_frozen_package(PyObject *module, PyObject *arg) {
+static PyObject *
+_imp_is_frozen_package(PyObject *module, PyObject *arg)
+{
     PyObject *return_value = NULL;
     PyObject *name;
 
@@ -204,8 +211,7 @@ exit:
     return return_value;
 }
 
-PyDoc_STRVAR(
+PyDoc_STRVAR(_imp_is_builtin__doc__,
-    _imp_is_builtin__doc__,
 "is_builtin($module, name, /)\n"
 "--\n"
 "\n"
@@ -214,9 +220,12 @@ PyDoc_STRVAR(
 #define _IMP_IS_BUILTIN_METHODDEF    \
     {"is_builtin", (PyCFunction)_imp_is_builtin, METH_O, _imp_is_builtin__doc__},
 
-static PyObject *_imp_is_builtin_impl(PyObject *module, PyObject *name);
+static PyObject *
+_imp_is_builtin_impl(PyObject *module, PyObject *name);
 
-static PyObject *_imp_is_builtin(PyObject *module, PyObject *arg) {
+static PyObject *
+_imp_is_builtin(PyObject *module, PyObject *arg)
+{
     PyObject *return_value = NULL;
     PyObject *name;
 
@@ -238,9 +247,12 @@ PyDoc_STRVAR(_imp_is_frozen__doc__,
 #define _IMP_IS_FROZEN_METHODDEF    \
     {"is_frozen", (PyCFunction)_imp_is_frozen, METH_O, _imp_is_frozen__doc__},
 
-static PyObject *_imp_is_frozen_impl(PyObject *module, PyObject *name);
+static PyObject *
+_imp_is_frozen_impl(PyObject *module, PyObject *name);
 
-static PyObject *_imp_is_frozen(PyObject *module, PyObject *arg) {
+static PyObject *
+_imp_is_frozen(PyObject *module, PyObject *arg)
+{
     PyObject *return_value = NULL;
     PyObject *name;
 
@@ -262,18 +274,21 @@ PyDoc_STRVAR(_imp_create_dynamic__doc__,
 "Create an extension module.");
 
 #define _IMP_CREATE_DYNAMIC_METHODDEF    \
-  {"create_dynamic", (PyCFunction)_imp_create_dynamic, METH_VARARGS, \
+    {"create_dynamic", (PyCFunction)_imp_create_dynamic, METH_VARARGS, _imp_create_dynamic__doc__},
-   _imp_create_dynamic__doc__},
 
-static PyObject *_imp_create_dynamic_impl(PyObject *module, PyObject *spec,
+static PyObject *
-                                          PyObject *file);
+_imp_create_dynamic_impl(PyObject *module, PyObject *spec, PyObject *file);
 
-static PyObject *_imp_create_dynamic(PyObject *module, PyObject *args) {
+static PyObject *
+_imp_create_dynamic(PyObject *module, PyObject *args)
+{
     PyObject *return_value = NULL;
     PyObject *spec;
     PyObject *file = NULL;
 
-  if (!PyArg_UnpackTuple(args, "create_dynamic", 1, 2, &spec, &file)) {
+    if (!PyArg_UnpackTuple(args, "create_dynamic",
+        1, 2,
+        &spec, &file)) {
         goto exit;
     }
     return_value = _imp_create_dynamic_impl(module, spec, file);
@@ -286,18 +301,21 @@ exit:
 
 #if defined(HAVE_DYNAMIC_LOADING)
 
-PyDoc_STRVAR(_imp_exec_dynamic__doc__, "exec_dynamic($module, mod, /)\n"
+PyDoc_STRVAR(_imp_exec_dynamic__doc__,
+"exec_dynamic($module, mod, /)\n"
 "--\n"
 "\n"
 "Initialize an extension module.");
 
 #define _IMP_EXEC_DYNAMIC_METHODDEF    \
-  {"exec_dynamic", (PyCFunction)_imp_exec_dynamic, METH_O, \
+    {"exec_dynamic", (PyCFunction)_imp_exec_dynamic, METH_O, _imp_exec_dynamic__doc__},
-   _imp_exec_dynamic__doc__},
 
-static int _imp_exec_dynamic_impl(PyObject *module, PyObject *mod);
+static int
+_imp_exec_dynamic_impl(PyObject *module, PyObject *mod);
 
-static PyObject *_imp_exec_dynamic(PyObject *module, PyObject *mod) {
+static PyObject *
+_imp_exec_dynamic(PyObject *module, PyObject *mod)
+{
     PyObject *return_value = NULL;
     int _return_value;
 
@@ -313,18 +331,21 @@ exit:
 
 #endif /* defined(HAVE_DYNAMIC_LOADING) */
 
-PyDoc_STRVAR(_imp_exec_builtin__doc__, "exec_builtin($module, mod, /)\n"
+PyDoc_STRVAR(_imp_exec_builtin__doc__,
+"exec_builtin($module, mod, /)\n"
 "--\n"
 "\n"
 "Initialize a built-in module.");
 
 #define _IMP_EXEC_BUILTIN_METHODDEF    \
-  {"exec_builtin", (PyCFunction)_imp_exec_builtin, METH_O, \
+    {"exec_builtin", (PyCFunction)_imp_exec_builtin, METH_O, _imp_exec_builtin__doc__},
-   _imp_exec_builtin__doc__},
 
-static int _imp_exec_builtin_impl(PyObject *module, PyObject *mod);
+static int
+_imp_exec_builtin_impl(PyObject *module, PyObject *mod);
 
-static PyObject *_imp_exec_builtin(PyObject *module, PyObject *mod) {
+static PyObject *
+_imp_exec_builtin(PyObject *module, PyObject *mod)
+{
     PyObject *return_value = NULL;
     int _return_value;
 
@@ -345,4 +366,4 @@ exit:
 #ifndef _IMP_EXEC_DYNAMIC_METHODDEF
     #define _IMP_EXEC_DYNAMIC_METHODDEF
 #endif /* !defined(_IMP_EXEC_DYNAMIC_METHODDEF) */
-/*[clinic end generated code: output=d24d7f73702a907f input=a9049054013a1b77]*/
+/*[clinic end generated code: output=5a3f012344950548 input=a9049054013a1b77]*/