Issue #28959: Added private macro PyDict_GET_SIZE for retrieving the size of dict.

diff --git a/Include/dictobject.h b/Include/dictobject.h
index 30f114e49cbb71de20a3ede4143d7e4d246359b7..885694b491480a113eb71c4bce9e74fe5a7da091 100644 (file)
--- a/Include/dictobject.h
+++ b/Include/dictobject.h
@@ -106,6 +106,8 @@ PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObject *mp);
 PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp);
 PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key);
 #ifndef Py_LIMITED_API
+/* Get the number of items of a dictionary. */
+#define PyDict_GET_SIZE(mp)  (assert(PyDict_Check(mp)),((PyDictObject *)mp)->ma_used)
 PyAPI_FUNC(int) _PyDict_Contains(PyObject *mp, PyObject *key, Py_hash_t hash);
 PyAPI_FUNC(PyObject *) _PyDict_NewPresized(Py_ssize_t minused);
 PyAPI_FUNC(void) _PyDict_MaybeUntrack(PyObject *mp);

diff --git a/Include/odictobject.h b/Include/odictobject.h
index c1d9592a1db861863f4d5a9683d9530039bebba6..9410a0d845b91f2509ba3ebf4a847024f8b0ef0d 100644 (file)
--- a/Include/odictobject.h
+++ b/Include/odictobject.h
@@ -21,7 +21,7 @@ PyAPI_DATA(PyTypeObject) PyODictValues_Type;
 
 #define PyODict_Check(op) PyObject_TypeCheck(op, &PyODict_Type)
 #define PyODict_CheckExact(op) (Py_TYPE(op) == &PyODict_Type)
-#define PyODict_SIZE(op) ((PyDictObject *)op)->ma_used
+#define PyODict_SIZE(op) PyDict_GET_SIZE((op))
 #define PyODict_HasKey(od, key) (PyMapping_HasKey(PyObject *)od, key)
 
 PyAPI_FUNC(PyObject *) PyODict_New(void);

diff --git a/Modules/_ctypes/_ctypes.c b/Modules/_ctypes/_ctypes.c
index 47d8f56785974e8a2048488c10de4e3f38fd39f7..4908ddee3374f04858d2d580f95282f15d84b426 100644 (file)
--- a/Modules/_ctypes/_ctypes.c
+++ b/Modules/_ctypes/_ctypes.c
@@ -3684,7 +3684,7 @@ _build_callargs(PyCFuncPtrObject *self, PyObject *argtypes,
        must be the same as len(inargs) + len(kwds), otherwise we have
        either too much or not enough arguments. */
 
-    actual_args = PyTuple_GET_SIZE(inargs) + (kwds ? PyDict_Size(kwds) : 0);
+    actual_args = PyTuple_GET_SIZE(inargs) + (kwds ? PyDict_GET_SIZE(kwds) : 0);
     if (actual_args != inargs_index) {
         /* When we have default values or named parameters, this error
            message is misleading.  See unittests/test_paramflags.py

diff --git a/Modules/_datetimemodule.c b/Modules/_datetimemodule.c
index 254e59531f1d663216be555f0f20bbc01374c4e9..d11f4a9a6b27ca19197be6d1a85860bd6e6ef148 100644 (file)
--- a/Modules/_datetimemodule.c
+++ b/Modules/_datetimemodule.c
@@ -3169,7 +3169,7 @@ tzinfo_reduce(PyObject *self)
         PyErr_Clear();
         state = Py_None;
         dictptr = _PyObject_GetDictPtr(self);
-        if (dictptr && *dictptr && PyDict_Size(*dictptr)) {
+        if (dictptr && *dictptr && PyDict_GET_SIZE(*dictptr)) {
             state = *dictptr;
         }
         Py_INCREF(state);

diff --git a/Modules/_decimal/_decimal.c b/Modules/_decimal/_decimal.c
index 9e8625dab5614ddb9f4c4751e1eee3a3585c577a..feaef2e8760f7e8de0417f39e6e99db007897e2c 100644 (file)
--- a/Modules/_decimal/_decimal.c
+++ b/Modules/_decimal/_decimal.c
@@ -428,7 +428,7 @@ dict_as_flags(PyObject *val)
         return DEC_INVALID_SIGNALS;
     }
 
-    if (PyDict_Size(val) != SIGNAL_MAP_LEN) {
+    if (PyDict_GET_SIZE(val) != SIGNAL_MAP_LEN) {
         PyErr_SetString(PyExc_KeyError,
             "invalid signal dict");
         return DEC_INVALID_SIGNALS;

diff --git a/Modules/_elementtree.c b/Modules/_elementtree.c
index ba827e667f6c228927907f497b409faea11434a6..9e6f63b91ccd26a69db030f9cfa1c7943b8baa00 100644 (file)
--- a/Modules/_elementtree.c
+++ b/Modules/_elementtree.c
@@ -150,7 +150,7 @@ list_join(PyObject* list)
 static int
 is_empty_dict(PyObject *obj)
 {
-    return PyDict_CheckExact(obj) && PyDict_Size(obj) == 0;
+    return PyDict_CheckExact(obj) && PyDict_GET_SIZE(obj) == 0;
 }
 
 

diff --git a/Modules/_functoolsmodule.c b/Modules/_functoolsmodule.c
index 19ca65becc7897a94afc2c3778b196a30af5742c..6b5c008f746d91f71429c327efc30d40f0882d1b 100644 (file)
--- a/Modules/_functoolsmodule.c
+++ b/Modules/_functoolsmodule.c
@@ -84,7 +84,7 @@ partial_new(PyTypeObject *type, PyObject *args, PyObject *kw)
     }
     Py_DECREF(nargs);
 
-    if (pkw == NULL || PyDict_Size(pkw) == 0) {
+    if (pkw == NULL || PyDict_GET_SIZE(pkw) == 0) {
         if (kw == NULL) {
             pto->kw = PyDict_New();
         }
@@ -155,7 +155,7 @@ partial_call(partialobject *pto, PyObject *args, PyObject *kw)
         assert(PyTuple_Check(argappl));
     }
 
-    if (PyDict_Size(pto->kw) == 0) {
+    if (PyDict_GET_SIZE(pto->kw) == 0) {
         kwappl = kw;
         Py_XINCREF(kwappl);
     }
@@ -713,7 +713,7 @@ lru_cache_make_key(PyObject *args, PyObject *kwds, int typed)
         return args;
     }
 
-    if (kwds && PyDict_Size(kwds) > 0) {
+    if (kwds && PyDict_GET_SIZE(kwds) > 0) {
         sorted_items = PyDict_Items(kwds);
         if (!sorted_items)
             return NULL;
@@ -933,7 +933,7 @@ bounded_lru_cache_wrapper(lru_cache_object *self, PyObject *args, PyObject *kwds
         }
         lru_cache_append_link(self, link);
         Py_INCREF(result); /* for return */
-        self->full = (PyDict_Size(self->cache) >= self->maxsize);
+        self->full = (PyDict_GET_SIZE(self->cache) >= self->maxsize);
     }
     self->misses++;
     return result;
@@ -1062,7 +1062,7 @@ lru_cache_cache_info(lru_cache_object *self, PyObject *unused)
 {
     return PyObject_CallFunction(self->cache_info_type, "nnOn",
                                  self->hits, self->misses, self->maxsize_O,
-                                 PyDict_Size(self->cache));
+                                 PyDict_GET_SIZE(self->cache));
 }
 
 static PyObject *

diff --git a/Modules/_operator.c b/Modules/_operator.c
index fb8eafc6793d703b7f9004e30ccc70f93e95fbfa..f5b86125b1aef2f83cec41eb59596b9ef481eaeb 100644 (file)
--- a/Modules/_operator.c
+++ b/Modules/_operator.c
@@ -1016,16 +1016,7 @@ methodcaller_repr(methodcallerobject *mc)
         return PyUnicode_FromFormat("%s(...)", Py_TYPE(mc)->tp_name);
     }
 
-    if (mc->kwds != NULL) {
-        numkwdargs = PyDict_Size(mc->kwds);
-        if (numkwdargs < 0) {
-            Py_ReprLeave((PyObject *)mc);
-            return NULL;
-        }
-    } else {
-        numkwdargs = 0;
-    }
-
+    numkwdargs = mc->kwds != NULL ? PyDict_GET_SIZE(mc->kwds) : 0;
     numposargs = PyTuple_GET_SIZE(mc->args);
     numtotalargs = numposargs + numkwdargs;
 
@@ -1092,7 +1083,7 @@ static PyObject *
 methodcaller_reduce(methodcallerobject *mc)
 {
     PyObject *newargs;
-    if (!mc->kwds || PyDict_Size(mc->kwds) == 0) {
+    if (!mc->kwds || PyDict_GET_SIZE(mc->kwds) == 0) {
         Py_ssize_t i;
         Py_ssize_t callargcount = PyTuple_GET_SIZE(mc->args);
         newargs = PyTuple_New(1 + callargcount);

diff --git a/Modules/_pickle.c b/Modules/_pickle.c
index 947069afbeb22dac11af1d402b62e43afded7039..b1e1d49635721ee501936f941047a669468bd1ae 100644 (file)
--- a/Modules/_pickle.c
+++ b/Modules/_pickle.c
@@ -2787,10 +2787,10 @@ batch_dict_exact(PicklerObject *self, PyObject *obj)
     const char setitem_op = SETITEM;
     const char setitems_op = SETITEMS;
 
-    assert(obj != NULL);
+    assert(obj != NULL && PyDict_CheckExact(obj));
     assert(self->proto > 0);
 
-    dict_size = PyDict_Size(obj);
+    dict_size = PyDict_GET_SIZE(obj);
 
     /* Special-case len(d) == 1 to save space. */
     if (dict_size == 1) {
@@ -2819,7 +2819,7 @@ batch_dict_exact(PicklerObject *self, PyObject *obj)
         }
         if (_Pickler_Write(self, &setitems_op, 1) < 0)
             return -1;
-        if (PyDict_Size(obj) != dict_size) {
+        if (PyDict_GET_SIZE(obj) != dict_size) {
             PyErr_Format(
                 PyExc_RuntimeError,
                 "dictionary changed size during iteration");
@@ -2837,6 +2837,7 @@ save_dict(PicklerObject *self, PyObject *obj)
     char header[3];
     Py_ssize_t len;
     int status = 0;
+    assert(PyDict_Check(obj));
 
     if (self->fast && !fast_save_enter(self, obj))
         goto error;
@@ -2855,14 +2856,10 @@ save_dict(PicklerObject *self, PyObject *obj)
     if (_Pickler_Write(self, header, len) < 0)
         goto error;
 
-    /* Get dict size, and bow out early if empty. */
-    if ((len = PyDict_Size(obj)) < 0)
-        goto error;
-
     if (memo_put(self, obj) < 0)
         goto error;
 
-    if (len != 0) {
+    if (PyDict_GET_SIZE(obj)) {
         /* Save the dict items. */
         if (PyDict_CheckExact(obj) && self->proto > 0) {
             /* We can take certain shortcuts if we know this is a dict and
@@ -6878,7 +6875,7 @@ Unpickler_set_memo(UnpicklerObject *self, PyObject *obj)
         Py_ssize_t i = 0;
         PyObject *key, *value;
 
-        new_memo_size = PyDict_Size(obj);
+        new_memo_size = PyDict_GET_SIZE(obj);
         new_memo = _Unpickler_NewMemo(new_memo_size);
         if (new_memo == NULL)
             return -1;

diff --git a/Modules/_sqlite/cache.c b/Modules/_sqlite/cache.c
index 62c58931fa5d765fc88d2fd2c7da493bb6fa6029..72b1f2c5614bf438a57c3952bacf4b9fb2d4bcd9 100644 (file)
--- a/Modules/_sqlite/cache.c
+++ b/Modules/_sqlite/cache.c
@@ -162,7 +162,7 @@ PyObject* pysqlite_cache_get(pysqlite_Cache* self, PyObject* args)
          * entry in the cache, and make space if necessary by throwing the
          * least used item out of the cache. */
 
-        if (PyDict_Size(self->mapping) == self->size) {
+        if (PyDict_GET_SIZE(self->mapping) == self->size) {
             if (self->last) {
                 node = self->last;
 

diff --git a/Modules/_struct.c b/Modules/_struct.c
index 1d7a935ac8c49a493060b7b2749c107463095161..d621789d6bec55f82c78e0b4e7f999d415632ff3 100644 (file)
--- a/Modules/_struct.c
+++ b/Modules/_struct.c
@@ -2048,7 +2048,7 @@ cache_struct(PyObject *fmt)
 
     s_object = PyObject_CallFunctionObjArgs((PyObject *)(&PyStructType), fmt, NULL);
     if (s_object != NULL) {
-        if (PyDict_Size(cache) >= MAXCACHE)
+        if (PyDict_GET_SIZE(cache) >= MAXCACHE)
             PyDict_Clear(cache);
         /* Attempt to cache the result */
         if (PyDict_SetItem(cache, fmt, s_object) == -1)

diff --git a/Modules/itertoolsmodule.c b/Modules/itertoolsmodule.c
index 6bf04cbee31c35ce76e1b05887472d6ca716e728..7cbee2b2fcd477d50f4ac2a08a7ce6c811e61984 100644 (file)
--- a/Modules/itertoolsmodule.c
+++ b/Modules/itertoolsmodule.c
@@ -4180,7 +4180,7 @@ repeat_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
         return NULL;
 
     if (kwds != NULL)
-        n_kwds = PyDict_Size(kwds);
+        n_kwds = PyDict_GET_SIZE(kwds);
     /* Does user supply times argument? */
     if ((PyTuple_Size(args) + n_kwds == 2) && cnt < 0)
         cnt = 0;
@@ -4331,9 +4331,9 @@ zip_longest_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
     PyObject *fillvalue = Py_None;
     Py_ssize_t tuplesize = PySequence_Length(args);
 
-    if (kwds != NULL && PyDict_CheckExact(kwds) && PyDict_Size(kwds) > 0) {
+    if (kwds != NULL && PyDict_CheckExact(kwds) && PyDict_GET_SIZE(kwds) > 0) {
         fillvalue = PyDict_GetItemString(kwds, "fillvalue");
-        if (fillvalue == NULL  ||  PyDict_Size(kwds) > 1) {
+        if (fillvalue == NULL || PyDict_GET_SIZE(kwds) > 1) {
             PyErr_SetString(PyExc_TypeError,
                 "zip_longest() got an unexpected keyword argument");
             return NULL;

diff --git a/Modules/selectmodule.c b/Modules/selectmodule.c
index 79cf1990d0fe06d18cd44f308706246e9ebd7ea8..0206651669fec9b01001088aa6d0a1a2d034b16e 100644 (file)
--- a/Modules/selectmodule.c
+++ b/Modules/selectmodule.c
@@ -353,7 +353,7 @@ update_ufd_array(pollObject *self)
     PyObject *key, *value;
     struct pollfd *old_ufds = self->ufds;
 
-    self->ufd_len = PyDict_Size(self->dict);
+    self->ufd_len = PyDict_GET_SIZE(self->dict);
     PyMem_RESIZE(self->ufds, struct pollfd, self->ufd_len);
     if (self->ufds == NULL) {
         self->ufds = old_ufds;

diff --git a/Objects/abstract.c b/Objects/abstract.c
index 67b163d7b76daccf8e853d2a9fae758c0e2e7695..8d1eddc0930ede0678f281c9d0726789daa560c5 100644 (file)
--- a/Objects/abstract.c
+++ b/Objects/abstract.c
@@ -2409,8 +2409,7 @@ _PyStack_UnpackDict(PyObject **args, Py_ssize_t nargs, PyObject *kwargs,
     assert(nargs >= 0);
     assert(kwargs == NULL || PyDict_CheckExact(kwargs));
 
-    nkwargs = (kwargs != NULL) ? PyDict_Size(kwargs) : 0;
-    if (!nkwargs) {
+    if (kwargs == NULL || (nkwargs = PyDict_GET_SIZE(kwargs)) == 0) {
         *p_kwnames = NULL;
         return args;
     }

diff --git a/Objects/descrobject.c b/Objects/descrobject.c
index 090c9cdd047774fc328ce6175dce82b6dadf1e99..ed398919a34f662ce9dede644bb716ac6679f49c 100644 (file)
--- a/Objects/descrobject.c
+++ b/Objects/descrobject.c
@@ -1173,7 +1173,7 @@ wrapper_call(wrapperobject *wp, PyObject *args, PyObject *kwds)
         return (*wk)(self, args, wp->descr->d_wrapped, kwds);
     }
 
-    if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_Size(kwds) != 0)) {
+    if (kwds != NULL && (!PyDict_Check(kwds) || PyDict_GET_SIZE(kwds) != 0)) {
         PyErr_Format(PyExc_TypeError,
                      "wrapper %s doesn't take keyword arguments",
                      wp->descr->d_base->name);

diff --git a/Objects/funcobject.c b/Objects/funcobject.c
index 69cd973384b2047ead07983d48ee2f233a4dd7e4..63aa9de5834c9be7329d7a4dc972a7778b1e6105 100644 (file)
--- a/Objects/funcobject.c
+++ b/Objects/funcobject.c
@@ -583,7 +583,7 @@ function_call(PyObject *func, PyObject *arg, PyObject *kw)
 
     if (kw != NULL && PyDict_Check(kw)) {
         Py_ssize_t pos, i;
-        nk = PyDict_Size(kw);
+        nk = PyDict_GET_SIZE(kw);
         kwtuple = PyTuple_New(2*nk);
         if (kwtuple == NULL)
             return NULL;

diff --git a/Objects/methodobject.c b/Objects/methodobject.c
index c2001f0169b030f316169d7001439426d5506c77..14750b63185876a874f07c7a7a6cb6086a51e3df 100644 (file)
--- a/Objects/methodobject.c
+++ b/Objects/methodobject.c
@@ -87,6 +87,7 @@ PyCFunction_Call(PyObject *func, PyObject *args, PyObject *kwds)
     Py_ssize_t size;
     int flags;
 
+    assert(kwds == NULL || PyDict_Check(kwds));
     /* PyCFunction_Call() must not be called with an exception set,
        because it may clear it (directly or indirectly) and so the
        caller loses its exception */
@@ -103,7 +104,7 @@ PyCFunction_Call(PyObject *func, PyObject *args, PyObject *kwds)
         res = _PyCFunction_FastCallDict(func, stack, nargs, kwds);
     }
     else {
-        if (kwds != NULL && PyDict_Size(kwds) != 0) {
+        if (kwds != NULL && PyDict_GET_SIZE(kwds) != 0) {
             PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
                          f->m_ml->ml_name);
             return NULL;
@@ -176,7 +177,7 @@ _PyCFunction_FastCallDict(PyObject *func_obj, PyObject **args, Py_ssize_t nargs,
     switch (flags)
     {
     case METH_NOARGS:
-        if (kwargs != NULL && PyDict_Size(kwargs) != 0) {
+        if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {
             PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
                          func->m_ml->ml_name);
             return NULL;
@@ -193,7 +194,7 @@ _PyCFunction_FastCallDict(PyObject *func_obj, PyObject **args, Py_ssize_t nargs,
         break;
 
     case METH_O:
-        if (kwargs != NULL && PyDict_Size(kwargs) != 0) {
+        if (kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {
             PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
                          func->m_ml->ml_name);
             return NULL;
@@ -215,7 +216,7 @@ _PyCFunction_FastCallDict(PyObject *func_obj, PyObject **args, Py_ssize_t nargs,
         /* Slow-path: create a temporary tuple */
         PyObject *tuple;
 
-        if (!(flags & METH_KEYWORDS) && kwargs != NULL && PyDict_Size(kwargs) != 0) {
+        if (!(flags & METH_KEYWORDS) && kwargs != NULL && PyDict_GET_SIZE(kwargs) != 0) {
             PyErr_Format(PyExc_TypeError,
                          "%.200s() takes no keyword arguments",
                          func->m_ml->ml_name);

diff --git a/Objects/object.c b/Objects/object.c
index 9a7c7f7896efd2b6f34b7361a724ea4f7d271c6f..dc50131e3fd146e69af36025d74d5a3566cee9ac 100644 (file)
--- a/Objects/object.c
+++ b/Objects/object.c
@@ -1454,7 +1454,7 @@ none_dealloc(PyObject* ignore)
 static PyObject *
 none_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 {
-    if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_Size(kwargs))) {
+    if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {
         PyErr_SetString(PyExc_TypeError, "NoneType takes no arguments");
         return NULL;
     }
@@ -1573,7 +1573,7 @@ static PyMethodDef notimplemented_methods[] = {
 static PyObject *
 notimplemented_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 {
-    if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_Size(kwargs))) {
+    if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {
         PyErr_SetString(PyExc_TypeError, "NotImplementedType takes no arguments");
         return NULL;
     }

diff --git a/Objects/odictobject.c b/Objects/odictobject.c
index 6b33386e17aa6cd5cdf9b80b7defe019371ab0d9..8e6d643e90a918286b37984eae842a2fb9766b8d 100644 (file)
--- a/Objects/odictobject.c
+++ b/Objects/odictobject.c
@@ -2423,8 +2423,7 @@ mutablemapping_update(PyObject *self, PyObject *args, PyObject *kwargs)
 
     /* now handle kwargs */
     assert(kwargs == NULL || PyDict_Check(kwargs));
-    len = (kwargs != NULL) ? PyDict_Size(kwargs) : 0;
-    if (len > 0) {
+    if (kwargs != NULL && PyDict_GET_SIZE(kwargs)) {
         PyObject *items = PyDict_Items(kwargs);
         if (items == NULL)
             return NULL;

diff --git a/Objects/setobject.c b/Objects/setobject.c
index b7e0617db3b3c0f34a735fc22af39f382335f3bd..59ed7955e6adc6a894f0c859b3351255e1b72a95 100644 (file)
--- a/Objects/setobject.c
+++ b/Objects/setobject.c
@@ -981,7 +981,7 @@ set_update_internal(PySetObject *so, PyObject *other)
         PyObject *value;
         Py_ssize_t pos = 0;
         Py_hash_t hash;
-        Py_ssize_t dictsize = PyDict_Size(other);
+        Py_ssize_t dictsize = PyDict_GET_SIZE(other);
 
         /* Do one big resize at the start, rather than
         * incrementally resizing as we insert new keys.  Expect

diff --git a/Objects/sliceobject.c b/Objects/sliceobject.c
index 2f32355cd25b3c35b0af72a74161a86661c467ec..1dc7e4e65686a17c64a4d3040ed687f7b332c5d7 100644 (file)
--- a/Objects/sliceobject.c
+++ b/Objects/sliceobject.c
@@ -19,7 +19,7 @@ this type and there is exactly one in existence.
 static PyObject *
 ellipsis_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
 {
-    if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_Size(kwargs))) {
+    if (PyTuple_GET_SIZE(args) || (kwargs && PyDict_GET_SIZE(kwargs))) {
         PyErr_SetString(PyExc_TypeError, "EllipsisType takes no arguments");
         return NULL;
     }

diff --git a/Objects/typeobject.c b/Objects/typeobject.c
index 391eed3156fcda08ca421398ad95ed8836f3d033..37f0082587114119e536a1e25648fb8582ec0ad4 100644 (file)
--- a/Objects/typeobject.c
+++ b/Objects/typeobject.c
@@ -902,7 +902,7 @@ type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
     if (type == &PyType_Type &&
         PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
         (kwds == NULL ||
-         (PyDict_Check(kwds) && PyDict_Size(kwds) == 0)))
+         (PyDict_Check(kwds) && PyDict_GET_SIZE(kwds) == 0)))
         return obj;
 
     /* If the returned object is not an instance of type,
@@ -1585,7 +1585,7 @@ set_mro_error(PyObject *to_merge, int *remain)
             }
         }
     }
-    n = PyDict_Size(set);
+    n = PyDict_GET_SIZE(set);
 
     off = PyOS_snprintf(buf, sizeof(buf), "Cannot create a \
 consistent method resolution\norder (MRO) for bases");
@@ -2187,7 +2187,7 @@ type_init(PyObject *cls, PyObject *args, PyObject *kwds)
     assert(kwds == NULL || PyDict_Check(kwds));
 
     if (kwds != NULL && PyTuple_Check(args) && PyTuple_GET_SIZE(args) == 1 &&
-        PyDict_Check(kwds) && PyDict_Size(kwds) != 0) {
+        PyDict_Check(kwds) && PyDict_GET_SIZE(kwds) != 0) {
         PyErr_SetString(PyExc_TypeError,
                         "type.__init__() takes no keyword arguments");
         return -1;
@@ -2272,7 +2272,7 @@ type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
        Note: We don't call PyType_CheckExact as that also allows subclasses */
     if (metatype == &PyType_Type) {
         const Py_ssize_t nargs = PyTuple_GET_SIZE(args);
-        const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_Size(kwds);
+        const Py_ssize_t nkwds = kwds == NULL ? 0 : PyDict_GET_SIZE(kwds);
 
         if (nargs == 1 && nkwds == 0) {
             PyObject *x = PyTuple_GET_ITEM(args, 0);
@@ -3416,7 +3416,7 @@ static int
 excess_args(PyObject *args, PyObject *kwds)
 {
     return PyTuple_GET_SIZE(args) ||
-        (kwds && PyDict_Check(kwds) && PyDict_Size(kwds));
+        (kwds && PyDict_Check(kwds) && PyDict_GET_SIZE(kwds));
 }
 
 static int
@@ -3894,7 +3894,7 @@ _PyObject_GetState(PyObject *obj, int required)
                We also return None if the dict is empty to make the behavior
                consistent regardless whether the dict was initialized or not.
                This make unit testing easier. */
-            if (dict != NULL && *dict != NULL && PyDict_Size(*dict) > 0) {
+            if (dict != NULL && *dict != NULL && PyDict_GET_SIZE(*dict)) {
                 state = *dict;
             }
             else {
@@ -3983,7 +3983,7 @@ _PyObject_GetState(PyObject *obj, int required)
 
             /* If we found some slot attributes, pack them in a tuple along
                the original attribute dictionary. */
-            if (PyDict_Size(slots) > 0) {
+            if (PyDict_GET_SIZE(slots) > 0) {
                 PyObject *state2;
 
                 state2 = PyTuple_Pack(2, state, slots);
@@ -4175,7 +4175,7 @@ reduce_newobj(PyObject *obj)
         return NULL;
     }
     hasargs = (args != NULL);
-    if (kwargs == NULL || PyDict_Size(kwargs) == 0) {
+    if (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) {
         _Py_IDENTIFIER(__newobj__);
         PyObject *cls;
         Py_ssize_t i, n;

diff --git a/Python/ceval.c b/Python/ceval.c
index 0f1f36e80d759815a3bbf50fb6fb4dcfe6f8fd6b..fc11117109cebb6cdcbc6e383cd0e8b8692440b5 100644 (file)
--- a/Python/ceval.c
+++ b/Python/ceval.c
@@ -5010,7 +5010,7 @@ _PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs,
     assert(kwargs == NULL || PyDict_Check(kwargs));
 
     if (co->co_kwonlyargcount == 0 &&
-        (kwargs == NULL || PyDict_Size(kwargs) == 0) &&
+        (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) &&
         co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE))
     {
         /* Fast paths */
@@ -5028,7 +5028,7 @@ _PyFunction_FastCallDict(PyObject *func, PyObject **args, Py_ssize_t nargs,
 
     if (kwargs != NULL) {
         Py_ssize_t pos, i;
-        nk = PyDict_Size(kwargs);
+        nk = PyDict_GET_SIZE(kwargs);
 
         kwtuple = PyTuple_New(2 * nk);
         if (kwtuple == NULL) {

diff --git a/Python/compile.c b/Python/compile.c
index 25179faa3ec4267740abc00a79eac21ed3e4ecc1..17fef314829a8edaf3c9afcfc66a2e514ef19a7a 100644 (file)
--- a/Python/compile.c
+++ b/Python/compile.c
@@ -564,7 +564,7 @@ compiler_enter_scope(struct compiler *c, identifier name,
         PyObject *tuple, *name, *zero;
         int res;
         assert(u->u_scope_type == COMPILER_SCOPE_CLASS);
-        assert(PyDict_Size(u->u_cellvars) == 0);
+        assert(PyDict_GET_SIZE(u->u_cellvars) == 0);
         name = _PyUnicode_FromId(&PyId___class__);
         if (!name) {
             compiler_unit_free(u);
@@ -591,7 +591,7 @@ compiler_enter_scope(struct compiler *c, identifier name,
     }
 
     u->u_freevars = dictbytype(u->u_ste->ste_symbols, FREE, DEF_FREE_CLASS,
-                               PyDict_Size(u->u_cellvars));
+                               PyDict_GET_SIZE(u->u_cellvars));
     if (!u->u_freevars) {
         compiler_unit_free(u);
         return 0;
@@ -1128,7 +1128,7 @@ compiler_add_o(struct compiler *c, PyObject *dict, PyObject *o)
             Py_DECREF(t);
             return -1;
         }
-        arg = PyDict_Size(dict);
+        arg = PyDict_GET_SIZE(dict);
         v = PyLong_FromSsize_t(arg);
         if (!v) {
             Py_DECREF(t);
@@ -1999,7 +1999,7 @@ compiler_class(struct compiler *c, stmt_ty s)
         }
         else {
             /* No methods referenced __class__, so just return None */
-            assert(PyDict_Size(c->u->u_cellvars) == 0);
+            assert(PyDict_GET_SIZE(c->u->u_cellvars) == 0);
             ADDOP_O(c, LOAD_CONST, Py_None, consts);
         }
         ADDOP_IN_SCOPE(c, RETURN_VALUE);
@@ -5179,7 +5179,7 @@ static PyObject *
 dict_keys_inorder(PyObject *dict, Py_ssize_t offset)
 {
     PyObject *tuple, *k, *v;
-    Py_ssize_t i, pos = 0, size = PyDict_Size(dict);
+    Py_ssize_t i, pos = 0, size = PyDict_GET_SIZE(dict);
 
     tuple = PyTuple_New(size);
     if (tuple == NULL)
@@ -5203,7 +5203,6 @@ compute_code_flags(struct compiler *c)
 {
     PySTEntryObject *ste = c->u->u_ste;
     int flags = 0;
-    Py_ssize_t n;
     if (ste->ste_type == FunctionBlock) {
         flags |= CO_NEWLOCALS | CO_OPTIMIZED;
         if (ste->ste_nested)
@@ -5223,16 +5222,9 @@ compute_code_flags(struct compiler *c)
     /* (Only) inherit compilerflags in PyCF_MASK */
     flags |= (c->c_flags->cf_flags & PyCF_MASK);
 
-    n = PyDict_Size(c->u->u_freevars);
-    if (n < 0)
-        return -1;
-    if (n == 0) {
-        n = PyDict_Size(c->u->u_cellvars);
-        if (n < 0)
-            return -1;
-        if (n == 0) {
-            flags |= CO_NOFREE;
-        }
+    if (!PyDict_GET_SIZE(c->u->u_freevars) &&
+        !PyDict_GET_SIZE(c->u->u_cellvars)) {
+        flags |= CO_NOFREE;
     }
 
     return flags;
@@ -5273,7 +5265,7 @@ makecode(struct compiler *c, struct assembler *a)
     if (!freevars)
         goto error;
 
-    nlocals = PyDict_Size(c->u->u_varnames);
+    nlocals = PyDict_GET_SIZE(c->u->u_varnames);
     assert(nlocals < INT_MAX);
     nlocals_int = Py_SAFE_DOWNCAST(nlocals, Py_ssize_t, int);
 

diff --git a/Python/getargs.c b/Python/getargs.c
index c552d0fe27a2228b0c7dde44e785bc77d2e2df3b..49888d11b66d2c91f444c820cebaee42acd05355 100644 (file)
--- a/Python/getargs.c
+++ b/Python/getargs.c
@@ -1650,7 +1650,7 @@ vgetargskeywords(PyObject *args, PyObject *keywords, const char *format,
     }
 
     nargs = PyTuple_GET_SIZE(args);
-    nkeywords = (keywords == NULL) ? 0 : PyDict_Size(keywords);
+    nkeywords = (keywords == NULL) ? 0 : PyDict_GET_SIZE(keywords);
     if (nargs + nkeywords > len) {
         PyErr_Format(PyExc_TypeError,
                      "%s%s takes at most %d argument%s (%zd given)",
@@ -2034,7 +2034,7 @@ vgetargskeywordsfast_impl(PyObject **args, Py_ssize_t nargs,
     }
 
     if (keywords != NULL) {
-        nkeywords = PyDict_Size(keywords);
+        nkeywords = PyDict_GET_SIZE(keywords);
     }
     else if (kwnames != NULL) {
         nkeywords = PyTuple_GET_SIZE(kwnames);
@@ -2421,7 +2421,7 @@ _PyArg_NoKeywords(const char *funcname, PyObject *kw)
         PyErr_BadInternalCall();
         return 0;
     }
-    if (PyDict_Size(kw) == 0)
+    if (PyDict_GET_SIZE(kw) == 0)
         return 1;
 
     PyErr_Format(PyExc_TypeError, "%s does not take keyword arguments",