diff -r db1d20825d71 Include/dictobject.h --- a/Include/dictobject.h Tue Dec 13 10:03:34 2016 +0100 +++ b/Include/dictobject.h Tue Dec 13 14:59:56 2016 +0200 @@ -106,6 +106,7 @@ PyAPI_FUNC(Py_ssize_t) PyDict_Size(PyObj PyAPI_FUNC(PyObject *) PyDict_Copy(PyObject *mp); PyAPI_FUNC(int) PyDict_Contains(PyObject *mp, PyObject *key); #ifndef Py_LIMITED_API +#define _PyDict_GET_SIZE(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 -r db1d20825d71 Include/odictobject.h --- a/Include/odictobject.h Tue Dec 13 10:03:34 2016 +0100 +++ b/Include/odictobject.h Tue Dec 13 14:59:56 2016 +0200 @@ -21,7 +21,7 @@ PyAPI_DATA(PyTypeObject) PyODictValues_T #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 -r db1d20825d71 Modules/_ctypes/_ctypes.c --- a/Modules/_ctypes/_ctypes.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_ctypes/_ctypes.c Tue Dec 13 14:59:56 2016 +0200 @@ -3684,7 +3684,7 @@ static PyObject * 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 -r db1d20825d71 Modules/_datetimemodule.c --- a/Modules/_datetimemodule.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_datetimemodule.c Tue Dec 13 14:59:56 2016 +0200 @@ -3169,7 +3169,8 @@ tzinfo_reduce(PyObject *self) PyErr_Clear(); state = Py_None; dictptr = _PyObject_GetDictPtr(self); - if (dictptr && *dictptr && PyDict_Size(*dictptr)) { + if (dictptr && *dictptr && + (!PyDict_Check(*dictptr) || _PyDict_GET_SIZE(*dictptr))) { state = *dictptr; } Py_INCREF(state); diff -r db1d20825d71 Modules/_decimal/_decimal.c --- a/Modules/_decimal/_decimal.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_decimal/_decimal.c Tue Dec 13 14:59:56 2016 +0200 @@ -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 -r db1d20825d71 Modules/_elementtree.c --- a/Modules/_elementtree.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_elementtree.c Tue Dec 13 14:59:56 2016 +0200 @@ -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 -r db1d20825d71 Modules/_functoolsmodule.c --- a/Modules/_functoolsmodule.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_functoolsmodule.c Tue Dec 13 14:59:56 2016 +0200 @@ -84,7 +84,7 @@ partial_new(PyTypeObject *type, PyObject } 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, PyObjec 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, PyObj 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_obje } 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 *s { 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 -r db1d20825d71 Modules/_operator.c --- a/Modules/_operator.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_operator.c Tue Dec 13 14:59:56 2016 +0200 @@ -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 -r db1d20825d71 Modules/_pickle.c --- a/Modules/_pickle.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_pickle.c Tue Dec 13 14:59:56 2016 +0200 @@ -2787,10 +2787,10 @@ batch_dict_exact(PicklerObject *self, Py 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, Py } 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 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 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 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 -r db1d20825d71 Modules/_sqlite/cache.c --- a/Modules/_sqlite/cache.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_sqlite/cache.c Tue Dec 13 14:59:56 2016 +0200 @@ -162,7 +162,7 @@ PyObject* pysqlite_cache_get(pysqlite_Ca * 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 -r db1d20825d71 Modules/_struct.c --- a/Modules/_struct.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/_struct.c Tue Dec 13 14:59:56 2016 +0200 @@ -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 -r db1d20825d71 Modules/itertoolsmodule.c --- a/Modules/itertoolsmodule.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/itertoolsmodule.c Tue Dec 13 14:59:56 2016 +0200 @@ -4180,7 +4180,7 @@ repeat_new(PyTypeObject *type, PyObject 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, PyOb 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 -r db1d20825d71 Modules/selectmodule.c --- a/Modules/selectmodule.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Modules/selectmodule.c Tue Dec 13 14:59:56 2016 +0200 @@ -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 -r db1d20825d71 Objects/abstract.c --- a/Objects/abstract.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/abstract.c Tue Dec 13 14:59:56 2016 +0200 @@ -2409,8 +2409,7 @@ PyObject ** 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 -r db1d20825d71 Objects/descrobject.c --- a/Objects/descrobject.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/descrobject.c Tue Dec 13 14:59:56 2016 +0200 @@ -1173,7 +1173,7 @@ wrapper_call(wrapperobject *wp, PyObject 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 -r db1d20825d71 Objects/funcobject.c --- a/Objects/funcobject.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/funcobject.c Tue Dec 13 14:59:56 2016 +0200 @@ -581,9 +581,8 @@ function_call(PyObject *func, PyObject * nd = 0; } - if (kw != NULL && PyDict_Check(kw)) { + if (kw != NULL && PyDict_Check(kw) && (nk = _PyDict_GET_SIZE(kw)) != 0) { Py_ssize_t pos, i; - nk = PyDict_Size(kw); kwtuple = PyTuple_New(2*nk); if (kwtuple == NULL) return NULL; diff -r db1d20825d71 Objects/methodobject.c --- a/Objects/methodobject.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/methodobject.c Tue Dec 13 14:59:56 2016 +0200 @@ -87,6 +87,7 @@ PyCFunction_Call(PyObject *func, PyObjec 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, PyObjec 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 @@ PyObject * 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 @@ PyObject * 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 @@ PyObject * /* 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 -r db1d20825d71 Objects/object.c --- a/Objects/object.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/object.c Tue Dec 13 14:59:56 2016 +0200 @@ -1366,7 +1366,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; } @@ -1485,7 +1485,7 @@ static PyMethodDef notimplemented_method 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 -r db1d20825d71 Objects/odictobject.c --- a/Objects/odictobject.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/odictobject.c Tue Dec 13 14:59:56 2016 +0200 @@ -2423,8 +2423,7 @@ mutablemapping_update(PyObject *self, Py /* 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 -r db1d20825d71 Objects/setobject.c --- a/Objects/setobject.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/setobject.c Tue Dec 13 14:59:56 2016 +0200 @@ -981,7 +981,7 @@ set_update_internal(PySetObject *so, PyO 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 -r db1d20825d71 Objects/sliceobject.c --- a/Objects/sliceobject.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/sliceobject.c Tue Dec 13 14:59:56 2016 +0200 @@ -19,7 +19,7 @@ this type and there is exactly one in ex 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 -r db1d20825d71 Objects/typeobject.c --- a/Objects/typeobject.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Objects/typeobject.c Tue Dec 13 14:59:56 2016 +0200 @@ -902,7 +902,7 @@ type_call(PyTypeObject *type, PyObject * 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 *r } } } - 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, 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, PyObjec 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,8 @@ static PyObject * 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_Check(*dict) || _PyDict_GET_SIZE(*dict))) { state = *dict; } else { @@ -3983,7 +3984,7 @@ static PyObject * /* 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 +4176,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 -r db1d20825d71 Python/ceval.c --- a/Python/ceval.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Python/ceval.c Tue Dec 13 14:59:56 2016 +0200 @@ -4913,7 +4913,7 @@ PyObject * 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 */ @@ -4929,9 +4929,8 @@ PyObject * } } - if (kwargs != NULL) { + if (kwargs != NULL && (nk = _PyDict_GET_SIZE(kwargs)) != 0) { Py_ssize_t pos, i; - nk = PyDict_Size(kwargs); kwtuple = PyTuple_New(2 * nk); if (kwtuple == NULL) { diff -r db1d20825d71 Python/compile.c --- a/Python/compile.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Python/compile.c Tue Dec 13 14:59:56 2016 +0200 @@ -564,7 +564,7 @@ compiler_enter_scope(struct compiler *c, 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, } 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; @@ -1124,7 +1124,7 @@ compiler_add_o(struct compiler *c, PyObj Py_DECREF(t); return -1; } - arg = PyDict_Size(dict); + arg = _PyDict_GET_SIZE(dict); v = PyLong_FromSsize_t(arg); if (!v) { Py_DECREF(t); @@ -1995,7 +1995,7 @@ compiler_class(struct compiler *c, stmt_ } 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); @@ -5142,7 +5142,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) @@ -5186,11 +5186,11 @@ 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); + n = _PyDict_GET_SIZE(c->u->u_freevars); if (n < 0) return -1; if (n == 0) { - n = PyDict_Size(c->u->u_cellvars); + n = _PyDict_GET_SIZE(c->u->u_cellvars); if (n < 0) return -1; if (n == 0) { @@ -5236,7 +5236,7 @@ makecode(struct compiler *c, struct asse 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 -r db1d20825d71 Python/getargs.c --- a/Python/getargs.c Tue Dec 13 10:03:34 2016 +0100 +++ b/Python/getargs.c Tue Dec 13 14:59:56 2016 +0200 @@ -1650,7 +1650,7 @@ vgetargskeywords(PyObject *args, PyObjec } 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 **arg } 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 @@ int 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",