diff -r 9c8d31d69044 Modules/_elementtree.c
--- a/Modules/_elementtree.c	Mon Jan 06 11:10:08 2014 -0800
+++ b/Modules/_elementtree.c	Tue Jan 07 11:24:42 2014 +0200
@@ -368,6 +368,12 @@
     return attrib;
 }
 
+/*[clinic]
+module _elementtree
+class _elementtree.Element
+[clinic]*/
+/*[clinic checksum: da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
+
 static int
 element_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
@@ -654,25 +660,80 @@
 
 /* -------------------------------------------------------------------- */
 
-static PyObject*
-element_append(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.append
+
+    self: self(type='ElementObject *')
+    subelement: object(type='Element_Type')
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_append__doc__,
+"append(subelement)");
+
+#define _ELEMENTTREE_ELEMENT_APPEND_METHODDEF    \
+    {"append", (PyCFunction)_elementtree_Element_append, METH_VARARGS, _elementtree_Element_append__doc__},
+
+static PyObject *
+_elementtree_Element_append_impl(ElementObject *self, PyObject *subelement);
+
+static PyObject *
+_elementtree_Element_append(PyObject *self, PyObject *args)
 {
-    PyObject* element;
-    if (!PyArg_ParseTuple(args, "O!:append", &Element_Type, &element))
-        return NULL;
-
-    if (element_add_subelement(self, element) < 0)
+    PyObject *return_value = NULL;
+    PyObject *subelement;
+
+    if (!PyArg_ParseTuple(args,
+        "O!:append",
+        &Element_Type, &subelement))
+        goto exit;
+    return_value = _elementtree_Element_append_impl((ElementObject *)self, subelement);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_append_impl(ElementObject *self, PyObject *subelement)
+/*[clinic checksum: 1fd211324089b30fdfbca4df3c62100bbae724b4]*/
+{
+    if (element_add_subelement(self, subelement) < 0)
         return NULL;
 
     Py_RETURN_NONE;
 }
 
-static PyObject*
-element_clearmethod(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.clear
+
+    self: self(type='ElementObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_clear__doc__,
+"clear()");
+
+#define _ELEMENTTREE_ELEMENT_CLEAR_METHODDEF    \
+    {"clear", (PyCFunction)_elementtree_Element_clear, METH_NOARGS, _elementtree_Element_clear__doc__},
+
+static PyObject *
+_elementtree_Element_clear_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_clear(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
-    if (!PyArg_ParseTuple(args, ":clear"))
-        return NULL;
-
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_Element_clear_impl((ElementObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_clear_impl(ElementObject *self)
+/*[clinic checksum: b112605d2110394281eaabbf17b7458fc1037828]*/
+{
     dealloc_extra(self);
 
     Py_INCREF(Py_None);
@@ -686,15 +747,39 @@
     Py_RETURN_NONE;
 }
 
-static PyObject*
-element_copy(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.__copy__
+
+    self: self(type='ElementObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element___copy____doc__,
+"__copy__()");
+
+#define _ELEMENTTREE_ELEMENT___COPY___METHODDEF    \
+    {"__copy__", (PyCFunction)_elementtree_Element___copy__, METH_NOARGS, _elementtree_Element___copy____doc__},
+
+static PyObject *
+_elementtree_Element___copy___impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element___copy__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_Element___copy___impl((ElementObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element___copy___impl(ElementObject *self)
+/*[clinic checksum: 7a0523cd605533c0e69293b9a4fcbecc6e072ba2]*/
 {
     int i;
     ElementObject* element;
 
-    if (!PyArg_ParseTuple(args, ":__copy__"))
-        return NULL;
-
     element = (ElementObject*) create_new_element(
         self->tag, (self->extra) ? self->extra->attrib : Py_None);
     if (!element)
@@ -725,8 +810,24 @@
     return (PyObject*) element;
 }
 
-static PyObject*
-element_deepcopy(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.__deepcopy__
+
+    self: self(type='ElementObject *')
+    memo: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element___deepcopy____doc__,
+"__deepcopy__(memo)");
+
+#define _ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF    \
+    {"__deepcopy__", (PyCFunction)_elementtree_Element___deepcopy__, METH_O, _elementtree_Element___deepcopy____doc__},
+
+static PyObject *
+_elementtree_Element___deepcopy__(ElementObject *self, PyObject *memo)
+/*[clinic checksum: f337046f0f00f6dc0dfc3dbf45553e310672f56b]*/
 {
     int i;
     ElementObject* element;
@@ -736,10 +837,6 @@
     PyObject* tail;
     PyObject* id;
 
-    PyObject* memo;
-    if (!PyArg_ParseTuple(args, "O:__deepcopy__", &memo))
-        return NULL;
-
     tag = deepcopy(self->tag, memo);
     if (!tag)
         return NULL;
@@ -810,17 +907,48 @@
     return NULL;
 }
 
-static PyObject*
-element_sizeof(PyObject* myself, PyObject* args)
+/*[clinic]
+_elementtree.Element.__sizeof__ -> Py_ssize_t
+
+    self: self(type='ElementObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element___sizeof____doc__,
+"__sizeof__()");
+
+#define _ELEMENTTREE_ELEMENT___SIZEOF___METHODDEF    \
+    {"__sizeof__", (PyCFunction)_elementtree_Element___sizeof__, METH_NOARGS, _elementtree_Element___sizeof____doc__},
+
+static Py_ssize_t
+_elementtree_Element___sizeof___impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element___sizeof__(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
-    ElementObject *self = (ElementObject*)myself;
+    PyObject *return_value = NULL;
+    Py_ssize_t _return_value;
+
+    _return_value = _elementtree_Element___sizeof___impl((ElementObject *)self);
+    if ((_return_value == -1) && PyErr_Occurred())
+        goto exit;
+    return_value = PyLong_FromSsize_t(_return_value);
+
+exit:
+    return return_value;
+}
+
+static Py_ssize_t
+_elementtree_Element___sizeof___impl(ElementObject *self)
+/*[clinic checksum: 5e3e8a02ed3a3c73c99467e90f8b840277286cb7]*/
+{
     Py_ssize_t result = sizeof(ElementObject);
     if (self->extra) {
         result += sizeof(ElementObjectExtra);
         if (self->extra->children != self->extra->_children)
             result += sizeof(PyObject*) * self->extra->allocated;
     }
-    return PyLong_FromSsize_t(result);
+    return result;
 }
 
 /* dict keys for getstate/setstate. */
@@ -836,8 +964,35 @@
  * any unnecessary structures there; and (b) it buys compatibility with 3.2
  * pickles.  See issue #16076.
  */
+/*[clinic]
+_elementtree.Element.__getstate__
+
+    self: self(type='ElementObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element___getstate____doc__,
+"__getstate__()");
+
+#define _ELEMENTTREE_ELEMENT___GETSTATE___METHODDEF    \
+    {"__getstate__", (PyCFunction)_elementtree_Element___getstate__, METH_NOARGS, _elementtree_Element___getstate____doc__},
+
 static PyObject *
-element_getstate(ElementObject *self)
+_elementtree_Element___getstate___impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element___getstate__(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_Element___getstate___impl((ElementObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element___getstate___impl(ElementObject *self)
+/*[clinic checksum: 54ff075281a1ea36af223e690490204bc27748fb]*/
 {
     int i, noattrib;
     PyObject *instancedict = NULL, *children;
@@ -952,6 +1107,7 @@
 /* __setstate__ for Element instance from the Python implementation.
  * 'state' should be the instance dict.
  */
+
 static PyObject *
 element_setstate_from_Python(ElementObject *self, PyObject *state)
 {
@@ -977,8 +1133,24 @@
     return retval;
 }
 
+/*[clinic]
+_elementtree.Element.__setstate__
+
+    self: self(type='ElementObject *')
+    state: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element___setstate____doc__,
+"__setstate__(state)");
+
+#define _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF    \
+    {"__setstate__", (PyCFunction)_elementtree_Element___setstate__, METH_O, _elementtree_Element___setstate____doc__},
+
 static PyObject *
-element_setstate(ElementObject *self, PyObject *state)
+_elementtree_Element___setstate__(ElementObject *self, PyObject *state)
+/*[clinic checksum: bd75aec0601d95cfd4ada7d5aa4b6597f7209422]*/
 {
     if (!PyDict_CheckExact(state)) {
         PyErr_Format(PyExc_TypeError,
@@ -1032,21 +1204,33 @@
     return 1; /* unknown type; might be path expression */
 }
 
-static PyObject*
-element_extend(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.extend
+
+    self: self(type='ElementObject *')
+    elements: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_extend__doc__,
+"extend(elements)");
+
+#define _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF    \
+    {"extend", (PyCFunction)_elementtree_Element_extend, METH_O, _elementtree_Element_extend__doc__},
+
+static PyObject *
+_elementtree_Element_extend(ElementObject *self, PyObject *elements)
+/*[clinic checksum: a5102ac72eb6ab1d742a8c6c06f5ee4c5e219580]*/
 {
     PyObject* seq;
     Py_ssize_t i, seqlen = 0;
 
-    PyObject* seq_in;
-    if (!PyArg_ParseTuple(args, "O:extend", &seq_in))
-        return NULL;
-
-    seq = PySequence_Fast(seq_in, "");
+    seq = PySequence_Fast(elements, "");
     if (!seq) {
         PyErr_Format(
             PyExc_TypeError,
-            "expected sequence, not \"%.200s\"", Py_TYPE(seq_in)->tp_name
+            "expected sequence, not \"%.200s\"", Py_TYPE(elements)->tp_name
             );
         return NULL;
     }
@@ -1074,23 +1258,53 @@
     Py_RETURN_NONE;
 }
 
-static PyObject*
-element_find(ElementObject *self, PyObject *args, PyObject *kwds)
+/*[clinic]
+_elementtree.Element.find
+
+    self: self(type='ElementObject *')
+    path: object
+    namespaces: object = None
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_find__doc__,
+"find(path, namespaces=None)");
+
+#define _ELEMENTTREE_ELEMENT_FIND_METHODDEF    \
+    {"find", (PyCFunction)_elementtree_Element_find, METH_VARARGS|METH_KEYWORDS, _elementtree_Element_find__doc__},
+
+static PyObject *
+_elementtree_Element_find_impl(ElementObject *self, PyObject *path, PyObject *namespaces);
+
+static PyObject *
+_elementtree_Element_find(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"path", "namespaces", NULL};
+    PyObject *path;
+    PyObject *namespaces = Py_None;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "O|O:find", _keywords,
+        &path, &namespaces))
+        goto exit;
+    return_value = _elementtree_Element_find_impl((ElementObject *)self, path, namespaces);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_find_impl(ElementObject *self, PyObject *path, PyObject *namespaces)
+/*[clinic checksum: 636eddffd045f4ff6d3538514285824437eabde6]*/
 {
     int i;
-    PyObject* tag;
-    PyObject* namespaces = Py_None;
-    static char *kwlist[] = {"path", "namespaces", 0};
     elementtreestate *st = ET_STATE_GLOBAL;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:find", kwlist,
-                                     &tag, &namespaces))
-        return NULL;
-
-    if (checkpath(tag) || namespaces != Py_None) {
+    if (checkpath(path) || namespaces != Py_None) {
         _Py_IDENTIFIER(find);
         return _PyObject_CallMethodId(
-            st->elementpath_obj, &PyId_find, "OOO", self, tag, namespaces
+            st->elementpath_obj, &PyId_find, "OOO", self, path, namespaces
             );
     }
 
@@ -1100,7 +1314,7 @@
     for (i = 0; i < self->extra->length; i++) {
         PyObject* item = self->extra->children[i];
         if (Element_CheckExact(item) &&
-            PyObject_RichCompareBool(((ElementObject*)item)->tag, tag, Py_EQ) == 1) {
+            PyObject_RichCompareBool(((ElementObject*)item)->tag, path, Py_EQ) == 1) {
             Py_INCREF(item);
             return item;
         }
@@ -1109,24 +1323,55 @@
     Py_RETURN_NONE;
 }
 
-static PyObject*
-element_findtext(ElementObject *self, PyObject *args, PyObject *kwds)
+/*[clinic]
+_elementtree.Element.findtext
+
+    self: self(type='ElementObject *')
+    path: object
+    default: object = None
+    namespaces: object = None
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_findtext__doc__,
+"findtext(path, default=None, namespaces=None)");
+
+#define _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF    \
+    {"findtext", (PyCFunction)_elementtree_Element_findtext, METH_VARARGS|METH_KEYWORDS, _elementtree_Element_findtext__doc__},
+
+static PyObject *
+_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path, PyObject *default_value, PyObject *namespaces);
+
+static PyObject *
+_elementtree_Element_findtext(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"path", "default", "namespaces", NULL};
+    PyObject *path;
+    PyObject *default_value = Py_None;
+    PyObject *namespaces = Py_None;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "O|OO:findtext", _keywords,
+        &path, &default_value, &namespaces))
+        goto exit;
+    return_value = _elementtree_Element_findtext_impl((ElementObject *)self, path, default_value, namespaces);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_findtext_impl(ElementObject *self, PyObject *path, PyObject *default_value, PyObject *namespaces)
+/*[clinic checksum: e11bc8eaad5fdd9565e7c3178b9c62be33399896]*/
 {
     int i;
-    PyObject* tag;
-    PyObject* default_value = Py_None;
-    PyObject* namespaces = Py_None;
     _Py_IDENTIFIER(findtext);
-    static char *kwlist[] = {"path", "default", "namespaces", 0};
     elementtreestate *st = ET_STATE_GLOBAL;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO:findtext", kwlist,
-                                     &tag, &default_value, &namespaces))
-        return NULL;
-
-    if (checkpath(tag) || namespaces != Py_None)
+    if (checkpath(path) || namespaces != Py_None)
         return _PyObject_CallMethodId(
-            st->elementpath_obj, &PyId_findtext, "OOOO", self, tag, default_value, namespaces
+            st->elementpath_obj, &PyId_findtext, "OOOO", self, path, default_value, namespaces
             );
 
     if (!self->extra) {
@@ -1137,7 +1382,7 @@
     for (i = 0; i < self->extra->length; i++) {
         ElementObject* item = (ElementObject*) self->extra->children[i];
         if (Element_CheckExact(item) &&
-            (PyObject_RichCompareBool(item->tag, tag, Py_EQ) == 1)) {
+            (PyObject_RichCompareBool(item->tag, path, Py_EQ) == 1)) {
             PyObject* text = element_get_text(item);
             if (text == Py_None)
                 return PyUnicode_New(0, 0);
@@ -1150,20 +1395,51 @@
     return default_value;
 }
 
-static PyObject*
-element_findall(ElementObject *self, PyObject *args, PyObject *kwds)
+/*[clinic]
+_elementtree.Element.findall
+
+    self: self(type='ElementObject *')
+    path: object
+    namespaces: object = None
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_findall__doc__,
+"findall(path, namespaces=None)");
+
+#define _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF    \
+    {"findall", (PyCFunction)_elementtree_Element_findall, METH_VARARGS|METH_KEYWORDS, _elementtree_Element_findall__doc__},
+
+static PyObject *
+_elementtree_Element_findall_impl(ElementObject *self, PyObject *path, PyObject *namespaces);
+
+static PyObject *
+_elementtree_Element_findall(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"path", "namespaces", NULL};
+    PyObject *path;
+    PyObject *namespaces = Py_None;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "O|O:findall", _keywords,
+        &path, &namespaces))
+        goto exit;
+    return_value = _elementtree_Element_findall_impl((ElementObject *)self, path, namespaces);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_findall_impl(ElementObject *self, PyObject *path, PyObject *namespaces)
+/*[clinic checksum: e126482bd3635e7ccfb83ba5bfb12c282b509e44]*/
 {
     int i;
     PyObject* out;
-    PyObject* tag;
-    PyObject* namespaces = Py_None;
-    static char *kwlist[] = {"path", "namespaces", 0};
+    PyObject* tag = path;
     elementtreestate *st = ET_STATE_GLOBAL;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:findall", kwlist,
-                                     &tag, &namespaces))
-        return NULL;
-
     if (checkpath(tag) || namespaces != Py_None) {
         _Py_IDENTIFIER(findall);
         return _PyObject_CallMethodId(
@@ -1192,36 +1468,95 @@
     return out;
 }
 
-static PyObject*
-element_iterfind(ElementObject *self, PyObject *args, PyObject *kwds)
+/*[clinic]
+_elementtree.Element.iterfind
+
+    self: self(type='ElementObject *')
+    path: object
+    namespaces: object = None
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_iterfind__doc__,
+"iterfind(path, namespaces=None)");
+
+#define _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF    \
+    {"iterfind", (PyCFunction)_elementtree_Element_iterfind, METH_VARARGS|METH_KEYWORDS, _elementtree_Element_iterfind__doc__},
+
+static PyObject *
+_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path, PyObject *namespaces);
+
+static PyObject *
+_elementtree_Element_iterfind(PyObject *self, PyObject *args, PyObject *kwargs)
 {
-    PyObject* tag;
-    PyObject* namespaces = Py_None;
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"path", "namespaces", NULL};
+    PyObject *path;
+    PyObject *namespaces = Py_None;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "O|O:iterfind", _keywords,
+        &path, &namespaces))
+        goto exit;
+    return_value = _elementtree_Element_iterfind_impl((ElementObject *)self, path, namespaces);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_iterfind_impl(ElementObject *self, PyObject *path, PyObject *namespaces)
+/*[clinic checksum: 15f071c02d939b097f57c37132904e5bd19efa4c]*/
+{
+    PyObject* tag = path;
     _Py_IDENTIFIER(iterfind);
-    static char *kwlist[] = {"path", "namespaces", 0};
     elementtreestate *st = ET_STATE_GLOBAL;
 
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:iterfind", kwlist,
-                                     &tag, &namespaces)) {
-        return NULL;
-    }
-
     return _PyObject_CallMethodId(
         st->elementpath_obj, &PyId_iterfind, "OOO", self, tag, namespaces);
 }
 
-static PyObject*
-element_get(ElementObject* self, PyObject* args, PyObject* kwds)
+/*[clinic]
+_elementtree.Element.get
+
+    self: self(type='ElementObject *')
+    key: object
+    default: object = None
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_get__doc__,
+"get(key, default=None)");
+
+#define _ELEMENTTREE_ELEMENT_GET_METHODDEF    \
+    {"get", (PyCFunction)_elementtree_Element_get, METH_VARARGS|METH_KEYWORDS, _elementtree_Element_get__doc__},
+
+static PyObject *
+_elementtree_Element_get_impl(ElementObject *self, PyObject *key, PyObject *default_value);
+
+static PyObject *
+_elementtree_Element_get(PyObject *self, PyObject *args, PyObject *kwargs)
+{
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"key", "default", NULL};
+    PyObject *key;
+    PyObject *default_value = Py_None;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "O|O:get", _keywords,
+        &key, &default_value))
+        goto exit;
+    return_value = _elementtree_Element_get_impl((ElementObject *)self, key, default_value);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_get_impl(ElementObject *self, PyObject *key, PyObject *default_value)
+/*[clinic checksum: e75d56718f0ad49c6406aa429d271dd5e2fb8fd9]*/
 {
     PyObject* value;
-    static char* kwlist[] = {"key", "default", 0};
-
-    PyObject* key;
-    PyObject* default_value = Py_None;
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|O:get", kwlist, &key,
-                                     &default_value))
-        return NULL;
 
     if (!self->extra || self->extra->attrib == Py_None)
         value = default_value;
@@ -1235,17 +1570,41 @@
     return value;
 }
 
-static PyObject*
-element_getchildren(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.getchildren
+
+    self: self(type='ElementObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_getchildren__doc__,
+"getchildren()");
+
+#define _ELEMENTTREE_ELEMENT_GETCHILDREN_METHODDEF    \
+    {"getchildren", (PyCFunction)_elementtree_Element_getchildren, METH_NOARGS, _elementtree_Element_getchildren__doc__},
+
+static PyObject *
+_elementtree_Element_getchildren_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_getchildren(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_Element_getchildren_impl((ElementObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_getchildren_impl(ElementObject *self)
+/*[clinic checksum: afae4354dc5231ba76ce51be3fcf6146fa327d58]*/
 {
     int i;
     PyObject* list;
 
     /* FIXME: report as deprecated? */
 
-    if (!PyArg_ParseTuple(args, ":getchildren"))
-        return NULL;
-
     if (!self->extra)
         return PyList_New(0);
 
@@ -1267,25 +1626,78 @@
 create_elementiter(ElementObject *self, PyObject *tag, int gettext);
 
 
+/*[clinic]
+_elementtree.Element.iter
+
+    self: self(type='ElementObject *')
+    tag: object = None
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_iter__doc__,
+"iter(tag=None)");
+
+#define _ELEMENTTREE_ELEMENT_ITER_METHODDEF    \
+    {"iter", (PyCFunction)_elementtree_Element_iter, METH_VARARGS|METH_KEYWORDS, _elementtree_Element_iter__doc__},
+
 static PyObject *
-element_iter(ElementObject *self, PyObject *args, PyObject *kwds)
+_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag);
+
+static PyObject *
+_elementtree_Element_iter(PyObject *self, PyObject *args, PyObject *kwargs)
 {
-    PyObject* tag = Py_None;
-    static char* kwlist[] = {"tag", 0};
-
-    if (!PyArg_ParseTupleAndKeywords(args, kwds, "|O:iter", kwlist, &tag))
-        return NULL;
-
+    PyObject *return_value = NULL;
+    static char *_keywords[] = {"tag", NULL};
+    PyObject *tag = Py_None;
+
+    if (!PyArg_ParseTupleAndKeywords(args, kwargs,
+        "|O:iter", _keywords,
+        &tag))
+        goto exit;
+    return_value = _elementtree_Element_iter_impl((ElementObject *)self, tag);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_iter_impl(ElementObject *self, PyObject *tag)
+/*[clinic checksum: 996b1537be06ed54b57c9ee79cf05219dced62e3]*/
+{
     return create_elementiter(self, tag, 0);
 }
 
 
-static PyObject*
-element_itertext(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.itertext
+
+    self: self(type='ElementObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_itertext__doc__,
+"itertext()");
+
+#define _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF    \
+    {"itertext", (PyCFunction)_elementtree_Element_itertext, METH_NOARGS, _elementtree_Element_itertext__doc__},
+
+static PyObject *
+_elementtree_Element_itertext_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_itertext(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
-    if (!PyArg_ParseTuple(args, ":itertext"))
-        return NULL;
-
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_Element_itertext_impl((ElementObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_itertext_impl(ElementObject *self)
+/*[clinic checksum: 46ee60dbf63f1c07205dc267333aef4d47cec1c9]*/
+{
     return create_elementiter(self, Py_None, 1);
 }
 
@@ -1307,17 +1719,48 @@
     return self->extra->children[index];
 }
 
-static PyObject*
-element_insert(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.insert
+
+    self: self(type='ElementObject *')
+    index: int
+    subelement: object(type='Element_Type')
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_insert__doc__,
+"insert(index, subelement)");
+
+#define _ELEMENTTREE_ELEMENT_INSERT_METHODDEF    \
+    {"insert", (PyCFunction)_elementtree_Element_insert, METH_VARARGS, _elementtree_Element_insert__doc__},
+
+static PyObject *
+_elementtree_Element_insert_impl(ElementObject *self, int index, PyObject *subelement);
+
+static PyObject *
+_elementtree_Element_insert(PyObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    int index;
+    PyObject *subelement;
+
+    if (!PyArg_ParseTuple(args,
+        "iO!:insert",
+        &index, &Element_Type, &subelement))
+        goto exit;
+    return_value = _elementtree_Element_insert_impl((ElementObject *)self, index, subelement);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_insert_impl(ElementObject *self, int index, PyObject *subelement)
+/*[clinic checksum: 4c0b012490a6724e6933fcf4195d58109166c5fe]*/
 {
     int i;
 
-    int index;
-    PyObject* element;
-    if (!PyArg_ParseTuple(args, "iO!:insert", &index,
-                          &Element_Type, &element))
-        return NULL;
-
     if (!self->extra) {
         if (create_extra(self, NULL) < 0)
             return NULL;
@@ -1337,32 +1780,80 @@
     for (i = self->extra->length; i > index; i--)
         self->extra->children[i] = self->extra->children[i-1];
 
-    Py_INCREF(element);
-    self->extra->children[index] = element;
+    Py_INCREF(subelement);
+    self->extra->children[index] = subelement;
 
     self->extra->length++;
 
     Py_RETURN_NONE;
 }
 
-static PyObject*
-element_items(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.items
+
+    self: self(type='ElementObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_items__doc__,
+"items()");
+
+#define _ELEMENTTREE_ELEMENT_ITEMS_METHODDEF    \
+    {"items", (PyCFunction)_elementtree_Element_items, METH_NOARGS, _elementtree_Element_items__doc__},
+
+static PyObject *
+_elementtree_Element_items_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_items(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
-    if (!PyArg_ParseTuple(args, ":items"))
-        return NULL;
-
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_Element_items_impl((ElementObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_items_impl(ElementObject *self)
+/*[clinic checksum: 6da79e8ab42972f525e6e861b7c4a484f276355a]*/
+{
     if (!self->extra || self->extra->attrib == Py_None)
         return PyList_New(0);
 
     return PyDict_Items(self->extra->attrib);
 }
 
-static PyObject*
-element_keys(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.keys
+
+    self: self(type='ElementObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_keys__doc__,
+"keys()");
+
+#define _ELEMENTTREE_ELEMENT_KEYS_METHODDEF    \
+    {"keys", (PyCFunction)_elementtree_Element_keys, METH_NOARGS, _elementtree_Element_keys__doc__},
+
+static PyObject *
+_elementtree_Element_keys_impl(ElementObject *self);
+
+static PyObject *
+_elementtree_Element_keys(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
-    if (!PyArg_ParseTuple(args, ":keys"))
-        return NULL;
-
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_Element_keys_impl((ElementObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_keys_impl(ElementObject *self)
+/*[clinic checksum: 793f43a3dac2f01b7666d889f093e3f512d482f3]*/
+{
     if (!self->extra || self->extra->attrib == Py_None)
         return PyList_New(0);
 
@@ -1378,16 +1869,48 @@
     return self->extra->length;
 }
 
-static PyObject*
-element_makeelement(PyObject* self, PyObject* args, PyObject* kw)
+/*[clinic]
+_elementtree.Element.makeelement
+
+    self: self(type='ElementObject *')
+    tag: object
+    attrib: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_makeelement__doc__,
+"makeelement(tag, attrib)");
+
+#define _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF    \
+    {"makeelement", (PyCFunction)_elementtree_Element_makeelement, METH_VARARGS, _elementtree_Element_makeelement__doc__},
+
+static PyObject *
+_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag, PyObject *attrib);
+
+static PyObject *
+_elementtree_Element_makeelement(PyObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *tag;
+    PyObject *attrib;
+
+    if (!PyArg_ParseTuple(args,
+        "OO:makeelement",
+        &tag, &attrib))
+        goto exit;
+    return_value = _elementtree_Element_makeelement_impl((ElementObject *)self, tag, attrib);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_makeelement_impl(ElementObject *self, PyObject *tag, PyObject *attrib)
+/*[clinic checksum: a6361094d69138417544cf031f3df2d669510053]*/
 {
     PyObject* elem;
 
-    PyObject* tag;
-    PyObject* attrib;
-    if (!PyArg_ParseTuple(args, "OO:makeelement", &tag, &attrib))
-        return NULL;
-
     attrib = PyDict_Copy(attrib);
     if (!attrib)
         return NULL;
@@ -1399,15 +1922,46 @@
     return elem;
 }
 
-static PyObject*
-element_remove(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.remove
+
+    self: self(type='ElementObject *')
+    subelement: object(type='Element_Type')
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_remove__doc__,
+"remove(subelement)");
+
+#define _ELEMENTTREE_ELEMENT_REMOVE_METHODDEF    \
+    {"remove", (PyCFunction)_elementtree_Element_remove, METH_VARARGS, _elementtree_Element_remove__doc__},
+
+static PyObject *
+_elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement);
+
+static PyObject *
+_elementtree_Element_remove(PyObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *subelement;
+
+    if (!PyArg_ParseTuple(args,
+        "O!:remove",
+        &Element_Type, &subelement))
+        goto exit;
+    return_value = _elementtree_Element_remove_impl((ElementObject *)self, subelement);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_remove_impl(ElementObject *self, PyObject *subelement)
+/*[clinic checksum: f5fb026528096686ad8018e3c5478295ed91d583]*/
 {
     int i;
 
-    PyObject* element;
-    if (!PyArg_ParseTuple(args, "O!:remove", &Element_Type, &element))
-        return NULL;
-
     if (!self->extra) {
         /* element has no children, so raise exception */
         PyErr_SetString(
@@ -1418,14 +1972,14 @@
     }
 
     for (i = 0; i < self->extra->length; i++) {
-        if (self->extra->children[i] == element)
+        if (self->extra->children[i] == subelement)
             break;
-        if (PyObject_RichCompareBool(self->extra->children[i], element, Py_EQ) == 1)
+        if (PyObject_RichCompareBool(self->extra->children[i], subelement, Py_EQ) == 1)
             break;
     }
 
     if (i == self->extra->length) {
-        /* element is not in children, so raise exception */
+        /* subelement is not in children, so raise exception */
         PyErr_SetString(
             PyExc_ValueError,
             "list.remove(x): x not in list"
@@ -1452,16 +2006,48 @@
         return PyUnicode_FromFormat("<Element at %p>", self);
 }
 
-static PyObject*
-element_set(ElementObject* self, PyObject* args)
+/*[clinic]
+_elementtree.Element.set
+
+    self: self(type='ElementObject *')
+    key: object
+    value: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_Element_set__doc__,
+"set(key, value)");
+
+#define _ELEMENTTREE_ELEMENT_SET_METHODDEF    \
+    {"set", (PyCFunction)_elementtree_Element_set, METH_VARARGS, _elementtree_Element_set__doc__},
+
+static PyObject *
+_elementtree_Element_set_impl(ElementObject *self, PyObject *key, PyObject *value);
+
+static PyObject *
+_elementtree_Element_set(PyObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *key;
+    PyObject *value;
+
+    if (!PyArg_ParseTuple(args,
+        "OO:set",
+        &key, &value))
+        goto exit;
+    return_value = _elementtree_Element_set_impl((ElementObject *)self, key, value);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_Element_set_impl(ElementObject *self, PyObject *key, PyObject *value)
+/*[clinic checksum: bff41191c04d8ebb5ca002101771cc54575ef34c]*/
 {
     PyObject* attrib;
 
-    PyObject* key;
-    PyObject* value;
-    if (!PyArg_ParseTuple(args, "OO:set", &key, &value))
-        return NULL;
-
     if (!self->extra) {
         if (create_extra(self, NULL) < 0)
             return NULL;
@@ -1744,37 +2330,37 @@
 
 static PyMethodDef element_methods[] = {
 
-    {"clear", (PyCFunction) element_clearmethod, METH_VARARGS},
-
-    {"get", (PyCFunction) element_get, METH_VARARGS | METH_KEYWORDS},
-    {"set", (PyCFunction) element_set, METH_VARARGS},
-
-    {"find", (PyCFunction) element_find, METH_VARARGS | METH_KEYWORDS},
-    {"findtext", (PyCFunction) element_findtext, METH_VARARGS | METH_KEYWORDS},
-    {"findall", (PyCFunction) element_findall, METH_VARARGS | METH_KEYWORDS},
-
-    {"append", (PyCFunction) element_append, METH_VARARGS},
-    {"extend", (PyCFunction) element_extend, METH_VARARGS},
-    {"insert", (PyCFunction) element_insert, METH_VARARGS},
-    {"remove", (PyCFunction) element_remove, METH_VARARGS},
-
-    {"iter", (PyCFunction) element_iter, METH_VARARGS | METH_KEYWORDS},
-    {"itertext", (PyCFunction) element_itertext, METH_VARARGS},
-    {"iterfind", (PyCFunction) element_iterfind, METH_VARARGS | METH_KEYWORDS},
-
-    {"getiterator", (PyCFunction) element_iter, METH_VARARGS | METH_KEYWORDS},
-    {"getchildren", (PyCFunction) element_getchildren, METH_VARARGS},
-
-    {"items", (PyCFunction) element_items, METH_VARARGS},
-    {"keys", (PyCFunction) element_keys, METH_VARARGS},
-
-    {"makeelement", (PyCFunction) element_makeelement, METH_VARARGS},
-
-    {"__copy__", (PyCFunction) element_copy, METH_VARARGS},
-    {"__deepcopy__", (PyCFunction) element_deepcopy, METH_VARARGS},
-    {"__sizeof__", element_sizeof, METH_NOARGS},
-    {"__getstate__", (PyCFunction)element_getstate, METH_NOARGS},
-    {"__setstate__", (PyCFunction)element_setstate, METH_O},
+    _ELEMENTTREE_ELEMENT_CLEAR_METHODDEF
+
+    _ELEMENTTREE_ELEMENT_GET_METHODDEF
+    _ELEMENTTREE_ELEMENT_SET_METHODDEF
+
+    _ELEMENTTREE_ELEMENT_FIND_METHODDEF
+    _ELEMENTTREE_ELEMENT_FINDTEXT_METHODDEF
+    _ELEMENTTREE_ELEMENT_FINDALL_METHODDEF
+
+    _ELEMENTTREE_ELEMENT_APPEND_METHODDEF
+    _ELEMENTTREE_ELEMENT_EXTEND_METHODDEF
+    _ELEMENTTREE_ELEMENT_INSERT_METHODDEF
+    _ELEMENTTREE_ELEMENT_REMOVE_METHODDEF
+
+    _ELEMENTTREE_ELEMENT_ITER_METHODDEF
+    _ELEMENTTREE_ELEMENT_ITERTEXT_METHODDEF
+    _ELEMENTTREE_ELEMENT_ITERFIND_METHODDEF
+
+    {"getiterator", (PyCFunction)_elementtree_Element_iter, METH_VARARGS|METH_KEYWORDS, _elementtree_Element_iter__doc__},
+    _ELEMENTTREE_ELEMENT_GETCHILDREN_METHODDEF
+
+    _ELEMENTTREE_ELEMENT_ITEMS_METHODDEF
+    _ELEMENTTREE_ELEMENT_KEYS_METHODDEF
+
+    _ELEMENTTREE_ELEMENT_MAKEELEMENT_METHODDEF
+
+    _ELEMENTTREE_ELEMENT___COPY___METHODDEF
+    _ELEMENTTREE_ELEMENT___DEEPCOPY___METHODDEF
+    _ELEMENTTREE_ELEMENT___SIZEOF___METHODDEF
+    _ELEMENTTREE_ELEMENT___GETSTATE___METHODDEF
+    _ELEMENTTREE_ELEMENT___SETSTATE___METHODDEF
 
     {NULL, NULL}
 };
@@ -2262,6 +2848,11 @@
     return (PyObject *)t;
 }
 
+/*[clinic]
+class _elementtree.TreeBuilder
+[clinic]*/
+/*[clinic checksum: da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
+
 static int
 treebuilder_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
@@ -2598,23 +3189,47 @@
 /* -------------------------------------------------------------------- */
 /* methods (in alphabetical order) */
 
-static PyObject*
-treebuilder_data(TreeBuilderObject* self, PyObject* args)
+/*[clinic]
+_elementtree.TreeBuilder.data
+
+    self: self(type='TreeBuilderObject *')
+    data: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_TreeBuilder_data__doc__,
+"data(data)");
+
+#define _ELEMENTTREE_TREEBUILDER_DATA_METHODDEF    \
+    {"data", (PyCFunction)_elementtree_TreeBuilder_data, METH_O, _elementtree_TreeBuilder_data__doc__},
+
+static PyObject *
+_elementtree_TreeBuilder_data(TreeBuilderObject *self, PyObject *data)
+/*[clinic checksum: c8bc9ede07a4b79d1f937c442d6990ebc8b180db]*/
 {
-    PyObject* data;
-    if (!PyArg_ParseTuple(args, "O:data", &data))
-        return NULL;
-
     return treebuilder_handle_data(self, data);
 }
 
-static PyObject*
-treebuilder_end(TreeBuilderObject* self, PyObject* args)
+/*[clinic]
+_elementtree.TreeBuilder.end
+
+    self: self(type='TreeBuilderObject *')
+    tag: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_TreeBuilder_end__doc__,
+"end(tag)");
+
+#define _ELEMENTTREE_TREEBUILDER_END_METHODDEF    \
+    {"end", (PyCFunction)_elementtree_TreeBuilder_end, METH_O, _elementtree_TreeBuilder_end__doc__},
+
+static PyObject *
+_elementtree_TreeBuilder_end(TreeBuilderObject *self, PyObject *tag)
+/*[clinic checksum: 82bee0547d56fa6b029f8732b4d3c7f15f5d011c]*/
 {
-    PyObject* tag;
-    if (!PyArg_ParseTuple(args, "O:end", &tag))
-        return NULL;
-
     return treebuilder_handle_end(self, tag);
 }
 
@@ -2634,31 +3249,87 @@
     return res;
 }
 
-static PyObject*
-treebuilder_close(TreeBuilderObject* self, PyObject* args)
+/*[clinic]
+_elementtree.TreeBuilder.close
+
+    self: self(type='TreeBuilderObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_TreeBuilder_close__doc__,
+"close()");
+
+#define _ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF    \
+    {"close", (PyCFunction)_elementtree_TreeBuilder_close, METH_NOARGS, _elementtree_TreeBuilder_close__doc__},
+
+static PyObject *
+_elementtree_TreeBuilder_close_impl(TreeBuilderObject *self);
+
+static PyObject *
+_elementtree_TreeBuilder_close(PyObject *self, PyObject *Py_UNUSED(ignored))
 {
-    if (!PyArg_ParseTuple(args, ":close"))
-        return NULL;
-
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_TreeBuilder_close_impl((TreeBuilderObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_TreeBuilder_close_impl(TreeBuilderObject *self)
+/*[clinic checksum: 04499971c07c3de69d131ca3885664749c4a48b7]*/
+{
     return treebuilder_done(self);
 }
 
-static PyObject*
-treebuilder_start(TreeBuilderObject* self, PyObject* args)
+/*[clinic]
+_elementtree.TreeBuilder.start
+
+    self: self(type='TreeBuilderObject *')
+    tag: object
+    attrs: object = None
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_TreeBuilder_start__doc__,
+"start(tag, attrs=None)");
+
+#define _ELEMENTTREE_TREEBUILDER_START_METHODDEF    \
+    {"start", (PyCFunction)_elementtree_TreeBuilder_start, METH_VARARGS, _elementtree_TreeBuilder_start__doc__},
+
+static PyObject *
+_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag, PyObject *attrs);
+
+static PyObject *
+_elementtree_TreeBuilder_start(PyObject *self, PyObject *args)
 {
-    PyObject* tag;
-    PyObject* attrib = Py_None;
-    if (!PyArg_ParseTuple(args, "O|O:start", &tag, &attrib))
-        return NULL;
-
-    return treebuilder_handle_start(self, tag, attrib);
+    PyObject *return_value = NULL;
+    PyObject *tag;
+    PyObject *attrs = Py_None;
+
+    if (!PyArg_ParseTuple(args,
+        "O|O:start",
+        &tag, &attrs))
+        goto exit;
+    return_value = _elementtree_TreeBuilder_start_impl((TreeBuilderObject *)self, tag, attrs);
+
+exit:
+    return return_value;
 }
 
+static PyObject *
+_elementtree_TreeBuilder_start_impl(TreeBuilderObject *self, PyObject *tag, PyObject *attrs)
+/*[clinic checksum: e1c32bce2ff2880e4756348b489e1eace4b7c442]*/
+{
+    return treebuilder_handle_start(self, tag, attrs);
+}
+
 static PyMethodDef treebuilder_methods[] = {
-    {"data", (PyCFunction) treebuilder_data, METH_VARARGS},
-    {"start", (PyCFunction) treebuilder_start, METH_VARARGS},
-    {"end", (PyCFunction) treebuilder_end, METH_VARARGS},
-    {"close", (PyCFunction) treebuilder_close, METH_VARARGS},
+    _ELEMENTTREE_TREEBUILDER_DATA_METHODDEF
+    _ELEMENTTREE_TREEBUILDER_START_METHODDEF
+    _ELEMENTTREE_TREEBUILDER_END_METHODDEF
+    _ELEMENTTREE_TREEBUILDER_CLOSE_METHODDEF
     {NULL, NULL}
 };
 
@@ -3209,6 +3880,11 @@
     return (PyObject *)self;
 }
 
+/*[clinic]
+class _elementtree.XMLParser
+[clinic]*/
+/*[clinic checksum: da39a3ee5e6b4b0d3255bfef95601890afd80709]*/
+
 static int
 xmlparser_init(PyObject *self, PyObject *args, PyObject *kwds)
 {
@@ -3369,15 +4045,39 @@
     Py_RETURN_NONE;
 }
 
-static PyObject*
-xmlparser_close(XMLParserObject* self, PyObject* args)
+/*[clinic]
+_elementtree.XMLParser.close
+
+    self: self(type='XMLParserObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser_close__doc__,
+"close()");
+
+#define _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF    \
+    {"close", (PyCFunction)_elementtree_XMLParser_close, METH_NOARGS, _elementtree_XMLParser_close__doc__},
+
+static PyObject *
+_elementtree_XMLParser_close_impl(XMLParserObject *self);
+
+static PyObject *
+_elementtree_XMLParser_close(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_XMLParser_close_impl((XMLParserObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_XMLParser_close_impl(XMLParserObject *self)
+/*[clinic checksum: e559a2ddc0d5eb10cd73b4af4eef751d3f266757]*/
 {
     /* end feeding data to parser */
 
     PyObject* res;
-    if (!PyArg_ParseTuple(args, ":close"))
-        return NULL;
-
     res = expat_parse(self, "", 0, 1);
     if (!res)
         return NULL;
@@ -3395,15 +4095,31 @@
     }
 }
 
-static PyObject*
-xmlparser_feed(XMLParserObject* self, PyObject* arg)
+/*[clinic]
+_elementtree.XMLParser.feed
+
+    self: self(type='XMLParserObject *')
+    data: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser_feed__doc__,
+"feed(data)");
+
+#define _ELEMENTTREE_XMLPARSER_FEED_METHODDEF    \
+    {"feed", (PyCFunction)_elementtree_XMLParser_feed, METH_O, _elementtree_XMLParser_feed__doc__},
+
+static PyObject *
+_elementtree_XMLParser_feed(XMLParserObject *self, PyObject *data)
+/*[clinic checksum: 4946fd63df292c934b8f4d4a4c4d1e5d46330d61]*/
 {
     /* feed data to parser */
 
-    if (PyUnicode_Check(arg)) {
+    if (PyUnicode_Check(data)) {
         Py_ssize_t data_len;
-        const char *data = PyUnicode_AsUTF8AndSize(arg, &data_len);
-        if (data == NULL)
+        const char *data_ptr = PyUnicode_AsUTF8AndSize(data, &data_len);
+        if (data_ptr == NULL)
             return NULL;
         if (data_len > INT_MAX) {
             PyErr_SetString(PyExc_OverflowError, "size does not fit in an int");
@@ -3411,12 +4127,12 @@
         }
         /* Explicitly set UTF-8 encoding. Return code ignored. */
         (void)EXPAT(SetEncoding)(self->parser, "utf-8");
-        return expat_parse(self, data, (int)data_len, 0);
+        return expat_parse(self, data_ptr, (int)data_len, 0);
     }
     else {
         Py_buffer view;
         PyObject *res;
-        if (PyObject_GetBuffer(arg, &view, PyBUF_SIMPLE) < 0)
+        if (PyObject_GetBuffer(data, &view, PyBUF_SIMPLE) < 0)
             return NULL;
         if (view.len > INT_MAX) {
             PyBuffer_Release(&view);
@@ -3429,8 +4145,24 @@
     }
 }
 
-static PyObject*
-xmlparser_parse_whole(XMLParserObject* self, PyObject* args)
+/*[clinic]
+_elementtree.XMLParser._parse_whole
+
+    self: self(type='XMLParserObject *')
+    file: object
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser__parse_whole__doc__,
+"_parse_whole(file)");
+
+#define _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF    \
+    {"_parse_whole", (PyCFunction)_elementtree_XMLParser__parse_whole, METH_O, _elementtree_XMLParser__parse_whole__doc__},
+
+static PyObject *
+_elementtree_XMLParser__parse_whole(XMLParserObject *self, PyObject *file)
+/*[clinic checksum: 1de535f1ffda36f6063de9c643d867d05a7fabe4]*/
 {
     /* (internal) parse the whole input, until end of stream */
     PyObject* reader;
@@ -3438,11 +4170,7 @@
     PyObject* temp;
     PyObject* res;
 
-    PyObject* fileobj;
-    if (!PyArg_ParseTuple(args, "O:_parse", &fileobj))
-        return NULL;
-
-    reader = PyObject_GetAttrString(fileobj, "read");
+    reader = PyObject_GetAttrString(file, "read");
     if (!reader)
         return NULL;
 
@@ -3503,25 +4231,83 @@
     return res;
 }
 
-static PyObject*
-xmlparser_doctype(XMLParserObject *self, PyObject *args)
+/*[clinic]
+_elementtree.XMLParser.doctype
+
+    self: self(type='XMLParserObject *')
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser_doctype__doc__,
+"doctype()");
+
+#define _ELEMENTTREE_XMLPARSER_DOCTYPE_METHODDEF    \
+    {"doctype", (PyCFunction)_elementtree_XMLParser_doctype, METH_NOARGS, _elementtree_XMLParser_doctype__doc__},
+
+static PyObject *
+_elementtree_XMLParser_doctype_impl(XMLParserObject *self);
+
+static PyObject *
+_elementtree_XMLParser_doctype(PyObject *self, PyObject *Py_UNUSED(ignored))
+{
+    PyObject *return_value = NULL;
+
+    return_value = _elementtree_XMLParser_doctype_impl((XMLParserObject *)self);
+
+    return return_value;
+}
+
+static PyObject *
+_elementtree_XMLParser_doctype_impl(XMLParserObject *self)
+/*[clinic checksum: a4be49db2c4827ccbee8f4511468d05d0dec0281]*/
 {
     Py_RETURN_NONE;
 }
 
-static PyObject*
-xmlparser_setevents(XMLParserObject *self, PyObject* args)
+/*[clinic]
+_elementtree.XMLParser._setevents
+
+    self: self(type='XMLParserObject *')
+    events_queue: object(type='PyList_Type')
+    events_to_report: object = None
+    /
+
+[clinic]*/
+
+PyDoc_STRVAR(_elementtree_XMLParser__setevents__doc__,
+"_setevents(events_queue, events_to_report=None)");
+
+#define _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF    \
+    {"_setevents", (PyCFunction)_elementtree_XMLParser__setevents, METH_VARARGS, _elementtree_XMLParser__setevents__doc__},
+
+static PyObject *
+_elementtree_XMLParser__setevents_impl(XMLParserObject *self, PyObject *events_queue, PyObject *events_to_report);
+
+static PyObject *
+_elementtree_XMLParser__setevents(PyObject *self, PyObject *args)
+{
+    PyObject *return_value = NULL;
+    PyObject *events_queue;
+    PyObject *events_to_report = Py_None;
+
+    if (!PyArg_ParseTuple(args,
+        "O!|O:_setevents",
+        &PyList_Type, &events_queue, &events_to_report))
+        goto exit;
+    return_value = _elementtree_XMLParser__setevents_impl((XMLParserObject *)self, events_queue, events_to_report);
+
+exit:
+    return return_value;
+}
+
+static PyObject *
+_elementtree_XMLParser__setevents_impl(XMLParserObject *self, PyObject *events_queue, PyObject *events_to_report)
+/*[clinic checksum: d97a20e17e200d3e0b01d748357d029d58e63f62]*/
 {
     /* activate element event reporting */
     Py_ssize_t i, seqlen;
     TreeBuilderObject *target;
-
-    PyObject *events_queue;
-    PyObject *events_to_report = Py_None;
     PyObject *events_seq;
-    if (!PyArg_ParseTuple(args, "O!|O:_setevents",  &PyList_Type, &events_queue,
-                          &events_to_report))
-        return NULL;
 
     if (!TreeBuilder_CheckExact(self->target)) {
         PyErr_SetString(
@@ -3606,11 +4392,11 @@
 }
 
 static PyMethodDef xmlparser_methods[] = {
-    {"feed", (PyCFunction) xmlparser_feed, METH_O},
-    {"close", (PyCFunction) xmlparser_close, METH_VARARGS},
-    {"_parse_whole", (PyCFunction) xmlparser_parse_whole, METH_VARARGS},
-    {"_setevents", (PyCFunction) xmlparser_setevents, METH_VARARGS},
-    {"doctype", (PyCFunction) xmlparser_doctype, METH_VARARGS},
+    _ELEMENTTREE_XMLPARSER_FEED_METHODDEF
+    _ELEMENTTREE_XMLPARSER_CLOSE_METHODDEF
+    _ELEMENTTREE_XMLPARSER__PARSE_WHOLE_METHODDEF
+    _ELEMENTTREE_XMLPARSER__SETEVENTS_METHODDEF
+    _ELEMENTTREE_XMLPARSER_DOCTYPE_METHODDEF
     {NULL, NULL}
 };