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

serhiy-storchaka · serhiy-storchaka · commit 5ab81d787f45 · 2016-12-16T16:18:57.000+02:00
diff --git 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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
@@ -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
diff --git a/Python/ceval.c b/Python/ceval.c
diff --git a/Python/compile.c b/Python/compile.c
diff --git a/Python/getargs.c b/Python/getargs.c

Original file line number	Diff line number	Diff line change
`@@ -3169,7 +3169,7 @@ tzinfo_reduce(PyObject *self)`
`3169`	`3169`	`PyErr_Clear();`
`3170`	`3170`	`state = Py_None;`
`3171`	`3171`	`dictptr = _PyObject_GetDictPtr(self);`
`3172`		`- if (dictptr && dictptr && PyDict_Size(dictptr)) {`
	`3172`	`+ if (dictptr && dictptr && PyDict_GET_SIZE(dictptr)) {`
`3173`	`3173`	`state = *dictptr;`
`3174`	`3174`	`}`
`3175`	`3175`	`Py_INCREF(state);`
Original file line number	Diff line number	Diff line change
`@@ -428,7 +428,7 @@ dict_as_flags(PyObject *val)`
`428`	`428`	`return DEC_INVALID_SIGNALS;`
`429`	`429`	`}`
`430`	`430`
`431`		`- if (PyDict_Size(val) != SIGNAL_MAP_LEN) {`
	`431`	`+ if (PyDict_GET_SIZE(val) != SIGNAL_MAP_LEN) {`
`432`	`432`	`PyErr_SetString(PyExc_KeyError,`
`433`	`433`	`"invalid signal dict");`
`434`	`434`	`return DEC_INVALID_SIGNALS;`
Original file line number	Diff line number	Diff line change
`@@ -150,7 +150,7 @@ list_join(PyObject* list)`
`150`	`150`	`static int`
`151`	`151`	`is_empty_dict(PyObject *obj)`
`152`	`152`	`{`
`153`		`- return PyDict_CheckExact(obj) && PyDict_Size(obj) == 0;`
	`153`	`+ return PyDict_CheckExact(obj) && PyDict_GET_SIZE(obj) == 0;`
`154`	`154`	`}`
`155`	`155`
`156`	`156`
Original file line number	Diff line number	Diff line change
`@@ -84,7 +84,7 @@ partial_new(PyTypeObject type, PyObject args, PyObject *kw)`
`84`	`84`	`}`
`85`	`85`	`Py_DECREF(nargs);`
`86`	`86`
`87`		`- if (pkw == NULL \|\| PyDict_Size(pkw) == 0) {`
	`87`	`+ if (pkw == NULL \|\| PyDict_GET_SIZE(pkw) == 0) {`
`88`	`88`	`if (kw == NULL) {`
`89`	`89`	`pto->kw = PyDict_New();`
`90`	`90`	`}`
`@@ -155,7 +155,7 @@ partial_call(partialobject pto, PyObject args, PyObject *kw)`
`155`	`155`	`assert(PyTuple_Check(argappl));`
`156`	`156`	`}`
`157`	`157`
`158`		`- if (PyDict_Size(pto->kw) == 0) {`
	`158`	`+ if (PyDict_GET_SIZE(pto->kw) == 0) {`
`159`	`159`	`kwappl = kw;`
`160`	`160`	`Py_XINCREF(kwappl);`
`161`	`161`	`}`
`@@ -713,7 +713,7 @@ lru_cache_make_key(PyObject args, PyObject kwds, int typed)`
`713`	`713`	`return args;`
`714`	`714`	`}`
`715`	`715`
`716`		`- if (kwds && PyDict_Size(kwds) > 0) {`
	`716`	`+ if (kwds && PyDict_GET_SIZE(kwds) > 0) {`
`717`	`717`	`sorted_items = PyDict_Items(kwds);`
`718`	`718`	`if (!sorted_items)`
`719`	`719`	`return NULL;`
`@@ -933,7 +933,7 @@ bounded_lru_cache_wrapper(lru_cache_object self, PyObject args, PyObject *kwds`
`933`	`933`	`}`
`934`	`934`	`lru_cache_append_link(self, link);`
`935`	`935`	`Py_INCREF(result); /* for return */`
`936`		`- self->full = (PyDict_Size(self->cache) >= self->maxsize);`
	`936`	`+ self->full = (PyDict_GET_SIZE(self->cache) >= self->maxsize);`
`937`	`937`	`}`
`938`	`938`	`self->misses++;`
`939`	`939`	`return result;`
`@@ -1062,7 +1062,7 @@ lru_cache_cache_info(lru_cache_object self, PyObject unused)`
`1062`	`1062`	`{`
`1063`	`1063`	`return PyObject_CallFunction(self->cache_info_type, "nnOn",`
`1064`	`1064`	`self->hits, self->misses, self->maxsize_O,`
`1065`		`- PyDict_Size(self->cache));`
	`1065`	`+ PyDict_GET_SIZE(self->cache));`
`1066`	`1066`	`}`
`1067`	`1067`
`1068`	`1068`	`static PyObject *`