diff --git a/Include/unicodeobject.h b/Include/unicodeobject.h
index 524ce8a..a1725e5 100644
--- a/Include/unicodeobject.h
+++ b/Include/unicodeobject.h
@@ -2031,7 +2031,7 @@
 
    do
 
-       _Py_identifier(foo);
+       _Py_IDENTIFIER(foo);
        ...
        r = _PyObject_CallMethodId(o, &PyId_foo, "args", ...);
 
@@ -2050,7 +2050,7 @@
 } _Py_Identifier;
 
 #define _Py_static_string(varname, value)  static _Py_Identifier varname = { 0, value, 0 }
-#define _Py_identifier(varname) _Py_static_string(PyId_##varname, #varname)
+#define _Py_IDENTIFIER(varname) _Py_static_string(PyId_##varname, #varname)
 
 /* Return an interned Unicode object for an Identifier; may fail if there is no memory.*/
 PyAPI_FUNC(PyObject*) _PyUnicode_FromId(_Py_Identifier*);
diff --git a/Modules/_bisectmodule.c b/Modules/_bisectmodule.c
index 9da255e..8cda642 100644
--- a/Modules/_bisectmodule.c
+++ b/Modules/_bisectmodule.c
@@ -86,7 +86,7 @@
         if (PyList_Insert(list, index, item) < 0)
             return NULL;
     } else {
-        _Py_identifier(insert);
+        _Py_IDENTIFIER(insert);
 
         result = _PyObject_CallMethodId(list, &PyId_insert, "nO", index, item);
         if (result == NULL)
@@ -188,7 +188,7 @@
         if (PyList_Insert(list, index, item) < 0)
             return NULL;
     } else {
-        _Py_identifier(insert);
+        _Py_IDENTIFIER(insert);
 
         result = _PyObject_CallMethodId(list, &PyId_insert, "iO", index, item);
         if (result == NULL)
diff --git a/Modules/_collectionsmodule.c b/Modules/_collectionsmodule.c
index 0c68aa8..efce5ce 100644
--- a/Modules/_collectionsmodule.c
+++ b/Modules/_collectionsmodule.c
@@ -767,7 +767,7 @@
 deque_reduce(dequeobject *deque)
 {
     PyObject *dict, *result, *aslist;
-    _Py_identifier(__dict__);
+    _Py_IDENTIFIER(__dict__);
 
     dict = _PyObject_GetAttrId((PyObject *)deque, &PyId___dict__);
     if (dict == NULL)
@@ -1335,7 +1335,7 @@
     PyObject *items;
     PyObject *iter;
     PyObject *result;
-    _Py_identifier(items);
+    _Py_IDENTIFIER(items);
 
     if (dd->default_factory == NULL || dd->default_factory == Py_None)
         args = PyTuple_New(0);
diff --git a/Modules/_csv.c b/Modules/_csv.c
index 59c74e7..627c3b1 100644
--- a/Modules/_csv.c
+++ b/Modules/_csv.c
@@ -1317,7 +1317,7 @@
 {
     PyObject * output_file, * dialect = NULL;
     WriterObj * self = PyObject_GC_New(WriterObj, &Writer_Type);
-    _Py_identifier(write);
+    _Py_IDENTIFIER(write);
 
     if (!self)
         return NULL;
diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index 1d7cf94..e08dea1a 100644
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -3679,7 +3679,7 @@
             PyTuple_SET_ITEM(tup, index, v);
             index++;
         } else if (bit & outmask) {
-            _Py_identifier(__ctypes_from_outparam__);
+            _Py_IDENTIFIER(__ctypes_from_outparam__);
 
             v = PyTuple_GET_ITEM(callargs, i);
             v = _PyObject_CallMethodId(v, &PyId___ctypes_from_outparam__, NULL);
diff --git a/Modules/_ctypes/callproc.c b/Modules/_ctypes/callproc.c
index adc2870..dd441f5 100644
--- a/Modules/_ctypes/callproc.c
+++ b/Modules/_ctypes/callproc.c
@@ -1687,8 +1687,8 @@
     PyObject *state;
     PyObject *result;
     PyObject *tmp;
-    _Py_identifier(__new__);
-    _Py_identifier(__setstate__);
+    _Py_IDENTIFIER(__new__);
+    _Py_IDENTIFIER(__setstate__);
 
     if (!PyArg_ParseTuple(args, "OO", &typ, &state))
         return NULL;
diff --git a/Modules/_cursesmodule.c b/Modules/_cursesmodule.c
index 7c89acc..dddaa3a 100644
--- a/Modules/_cursesmodule.c
+++ b/Modules/_cursesmodule.c
@@ -1418,7 +1418,7 @@
     while (1) {
         char buf[BUFSIZ];
         Py_ssize_t n = fread(buf, 1, BUFSIZ, fp);
-        _Py_identifier(write);
+        _Py_IDENTIFIER(write);
 
         if (n <= 0)
             break;
@@ -1913,7 +1913,7 @@
     WINDOW *win;
 
     PyCursesInitialised;
-    _Py_identifier(read);
+    _Py_IDENTIFIER(read);
 
     strcpy(fn, "/tmp/py.curses.getwin.XXXXXX");
     fd = mkstemp(fn);
diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
index 4dceaa9..316e1d7 100644
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -946,7 +946,7 @@
 call_tzname(PyObject *tzinfo, PyObject *tzinfoarg)
 {
     PyObject *result;
-    _Py_identifier(tzname);
+    _Py_IDENTIFIER(tzname);
 
     assert(tzinfo != NULL);
     assert(check_tzinfo_subclass(tzinfo) >= 0);
@@ -1079,7 +1079,7 @@
     PyObject *temp;
     PyObject *tzinfo = get_tzinfo_member(object);
     PyObject *Zreplacement = PyUnicode_FromStringAndSize(NULL, 0);
-    _Py_identifier(replace);
+    _Py_IDENTIFIER(replace);
 	
     if (Zreplacement == NULL)
         return NULL;
@@ -1289,7 +1289,7 @@
             goto Done;
         format = PyUnicode_FromString(PyBytes_AS_STRING(newfmt));
         if (format != NULL) {
-            _Py_identifier(strftime);
+            _Py_IDENTIFIER(strftime);
 
             result = _PyObject_CallMethodId(time, &PyId_strftime, "OO",
                                             format, timetuple, NULL);
@@ -1318,7 +1318,7 @@
     PyObject *time = PyImport_ImportModuleNoBlock("time");
 
     if (time != NULL) {
-        _Py_identifier(time);
+        _Py_IDENTIFIER(time);
 
         result = _PyObject_CallMethodId(time, &PyId_time, "()");
         Py_DECREF(time);
@@ -1337,7 +1337,7 @@
 
     time = PyImport_ImportModuleNoBlock("time");
     if (time != NULL) {
-        _Py_identifier(struct_time);
+        _Py_IDENTIFIER(struct_time);
 
         result = _PyObject_CallMethodId(time, &PyId_struct_time,
                                         "((iiiiiiiii))",
@@ -1578,7 +1578,7 @@
     PyObject *result = NULL;
     PyObject *pyus_in = NULL, *temp, *pyus_out;
     PyObject *ratio = NULL;
-    _Py_identifier(as_integer_ratio);
+    _Py_IDENTIFIER(as_integer_ratio);
 
     pyus_in = delta_to_microseconds(delta);
     if (pyus_in == NULL)
@@ -1677,7 +1677,7 @@
     PyObject *result = NULL;
     PyObject *pyus_in = NULL, *temp, *pyus_out;
     PyObject *ratio = NULL;
-    _Py_identifier(as_integer_ratio);
+    _Py_IDENTIFIER(as_integer_ratio);
 
     pyus_in = delta_to_microseconds(delta);
     if (pyus_in == NULL)
@@ -2473,7 +2473,7 @@
 {
     PyObject *time;
     PyObject *result;
-    _Py_identifier(fromtimestamp);
+    _Py_IDENTIFIER(fromtimestamp);
 
     time = time_time();
     if (time == NULL)
@@ -2626,7 +2626,7 @@
 static PyObject *
 date_str(PyDateTime_Date *self)
 {
-    _Py_identifier(isoformat);
+    _Py_IDENTIFIER(isoformat);
 
     return _PyObject_CallMethodId((PyObject *)self, &PyId_isoformat, "()");
 }
@@ -2647,7 +2647,7 @@
     PyObject *result;
     PyObject *tuple;
     PyObject *format;
-    _Py_identifier(timetuple);
+    _Py_IDENTIFIER(timetuple);
     static char *keywords[] = {"format", NULL};
 
     if (! PyArg_ParseTupleAndKeywords(args, kw, "U:strftime", keywords,
@@ -2667,7 +2667,7 @@
 date_format(PyDateTime_Date *self, PyObject *args)
 {
     PyObject *format;
-    _Py_identifier(strftime);
+    _Py_IDENTIFIER(strftime);
 
     if (!PyArg_ParseTuple(args, "U:__format__", &format))
         return NULL;
@@ -3077,8 +3077,8 @@
 {
     PyObject *args, *state, *tmp;
     PyObject *getinitargs, *getstate;
-    _Py_identifier(__getinitargs__);
-    _Py_identifier(__getstate__);
+    _Py_IDENTIFIER(__getinitargs__);
+    _Py_IDENTIFIER(__getstate__);
 
     tmp = PyTuple_New(0);
     if (tmp == NULL)
@@ -3592,7 +3592,7 @@
 static PyObject *
 time_str(PyDateTime_Time *self)
 {
-    _Py_identifier(isoformat);
+    _Py_IDENTIFIER(isoformat);
 
     return _PyObject_CallMethodId((PyObject *)self, &PyId_isoformat, "()");
 }
@@ -4173,7 +4173,7 @@
     if (self != NULL && tzinfo != Py_None) {
         /* Convert UTC to tzinfo's zone. */
         PyObject *temp = self;
-        _Py_identifier(fromutc);
+        _Py_IDENTIFIER(fromutc);
 
         self = _PyObject_CallMethodId(tzinfo, &PyId_fromutc, "O", self);
         Py_DECREF(temp);
@@ -4212,7 +4212,7 @@
     if (self != NULL && tzinfo != Py_None) {
         /* Convert UTC to tzinfo's zone. */
         PyObject *temp = self;
-        _Py_identifier(fromutc);
+        _Py_IDENTIFIER(fromutc);
 
         self = _PyObject_CallMethodId(tzinfo, &PyId_fromutc, "O", self);
         Py_DECREF(temp);
@@ -4239,7 +4239,7 @@
 {
     static PyObject *module = NULL;
     PyObject *string, *format;
-    _Py_identifier(_strptime_datetime);
+    _Py_IDENTIFIER(_strptime_datetime);
 
     if (!PyArg_ParseTuple(args, "UU:strptime", &string, &format))
         return NULL;
@@ -4495,7 +4495,7 @@
 static PyObject *
 datetime_str(PyDateTime_DateTime *self)
 {
-    _Py_identifier(isoformat);
+    _Py_IDENTIFIER(isoformat);
 
     return _PyObject_CallMethodId((PyObject *)self, &PyId_isoformat, "(s)", " ");
 }
@@ -4704,7 +4704,7 @@
     PyObject *offset;
     PyObject *temp;
     PyObject *tzinfo;
-    _Py_identifier(fromutc);
+    _Py_IDENTIFIER(fromutc);
     static char *keywords[] = {"tz", NULL};
 
     if (! PyArg_ParseTupleAndKeywords(args, kw, "O!:astimezone", keywords,
diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
index fcd1271..1fb6038 100644
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -797,7 +797,7 @@
         return NULL;
 
     if (checkpath(tag) || namespaces != Py_None) {
-        _Py_identifier(find);
+        _Py_IDENTIFIER(find);
         return _PyObject_CallMethodId(
             elementpath_obj, &PyId_find, "OOO", self, tag, namespaces
             );
@@ -825,7 +825,7 @@
     PyObject* tag;
     PyObject* default_value = Py_None;
     PyObject* namespaces = Py_None;
-    _Py_identifier(findtext);
+    _Py_IDENTIFIER(findtext);
 
     if (!PyArg_ParseTuple(args, "O|OO:findtext", &tag, &default_value, &namespaces))
         return NULL;
@@ -868,7 +868,7 @@
         return NULL;
 
     if (checkpath(tag) || namespaces != Py_None) {
-        _Py_identifier(findall);
+        _Py_IDENTIFIER(findall);
         return _PyObject_CallMethodId(
             elementpath_obj, &PyId_findall, "OOO", self, tag, namespaces
             );
@@ -900,7 +900,7 @@
 {
     PyObject* tag;
     PyObject* namespaces = Py_None;
-    _Py_identifier(iterfind);
+    _Py_IDENTIFIER(iterfind);
 
     if (!PyArg_ParseTuple(args, "O|O:iterfind", &tag, &namespaces))
         return NULL;
diff --git a/Modules/_io/_iomodule.c b/Modules/_io/_iomodule.c
index 9061a41..2ad002e 100644
--- a/Modules/_io/_iomodule.c
+++ b/Modules/_io/_iomodule.c
@@ -225,8 +225,8 @@
 
     PyObject *raw, *modeobj = NULL, *buffer = NULL, *wrapper = NULL;
 
-    _Py_identifier(isatty);
-    _Py_identifier(fileno);
+    _Py_IDENTIFIER(isatty);
+    _Py_IDENTIFIER(fileno);
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|sizzzi:open", kwlist,
                                      &file, &mode, &buffering,
diff --git a/Modules/_io/bufferedio.c b/Modules/_io/bufferedio.c
index c72bfb9..880ed78 100644
--- a/Modules/_io/bufferedio.c
+++ b/Modules/_io/bufferedio.c
@@ -13,17 +13,17 @@
 #include "pythread.h"
 #include "_iomodule.h"
 
-_Py_identifier(close);
-_Py_identifier(_dealloc_warn);
-_Py_identifier(flush);
-_Py_identifier(isatty);
-_Py_identifier(peek);
-_Py_identifier(read);
-_Py_identifier(read1);
-_Py_identifier(readable);
-_Py_identifier(readinto);
-_Py_identifier(writable);
-_Py_identifier(write);
+_Py_IDENTIFIER(close);
+_Py_IDENTIFIER(_dealloc_warn);
+_Py_IDENTIFIER(flush);
+_Py_IDENTIFIER(isatty);
+_Py_IDENTIFIER(peek);
+_Py_IDENTIFIER(read);
+_Py_IDENTIFIER(read1);
+_Py_IDENTIFIER(readable);
+_Py_IDENTIFIER(readinto);
+_Py_IDENTIFIER(writable);
+_Py_IDENTIFIER(write);
 
 /*
  * BufferedIOBase class, inherits from IOBase.
@@ -50,7 +50,7 @@
     Py_buffer buf;
     Py_ssize_t len;
     PyObject *data;
-    _Py_identifier(read);
+    _Py_IDENTIFIER(read);
 
     if (!PyArg_ParseTuple(args, "w*:readinto", &buf)) {
         return NULL;
diff --git a/Modules/_io/fileio.c b/Modules/_io/fileio.c
index c6b89f3..acb0097 100644
--- a/Modules/_io/fileio.c
+++ b/Modules/_io/fileio.c
@@ -122,7 +122,7 @@
 static PyObject *
 fileio_close(fileio *self)
 {
-    _Py_identifier(close);
+    _Py_IDENTIFIER(close);
     if (!self->closefd) {
         self->fd = -1;
         Py_RETURN_NONE;
diff --git a/Modules/_io/iobase.c b/Modules/_io/iobase.c
index 6a94a04..52f6aa0 100644
--- a/Modules/_io/iobase.c
+++ b/Modules/_io/iobase.c
@@ -97,7 +97,7 @@
 static PyObject *
 iobase_tell(PyObject *self, PyObject *args)
 {
-    _Py_identifier(seek);
+    _Py_IDENTIFIER(seek);
 
     return _PyObject_CallMethodId(self, &PyId_seek, "ii", 0, 1);
 }
@@ -466,7 +466,7 @@
     int has_peek = 0;
     PyObject *buffer, *result;
     Py_ssize_t old_size = -1;
-    _Py_identifier(read);
+    _Py_IDENTIFIER(read);
 
     if (!PyArg_ParseTuple(args, "|O&:readline", &_PyIO_ConvertSsize_t, &limit)) {
         return NULL;
@@ -484,7 +484,7 @@
         PyObject *b;
 
         if (has_peek) {
-            _Py_identifier(peek);
+            _Py_IDENTIFIER(peek);
             PyObject *readahead = _PyObject_CallMethodId(self, &PyId_peek, "i", 1);
 
             if (readahead == NULL)
@@ -606,7 +606,7 @@
         /* XXX special-casing this made sense in the Python version in order
            to remove the bytecode interpretation overhead, but it could
            probably be removed here. */
-        _Py_identifier(extend);
+        _Py_IDENTIFIER(extend);
         PyObject *ret = _PyObject_CallMethodId(result, &PyId_extend, "O", self);
 
         if (ret == NULL) {
@@ -789,7 +789,7 @@
     }
 
     if (n < 0) {
-        _Py_identifier(readall);
+        _Py_IDENTIFIER(readall);
 
         return _PyObject_CallMethodId(self, &PyId_readall, NULL);
     }
@@ -833,7 +833,7 @@
         return NULL;
 
     while (1) {
-        _Py_identifier(read);
+        _Py_IDENTIFIER(read);
         PyObject *data = _PyObject_CallMethodId(self, &PyId_read,
                                                 "i", DEFAULT_BUFFER_SIZE);
         if (!data) {
diff --git a/Modules/_io/textio.c b/Modules/_io/textio.c
index 2ded719..c63c3c7 100644
--- a/Modules/_io/textio.c
+++ b/Modules/_io/textio.c
@@ -11,23 +11,23 @@
 #include "structmember.h"
 #include "_iomodule.h"
 
-_Py_identifier(close);
-_Py_identifier(_dealloc_warn);
-_Py_identifier(decode);
-_Py_identifier(device_encoding);
-_Py_identifier(fileno);
-_Py_identifier(flush);
-_Py_identifier(getpreferredencoding);
-_Py_identifier(isatty);
-_Py_identifier(read);
-_Py_identifier(readable);
-_Py_identifier(replace);
-_Py_identifier(reset);
-_Py_identifier(seek);
-_Py_identifier(seekable);
-_Py_identifier(setstate);
-_Py_identifier(tell);
-_Py_identifier(writable);
+_Py_IDENTIFIER(close);
+_Py_IDENTIFIER(_dealloc_warn);
+_Py_IDENTIFIER(decode);
+_Py_IDENTIFIER(device_encoding);
+_Py_IDENTIFIER(fileno);
+_Py_IDENTIFIER(flush);
+_Py_IDENTIFIER(getpreferredencoding);
+_Py_IDENTIFIER(isatty);
+_Py_IDENTIFIER(read);
+_Py_IDENTIFIER(readable);
+_Py_IDENTIFIER(replace);
+_Py_IDENTIFIER(reset);
+_Py_IDENTIFIER(seek);
+_Py_IDENTIFIER(seekable);
+_Py_IDENTIFIER(setstate);
+_Py_IDENTIFIER(tell);
+_Py_IDENTIFIER(writable);
 
 /* TextIOBase */
 
diff --git a/Modules/_pickle.c b/Modules/_pickle.c
index ad185a7..2c29b20 100644
--- a/Modules/_pickle.c
+++ b/Modules/_pickle.c
@@ -826,7 +826,7 @@
 static int
 _Pickler_SetOutputStream(PicklerObject *self, PyObject *file)
 {
-    _Py_identifier(write);
+    _Py_IDENTIFIER(write);
     assert(file != NULL);
     self->write = _PyObject_GetAttrId(file, &PyId_write);
     if (self->write == NULL) {
@@ -1174,9 +1174,9 @@
 static int
 _Unpickler_SetInputStream(UnpicklerObject *self, PyObject *file)
 {
-    _Py_identifier(peek);
-    _Py_identifier(read);
-    _Py_identifier(readline);
+    _Py_IDENTIFIER(peek);
+    _Py_IDENTIFIER(read);
+    _Py_IDENTIFIER(readline);
 
     self->peek = _PyObject_GetAttrId(file, &PyId_peek);
     if (self->peek == NULL) {
@@ -2492,7 +2492,7 @@
             status = batch_dict_exact(self, obj);
             Py_LeaveRecursiveCall();
         } else {
-            _Py_identifier(items);
+            _Py_IDENTIFIER(items);
 
             items = _PyObject_CallMethodId(obj, &PyId_items, "()");
             if (items == NULL)
@@ -3394,7 +3394,7 @@
     PyObject *file;
     PyObject *proto_obj = NULL;
     PyObject *fix_imports = Py_True;
-    _Py_identifier(persistent_id);
+    _Py_IDENTIFIER(persistent_id);
 
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|OO:Pickler",
                                      kwlist, &file, &proto_obj, &fix_imports))
@@ -3781,7 +3781,7 @@
 static PyObject *
 find_class(UnpicklerObject *self, PyObject *module_name, PyObject *global_name)
 {
-    _Py_identifier(find_class);
+    _Py_IDENTIFIER(find_class);
 
     return _PyObject_CallMethodId((PyObject *)self, &PyId_find_class, "OO",
                                   module_name, global_name);
@@ -4397,7 +4397,7 @@
         result = PyObject_CallObject(cls, args);
     }
     else {
-        _Py_identifier(__new__);
+        _Py_IDENTIFIER(__new__);
 
         result = _PyObject_CallMethodId(cls, &PyId___new__, "O", cls);
     }
@@ -4940,7 +4940,7 @@
     }
     else {
         PyObject *append_func;
-        _Py_identifier(append);
+        _Py_IDENTIFIER(append);
 
         append_func = _PyObject_GetAttrId(list, &PyId_append);
         if (append_func == NULL)
@@ -5029,7 +5029,7 @@
     PyObject *state, *inst, *slotstate;
     PyObject *setstate;
     int status = 0;
-    _Py_identifier(__setstate__);
+    _Py_IDENTIFIER(__setstate__);
 
     /* Stack is ... instance, state.  We want to leave instance at
      * the stack top, possibly mutated via instance.__setstate__(state).
@@ -5086,7 +5086,7 @@
         PyObject *dict;
         PyObject *d_key, *d_value;
         Py_ssize_t i;
-        _Py_identifier(__dict__);
+        _Py_IDENTIFIER(__dict__);
 
         if (!PyDict_Check(state)) {
             PyErr_SetString(UnpicklingError, "state is not a dictionary");
@@ -5592,7 +5592,7 @@
         return -1;
 
     if (PyObject_HasAttrString((PyObject *)self, "persistent_load")) {
-        _Py_identifier(persistent_load);
+        _Py_IDENTIFIER(persistent_load);
         self->pers_func = _PyObject_GetAttrId((PyObject *)self,
                                               &PyId_persistent_load);
         if (self->pers_func == NULL)
diff --git a/Modules/_posixsubprocess.c b/Modules/_posixsubprocess.c
index e6a9283..301f2a5 100644
--- a/Modules/_posixsubprocess.c
+++ b/Modules/_posixsubprocess.c
@@ -18,7 +18,7 @@
 static int _enable_gc(PyObject *gc_module)
 {
     PyObject *result;
-    _Py_identifier(enable);
+    _Py_IDENTIFIER(enable);
 
     result = _PyObject_CallMethodId(gc_module, &PyId_enable, NULL);
     if (result == NULL)
@@ -251,8 +251,8 @@
     /* We need to call gc.disable() when we'll be calling preexec_fn */
     if (preexec_fn != Py_None) {
         PyObject *result;
-        _Py_identifier(isenabled);
-        _Py_identifier(disable);
+        _Py_IDENTIFIER(isenabled);
+        _Py_IDENTIFIER(disable);
         
         gc_module = PyImport_ImportModule("gc");
         if (gc_module == NULL)
diff --git a/Modules/_sqlite/connection.c b/Modules/_sqlite/connection.c
index c2f218f..5cbf418 100644
--- a/Modules/_sqlite/connection.c
+++ b/Modules/_sqlite/connection.c
@@ -675,7 +675,7 @@
 {
     PyObject* function_result = NULL;
     PyObject** aggregate_instance;
-    _Py_identifier(finalize);
+    _Py_IDENTIFIER(finalize);
 
 #ifdef WITH_THREAD
     PyGILState_STATE threadstate;
@@ -1231,7 +1231,7 @@
     PyObject* cursor = 0;
     PyObject* result = 0;
     PyObject* method = 0;
-    _Py_identifier(cursor);
+    _Py_IDENTIFIER(cursor);
 
     cursor = _PyObject_CallMethodId((PyObject*)self, &PyId_cursor, "");
     if (!cursor) {
@@ -1261,7 +1261,7 @@
     PyObject* cursor = 0;
     PyObject* result = 0;
     PyObject* method = 0;
-    _Py_identifier(cursor);
+    _Py_IDENTIFIER(cursor);
 
     cursor = _PyObject_CallMethodId((PyObject*)self, &PyId_cursor, "");
     if (!cursor) {
@@ -1291,7 +1291,7 @@
     PyObject* cursor = 0;
     PyObject* result = 0;
     PyObject* method = 0;
-    _Py_identifier(cursor);
+    _Py_IDENTIFIER(cursor);
 
     cursor = _PyObject_CallMethodId((PyObject*)self, &PyId_cursor, "");
     if (!cursor) {
@@ -1441,7 +1441,7 @@
     PyObject* name;
     PyObject* retval;
     Py_ssize_t i, len;
-    _Py_identifier(upper);
+    _Py_IDENTIFIER(upper);
     char *uppercase_name_str;
     int rc;
     unsigned int kind;
diff --git a/Modules/_sqlite/cursor.c b/Modules/_sqlite/cursor.c
index b47fed4..75ee73a 100644
--- a/Modules/_sqlite/cursor.c
+++ b/Modules/_sqlite/cursor.c
@@ -150,7 +150,7 @@
 {
     PyObject* upcase_key;
     PyObject* retval;
-    _Py_identifier(upper);
+    _Py_IDENTIFIER(upper);
 
     upcase_key = _PyObject_CallMethodId(key, &PyId_upper, "");
     if (!upcase_key) {
diff --git a/Modules/_sqlite/microprotocols.c b/Modules/_sqlite/microprotocols.c
index c0f5e22..2261b80 100644
--- a/Modules/_sqlite/microprotocols.c
+++ b/Modules/_sqlite/microprotocols.c
@@ -95,7 +95,7 @@
 
     /* try to have the protocol adapt this object*/
     if (PyObject_HasAttrString(proto, "__adapt__")) {
-        _Py_identifier(__adapt__);
+        _Py_IDENTIFIER(__adapt__);
         PyObject *adapted = _PyObject_CallMethodId(proto, &PyId___adapt__, "O", obj);
 
         if (adapted) {
@@ -112,7 +112,7 @@
 
     /* and finally try to have the object adapt itself */
     if (PyObject_HasAttrString(obj, "__conform__")) {
-        _Py_identifier(__conform__);
+        _Py_IDENTIFIER(__conform__);
         PyObject *adapted = _PyObject_CallMethodId(obj, &PyId___conform__,"O", proto);
 
         if (adapted) {
diff --git a/Modules/_sqlite/module.c b/Modules/_sqlite/module.c
index 20e1ec7..406d787 100644
--- a/Modules/_sqlite/module.c
+++ b/Modules/_sqlite/module.c
@@ -179,7 +179,7 @@
     PyObject* name = NULL;
     PyObject* callable;
     PyObject* retval = NULL;
-    _Py_identifier(upper);
+    _Py_IDENTIFIER(upper);
 
     if (!PyArg_ParseTuple(args, "UO", &orig_name, &callable)) {
         return NULL;
diff --git a/Modules/arraymodule.c b/Modules/arraymodule.c
index cb86de7..b2d368d 100644
--- a/Modules/arraymodule.c
+++ b/Modules/arraymodule.c
@@ -1253,7 +1253,7 @@
     PyObject *f, *b, *res;
     Py_ssize_t itemsize = self->ob_descr->itemsize;
     Py_ssize_t n, nbytes;
-    _Py_identifier(read);
+    _Py_IDENTIFIER(read);
     int not_enough_bytes;
 
     if (!PyArg_ParseTuple(args, "On:fromfile", &f, &n))
@@ -1322,7 +1322,7 @@
         char* ptr = self->ob_item + i*BLOCKSIZE;
         Py_ssize_t size = BLOCKSIZE;
         PyObject *bytes, *res;
-        _Py_identifier(write);
+        _Py_IDENTIFIER(write);
 
         if (i*BLOCKSIZE + size > nbytes)
             size = nbytes - i*BLOCKSIZE;
@@ -2003,8 +2003,8 @@
     int mformat_code;
     static PyObject *array_reconstructor = NULL;
     long protocol;
-    _Py_identifier(_array_reconstructor);
-    _Py_identifier(__dict__);
+    _Py_IDENTIFIER(_array_reconstructor);
+    _Py_IDENTIFIER(__dict__);
 
     if (array_reconstructor == NULL) {
         PyObject *array_module = PyImport_ImportModule("array");
diff --git a/Modules/cjkcodecs/multibytecodec.c b/Modules/cjkcodecs/multibytecodec.c
index 8635a56..77edbb3 100644
--- a/Modules/cjkcodecs/multibytecodec.c
+++ b/Modules/cjkcodecs/multibytecodec.c
@@ -1579,7 +1579,7 @@
                       PyObject *unistr)
 {
     PyObject *str, *wr;
-    _Py_identifier(write);
+    _Py_IDENTIFIER(write);
 
     str = encoder_encode_stateful(STATEFUL_ECTX(self), unistr, 0);
     if (str == NULL)
@@ -1651,7 +1651,7 @@
     assert(PyBytes_Check(pwrt));
     if (PyBytes_Size(pwrt) > 0) {
         PyObject *wr;
-        _Py_identifier(write);
+        _Py_IDENTIFIER(write);
 
         wr = _PyObject_CallMethodId(self->stream, &PyId_write, "O", pwrt);
         if (wr == NULL) {
diff --git a/Modules/faulthandler.c b/Modules/faulthandler.c
index 11d5340..51c66bd 100644
--- a/Modules/faulthandler.c
+++ b/Modules/faulthandler.c
@@ -146,8 +146,8 @@
 faulthandler_get_fileno(PyObject *file, int *p_fd)
 {
     PyObject *result;
-    _Py_identifier(fileno);
-    _Py_identifier(flush);
+    _Py_IDENTIFIER(fileno);
+    _Py_IDENTIFIER(flush);
     long fd_long;
     int fd;
 
@@ -1199,7 +1199,7 @@
 faulthandler_env_options(void)
 {
     PyObject *xoptions, *key, *module, *res;
-    _Py_identifier(enable);
+    _Py_IDENTIFIER(enable);
 
     if (!Py_GETENV("PYTHONFAULTHANDLER")) {
         int has_key;
diff --git a/Modules/gcmodule.c b/Modules/gcmodule.c
index 2533de6..6c8ca38 100644
--- a/Modules/gcmodule.c
+++ b/Modules/gcmodule.c
@@ -769,7 +769,7 @@
 {
     double result = 0;
     if (tmod != NULL) {
-        _Py_identifier(time);
+        _Py_IDENTIFIER(time);
 
         PyObject *f = _PyObject_CallMethodId(tmod, &PyId_time, NULL);
         if (f == NULL) {
diff --git a/Modules/itertoolsmodule.c b/Modules/itertoolsmodule.c
index 4f81fe2..63f199b 100644
--- a/Modules/itertoolsmodule.c
+++ b/Modules/itertoolsmodule.c
@@ -654,7 +654,7 @@
         copyable = it;
     PyTuple_SET_ITEM(result, 0, copyable);
     for (i=1 ; i<n ; i++) {
-        _Py_identifier(__copy__);
+        _Py_IDENTIFIER(__copy__);
 
         copyable = _PyObject_CallMethodId(copyable, &PyId___copy__, NULL);
         if (copyable == NULL) {
diff --git a/Modules/mmapmodule.c b/Modules/mmapmodule.c
index 35d61ba..cf0b687 100644
--- a/Modules/mmapmodule.c
+++ b/Modules/mmapmodule.c
@@ -700,7 +700,7 @@
 static PyObject *
 mmap__exit__method(PyObject *self, PyObject *args)
 {
-    _Py_identifier(close);
+    _Py_IDENTIFIER(close);
 
     return _PyObject_CallMethodId(self, &PyId_close, NULL);
 }
diff --git a/Modules/ossaudiodev.c b/Modules/ossaudiodev.c
index 7512c1d..a17a647 100644
--- a/Modules/ossaudiodev.c
+++ b/Modules/ossaudiodev.c
@@ -534,7 +534,7 @@
 static PyObject *
 oss_exit(PyObject *self, PyObject *unused)
 {
-    _Py_identifier(close);
+    _Py_IDENTIFIER(close);
 
     PyObject *ret = _PyObject_CallMethodId(self, &PyId_close, NULL);
     if (!ret)
diff --git a/Modules/parsermodule.c b/Modules/parsermodule.c
index 3f03cee..2f2e045 100644
--- a/Modules/parsermodule.c
+++ b/Modules/parsermodule.c
@@ -3241,9 +3241,9 @@
     copyreg = PyImport_ImportModuleNoBlock("copyreg");
     if (copyreg != NULL) {
         PyObject *func, *pickler;
-        _Py_identifier(pickle);
-        _Py_identifier(sequence2st);
-        _Py_identifier(_pickler);
+        _Py_IDENTIFIER(pickle);
+        _Py_IDENTIFIER(sequence2st);
+        _Py_IDENTIFIER(_pickler);
 
         func = _PyObject_GetAttrId(copyreg, &PyId_pickle);
         pickle_constructor = _PyObject_GetAttrId(module, &PyId_sequence2st);
diff --git a/Modules/posixmodule.c b/Modules/posixmodule.c
index da0bef0..fa50296 100644
--- a/Modules/posixmodule.c
+++ b/Modules/posixmodule.c
@@ -6102,7 +6102,7 @@
 {
     PyObject *result;
     static PyObject *struct_rusage;
-    _Py_identifier(struct_rusage);
+    _Py_IDENTIFIER(struct_rusage);
 
     if (pid == -1)
         return posix_error();
diff --git a/Modules/pyexpat.c b/Modules/pyexpat.c
index 45ab70e..1bc4ffa 100644
--- a/Modules/pyexpat.c
+++ b/Modules/pyexpat.c
@@ -843,7 +843,7 @@
 {
     int rv = 1;
     PyObject *readmethod = NULL;
-    _Py_identifier(read);
+    _Py_IDENTIFIER(read);
 
     readmethod = _PyObject_GetAttrId(f, &PyId_read);
     if (readmethod == NULL) {
diff --git a/Modules/socketmodule.c b/Modules/socketmodule.c
index 2056b61..3618df1 100644
--- a/Modules/socketmodule.c
+++ b/Modules/socketmodule.c
@@ -4820,7 +4820,7 @@
     if (hobj == Py_None) {
         hptr = NULL;
     } else if (PyUnicode_Check(hobj)) {
-        _Py_identifier(encode);
+        _Py_IDENTIFIER(encode);
 
         idna = _PyObject_CallMethodId(hobj, &PyId_encode, "s", "idna");
         if (!idna)
diff --git a/Modules/timemodule.c b/Modules/timemodule.c
index 24066d8..f825c2c 100644
--- a/Modules/timemodule.c
+++ b/Modules/timemodule.c
@@ -540,7 +540,7 @@
 {
     PyObject *strptime_module = PyImport_ImportModuleNoBlock("_strptime");
     PyObject *strptime_result;
-    _Py_identifier(_strptime_time);
+    _Py_IDENTIFIER(_strptime_time);
 
     if (!strptime_module)
         return NULL;
diff --git a/Modules/zipimport.c b/Modules/zipimport.c
index 87dc0db..8e16750 100644
--- a/Modules/zipimport.c
+++ b/Modules/zipimport.c
@@ -908,7 +908,7 @@
     static int importing_zlib = 0;
     PyObject *zlib;
     PyObject *decompress;
-    _Py_identifier(decompress);
+    _Py_IDENTIFIER(decompress);
 
     if (importing_zlib != 0)
         /* Someone has a zlib.py[co] in their Zip file;
diff --git a/Objects/abstract.c b/Objects/abstract.c
index 57424a6..bce9794 100644
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -2082,7 +2082,7 @@
 {
     PyObject *keys;
     PyObject *fast;
-    _Py_identifier(keys);
+    _Py_IDENTIFIER(keys);
 
     if (PyDict_CheckExact(o))
         return PyDict_Keys(o);
@@ -2099,7 +2099,7 @@
 {
     PyObject *items;
     PyObject *fast;
-    _Py_identifier(items);
+    _Py_IDENTIFIER(items);
 
     if (PyDict_CheckExact(o))
         return PyDict_Items(o);
@@ -2116,7 +2116,7 @@
 {
     PyObject *values;
     PyObject *fast;
-    _Py_identifier(values);
+    _Py_IDENTIFIER(values);
 
     if (PyDict_CheckExact(o))
         return PyDict_Values(o);
diff --git a/Objects/bytearrayobject.c b/Objects/bytearrayobject.c
index 41ea2dd..0c9add0 100644
--- a/Objects/bytearrayobject.c
+++ b/Objects/bytearrayobject.c
@@ -2698,7 +2698,7 @@
 bytearray_reduce(PyByteArrayObject *self)
 {
     PyObject *latin1, *dict;
-    _Py_identifier(__dict__);
+    _Py_IDENTIFIER(__dict__);
 
     if (self->ob_bytes)
         latin1 = PyUnicode_DecodeLatin1(self->ob_bytes,
diff --git a/Objects/classobject.c b/Objects/classobject.c
index 40161ef..09b95bf 100644
--- a/Objects/classobject.c
+++ b/Objects/classobject.c
@@ -14,7 +14,7 @@
 #define PyMethod_MAXFREELIST 256
 #endif
 
-_Py_identifier(__name__);
+_Py_IDENTIFIER(__name__);
 
 PyObject *
 PyMethod_Function(PyObject *im)
diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index d664789..6e2d34e 100644
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -703,7 +703,7 @@
 proxy_get(proxyobject *pp, PyObject *args)
 {
     PyObject *key, *def = Py_None;
-    _Py_identifier(get);
+    _Py_IDENTIFIER(get);
 
     if (!PyArg_UnpackTuple(args, "get", 1, 2, &key, &def))
         return NULL;
@@ -713,28 +713,28 @@
 static PyObject *
 proxy_keys(proxyobject *pp)
 {
-    _Py_identifier(keys);
+    _Py_IDENTIFIER(keys);
     return _PyObject_CallMethodId(pp->dict, &PyId_keys, NULL);
 }
 
 static PyObject *
 proxy_values(proxyobject *pp)
 {
-    _Py_identifier(values);
+    _Py_IDENTIFIER(values);
     return _PyObject_CallMethodId(pp->dict, &PyId_values, NULL);
 }
 
 static PyObject *
 proxy_items(proxyobject *pp)
 {
-    _Py_identifier(items);
+    _Py_IDENTIFIER(items);
     return _PyObject_CallMethodId(pp->dict, &PyId_items, NULL);
 }
 
 static PyObject *
 proxy_copy(proxyobject *pp)
 {
-    _Py_identifier(copy);
+    _Py_IDENTIFIER(copy);
     return _PyObject_CallMethodId(pp->dict, &PyId_copy, NULL);
 }
 
@@ -1299,7 +1299,7 @@
 
     /* if no docstring given and the getter has one, use that one */
     if ((doc == NULL || doc == Py_None) && get != NULL) {
-        _Py_identifier(__doc__);
+        _Py_IDENTIFIER(__doc__);
         PyObject *get_doc = _PyObject_GetAttrId(get, &PyId___doc__);
         if (get_doc) {
             if (Py_TYPE(self) == &PyProperty_Type) {
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
index 28c3dc1..3896b31 100644
--- a/Objects/dictobject.c
+++ b/Objects/dictobject.c
@@ -2707,7 +2707,7 @@
 {
     PyObject *result = PySet_New(self);
     PyObject *tmp;
-    _Py_identifier(difference_update);
+    _Py_IDENTIFIER(difference_update);
 
     if (result == NULL)
         return NULL;
@@ -2727,7 +2727,7 @@
 {
     PyObject *result = PySet_New(self);
     PyObject *tmp;
-    _Py_identifier(intersection_update);
+    _Py_IDENTIFIER(intersection_update);
 
     if (result == NULL)
         return NULL;
@@ -2767,7 +2767,7 @@
 {
     PyObject *result = PySet_New(self);
     PyObject *tmp;
-    _Py_identifier(symmetric_difference_update);
+    _Py_IDENTIFIER(symmetric_difference_update);
 
     if (result == NULL)
         return NULL;
diff --git a/Objects/fileobject.c b/Objects/fileobject.c
index 324e2ee..e1c47ce 100644
--- a/Objects/fileobject.c
+++ b/Objects/fileobject.c
@@ -30,7 +30,7 @@
               char *errors, char *newline, int closefd)
 {
     PyObject *io, *stream;
-    _Py_identifier(open);
+    _Py_IDENTIFIER(open);
 
     io = PyImport_ImportModule("io");
     if (io == NULL)
@@ -59,7 +59,7 @@
     {
         PyObject *reader;
         PyObject *args;
-        _Py_identifier(readline);
+        _Py_IDENTIFIER(readline);
 
         reader = _PyObject_GetAttrId(f, &PyId_readline);
         if (reader == NULL)
@@ -128,7 +128,7 @@
 PyFile_WriteObject(PyObject *v, PyObject *f, int flags)
 {
     PyObject *writer, *value, *args, *result;
-    _Py_identifier(write);
+    _Py_IDENTIFIER(write);
 
     if (f == NULL) {
         PyErr_SetString(PyExc_TypeError, "writeobject with NULL file");
@@ -197,7 +197,7 @@
 {
     int fd;
     PyObject *meth;
-    _Py_identifier(fileno);
+    _Py_IDENTIFIER(fileno);
 
     if (PyLong_Check(o)) {
         fd = PyLong_AsLong(o);
diff --git a/Objects/moduleobject.c b/Objects/moduleobject.c
index 32c4b9e..b69bce6 100644
--- a/Objects/moduleobject.c
+++ b/Objects/moduleobject.c
@@ -415,7 +415,7 @@
 static PyObject *
 module_dir(PyObject *self, PyObject *args)
 {
-    _Py_identifier(__dict__);
+    _Py_IDENTIFIER(__dict__);
     PyObject *result = NULL;
     PyObject *dict = _PyObject_GetAttrId(self, &PyId___dict__);
 
diff --git a/Objects/setobject.c b/Objects/setobject.c
index 8f6325a..d7990d8 100644
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -1933,7 +1933,7 @@
 set_reduce(PySetObject *so)
 {
     PyObject *keys=NULL, *args=NULL, *result=NULL, *dict=NULL;
-    _Py_identifier(__dict__);
+    _Py_IDENTIFIER(__dict__);
 
     keys = PySequence_List((PyObject *)so);
     if (keys == NULL)
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 61f5bb1..130e8fe 100644
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -35,8 +35,8 @@
 static struct method_cache_entry method_cache[1 << MCACHE_SIZE_EXP];
 static unsigned int next_version_tag = 0;
 
-_Py_identifier(__dict__);
-_Py_identifier(__class__);
+_Py_IDENTIFIER(__dict__);
+_Py_IDENTIFIER(__class__);
 
 unsigned int
 PyType_ClearCache(void)
@@ -1284,7 +1284,7 @@
 static PyObject *
 class_name(PyObject *cls)
 {
-    _Py_identifier(__name__);
+    _Py_IDENTIFIER(__name__);
     PyObject *name = _PyObject_GetAttrId(cls, &PyId___name__);
     if (name == NULL) {
         PyErr_Clear();
@@ -2599,7 +2599,7 @@
 {
     PyObject *classdict;
     PyObject *bases;
-    _Py_identifier(__bases__);
+    _Py_IDENTIFIER(__bases__);
 
     assert(PyDict_Check(dict));
     assert(aclass);
@@ -2901,7 +2901,7 @@
         PyObject *sorted;
         PyObject *sorted_methods = NULL;
         PyObject *joined = NULL;
-        _Py_identifier(join);
+        _Py_IDENTIFIER(join);
 
         /* Compute ", ".join(sorted(type.__abstractmethods__))
            into joined. */
@@ -3189,7 +3189,7 @@
     PyObject *copyreg;
     PyObject *slotnames;
     static PyObject *str_slotnames;
-    _Py_identifier(_slotnames);
+    _Py_IDENTIFIER(_slotnames);
 
     if (str_slotnames == NULL) {
         str_slotnames = PyUnicode_InternFromString("__slotnames__");
@@ -3329,7 +3329,7 @@
         Py_INCREF(dictitems);
     }
     else {
-        _Py_identifier(items);
+        _Py_IDENTIFIER(items);
         PyObject *items = _PyObject_CallMethodId(obj, &PyId_items, "");
         if (items == NULL)
             goto end;
diff --git a/Objects/weakrefobject.c b/Objects/weakrefobject.c
index 374e720..e07adb2 100644
--- a/Objects/weakrefobject.c
+++ b/Objects/weakrefobject.c
@@ -157,7 +157,7 @@
 weakref_repr(PyWeakReference *self)
 {
     PyObject *name, *repr;
-    _Py_identifier(__name__);
+    _Py_IDENTIFIER(__name__);
 
     if (PyWeakref_GET_OBJECT(self) == Py_None)
         return PyUnicode_FromFormat("<weakref at %p; dead>", self);
@@ -441,7 +441,7 @@
 #define WRAP_METHOD(method, special) \
     static PyObject * \
     method(PyObject *proxy) { \
-            _Py_identifier(special); \
+            _Py_IDENTIFIER(special); \
             UNWRAP(proxy); \
                 return _PyObject_CallMethodId(proxy, &PyId_##special, ""); \
         }
diff --git a/PC/_msi.c b/PC/_msi.c
index 54406df..6fb9c42 100644
--- a/PC/_msi.c
+++ b/PC/_msi.c
@@ -122,7 +122,7 @@
 static FNFCISTATUS(cb_status)
 {
     if (pv) {
-        _Py_identifier(status);
+        _Py_IDENTIFIER(status);
 
         PyObject *result = _PyObject_CallMethodId(pv, &PyId_status, "iii", typeStatus, cb1, cb2);
         if (result == NULL)
@@ -135,7 +135,7 @@
 static FNFCIGETNEXTCABINET(cb_getnextcabinet)
 {
     if (pv) {
-        _Py_identifier(getnextcabinet);
+        _Py_IDENTIFIER(getnextcabinet);
 
         PyObject *result = _PyObject_CallMethodId(pv, &PyId_getnextcabinet, "i", pccab->iCab);
         if (result == NULL)
diff --git a/Parser/tokenizer.c b/Parser/tokenizer.c
index d13b438..c3b2f35 100644
--- a/Parser/tokenizer.c
+++ b/Parser/tokenizer.c
@@ -462,8 +462,8 @@
 fp_setreadl(struct tok_state *tok, const char* enc)
 {
     PyObject *readline = NULL, *stream = NULL, *io = NULL;
-    _Py_identifier(open);
-    _Py_identifier(readline);
+    _Py_IDENTIFIER(open);
+    _Py_IDENTIFIER(readline);
     int fd;
 
     io = PyImport_ImportModuleNoBlock("io");
diff --git a/Python/Python-ast.c b/Python/Python-ast.c
index 2ed36cd..7c0d858 100644
--- a/Python/Python-ast.c
+++ b/Python/Python-ast.c
@@ -7,7 +7,7 @@
 static PyTypeObject *mod_type;
 static PyObject* ast2obj_mod(void*);
 static PyTypeObject *Module_type;
-_Py_identifier(body);
+_Py_IDENTIFIER(body);
 static char *Module_fields[]={
         "body",
 };
@@ -24,18 +24,18 @@
         "body",
 };
 static PyTypeObject *stmt_type;
-_Py_identifier(lineno);
-_Py_identifier(col_offset);
+_Py_IDENTIFIER(lineno);
+_Py_IDENTIFIER(col_offset);
 static char *stmt_attributes[] = {
         "lineno",
         "col_offset",
 };
 static PyObject* ast2obj_stmt(void*);
 static PyTypeObject *FunctionDef_type;
-_Py_identifier(name);
-_Py_identifier(args);
-_Py_identifier(decorator_list);
-_Py_identifier(returns);
+_Py_IDENTIFIER(name);
+_Py_IDENTIFIER(args);
+_Py_IDENTIFIER(decorator_list);
+_Py_IDENTIFIER(returns);
 static char *FunctionDef_fields[]={
         "name",
         "args",
@@ -44,10 +44,10 @@
         "returns",
 };
 static PyTypeObject *ClassDef_type;
-_Py_identifier(bases);
-_Py_identifier(keywords);
-_Py_identifier(starargs);
-_Py_identifier(kwargs);
+_Py_IDENTIFIER(bases);
+_Py_IDENTIFIER(keywords);
+_Py_IDENTIFIER(starargs);
+_Py_IDENTIFIER(kwargs);
 static char *ClassDef_fields[]={
         "name",
         "bases",
@@ -58,12 +58,12 @@
         "decorator_list",
 };
 static PyTypeObject *Return_type;
-_Py_identifier(value);
+_Py_IDENTIFIER(value);
 static char *Return_fields[]={
         "value",
 };
 static PyTypeObject *Delete_type;
-_Py_identifier(targets);
+_Py_IDENTIFIER(targets);
 static char *Delete_fields[]={
         "targets",
 };
@@ -73,16 +73,16 @@
         "value",
 };
 static PyTypeObject *AugAssign_type;
-_Py_identifier(target);
-_Py_identifier(op);
+_Py_IDENTIFIER(target);
+_Py_IDENTIFIER(op);
 static char *AugAssign_fields[]={
         "target",
         "op",
         "value",
 };
 static PyTypeObject *For_type;
-_Py_identifier(iter);
-_Py_identifier(orelse);
+_Py_IDENTIFIER(iter);
+_Py_IDENTIFIER(orelse);
 static char *For_fields[]={
         "target",
         "iter",
@@ -90,7 +90,7 @@
         "orelse",
 };
 static PyTypeObject *While_type;
-_Py_identifier(test);
+_Py_IDENTIFIER(test);
 static char *While_fields[]={
         "test",
         "body",
@@ -103,21 +103,21 @@
         "orelse",
 };
 static PyTypeObject *With_type;
-_Py_identifier(items);
+_Py_IDENTIFIER(items);
 static char *With_fields[]={
         "items",
         "body",
 };
 static PyTypeObject *Raise_type;
-_Py_identifier(exc);
-_Py_identifier(cause);
+_Py_IDENTIFIER(exc);
+_Py_IDENTIFIER(cause);
 static char *Raise_fields[]={
         "exc",
         "cause",
 };
 static PyTypeObject *Try_type;
-_Py_identifier(handlers);
-_Py_identifier(finalbody);
+_Py_IDENTIFIER(handlers);
+_Py_IDENTIFIER(finalbody);
 static char *Try_fields[]={
         "body",
         "handlers",
@@ -125,19 +125,19 @@
         "finalbody",
 };
 static PyTypeObject *Assert_type;
-_Py_identifier(msg);
+_Py_IDENTIFIER(msg);
 static char *Assert_fields[]={
         "test",
         "msg",
 };
 static PyTypeObject *Import_type;
-_Py_identifier(names);
+_Py_IDENTIFIER(names);
 static char *Import_fields[]={
         "names",
 };
 static PyTypeObject *ImportFrom_type;
-_Py_identifier(module);
-_Py_identifier(level);
+_Py_IDENTIFIER(module);
+_Py_IDENTIFIER(level);
 static char *ImportFrom_fields[]={
         "module",
         "names",
@@ -165,21 +165,21 @@
 };
 static PyObject* ast2obj_expr(void*);
 static PyTypeObject *BoolOp_type;
-_Py_identifier(values);
+_Py_IDENTIFIER(values);
 static char *BoolOp_fields[]={
         "op",
         "values",
 };
 static PyTypeObject *BinOp_type;
-_Py_identifier(left);
-_Py_identifier(right);
+_Py_IDENTIFIER(left);
+_Py_IDENTIFIER(right);
 static char *BinOp_fields[]={
         "left",
         "op",
         "right",
 };
 static PyTypeObject *UnaryOp_type;
-_Py_identifier(operand);
+_Py_IDENTIFIER(operand);
 static char *UnaryOp_fields[]={
         "op",
         "operand",
@@ -196,19 +196,19 @@
         "orelse",
 };
 static PyTypeObject *Dict_type;
-_Py_identifier(keys);
+_Py_IDENTIFIER(keys);
 static char *Dict_fields[]={
         "keys",
         "values",
 };
 static PyTypeObject *Set_type;
-_Py_identifier(elts);
+_Py_IDENTIFIER(elts);
 static char *Set_fields[]={
         "elts",
 };
 static PyTypeObject *ListComp_type;
-_Py_identifier(elt);
-_Py_identifier(generators);
+_Py_IDENTIFIER(elt);
+_Py_IDENTIFIER(generators);
 static char *ListComp_fields[]={
         "elt",
         "generators",
@@ -219,7 +219,7 @@
         "generators",
 };
 static PyTypeObject *DictComp_type;
-_Py_identifier(key);
+_Py_IDENTIFIER(key);
 static char *DictComp_fields[]={
         "key",
         "value",
@@ -235,15 +235,15 @@
         "value",
 };
 static PyTypeObject *Compare_type;
-_Py_identifier(ops);
-_Py_identifier(comparators);
+_Py_IDENTIFIER(ops);
+_Py_IDENTIFIER(comparators);
 static char *Compare_fields[]={
         "left",
         "ops",
         "comparators",
 };
 static PyTypeObject *Call_type;
-_Py_identifier(func);
+_Py_IDENTIFIER(func);
 static char *Call_fields[]={
         "func",
         "args",
@@ -252,12 +252,12 @@
         "kwargs",
 };
 static PyTypeObject *Num_type;
-_Py_identifier(n);
+_Py_IDENTIFIER(n);
 static char *Num_fields[]={
         "n",
 };
 static PyTypeObject *Str_type;
-_Py_identifier(s);
+_Py_IDENTIFIER(s);
 static char *Str_fields[]={
         "s",
 };
@@ -267,15 +267,15 @@
 };
 static PyTypeObject *Ellipsis_type;
 static PyTypeObject *Attribute_type;
-_Py_identifier(attr);
-_Py_identifier(ctx);
+_Py_IDENTIFIER(attr);
+_Py_IDENTIFIER(ctx);
 static char *Attribute_fields[]={
         "value",
         "attr",
         "ctx",
 };
 static PyTypeObject *Subscript_type;
-_Py_identifier(slice);
+_Py_IDENTIFIER(slice);
 static char *Subscript_fields[]={
         "value",
         "slice",
@@ -287,7 +287,7 @@
         "ctx",
 };
 static PyTypeObject *Name_type;
-_Py_identifier(id);
+_Py_IDENTIFIER(id);
 static char *Name_fields[]={
         "id",
         "ctx",
@@ -315,16 +315,16 @@
 static PyTypeObject *slice_type;
 static PyObject* ast2obj_slice(void*);
 static PyTypeObject *Slice_type;
-_Py_identifier(lower);
-_Py_identifier(upper);
-_Py_identifier(step);
+_Py_IDENTIFIER(lower);
+_Py_IDENTIFIER(upper);
+_Py_IDENTIFIER(step);
 static char *Slice_fields[]={
         "lower",
         "upper",
         "step",
 };
 static PyTypeObject *ExtSlice_type;
-_Py_identifier(dims);
+_Py_IDENTIFIER(dims);
 static char *ExtSlice_fields[]={
         "dims",
 };
@@ -380,7 +380,7 @@
 static PyTypeObject *NotIn_type;
 static PyTypeObject *comprehension_type;
 static PyObject* ast2obj_comprehension(void*);
-_Py_identifier(ifs);
+_Py_IDENTIFIER(ifs);
 static char *comprehension_fields[]={
         "target",
         "iter",
@@ -393,7 +393,7 @@
 };
 static PyObject* ast2obj_excepthandler(void*);
 static PyTypeObject *ExceptHandler_type;
-_Py_identifier(type);
+_Py_IDENTIFIER(type);
 static char *ExceptHandler_fields[]={
         "type",
         "name",
@@ -401,13 +401,13 @@
 };
 static PyTypeObject *arguments_type;
 static PyObject* ast2obj_arguments(void*);
-_Py_identifier(vararg);
-_Py_identifier(varargannotation);
-_Py_identifier(kwonlyargs);
-_Py_identifier(kwarg);
-_Py_identifier(kwargannotation);
-_Py_identifier(defaults);
-_Py_identifier(kw_defaults);
+_Py_IDENTIFIER(vararg);
+_Py_IDENTIFIER(varargannotation);
+_Py_IDENTIFIER(kwonlyargs);
+_Py_IDENTIFIER(kwarg);
+_Py_IDENTIFIER(kwargannotation);
+_Py_IDENTIFIER(defaults);
+_Py_IDENTIFIER(kw_defaults);
 static char *arguments_fields[]={
         "args",
         "vararg",
@@ -420,8 +420,8 @@
 };
 static PyTypeObject *arg_type;
 static PyObject* ast2obj_arg(void*);
-_Py_identifier(arg);
-_Py_identifier(annotation);
+_Py_IDENTIFIER(arg);
+_Py_IDENTIFIER(annotation);
 static char *arg_fields[]={
         "arg",
         "annotation",
@@ -434,15 +434,15 @@
 };
 static PyTypeObject *alias_type;
 static PyObject* ast2obj_alias(void*);
-_Py_identifier(asname);
+_Py_IDENTIFIER(asname);
 static char *alias_fields[]={
         "name",
         "asname",
 };
 static PyTypeObject *withitem_type;
 static PyObject* ast2obj_withitem(void*);
-_Py_identifier(context_expr);
-_Py_identifier(optional_vars);
+_Py_IDENTIFIER(context_expr);
+_Py_IDENTIFIER(optional_vars);
 static char *withitem_fields[]={
         "context_expr",
         "optional_vars",
@@ -452,7 +452,7 @@
 static int
 ast_type_init(PyObject *self, PyObject *args, PyObject *kw)
 {
-    _Py_identifier(_fields);
+    _Py_IDENTIFIER(_fields);
     Py_ssize_t i, numfields = 0;
     int res = -1;
     PyObject *key, *value, *fields;
@@ -506,7 +506,7 @@
 ast_type_reduce(PyObject *self, PyObject *unused)
 {
     PyObject *res;
-    _Py_identifier(__dict__);
+    _Py_IDENTIFIER(__dict__);
     PyObject *dict = _PyObject_GetAttrId(self, &PyId___dict__);
     if (dict == NULL) {
         if (PyErr_ExceptionMatches(PyExc_AttributeError))
diff --git a/Python/_warnings.c b/Python/_warnings.c
index ebc9cb8..6fcc128 100644
--- a/Python/_warnings.c
+++ b/Python/_warnings.c
@@ -18,7 +18,7 @@
 check_matched(PyObject *obj, PyObject *arg)
 {
     PyObject *result;
-    _Py_identifier(match);
+    _Py_IDENTIFIER(match);
     int rc;
 
     if (obj == Py_None)
@@ -247,7 +247,7 @@
     PyObject *f_stderr;
     PyObject *name;
     char lineno_str[128];
-    _Py_identifier(__name__);
+    _Py_IDENTIFIER(__name__);
 
     PyOS_snprintf(lineno_str, sizeof(lineno_str), ":%d: ", lineno);
 
diff --git a/Python/ast.c b/Python/ast.c
index 9872979..48aef48 100644
--- a/Python/ast.c
+++ b/Python/ast.c
@@ -527,7 +527,7 @@
 static identifier
 new_identifier(const char* n, PyArena *arena)
 {
-    _Py_identifier(normalize);
+    _Py_IDENTIFIER(normalize);
     PyObject* id = PyUnicode_DecodeUTF8(n, strlen(n), NULL);
     if (!id || PyUnicode_READY(id) == -1)
         return NULL;
diff --git a/Python/bltinmodule.c b/Python/bltinmodule.c
index 9849df6..e68f025 100644
--- a/Python/bltinmodule.c
+++ b/Python/bltinmodule.c
@@ -32,8 +32,8 @@
 int Py_HasFileSystemDefaultEncoding = 0;
 #endif
 
-_Py_identifier(fileno);
-_Py_identifier(flush);
+_Py_IDENTIFIER(fileno);
+_Py_IDENTIFIER(flush);
 
 static PyObject *
 builtin___build_class__(PyObject *self, PyObject *args, PyObject *kwds)
@@ -41,7 +41,7 @@
     PyObject *func, *name, *bases, *mkw, *meta, *prep, *ns, *cell;
     PyObject *cls = NULL;
     Py_ssize_t nargs;
-    _Py_identifier(__prepare__);
+    _Py_IDENTIFIER(__prepare__);
 
     assert(args != NULL);
     if (!PyTuple_Check(args)) {
@@ -1614,7 +1614,7 @@
         char *stdin_encoding_str;
         PyObject *result;
         size_t len;
-        _Py_identifier(encoding);
+        _Py_IDENTIFIER(encoding);
 
         stdin_encoding = _PyObject_GetAttrId(fin, &PyId_encoding);
         if (!stdin_encoding)
@@ -1790,7 +1790,7 @@
     PyObject *callable;
     static char *kwlist[] = {"iterable", "key", "reverse", 0};
     int reverse;
-    _Py_identifier(sort);
+    _Py_IDENTIFIER(sort);
 
     /* args 1-3 should match listsort in Objects/listobject.c */
     if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|Oi:sorted",
@@ -1847,7 +1847,7 @@
             Py_INCREF(d);
     }
     else {
-        _Py_identifier(__dict__);
+        _Py_IDENTIFIER(__dict__);
         d = _PyObject_GetAttrId(v, &PyId___dict__);
         if (d == NULL) {
             PyErr_SetString(PyExc_TypeError,
diff --git a/Python/ceval.c b/Python/ceval.c
index 04d3df1..543c6f2 100644
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -372,7 +372,7 @@
 void
 PyEval_ReInitThreads(void)
 {
-    _Py_identifier(_after_fork);
+    _Py_IDENTIFIER(_after_fork);
     PyObject *threading, *result;
     PyThreadState *tstate = PyThreadState_GET();
 
diff --git a/Python/codecs.c b/Python/codecs.c
index 006d288..eca2b88 100644
--- a/Python/codecs.c
+++ b/Python/codecs.c
@@ -467,8 +467,8 @@
 
 static void wrong_exception_type(PyObject *exc)
 {
-    _Py_identifier(__class__);
-    _Py_identifier(__name__);
+    _Py_IDENTIFIER(__class__);
+    _Py_IDENTIFIER(__name__);
     PyObject *type = _PyObject_GetAttrId(exc, &PyId___class__);
     if (type != NULL) {
         PyObject *name = _PyObject_GetAttrId(type, &PyId___name__);
diff --git a/Python/errors.c b/Python/errors.c
index 5988e1b..998bef6 100644
--- a/Python/errors.c
+++ b/Python/errors.c
@@ -712,7 +712,7 @@
 void
 PyErr_WriteUnraisable(PyObject *obj)
 {
-    _Py_identifier(__module__);
+    _Py_IDENTIFIER(__module__);
     PyObject *f, *t, *v, *tb;
     PyErr_Fetch(&t, &v, &tb);
     f = PySys_GetObject("stderr");
diff --git a/Python/import.c b/Python/import.c
index d937cc1..6e3e0f1 100644
--- a/Python/import.c
+++ b/Python/import.c
@@ -154,7 +154,7 @@
 };
 
 static PyObject *initstr = NULL;
-_Py_identifier(__path__);
+_Py_IDENTIFIER(__path__);
 
 /* Initialize things */
 
@@ -248,7 +248,7 @@
             PySys_WriteStderr("# can't import zipimport\n");
     }
     else {
-        _Py_identifier(zipimporter);
+        _Py_IDENTIFIER(zipimporter);
         PyObject *zipimporter = _PyObject_GetAttrId(zimpimport,
                                                     &PyId_zipimporter);
         Py_DECREF(zimpimport);
@@ -1802,7 +1802,7 @@
 
     /* sys.path_hooks import hook */
     if (p_loader != NULL) {
-        _Py_identifier(find_module);
+        _Py_IDENTIFIER(find_module);
         PyObject *importer;
 
         importer = get_path_importer(path_importer_cache,
@@ -2032,7 +2032,7 @@
 
     /* sys.meta_path import hook */
     if (p_loader != NULL) {
-        _Py_identifier(find_module);
+        _Py_IDENTIFIER(find_module);
         PyObject *meta_path;
 
         meta_path = PySys_GetObject("meta_path");
@@ -2462,7 +2462,7 @@
         break;
 
     case IMP_HOOK: {
-        _Py_identifier(load_module);
+        _Py_IDENTIFIER(load_module);
         if (loader == NULL) {
             PyErr_SetString(PyExc_ImportError,
                             "import hook without loader");
@@ -3227,7 +3227,7 @@
         }
         if (PyUnicode_READ_CHAR(item, 0) == '*') {
             PyObject *all;
-            _Py_identifier(__all__);
+            _Py_IDENTIFIER(__all__);
             Py_DECREF(item);
             /* See if the package defines __all__ */
             if (recursive)
diff --git a/Python/marshal.c b/Python/marshal.c
index b8288d0..98bbbaf 100644
--- a/Python/marshal.c
+++ b/Python/marshal.c
@@ -480,7 +480,7 @@
         }
     }
     else {
-        _Py_identifier(read);
+        _Py_IDENTIFIER(read);
 
         PyObject *data = _PyObject_CallMethodId(p->readable, &PyId_read, "i", n);
         read = 0;
@@ -1292,7 +1292,7 @@
     int version = Py_MARSHAL_VERSION;
     PyObject *s;
     PyObject *res;
-    _Py_identifier(write);
+    _Py_IDENTIFIER(write);
 
     if (!PyArg_ParseTuple(args, "OO|i:dump", &x, &f, &version))
         return NULL;
@@ -1321,7 +1321,7 @@
 marshal_load(PyObject *self, PyObject *f)
 {
     PyObject *data, *result;
-    _Py_identifier(read);
+    _Py_IDENTIFIER(read);
     RFILE rf;
 
     /*
diff --git a/Python/pythonrun.c b/Python/pythonrun.c
index df0d1b3..0ce61a5 100644
--- a/Python/pythonrun.c
+++ b/Python/pythonrun.c
@@ -141,7 +141,7 @@
 {
     char *name_utf8, *name_str;
     PyObject *codec, *name = NULL;
-    _Py_identifier(name);
+    _Py_IDENTIFIER(name);
 
     codec = _PyCodec_Lookup(encoding);
     if (!codec)
@@ -353,7 +353,7 @@
     PyObject *fout = PySys_GetObject("stdout");
     PyObject *ferr = PySys_GetObject("stderr");
     PyObject *tmp;
-    _Py_identifier(flush);
+    _Py_IDENTIFIER(flush);
 
     if (fout != NULL && fout != Py_None) {
         tmp = _PyObject_CallMethodId(fout, &PyId_flush, "");
@@ -807,9 +807,9 @@
     const char* newline;
     PyObject *line_buffering;
     int buffering, isatty;
-    _Py_identifier(open);
-    _Py_identifier(isatty);
-    _Py_identifier(TextIOWrapper);
+    _Py_IDENTIFIER(open);
+    _Py_IDENTIFIER(isatty);
+    _Py_IDENTIFIER(TextIOWrapper);
 
     /* stdin is always opened in buffered mode, first because it shouldn't
        make a difference in common use cases, second because TextIOWrapper
@@ -831,7 +831,7 @@
         goto error;
 
     if (buffering) {
-        _Py_identifier(raw);
+        _Py_IDENTIFIER(raw);
         raw = _PyObject_GetAttrId(buf, &PyId_raw);
         if (raw == NULL)
             goto error;
@@ -1117,7 +1117,7 @@
     PyArena *arena;
     char *ps1 = "", *ps2 = "", *enc = NULL;
     int errcode = 0;
-    _Py_identifier(encoding);
+    _Py_IDENTIFIER(encoding);
 
     if (fp == stdin) {
         /* Fetch encoding from sys.stdin */
@@ -1321,11 +1321,11 @@
 {
     long hold;
     PyObject *v;
-    _Py_identifier(msg);
-    _Py_identifier(filename);
-    _Py_identifier(lineno);
-    _Py_identifier(offset);
-    _Py_identifier(text);
+    _Py_IDENTIFIER(msg);
+    _Py_IDENTIFIER(filename);
+    _Py_IDENTIFIER(lineno);
+    _Py_IDENTIFIER(offset);
+    _Py_IDENTIFIER(text);
 
     /* old style errors */
     if (PyTuple_Check(err))
@@ -1439,7 +1439,7 @@
         goto done;
     if (PyExceptionInstance_Check(value)) {
         /* The error code should be in the `code' attribute. */
-        _Py_identifier(code);
+        _Py_IDENTIFIER(code);
         PyObject *code = _PyObject_GetAttrId(value, &PyId_code);
         if (code) {
             Py_DECREF(value);
@@ -1597,7 +1597,7 @@
     else {
         PyObject* moduleName;
         char* className;
-        _Py_identifier(__module__);
+        _Py_IDENTIFIER(__module__);
         assert(PyExceptionClass_Check(type));
         className = PyExceptionClass_Name(type);
         if (className != NULL) {
@@ -1773,7 +1773,7 @@
 {
     PyObject *f, *r;
     PyObject *type, *value, *traceback;
-    _Py_identifier(flush);
+    _Py_IDENTIFIER(flush);
 
     /* Save the current exception */
     PyErr_Fetch(&type, &value, &traceback);
@@ -2220,7 +2220,7 @@
 wait_for_thread_shutdown(void)
 {
 #ifdef WITH_THREAD
-    _Py_identifier(_shutdown);
+    _Py_IDENTIFIER(_shutdown);
     PyObject *result;
     PyThreadState *tstate = PyThreadState_GET();
     PyObject *threading = PyMapping_GetItemString(tstate->interp->modules,
diff --git a/Python/sysmodule.c b/Python/sysmodule.c
index 5195a4a..7a1933d 100644
--- a/Python/sysmodule.c
+++ b/Python/sysmodule.c
@@ -79,8 +79,8 @@
     PyObject *encoded, *escaped_str, *repr_str, *buffer, *result;
     char *stdout_encoding_str;
     int ret;
-    _Py_identifier(encoding);
-    _Py_identifier(buffer);
+    _Py_IDENTIFIER(encoding);
+    _Py_IDENTIFIER(buffer);
 
     stdout_encoding = _PyObject_GetAttrId(outf, &PyId_encoding);
     if (stdout_encoding == NULL)
@@ -101,7 +101,7 @@
 
     buffer = _PyObject_GetAttrId(outf, &PyId_buffer);
     if (buffer) {
-        _Py_identifier(write);
+        _Py_IDENTIFIER(write);
         result = _PyObject_CallMethodId(buffer, &PyId_write, "(O)", encoded);
         Py_DECREF(buffer);
         Py_DECREF(encoded);
@@ -1843,7 +1843,7 @@
 {
     PyObject *writer = NULL, *args = NULL, *result = NULL;
     int err;
-    _Py_identifier(write);
+    _Py_IDENTIFIER(write);
 
     if (file == NULL)
         return -1;
diff --git a/Python/traceback.c b/Python/traceback.c
index 44358ed..2f4653b 100644
--- a/Python/traceback.c
+++ b/Python/traceback.c
@@ -152,7 +152,7 @@
     const char* filepath;
     Py_ssize_t len;
     PyObject* result;
-    _Py_identifier(open);
+    _Py_IDENTIFIER(open);
 
     filebytes = PyUnicode_EncodeFSDefault(filename);
     if (filebytes == NULL) {
@@ -232,9 +232,9 @@
     char buf[MAXPATHLEN+1];
     int kind;
     void *data;
-    _Py_identifier(close);
-    _Py_identifier(open);
-    _Py_identifier(TextIOWrapper);
+    _Py_IDENTIFIER(close);
+    _Py_IDENTIFIER(open);
+    _Py_IDENTIFIER(TextIOWrapper);
 
     /* open the file */
     if (filename == NULL)