bpo-29865: Use PyXXX_GET_SIZE macros rather than Py_SIZE for concrete types. (#748)

Modules/_io/bufferedio.c

@@ -83,7 +83,7 @@ _bufferediobase_readinto_generic(PyObject *self, Py_buffer *buffer, char readint
         return NULL;
     }
 
-    len = Py_SIZE(data);
+    len = PyBytes_GET_SIZE(data);
     if (len > buffer->len) {
         PyErr_Format(PyExc_ValueError,
                      "read() returned too much data: "

Modules/_io/bytesio.c

@@ -822,7 +822,7 @@ bytesio_setstate(bytesio *self, PyObject *state)
     /* We allow the state tuple to be longer than 3, because we may need
        someday to extend the object's state without breaking
        backward-compatibility. */
-    if (!PyTuple_Check(state) || Py_SIZE(state) < 3) {
+    if (!PyTuple_Check(state) || PyTuple_GET_SIZE(state) < 3) {
         PyErr_Format(PyExc_TypeError,
                      "%.200s.__setstate__ argument should be 3-tuple, got %.200s",
                      Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name);

Modules/_io/iobase.c

@@ -518,7 +518,7 @@ _io__IOBase_readline_impl(PyObject *self, Py_ssize_t limit)
     if (buffer == NULL)
         return NULL;
 
-    while (limit < 0 || Py_SIZE(buffer) < limit) {
+    while (limit < 0 || PyByteArray_GET_SIZE(buffer) < limit) {
         Py_ssize_t nreadahead = 1;
         PyObject *b;
 

Modules/_io/stringio.c

@@ -877,7 +877,7 @@ stringio_setstate(stringio *self, PyObject *state)
     /* We allow the state tuple to be longer than 4, because we may need
        someday to extend the object's state without breaking
        backward-compatibility. */
-    if (!PyTuple_Check(state) || Py_SIZE(state) < 4) {
+    if (!PyTuple_Check(state) || PyTuple_GET_SIZE(state) < 4) {
         PyErr_Format(PyExc_TypeError,
                      "%.200s.__setstate__ argument should be 4-tuple, got %.200s",
                      Py_TYPE(self)->tp_name, Py_TYPE(state)->tp_name);

Modules/_json.c

@@ -1654,7 +1654,7 @@ encoder_listencode_dict(PyEncoderObject *s, _PyAccu *acc,
     idx = 0;
     while ((item = PyIter_Next(it)) != NULL) {
         PyObject *encoded, *key, *value;
-        if (!PyTuple_Check(item) || Py_SIZE(item) != 2) {
+        if (!PyTuple_Check(item) || PyTuple_GET_SIZE(item) != 2) {
             PyErr_SetString(PyExc_ValueError, "items must return 2-tuples");
             goto bail;
         }

Modules/_pickle.c

@@ -3559,10 +3559,10 @@ save_reduce(PicklerObject *self, PyObject *args, PyObject *obj)
         PyObject *args;
         PyObject *kwargs;
 
-        if (Py_SIZE(argtup) != 3) {
+        if (PyTuple_GET_SIZE(argtup) != 3) {
             PyErr_Format(st->PicklingError,
                          "length of the NEWOBJ_EX argument tuple must be "
-                         "exactly 3, not %zd", Py_SIZE(argtup));
+                         "exactly 3, not %zd", PyTuple_GET_SIZE(argtup));
             return -1;
         }
 
@@ -3602,7 +3602,7 @@ save_reduce(PicklerObject *self, PyObject *args, PyObject *obj)
             Py_ssize_t i;
             _Py_IDENTIFIER(__new__);
 
-            newargs = PyTuple_New(Py_SIZE(args) + 2);
+            newargs = PyTuple_New(PyTuple_GET_SIZE(args) + 2);
             if (newargs == NULL)
                 return -1;
 
@@ -3614,7 +3614,7 @@ save_reduce(PicklerObject *self, PyObject *args, PyObject *obj)
             PyTuple_SET_ITEM(newargs, 0, cls_new);
             Py_INCREF(cls);
             PyTuple_SET_ITEM(newargs, 1, cls);
-            for (i = 0; i < Py_SIZE(args); i++) {
+            for (i = 0; i < PyTuple_GET_SIZE(args); i++) {
                 PyObject *item = PyTuple_GET_ITEM(args, i);
                 Py_INCREF(item);
                 PyTuple_SET_ITEM(newargs, i + 2, item);
@@ -3649,7 +3649,7 @@ save_reduce(PicklerObject *self, PyObject *args, PyObject *obj)
         int p;
 
         /* Sanity checks. */
-        if (Py_SIZE(argtup) < 1) {
+        if (PyTuple_GET_SIZE(argtup) < 1) {
             PyErr_SetString(st->PicklingError, "__newobj__ arglist is empty");
             return -1;
         }
@@ -3702,7 +3702,7 @@ save_reduce(PicklerObject *self, PyObject *args, PyObject *obj)
         if (save(self, cls, 0) < 0)
             return -1;
 
-        newargtup = PyTuple_GetSlice(argtup, 1, Py_SIZE(argtup));
+        newargtup = PyTuple_GetSlice(argtup, 1, PyTuple_GET_SIZE(argtup));
         if (newargtup == NULL)
             return -1;
 
@@ -4431,7 +4431,7 @@ Pickler_set_memo(PicklerObject *self, PyObject *obj)
             Py_ssize_t memo_id;
             PyObject *memo_obj;
 
-            if (!PyTuple_Check(value) || Py_SIZE(value) != 2) {
+            if (!PyTuple_Check(value) || PyTuple_GET_SIZE(value) != 2) {
                 PyErr_SetString(PyExc_TypeError,
                                 "'memo' values must be 2-item tuples");
                 goto error;
@@ -5168,7 +5168,7 @@ instantiate(PyObject *cls, PyObject *args)
        Pdata_poptuple which packs objects from the top of the stack
        into a newly created tuple. */
     assert(PyTuple_Check(args));
-    if (Py_SIZE(args) > 0 || !PyType_Check(cls) ||
+    if (PyTuple_GET_SIZE(args) > 0 || !PyType_Check(cls) ||
         _PyObject_HasAttrId(cls, &PyId___getinitargs__)) {
         result = PyObject_CallObject(cls, args);
     }
@@ -6048,7 +6048,7 @@ load_build(UnpicklerObject *self)
     /* A default __setstate__.  First see whether state embeds a
      * slot state dict too (a proto 2 addition).
      */
-    if (PyTuple_Check(state) && Py_SIZE(state) == 2) {
+    if (PyTuple_Check(state) && PyTuple_GET_SIZE(state) == 2) {
         PyObject *tmp = state;
 
         state = PyTuple_GET_ITEM(tmp, 0);

Modules/itertoolsmodule.c

@@ -942,11 +942,11 @@ cycle_next(cycleobject *lz)
             return NULL;
         Py_CLEAR(lz->it);
     }
-    if (Py_SIZE(lz->saved) == 0)
+    if (PyList_GET_SIZE(lz->saved) == 0)
         return NULL;
     item = PyList_GET_ITEM(lz->saved, lz->index);
     lz->index++;
-    if (lz->index >= Py_SIZE(lz->saved))
+    if (lz->index >= PyList_GET_SIZE(lz->saved))
         lz->index = 0;
     Py_INCREF(item);
     return item;

Objects/call.c

@@ -321,11 +321,12 @@ _PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs,
             return function_code_fastcall(co, args, nargs, globals);
         }
         else if (nargs == 0 && argdefs != NULL
-                 && co->co_argcount == Py_SIZE(argdefs)) {
+                 && co->co_argcount == PyTuple_GET_SIZE(argdefs)) {
             /* function called with no arguments, but all parameters have
                a default value: use default values as arguments .*/
             args = &PyTuple_GET_ITEM(argdefs, 0);
-            return function_code_fastcall(co, args, Py_SIZE(argdefs), globals);
+            return function_code_fastcall(co, args, PyTuple_GET_SIZE(argdefs),
+                                          globals);
         }
     }
 
@@ -364,7 +365,7 @@ _PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs,
 
     if (argdefs != NULL) {
         d = &PyTuple_GET_ITEM(argdefs, 0);
-        nd = Py_SIZE(argdefs);
+        nd = PyTuple_GET_SIZE(argdefs);
     }
     else {
         d = NULL;
@@ -406,11 +407,12 @@ _PyFunction_FastCallKeywords(PyObject *func, PyObject **stack,
             return function_code_fastcall(co, stack, nargs, globals);
         }
         else if (nargs == 0 && argdefs != NULL
-                 && co->co_argcount == Py_SIZE(argdefs)) {
+                 && co->co_argcount == PyTuple_GET_SIZE(argdefs)) {
             /* function called with no arguments, but all parameters have
                a default value: use default values as arguments .*/
             stack = &PyTuple_GET_ITEM(argdefs, 0);
-            return function_code_fastcall(co, stack, Py_SIZE(argdefs), globals);
+            return function_code_fastcall(co, stack, PyTuple_GET_SIZE(argdefs),
+                                          globals);
         }
     }
 
@@ -421,7 +423,7 @@ _PyFunction_FastCallKeywords(PyObject *func, PyObject **stack,
 
     if (argdefs != NULL) {
         d = &PyTuple_GET_ITEM(argdefs, 0);
-        nd = Py_SIZE(argdefs);
+        nd = PyTuple_GET_SIZE(argdefs);
     }
     else {
         d = NULL;

Objects/descrobject.c

@@ -1385,7 +1385,7 @@ property_descr_get(PyObject *self, PyObject *obj, PyObject *type)
     PyTuple_SET_ITEM(args, 0, obj);
     ret = PyObject_Call(gs->prop_get, args, NULL);
     if (cached_args == NULL && Py_REFCNT(args) == 1) {
-        assert(Py_SIZE(args) == 1);
+        assert(PyTuple_GET_SIZE(args) == 1);
         assert(PyTuple_GET_ITEM(args, 0) == obj);
         cached_args = args;
         Py_DECREF(obj);

Objects/memoryobject.c

@@ -2143,7 +2143,7 @@ memory_hex(PyMemoryViewObject *self, PyObject *dummy)
     if (bytes == NULL)
         return NULL;
 
-    ret = _Py_strhex(PyBytes_AS_STRING(bytes), Py_SIZE(bytes));
+    ret = _Py_strhex(PyBytes_AS_STRING(bytes), PyBytes_GET_SIZE(bytes));
     Py_DECREF(bytes);
 
     return ret;

Objects/typeobject.c

@@ -4022,7 +4022,7 @@ _PyObject_GetState(PyObject *obj, int required)
             if (obj->ob_type->tp_weaklistoffset)
                 basicsize += sizeof(PyObject *);
             if (slotnames != Py_None)
-                basicsize += sizeof(PyObject *) * Py_SIZE(slotnames);
+                basicsize += sizeof(PyObject *) * PyList_GET_SIZE(slotnames);
             if (obj->ob_type->tp_basicsize > basicsize) {
                 Py_DECREF(slotnames);
                 Py_DECREF(state);
@@ -4033,7 +4033,7 @@ _PyObject_GetState(PyObject *obj, int required)
             }
         }
 
-        if (slotnames != Py_None && Py_SIZE(slotnames) > 0) {
+        if (slotnames != Py_None && PyList_GET_SIZE(slotnames) > 0) {
             PyObject *slots;
             Py_ssize_t slotnames_size, i;
 
@@ -4044,7 +4044,7 @@ _PyObject_GetState(PyObject *obj, int required)
                 return NULL;
             }
 
-            slotnames_size = Py_SIZE(slotnames);
+            slotnames_size = PyList_GET_SIZE(slotnames);
             for (i = 0; i < slotnames_size; i++) {
                 PyObject *name, *value;
 
@@ -4070,7 +4070,7 @@ _PyObject_GetState(PyObject *obj, int required)
 
                 /* The list is stored on the class so it may mutate while we
                    iterate over it */
-                if (slotnames_size != Py_SIZE(slotnames)) {
+                if (slotnames_size != PyList_GET_SIZE(slotnames)) {
                     PyErr_Format(PyExc_RuntimeError,
                                  "__slotsname__ changed size during iteration");
                     goto error;
@@ -4142,10 +4142,10 @@ _PyObject_GetNewArguments(PyObject *obj, PyObject **args, PyObject **kwargs)
             Py_DECREF(newargs);
             return -1;
         }
-        if (Py_SIZE(newargs) != 2) {
+        if (PyTuple_GET_SIZE(newargs) != 2) {
             PyErr_Format(PyExc_ValueError,
                          "__getnewargs_ex__ should return a tuple of "
-                         "length 2, not %zd", Py_SIZE(newargs));
+                         "length 2, not %zd", PyTuple_GET_SIZE(newargs));
             Py_DECREF(newargs);
             return -1;
         }

Objects/unicodeobject.c

@@ -3633,7 +3633,8 @@ PyUnicode_AsEncodedString(PyObject *unicode,
             return NULL;
         }
 
-        b = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(v), Py_SIZE(v));
+        b = PyBytes_FromStringAndSize(PyByteArray_AS_STRING(v),
+                                      PyByteArray_GET_SIZE(v));
         Py_DECREF(v);
         return b;
     }

Python/ast.c

@@ -4221,7 +4221,7 @@ decode_unicode_with_escapes(struct compiling *c, const node *n, const char *s,
                 p += 10;
             }
             /* Should be impossible to overflow */
-            assert(p - buf <= Py_SIZE(u));
+            assert(p - buf <= PyBytes_GET_SIZE(u));
             Py_DECREF(w);
         } else {
             *p++ = *s++;