Branch data Line data Source code
1 : : /* Type object implementation */
2 : :
3 : : #include "Python.h"
4 : : #include "pycore_call.h"
5 : : #include "pycore_code.h" // CO_FAST_FREE
6 : : #include "pycore_compile.h" // _Py_Mangle()
7 : : #include "pycore_initconfig.h" // _PyStatus_OK()
8 : : #include "pycore_moduleobject.h" // _PyModule_GetDef()
9 : : #include "pycore_object.h" // _PyType_HasFeature()
10 : : #include "pycore_pyerrors.h" // _PyErr_Occurred()
11 : : #include "pycore_pystate.h" // _PyThreadState_GET()
12 : : #include "pycore_typeobject.h" // struct type_cache
13 : : #include "pycore_unionobject.h" // _Py_union_type_or
14 : : #include "pycore_frame.h" // _PyInterpreterFrame
15 : : #include "opcode.h" // MAKE_CELL
16 : : #include "structmember.h" // PyMemberDef
17 : :
18 : : #include <ctype.h>
19 : :
20 : : /*[clinic input]
21 : : class type "PyTypeObject *" "&PyType_Type"
22 : : class object "PyObject *" "&PyBaseObject_Type"
23 : : [clinic start generated code]*/
24 : : /*[clinic end generated code: output=da39a3ee5e6b4b0d input=4b94608d231c434b]*/
25 : :
26 : : #include "clinic/typeobject.c.h"
27 : :
28 : : /* Support type attribute lookup cache */
29 : :
30 : : /* The cache can keep references to the names alive for longer than
31 : : they normally would. This is why the maximum size is limited to
32 : : MCACHE_MAX_ATTR_SIZE, since it might be a problem if very large
33 : : strings are used as attribute names. */
34 : : #define MCACHE_MAX_ATTR_SIZE 100
35 : : #define MCACHE_HASH(version, name_hash) \
36 : : (((unsigned int)(version) ^ (unsigned int)(name_hash)) \
37 : : & ((1 << MCACHE_SIZE_EXP) - 1))
38 : :
39 : : #define MCACHE_HASH_METHOD(type, name) \
40 : : MCACHE_HASH((type)->tp_version_tag, ((Py_ssize_t)(name)) >> 3)
41 : : #define MCACHE_CACHEABLE_NAME(name) \
42 : : PyUnicode_CheckExact(name) && \
43 : : PyUnicode_IS_READY(name) && \
44 : : (PyUnicode_GET_LENGTH(name) <= MCACHE_MAX_ATTR_SIZE)
45 : :
46 : : // bpo-42745: next_version_tag remains shared by all interpreters because of static types
47 : : // Used to set PyTypeObject.tp_version_tag
48 : : static unsigned int next_version_tag = 1;
49 : :
50 : : typedef struct PySlot_Offset {
51 : : short subslot_offset;
52 : : short slot_offset;
53 : : } PySlot_Offset;
54 : :
55 : :
56 : : static PyObject *
57 : : slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
58 : :
59 : : static void
60 : : clear_slotdefs(void);
61 : :
62 : : static PyObject *
63 : : lookup_maybe_method(PyObject *self, PyObject *attr, int *unbound);
64 : :
65 : : static int
66 : : slot_tp_setattro(PyObject *self, PyObject *name, PyObject *value);
67 : :
68 : : /*
69 : : * finds the beginning of the docstring's introspection signature.
70 : : * if present, returns a pointer pointing to the first '('.
71 : : * otherwise returns NULL.
72 : : *
73 : : * doesn't guarantee that the signature is valid, only that it
74 : : * has a valid prefix. (the signature must also pass skip_signature.)
75 : : */
76 : : static const char *
77 : 663554 : find_signature(const char *name, const char *doc)
78 : : {
79 : : const char *dot;
80 : : size_t length;
81 : :
82 [ + + ]: 663554 : if (!doc)
83 : 243 : return NULL;
84 : :
85 : : assert(name != NULL);
86 : :
87 : : /* for dotted names like classes, only use the last component */
88 : 663311 : dot = strrchr(name, '.');
89 [ + + ]: 663311 : if (dot)
90 : 342632 : name = dot + 1;
91 : :
92 : 663311 : length = strlen(name);
93 [ + + ]: 663311 : if (strncmp(doc, name, length))
94 : 398068 : return NULL;
95 : 265243 : doc += length;
96 [ + + ]: 265243 : if (*doc != '(')
97 : 48166 : return NULL;
98 : 217077 : return doc;
99 : : }
100 : :
101 : : #define SIGNATURE_END_MARKER ")\n--\n\n"
102 : : #define SIGNATURE_END_MARKER_LENGTH 6
103 : : /*
104 : : * skips past the end of the docstring's introspection signature.
105 : : * (assumes doc starts with a valid signature prefix.)
106 : : */
107 : : static const char *
108 : 217077 : skip_signature(const char *doc)
109 : : {
110 [ + + ]: 12047369 : while (*doc) {
111 [ + + ]: 12033066 : if ((*doc == *SIGNATURE_END_MARKER) &&
112 [ + + ]: 331893 : !strncmp(doc, SIGNATURE_END_MARKER, SIGNATURE_END_MARKER_LENGTH))
113 : 129168 : return doc + SIGNATURE_END_MARKER_LENGTH;
114 [ + + + + ]: 11903898 : if ((*doc == '\n') && (doc[1] == '\n'))
115 : 73606 : return NULL;
116 : 11830292 : doc++;
117 : : }
118 : 14303 : return NULL;
119 : : }
120 : :
121 : : int
122 : 0 : _PyType_CheckConsistency(PyTypeObject *type)
123 : : {
124 : : #define CHECK(expr) \
125 : : do { if (!(expr)) { _PyObject_ASSERT_FAILED_MSG((PyObject *)type, Py_STRINGIFY(expr)); } } while (0)
126 : :
127 [ # # ]: 0 : CHECK(!_PyObject_IsFreed((PyObject *)type));
128 : :
129 [ # # ]: 0 : if (!(type->tp_flags & Py_TPFLAGS_READY)) {
130 : : /* don't check static types before PyType_Ready() */
131 : 0 : return 1;
132 : : }
133 : :
134 [ # # ]: 0 : CHECK(Py_REFCNT(type) >= 1);
135 [ # # ]: 0 : CHECK(PyType_Check(type));
136 : :
137 [ # # ]: 0 : CHECK(!(type->tp_flags & Py_TPFLAGS_READYING));
138 [ # # ]: 0 : CHECK(type->tp_dict != NULL);
139 : :
140 [ # # ]: 0 : if (type->tp_flags & Py_TPFLAGS_HAVE_GC) {
141 : : // bpo-44263: tp_traverse is required if Py_TPFLAGS_HAVE_GC is set.
142 : : // Note: tp_clear is optional.
143 [ # # ]: 0 : CHECK(type->tp_traverse != NULL);
144 : : }
145 : :
146 [ # # ]: 0 : if (type->tp_flags & Py_TPFLAGS_DISALLOW_INSTANTIATION) {
147 [ # # ]: 0 : CHECK(type->tp_new == NULL);
148 [ # # ]: 0 : CHECK(PyDict_Contains(type->tp_dict, &_Py_ID(__new__)) == 0);
149 : : }
150 : :
151 : 0 : return 1;
152 : : #undef CHECK
153 : : }
154 : :
155 : : static const char *
156 : 661366 : _PyType_DocWithoutSignature(const char *name, const char *internal_doc)
157 : : {
158 : 661366 : const char *doc = find_signature(name, internal_doc);
159 : :
160 [ + + ]: 661366 : if (doc) {
161 : 215055 : doc = skip_signature(doc);
162 [ + + ]: 215055 : if (doc)
163 : 127286 : return doc;
164 : : }
165 : 534080 : return internal_doc;
166 : : }
167 : :
168 : : PyObject *
169 : 74063 : _PyType_GetDocFromInternalDoc(const char *name, const char *internal_doc)
170 : : {
171 : 74063 : const char *doc = _PyType_DocWithoutSignature(name, internal_doc);
172 : :
173 [ + + + + ]: 74063 : if (!doc || *doc == '\0') {
174 : 316 : Py_RETURN_NONE;
175 : : }
176 : :
177 : 73747 : return PyUnicode_FromString(doc);
178 : : }
179 : :
180 : : PyObject *
181 : 2188 : _PyType_GetTextSignatureFromInternalDoc(const char *name, const char *internal_doc)
182 : : {
183 : 2188 : const char *start = find_signature(name, internal_doc);
184 : : const char *end;
185 : :
186 [ + + ]: 2188 : if (start)
187 : 2022 : end = skip_signature(start);
188 : : else
189 : 166 : end = NULL;
190 [ + + ]: 2188 : if (!end) {
191 : 306 : Py_RETURN_NONE;
192 : : }
193 : :
194 : : /* back "end" up until it points just past the final ')' */
195 : 1882 : end -= SIGNATURE_END_MARKER_LENGTH - 1;
196 : : assert((end - start) >= 2); /* should be "()" at least */
197 : : assert(end[-1] == ')');
198 : : assert(end[0] == '\n');
199 : 1882 : return PyUnicode_FromStringAndSize(start, end - start);
200 : : }
201 : :
202 : :
203 : : static struct type_cache*
204 : 449312092 : get_type_cache(void)
205 : : {
206 : 449312092 : PyInterpreterState *interp = _PyInterpreterState_GET();
207 : 449312092 : return &interp->type_cache;
208 : : }
209 : :
210 : :
211 : : static void
212 : 3156 : type_cache_clear(struct type_cache *cache, PyObject *value)
213 : : {
214 [ + + ]: 12930132 : for (Py_ssize_t i = 0; i < (1 << MCACHE_SIZE_EXP); i++) {
215 : 12926976 : struct type_cache_entry *entry = &cache->hashtable[i];
216 : 12926976 : entry->version = 0;
217 : 12926976 : Py_XSETREF(entry->name, _Py_XNewRef(value));
218 : 12926976 : entry->value = NULL;
219 : : }
220 : 3156 : }
221 : :
222 : :
223 : : void
224 : 3138 : _PyType_InitCache(PyInterpreterState *interp)
225 : : {
226 : 3138 : struct type_cache *cache = &interp->type_cache;
227 [ + + ]: 12856386 : for (Py_ssize_t i = 0; i < (1 << MCACHE_SIZE_EXP); i++) {
228 : 12853248 : struct type_cache_entry *entry = &cache->hashtable[i];
229 : : assert(entry->name == NULL);
230 : :
231 : 12853248 : entry->version = 0;
232 : : // Set to None so _PyType_Lookup() can use Py_SETREF(),
233 : : // rather than using slower Py_XSETREF().
234 : 12853248 : entry->name = Py_NewRef(Py_None);
235 : 12853248 : entry->value = NULL;
236 : : }
237 : 3138 : }
238 : :
239 : :
240 : : static unsigned int
241 : 31 : _PyType_ClearCache(PyInterpreterState *interp)
242 : : {
243 : 31 : struct type_cache *cache = &interp->type_cache;
244 : : #if MCACHE_STATS
245 : : size_t total = cache->hits + cache->collisions + cache->misses;
246 : : fprintf(stderr, "-- Method cache hits = %zd (%d%%)\n",
247 : : cache->hits, (int) (100.0 * cache->hits / total));
248 : : fprintf(stderr, "-- Method cache true misses = %zd (%d%%)\n",
249 : : cache->misses, (int) (100.0 * cache->misses / total));
250 : : fprintf(stderr, "-- Method cache collisions = %zd (%d%%)\n",
251 : : cache->collisions, (int) (100.0 * cache->collisions / total));
252 : : fprintf(stderr, "-- Method cache size = %zd KiB\n",
253 : : sizeof(cache->hashtable) / 1024);
254 : : #endif
255 : :
256 : : // Set to None, rather than NULL, so _PyType_Lookup() can
257 : : // use Py_SETREF() rather than using slower Py_XSETREF().
258 : 31 : type_cache_clear(cache, Py_None);
259 : :
260 : 31 : return next_version_tag - 1;
261 : : }
262 : :
263 : :
264 : : unsigned int
265 : 31 : PyType_ClearCache(void)
266 : : {
267 : 31 : PyInterpreterState *interp = _PyInterpreterState_GET();
268 : 31 : return _PyType_ClearCache(interp);
269 : : }
270 : :
271 : :
272 : : void
273 : 3125 : _PyTypes_Fini(PyInterpreterState *interp)
274 : : {
275 : 3125 : struct type_cache *cache = &interp->type_cache;
276 : 3125 : type_cache_clear(cache, NULL);
277 [ + + ]: 3125 : if (_Py_IsMainInterpreter(interp)) {
278 : 2956 : clear_slotdefs();
279 : : }
280 : 3125 : }
281 : :
282 : :
283 : : void
284 : 13486479 : PyType_Modified(PyTypeObject *type)
285 : : {
286 : : /* Invalidate any cached data for the specified type and all
287 : : subclasses. This function is called after the base
288 : : classes, mro, or attributes of the type are altered.
289 : :
290 : : Invariants:
291 : :
292 : : - before Py_TPFLAGS_VALID_VERSION_TAG can be set on a type,
293 : : it must first be set on all super types.
294 : :
295 : : This function clears the Py_TPFLAGS_VALID_VERSION_TAG of a
296 : : type (so it must first clear it on all subclasses). The
297 : : tp_version_tag value is meaningless unless this flag is set.
298 : : We don't assign new version tags eagerly, but only as
299 : : needed.
300 : : */
301 [ + + ]: 13486479 : if (!_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {
302 : 4013300 : return;
303 : : }
304 : :
305 : 9473179 : PyObject *subclasses = type->tp_subclasses;
306 [ + + ]: 9473179 : if (subclasses != NULL) {
307 : : assert(PyDict_CheckExact(subclasses));
308 : :
309 : 131658 : Py_ssize_t i = 0;
310 : : PyObject *ref;
311 [ + + ]: 486925 : while (PyDict_Next(subclasses, &i, NULL, &ref)) {
312 : : assert(PyWeakref_CheckRef(ref));
313 : 355267 : PyObject *obj = PyWeakref_GET_OBJECT(ref);
314 [ + + ]: 355267 : if (obj == Py_None) {
315 : 351398 : continue;
316 : : }
317 : 3869 : PyType_Modified(_PyType_CAST(obj));
318 : : }
319 : : }
320 : :
321 : 9473179 : type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
322 : 9473179 : type->tp_version_tag = 0; /* 0 is not a valid version tag */
323 : : }
324 : :
325 : : static void
326 : 4011956 : type_mro_modified(PyTypeObject *type, PyObject *bases) {
327 : : /*
328 : : Check that all base classes or elements of the MRO of type are
329 : : able to be cached. This function is called after the base
330 : : classes or mro of the type are altered.
331 : :
332 : : Unset HAVE_VERSION_TAG and VALID_VERSION_TAG if the type
333 : : has a custom MRO that includes a type which is not officially
334 : : super type, or if the type implements its own mro() method.
335 : :
336 : : Called from mro_internal, which will subsequently be called on
337 : : each subclass when their mro is recursively updated.
338 : : */
339 : : Py_ssize_t i, n;
340 : 4011956 : int custom = !Py_IS_TYPE(type, &PyType_Type);
341 : : int unbound;
342 : :
343 [ + + ]: 4011956 : if (custom) {
344 : : PyObject *mro_meth, *type_mro_meth;
345 : 480818 : mro_meth = lookup_maybe_method(
346 : : (PyObject *)type, &_Py_ID(mro), &unbound);
347 [ - + ]: 480818 : if (mro_meth == NULL) {
348 : 0 : goto clear;
349 : : }
350 : 480818 : type_mro_meth = lookup_maybe_method(
351 : : (PyObject *)&PyType_Type, &_Py_ID(mro), &unbound);
352 [ - + ]: 480818 : if (type_mro_meth == NULL) {
353 : 0 : Py_DECREF(mro_meth);
354 : 0 : goto clear;
355 : : }
356 : 480818 : int custom_mro = (mro_meth != type_mro_meth);
357 : 480818 : Py_DECREF(mro_meth);
358 : 480818 : Py_DECREF(type_mro_meth);
359 [ + + ]: 480818 : if (custom_mro) {
360 : 86 : goto clear;
361 : : }
362 : : }
363 : 4011870 : n = PyTuple_GET_SIZE(bases);
364 [ + + ]: 12791670 : for (i = 0; i < n; i++) {
365 : 8779801 : PyObject *b = PyTuple_GET_ITEM(bases, i);
366 : 8779801 : PyTypeObject *cls = _PyType_CAST(b);
367 : :
368 [ + + ]: 8779801 : if (!PyType_IsSubtype(type, cls)) {
369 : 1 : goto clear;
370 : : }
371 : : }
372 : 4011869 : return;
373 : 87 : clear:
374 : 87 : type->tp_flags &= ~Py_TPFLAGS_VALID_VERSION_TAG;
375 : 87 : type->tp_version_tag = 0; /* 0 is not a valid version tag */
376 : : }
377 : :
378 : : static int
379 : 52416362 : assign_version_tag(struct type_cache *cache, PyTypeObject *type)
380 : : {
381 : : /* Ensure that the tp_version_tag is valid and set
382 : : Py_TPFLAGS_VALID_VERSION_TAG. To respect the invariant, this
383 : : must first be done on all super classes. Return 0 if this
384 : : cannot be done, 1 if Py_TPFLAGS_VALID_VERSION_TAG.
385 : : */
386 [ + + ]: 52416362 : if (_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG)) {
387 : 42762187 : return 1;
388 : : }
389 [ - + ]: 9654175 : if (!_PyType_HasFeature(type, Py_TPFLAGS_READY)) {
390 : 0 : return 0;
391 : : }
392 : :
393 [ - + ]: 9654175 : if (next_version_tag == 0) {
394 : : /* We have run out of version numbers */
395 : 0 : return 0;
396 : : }
397 : 9654175 : type->tp_version_tag = next_version_tag++;
398 : : assert (type->tp_version_tag != 0);
399 : :
400 : 9654175 : PyObject *bases = type->tp_bases;
401 : 9654175 : Py_ssize_t n = PyTuple_GET_SIZE(bases);
402 [ + + ]: 19451812 : for (Py_ssize_t i = 0; i < n; i++) {
403 : 9797637 : PyObject *b = PyTuple_GET_ITEM(bases, i);
404 [ - + ]: 9797637 : if (!assign_version_tag(cache, _PyType_CAST(b)))
405 : 0 : return 0;
406 : : }
407 : 9654175 : type->tp_flags |= Py_TPFLAGS_VALID_VERSION_TAG;
408 : 9654175 : return 1;
409 : : }
410 : :
411 : :
412 : : static PyMemberDef type_members[] = {
413 : : {"__basicsize__", T_PYSSIZET, offsetof(PyTypeObject,tp_basicsize),READONLY},
414 : : {"__itemsize__", T_PYSSIZET, offsetof(PyTypeObject, tp_itemsize), READONLY},
415 : : {"__flags__", T_ULONG, offsetof(PyTypeObject, tp_flags), READONLY},
416 : : {"__weakrefoffset__", T_PYSSIZET,
417 : : offsetof(PyTypeObject, tp_weaklistoffset), READONLY},
418 : : {"__base__", T_OBJECT, offsetof(PyTypeObject, tp_base), READONLY},
419 : : {"__dictoffset__", T_PYSSIZET,
420 : : offsetof(PyTypeObject, tp_dictoffset), READONLY},
421 : : {"__mro__", T_OBJECT, offsetof(PyTypeObject, tp_mro), READONLY},
422 : : {0}
423 : : };
424 : :
425 : : static int
426 : 89630 : check_set_special_type_attr(PyTypeObject *type, PyObject *value, const char *name)
427 : : {
428 [ + + ]: 89630 : if (_PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE)) {
429 : 2 : PyErr_Format(PyExc_TypeError,
430 : : "cannot set '%s' attribute of immutable type '%s'",
431 : : name, type->tp_name);
432 : 2 : return 0;
433 : : }
434 [ + + ]: 89628 : if (!value) {
435 : 3 : PyErr_Format(PyExc_TypeError,
436 : : "cannot delete '%s' attribute of immutable type '%s'",
437 : : name, type->tp_name);
438 : 3 : return 0;
439 : : }
440 : :
441 [ - + ]: 89625 : if (PySys_Audit("object.__setattr__", "OsO",
442 : : type, name, value) < 0) {
443 : 0 : return 0;
444 : : }
445 : :
446 : 89625 : return 1;
447 : : }
448 : :
449 : : const char *
450 : 927769 : _PyType_Name(PyTypeObject *type)
451 : : {
452 : : assert(type->tp_name != NULL);
453 : 927769 : const char *s = strrchr(type->tp_name, '.');
454 [ + + ]: 927769 : if (s == NULL) {
455 : 668735 : s = type->tp_name;
456 : : }
457 : : else {
458 : 259034 : s++;
459 : : }
460 : 927769 : return s;
461 : : }
462 : :
463 : : static PyObject *
464 : 3336283 : type_name(PyTypeObject *type, void *context)
465 : : {
466 [ + + ]: 3336283 : if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
467 : 2639522 : PyHeapTypeObject* et = (PyHeapTypeObject*)type;
468 : :
469 : 2639522 : Py_INCREF(et->ht_name);
470 : 2639522 : return et->ht_name;
471 : : }
472 : : else {
473 : 696761 : return PyUnicode_FromString(_PyType_Name(type));
474 : : }
475 : : }
476 : :
477 : : static PyObject *
478 : 660915 : type_qualname(PyTypeObject *type, void *context)
479 : : {
480 [ + + ]: 660915 : if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
481 : 585648 : PyHeapTypeObject* et = (PyHeapTypeObject*)type;
482 : 585648 : Py_INCREF(et->ht_qualname);
483 : 585648 : return et->ht_qualname;
484 : : }
485 : : else {
486 : 75267 : return PyUnicode_FromString(_PyType_Name(type));
487 : : }
488 : : }
489 : :
490 : : static int
491 : 18544 : type_set_name(PyTypeObject *type, PyObject *value, void *context)
492 : : {
493 : : const char *tp_name;
494 : : Py_ssize_t name_size;
495 : :
496 [ - + ]: 18544 : if (!check_set_special_type_attr(type, value, "__name__"))
497 : 0 : return -1;
498 [ + + ]: 18544 : if (!PyUnicode_Check(value)) {
499 : 1 : PyErr_Format(PyExc_TypeError,
500 : : "can only assign string to %s.__name__, not '%s'",
501 : 1 : type->tp_name, Py_TYPE(value)->tp_name);
502 : 1 : return -1;
503 : : }
504 : :
505 : 18543 : tp_name = PyUnicode_AsUTF8AndSize(value, &name_size);
506 [ + + ]: 18543 : if (tp_name == NULL)
507 : 1 : return -1;
508 [ + + ]: 18542 : if (strlen(tp_name) != (size_t)name_size) {
509 : 1 : PyErr_SetString(PyExc_ValueError,
510 : : "type name must not contain null characters");
511 : 1 : return -1;
512 : : }
513 : :
514 : 18541 : type->tp_name = tp_name;
515 : 18541 : Py_INCREF(value);
516 : 18541 : Py_SETREF(((PyHeapTypeObject*)type)->ht_name, value);
517 : :
518 : 18541 : return 0;
519 : : }
520 : :
521 : : static int
522 : 17414 : type_set_qualname(PyTypeObject *type, PyObject *value, void *context)
523 : : {
524 : : PyHeapTypeObject* et;
525 : :
526 [ + + ]: 17414 : if (!check_set_special_type_attr(type, value, "__qualname__"))
527 : 2 : return -1;
528 [ + + ]: 17412 : if (!PyUnicode_Check(value)) {
529 : 1 : PyErr_Format(PyExc_TypeError,
530 : : "can only assign string to %s.__qualname__, not '%s'",
531 : 1 : type->tp_name, Py_TYPE(value)->tp_name);
532 : 1 : return -1;
533 : : }
534 : :
535 : 17411 : et = (PyHeapTypeObject*)type;
536 : 17411 : Py_INCREF(value);
537 : 17411 : Py_SETREF(et->ht_qualname, value);
538 : 17411 : return 0;
539 : : }
540 : :
541 : : static PyObject *
542 : 678559 : type_module(PyTypeObject *type, void *context)
543 : : {
544 : : PyObject *mod;
545 : :
546 [ + + ]: 678559 : if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
547 : 596929 : mod = PyDict_GetItemWithError(type->tp_dict, &_Py_ID(__module__));
548 [ - + ]: 596929 : if (mod == NULL) {
549 [ # # ]: 0 : if (!PyErr_Occurred()) {
550 : 0 : PyErr_Format(PyExc_AttributeError, "__module__");
551 : : }
552 : 0 : return NULL;
553 : : }
554 : 596929 : Py_INCREF(mod);
555 : : }
556 : : else {
557 : 81630 : const char *s = strrchr(type->tp_name, '.');
558 [ + + ]: 81630 : if (s != NULL) {
559 : 121834 : mod = PyUnicode_FromStringAndSize(
560 : 60917 : type->tp_name, (Py_ssize_t)(s - type->tp_name));
561 [ + - ]: 60917 : if (mod != NULL)
562 : 60917 : PyUnicode_InternInPlace(&mod);
563 : : }
564 : : else {
565 : 20713 : mod = &_Py_ID(builtins);
566 : 20713 : Py_INCREF(mod);
567 : : }
568 : : }
569 : 678559 : return mod;
570 : : }
571 : :
572 : : static int
573 : 48797 : type_set_module(PyTypeObject *type, PyObject *value, void *context)
574 : : {
575 [ - + ]: 48797 : if (!check_set_special_type_attr(type, value, "__module__"))
576 : 0 : return -1;
577 : :
578 : 48797 : PyType_Modified(type);
579 : :
580 : 48797 : return PyDict_SetItem(type->tp_dict, &_Py_ID(__module__), value);
581 : : }
582 : :
583 : : static PyObject *
584 : 219209 : type_abstractmethods(PyTypeObject *type, void *context)
585 : : {
586 : 219209 : PyObject *mod = NULL;
587 : : /* type itself has an __abstractmethods__ descriptor (this). Don't return
588 : : that. */
589 [ + + ]: 219209 : if (type != &PyType_Type)
590 : 219203 : mod = PyDict_GetItemWithError(type->tp_dict,
591 : : &_Py_ID(__abstractmethods__));
592 [ + + ]: 219209 : if (!mod) {
593 [ + - ]: 55173 : if (!PyErr_Occurred()) {
594 : 55173 : PyErr_SetObject(PyExc_AttributeError, &_Py_ID(__abstractmethods__));
595 : : }
596 : 55173 : return NULL;
597 : : }
598 : 164036 : Py_INCREF(mod);
599 : 164036 : return mod;
600 : : }
601 : :
602 : : static int
603 : 175640 : type_set_abstractmethods(PyTypeObject *type, PyObject *value, void *context)
604 : : {
605 : : /* __abstractmethods__ should only be set once on a type, in
606 : : abc.ABCMeta.__new__, so this function doesn't do anything
607 : : special to update subclasses.
608 : : */
609 : : int abstract, res;
610 [ + + ]: 175640 : if (value != NULL) {
611 : 175639 : abstract = PyObject_IsTrue(value);
612 [ - + ]: 175639 : if (abstract < 0)
613 : 0 : return -1;
614 : 175639 : res = PyDict_SetItem(type->tp_dict, &_Py_ID(__abstractmethods__), value);
615 : : }
616 : : else {
617 : 1 : abstract = 0;
618 : 1 : res = PyDict_DelItem(type->tp_dict, &_Py_ID(__abstractmethods__));
619 [ + - + - ]: 1 : if (res && PyErr_ExceptionMatches(PyExc_KeyError)) {
620 : 1 : PyErr_SetObject(PyExc_AttributeError, &_Py_ID(__abstractmethods__));
621 : 1 : return -1;
622 : : }
623 : : }
624 [ + - ]: 175639 : if (res == 0) {
625 : 175639 : PyType_Modified(type);
626 [ + + ]: 175639 : if (abstract)
627 : 81580 : type->tp_flags |= Py_TPFLAGS_IS_ABSTRACT;
628 : : else
629 : 94059 : type->tp_flags &= ~Py_TPFLAGS_IS_ABSTRACT;
630 : : }
631 : 175639 : return res;
632 : : }
633 : :
634 : : static PyObject *
635 : 263504 : type_get_bases(PyTypeObject *type, void *context)
636 : : {
637 : 263504 : Py_INCREF(type->tp_bases);
638 : 263504 : return type->tp_bases;
639 : : }
640 : :
641 : : static PyTypeObject *best_base(PyObject *);
642 : : static int mro_internal(PyTypeObject *, PyObject **);
643 : : static int type_is_subtype_base_chain(PyTypeObject *, PyTypeObject *);
644 : : static int compatible_for_assignment(PyTypeObject *, PyTypeObject *, const char *);
645 : : static int add_subclass(PyTypeObject*, PyTypeObject*);
646 : : static int add_all_subclasses(PyTypeObject *type, PyObject *bases);
647 : : static void remove_subclass(PyTypeObject *, PyTypeObject *);
648 : : static void remove_all_subclasses(PyTypeObject *type, PyObject *bases);
649 : : static void update_all_slots(PyTypeObject *);
650 : :
651 : : typedef int (*update_callback)(PyTypeObject *, void *);
652 : : static int update_subclasses(PyTypeObject *type, PyObject *attr_name,
653 : : update_callback callback, void *data);
654 : : static int recurse_down_subclasses(PyTypeObject *type, PyObject *name,
655 : : update_callback callback, void *data);
656 : :
657 : : static int
658 : 720 : mro_hierarchy(PyTypeObject *type, PyObject *temp)
659 : : {
660 : : PyObject *old_mro;
661 : 720 : int res = mro_internal(type, &old_mro);
662 [ + + ]: 720 : if (res <= 0) {
663 : : /* error / reentrance */
664 : 21 : return res;
665 : : }
666 : 699 : PyObject *new_mro = type->tp_mro;
667 : :
668 : : PyObject *tuple;
669 [ + + ]: 699 : if (old_mro != NULL) {
670 : 698 : tuple = PyTuple_Pack(3, type, new_mro, old_mro);
671 : : }
672 : : else {
673 : 1 : tuple = PyTuple_Pack(2, type, new_mro);
674 : : }
675 : :
676 [ + - ]: 699 : if (tuple != NULL) {
677 : 699 : res = PyList_Append(temp, tuple);
678 : : }
679 : : else {
680 : 0 : res = -1;
681 : : }
682 : 699 : Py_XDECREF(tuple);
683 : :
684 [ - + ]: 699 : if (res < 0) {
685 : 0 : type->tp_mro = old_mro;
686 : 0 : Py_DECREF(new_mro);
687 : 0 : return -1;
688 : : }
689 : 699 : Py_XDECREF(old_mro);
690 : :
691 : : // Avoid creating an empty list if there is no subclass
692 [ + + ]: 699 : if (type->tp_subclasses != NULL) {
693 : : /* Obtain a copy of subclasses list to iterate over.
694 : :
695 : : Otherwise type->tp_subclasses might be altered
696 : : in the middle of the loop, for example, through a custom mro(),
697 : : by invoking type_set_bases on some subclass of the type
698 : : which in turn calls remove_subclass/add_subclass on this type.
699 : :
700 : : Finally, this makes things simple avoiding the need to deal
701 : : with dictionary iterators and weak references.
702 : : */
703 : 20 : PyObject *subclasses = _PyType_GetSubclasses(type);
704 [ - + ]: 20 : if (subclasses == NULL) {
705 : 0 : return -1;
706 : : }
707 : :
708 : 20 : Py_ssize_t n = PyList_GET_SIZE(subclasses);
709 [ + + ]: 55 : for (Py_ssize_t i = 0; i < n; i++) {
710 : 37 : PyTypeObject *subclass = _PyType_CAST(PyList_GET_ITEM(subclasses, i));
711 : 37 : res = mro_hierarchy(subclass, temp);
712 [ + + ]: 37 : if (res < 0) {
713 : 2 : break;
714 : : }
715 : : }
716 : 20 : Py_DECREF(subclasses);
717 : : }
718 : :
719 : 699 : return res;
720 : : }
721 : :
722 : : static int
723 : 695 : type_set_bases(PyTypeObject *type, PyObject *new_bases, void *context)
724 : : {
725 : : // Check arguments
726 [ + + ]: 695 : if (!check_set_special_type_attr(type, new_bases, "__bases__")) {
727 : 1 : return -1;
728 : : }
729 : : assert(new_bases != NULL);
730 : :
731 [ - + ]: 694 : if (!PyTuple_Check(new_bases)) {
732 : 0 : PyErr_Format(PyExc_TypeError,
733 : : "can only assign tuple to %s.__bases__, not %s",
734 : 0 : type->tp_name, Py_TYPE(new_bases)->tp_name);
735 : 0 : return -1;
736 : : }
737 [ + + ]: 694 : if (PyTuple_GET_SIZE(new_bases) == 0) {
738 : 1 : PyErr_Format(PyExc_TypeError,
739 : : "can only assign non-empty tuple to %s.__bases__, not ()",
740 : : type->tp_name);
741 : 1 : return -1;
742 : : }
743 : 693 : Py_ssize_t n = PyTuple_GET_SIZE(new_bases);
744 [ + + ]: 1397 : for (Py_ssize_t i = 0; i < n; i++) {
745 : 707 : PyObject *ob = PyTuple_GET_ITEM(new_bases, i);
746 [ - + ]: 707 : if (!PyType_Check(ob)) {
747 : 0 : PyErr_Format(PyExc_TypeError,
748 : : "%s.__bases__ must be tuple of classes, not '%s'",
749 : 0 : type->tp_name, Py_TYPE(ob)->tp_name);
750 : 0 : return -1;
751 : : }
752 : 707 : PyTypeObject *base = (PyTypeObject*)ob;
753 : :
754 [ + + ]: 707 : if (PyType_IsSubtype(base, type) ||
755 : : /* In case of reentering here again through a custom mro()
756 : : the above check is not enough since it relies on
757 : : base->tp_mro which would gonna be updated inside
758 : : mro_internal only upon returning from the mro().
759 : :
760 : : However, base->tp_base has already been assigned (see
761 : : below), which in turn may cause an inheritance cycle
762 : : through tp_base chain. And this is definitely
763 : : not what you want to ever happen. */
764 [ + - + + ]: 705 : (base->tp_mro != NULL && type_is_subtype_base_chain(base, type)))
765 : : {
766 : 3 : PyErr_SetString(PyExc_TypeError,
767 : : "a __bases__ item causes an inheritance cycle");
768 : 3 : return -1;
769 : : }
770 : : }
771 : :
772 : : // Compute the new MRO and the new base class
773 : 690 : PyTypeObject *new_base = best_base(new_bases);
774 [ + + ]: 690 : if (new_base == NULL)
775 : 5 : return -1;
776 : :
777 [ + + ]: 685 : if (!compatible_for_assignment(type->tp_base, new_base, "__bases__")) {
778 : 2 : return -1;
779 : : }
780 : :
781 : 683 : PyObject *old_bases = type->tp_bases;
782 : : assert(old_bases != NULL);
783 : 683 : PyTypeObject *old_base = type->tp_base;
784 : :
785 : 683 : type->tp_bases = Py_NewRef(new_bases);
786 : 683 : type->tp_base = (PyTypeObject *)Py_NewRef(new_base);
787 : :
788 : 683 : PyObject *temp = PyList_New(0);
789 [ - + ]: 683 : if (temp == NULL) {
790 : 0 : goto bail;
791 : : }
792 [ + + ]: 683 : if (mro_hierarchy(type, temp) < 0) {
793 : 7 : goto undo;
794 : : }
795 : 676 : Py_DECREF(temp);
796 : :
797 : : /* Take no action in case if type->tp_bases has been replaced
798 : : through reentrance. */
799 : : int res;
800 [ + + ]: 676 : if (type->tp_bases == new_bases) {
801 : : /* any base that was in __bases__ but now isn't, we
802 : : need to remove |type| from its tp_subclasses.
803 : : conversely, any class now in __bases__ that wasn't
804 : : needs to have |type| added to its subclasses. */
805 : :
806 : : /* for now, sod that: just remove from all old_bases,
807 : : add to all new_bases */
808 : 675 : remove_all_subclasses(type, old_bases);
809 : 675 : res = add_all_subclasses(type, new_bases);
810 : 675 : update_all_slots(type);
811 : : }
812 : : else {
813 : 1 : res = 0;
814 : : }
815 : :
816 : 676 : Py_DECREF(old_bases);
817 : 676 : Py_DECREF(old_base);
818 : :
819 : : assert(_PyType_CheckConsistency(type));
820 : 676 : return res;
821 : :
822 : 7 : undo:
823 : 7 : n = PyList_GET_SIZE(temp);
824 [ + + ]: 10 : for (Py_ssize_t i = n - 1; i >= 0; i--) {
825 : : PyTypeObject *cls;
826 : 3 : PyObject *new_mro, *old_mro = NULL;
827 : :
828 : 3 : PyArg_UnpackTuple(PyList_GET_ITEM(temp, i),
829 : : "", 2, 3, &cls, &new_mro, &old_mro);
830 : : /* Do not rollback if cls has a newer version of MRO. */
831 [ + - ]: 3 : if (cls->tp_mro == new_mro) {
832 : 3 : Py_XINCREF(old_mro);
833 : 3 : cls->tp_mro = old_mro;
834 : 3 : Py_DECREF(new_mro);
835 : : }
836 : : }
837 : 7 : Py_DECREF(temp);
838 : :
839 : 7 : bail:
840 [ + + ]: 7 : if (type->tp_bases == new_bases) {
841 : : assert(type->tp_base == new_base);
842 : :
843 : 6 : type->tp_bases = old_bases;
844 : 6 : type->tp_base = old_base;
845 : :
846 : 6 : Py_DECREF(new_bases);
847 : 6 : Py_DECREF(new_base);
848 : : }
849 : : else {
850 : 1 : Py_DECREF(old_bases);
851 : 1 : Py_DECREF(old_base);
852 : : }
853 : :
854 : : assert(_PyType_CheckConsistency(type));
855 : 7 : return -1;
856 : : }
857 : :
858 : : static PyObject *
859 : 1337337 : type_dict(PyTypeObject *type, void *context)
860 : : {
861 [ - + ]: 1337337 : if (type->tp_dict == NULL) {
862 : 0 : Py_RETURN_NONE;
863 : : }
864 : 1337337 : return PyDictProxy_New(type->tp_dict);
865 : : }
866 : :
867 : : static PyObject *
868 : 75215 : type_get_doc(PyTypeObject *type, void *context)
869 : : {
870 : : PyObject *result;
871 [ + + + + ]: 75215 : if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE) && type->tp_doc != NULL) {
872 : 57345 : return _PyType_GetDocFromInternalDoc(type->tp_name, type->tp_doc);
873 : : }
874 : 17870 : result = PyDict_GetItemWithError(type->tp_dict, &_Py_ID(__doc__));
875 [ - + ]: 17870 : if (result == NULL) {
876 [ # # ]: 0 : if (!PyErr_Occurred()) {
877 : 0 : result = Py_None;
878 : 0 : Py_INCREF(result);
879 : : }
880 : : }
881 [ + + ]: 17870 : else if (Py_TYPE(result)->tp_descr_get) {
882 : 527 : result = Py_TYPE(result)->tp_descr_get(result, NULL,
883 : : (PyObject *)type);
884 : : }
885 : : else {
886 : 17343 : Py_INCREF(result);
887 : : }
888 : 17870 : return result;
889 : : }
890 : :
891 : : static PyObject *
892 : 292 : type_get_text_signature(PyTypeObject *type, void *context)
893 : : {
894 : 292 : return _PyType_GetTextSignatureFromInternalDoc(type->tp_name, type->tp_doc);
895 : : }
896 : :
897 : : static int
898 : 4180 : type_set_doc(PyTypeObject *type, PyObject *value, void *context)
899 : : {
900 [ + + ]: 4180 : if (!check_set_special_type_attr(type, value, "__doc__"))
901 : 2 : return -1;
902 : 4178 : PyType_Modified(type);
903 : 4178 : return PyDict_SetItem(type->tp_dict, &_Py_ID(__doc__), value);
904 : : }
905 : :
906 : : static PyObject *
907 : 49402 : type_get_annotations(PyTypeObject *type, void *context)
908 : : {
909 [ + + ]: 49402 : if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
910 : 43535 : PyErr_Format(PyExc_AttributeError, "type object '%s' has no attribute '__annotations__'", type->tp_name);
911 : 43535 : return NULL;
912 : : }
913 : :
914 : : PyObject *annotations;
915 : : /* there's no _PyDict_GetItemId without WithError, so let's LBYL. */
916 [ + + ]: 5867 : if (PyDict_Contains(type->tp_dict, &_Py_ID(__annotations__))) {
917 : 613 : annotations = PyDict_GetItemWithError(
918 : : type->tp_dict, &_Py_ID(__annotations__));
919 : : /*
920 : : ** PyDict_GetItemWithError could still fail,
921 : : ** for instance with a well-timed Ctrl-C or a MemoryError.
922 : : ** so let's be totally safe.
923 : : */
924 [ + - ]: 613 : if (annotations) {
925 [ - + ]: 613 : if (Py_TYPE(annotations)->tp_descr_get) {
926 : 0 : annotations = Py_TYPE(annotations)->tp_descr_get(
927 : : annotations, NULL, (PyObject *)type);
928 : : } else {
929 : 613 : Py_INCREF(annotations);
930 : : }
931 : : }
932 : : } else {
933 : 5254 : annotations = PyDict_New();
934 [ + - ]: 5254 : if (annotations) {
935 : 5254 : int result = PyDict_SetItem(
936 : : type->tp_dict, &_Py_ID(__annotations__), annotations);
937 [ - + ]: 5254 : if (result) {
938 [ # # ]: 0 : Py_CLEAR(annotations);
939 : : } else {
940 : 5254 : PyType_Modified(type);
941 : : }
942 : : }
943 : : }
944 : 5867 : return annotations;
945 : : }
946 : :
947 : : static int
948 : 727 : type_set_annotations(PyTypeObject *type, PyObject *value, void *context)
949 : : {
950 [ - + ]: 727 : if (_PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE)) {
951 : 0 : PyErr_Format(PyExc_TypeError,
952 : : "cannot set '__annotations__' attribute of immutable type '%s'",
953 : : type->tp_name);
954 : 0 : return -1;
955 : : }
956 : :
957 : : int result;
958 [ + + ]: 727 : if (value != NULL) {
959 : : /* set */
960 : 718 : result = PyDict_SetItem(type->tp_dict, &_Py_ID(__annotations__), value);
961 : : } else {
962 : : /* delete */
963 [ + + ]: 9 : if (!PyDict_Contains(type->tp_dict, &_Py_ID(__annotations__))) {
964 : 1 : PyErr_Format(PyExc_AttributeError, "__annotations__");
965 : 1 : return -1;
966 : : }
967 : 8 : result = PyDict_DelItem(type->tp_dict, &_Py_ID(__annotations__));
968 : : }
969 : :
970 [ + - ]: 726 : if (result == 0) {
971 : 726 : PyType_Modified(type);
972 : : }
973 : 726 : return result;
974 : : }
975 : :
976 : :
977 : : /*[clinic input]
978 : : type.__instancecheck__ -> bool
979 : :
980 : : instance: object
981 : : /
982 : :
983 : : Check if an object is an instance.
984 : : [clinic start generated code]*/
985 : :
986 : : static int
987 : 401552 : type___instancecheck___impl(PyTypeObject *self, PyObject *instance)
988 : : /*[clinic end generated code: output=08b6bf5f591c3618 input=cdbfeaee82c01a0f]*/
989 : : {
990 : 401552 : return _PyObject_RealIsInstance(instance, (PyObject *)self);
991 : : }
992 : :
993 : : /*[clinic input]
994 : : type.__subclasscheck__ -> bool
995 : :
996 : : subclass: object
997 : : /
998 : :
999 : : Check if a class is a subclass.
1000 : : [clinic start generated code]*/
1001 : :
1002 : : static int
1003 : 359150 : type___subclasscheck___impl(PyTypeObject *self, PyObject *subclass)
1004 : : /*[clinic end generated code: output=97a4e51694500941 input=071b2ca9e03355f4]*/
1005 : : {
1006 : 359150 : return _PyObject_RealIsSubclass(subclass, (PyObject *)self);
1007 : : }
1008 : :
1009 : :
1010 : : static PyGetSetDef type_getsets[] = {
1011 : : {"__name__", (getter)type_name, (setter)type_set_name, NULL},
1012 : : {"__qualname__", (getter)type_qualname, (setter)type_set_qualname, NULL},
1013 : : {"__bases__", (getter)type_get_bases, (setter)type_set_bases, NULL},
1014 : : {"__module__", (getter)type_module, (setter)type_set_module, NULL},
1015 : : {"__abstractmethods__", (getter)type_abstractmethods,
1016 : : (setter)type_set_abstractmethods, NULL},
1017 : : {"__dict__", (getter)type_dict, NULL, NULL},
1018 : : {"__doc__", (getter)type_get_doc, (setter)type_set_doc, NULL},
1019 : : {"__text_signature__", (getter)type_get_text_signature, NULL, NULL},
1020 : : {"__annotations__", (getter)type_get_annotations, (setter)type_set_annotations, NULL},
1021 : : {0}
1022 : : };
1023 : :
1024 : : static PyObject *
1025 : 335334 : type_repr(PyTypeObject *type)
1026 : : {
1027 [ - + ]: 335334 : if (type->tp_name == NULL) {
1028 : : // type_repr() called before the type is fully initialized
1029 : : // by PyType_Ready().
1030 : 0 : return PyUnicode_FromFormat("<class at %p>", type);
1031 : : }
1032 : :
1033 : : PyObject *mod, *name, *rtn;
1034 : :
1035 : 335334 : mod = type_module(type, NULL);
1036 [ - + ]: 335334 : if (mod == NULL)
1037 : 0 : PyErr_Clear();
1038 [ - + ]: 335334 : else if (!PyUnicode_Check(mod)) {
1039 : 0 : Py_DECREF(mod);
1040 : 0 : mod = NULL;
1041 : : }
1042 : 335334 : name = type_qualname(type, NULL);
1043 [ - + ]: 335334 : if (name == NULL) {
1044 : 0 : Py_XDECREF(mod);
1045 : 0 : return NULL;
1046 : : }
1047 : :
1048 [ + - + + ]: 335334 : if (mod != NULL && !_PyUnicode_Equal(mod, &_Py_ID(builtins)))
1049 : 333893 : rtn = PyUnicode_FromFormat("<class '%U.%U'>", mod, name);
1050 : : else
1051 : 1441 : rtn = PyUnicode_FromFormat("<class '%s'>", type->tp_name);
1052 : :
1053 : 335334 : Py_XDECREF(mod);
1054 : 335334 : Py_DECREF(name);
1055 : 335334 : return rtn;
1056 : : }
1057 : :
1058 : : static PyObject *
1059 : 43766973 : type_call(PyTypeObject *type, PyObject *args, PyObject *kwds)
1060 : : {
1061 : : PyObject *obj;
1062 : 43766973 : PyThreadState *tstate = _PyThreadState_GET();
1063 : :
1064 : : #ifdef Py_DEBUG
1065 : : /* type_call() must not be called with an exception set,
1066 : : because it can clear it (directly or indirectly) and so the
1067 : : caller loses its exception */
1068 : : assert(!_PyErr_Occurred(tstate));
1069 : : #endif
1070 : :
1071 : : /* Special case: type(x) should return Py_TYPE(x) */
1072 : : /* We only want type itself to accept the one-argument form (#27157) */
1073 [ + + ]: 43766973 : if (type == &PyType_Type) {
1074 : : assert(args != NULL && PyTuple_Check(args));
1075 : : assert(kwds == NULL || PyDict_Check(kwds));
1076 : 995246 : Py_ssize_t nargs = PyTuple_GET_SIZE(args);
1077 : :
1078 [ - + - - : 995246 : if (nargs == 1 && (kwds == NULL || !PyDict_GET_SIZE(kwds))) {
- - ]
1079 : 0 : obj = (PyObject *) Py_TYPE(PyTuple_GET_ITEM(args, 0));
1080 : 0 : Py_INCREF(obj);
1081 : 0 : return obj;
1082 : : }
1083 : :
1084 : : /* SF bug 475327 -- if that didn't trigger, we need 3
1085 : : arguments. But PyArg_ParseTuple in type_new may give
1086 : : a msg saying type() needs exactly 3. */
1087 [ + + ]: 995246 : if (nargs != 3) {
1088 : 8 : PyErr_SetString(PyExc_TypeError,
1089 : : "type() takes 1 or 3 arguments");
1090 : 8 : return NULL;
1091 : : }
1092 : : }
1093 : :
1094 [ + + ]: 43766965 : if (type->tp_new == NULL) {
1095 : 54 : _PyErr_Format(tstate, PyExc_TypeError,
1096 : : "cannot create '%s' instances", type->tp_name);
1097 : 54 : return NULL;
1098 : : }
1099 : :
1100 : 43766911 : obj = type->tp_new(type, args, kwds);
1101 : 43766911 : obj = _Py_CheckFunctionResult(tstate, (PyObject*)type, obj, NULL);
1102 [ + + ]: 43766911 : if (obj == NULL)
1103 : 62824 : return NULL;
1104 : :
1105 : : /* If the returned object is not an instance of type,
1106 : : it won't be initialized. */
1107 [ + + ]: 43704087 : if (!PyObject_TypeCheck(obj, type))
1108 : 803 : return obj;
1109 : :
1110 : 43703284 : type = Py_TYPE(obj);
1111 [ + + ]: 43703284 : if (type->tp_init != NULL) {
1112 : 43703283 : int res = type->tp_init(obj, args, kwds);
1113 [ + + ]: 43703274 : if (res < 0) {
1114 : : assert(_PyErr_Occurred(tstate));
1115 : 78765 : Py_DECREF(obj);
1116 : 78765 : obj = NULL;
1117 : : }
1118 : : else {
1119 : : assert(!_PyErr_Occurred(tstate));
1120 : : }
1121 : : }
1122 : 43703275 : return obj;
1123 : : }
1124 : :
1125 : : PyObject *
1126 : 74028134 : _PyType_AllocNoTrack(PyTypeObject *type, Py_ssize_t nitems)
1127 : : {
1128 : : PyObject *obj;
1129 : 74028134 : const size_t size = _PyObject_VAR_SIZE(type, nitems+1);
1130 : : /* note that we need to add one, for the sentinel */
1131 : :
1132 : 74028134 : const size_t presize = _PyType_PreHeaderSize(type);
1133 : 74028134 : char *alloc = PyObject_Malloc(size + presize);
1134 [ + + ]: 74028134 : if (alloc == NULL) {
1135 : : return PyErr_NoMemory();
1136 : : }
1137 : 74028076 : obj = (PyObject *)(alloc + presize);
1138 [ + + ]: 74028076 : if (presize) {
1139 : 72804774 : ((PyObject **)alloc)[0] = NULL;
1140 : 72804774 : ((PyObject **)alloc)[1] = NULL;
1141 : 72804774 : _PyObject_GC_Link(obj);
1142 : : }
1143 : 74028076 : memset(obj, '\0', size);
1144 : :
1145 [ + + ]: 74028076 : if (type->tp_itemsize == 0) {
1146 : 64457804 : _PyObject_Init(obj, type);
1147 : : }
1148 : : else {
1149 : 9570272 : _PyObject_InitVar((PyVarObject *)obj, type, nitems);
1150 : : }
1151 : 74028076 : return obj;
1152 : : }
1153 : :
1154 : : PyObject *
1155 : 73441102 : PyType_GenericAlloc(PyTypeObject *type, Py_ssize_t nitems)
1156 : : {
1157 : 73441102 : PyObject *obj = _PyType_AllocNoTrack(type, nitems);
1158 [ + + ]: 73441102 : if (obj == NULL) {
1159 : 58 : return NULL;
1160 : : }
1161 : :
1162 [ + + ]: 73441044 : if (_PyType_IS_GC(type)) {
1163 : 72217742 : _PyObject_GC_TRACK(obj);
1164 : : }
1165 : 73441044 : return obj;
1166 : : }
1167 : :
1168 : : PyObject *
1169 : 11329065 : PyType_GenericNew(PyTypeObject *type, PyObject *args, PyObject *kwds)
1170 : : {
1171 : 11329065 : return type->tp_alloc(type, 0);
1172 : : }
1173 : :
1174 : : /* Helpers for subtyping */
1175 : :
1176 : : static int
1177 : 5371978 : traverse_slots(PyTypeObject *type, PyObject *self, visitproc visit, void *arg)
1178 : : {
1179 : : Py_ssize_t i, n;
1180 : : PyMemberDef *mp;
1181 : :
1182 : 5371978 : n = Py_SIZE(type);
1183 : 5371978 : mp = _PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
1184 [ + + ]: 16969864 : for (i = 0; i < n; i++, mp++) {
1185 [ + - ]: 11597886 : if (mp->type == T_OBJECT_EX) {
1186 : 11597886 : char *addr = (char *)self + mp->offset;
1187 : 11597886 : PyObject *obj = *(PyObject **)addr;
1188 [ + + ]: 11597886 : if (obj != NULL) {
1189 : 10908656 : int err = visit(obj, arg);
1190 [ - + ]: 10908656 : if (err)
1191 : 0 : return err;
1192 : : }
1193 : : }
1194 : : }
1195 : 5371978 : return 0;
1196 : : }
1197 : :
1198 : : static int
1199 : 158587222 : subtype_traverse(PyObject *self, visitproc visit, void *arg)
1200 : : {
1201 : : PyTypeObject *type, *base;
1202 : : traverseproc basetraverse;
1203 : :
1204 : : /* Find the nearest base with a different tp_traverse,
1205 : : and traverse slots while we're at it */
1206 : 158587222 : type = Py_TYPE(self);
1207 : 158587222 : base = type;
1208 [ + + ]: 396494850 : while ((basetraverse = base->tp_traverse) == subtype_traverse) {
1209 [ + + ]: 237907628 : if (Py_SIZE(base)) {
1210 : 5371978 : int err = traverse_slots(base, self, visit, arg);
1211 [ - + ]: 5371978 : if (err)
1212 : 0 : return err;
1213 : : }
1214 : 237907628 : base = base->tp_base;
1215 : : assert(base);
1216 : : }
1217 : :
1218 [ + + ]: 158587222 : if (type->tp_flags & Py_TPFLAGS_MANAGED_DICT) {
1219 : : assert(type->tp_dictoffset);
1220 : 103876107 : int err = _PyObject_VisitInstanceAttributes(self, visit, arg);
1221 [ + + ]: 103876107 : if (err) {
1222 : 1 : return err;
1223 : : }
1224 : : }
1225 : :
1226 [ + + ]: 158587221 : if (type->tp_dictoffset != base->tp_dictoffset) {
1227 : 126843556 : PyObject **dictptr = _PyObject_DictPointer(self);
1228 [ + - + + ]: 126843556 : if (dictptr && *dictptr)
1229 [ + - - + ]: 59565367 : Py_VISIT(*dictptr);
1230 : : }
1231 : :
1232 [ + - ]: 158587221 : if (type->tp_flags & Py_TPFLAGS_HEAPTYPE
1233 [ + + + + ]: 158587221 : && (!basetraverse || !(base->tp_flags & Py_TPFLAGS_HEAPTYPE))) {
1234 : : /* For a heaptype, the instances count as references
1235 : : to the type. Traverse the type so the collector
1236 : : can find cycles involving this link.
1237 : : Skip this visit if basetraverse belongs to a heap type: in that
1238 : : case, basetraverse will visit the type when we call it later.
1239 : : */
1240 [ + - - + ]: 138799351 : Py_VISIT(type);
1241 : : }
1242 : :
1243 [ + + ]: 158587221 : if (basetraverse)
1244 : 89006276 : return basetraverse(self, visit, arg);
1245 : 69580945 : return 0;
1246 : : }
1247 : :
1248 : : static void
1249 : 2480824 : clear_slots(PyTypeObject *type, PyObject *self)
1250 : : {
1251 : : Py_ssize_t i, n;
1252 : : PyMemberDef *mp;
1253 : :
1254 : 2480824 : n = Py_SIZE(type);
1255 : 2480824 : mp = _PyHeapType_GET_MEMBERS((PyHeapTypeObject *)type);
1256 [ + + ]: 10719179 : for (i = 0; i < n; i++, mp++) {
1257 [ + - + - ]: 8238355 : if (mp->type == T_OBJECT_EX && !(mp->flags & READONLY)) {
1258 : 8238355 : char *addr = (char *)self + mp->offset;
1259 : 8238355 : PyObject *obj = *(PyObject **)addr;
1260 [ + + ]: 8238355 : if (obj != NULL) {
1261 : 7726454 : *(PyObject **)addr = NULL;
1262 : 7726454 : Py_DECREF(obj);
1263 : : }
1264 : : }
1265 : : }
1266 : 2480824 : }
1267 : :
1268 : : static int
1269 : 1226869 : subtype_clear(PyObject *self)
1270 : : {
1271 : : PyTypeObject *type, *base;
1272 : : inquiry baseclear;
1273 : :
1274 : : /* Find the nearest base with a different tp_clear
1275 : : and clear slots while we're at it */
1276 : 1226869 : type = Py_TYPE(self);
1277 : 1226869 : base = type;
1278 [ + + ]: 2904319 : while ((baseclear = base->tp_clear) == subtype_clear) {
1279 [ + + ]: 1677450 : if (Py_SIZE(base))
1280 : 6944 : clear_slots(base, self);
1281 : 1677450 : base = base->tp_base;
1282 : : assert(base);
1283 : : }
1284 : :
1285 : : /* Clear the instance dict (if any), to break cycles involving only
1286 : : __dict__ slots (as in the case 'self.__dict__ is self'). */
1287 [ + + ]: 1226869 : if (type->tp_flags & Py_TPFLAGS_MANAGED_DICT) {
1288 : 919500 : _PyObject_ClearInstanceAttributes(self);
1289 : : }
1290 [ + + ]: 1226869 : if (type->tp_dictoffset != base->tp_dictoffset) {
1291 : 992885 : PyObject **dictptr = _PyObject_DictPointer(self);
1292 [ + - + + ]: 992885 : if (dictptr && *dictptr)
1293 [ + - ]: 183405 : Py_CLEAR(*dictptr);
1294 : : }
1295 : :
1296 [ + + ]: 1226869 : if (baseclear)
1297 : 231311 : return baseclear(self);
1298 : 995558 : return 0;
1299 : : }
1300 : :
1301 : : static void
1302 : 29392660 : subtype_dealloc(PyObject *self)
1303 : : {
1304 : : PyTypeObject *type, *base;
1305 : : destructor basedealloc;
1306 : : int has_finalizer;
1307 : :
1308 : : /* Extract the type; we expect it to be a heap type */
1309 : 29392660 : type = Py_TYPE(self);
1310 : : _PyObject_ASSERT((PyObject *)type, type->tp_flags & Py_TPFLAGS_HEAPTYPE);
1311 : :
1312 : : /* Test whether the type has GC exactly once */
1313 : :
1314 [ + + ]: 29392660 : if (!_PyType_IS_GC(type)) {
1315 : : /* A non GC dynamic type allows certain simplifications:
1316 : : there's no need to call clear_slots(), or DECREF the dict,
1317 : : or clear weakrefs. */
1318 : :
1319 : : /* Maybe call finalizer; exit early if resurrected */
1320 [ + + ]: 2127 : if (type->tp_finalize) {
1321 [ + + ]: 5 : if (PyObject_CallFinalizerFromDealloc(self) < 0)
1322 : 2 : return;
1323 : : }
1324 [ - + ]: 2125 : if (type->tp_del) {
1325 : 0 : type->tp_del(self);
1326 [ # # ]: 0 : if (Py_REFCNT(self) > 0) {
1327 : 0 : return;
1328 : : }
1329 : : }
1330 : :
1331 : : /* Find the nearest base with a different tp_dealloc */
1332 : 2125 : base = type;
1333 [ + + ]: 4253 : while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
1334 : 2128 : base = base->tp_base;
1335 : : assert(base);
1336 : : }
1337 : :
1338 : : /* Extract the type again; tp_del may have changed it */
1339 : 2125 : type = Py_TYPE(self);
1340 : :
1341 : : // Don't read type memory after calling basedealloc() since basedealloc()
1342 : : // can deallocate the type and free its memory.
1343 : 4250 : int type_needs_decref = (type->tp_flags & Py_TPFLAGS_HEAPTYPE
1344 [ + - + + ]: 2125 : && !(base->tp_flags & Py_TPFLAGS_HEAPTYPE));
1345 : :
1346 : : assert((type->tp_flags & Py_TPFLAGS_MANAGED_DICT) == 0);
1347 : :
1348 : : /* Call the base tp_dealloc() */
1349 : : assert(basedealloc);
1350 : 2125 : basedealloc(self);
1351 : :
1352 : : /* Can't reference self beyond this point. It's possible tp_del switched
1353 : : our type from a HEAPTYPE to a non-HEAPTYPE, so be careful about
1354 : : reference counting. Only decref if the base type is not already a heap
1355 : : allocated type. Otherwise, basedealloc should have decref'd it already */
1356 [ + + ]: 2125 : if (type_needs_decref) {
1357 : 25 : Py_DECREF(type);
1358 : : }
1359 : :
1360 : : /* Done */
1361 : 2125 : return;
1362 : : }
1363 : :
1364 : : /* We get here only if the type has GC */
1365 : :
1366 : : /* UnTrack and re-Track around the trashcan macro, alas */
1367 : : /* See explanation at end of function for full disclosure */
1368 : 29390533 : PyObject_GC_UnTrack(self);
1369 [ + - + + ]: 29390533 : Py_TRASHCAN_BEGIN(self, subtype_dealloc);
1370 : :
1371 : : /* Find the nearest base with a different tp_dealloc */
1372 : 29302581 : base = type;
1373 [ + + ]: 79730636 : while ((/*basedealloc =*/ base->tp_dealloc) == subtype_dealloc) {
1374 : 50428055 : base = base->tp_base;
1375 : : assert(base);
1376 : : }
1377 : :
1378 [ + + + + ]: 29302581 : has_finalizer = type->tp_finalize || type->tp_del;
1379 : :
1380 [ + + ]: 29302581 : if (type->tp_finalize) {
1381 : 4462682 : _PyObject_GC_TRACK(self);
1382 [ + + ]: 4462682 : if (PyObject_CallFinalizerFromDealloc(self) < 0) {
1383 : : /* Resurrected */
1384 : 41 : goto endlabel;
1385 : : }
1386 : 4462641 : _PyObject_GC_UNTRACK(self);
1387 : : }
1388 : : /*
1389 : : If we added a weaklist, we clear it. Do this *before* calling tp_del,
1390 : : clearing slots, or clearing the instance dict.
1391 : :
1392 : : GC tracking must be off at this point. weakref callbacks (if any, and
1393 : : whether directly here or indirectly in something we call) may trigger GC,
1394 : : and if self is tracked at that point, it will look like trash to GC and GC
1395 : : will try to delete self again.
1396 : : */
1397 [ + + + + ]: 29302540 : if (type->tp_weaklistoffset && !base->tp_weaklistoffset) {
1398 : 18640749 : PyObject_ClearWeakRefs(self);
1399 : : }
1400 : :
1401 [ + + ]: 29302540 : if (type->tp_del) {
1402 : 11 : _PyObject_GC_TRACK(self);
1403 : 11 : type->tp_del(self);
1404 [ + + ]: 11 : if (Py_REFCNT(self) > 0) {
1405 : : /* Resurrected */
1406 : 2 : goto endlabel;
1407 : : }
1408 : 9 : _PyObject_GC_UNTRACK(self);
1409 : : }
1410 [ + + ]: 29302538 : if (has_finalizer) {
1411 : : /* New weakrefs could be created during the finalizer call.
1412 : : If this occurs, clear them out without calling their
1413 : : finalizers since they might rely on part of the object
1414 : : being finalized that has already been destroyed. */
1415 [ + + + + ]: 4462645 : if (type->tp_weaklistoffset && !base->tp_weaklistoffset) {
1416 : : /* Modeled after GET_WEAKREFS_LISTPTR() */
1417 : : PyWeakReference **list = (PyWeakReference **) \
1418 : 4403401 : _PyObject_GET_WEAKREFS_LISTPTR(self);
1419 [ - + ]: 4403401 : while (*list)
1420 : 0 : _PyWeakref_ClearRef(*list);
1421 : : }
1422 : : }
1423 : :
1424 : : /* Clear slots up to the nearest base with a different tp_dealloc */
1425 : 29302538 : base = type;
1426 [ + + ]: 79730518 : while ((basedealloc = base->tp_dealloc) == subtype_dealloc) {
1427 [ + + ]: 50427980 : if (Py_SIZE(base))
1428 : 2473880 : clear_slots(base, self);
1429 : 50427980 : base = base->tp_base;
1430 : : assert(base);
1431 : : }
1432 : :
1433 : : /* If we added a dict, DECREF it, or free inline values. */
1434 [ + + ]: 29302538 : if (type->tp_flags & Py_TPFLAGS_MANAGED_DICT) {
1435 : 13319170 : PyObject **dictptr = _PyObject_ManagedDictPointer(self);
1436 [ + + ]: 13319170 : if (*dictptr != NULL) {
1437 : : assert(*_PyObject_ValuesPointer(self) == NULL);
1438 : 4439978 : Py_DECREF(*dictptr);
1439 : 4439978 : *dictptr = NULL;
1440 : : }
1441 : : else {
1442 : 8879192 : _PyObject_FreeInstanceAttributes(self);
1443 : : }
1444 : : }
1445 [ + + + + ]: 15983368 : else if (type->tp_dictoffset && !base->tp_dictoffset) {
1446 : 7947596 : PyObject **dictptr = _PyObject_DictPointer(self);
1447 [ + - ]: 7947596 : if (dictptr != NULL) {
1448 : 7947596 : PyObject *dict = *dictptr;
1449 [ + + ]: 7947596 : if (dict != NULL) {
1450 : 363428 : Py_DECREF(dict);
1451 : 363428 : *dictptr = NULL;
1452 : : }
1453 : : }
1454 : : }
1455 : :
1456 : : /* Extract the type again; tp_del may have changed it */
1457 : 29302538 : type = Py_TYPE(self);
1458 : :
1459 : : /* Call the base tp_dealloc(); first retrack self if
1460 : : * basedealloc knows about gc.
1461 : : */
1462 [ + + ]: 29302538 : if (_PyType_IS_GC(base)) {
1463 : 18137501 : _PyObject_GC_TRACK(self);
1464 : : }
1465 : :
1466 : : // Don't read type memory after calling basedealloc() since basedealloc()
1467 : : // can deallocate the type and free its memory.
1468 : 58605076 : int type_needs_decref = (type->tp_flags & Py_TPFLAGS_HEAPTYPE
1469 [ + - + + ]: 29302538 : && !(base->tp_flags & Py_TPFLAGS_HEAPTYPE));
1470 : :
1471 : : assert(basedealloc);
1472 : 29302538 : basedealloc(self);
1473 : :
1474 : : /* Can't reference self beyond this point. It's possible tp_del switched
1475 : : our type from a HEAPTYPE to a non-HEAPTYPE, so be careful about
1476 : : reference counting. Only decref if the base type is not already a heap
1477 : : allocated type. Otherwise, basedealloc should have decref'd it already */
1478 [ + + ]: 29302538 : if (type_needs_decref) {
1479 : 24416720 : Py_DECREF(type);
1480 : : }
1481 : :
1482 : 4885818 : endlabel:
1483 [ + - ]: 29302581 : Py_TRASHCAN_END
1484 : :
1485 : : /* Explanation of the weirdness around the trashcan macros:
1486 : :
1487 : : Q. What do the trashcan macros do?
1488 : :
1489 : : A. Read the comment titled "Trashcan mechanism" in object.h.
1490 : : For one, this explains why there must be a call to GC-untrack
1491 : : before the trashcan begin macro. Without understanding the
1492 : : trashcan code, the answers to the following questions don't make
1493 : : sense.
1494 : :
1495 : : Q. Why do we GC-untrack before the trashcan and then immediately
1496 : : GC-track again afterward?
1497 : :
1498 : : A. In the case that the base class is GC-aware, the base class
1499 : : probably GC-untracks the object. If it does that using the
1500 : : UNTRACK macro, this will crash when the object is already
1501 : : untracked. Because we don't know what the base class does, the
1502 : : only safe thing is to make sure the object is tracked when we
1503 : : call the base class dealloc. But... The trashcan begin macro
1504 : : requires that the object is *untracked* before it is called. So
1505 : : the dance becomes:
1506 : :
1507 : : GC untrack
1508 : : trashcan begin
1509 : : GC track
1510 : :
1511 : : Q. Why did the last question say "immediately GC-track again"?
1512 : : It's nowhere near immediately.
1513 : :
1514 : : A. Because the code *used* to re-track immediately. Bad Idea.
1515 : : self has a refcount of 0, and if gc ever gets its hands on it
1516 : : (which can happen if any weakref callback gets invoked), it
1517 : : looks like trash to gc too, and gc also tries to delete self
1518 : : then. But we're already deleting self. Double deallocation is
1519 : : a subtle disaster.
1520 : : */
1521 : : }
1522 : :
1523 : : static PyTypeObject *solid_base(PyTypeObject *type);
1524 : :
1525 : : /* type test with subclassing support */
1526 : :
1527 : : static int
1528 : 280077 : type_is_subtype_base_chain(PyTypeObject *a, PyTypeObject *b)
1529 : : {
1530 : : do {
1531 [ + + ]: 919480 : if (a == b)
1532 : 279370 : return 1;
1533 : 640110 : a = a->tp_base;
1534 [ + + ]: 640110 : } while (a != NULL);
1535 : :
1536 : 707 : return (b == &PyBaseObject_Type);
1537 : : }
1538 : :
1539 : : int
1540 : 219523507 : PyType_IsSubtype(PyTypeObject *a, PyTypeObject *b)
1541 : : {
1542 : : PyObject *mro;
1543 : :
1544 : 219523507 : mro = a->tp_mro;
1545 [ + + ]: 219523507 : if (mro != NULL) {
1546 : : /* Deal with multiple inheritance without recursion
1547 : : by walking the MRO tuple */
1548 : : Py_ssize_t i, n;
1549 : : assert(PyTuple_Check(mro));
1550 : 219244135 : n = PyTuple_GET_SIZE(mro);
1551 [ + + ]: 605170641 : for (i = 0; i < n; i++) {
1552 [ + + ]: 511305822 : if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b)
1553 : 125379316 : return 1;
1554 : : }
1555 : 93864819 : return 0;
1556 : : }
1557 : : else
1558 : : /* a is not completely initialized yet; follow tp_base */
1559 : 279372 : return type_is_subtype_base_chain(a, b);
1560 : : }
1561 : :
1562 : : /* Routines to do a method lookup in the type without looking in the
1563 : : instance dictionary (so we can't use PyObject_GetAttr) but still
1564 : : binding it to the instance.
1565 : :
1566 : : Variants:
1567 : :
1568 : : - _PyObject_LookupSpecial() returns NULL without raising an exception
1569 : : when the _PyType_Lookup() call fails;
1570 : :
1571 : : - lookup_maybe_method() and lookup_method() are internal routines similar
1572 : : to _PyObject_LookupSpecial(), but can return unbound PyFunction
1573 : : to avoid temporary method object. Pass self as first argument when
1574 : : unbound == 1.
1575 : : */
1576 : :
1577 : : PyObject *
1578 : 29075091 : _PyObject_LookupSpecial(PyObject *self, PyObject *attr)
1579 : : {
1580 : : PyObject *res;
1581 : :
1582 : 29075091 : res = _PyType_Lookup(Py_TYPE(self), attr);
1583 [ + + ]: 29075091 : if (res != NULL) {
1584 : : descrgetfunc f;
1585 [ + + ]: 16472723 : if ((f = Py_TYPE(res)->tp_descr_get) == NULL)
1586 : 29 : Py_INCREF(res);
1587 : : else
1588 : 16472694 : res = f(res, self, (PyObject *)(Py_TYPE(self)));
1589 : : }
1590 : 29075091 : return res;
1591 : : }
1592 : :
1593 : : PyObject *
1594 : 11 : _PyObject_LookupSpecialId(PyObject *self, _Py_Identifier *attrid)
1595 : : {
1596 : 11 : PyObject *attr = _PyUnicode_FromId(attrid); /* borrowed */
1597 [ - + ]: 11 : if (attr == NULL)
1598 : 0 : return NULL;
1599 : 11 : return _PyObject_LookupSpecial(self, attr);
1600 : : }
1601 : :
1602 : : static PyObject *
1603 : 38326246 : lookup_maybe_method(PyObject *self, PyObject *attr, int *unbound)
1604 : : {
1605 : 38326246 : PyObject *res = _PyType_Lookup(Py_TYPE(self), attr);
1606 [ + + ]: 38326246 : if (res == NULL) {
1607 : 33 : return NULL;
1608 : : }
1609 : :
1610 [ + + ]: 38326213 : if (_PyType_HasFeature(Py_TYPE(res), Py_TPFLAGS_METHOD_DESCRIPTOR)) {
1611 : : /* Avoid temporary PyMethodObject */
1612 : 38323529 : *unbound = 1;
1613 : 38323529 : Py_INCREF(res);
1614 : : }
1615 : : else {
1616 : 2684 : *unbound = 0;
1617 : 2684 : descrgetfunc f = Py_TYPE(res)->tp_descr_get;
1618 [ + + ]: 2684 : if (f == NULL) {
1619 : 2397 : Py_INCREF(res);
1620 : : }
1621 : : else {
1622 : 287 : res = f(res, self, (PyObject *)(Py_TYPE(self)));
1623 : : }
1624 : : }
1625 : 38326213 : return res;
1626 : : }
1627 : :
1628 : : static PyObject *
1629 : 20393799 : lookup_method(PyObject *self, PyObject *attr, int *unbound)
1630 : : {
1631 : 20393799 : PyObject *res = lookup_maybe_method(self, attr, unbound);
1632 [ + + - + ]: 20393799 : if (res == NULL && !PyErr_Occurred()) {
1633 : 0 : PyErr_SetObject(PyExc_AttributeError, attr);
1634 : : }
1635 : 20393799 : return res;
1636 : : }
1637 : :
1638 : :
1639 : : static inline PyObject*
1640 : 17845660 : vectorcall_unbound(PyThreadState *tstate, int unbound, PyObject *func,
1641 : : PyObject *const *args, Py_ssize_t nargs)
1642 : : {
1643 : 17845660 : size_t nargsf = nargs;
1644 [ + + ]: 17845660 : if (!unbound) {
1645 : : /* Skip self argument, freeing up args[0] to use for
1646 : : * PY_VECTORCALL_ARGUMENTS_OFFSET */
1647 : 518 : args++;
1648 : 518 : nargsf = nargsf - 1 + PY_VECTORCALL_ARGUMENTS_OFFSET;
1649 : : }
1650 : : EVAL_CALL_STAT_INC_IF_FUNCTION(EVAL_CALL_SLOT, func);
1651 : 17845660 : return _PyObject_VectorcallTstate(tstate, func, args, nargsf, NULL);
1652 : : }
1653 : :
1654 : : static PyObject*
1655 : 6341029 : call_unbound_noarg(int unbound, PyObject *func, PyObject *self)
1656 : : {
1657 [ + + ]: 6341029 : if (unbound) {
1658 : 6340865 : return PyObject_CallOneArg(func, self);
1659 : : }
1660 : : else {
1661 : 164 : return _PyObject_CallNoArgs(func);
1662 : : }
1663 : : }
1664 : :
1665 : : /* A variation of PyObject_CallMethod* that uses lookup_method()
1666 : : instead of PyObject_GetAttrString().
1667 : :
1668 : : args is an argument vector of length nargs. The first element in this
1669 : : vector is the special object "self" which is used for the method lookup */
1670 : : static PyObject *
1671 : 6975506 : vectorcall_method(PyObject *name, PyObject *const *args, Py_ssize_t nargs)
1672 : : {
1673 : : assert(nargs >= 1);
1674 : :
1675 : 6975506 : PyThreadState *tstate = _PyThreadState_GET();
1676 : : int unbound;
1677 : 6975506 : PyObject *self = args[0];
1678 : 6975506 : PyObject *func = lookup_method(self, name, &unbound);
1679 [ + + ]: 6975506 : if (func == NULL) {
1680 : 1 : return NULL;
1681 : : }
1682 : 6975505 : PyObject *retval = vectorcall_unbound(tstate, unbound, func, args, nargs);
1683 : 6975505 : Py_DECREF(func);
1684 : 6975505 : return retval;
1685 : : }
1686 : :
1687 : : /* Clone of vectorcall_method() that returns NotImplemented
1688 : : * when the lookup fails. */
1689 : : static PyObject *
1690 : 588643 : vectorcall_maybe(PyThreadState *tstate, PyObject *name,
1691 : : PyObject *const *args, Py_ssize_t nargs)
1692 : : {
1693 : : assert(nargs >= 1);
1694 : :
1695 : : int unbound;
1696 : 588643 : PyObject *self = args[0];
1697 : 588643 : PyObject *func = lookup_maybe_method(self, name, &unbound);
1698 [ + + ]: 588643 : if (func == NULL) {
1699 [ + - ]: 33 : if (!PyErr_Occurred())
1700 : 33 : Py_RETURN_NOTIMPLEMENTED;
1701 : 0 : return NULL;
1702 : : }
1703 : 588610 : PyObject *retval = vectorcall_unbound(tstate, unbound, func, args, nargs);
1704 : 588610 : Py_DECREF(func);
1705 : 588610 : return retval;
1706 : : }
1707 : :
1708 : : /*
1709 : : Method resolution order algorithm C3 described in
1710 : : "A Monotonic Superclass Linearization for Dylan",
1711 : : by Kim Barrett, Bob Cassel, Paul Haahr,
1712 : : David A. Moon, Keith Playford, and P. Tucker Withington.
1713 : : (OOPSLA 1996)
1714 : :
1715 : : Some notes about the rules implied by C3:
1716 : :
1717 : : No duplicate bases.
1718 : : It isn't legal to repeat a class in a list of base classes.
1719 : :
1720 : : The next three properties are the 3 constraints in "C3".
1721 : :
1722 : : Local precedence order.
1723 : : If A precedes B in C's MRO, then A will precede B in the MRO of all
1724 : : subclasses of C.
1725 : :
1726 : : Monotonicity.
1727 : : The MRO of a class must be an extension without reordering of the
1728 : : MRO of each of its superclasses.
1729 : :
1730 : : Extended Precedence Graph (EPG).
1731 : : Linearization is consistent if there is a path in the EPG from
1732 : : each class to all its successors in the linearization. See
1733 : : the paper for definition of EPG.
1734 : : */
1735 : :
1736 : : static int
1737 : 2290531 : tail_contains(PyObject *tuple, int whence, PyObject *o)
1738 : : {
1739 : : Py_ssize_t j, size;
1740 : 2290531 : size = PyTuple_GET_SIZE(tuple);
1741 : :
1742 [ + + ]: 3885308 : for (j = whence+1; j < size; j++) {
1743 [ + + ]: 1842303 : if (PyTuple_GET_ITEM(tuple, j) == o)
1744 : 247526 : return 1;
1745 : : }
1746 : 2043005 : return 0;
1747 : : }
1748 : :
1749 : : static PyObject *
1750 : 26 : class_name(PyObject *cls)
1751 : : {
1752 : : PyObject *name;
1753 [ - + ]: 26 : if (_PyObject_LookupAttr(cls, &_Py_ID(__name__), &name) == 0) {
1754 : 0 : name = PyObject_Repr(cls);
1755 : : }
1756 : 26 : return name;
1757 : : }
1758 : :
1759 : : static int
1760 : 116193 : check_duplicates(PyObject *tuple)
1761 : : {
1762 : : Py_ssize_t i, j, n;
1763 : : /* Let's use a quadratic time algorithm,
1764 : : assuming that the bases tuples is short.
1765 : : */
1766 : 116193 : n = PyTuple_GET_SIZE(tuple);
1767 [ + + ]: 369427 : for (i = 0; i < n; i++) {
1768 : 253239 : PyObject *o = PyTuple_GET_ITEM(tuple, i);
1769 [ + + ]: 421903 : for (j = i + 1; j < n; j++) {
1770 [ + + ]: 168669 : if (PyTuple_GET_ITEM(tuple, j) == o) {
1771 : 5 : o = class_name(o);
1772 [ + - ]: 5 : if (o != NULL) {
1773 [ + - ]: 5 : if (PyUnicode_Check(o)) {
1774 : 5 : PyErr_Format(PyExc_TypeError,
1775 : : "duplicate base class %U", o);
1776 : : }
1777 : : else {
1778 : 0 : PyErr_SetString(PyExc_TypeError,
1779 : : "duplicate base class");
1780 : : }
1781 : 5 : Py_DECREF(o);
1782 : : }
1783 : 5 : return -1;
1784 : : }
1785 : : }
1786 : : }
1787 : 116188 : return 0;
1788 : : }
1789 : :
1790 : : /* Raise a TypeError for an MRO order disagreement.
1791 : :
1792 : : It's hard to produce a good error message. In the absence of better
1793 : : insight into error reporting, report the classes that were candidates
1794 : : to be put next into the MRO. There is some conflict between the
1795 : : order in which they should be put in the MRO, but it's hard to
1796 : : diagnose what constraint can't be satisfied.
1797 : : */
1798 : :
1799 : : static void
1800 : 10 : set_mro_error(PyObject **to_merge, Py_ssize_t to_merge_size, int *remain)
1801 : : {
1802 : : Py_ssize_t i, n, off;
1803 : : char buf[1000];
1804 : : PyObject *k, *v;
1805 : 10 : PyObject *set = PyDict_New();
1806 [ - + ]: 10 : if (!set) return;
1807 : :
1808 [ + + ]: 41 : for (i = 0; i < to_merge_size; i++) {
1809 : 31 : PyObject *L = to_merge[i];
1810 [ + + ]: 31 : if (remain[i] < PyTuple_GET_SIZE(L)) {
1811 : 27 : PyObject *c = PyTuple_GET_ITEM(L, remain[i]);
1812 [ - + ]: 27 : if (PyDict_SetItem(set, c, Py_None) < 0) {
1813 : 0 : Py_DECREF(set);
1814 : 0 : return;
1815 : : }
1816 : : }
1817 : : }
1818 : 10 : n = PyDict_GET_SIZE(set);
1819 : :
1820 : 10 : off = PyOS_snprintf(buf, sizeof(buf), "Cannot create a \
1821 : : consistent method resolution\norder (MRO) for bases");
1822 : 10 : i = 0;
1823 [ + + + - ]: 31 : while (PyDict_Next(set, &i, &k, &v) && (size_t)off < sizeof(buf)) {
1824 : 21 : PyObject *name = class_name(k);
1825 : 21 : const char *name_str = NULL;
1826 [ + - ]: 21 : if (name != NULL) {
1827 [ + - ]: 21 : if (PyUnicode_Check(name)) {
1828 : 21 : name_str = PyUnicode_AsUTF8(name);
1829 : : }
1830 : : else {
1831 : 0 : name_str = "?";
1832 : : }
1833 : : }
1834 [ - + ]: 21 : if (name_str == NULL) {
1835 : 0 : Py_XDECREF(name);
1836 : 0 : Py_DECREF(set);
1837 : 0 : return;
1838 : : }
1839 : 21 : off += PyOS_snprintf(buf + off, sizeof(buf) - off, " %s", name_str);
1840 : 21 : Py_XDECREF(name);
1841 [ + + + - ]: 21 : if (--n && (size_t)(off+1) < sizeof(buf)) {
1842 : 11 : buf[off++] = ',';
1843 : 11 : buf[off] = '\0';
1844 : : }
1845 : : }
1846 : 10 : PyErr_SetString(PyExc_TypeError, buf);
1847 : 10 : Py_DECREF(set);
1848 : : }
1849 : :
1850 : : static int
1851 : 116188 : pmerge(PyObject *acc, PyObject **to_merge, Py_ssize_t to_merge_size)
1852 : : {
1853 : 116188 : int res = 0;
1854 : : Py_ssize_t i, j, empty_cnt;
1855 : : int *remain;
1856 : :
1857 : : /* remain stores an index into each sublist of to_merge.
1858 : : remain[i] is the index of the next base in to_merge[i]
1859 : : that is not included in acc.
1860 : : */
1861 [ + - ]: 116188 : remain = PyMem_New(int, to_merge_size);
1862 [ - + ]: 116188 : if (remain == NULL) {
1863 : : PyErr_NoMemory();
1864 : 0 : return -1;
1865 : : }
1866 [ + + ]: 485610 : for (i = 0; i < to_merge_size; i++)
1867 : 369422 : remain[i] = 0;
1868 : :
1869 : 116188 : again:
1870 : 645579 : empty_cnt = 0;
1871 [ + + ]: 1262500 : for (i = 0; i < to_merge_size; i++) {
1872 : : PyObject *candidate;
1873 : :
1874 : 1146312 : PyObject *cur_tuple = to_merge[i];
1875 : :
1876 [ + + ]: 1146312 : if (remain[i] >= PyTuple_GET_SIZE(cur_tuple)) {
1877 : 369395 : empty_cnt++;
1878 : 369395 : continue;
1879 : : }
1880 : :
1881 : : /* Choose next candidate for MRO.
1882 : :
1883 : : The input sequences alone can determine the choice.
1884 : : If not, choose the class which appears in the MRO
1885 : : of the earliest direct superclass of the new class.
1886 : : */
1887 : :
1888 : 776917 : candidate = PyTuple_GET_ITEM(cur_tuple, remain[i]);
1889 [ + + ]: 2819922 : for (j = 0; j < to_merge_size; j++) {
1890 : 2290531 : PyObject *j_lst = to_merge[j];
1891 [ + + ]: 2290531 : if (tail_contains(j_lst, remain[j], candidate))
1892 : 247526 : goto skip; /* continue outer loop */
1893 : : }
1894 : 529391 : res = PyList_Append(acc, candidate);
1895 [ - + ]: 529391 : if (res < 0)
1896 : 0 : goto out;
1897 : :
1898 [ + + ]: 2262117 : for (j = 0; j < to_merge_size; j++) {
1899 : 1732726 : PyObject *j_lst = to_merge[j];
1900 [ + + ]: 1732726 : if (remain[j] < PyTuple_GET_SIZE(j_lst) &&
1901 [ + + ]: 1504029 : PyTuple_GET_ITEM(j_lst, remain[j]) == candidate) {
1902 : 979880 : remain[j]++;
1903 : : }
1904 : : }
1905 : 529391 : goto again;
1906 : 247526 : skip: ;
1907 : : }
1908 : :
1909 [ + + ]: 116188 : if (empty_cnt != to_merge_size) {
1910 : 10 : set_mro_error(to_merge, to_merge_size, remain);
1911 : 10 : res = -1;
1912 : : }
1913 : :
1914 : 116178 : out:
1915 : 116188 : PyMem_Free(remain);
1916 : :
1917 : 116188 : return res;
1918 : : }
1919 : :
1920 : : static PyObject *
1921 : 2006541 : mro_implementation(PyTypeObject *type)
1922 : : {
1923 [ - + ]: 2006541 : if (!_PyType_IsReady(type)) {
1924 [ # # ]: 0 : if (PyType_Ready(type) < 0)
1925 : 0 : return NULL;
1926 : : }
1927 : :
1928 : 2006541 : PyObject *bases = type->tp_bases;
1929 : 2006541 : Py_ssize_t n = PyTuple_GET_SIZE(bases);
1930 [ + + ]: 4150132 : for (Py_ssize_t i = 0; i < n; i++) {
1931 : 2143592 : PyTypeObject *base = _PyType_CAST(PyTuple_GET_ITEM(bases, i));
1932 [ + + ]: 2143592 : if (base->tp_mro == NULL) {
1933 : 1 : PyErr_Format(PyExc_TypeError,
1934 : : "Cannot extend an incomplete type '%.100s'",
1935 : : base->tp_name);
1936 : 1 : return NULL;
1937 : : }
1938 : : assert(PyTuple_Check(base->tp_mro));
1939 : : }
1940 : :
1941 [ + + ]: 2006540 : if (n == 1) {
1942 : : /* Fast path: if there is a single base, constructing the MRO
1943 : : * is trivial.
1944 : : */
1945 : 1890347 : PyTypeObject *base = _PyType_CAST(PyTuple_GET_ITEM(bases, 0));
1946 : 1890347 : Py_ssize_t k = PyTuple_GET_SIZE(base->tp_mro);
1947 : 1890347 : PyObject *result = PyTuple_New(k + 1);
1948 [ - + ]: 1890347 : if (result == NULL) {
1949 : 0 : return NULL;
1950 : : }
1951 : :
1952 : 1890347 : Py_INCREF(type);
1953 : 1890347 : PyTuple_SET_ITEM(result, 0, (PyObject *) type);
1954 [ + + ]: 5993340 : for (Py_ssize_t i = 0; i < k; i++) {
1955 : 4102993 : PyObject *cls = PyTuple_GET_ITEM(base->tp_mro, i);
1956 : 4102993 : Py_INCREF(cls);
1957 : 4102993 : PyTuple_SET_ITEM(result, i + 1, cls);
1958 : : }
1959 : 1890347 : return result;
1960 : : }
1961 : :
1962 : : /* This is just a basic sanity check. */
1963 [ + + ]: 116193 : if (check_duplicates(bases) < 0) {
1964 : 5 : return NULL;
1965 : : }
1966 : :
1967 : : /* Find a superclass linearization that honors the constraints
1968 : : of the explicit tuples of bases and the constraints implied by
1969 : : each base class.
1970 : :
1971 : : to_merge is an array of tuples, where each tuple is a superclass
1972 : : linearization implied by a base class. The last element of
1973 : : to_merge is the declared tuple of bases.
1974 : : */
1975 [ + - ]: 116188 : PyObject **to_merge = PyMem_New(PyObject *, n + 1);
1976 [ - + ]: 116188 : if (to_merge == NULL) {
1977 : : PyErr_NoMemory();
1978 : 0 : return NULL;
1979 : : }
1980 : :
1981 [ + + ]: 369422 : for (Py_ssize_t i = 0; i < n; i++) {
1982 : 253234 : PyTypeObject *base = _PyType_CAST(PyTuple_GET_ITEM(bases, i));
1983 : 253234 : to_merge[i] = base->tp_mro;
1984 : : }
1985 : 116188 : to_merge[n] = bases;
1986 : :
1987 : 116188 : PyObject *result = PyList_New(1);
1988 [ - + ]: 116188 : if (result == NULL) {
1989 : 0 : PyMem_Free(to_merge);
1990 : 0 : return NULL;
1991 : : }
1992 : :
1993 : 116188 : Py_INCREF(type);
1994 : 116188 : PyList_SET_ITEM(result, 0, (PyObject *)type);
1995 [ + + ]: 116188 : if (pmerge(result, to_merge, n + 1) < 0) {
1996 [ + - ]: 10 : Py_CLEAR(result);
1997 : : }
1998 : 116188 : PyMem_Free(to_merge);
1999 : :
2000 : 116188 : return result;
2001 : : }
2002 : :
2003 : : /*[clinic input]
2004 : : type.mro
2005 : :
2006 : : Return a type's method resolution order.
2007 : : [clinic start generated code]*/
2008 : :
2009 : : static PyObject *
2010 : 240962 : type_mro_impl(PyTypeObject *self)
2011 : : /*[clinic end generated code: output=bffc4a39b5b57027 input=28414f4e156db28d]*/
2012 : : {
2013 : : PyObject *seq;
2014 : 240962 : seq = mro_implementation(self);
2015 [ + + + + ]: 240962 : if (seq != NULL && !PyList_Check(seq)) {
2016 : 200368 : Py_SETREF(seq, PySequence_List(seq));
2017 : : }
2018 : 240962 : return seq;
2019 : : }
2020 : :
2021 : : static int
2022 : 240426 : mro_check(PyTypeObject *type, PyObject *mro)
2023 : : {
2024 : : PyTypeObject *solid;
2025 : : Py_ssize_t i, n;
2026 : :
2027 : 240426 : solid = solid_base(type);
2028 : :
2029 : 240426 : n = PyTuple_GET_SIZE(mro);
2030 [ + + ]: 1411649 : for (i = 0; i < n; i++) {
2031 : 1171225 : PyObject *obj = PyTuple_GET_ITEM(mro, i);
2032 [ + + ]: 1171225 : if (!PyType_Check(obj)) {
2033 : 1 : PyErr_Format(
2034 : : PyExc_TypeError,
2035 : : "mro() returned a non-class ('%.500s')",
2036 : 1 : Py_TYPE(obj)->tp_name);
2037 : 1 : return -1;
2038 : : }
2039 : 1171224 : PyTypeObject *base = (PyTypeObject*)obj;
2040 : :
2041 [ + + ]: 1171224 : if (!PyType_IsSubtype(solid, solid_base(base))) {
2042 : 1 : PyErr_Format(
2043 : : PyExc_TypeError,
2044 : : "mro() returned base with unsuitable layout ('%.500s')",
2045 : : base->tp_name);
2046 : 1 : return -1;
2047 : : }
2048 : : }
2049 : :
2050 : 240424 : return 0;
2051 : : }
2052 : :
2053 : : /* Lookups an mcls.mro method, invokes it and checks the result (if needed,
2054 : : in case of a custom mro() implementation).
2055 : :
2056 : : Keep in mind that during execution of this function type->tp_mro
2057 : : can be replaced due to possible reentrance (for example,
2058 : : through type_set_bases):
2059 : :
2060 : : - when looking up the mcls.mro attribute (it could be
2061 : : a user-provided descriptor);
2062 : :
2063 : : - from inside a custom mro() itself;
2064 : :
2065 : : - through a finalizer of the return value of mro().
2066 : : */
2067 : : static PyObject *
2068 : 2006016 : mro_invoke(PyTypeObject *type)
2069 : : {
2070 : : PyObject *mro_result;
2071 : : PyObject *new_mro;
2072 : 2006016 : const int custom = !Py_IS_TYPE(type, &PyType_Type);
2073 : :
2074 [ + + ]: 2006016 : if (custom) {
2075 : : int unbound;
2076 : 240437 : PyObject *mro_meth = lookup_method(
2077 : : (PyObject *)type, &_Py_ID(mro), &unbound);
2078 [ - + ]: 240437 : if (mro_meth == NULL)
2079 : 0 : return NULL;
2080 : 240437 : mro_result = call_unbound_noarg(unbound, mro_meth, (PyObject *)type);
2081 : 240437 : Py_DECREF(mro_meth);
2082 : : }
2083 : : else {
2084 : 1765579 : mro_result = mro_implementation(type);
2085 : : }
2086 [ + + ]: 2006016 : if (mro_result == NULL)
2087 : 20 : return NULL;
2088 : :
2089 : 2005996 : new_mro = PySequence_Tuple(mro_result);
2090 : 2005996 : Py_DECREF(mro_result);
2091 [ + + ]: 2005996 : if (new_mro == NULL) {
2092 : 1 : return NULL;
2093 : : }
2094 : :
2095 [ - + ]: 2005995 : if (PyTuple_GET_SIZE(new_mro) == 0) {
2096 : 0 : Py_DECREF(new_mro);
2097 : 0 : PyErr_Format(PyExc_TypeError, "type MRO must not be empty");
2098 : 0 : return NULL;
2099 : : }
2100 : :
2101 [ + + + + ]: 2005995 : if (custom && mro_check(type, new_mro) < 0) {
2102 : 2 : Py_DECREF(new_mro);
2103 : 2 : return NULL;
2104 : : }
2105 : 2005993 : return new_mro;
2106 : : }
2107 : :
2108 : : /* Calculates and assigns a new MRO to type->tp_mro.
2109 : : Return values and invariants:
2110 : :
2111 : : - Returns 1 if a new MRO value has been set to type->tp_mro due to
2112 : : this call of mro_internal (no tricky reentrancy and no errors).
2113 : :
2114 : : In case if p_old_mro argument is not NULL, a previous value
2115 : : of type->tp_mro is put there, and the ownership of this
2116 : : reference is transferred to a caller.
2117 : : Otherwise, the previous value (if any) is decref'ed.
2118 : :
2119 : : - Returns 0 in case when type->tp_mro gets changed because of
2120 : : reentering here through a custom mro() (see a comment to mro_invoke).
2121 : :
2122 : : In this case, a refcount of an old type->tp_mro is adjusted
2123 : : somewhere deeper in the call stack (by the innermost mro_internal
2124 : : or its caller) and may become zero upon returning from here.
2125 : : This also implies that the whole hierarchy of subclasses of the type
2126 : : has seen the new value and updated their MRO accordingly.
2127 : :
2128 : : - Returns -1 in case of an error.
2129 : : */
2130 : : static int
2131 : 2006016 : mro_internal(PyTypeObject *type, PyObject **p_old_mro)
2132 : : {
2133 : : PyObject *new_mro, *old_mro;
2134 : : int reent;
2135 : :
2136 : : /* Keep a reference to be able to do a reentrancy check below.
2137 : : Don't let old_mro be GC'ed and its address be reused for
2138 : : another object, like (suddenly!) a new tp_mro. */
2139 : 2006016 : old_mro = type->tp_mro;
2140 : 2006016 : Py_XINCREF(old_mro);
2141 : 2006016 : new_mro = mro_invoke(type); /* might cause reentrance */
2142 : 2006016 : reent = (type->tp_mro != old_mro);
2143 : 2006016 : Py_XDECREF(old_mro);
2144 [ + + ]: 2006016 : if (new_mro == NULL) {
2145 : 23 : return -1;
2146 : : }
2147 : :
2148 [ + + ]: 2005993 : if (reent) {
2149 : 15 : Py_DECREF(new_mro);
2150 : 15 : return 0;
2151 : : }
2152 : :
2153 : 2005978 : type->tp_mro = new_mro;
2154 : :
2155 : 2005978 : type_mro_modified(type, type->tp_mro);
2156 : : /* corner case: the super class might have been hidden
2157 : : from the custom MRO */
2158 : 2005978 : type_mro_modified(type, type->tp_bases);
2159 : :
2160 : 2005978 : PyType_Modified(type);
2161 : :
2162 [ + + ]: 2005978 : if (p_old_mro != NULL)
2163 : 699 : *p_old_mro = old_mro; /* transfer the ownership */
2164 : : else
2165 : 2005279 : Py_XDECREF(old_mro);
2166 : :
2167 : 2005978 : return 1;
2168 : : }
2169 : :
2170 : : /* Calculate the best base amongst multiple base classes.
2171 : : This is the first one that's on the path to the "solid base". */
2172 : :
2173 : : static PyTypeObject *
2174 : 1067362 : best_base(PyObject *bases)
2175 : : {
2176 : : Py_ssize_t i, n;
2177 : : PyTypeObject *base, *winner, *candidate;
2178 : :
2179 : : assert(PyTuple_Check(bases));
2180 : 1067362 : n = PyTuple_GET_SIZE(bases);
2181 : : assert(n > 0);
2182 : 1067362 : base = NULL;
2183 : 1067362 : winner = NULL;
2184 [ + + ]: 2274711 : for (i = 0; i < n; i++) {
2185 : 1207369 : PyObject *base_proto = PyTuple_GET_ITEM(bases, i);
2186 [ - + ]: 1207369 : if (!PyType_Check(base_proto)) {
2187 : 0 : PyErr_SetString(
2188 : : PyExc_TypeError,
2189 : : "bases must be types");
2190 : 0 : return NULL;
2191 : : }
2192 : 1207369 : PyTypeObject *base_i = (PyTypeObject *)base_proto;
2193 : :
2194 [ + + ]: 1207369 : if (!_PyType_IsReady(base_i)) {
2195 [ - + ]: 780 : if (PyType_Ready(base_i) < 0)
2196 : 0 : return NULL;
2197 : : }
2198 [ + + ]: 1207369 : if (!_PyType_HasFeature(base_i, Py_TPFLAGS_BASETYPE)) {
2199 : 17 : PyErr_Format(PyExc_TypeError,
2200 : : "type '%.100s' is not an acceptable base type",
2201 : : base_i->tp_name);
2202 : 17 : return NULL;
2203 : : }
2204 : 1207352 : candidate = solid_base(base_i);
2205 [ + + ]: 1207352 : if (winner == NULL) {
2206 : 1067349 : winner = candidate;
2207 : 1067349 : base = base_i;
2208 : : }
2209 [ + + ]: 140003 : else if (PyType_IsSubtype(winner, candidate))
2210 : : ;
2211 [ + + ]: 7589 : else if (PyType_IsSubtype(candidate, winner)) {
2212 : 7586 : winner = candidate;
2213 : 7586 : base = base_i;
2214 : : }
2215 : : else {
2216 : 3 : PyErr_SetString(
2217 : : PyExc_TypeError,
2218 : : "multiple bases have "
2219 : : "instance lay-out conflict");
2220 : 3 : return NULL;
2221 : : }
2222 : : }
2223 : : assert (base != NULL);
2224 : :
2225 : 1067342 : return base;
2226 : : }
2227 : :
2228 : : static int
2229 : 6929630 : extra_ivars(PyTypeObject *type, PyTypeObject *base)
2230 : : {
2231 : 6929630 : size_t t_size = type->tp_basicsize;
2232 : 6929630 : size_t b_size = base->tp_basicsize;
2233 : :
2234 : : assert(t_size >= b_size); /* Else type smaller than base! */
2235 [ + + - + ]: 6929630 : if (type->tp_itemsize || base->tp_itemsize) {
2236 : : /* If itemsize is involved, stricter rules */
2237 [ + + ]: 380256 : return t_size != b_size ||
2238 [ - + ]: 52290 : type->tp_itemsize != base->tp_itemsize;
2239 : : }
2240 [ + + + + ]: 6601664 : if (type->tp_weaklistoffset && base->tp_weaklistoffset == 0 &&
2241 [ + + ]: 1341049 : type->tp_weaklistoffset + sizeof(PyObject *) == t_size &&
2242 [ + + ]: 1333417 : type->tp_flags & Py_TPFLAGS_HEAPTYPE)
2243 : 1191174 : t_size -= sizeof(PyObject *);
2244 : 6601664 : return t_size != b_size;
2245 : : }
2246 : :
2247 : : static PyTypeObject *
2248 : 6929630 : solid_base(PyTypeObject *type)
2249 : : {
2250 : : PyTypeObject *base;
2251 : :
2252 [ + + ]: 6929630 : if (type->tp_base)
2253 : 4310628 : base = solid_base(type->tp_base);
2254 : : else
2255 : 2619002 : base = &PyBaseObject_Type;
2256 [ + + ]: 6929630 : if (extra_ivars(type, base))
2257 : 1135250 : return type;
2258 : : else
2259 : 5794380 : return base;
2260 : : }
2261 : :
2262 : : static void object_dealloc(PyObject *);
2263 : : static PyObject *object_new(PyTypeObject *, PyObject *, PyObject *);
2264 : : static int object_init(PyObject *, PyObject *, PyObject *);
2265 : : static int update_slot(PyTypeObject *, PyObject *);
2266 : : static void fixup_slot_dispatchers(PyTypeObject *);
2267 : : static int type_new_set_names(PyTypeObject *);
2268 : : static int type_new_init_subclass(PyTypeObject *, PyObject *);
2269 : :
2270 : : /*
2271 : : * Helpers for __dict__ descriptor. We don't want to expose the dicts
2272 : : * inherited from various builtin types. The builtin base usually provides
2273 : : * its own __dict__ descriptor, so we use that when we can.
2274 : : */
2275 : : static PyTypeObject *
2276 : 227944 : get_builtin_base_with_dict(PyTypeObject *type)
2277 : : {
2278 [ + + ]: 912070 : while (type->tp_base != NULL) {
2279 [ + + ]: 684138 : if (type->tp_dictoffset != 0 &&
2280 [ + + ]: 653215 : !(type->tp_flags & Py_TPFLAGS_HEAPTYPE))
2281 : 12 : return type;
2282 : 684126 : type = type->tp_base;
2283 : : }
2284 : 227932 : return NULL;
2285 : : }
2286 : :
2287 : : static PyObject *
2288 : 12 : get_dict_descriptor(PyTypeObject *type)
2289 : : {
2290 : : PyObject *descr;
2291 : :
2292 : 12 : descr = _PyType_Lookup(type, &_Py_ID(__dict__));
2293 [ + - - + ]: 12 : if (descr == NULL || !PyDescr_IsData(descr))
2294 : 0 : return NULL;
2295 : :
2296 : 12 : return descr;
2297 : : }
2298 : :
2299 : : static void
2300 : 0 : raise_dict_descr_error(PyObject *obj)
2301 : : {
2302 : 0 : PyErr_Format(PyExc_TypeError,
2303 : : "this __dict__ descriptor does not support "
2304 : 0 : "'%.200s' objects", Py_TYPE(obj)->tp_name);
2305 : 0 : }
2306 : :
2307 : : static PyObject *
2308 : 227320 : subtype_dict(PyObject *obj, void *context)
2309 : : {
2310 : : PyTypeObject *base;
2311 : :
2312 : 227320 : base = get_builtin_base_with_dict(Py_TYPE(obj));
2313 [ + + ]: 227320 : if (base != NULL) {
2314 : : descrgetfunc func;
2315 : 2 : PyObject *descr = get_dict_descriptor(base);
2316 [ - + ]: 2 : if (descr == NULL) {
2317 : 0 : raise_dict_descr_error(obj);
2318 : 0 : return NULL;
2319 : : }
2320 : 2 : func = Py_TYPE(descr)->tp_descr_get;
2321 [ - + ]: 2 : if (func == NULL) {
2322 : 0 : raise_dict_descr_error(obj);
2323 : 0 : return NULL;
2324 : : }
2325 : 2 : return func(descr, obj, (PyObject *)(Py_TYPE(obj)));
2326 : : }
2327 : 227318 : return PyObject_GenericGetDict(obj, context);
2328 : : }
2329 : :
2330 : : static int
2331 : 624 : subtype_setdict(PyObject *obj, PyObject *value, void *context)
2332 : : {
2333 : : PyObject **dictptr;
2334 : : PyTypeObject *base;
2335 : :
2336 : 624 : base = get_builtin_base_with_dict(Py_TYPE(obj));
2337 [ + + ]: 624 : if (base != NULL) {
2338 : : descrsetfunc func;
2339 : 10 : PyObject *descr = get_dict_descriptor(base);
2340 [ - + ]: 10 : if (descr == NULL) {
2341 : 0 : raise_dict_descr_error(obj);
2342 : 0 : return -1;
2343 : : }
2344 : 10 : func = Py_TYPE(descr)->tp_descr_set;
2345 [ - + ]: 10 : if (func == NULL) {
2346 : 0 : raise_dict_descr_error(obj);
2347 : 0 : return -1;
2348 : : }
2349 : 10 : return func(descr, obj, value);
2350 : : }
2351 : : /* Almost like PyObject_GenericSetDict, but allow __dict__ to be deleted. */
2352 : 614 : dictptr = _PyObject_GetDictPtr(obj);
2353 [ - + ]: 614 : if (dictptr == NULL) {
2354 : 0 : PyErr_SetString(PyExc_AttributeError,
2355 : : "This object has no __dict__");
2356 : 0 : return -1;
2357 : : }
2358 [ + + + + ]: 614 : if (value != NULL && !PyDict_Check(value)) {
2359 : 3 : PyErr_Format(PyExc_TypeError,
2360 : : "__dict__ must be set to a dictionary, "
2361 : 3 : "not a '%.200s'", Py_TYPE(value)->tp_name);
2362 : 3 : return -1;
2363 : : }
2364 : 611 : Py_XINCREF(value);
2365 : 611 : Py_XSETREF(*dictptr, value);
2366 : 611 : return 0;
2367 : : }
2368 : :
2369 : : static PyObject *
2370 : 106 : subtype_getweakref(PyObject *obj, void *context)
2371 : : {
2372 : : PyObject **weaklistptr;
2373 : : PyObject *result;
2374 : 106 : PyTypeObject *type = Py_TYPE(obj);
2375 : :
2376 [ - + ]: 106 : if (type->tp_weaklistoffset == 0) {
2377 : 0 : PyErr_SetString(PyExc_AttributeError,
2378 : : "This object has no __weakref__");
2379 : 0 : return NULL;
2380 : : }
2381 : : _PyObject_ASSERT((PyObject *)type,
2382 : : type->tp_weaklistoffset > 0);
2383 : : _PyObject_ASSERT((PyObject *)type,
2384 : : ((type->tp_weaklistoffset + sizeof(PyObject *))
2385 : : <= (size_t)(type->tp_basicsize)));
2386 : 106 : weaklistptr = (PyObject **)((char *)obj + type->tp_weaklistoffset);
2387 [ + - ]: 106 : if (*weaklistptr == NULL)
2388 : 106 : result = Py_None;
2389 : : else
2390 : 0 : result = *weaklistptr;
2391 : 106 : Py_INCREF(result);
2392 : 106 : return result;
2393 : : }
2394 : :
2395 : : /* Three variants on the subtype_getsets list. */
2396 : :
2397 : : static PyGetSetDef subtype_getsets_full[] = {
2398 : : {"__dict__", subtype_dict, subtype_setdict,
2399 : : PyDoc_STR("dictionary for instance variables (if defined)")},
2400 : : {"__weakref__", subtype_getweakref, NULL,
2401 : : PyDoc_STR("list of weak references to the object (if defined)")},
2402 : : {0}
2403 : : };
2404 : :
2405 : : static PyGetSetDef subtype_getsets_dict_only[] = {
2406 : : {"__dict__", subtype_dict, subtype_setdict,
2407 : : PyDoc_STR("dictionary for instance variables (if defined)")},
2408 : : {0}
2409 : : };
2410 : :
2411 : : static PyGetSetDef subtype_getsets_weakref_only[] = {
2412 : : {"__weakref__", subtype_getweakref, NULL,
2413 : : PyDoc_STR("list of weak references to the object (if defined)")},
2414 : : {0}
2415 : : };
2416 : :
2417 : : static int
2418 : 142808 : valid_identifier(PyObject *s)
2419 : : {
2420 [ + + ]: 142808 : if (!PyUnicode_Check(s)) {
2421 : 3 : PyErr_Format(PyExc_TypeError,
2422 : : "__slots__ items must be strings, not '%.200s'",
2423 : 3 : Py_TYPE(s)->tp_name);
2424 : 3 : return 0;
2425 : : }
2426 [ + + ]: 142805 : if (!PyUnicode_IsIdentifier(s)) {
2427 : 8 : PyErr_SetString(PyExc_TypeError,
2428 : : "__slots__ must be identifiers");
2429 : 8 : return 0;
2430 : : }
2431 : 142797 : return 1;
2432 : : }
2433 : :
2434 : : static int
2435 : 1205061 : type_init(PyObject *cls, PyObject *args, PyObject *kwds)
2436 : : {
2437 : : assert(args != NULL && PyTuple_Check(args));
2438 : : assert(kwds == NULL || PyDict_Check(kwds));
2439 : :
2440 [ + + - + : 1205061 : if (kwds != NULL && PyTuple_GET_SIZE(args) == 1 &&
- - ]
2441 : 0 : PyDict_GET_SIZE(kwds) != 0) {
2442 : 0 : PyErr_SetString(PyExc_TypeError,
2443 : : "type.__init__() takes no keyword arguments");
2444 : 0 : return -1;
2445 : : }
2446 : :
2447 [ + - - + ]: 1205061 : if ((PyTuple_GET_SIZE(args) != 1 && PyTuple_GET_SIZE(args) != 3)) {
2448 : 0 : PyErr_SetString(PyExc_TypeError,
2449 : : "type.__init__() takes 1 or 3 arguments");
2450 : 0 : return -1;
2451 : : }
2452 : :
2453 : 1205061 : return 0;
2454 : : }
2455 : :
2456 : :
2457 : : unsigned long
2458 : 8 : PyType_GetFlags(PyTypeObject *type)
2459 : : {
2460 : 8 : return type->tp_flags;
2461 : : }
2462 : :
2463 : :
2464 : : int
2465 : 0 : PyType_SUPPORTS_WEAKREFS(PyTypeObject *type)
2466 : : {
2467 : 0 : return _PyType_SUPPORTS_WEAKREFS(type);
2468 : : }
2469 : :
2470 : :
2471 : : /* Determine the most derived metatype. */
2472 : : PyTypeObject *
2473 : 2021240 : _PyType_CalculateMetaclass(PyTypeObject *metatype, PyObject *bases)
2474 : : {
2475 : : Py_ssize_t i, nbases;
2476 : : PyTypeObject *winner;
2477 : : PyObject *tmp;
2478 : : PyTypeObject *tmptype;
2479 : :
2480 : : /* Determine the proper metatype to deal with this,
2481 : : and check for metatype conflicts while we're at it.
2482 : : Note that if some other metatype wins to contract,
2483 : : it's possible that its instances are not types. */
2484 : :
2485 : 2021240 : nbases = PyTuple_GET_SIZE(bases);
2486 : 2021240 : winner = metatype;
2487 [ + + ]: 4042857 : for (i = 0; i < nbases; i++) {
2488 : 2021624 : tmp = PyTuple_GET_ITEM(bases, i);
2489 : 2021624 : tmptype = Py_TYPE(tmp);
2490 [ + + ]: 2021624 : if (PyType_IsSubtype(winner, tmptype))
2491 : 1981568 : continue;
2492 [ + + ]: 40056 : if (PyType_IsSubtype(tmptype, winner)) {
2493 : 40049 : winner = tmptype;
2494 : 40049 : continue;
2495 : : }
2496 : : /* else: */
2497 : 7 : PyErr_SetString(PyExc_TypeError,
2498 : : "metaclass conflict: "
2499 : : "the metaclass of a derived class "
2500 : : "must be a (non-strict) subclass "
2501 : : "of the metaclasses of all its bases");
2502 : 7 : return NULL;
2503 : : }
2504 : 2021233 : return winner;
2505 : : }
2506 : :
2507 : :
2508 : : // Forward declaration
2509 : : static PyObject *
2510 : : type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds);
2511 : :
2512 : : typedef struct {
2513 : : PyTypeObject *metatype;
2514 : : PyObject *args;
2515 : : PyObject *kwds;
2516 : : PyObject *orig_dict;
2517 : : PyObject *name;
2518 : : PyObject *bases;
2519 : : PyTypeObject *base;
2520 : : PyObject *slots;
2521 : : Py_ssize_t nslot;
2522 : : int add_dict;
2523 : : int add_weak;
2524 : : int may_add_dict;
2525 : : int may_add_weak;
2526 : : } type_new_ctx;
2527 : :
2528 : :
2529 : : /* Check for valid slot names and two special cases */
2530 : : static int
2531 : 179379 : type_new_visit_slots(type_new_ctx *ctx)
2532 : : {
2533 : 179379 : PyObject *slots = ctx->slots;
2534 : 179379 : Py_ssize_t nslot = ctx->nslot;
2535 [ + + ]: 322172 : for (Py_ssize_t i = 0; i < nslot; i++) {
2536 : 142808 : PyObject *name = PyTuple_GET_ITEM(slots, i);
2537 [ + + ]: 142808 : if (!valid_identifier(name)) {
2538 : 11 : return -1;
2539 : : }
2540 : : assert(PyUnicode_Check(name));
2541 [ + + ]: 142797 : if (_PyUnicode_Equal(name, &_Py_ID(__dict__))) {
2542 [ + + + + ]: 2000 : if (!ctx->may_add_dict || ctx->add_dict != 0) {
2543 : 2 : PyErr_SetString(PyExc_TypeError,
2544 : : "__dict__ slot disallowed: "
2545 : : "we already got one");
2546 : 2 : return -1;
2547 : : }
2548 : 1998 : ctx->add_dict++;
2549 : : }
2550 [ + + ]: 142795 : if (_PyUnicode_Equal(name, &_Py_ID(__weakref__))) {
2551 [ + + + + ]: 8798 : if (!ctx->may_add_weak || ctx->add_weak != 0) {
2552 : 2 : PyErr_SetString(PyExc_TypeError,
2553 : : "__weakref__ slot disallowed: "
2554 : : "either we already got one, "
2555 : : "or __itemsize__ != 0");
2556 : 2 : return -1;
2557 : : }
2558 : 8796 : ctx->add_weak++;
2559 : : }
2560 : : }
2561 : 179364 : return 0;
2562 : : }
2563 : :
2564 : :
2565 : : /* Copy slots into a list, mangle names and sort them.
2566 : : Sorted names are needed for __class__ assignment.
2567 : : Convert them back to tuple at the end.
2568 : : */
2569 : : static PyObject*
2570 : 179364 : type_new_copy_slots(type_new_ctx *ctx, PyObject *dict)
2571 : : {
2572 : 179364 : PyObject *slots = ctx->slots;
2573 : 179364 : Py_ssize_t nslot = ctx->nslot;
2574 : :
2575 : 179364 : Py_ssize_t new_nslot = nslot - ctx->add_dict - ctx->add_weak;
2576 : 179364 : PyObject *new_slots = PyList_New(new_nslot);
2577 [ - + ]: 179364 : if (new_slots == NULL) {
2578 : 0 : return NULL;
2579 : : }
2580 : :
2581 : 179364 : Py_ssize_t j = 0;
2582 [ + + ]: 322153 : for (Py_ssize_t i = 0; i < nslot; i++) {
2583 : 142791 : PyObject *slot = PyTuple_GET_ITEM(slots, i);
2584 [ + + + + ]: 142791 : if ((ctx->add_dict && _PyUnicode_Equal(slot, &_Py_ID(__dict__))) ||
2585 [ + + + + ]: 140794 : (ctx->add_weak && _PyUnicode_Equal(slot, &_Py_ID(__weakref__))))
2586 : : {
2587 : 10792 : continue;
2588 : : }
2589 : :
2590 : 131999 : slot =_Py_Mangle(ctx->name, slot);
2591 [ - + ]: 131999 : if (!slot) {
2592 : 0 : goto error;
2593 : : }
2594 : 131999 : PyList_SET_ITEM(new_slots, j, slot);
2595 : :
2596 : 131999 : int r = PyDict_Contains(dict, slot);
2597 [ - + ]: 131999 : if (r < 0) {
2598 : 0 : goto error;
2599 : : }
2600 [ + + ]: 131999 : if (r > 0) {
2601 : : /* CPython inserts __qualname__ and __classcell__ (when needed)
2602 : : into the namespace when creating a class. They will be deleted
2603 : : below so won't act as class variables. */
2604 [ + + + + ]: 10 : if (!_PyUnicode_Equal(slot, &_Py_ID(__qualname__)) &&
2605 : 4 : !_PyUnicode_Equal(slot, &_Py_ID(__classcell__)))
2606 : : {
2607 : 2 : PyErr_Format(PyExc_ValueError,
2608 : : "%R in __slots__ conflicts with class variable",
2609 : : slot);
2610 : 2 : goto error;
2611 : : }
2612 : : }
2613 : :
2614 : 131997 : j++;
2615 : : }
2616 : : assert(j == new_nslot);
2617 : :
2618 [ - + ]: 179362 : if (PyList_Sort(new_slots) == -1) {
2619 : 0 : goto error;
2620 : : }
2621 : :
2622 : 179362 : PyObject *tuple = PyList_AsTuple(new_slots);
2623 : 179362 : Py_DECREF(new_slots);
2624 [ - + ]: 179362 : if (tuple == NULL) {
2625 : 0 : return NULL;
2626 : : }
2627 : :
2628 : : assert(PyTuple_GET_SIZE(tuple) == new_nslot);
2629 : 179362 : return tuple;
2630 : :
2631 : 2 : error:
2632 : 2 : Py_DECREF(new_slots);
2633 : 2 : return NULL;
2634 : : }
2635 : :
2636 : :
2637 : : static void
2638 : 179362 : type_new_slots_bases(type_new_ctx *ctx)
2639 : : {
2640 : 179362 : Py_ssize_t nbases = PyTuple_GET_SIZE(ctx->bases);
2641 [ + + ]: 179362 : if (nbases > 1 &&
2642 [ + + - + ]: 23371 : ((ctx->may_add_dict && ctx->add_dict == 0) ||
2643 [ + + + - ]: 3 : (ctx->may_add_weak && ctx->add_weak == 0)))
2644 : : {
2645 [ + + ]: 73217 : for (Py_ssize_t i = 0; i < nbases; i++) {
2646 : 49855 : PyObject *obj = PyTuple_GET_ITEM(ctx->bases, i);
2647 [ + + ]: 49855 : if (obj == (PyObject *)ctx->base) {
2648 : : /* Skip primary base */
2649 : 23369 : continue;
2650 : : }
2651 : 26486 : PyTypeObject *base = _PyType_CAST(obj);
2652 : :
2653 [ + + + - ]: 26486 : if (ctx->may_add_dict && ctx->add_dict == 0 &&
2654 [ + + ]: 26485 : base->tp_dictoffset != 0)
2655 : : {
2656 : 6 : ctx->add_dict++;
2657 : : }
2658 [ + + + + ]: 26486 : if (ctx->may_add_weak && ctx->add_weak == 0 &&
2659 [ + + ]: 21627 : base->tp_weaklistoffset != 0)
2660 : : {
2661 : 6 : ctx->add_weak++;
2662 : : }
2663 [ + + + + ]: 26486 : if (ctx->may_add_dict && ctx->add_dict == 0) {
2664 : 26479 : continue;
2665 : : }
2666 [ + + - + ]: 7 : if (ctx->may_add_weak && ctx->add_weak == 0) {
2667 : 0 : continue;
2668 : : }
2669 : : /* Nothing more to check */
2670 : 7 : break;
2671 : : }
2672 : : }
2673 : 179362 : }
2674 : :
2675 : :
2676 : : static int
2677 : 179380 : type_new_slots_impl(type_new_ctx *ctx, PyObject *dict)
2678 : : {
2679 : : /* Are slots allowed? */
2680 [ + + + + ]: 179380 : if (ctx->nslot > 0 && ctx->base->tp_itemsize != 0) {
2681 : 1 : PyErr_Format(PyExc_TypeError,
2682 : : "nonempty __slots__ not supported for subtype of '%s'",
2683 : 1 : ctx->base->tp_name);
2684 : 1 : return -1;
2685 : : }
2686 : :
2687 [ + + ]: 179379 : if (type_new_visit_slots(ctx) < 0) {
2688 : 15 : return -1;
2689 : : }
2690 : :
2691 : 179364 : PyObject *new_slots = type_new_copy_slots(ctx, dict);
2692 [ + + ]: 179364 : if (new_slots == NULL) {
2693 : 2 : return -1;
2694 : : }
2695 : : assert(PyTuple_CheckExact(new_slots));
2696 : :
2697 : 179362 : Py_XSETREF(ctx->slots, new_slots);
2698 : 179362 : ctx->nslot = PyTuple_GET_SIZE(new_slots);
2699 : :
2700 : : /* Secondary bases may provide weakrefs or dict */
2701 : 179362 : type_new_slots_bases(ctx);
2702 : 179362 : return 0;
2703 : : }
2704 : :
2705 : :
2706 : : static Py_ssize_t
2707 : 1216618 : type_new_slots(type_new_ctx *ctx, PyObject *dict)
2708 : : {
2709 : : // Check for a __slots__ sequence variable in dict, and count it
2710 : 1216618 : ctx->add_dict = 0;
2711 : 1216618 : ctx->add_weak = 0;
2712 : 1216618 : ctx->may_add_dict = (ctx->base->tp_dictoffset == 0);
2713 : 2433236 : ctx->may_add_weak = (ctx->base->tp_weaklistoffset == 0
2714 [ + + + + ]: 1216618 : && ctx->base->tp_itemsize == 0);
2715 : :
2716 [ + + ]: 1216618 : if (ctx->slots == NULL) {
2717 [ + + ]: 1037238 : if (ctx->may_add_dict) {
2718 : 405457 : ctx->add_dict++;
2719 : : }
2720 [ + + ]: 1037238 : if (ctx->may_add_weak) {
2721 : 496598 : ctx->add_weak++;
2722 : : }
2723 : : }
2724 : : else {
2725 : : /* Have slots */
2726 [ + + ]: 179380 : if (type_new_slots_impl(ctx, dict) < 0) {
2727 : 18 : return -1;
2728 : : }
2729 : : }
2730 : 1216600 : return 0;
2731 : : }
2732 : :
2733 : :
2734 : : static PyTypeObject*
2735 : 1216600 : type_new_alloc(type_new_ctx *ctx)
2736 : : {
2737 : 1216600 : PyTypeObject *metatype = ctx->metatype;
2738 : : PyTypeObject *type;
2739 : :
2740 : : // Allocate the type object
2741 : 1216600 : type = (PyTypeObject *)metatype->tp_alloc(metatype, ctx->nslot);
2742 [ - + ]: 1216600 : if (type == NULL) {
2743 : 0 : return NULL;
2744 : : }
2745 : 1216600 : PyHeapTypeObject *et = (PyHeapTypeObject *)type;
2746 : :
2747 : : // Initialize tp_flags.
2748 : : // All heap types need GC, since we can create a reference cycle by storing
2749 : : // an instance on one of its parents.
2750 : 1216600 : type->tp_flags = (Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HEAPTYPE |
2751 : : Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HAVE_GC);
2752 : :
2753 : : // Initialize essential fields
2754 : 1216600 : type->tp_as_async = &et->as_async;
2755 : 1216600 : type->tp_as_number = &et->as_number;
2756 : 1216600 : type->tp_as_sequence = &et->as_sequence;
2757 : 1216600 : type->tp_as_mapping = &et->as_mapping;
2758 : 1216600 : type->tp_as_buffer = &et->as_buffer;
2759 : :
2760 : 1216600 : type->tp_bases = Py_NewRef(ctx->bases);
2761 : 1216600 : type->tp_base = (PyTypeObject *)Py_NewRef(ctx->base);
2762 : :
2763 : 1216600 : type->tp_dealloc = subtype_dealloc;
2764 : : /* Always override allocation strategy to use regular heap */
2765 : 1216600 : type->tp_alloc = PyType_GenericAlloc;
2766 : 1216600 : type->tp_free = PyObject_GC_Del;
2767 : :
2768 : 1216600 : type->tp_traverse = subtype_traverse;
2769 : 1216600 : type->tp_clear = subtype_clear;
2770 : :
2771 : 1216600 : et->ht_name = Py_NewRef(ctx->name);
2772 : 1216600 : et->ht_module = NULL;
2773 : 1216600 : et->_ht_tpname = NULL;
2774 : :
2775 : 1216600 : return type;
2776 : : }
2777 : :
2778 : :
2779 : : static int
2780 : 1216600 : type_new_set_name(const type_new_ctx *ctx, PyTypeObject *type)
2781 : : {
2782 : : Py_ssize_t name_size;
2783 : 1216600 : type->tp_name = PyUnicode_AsUTF8AndSize(ctx->name, &name_size);
2784 [ + + ]: 1216600 : if (!type->tp_name) {
2785 : 1 : return -1;
2786 : : }
2787 [ + + ]: 1216599 : if (strlen(type->tp_name) != (size_t)name_size) {
2788 : 1 : PyErr_SetString(PyExc_ValueError,
2789 : : "type name must not contain null characters");
2790 : 1 : return -1;
2791 : : }
2792 : 1216598 : return 0;
2793 : : }
2794 : :
2795 : :
2796 : : /* Set __module__ in the dict */
2797 : : static int
2798 : 1216598 : type_new_set_module(PyTypeObject *type)
2799 : : {
2800 : 1216598 : int r = PyDict_Contains(type->tp_dict, &_Py_ID(__module__));
2801 [ - + ]: 1216598 : if (r < 0) {
2802 : 0 : return -1;
2803 : : }
2804 [ + + ]: 1216598 : if (r > 0) {
2805 : 1162772 : return 0;
2806 : : }
2807 : :
2808 : 53826 : PyObject *globals = PyEval_GetGlobals();
2809 [ - + ]: 53826 : if (globals == NULL) {
2810 : 0 : return 0;
2811 : : }
2812 : :
2813 : 53826 : PyObject *module = PyDict_GetItemWithError(globals, &_Py_ID(__name__));
2814 [ - + ]: 53826 : if (module == NULL) {
2815 [ # # ]: 0 : if (PyErr_Occurred()) {
2816 : 0 : return -1;
2817 : : }
2818 : 0 : return 0;
2819 : : }
2820 : :
2821 [ - + ]: 53826 : if (PyDict_SetItem(type->tp_dict, &_Py_ID(__module__), module) < 0) {
2822 : 0 : return -1;
2823 : : }
2824 : 53826 : return 0;
2825 : : }
2826 : :
2827 : :
2828 : : /* Set ht_qualname to dict['__qualname__'] if available, else to
2829 : : __name__. The __qualname__ accessor will look for ht_qualname. */
2830 : : static int
2831 : 1216598 : type_new_set_ht_name(PyTypeObject *type)
2832 : : {
2833 : 1216598 : PyHeapTypeObject *et = (PyHeapTypeObject *)type;
2834 : 1216598 : PyObject *qualname = PyDict_GetItemWithError(
2835 : : type->tp_dict, &_Py_ID(__qualname__));
2836 [ + + ]: 1216598 : if (qualname != NULL) {
2837 [ + + ]: 939381 : if (!PyUnicode_Check(qualname)) {
2838 : 3 : PyErr_Format(PyExc_TypeError,
2839 : : "type __qualname__ must be a str, not %s",
2840 : 3 : Py_TYPE(qualname)->tp_name);
2841 : 3 : return -1;
2842 : : }
2843 : 939378 : et->ht_qualname = Py_NewRef(qualname);
2844 [ - + ]: 939378 : if (PyDict_DelItem(type->tp_dict, &_Py_ID(__qualname__)) < 0) {
2845 : 0 : return -1;
2846 : : }
2847 : : }
2848 : : else {
2849 [ - + ]: 277217 : if (PyErr_Occurred()) {
2850 : 0 : return -1;
2851 : : }
2852 : 277217 : et->ht_qualname = Py_NewRef(et->ht_name);
2853 : : }
2854 : 1216595 : return 0;
2855 : : }
2856 : :
2857 : :
2858 : : /* Set tp_doc to a copy of dict['__doc__'], if the latter is there
2859 : : and is a string. The __doc__ accessor will first look for tp_doc;
2860 : : if that fails, it will still look into __dict__. */
2861 : : static int
2862 : 1216595 : type_new_set_doc(PyTypeObject *type)
2863 : : {
2864 : 1216595 : PyObject *doc = PyDict_GetItemWithError(type->tp_dict, &_Py_ID(__doc__));
2865 [ + + ]: 1216595 : if (doc == NULL) {
2866 [ - + ]: 470338 : if (PyErr_Occurred()) {
2867 : 0 : return -1;
2868 : : }
2869 : : // no __doc__ key
2870 : 470338 : return 0;
2871 : : }
2872 [ + + ]: 746257 : if (!PyUnicode_Check(doc)) {
2873 : : // ignore non-string __doc__
2874 : 72 : return 0;
2875 : : }
2876 : :
2877 : 746185 : const char *doc_str = PyUnicode_AsUTF8(doc);
2878 [ + + ]: 746185 : if (doc_str == NULL) {
2879 : 1 : return -1;
2880 : : }
2881 : :
2882 : : // Silently truncate the docstring if it contains a null byte
2883 : 746184 : Py_ssize_t size = strlen(doc_str) + 1;
2884 : 746184 : char *tp_doc = (char *)PyObject_Malloc(size);
2885 [ - + ]: 746184 : if (tp_doc == NULL) {
2886 : : PyErr_NoMemory();
2887 : 0 : return -1;
2888 : : }
2889 : :
2890 : 746184 : memcpy(tp_doc, doc_str, size);
2891 : 746184 : type->tp_doc = tp_doc;
2892 : 746184 : return 0;
2893 : : }
2894 : :
2895 : :
2896 : : static int
2897 : 1216594 : type_new_staticmethod(PyTypeObject *type, PyObject *attr)
2898 : : {
2899 : 1216594 : PyObject *func = PyDict_GetItemWithError(type->tp_dict, attr);
2900 [ + + ]: 1216594 : if (func == NULL) {
2901 [ - + ]: 1144705 : if (PyErr_Occurred()) {
2902 : 0 : return -1;
2903 : : }
2904 : 1144705 : return 0;
2905 : : }
2906 [ + + ]: 71889 : if (!PyFunction_Check(func)) {
2907 : 172 : return 0;
2908 : : }
2909 : :
2910 : 71717 : PyObject *static_func = PyStaticMethod_New(func);
2911 [ - + ]: 71717 : if (static_func == NULL) {
2912 : 0 : return -1;
2913 : : }
2914 [ - + ]: 71717 : if (PyDict_SetItem(type->tp_dict, attr, static_func) < 0) {
2915 : 0 : Py_DECREF(static_func);
2916 : 0 : return -1;
2917 : : }
2918 : 71717 : Py_DECREF(static_func);
2919 : 71717 : return 0;
2920 : : }
2921 : :
2922 : :
2923 : : static int
2924 : 2433188 : type_new_classmethod(PyTypeObject *type, PyObject *attr)
2925 : : {
2926 : 2433188 : PyObject *func = PyDict_GetItemWithError(type->tp_dict, attr);
2927 [ + + ]: 2433188 : if (func == NULL) {
2928 [ - + ]: 2378082 : if (PyErr_Occurred()) {
2929 : 0 : return -1;
2930 : : }
2931 : 2378082 : return 0;
2932 : : }
2933 [ + + ]: 55106 : if (!PyFunction_Check(func)) {
2934 : 46621 : return 0;
2935 : : }
2936 : :
2937 : 8485 : PyObject *method = PyClassMethod_New(func);
2938 [ - + ]: 8485 : if (method == NULL) {
2939 : 0 : return -1;
2940 : : }
2941 : :
2942 [ - + ]: 8485 : if (PyDict_SetItem(type->tp_dict, attr, method) < 0) {
2943 : 0 : Py_DECREF(method);
2944 : 0 : return -1;
2945 : : }
2946 : 8485 : Py_DECREF(method);
2947 : 8485 : return 0;
2948 : : }
2949 : :
2950 : :
2951 : : /* Add descriptors for custom slots from __slots__, or for __dict__ */
2952 : : static int
2953 : 1216594 : type_new_descriptors(const type_new_ctx *ctx, PyTypeObject *type)
2954 : : {
2955 : 1216594 : PyHeapTypeObject *et = (PyHeapTypeObject *)type;
2956 : 1216594 : Py_ssize_t slotoffset = ctx->base->tp_basicsize;
2957 [ + + ]: 1216594 : if (et->ht_slots != NULL) {
2958 : 179361 : PyMemberDef *mp = _PyHeapType_GET_MEMBERS(et);
2959 : 179361 : Py_ssize_t nslot = PyTuple_GET_SIZE(et->ht_slots);
2960 [ + + ]: 311357 : for (Py_ssize_t i = 0; i < nslot; i++, mp++) {
2961 : 263992 : mp->name = PyUnicode_AsUTF8(
2962 : 131996 : PyTuple_GET_ITEM(et->ht_slots, i));
2963 [ - + ]: 131996 : if (mp->name == NULL) {
2964 : 0 : return -1;
2965 : : }
2966 : 131996 : mp->type = T_OBJECT_EX;
2967 : 131996 : mp->offset = slotoffset;
2968 : :
2969 : : /* __dict__ and __weakref__ are already filtered out */
2970 : : assert(strcmp(mp->name, "__dict__") != 0);
2971 : : assert(strcmp(mp->name, "__weakref__") != 0);
2972 : :
2973 : 131996 : slotoffset += sizeof(PyObject *);
2974 : : }
2975 : : }
2976 : :
2977 [ + + + + ]: 1216594 : if (ctx->add_dict && ctx->base->tp_itemsize) {
2978 : 17456 : type->tp_dictoffset = -(long)sizeof(PyObject *);
2979 : 17456 : slotoffset += sizeof(PyObject *);
2980 : : }
2981 : :
2982 [ + + ]: 1216594 : if (ctx->add_weak) {
2983 : : assert(!ctx->base->tp_itemsize);
2984 : 505394 : type->tp_weaklistoffset = slotoffset;
2985 : 505394 : slotoffset += sizeof(PyObject *);
2986 : : }
2987 [ + + + + ]: 1216594 : if (ctx->add_dict && ctx->base->tp_itemsize == 0) {
2988 : : assert((type->tp_flags & Py_TPFLAGS_MANAGED_DICT) == 0);
2989 : 389999 : type->tp_flags |= Py_TPFLAGS_MANAGED_DICT;
2990 : 389999 : type->tp_dictoffset = -slotoffset - sizeof(PyObject *)*3;
2991 : : }
2992 : :
2993 : 1216594 : type->tp_basicsize = slotoffset;
2994 : 1216594 : type->tp_itemsize = ctx->base->tp_itemsize;
2995 : 1216594 : type->tp_members = _PyHeapType_GET_MEMBERS(et);
2996 : 1216594 : return 0;
2997 : : }
2998 : :
2999 : :
3000 : : static void
3001 : 1216594 : type_new_set_slots(const type_new_ctx *ctx, PyTypeObject *type)
3002 : : {
3003 [ + + + + ]: 1216594 : if (type->tp_weaklistoffset && type->tp_dictoffset) {
3004 : 381385 : type->tp_getset = subtype_getsets_full;
3005 : : }
3006 [ + + + - ]: 835209 : else if (type->tp_weaklistoffset && !type->tp_dictoffset) {
3007 : 124009 : type->tp_getset = subtype_getsets_weakref_only;
3008 : : }
3009 [ + - + + ]: 711200 : else if (!type->tp_weaklistoffset && type->tp_dictoffset) {
3010 : 26070 : type->tp_getset = subtype_getsets_dict_only;
3011 : : }
3012 : : else {
3013 : 685130 : type->tp_getset = NULL;
3014 : : }
3015 : :
3016 : : /* Special case some slots */
3017 [ + + + + ]: 1216594 : if (type->tp_dictoffset != 0 || ctx->nslot > 0) {
3018 : 443384 : PyTypeObject *base = ctx->base;
3019 [ + - - + ]: 443384 : if (base->tp_getattr == NULL && base->tp_getattro == NULL) {
3020 : 0 : type->tp_getattro = PyObject_GenericGetAttr;
3021 : : }
3022 [ + - - + ]: 443384 : if (base->tp_setattr == NULL && base->tp_setattro == NULL) {
3023 : 0 : type->tp_setattro = PyObject_GenericSetAttr;
3024 : : }
3025 : : }
3026 : 1216594 : }
3027 : :
3028 : :
3029 : : /* store type in class' cell if one is supplied */
3030 : : static int
3031 : 1216594 : type_new_set_classcell(PyTypeObject *type)
3032 : : {
3033 : 1216594 : PyObject *cell = PyDict_GetItemWithError(
3034 : : type->tp_dict, &_Py_ID(__classcell__));
3035 [ + + ]: 1216594 : if (cell == NULL) {
3036 [ - + ]: 1098117 : if (PyErr_Occurred()) {
3037 : 0 : return -1;
3038 : : }
3039 : 1098117 : return 0;
3040 : : }
3041 : :
3042 : : /* At least one method requires a reference to its defining class */
3043 [ + + ]: 118477 : if (!PyCell_Check(cell)) {
3044 : 5 : PyErr_Format(PyExc_TypeError,
3045 : : "__classcell__ must be a nonlocal cell, not %.200R",
3046 : : Py_TYPE(cell));
3047 : 5 : return -1;
3048 : : }
3049 : :
3050 : 118472 : (void)PyCell_Set(cell, (PyObject *) type);
3051 [ - + ]: 118472 : if (PyDict_DelItem(type->tp_dict, &_Py_ID(__classcell__)) < 0) {
3052 : 0 : return -1;
3053 : : }
3054 : 118472 : return 0;
3055 : : }
3056 : :
3057 : :
3058 : : static int
3059 : 1216600 : type_new_set_attrs(const type_new_ctx *ctx, PyTypeObject *type)
3060 : : {
3061 [ + + ]: 1216600 : if (type_new_set_name(ctx, type) < 0) {
3062 : 2 : return -1;
3063 : : }
3064 : :
3065 [ - + ]: 1216598 : if (type_new_set_module(type) < 0) {
3066 : 0 : return -1;
3067 : : }
3068 : :
3069 [ + + ]: 1216598 : if (type_new_set_ht_name(type) < 0) {
3070 : 3 : return -1;
3071 : : }
3072 : :
3073 [ + + ]: 1216595 : if (type_new_set_doc(type) < 0) {
3074 : 1 : return -1;
3075 : : }
3076 : :
3077 : : /* Special-case __new__: if it's a plain function,
3078 : : make it a static function */
3079 [ - + ]: 1216594 : if (type_new_staticmethod(type, &_Py_ID(__new__)) < 0) {
3080 : 0 : return -1;
3081 : : }
3082 : :
3083 : : /* Special-case __init_subclass__ and __class_getitem__:
3084 : : if they are plain functions, make them classmethods */
3085 [ - + ]: 1216594 : if (type_new_classmethod(type, &_Py_ID(__init_subclass__)) < 0) {
3086 : 0 : return -1;
3087 : : }
3088 [ - + ]: 1216594 : if (type_new_classmethod(type, &_Py_ID(__class_getitem__)) < 0) {
3089 : 0 : return -1;
3090 : : }
3091 : :
3092 [ - + ]: 1216594 : if (type_new_descriptors(ctx, type) < 0) {
3093 : 0 : return -1;
3094 : : }
3095 : :
3096 : 1216594 : type_new_set_slots(ctx, type);
3097 : :
3098 [ + + ]: 1216594 : if (type_new_set_classcell(type) < 0) {
3099 : 5 : return -1;
3100 : : }
3101 : 1216589 : return 0;
3102 : : }
3103 : :
3104 : :
3105 : : static int
3106 : 1216619 : type_new_get_slots(type_new_ctx *ctx, PyObject *dict)
3107 : : {
3108 : 1216619 : PyObject *slots = PyDict_GetItemWithError(dict, &_Py_ID(__slots__));
3109 [ + + ]: 1216619 : if (slots == NULL) {
3110 [ - + ]: 1037238 : if (PyErr_Occurred()) {
3111 : 0 : return -1;
3112 : : }
3113 : 1037238 : ctx->slots = NULL;
3114 : 1037238 : ctx->nslot = 0;
3115 : 1037238 : return 0;
3116 : : }
3117 : :
3118 : : // Make it into a tuple
3119 : : PyObject *new_slots;
3120 [ + + ]: 179381 : if (PyUnicode_Check(slots)) {
3121 : 2003 : new_slots = PyTuple_Pack(1, slots);
3122 : : }
3123 : : else {
3124 : 177378 : new_slots = PySequence_Tuple(slots);
3125 : : }
3126 [ + + ]: 179381 : if (new_slots == NULL) {
3127 : 1 : return -1;
3128 : : }
3129 : : assert(PyTuple_CheckExact(new_slots));
3130 : 179380 : ctx->slots = new_slots;
3131 : 179380 : ctx->nslot = PyTuple_GET_SIZE(new_slots);
3132 : 179380 : return 0;
3133 : : }
3134 : :
3135 : :
3136 : : static PyTypeObject*
3137 : 1216619 : type_new_init(type_new_ctx *ctx)
3138 : : {
3139 : 1216619 : PyObject *dict = PyDict_Copy(ctx->orig_dict);
3140 [ - + ]: 1216619 : if (dict == NULL) {
3141 : 0 : goto error;
3142 : : }
3143 : :
3144 [ + + ]: 1216619 : if (type_new_get_slots(ctx, dict) < 0) {
3145 : 1 : goto error;
3146 : : }
3147 : : assert(!PyErr_Occurred());
3148 : :
3149 [ + + ]: 1216618 : if (type_new_slots(ctx, dict) < 0) {
3150 : 18 : goto error;
3151 : : }
3152 : :
3153 : 1216600 : PyTypeObject *type = type_new_alloc(ctx);
3154 [ - + ]: 1216600 : if (type == NULL) {
3155 : 0 : goto error;
3156 : : }
3157 : :
3158 : 1216600 : type->tp_dict = dict;
3159 : :
3160 : 1216600 : PyHeapTypeObject *et = (PyHeapTypeObject*)type;
3161 : 1216600 : et->ht_slots = ctx->slots;
3162 : 1216600 : ctx->slots = NULL;
3163 : :
3164 : 1216600 : return type;
3165 : :
3166 : 19 : error:
3167 [ + + ]: 19 : Py_CLEAR(ctx->slots);
3168 : 19 : Py_XDECREF(dict);
3169 : 19 : return NULL;
3170 : : }
3171 : :
3172 : :
3173 : : static PyObject*
3174 : 1216619 : type_new_impl(type_new_ctx *ctx)
3175 : : {
3176 : 1216619 : PyTypeObject *type = type_new_init(ctx);
3177 [ + + ]: 1216619 : if (type == NULL) {
3178 : 19 : return NULL;
3179 : : }
3180 : :
3181 [ + + ]: 1216600 : if (type_new_set_attrs(ctx, type) < 0) {
3182 : 11 : goto error;
3183 : : }
3184 : :
3185 : : /* Initialize the rest */
3186 [ + + ]: 1216589 : if (PyType_Ready(type) < 0) {
3187 : 16 : goto error;
3188 : : }
3189 : :
3190 : : // Put the proper slots in place
3191 : 1216573 : fixup_slot_dispatchers(type);
3192 : :
3193 [ + + ]: 1216573 : if (type->tp_flags & Py_TPFLAGS_MANAGED_DICT) {
3194 : 670556 : PyHeapTypeObject *et = (PyHeapTypeObject*)type;
3195 : 670556 : et->ht_cached_keys = _PyDict_NewKeysForClass();
3196 : : }
3197 : :
3198 [ + + ]: 1216573 : if (type_new_set_names(type) < 0) {
3199 : 12 : goto error;
3200 : : }
3201 : :
3202 [ + + ]: 1216561 : if (type_new_init_subclass(type, ctx->kwds) < 0) {
3203 : 44 : goto error;
3204 : : }
3205 : :
3206 : : assert(_PyType_CheckConsistency(type));
3207 : :
3208 : 1216517 : return (PyObject *)type;
3209 : :
3210 : 83 : error:
3211 : 83 : Py_DECREF(type);
3212 : 83 : return NULL;
3213 : : }
3214 : :
3215 : :
3216 : : static int
3217 : 1233673 : type_new_get_bases(type_new_ctx *ctx, PyObject **type)
3218 : : {
3219 : 1233673 : Py_ssize_t nbases = PyTuple_GET_SIZE(ctx->bases);
3220 [ + + ]: 1233673 : if (nbases == 0) {
3221 : : // Adjust for empty tuple bases
3222 : 265751 : ctx->base = &PyBaseObject_Type;
3223 : 265751 : PyObject *new_bases = PyTuple_Pack(1, ctx->base);
3224 [ - + ]: 265751 : if (new_bases == NULL) {
3225 : 0 : return -1;
3226 : : }
3227 : 265751 : ctx->bases = new_bases;
3228 : 265751 : return 0;
3229 : : }
3230 : :
3231 [ + + ]: 2075891 : for (Py_ssize_t i = 0; i < nbases; i++) {
3232 : 1107970 : PyObject *base = PyTuple_GET_ITEM(ctx->bases, i);
3233 [ + + ]: 1107970 : if (PyType_Check(base)) {
3234 : 1107968 : continue;
3235 : : }
3236 : : PyObject *mro_entries;
3237 [ - + ]: 2 : if (_PyObject_LookupAttr(base, &_Py_ID(__mro_entries__),
3238 : : &mro_entries) < 0) {
3239 : 1 : return -1;
3240 : : }
3241 [ + + ]: 2 : if (mro_entries != NULL) {
3242 : 1 : PyErr_SetString(PyExc_TypeError,
3243 : : "type() doesn't support MRO entry resolution; "
3244 : : "use types.new_class()");
3245 : 1 : Py_DECREF(mro_entries);
3246 : 1 : return -1;
3247 : : }
3248 : : }
3249 : :
3250 : : // Search the bases for the proper metatype to deal with this
3251 : : PyTypeObject *winner;
3252 : 967921 : winner = _PyType_CalculateMetaclass(ctx->metatype, ctx->bases);
3253 [ + + ]: 967921 : if (winner == NULL) {
3254 : 1 : return -1;
3255 : : }
3256 : :
3257 [ + + ]: 967920 : if (winner != ctx->metatype) {
3258 [ + - ]: 17037 : if (winner->tp_new != type_new) {
3259 : : /* Pass it to the winner */
3260 : 17037 : *type = winner->tp_new(winner, ctx->args, ctx->kwds);
3261 [ + + ]: 17037 : if (*type == NULL) {
3262 : 1 : return -1;
3263 : : }
3264 : 17036 : return 1;
3265 : : }
3266 : :
3267 : 0 : ctx->metatype = winner;
3268 : : }
3269 : :
3270 : : /* Calculate best base, and check that all bases are type objects */
3271 : 950883 : PyTypeObject *base = best_base(ctx->bases);
3272 [ + + ]: 950883 : if (base == NULL) {
3273 : 15 : return -1;
3274 : : }
3275 : :
3276 : 950868 : ctx->base = base;
3277 : 950868 : ctx->bases = Py_NewRef(ctx->bases);
3278 : 950868 : return 0;
3279 : : }
3280 : :
3281 : :
3282 : : static PyObject *
3283 : 1233680 : type_new(PyTypeObject *metatype, PyObject *args, PyObject *kwds)
3284 : : {
3285 : : assert(args != NULL && PyTuple_Check(args));
3286 : : assert(kwds == NULL || PyDict_Check(kwds));
3287 : :
3288 : : /* Parse arguments: (name, bases, dict) */
3289 : : PyObject *name, *bases, *orig_dict;
3290 [ + + ]: 1233680 : if (!PyArg_ParseTuple(args, "UO!O!:type.__new__",
3291 : : &name,
3292 : : &PyTuple_Type, &bases,
3293 : : &PyDict_Type, &orig_dict))
3294 : : {
3295 : 7 : return NULL;
3296 : : }
3297 : :
3298 : 1233673 : type_new_ctx ctx = {
3299 : : .metatype = metatype,
3300 : : .args = args,
3301 : : .kwds = kwds,
3302 : : .orig_dict = orig_dict,
3303 : : .name = name,
3304 : : .bases = bases,
3305 : : .base = NULL,
3306 : : .slots = NULL,
3307 : : .nslot = 0,
3308 : : .add_dict = 0,
3309 : : .add_weak = 0,
3310 : : .may_add_dict = 0,
3311 : : .may_add_weak = 0};
3312 : 1233673 : PyObject *type = NULL;
3313 : 1233673 : int res = type_new_get_bases(&ctx, &type);
3314 [ + + ]: 1233673 : if (res < 0) {
3315 : : assert(PyErr_Occurred());
3316 : 18 : return NULL;
3317 : : }
3318 [ + + ]: 1233655 : if (res == 1) {
3319 : : assert(type != NULL);
3320 : 17036 : return type;
3321 : : }
3322 : : assert(ctx.base != NULL);
3323 : : assert(ctx.bases != NULL);
3324 : :
3325 : 1216619 : type = type_new_impl(&ctx);
3326 : 1216619 : Py_DECREF(ctx.bases);
3327 : 1216619 : return type;
3328 : : }
3329 : :
3330 : :
3331 : : static PyObject *
3332 : 1523709 : type_vectorcall(PyObject *metatype, PyObject *const *args,
3333 : : size_t nargsf, PyObject *kwnames)
3334 : : {
3335 : 1523709 : Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
3336 [ + + + - ]: 1523709 : if (nargs == 1 && metatype == (PyObject *)&PyType_Type){
3337 [ - + - - ]: 528463 : if (!_PyArg_NoKwnames("type", kwnames)) {
3338 : 0 : return NULL;
3339 : : }
3340 : 528463 : return Py_NewRef(Py_TYPE(args[0]));
3341 : : }
3342 : : /* In other (much less common) cases, fall back to
3343 : : more flexible calling conventions. */
3344 : 995246 : PyThreadState *tstate = _PyThreadState_GET();
3345 : 995246 : return _PyObject_MakeTpCall(tstate, metatype, args, nargs, kwnames);
3346 : : }
3347 : :
3348 : : /* An array of type slot offsets corresponding to Py_tp_* constants,
3349 : : * for use in e.g. PyType_Spec and PyType_GetSlot.
3350 : : * Each entry has two offsets: "slot_offset" and "subslot_offset".
3351 : : * If is subslot_offset is -1, slot_offset is an offset within the
3352 : : * PyTypeObject struct.
3353 : : * Otherwise slot_offset is an offset to a pointer to a sub-slots struct
3354 : : * (such as "tp_as_number"), and subslot_offset is the offset within
3355 : : * that struct.
3356 : : * The actual table is generated by a script.
3357 : : */
3358 : : static const PySlot_Offset pyslot_offsets[] = {
3359 : : {0, 0},
3360 : : #include "typeslots.inc"
3361 : : };
3362 : :
3363 : : /* Given a PyType_FromMetaclass `bases` argument (NULL, type, or tuple of
3364 : : * types), return a tuple of types.
3365 : : */
3366 : : inline static PyObject *
3367 : 115791 : get_bases_tuple(PyObject *bases_in, PyType_Spec *spec)
3368 : : {
3369 [ + + ]: 115791 : if (!bases_in) {
3370 : : /* Default: look in the spec, fall back to (type,). */
3371 : 78345 : PyTypeObject *base = &PyBaseObject_Type; // borrowed ref
3372 : 78345 : PyObject *bases = NULL; // borrowed ref
3373 : : const PyType_Slot *slot;
3374 [ + + ]: 571277 : for (slot = spec->slots; slot->slot; slot++) {
3375 [ + - + ]: 492932 : switch (slot->slot) {
3376 : 23 : case Py_tp_base:
3377 : 23 : base = slot->pfunc;
3378 : 23 : break;
3379 : 0 : case Py_tp_bases:
3380 : 0 : bases = slot->pfunc;
3381 : 0 : break;
3382 : : }
3383 : : }
3384 [ + - ]: 78345 : if (!bases) {
3385 : 78345 : return PyTuple_Pack(1, base);
3386 : : }
3387 [ # # ]: 0 : if (PyTuple_Check(bases)) {
3388 : 0 : return Py_NewRef(bases);
3389 : : }
3390 : 0 : PyErr_SetString(PyExc_SystemError, "Py_tp_bases is not a tuple");
3391 : 0 : return NULL;
3392 : : }
3393 [ + + ]: 37446 : if (PyTuple_Check(bases_in)) {
3394 : 2358 : return Py_NewRef(bases_in);
3395 : : }
3396 : : // Not a tuple, should be a single type
3397 : 35088 : return PyTuple_Pack(1, bases_in);
3398 : : }
3399 : :
3400 : : static inline int
3401 : 115789 : check_basicsize_includes_size_and_offsets(PyTypeObject* type)
3402 : : {
3403 [ - + ]: 115789 : if (type->tp_alloc != PyType_GenericAlloc) {
3404 : : // Custom allocators can ignore tp_basicsize
3405 : 0 : return 1;
3406 : : }
3407 : 115789 : Py_ssize_t max = (Py_ssize_t)type->tp_basicsize;
3408 : :
3409 [ + - - + ]: 115789 : if (type->tp_base && type->tp_base->tp_basicsize > type->tp_basicsize) {
3410 : 0 : PyErr_Format(PyExc_TypeError,
3411 : : "tp_basicsize for type '%s' (%d) is too small for base '%s' (%d)",
3412 : : type->tp_name, type->tp_basicsize,
3413 : 0 : type->tp_base->tp_name, type->tp_base->tp_basicsize);
3414 : 0 : return 0;
3415 : : }
3416 [ - + ]: 115789 : if (type->tp_weaklistoffset + (Py_ssize_t)sizeof(PyObject*) > max) {
3417 : 0 : PyErr_Format(PyExc_TypeError,
3418 : : "weaklist offset %d is out of bounds for type '%s' (tp_basicsize = %d)",
3419 : : type->tp_weaklistoffset,
3420 : : type->tp_name, type->tp_basicsize);
3421 : 0 : return 0;
3422 : : }
3423 [ - + ]: 115789 : if (type->tp_dictoffset + (Py_ssize_t)sizeof(PyObject*) > max) {
3424 : 0 : PyErr_Format(PyExc_TypeError,
3425 : : "dict offset %d is out of bounds for type '%s' (tp_basicsize = %d)",
3426 : : type->tp_dictoffset,
3427 : : type->tp_name, type->tp_basicsize);
3428 : 0 : return 0;
3429 : : }
3430 [ - + ]: 115789 : if (type->tp_vectorcall_offset + (Py_ssize_t)sizeof(vectorcallfunc*) > max) {
3431 : 0 : PyErr_Format(PyExc_TypeError,
3432 : : "vectorcall offset %d is out of bounds for type '%s' (tp_basicsize = %d)",
3433 : : type->tp_vectorcall_offset,
3434 : : type->tp_name, type->tp_basicsize);
3435 : 0 : return 0;
3436 : : }
3437 : 115789 : return 1;
3438 : : }
3439 : :
3440 : : PyObject *
3441 : 115793 : PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module,
3442 : : PyType_Spec *spec, PyObject *bases_in)
3443 : : {
3444 : : /* Invariant: A non-NULL value in one of these means this function holds
3445 : : * a strong reference or owns allocated memory.
3446 : : * These get decrefed/freed/returned at the end, on both success and error.
3447 : : */
3448 : 115793 : PyHeapTypeObject *res = NULL;
3449 : : PyTypeObject *type;
3450 : 115793 : PyObject *bases = NULL;
3451 : 115793 : char *tp_doc = NULL;
3452 : 115793 : PyObject *ht_name = NULL;
3453 : 115793 : char *_ht_tpname = NULL;
3454 : :
3455 : : int r;
3456 : :
3457 : : /* Prepare slots that need special handling.
3458 : : * Keep in mind that a slot can be given multiple times:
3459 : : * if that would cause trouble (leaks, UB, ...), raise an exception.
3460 : : */
3461 : :
3462 : : const PyType_Slot *slot;
3463 : 115793 : Py_ssize_t nmembers = 0;
3464 : : Py_ssize_t weaklistoffset, dictoffset, vectorcalloffset;
3465 : : char *res_start;
3466 : :
3467 : 115793 : nmembers = weaklistoffset = dictoffset = vectorcalloffset = 0;
3468 [ + + ]: 843433 : for (slot = spec->slots; slot->slot; slot++) {
3469 [ + - ]: 727642 : if (slot->slot < 0
3470 [ - + ]: 727642 : || (size_t)slot->slot >= Py_ARRAY_LENGTH(pyslot_offsets)) {
3471 : 0 : PyErr_SetString(PyExc_RuntimeError, "invalid slot offset");
3472 : 0 : goto finally;
3473 : : }
3474 [ + + + ]: 727642 : switch (slot->slot) {
3475 : 84993 : case Py_tp_members:
3476 [ + + ]: 84993 : if (nmembers != 0) {
3477 : 1 : PyErr_SetString(
3478 : : PyExc_SystemError,
3479 : : "Multiple Py_tp_members slots are not supported.");
3480 : 1 : goto finally;
3481 : : }
3482 [ + + ]: 402774 : for (const PyMemberDef *memb = slot->pfunc; memb->name != NULL; memb++) {
3483 : 317782 : nmembers++;
3484 [ + + ]: 317782 : if (strcmp(memb->name, "__weaklistoffset__") == 0) {
3485 : : // The PyMemberDef must be a Py_ssize_t and readonly
3486 : : assert(memb->type == T_PYSSIZET);
3487 : : assert(memb->flags == READONLY);
3488 : 22806 : weaklistoffset = memb->offset;
3489 : : }
3490 [ + + ]: 317782 : if (strcmp(memb->name, "__dictoffset__") == 0) {
3491 : : // The PyMemberDef must be a Py_ssize_t and readonly
3492 : : assert(memb->type == T_PYSSIZET);
3493 : : assert(memb->flags == READONLY);
3494 : 7763 : dictoffset = memb->offset;
3495 : : }
3496 [ + + ]: 317782 : if (strcmp(memb->name, "__vectorcalloffset__") == 0) {
3497 : : // The PyMemberDef must be a Py_ssize_t and readonly
3498 : : assert(memb->type == T_PYSSIZET);
3499 : : assert(memb->flags == READONLY);
3500 : 5962 : vectorcalloffset = memb->offset;
3501 : : }
3502 : : }
3503 : 84992 : break;
3504 : 82551 : case Py_tp_doc:
3505 : : /* For the docstring slot, which usually points to a static string
3506 : : literal, we need to make a copy */
3507 [ + + ]: 82551 : if (tp_doc != NULL) {
3508 : 1 : PyErr_SetString(
3509 : : PyExc_SystemError,
3510 : : "Multiple Py_tp_doc slots are not supported.");
3511 : 1 : goto finally;
3512 : : }
3513 [ + + ]: 82550 : if (slot->pfunc == NULL) {
3514 : 1189 : PyObject_Free(tp_doc);
3515 : 1189 : tp_doc = NULL;
3516 : : }
3517 : : else {
3518 : 81361 : size_t len = strlen(slot->pfunc)+1;
3519 : 81361 : tp_doc = PyObject_Malloc(len);
3520 [ - + ]: 81361 : if (tp_doc == NULL) {
3521 : : PyErr_NoMemory();
3522 : 0 : goto finally;
3523 : : }
3524 : 81361 : memcpy(tp_doc, slot->pfunc, len);
3525 : : }
3526 : 82550 : break;
3527 : : }
3528 : : }
3529 : :
3530 : : /* Prepare the type name and qualname */
3531 : :
3532 [ - + ]: 115791 : if (spec->name == NULL) {
3533 : 0 : PyErr_SetString(PyExc_SystemError,
3534 : : "Type spec does not define the name field.");
3535 : 0 : goto finally;
3536 : : }
3537 : :
3538 : 115791 : const char *s = strrchr(spec->name, '.');
3539 [ - + ]: 115791 : if (s == NULL) {
3540 : 0 : s = spec->name;
3541 : : }
3542 : : else {
3543 : 115791 : s++;
3544 : : }
3545 : :
3546 : 115791 : ht_name = PyUnicode_FromString(s);
3547 [ - + ]: 115791 : if (!ht_name) {
3548 : 0 : goto finally;
3549 : : }
3550 : :
3551 : : /* Copy spec->name to a buffer we own.
3552 : : *
3553 : : * Unfortunately, we can't use tp_name directly (with some
3554 : : * flag saying that it should be deallocated with the type),
3555 : : * because tp_name is public API and may be set independently
3556 : : * of any such flag.
3557 : : * So, we use a separate buffer, _ht_tpname, that's always
3558 : : * deallocated with the type (if it's non-NULL).
3559 : : */
3560 : 115791 : Py_ssize_t name_buf_len = strlen(spec->name) + 1;
3561 : 115791 : _ht_tpname = PyMem_Malloc(name_buf_len);
3562 [ - + ]: 115791 : if (_ht_tpname == NULL) {
3563 : 0 : goto finally;
3564 : : }
3565 : 115791 : memcpy(_ht_tpname, spec->name, name_buf_len);
3566 : :
3567 : : /* Get a tuple of bases.
3568 : : * bases is a strong reference (unlike bases_in).
3569 : : */
3570 : 115791 : bases = get_bases_tuple(bases_in, spec);
3571 [ - + ]: 115791 : if (!bases) {
3572 : 0 : goto finally;
3573 : : }
3574 : :
3575 : : /* Calculate the metaclass */
3576 : :
3577 [ + + ]: 115791 : if (!metaclass) {
3578 : 113449 : metaclass = &PyType_Type;
3579 : : }
3580 : 115791 : metaclass = _PyType_CalculateMetaclass(metaclass, bases);
3581 [ + + ]: 115791 : if (metaclass == NULL) {
3582 : 1 : goto finally;
3583 : : }
3584 [ - + ]: 115790 : if (!PyType_Check(metaclass)) {
3585 : 0 : PyErr_Format(PyExc_TypeError,
3586 : : "Metaclass '%R' is not a subclass of 'type'.",
3587 : : metaclass);
3588 : 0 : goto finally;
3589 : : }
3590 [ + + ]: 115790 : if (metaclass->tp_new != PyType_Type.tp_new) {
3591 : 1 : PyErr_SetString(PyExc_TypeError,
3592 : : "Metaclasses with custom tp_new are not supported.");
3593 : 1 : goto finally;
3594 : : }
3595 : :
3596 : : /* Calculate best base, and check that all bases are type objects */
3597 : 115789 : PyTypeObject *base = best_base(bases); // borrowed ref
3598 [ - + ]: 115789 : if (base == NULL) {
3599 : 0 : goto finally;
3600 : : }
3601 : : // best_base should check Py_TPFLAGS_BASETYPE & raise a proper exception,
3602 : : // here we just check its work
3603 : : assert(_PyType_HasFeature(base, Py_TPFLAGS_BASETYPE));
3604 : :
3605 : : /* Allocate the new type
3606 : : *
3607 : : * Between here and PyType_Ready, we should limit:
3608 : : * - calls to Python code
3609 : : * - raising exceptions
3610 : : * - memory allocations
3611 : : */
3612 : :
3613 : 115789 : res = (PyHeapTypeObject*)metaclass->tp_alloc(metaclass, nmembers);
3614 [ - + ]: 115789 : if (res == NULL) {
3615 : 0 : goto finally;
3616 : : }
3617 : 115789 : res_start = (char*)res;
3618 : :
3619 : 115789 : type = &res->ht_type;
3620 : : /* The flags must be initialized early, before the GC traverses us */
3621 : 115789 : type->tp_flags = spec->flags | Py_TPFLAGS_HEAPTYPE;
3622 : :
3623 : 115789 : res->ht_module = Py_XNewRef(module);
3624 : :
3625 : : /* Initialize essential fields */
3626 : :
3627 : 115789 : type->tp_as_async = &res->as_async;
3628 : 115789 : type->tp_as_number = &res->as_number;
3629 : 115789 : type->tp_as_sequence = &res->as_sequence;
3630 : 115789 : type->tp_as_mapping = &res->as_mapping;
3631 : 115789 : type->tp_as_buffer = &res->as_buffer;
3632 : :
3633 : : /* Set slots we have prepared */
3634 : :
3635 : 115789 : type->tp_base = (PyTypeObject *)Py_NewRef(base);
3636 : 115789 : type->tp_bases = bases;
3637 : 115789 : bases = NULL; // We give our reference to bases to the type
3638 : :
3639 : 115789 : type->tp_doc = tp_doc;
3640 : 115789 : tp_doc = NULL; // Give ownership of the allocated memory to the type
3641 : :
3642 : 115789 : res->ht_qualname = Py_NewRef(ht_name);
3643 : 115789 : res->ht_name = ht_name;
3644 : 115789 : ht_name = NULL; // Give our reference to to the type
3645 : :
3646 : 115789 : type->tp_name = _ht_tpname;
3647 : 115789 : res->_ht_tpname = _ht_tpname;
3648 : 115789 : _ht_tpname = NULL; // Give ownership to to the type
3649 : :
3650 : : /* Copy the sizes */
3651 : :
3652 : 115789 : type->tp_basicsize = spec->basicsize;
3653 : 115789 : type->tp_itemsize = spec->itemsize;
3654 : :
3655 : : /* Copy all the ordinary slots */
3656 : :
3657 [ + + ]: 843427 : for (slot = spec->slots; slot->slot; slot++) {
3658 [ + + + ]: 727638 : switch (slot->slot) {
3659 : 82572 : case Py_tp_base:
3660 : : case Py_tp_bases:
3661 : : case Py_tp_doc:
3662 : : /* Processed above */
3663 : 82572 : break;
3664 : 84991 : case Py_tp_members:
3665 : : {
3666 : : /* Move the slots to the heap type itself */
3667 : 84991 : size_t len = Py_TYPE(type)->tp_itemsize * nmembers;
3668 : 84991 : memcpy(_PyHeapType_GET_MEMBERS(res), slot->pfunc, len);
3669 : 84991 : type->tp_members = _PyHeapType_GET_MEMBERS(res);
3670 : : }
3671 : 84991 : break;
3672 : 560075 : default:
3673 : : {
3674 : : /* Copy other slots directly */
3675 : 560075 : PySlot_Offset slotoffsets = pyslot_offsets[slot->slot];
3676 : 560075 : short slot_offset = slotoffsets.slot_offset;
3677 [ + + ]: 560075 : if (slotoffsets.subslot_offset == -1) {
3678 : 542556 : *(void**)((char*)res_start + slot_offset) = slot->pfunc;
3679 : : }
3680 : : else {
3681 : 17519 : void *procs = *(void**)((char*)res_start + slot_offset);
3682 : 17519 : short subslot_offset = slotoffsets.subslot_offset;
3683 : 17519 : *(void**)((char*)procs + subslot_offset) = slot->pfunc;
3684 : : }
3685 : : }
3686 : 560075 : break;
3687 : : }
3688 : : }
3689 [ + + ]: 115789 : if (type->tp_dealloc == NULL) {
3690 : : /* It's a heap type, so needs the heap types' dealloc.
3691 : : subtype_dealloc will call the base type's tp_dealloc, if
3692 : : necessary. */
3693 : 10227 : type->tp_dealloc = subtype_dealloc;
3694 : : }
3695 : :
3696 : : /* Set up offsets */
3697 : :
3698 : 115789 : type->tp_vectorcall_offset = vectorcalloffset;
3699 : 115789 : type->tp_weaklistoffset = weaklistoffset;
3700 : 115789 : type->tp_dictoffset = dictoffset;
3701 : :
3702 : : /* Ready the type (which includes inheritance).
3703 : : *
3704 : : * After this call we should generally only touch up what's
3705 : : * accessible to Python code, like __dict__.
3706 : : */
3707 : :
3708 [ - + ]: 115789 : if (PyType_Ready(type) < 0) {
3709 : 0 : goto finally;
3710 : : }
3711 : :
3712 [ - + ]: 115789 : if (!check_basicsize_includes_size_and_offsets(type)) {
3713 : 0 : goto finally;
3714 : : }
3715 : :
3716 [ + + ]: 115789 : if (type->tp_flags & Py_TPFLAGS_MANAGED_DICT) {
3717 : 1 : res->ht_cached_keys = _PyDict_NewKeysForClass();
3718 : : }
3719 : :
3720 [ + + ]: 115789 : if (type->tp_doc) {
3721 : 81360 : PyObject *__doc__ = PyUnicode_FromString(_PyType_DocWithoutSignature(type->tp_name, type->tp_doc));
3722 [ - + ]: 81360 : if (!__doc__) {
3723 : 0 : goto finally;
3724 : : }
3725 : 81360 : r = PyDict_SetItem(type->tp_dict, &_Py_ID(__doc__), __doc__);
3726 : 81360 : Py_DECREF(__doc__);
3727 [ - + ]: 81360 : if (r < 0) {
3728 : 0 : goto finally;
3729 : : }
3730 : : }
3731 : :
3732 [ + + ]: 115789 : if (weaklistoffset) {
3733 [ - + ]: 22806 : if (PyDict_DelItem((PyObject *)type->tp_dict, &_Py_ID(__weaklistoffset__)) < 0) {
3734 : 0 : goto finally;
3735 : : }
3736 : : }
3737 [ + + ]: 115789 : if (dictoffset) {
3738 [ - + ]: 7763 : if (PyDict_DelItem((PyObject *)type->tp_dict, &_Py_ID(__dictoffset__)) < 0) {
3739 : 0 : goto finally;
3740 : : }
3741 : : }
3742 : :
3743 : : /* Set type.__module__ */
3744 : 115789 : r = PyDict_Contains(type->tp_dict, &_Py_ID(__module__));
3745 [ - + ]: 115789 : if (r < 0) {
3746 : 0 : goto finally;
3747 : : }
3748 [ - + ]: 115789 : if (r == 0) {
3749 : 115789 : s = strrchr(spec->name, '.');
3750 [ + - ]: 115789 : if (s != NULL) {
3751 : 115789 : PyObject *modname = PyUnicode_FromStringAndSize(
3752 : 115789 : spec->name, (Py_ssize_t)(s - spec->name));
3753 [ - + ]: 115789 : if (modname == NULL) {
3754 : 0 : goto finally;
3755 : : }
3756 : 115789 : r = PyDict_SetItem(type->tp_dict, &_Py_ID(__module__), modname);
3757 : 115789 : Py_DECREF(modname);
3758 [ - + ]: 115789 : if (r != 0) {
3759 : 0 : goto finally;
3760 : : }
3761 : : }
3762 : : else {
3763 [ # # ]: 0 : if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
3764 : : "builtin type %.200s has no __module__ attribute",
3765 : : spec->name))
3766 : 0 : goto finally;
3767 : : }
3768 : : }
3769 : :
3770 : : assert(_PyType_CheckConsistency(type));
3771 : :
3772 : 0 : finally:
3773 [ + + ]: 115793 : if (PyErr_Occurred()) {
3774 [ - + ]: 4 : Py_CLEAR(res);
3775 : : }
3776 : 115793 : Py_XDECREF(bases);
3777 : 115793 : PyObject_Free(tp_doc);
3778 : 115793 : Py_XDECREF(ht_name);
3779 : 115793 : PyMem_Free(_ht_tpname);
3780 : 115793 : return (PyObject*)res;
3781 : : }
3782 : :
3783 : : PyObject *
3784 : 54862 : PyType_FromModuleAndSpec(PyObject *module, PyType_Spec *spec, PyObject *bases)
3785 : : {
3786 : 54862 : return PyType_FromMetaclass(NULL, module, spec, bases);
3787 : : }
3788 : :
3789 : : PyObject *
3790 : 35087 : PyType_FromSpecWithBases(PyType_Spec *spec, PyObject *bases)
3791 : : {
3792 : 35087 : return PyType_FromMetaclass(NULL, NULL, spec, bases);
3793 : : }
3794 : :
3795 : : PyObject *
3796 : 23502 : PyType_FromSpec(PyType_Spec *spec)
3797 : : {
3798 : 23502 : return PyType_FromMetaclass(NULL, NULL, spec, NULL);
3799 : : }
3800 : :
3801 : : PyObject *
3802 : 4 : PyType_GetName(PyTypeObject *type)
3803 : : {
3804 : 4 : return type_name(type, NULL);
3805 : : }
3806 : :
3807 : : PyObject *
3808 : 610 : PyType_GetQualName(PyTypeObject *type)
3809 : : {
3810 : 610 : return type_qualname(type, NULL);
3811 : : }
3812 : :
3813 : : void *
3814 : 5545506 : PyType_GetSlot(PyTypeObject *type, int slot)
3815 : : {
3816 : : void *parent_slot;
3817 : 5545506 : int slots_len = Py_ARRAY_LENGTH(pyslot_offsets);
3818 : :
3819 [ + + - + ]: 5545506 : if (slot <= 0 || slot >= slots_len) {
3820 : 1 : PyErr_BadInternalCall();
3821 : 1 : return NULL;
3822 : : }
3823 : :
3824 : 5545505 : parent_slot = *(void**)((char*)type + pyslot_offsets[slot].slot_offset);
3825 [ + + ]: 5545505 : if (parent_slot == NULL) {
3826 : 3 : return NULL;
3827 : : }
3828 : : /* Return slot directly if we have no sub slot. */
3829 [ + + ]: 5545502 : if (pyslot_offsets[slot].subslot_offset == -1) {
3830 : 5545501 : return parent_slot;
3831 : : }
3832 : 1 : return *(void**)((char*)parent_slot + pyslot_offsets[slot].subslot_offset);
3833 : : }
3834 : :
3835 : : PyObject *
3836 : 14351156 : PyType_GetModule(PyTypeObject *type)
3837 : : {
3838 : : assert(PyType_Check(type));
3839 [ - + ]: 14351156 : if (!_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE)) {
3840 : 0 : PyErr_Format(
3841 : : PyExc_TypeError,
3842 : : "PyType_GetModule: Type '%s' is not a heap type",
3843 : : type->tp_name);
3844 : 0 : return NULL;
3845 : : }
3846 : :
3847 : 14351156 : PyHeapTypeObject* et = (PyHeapTypeObject*)type;
3848 [ - + ]: 14351156 : if (!et->ht_module) {
3849 : 0 : PyErr_Format(
3850 : : PyExc_TypeError,
3851 : : "PyType_GetModule: Type '%s' has no associated module",
3852 : : type->tp_name);
3853 : 0 : return NULL;
3854 : : }
3855 : 14351156 : return et->ht_module;
3856 : :
3857 : : }
3858 : :
3859 : : void *
3860 : 331546 : PyType_GetModuleState(PyTypeObject *type)
3861 : : {
3862 : 331546 : PyObject *m = PyType_GetModule(type);
3863 [ - + ]: 331546 : if (m == NULL) {
3864 : 0 : return NULL;
3865 : : }
3866 : 331546 : return _PyModule_GetState(m);
3867 : : }
3868 : :
3869 : :
3870 : : /* Get the module of the first superclass where the module has the
3871 : : * given PyModuleDef.
3872 : : */
3873 : : PyObject *
3874 : 10145425 : PyType_GetModuleByDef(PyTypeObject *type, PyModuleDef *def)
3875 : : {
3876 : : assert(PyType_Check(type));
3877 : :
3878 : 10145425 : PyObject *mro = type->tp_mro;
3879 : : // The type must be ready
3880 : : assert(mro != NULL);
3881 : : assert(PyTuple_Check(mro));
3882 : : // mro_invoke() ensures that the type MRO cannot be empty, so we don't have
3883 : : // to check i < PyTuple_GET_SIZE(mro) at the first loop iteration.
3884 : : assert(PyTuple_GET_SIZE(mro) >= 1);
3885 : :
3886 : 10145425 : Py_ssize_t n = PyTuple_GET_SIZE(mro);
3887 [ + + ]: 10183858 : for (Py_ssize_t i = 0; i < n; i++) {
3888 : 10183857 : PyObject *super = PyTuple_GET_ITEM(mro, i);
3889 [ + + ]: 10183857 : if(!_PyType_HasFeature((PyTypeObject *)super, Py_TPFLAGS_HEAPTYPE)) {
3890 : : // Static types in the MRO need to be skipped
3891 : 1 : continue;
3892 : : }
3893 : :
3894 : 10183856 : PyHeapTypeObject *ht = (PyHeapTypeObject*)super;
3895 : 10183856 : PyObject *module = ht->ht_module;
3896 [ + + + + ]: 10183856 : if (module && _PyModule_GetDef(module) == def) {
3897 : 10145424 : return module;
3898 : : }
3899 : : }
3900 : :
3901 : 1 : PyErr_Format(
3902 : : PyExc_TypeError,
3903 : : "PyType_GetModuleByDef: No superclass of '%s' has the given module",
3904 : : type->tp_name);
3905 : 1 : return NULL;
3906 : : }
3907 : :
3908 : :
3909 : : /* Internal API to look for a name through the MRO, bypassing the method cache.
3910 : : This returns a borrowed reference, and might set an exception.
3911 : : 'error' is set to: -1: error with exception; 1: error without exception; 0: ok */
3912 : : static PyObject *
3913 : 155502324 : find_name_in_mro(PyTypeObject *type, PyObject *name, int *error)
3914 : : {
3915 : : Py_hash_t hash;
3916 [ + + ]: 155502324 : if (!PyUnicode_CheckExact(name) ||
3917 [ + + ]: 155502318 : (hash = _PyASCIIObject_CAST(name)->hash) == -1)
3918 : : {
3919 : 6360230 : hash = PyObject_Hash(name);
3920 [ - + ]: 6360230 : if (hash == -1) {
3921 : 0 : *error = -1;
3922 : 0 : return NULL;
3923 : : }
3924 : : }
3925 : :
3926 : : /* Look in tp_dict of types in MRO */
3927 : 155502324 : PyObject *mro = type->tp_mro;
3928 [ + + ]: 155502324 : if (mro == NULL) {
3929 [ + + ]: 3 : if ((type->tp_flags & Py_TPFLAGS_READYING) == 0) {
3930 [ - + ]: 1 : if (PyType_Ready(type) < 0) {
3931 : 0 : *error = -1;
3932 : 0 : return NULL;
3933 : : }
3934 : 1 : mro = type->tp_mro;
3935 : : }
3936 [ + + ]: 3 : if (mro == NULL) {
3937 : 2 : *error = 1;
3938 : 2 : return NULL;
3939 : : }
3940 : : }
3941 : :
3942 : 155502322 : PyObject *res = NULL;
3943 : : /* Keep a strong reference to mro because type->tp_mro can be replaced
3944 : : during dict lookup, e.g. when comparing to non-string keys. */
3945 : 155502322 : Py_INCREF(mro);
3946 : 155502322 : Py_ssize_t n = PyTuple_GET_SIZE(mro);
3947 [ + + ]: 570553613 : for (Py_ssize_t i = 0; i < n; i++) {
3948 : 467314224 : PyObject *base = PyTuple_GET_ITEM(mro, i);
3949 : 467314224 : PyObject *dict = _PyType_CAST(base)->tp_dict;
3950 : : assert(dict && PyDict_Check(dict));
3951 : 467314224 : res = _PyDict_GetItem_KnownHash(dict, name, hash);
3952 [ + + ]: 467314224 : if (res != NULL) {
3953 : 52262933 : break;
3954 : : }
3955 [ - + ]: 415051291 : if (PyErr_Occurred()) {
3956 : 0 : *error = -1;
3957 : 0 : goto done;
3958 : : }
3959 : : }
3960 : 155502322 : *error = 0;
3961 : 155502322 : done:
3962 : 155502322 : Py_DECREF(mro);
3963 : 155502322 : return res;
3964 : : }
3965 : :
3966 : : /* Internal API to look for a name through the MRO.
3967 : : This returns a borrowed reference, and doesn't set an exception! */
3968 : : PyObject *
3969 : 449312092 : _PyType_Lookup(PyTypeObject *type, PyObject *name)
3970 : : {
3971 : : PyObject *res;
3972 : : int error;
3973 : :
3974 : 449312092 : unsigned int h = MCACHE_HASH_METHOD(type, name);
3975 : 449312092 : struct type_cache *cache = get_type_cache();
3976 : 449312092 : struct type_cache_entry *entry = &cache->hashtable[h];
3977 [ + + ]: 449312092 : if (entry->version == type->tp_version_tag &&
3978 [ + + ]: 415407337 : entry->name == name) {
3979 : : #if MCACHE_STATS
3980 : : cache->hits++;
3981 : : #endif
3982 : : assert(_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG));
3983 : 406693350 : return entry->value;
3984 : : }
3985 : :
3986 : : /* We may end up clearing live exceptions below, so make sure it's ours. */
3987 : : assert(!PyErr_Occurred());
3988 : :
3989 : 42618742 : res = find_name_in_mro(type, name, &error);
3990 : : /* Only put NULL results into cache if there was no error. */
3991 [ + + ]: 42618742 : if (error) {
3992 : : /* It's not ideal to clear the error condition,
3993 : : but this function is documented as not setting
3994 : : an exception, and I don't want to change that.
3995 : : E.g., when PyType_Ready() can't proceed, it won't
3996 : : set the "ready" flag, so future attempts to ready
3997 : : the same type will call it again -- hopefully
3998 : : in a context that propagates the exception out.
3999 : : */
4000 [ - + ]: 2 : if (error == -1) {
4001 : 0 : PyErr_Clear();
4002 : : }
4003 : 2 : return NULL;
4004 : : }
4005 : :
4006 [ + + + - : 42618740 : if (MCACHE_CACHEABLE_NAME(name) && assign_version_tag(cache, type)) {
+ + + - ]
4007 : 42618725 : h = MCACHE_HASH_METHOD(type, name);
4008 : 42618725 : struct type_cache_entry *entry = &cache->hashtable[h];
4009 : 42618725 : entry->version = type->tp_version_tag;
4010 : 42618725 : entry->value = res; /* borrowed */
4011 : : assert(_PyASCIIObject_CAST(name)->hash != -1);
4012 : : #if MCACHE_STATS
4013 : : if (entry->name != Py_None && entry->name != name) {
4014 : : cache->collisions++;
4015 : : }
4016 : : else {
4017 : : cache->misses++;
4018 : : }
4019 : : #endif
4020 : : assert(_PyType_HasFeature(type, Py_TPFLAGS_VALID_VERSION_TAG));
4021 : 42618725 : Py_SETREF(entry->name, Py_NewRef(name));
4022 : : }
4023 : 42618740 : return res;
4024 : : }
4025 : :
4026 : : PyObject *
4027 : 0 : _PyType_LookupId(PyTypeObject *type, _Py_Identifier *name)
4028 : : {
4029 : : PyObject *oname;
4030 : 0 : oname = _PyUnicode_FromId(name); /* borrowed */
4031 [ # # ]: 0 : if (oname == NULL)
4032 : 0 : return NULL;
4033 : 0 : return _PyType_Lookup(type, oname);
4034 : : }
4035 : :
4036 : : /* Check if the "readied" PyUnicode name
4037 : : is a double-underscore special name. */
4038 : : static int
4039 : 9938340 : is_dunder_name(PyObject *name)
4040 : : {
4041 : 9938340 : Py_ssize_t length = PyUnicode_GET_LENGTH(name);
4042 : 9938340 : int kind = PyUnicode_KIND(name);
4043 : : /* Special names contain at least "__x__" and are always ASCII. */
4044 [ + + + + ]: 9938340 : if (length > 4 && kind == PyUnicode_1BYTE_KIND) {
4045 : 1483268 : const Py_UCS1 *characters = PyUnicode_1BYTE_DATA(name);
4046 : : return (
4047 [ + + + + ]: 2299956 : ((characters[length-2] == '_') && (characters[length-1] == '_')) &&
4048 [ + - + - ]: 816688 : ((characters[0] == '_') && (characters[1] == '_'))
4049 : : );
4050 : : }
4051 : 8455072 : return 0;
4052 : : }
4053 : :
4054 : : /* This is similar to PyObject_GenericGetAttr(),
4055 : : but uses _PyType_Lookup() instead of just looking in type->tp_dict. */
4056 : : static PyObject *
4057 : 40456369 : type_getattro(PyTypeObject *type, PyObject *name)
4058 : : {
4059 : 40456369 : PyTypeObject *metatype = Py_TYPE(type);
4060 : : PyObject *meta_attribute, *attribute;
4061 : : descrgetfunc meta_get;
4062 : : PyObject* res;
4063 : :
4064 [ + + ]: 40456369 : if (!PyUnicode_Check(name)) {
4065 : 1 : PyErr_Format(PyExc_TypeError,
4066 : : "attribute name must be string, not '%.200s'",
4067 : 1 : Py_TYPE(name)->tp_name);
4068 : 1 : return NULL;
4069 : : }
4070 : :
4071 : : /* Initialize this type (we'll assume the metatype is initialized) */
4072 [ + + ]: 40456368 : if (!_PyType_IsReady(type)) {
4073 [ - + ]: 1 : if (PyType_Ready(type) < 0)
4074 : 0 : return NULL;
4075 : : }
4076 : :
4077 : : /* No readable descriptor found yet */
4078 : 40456368 : meta_get = NULL;
4079 : :
4080 : : /* Look for the attribute in the metatype */
4081 : 40456368 : meta_attribute = _PyType_Lookup(metatype, name);
4082 : :
4083 [ + + ]: 40456368 : if (meta_attribute != NULL) {
4084 : 23185046 : Py_INCREF(meta_attribute);
4085 : 23185046 : meta_get = Py_TYPE(meta_attribute)->tp_descr_get;
4086 : :
4087 [ + + + + ]: 23185046 : if (meta_get != NULL && PyDescr_IsData(meta_attribute)) {
4088 : : /* Data descriptors implement tp_descr_set to intercept
4089 : : * writes. Assume the attribute is not overridden in
4090 : : * type's tp_dict (and bases): call the descriptor now.
4091 : : */
4092 : 6640565 : res = meta_get(meta_attribute, (PyObject *)type,
4093 : : (PyObject *)metatype);
4094 : 6640565 : Py_DECREF(meta_attribute);
4095 : 6640565 : return res;
4096 : : }
4097 : : }
4098 : :
4099 : : /* No data descriptor found on metatype. Look in tp_dict of this
4100 : : * type and its bases */
4101 : 33815803 : attribute = _PyType_Lookup(type, name);
4102 [ + + ]: 33815803 : if (attribute != NULL) {
4103 : : /* Implement descriptor functionality, if any */
4104 : 33350599 : Py_INCREF(attribute);
4105 : 33350599 : descrgetfunc local_get = Py_TYPE(attribute)->tp_descr_get;
4106 : :
4107 : 33350599 : Py_XDECREF(meta_attribute);
4108 : :
4109 [ + + ]: 33350599 : if (local_get != NULL) {
4110 : : /* NULL 2nd argument indicates the descriptor was
4111 : : * found on the target object itself (or a base) */
4112 : 19146707 : res = local_get(attribute, (PyObject *)NULL,
4113 : : (PyObject *)type);
4114 : 19146707 : Py_DECREF(attribute);
4115 : 19146707 : return res;
4116 : : }
4117 : :
4118 : 14203892 : return attribute;
4119 : : }
4120 : :
4121 : : /* No attribute found in local __dict__ (or bases): use the
4122 : : * descriptor from the metatype, if any */
4123 [ + + ]: 465204 : if (meta_get != NULL) {
4124 : : PyObject *res;
4125 : 256514 : res = meta_get(meta_attribute, (PyObject *)type,
4126 : : (PyObject *)metatype);
4127 : 256514 : Py_DECREF(meta_attribute);
4128 : 256514 : return res;
4129 : : }
4130 : :
4131 : : /* If an ordinary attribute was found on the metatype, return it now */
4132 [ + + ]: 208690 : if (meta_attribute != NULL) {
4133 : 6 : return meta_attribute;
4134 : : }
4135 : :
4136 : : /* Give up */
4137 : 208684 : PyErr_Format(PyExc_AttributeError,
4138 : : "type object '%.50s' has no attribute '%U'",
4139 : : type->tp_name, name);
4140 : 208684 : return NULL;
4141 : : }
4142 : :
4143 : : static int
4144 : 9938973 : type_setattro(PyTypeObject *type, PyObject *name, PyObject *value)
4145 : : {
4146 : : int res;
4147 [ + + ]: 9938973 : if (type->tp_flags & Py_TPFLAGS_IMMUTABLETYPE) {
4148 : 585 : PyErr_Format(
4149 : : PyExc_TypeError,
4150 : : "cannot set %R attribute of immutable type '%s'",
4151 : : name, type->tp_name);
4152 : 585 : return -1;
4153 : : }
4154 [ + + ]: 9938388 : if (PyUnicode_Check(name)) {
4155 [ + - ]: 9938387 : if (PyUnicode_CheckExact(name)) {
4156 [ - + ]: 9938387 : if (PyUnicode_READY(name) == -1)
4157 : 0 : return -1;
4158 : 9938387 : Py_INCREF(name);
4159 : : }
4160 : : else {
4161 : 0 : name = _PyUnicode_Copy(name);
4162 [ # # ]: 0 : if (name == NULL)
4163 : 0 : return -1;
4164 : : }
4165 : : /* bpo-40521: Interned strings are shared by all subinterpreters */
4166 [ + + ]: 9938387 : if (!PyUnicode_CHECK_INTERNED(name)) {
4167 : 2 : PyUnicode_InternInPlace(&name);
4168 [ - + ]: 2 : if (!PyUnicode_CHECK_INTERNED(name)) {
4169 : 0 : PyErr_SetString(PyExc_MemoryError,
4170 : : "Out of memory interning an attribute name");
4171 : 0 : Py_DECREF(name);
4172 : 0 : return -1;
4173 : : }
4174 : : }
4175 : : }
4176 : : else {
4177 : : /* Will fail in _PyObject_GenericSetAttrWithDict. */
4178 : 1 : Py_INCREF(name);
4179 : : }
4180 : 9938388 : res = _PyObject_GenericSetAttrWithDict((PyObject *)type, name, value, NULL);
4181 [ + + ]: 9938388 : if (res == 0) {
4182 : : /* Clear the VALID_VERSION flag of 'type' and all its
4183 : : subclasses. This could possibly be unified with the
4184 : : update_subclasses() recursion in update_slot(), but carefully:
4185 : : they each have their own conditions on which to stop
4186 : : recursing into subclasses. */
4187 : 9938340 : PyType_Modified(type);
4188 : :
4189 [ + + ]: 9938340 : if (is_dunder_name(name)) {
4190 : 816688 : res = update_slot(type, name);
4191 : : }
4192 : : assert(_PyType_CheckConsistency(type));
4193 : : }
4194 : 9938388 : Py_DECREF(name);
4195 : 9938388 : return res;
4196 : : }
4197 : :
4198 : : extern void
4199 : : _PyDictKeys_DecRef(PyDictKeysObject *keys);
4200 : :
4201 : :
4202 : : static void
4203 : 1881591 : type_dealloc_common(PyTypeObject *type)
4204 : : {
4205 [ + - ]: 1881591 : if (type->tp_bases != NULL) {
4206 : : PyObject *tp, *val, *tb;
4207 : 1881591 : PyErr_Fetch(&tp, &val, &tb);
4208 : 1881591 : remove_all_subclasses(type, type->tp_bases);
4209 : 1881591 : PyErr_Restore(tp, val, tb);
4210 : : }
4211 : 1881591 : }
4212 : :
4213 : :
4214 : : void
4215 : 588244 : _PyStaticType_Dealloc(PyTypeObject *type)
4216 : : {
4217 : : // If a type still has subtypes, it cannot be deallocated.
4218 : : // A subtype can inherit attributes and methods of its parent type,
4219 : : // and a type must no longer be used once it's deallocated.
4220 [ + + ]: 588244 : if (type->tp_subclasses != NULL) {
4221 : 9703 : return;
4222 : : }
4223 : :
4224 : 578541 : type_dealloc_common(type);
4225 : :
4226 [ + - ]: 578541 : Py_CLEAR(type->tp_dict);
4227 [ + - ]: 578541 : Py_CLEAR(type->tp_bases);
4228 [ + - ]: 578541 : Py_CLEAR(type->tp_mro);
4229 [ - + ]: 578541 : Py_CLEAR(type->tp_cache);
4230 : : // type->tp_subclasses is NULL
4231 : :
4232 : : // PyObject_ClearWeakRefs() raises an exception if Py_REFCNT() != 0
4233 [ - + ]: 578541 : if (Py_REFCNT(type) == 0) {
4234 : 0 : PyObject_ClearWeakRefs((PyObject *)type);
4235 : : }
4236 : :
4237 : 578541 : type->tp_flags &= ~Py_TPFLAGS_READY;
4238 : : }
4239 : :
4240 : :
4241 : : static void
4242 : 1303050 : type_dealloc(PyTypeObject *type)
4243 : : {
4244 : : // Assert this is a heap-allocated type object
4245 : : _PyObject_ASSERT((PyObject *)type, type->tp_flags & Py_TPFLAGS_HEAPTYPE);
4246 : :
4247 : 1303050 : _PyObject_GC_UNTRACK(type);
4248 : :
4249 : 1303050 : type_dealloc_common(type);
4250 : :
4251 : : // PyObject_ClearWeakRefs() raises an exception if Py_REFCNT() != 0
4252 : : assert(Py_REFCNT(type) == 0);
4253 : 1303050 : PyObject_ClearWeakRefs((PyObject *)type);
4254 : :
4255 : 1303050 : Py_XDECREF(type->tp_base);
4256 : 1303050 : Py_XDECREF(type->tp_dict);
4257 : 1303050 : Py_XDECREF(type->tp_bases);
4258 : 1303050 : Py_XDECREF(type->tp_mro);
4259 : 1303050 : Py_XDECREF(type->tp_cache);
4260 : 1303050 : Py_XDECREF(type->tp_subclasses);
4261 : :
4262 : : /* A type's tp_doc is heap allocated, unlike the tp_doc slots
4263 : : * of most other objects. It's okay to cast it to char *.
4264 : : */
4265 : 1303050 : PyObject_Free((char *)type->tp_doc);
4266 : :
4267 : 1303050 : PyHeapTypeObject *et = (PyHeapTypeObject *)type;
4268 : 1303050 : Py_XDECREF(et->ht_name);
4269 : 1303050 : Py_XDECREF(et->ht_qualname);
4270 : 1303050 : Py_XDECREF(et->ht_slots);
4271 [ + + ]: 1303050 : if (et->ht_cached_keys) {
4272 : 652903 : _PyDictKeys_DecRef(et->ht_cached_keys);
4273 : : }
4274 : 1303050 : Py_XDECREF(et->ht_module);
4275 : 1303050 : PyMem_Free(et->_ht_tpname);
4276 : 1303050 : Py_TYPE(type)->tp_free((PyObject *)type);
4277 : 1303050 : }
4278 : :
4279 : :
4280 : : PyObject*
4281 : 108141 : _PyType_GetSubclasses(PyTypeObject *self)
4282 : : {
4283 : 108141 : PyObject *list = PyList_New(0);
4284 [ - + ]: 108141 : if (list == NULL) {
4285 : 0 : return NULL;
4286 : : }
4287 : :
4288 : 108141 : PyObject *subclasses = self->tp_subclasses; // borrowed ref
4289 [ + + ]: 108141 : if (subclasses == NULL) {
4290 : 98047 : return list;
4291 : : }
4292 : : assert(PyDict_CheckExact(subclasses));
4293 : : // The loop cannot modify tp_subclasses, there is no need
4294 : : // to hold a strong reference (use a borrowed reference).
4295 : :
4296 : 10094 : Py_ssize_t i = 0;
4297 : : PyObject *ref; // borrowed ref
4298 [ + + ]: 44198 : while (PyDict_Next(subclasses, &i, NULL, &ref)) {
4299 : : assert(PyWeakref_CheckRef(ref));
4300 : 34104 : PyObject *obj = PyWeakref_GET_OBJECT(ref); // borrowed ref
4301 [ + + ]: 34104 : if (obj == Py_None) {
4302 : 3 : continue;
4303 : : }
4304 : : assert(PyType_Check(obj));
4305 : :
4306 [ - + ]: 34101 : if (PyList_Append(list, obj) < 0) {
4307 : 0 : Py_DECREF(list);
4308 : 0 : return NULL;
4309 : : }
4310 : : }
4311 : 10094 : return list;
4312 : : }
4313 : :
4314 : :
4315 : : /*[clinic input]
4316 : : type.__subclasses__
4317 : :
4318 : : Return a list of immediate subclasses.
4319 : : [clinic start generated code]*/
4320 : :
4321 : : static PyObject *
4322 : 108090 : type___subclasses___impl(PyTypeObject *self)
4323 : : /*[clinic end generated code: output=eb5eb54485942819 input=5af66132436f9a7b]*/
4324 : : {
4325 : 108090 : return _PyType_GetSubclasses(self);
4326 : : }
4327 : :
4328 : : static PyObject *
4329 : 916309 : type_prepare(PyObject *self, PyObject *const *args, Py_ssize_t nargs,
4330 : : PyObject *kwnames)
4331 : : {
4332 : 916309 : return PyDict_New();
4333 : : }
4334 : :
4335 : :
4336 : : /*
4337 : : Merge the __dict__ of aclass into dict, and recursively also all
4338 : : the __dict__s of aclass's base classes. The order of merging isn't
4339 : : defined, as it's expected that only the final set of dict keys is
4340 : : interesting.
4341 : : Return 0 on success, -1 on error.
4342 : : */
4343 : :
4344 : : static int
4345 : 61749 : merge_class_dict(PyObject *dict, PyObject *aclass)
4346 : : {
4347 : : PyObject *classdict;
4348 : : PyObject *bases;
4349 : :
4350 : : assert(PyDict_Check(dict));
4351 : : assert(aclass);
4352 : :
4353 : : /* Merge in the type's dict (if any). */
4354 [ - + ]: 61749 : if (_PyObject_LookupAttr(aclass, &_Py_ID(__dict__), &classdict) < 0) {
4355 : 0 : return -1;
4356 : : }
4357 [ + - ]: 61749 : if (classdict != NULL) {
4358 : 61749 : int status = PyDict_Update(dict, classdict);
4359 : 61749 : Py_DECREF(classdict);
4360 [ - + ]: 61749 : if (status < 0)
4361 : 0 : return -1;
4362 : : }
4363 : :
4364 : : /* Recursively merge in the base types' (if any) dicts. */
4365 [ - + ]: 61749 : if (_PyObject_LookupAttr(aclass, &_Py_ID(__bases__), &bases) < 0) {
4366 : 0 : return -1;
4367 : : }
4368 [ + - ]: 61749 : if (bases != NULL) {
4369 : : /* We have no guarantee that bases is a real tuple */
4370 : : Py_ssize_t i, n;
4371 : 61749 : n = PySequence_Size(bases); /* This better be right */
4372 [ - + ]: 61749 : if (n < 0) {
4373 : 0 : Py_DECREF(bases);
4374 : 0 : return -1;
4375 : : }
4376 : : else {
4377 [ + + ]: 104073 : for (i = 0; i < n; i++) {
4378 : : int status;
4379 : 42324 : PyObject *base = PySequence_GetItem(bases, i);
4380 [ - + ]: 42324 : if (base == NULL) {
4381 : 0 : Py_DECREF(bases);
4382 : 0 : return -1;
4383 : : }
4384 : 42324 : status = merge_class_dict(dict, base);
4385 : 42324 : Py_DECREF(base);
4386 [ - + ]: 42324 : if (status < 0) {
4387 : 0 : Py_DECREF(bases);
4388 : 0 : return -1;
4389 : : }
4390 : : }
4391 : : }
4392 : 61749 : Py_DECREF(bases);
4393 : : }
4394 : 61749 : return 0;
4395 : : }
4396 : :
4397 : : /* __dir__ for type objects: returns __dict__ and __bases__.
4398 : : We deliberately don't suck up its __class__, as methods belonging to the
4399 : : metaclass would probably be more confusing than helpful.
4400 : : */
4401 : : /*[clinic input]
4402 : : type.__dir__
4403 : :
4404 : : Specialized __dir__ implementation for types.
4405 : : [clinic start generated code]*/
4406 : :
4407 : : static PyObject *
4408 : 6858 : type___dir___impl(PyTypeObject *self)
4409 : : /*[clinic end generated code: output=69d02fe92c0f15fa input=7733befbec645968]*/
4410 : : {
4411 : 6858 : PyObject *result = NULL;
4412 : 6858 : PyObject *dict = PyDict_New();
4413 : :
4414 [ + - + - ]: 6858 : if (dict != NULL && merge_class_dict(dict, (PyObject *)self) == 0)
4415 : 6858 : result = PyDict_Keys(dict);
4416 : :
4417 : 6858 : Py_XDECREF(dict);
4418 : 6858 : return result;
4419 : : }
4420 : :
4421 : : /*[clinic input]
4422 : : type.__sizeof__
4423 : :
4424 : : Return memory consumption of the type object.
4425 : : [clinic start generated code]*/
4426 : :
4427 : : static PyObject *
4428 : 3 : type___sizeof___impl(PyTypeObject *self)
4429 : : /*[clinic end generated code: output=766f4f16cd3b1854 input=99398f24b9cf45d6]*/
4430 : : {
4431 : : Py_ssize_t size;
4432 [ + + ]: 3 : if (self->tp_flags & Py_TPFLAGS_HEAPTYPE) {
4433 : 2 : PyHeapTypeObject* et = (PyHeapTypeObject*)self;
4434 : 2 : size = sizeof(PyHeapTypeObject);
4435 [ + - ]: 2 : if (et->ht_cached_keys)
4436 : 2 : size += _PyDict_KeysSize(et->ht_cached_keys);
4437 : : }
4438 : : else
4439 : 1 : size = sizeof(PyTypeObject);
4440 : 3 : return PyLong_FromSsize_t(size);
4441 : : }
4442 : :
4443 : : static PyMethodDef type_methods[] = {
4444 : : TYPE_MRO_METHODDEF
4445 : : TYPE___SUBCLASSES___METHODDEF
4446 : : {"__prepare__", _PyCFunction_CAST(type_prepare),
4447 : : METH_FASTCALL | METH_KEYWORDS | METH_CLASS,
4448 : : PyDoc_STR("__prepare__() -> dict\n"
4449 : : "used to create the namespace for the class statement")},
4450 : : TYPE___INSTANCECHECK___METHODDEF
4451 : : TYPE___SUBCLASSCHECK___METHODDEF
4452 : : TYPE___DIR___METHODDEF
4453 : : TYPE___SIZEOF___METHODDEF
4454 : : {0}
4455 : : };
4456 : :
4457 : : PyDoc_STRVAR(type_doc,
4458 : : "type(object) -> the object's type\n"
4459 : : "type(name, bases, dict, **kwds) -> a new type");
4460 : :
4461 : : static int
4462 : 35612027 : type_traverse(PyTypeObject *type, visitproc visit, void *arg)
4463 : : {
4464 : : /* Because of type_is_gc(), the collector only calls this
4465 : : for heaptypes. */
4466 [ - + ]: 35612027 : if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
4467 : : char msg[200];
4468 : 0 : sprintf(msg, "type_traverse() called on non-heap type '%.100s'",
4469 : : type->tp_name);
4470 : 0 : _PyObject_ASSERT_FAILED_MSG((PyObject *)type, msg);
4471 : : }
4472 : :
4473 [ + + + + ]: 35612027 : Py_VISIT(type->tp_dict);
4474 [ - + - - ]: 35612004 : Py_VISIT(type->tp_cache);
4475 [ + + - + ]: 35612004 : Py_VISIT(type->tp_mro);
4476 [ + - - + ]: 35612004 : Py_VISIT(type->tp_bases);
4477 [ + - - + ]: 35612004 : Py_VISIT(type->tp_base);
4478 [ + + - + ]: 35612004 : Py_VISIT(((PyHeapTypeObject *)type)->ht_module);
4479 : :
4480 : : /* There's no need to visit others because they can't be involved
4481 : : in cycles:
4482 : : type->tp_subclasses is a list of weak references,
4483 : : ((PyHeapTypeObject *)type)->ht_slots is a tuple of strings,
4484 : : ((PyHeapTypeObject *)type)->ht_*name are strings.
4485 : : */
4486 : :
4487 : 35612004 : return 0;
4488 : : }
4489 : :
4490 : : static int
4491 : 1303023 : type_clear(PyTypeObject *type)
4492 : : {
4493 : : /* Because of type_is_gc(), the collector only calls this
4494 : : for heaptypes. */
4495 : : _PyObject_ASSERT((PyObject *)type, type->tp_flags & Py_TPFLAGS_HEAPTYPE);
4496 : :
4497 : : /* We need to invalidate the method cache carefully before clearing
4498 : : the dict, so that other objects caught in a reference cycle
4499 : : don't start calling destroyed methods.
4500 : :
4501 : : Otherwise, the we need to clear tp_mro, which is
4502 : : part of a hard cycle (its first element is the class itself) that
4503 : : won't be broken otherwise (it's a tuple and tuples don't have a
4504 : : tp_clear handler).
4505 : : We also need to clear ht_module, if present: the module usually holds a
4506 : : reference to its class. None of the other fields need to be
4507 : :
4508 : : cleared, and here's why:
4509 : :
4510 : : tp_cache:
4511 : : Not used; if it were, it would be a dict.
4512 : :
4513 : : tp_bases, tp_base:
4514 : : If these are involved in a cycle, there must be at least
4515 : : one other, mutable object in the cycle, e.g. a base
4516 : : class's dict; the cycle will be broken that way.
4517 : :
4518 : : tp_subclasses:
4519 : : A dict of weak references can't be part of a cycle; and
4520 : : dicts have their own tp_clear.
4521 : :
4522 : : slots (in PyHeapTypeObject):
4523 : : A tuple of strings can't be part of a cycle.
4524 : : */
4525 : :
4526 : 1303023 : PyType_Modified(type);
4527 [ + - ]: 1303023 : if (type->tp_dict) {
4528 : 1303023 : PyDict_Clear(type->tp_dict);
4529 : : }
4530 [ + + ]: 1303023 : Py_CLEAR(((PyHeapTypeObject *)type)->ht_module);
4531 : :
4532 [ + - ]: 1303023 : Py_CLEAR(type->tp_mro);
4533 : :
4534 : 1303023 : return 0;
4535 : : }
4536 : :
4537 : : static int
4538 : 699199055 : type_is_gc(PyTypeObject *type)
4539 : : {
4540 : 699199055 : return type->tp_flags & Py_TPFLAGS_HEAPTYPE;
4541 : : }
4542 : :
4543 : :
4544 : : static PyNumberMethods type_as_number = {
4545 : : .nb_or = _Py_union_type_or, // Add __or__ function
4546 : : };
4547 : :
4548 : : PyTypeObject PyType_Type = {
4549 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
4550 : : "type", /* tp_name */
4551 : : sizeof(PyHeapTypeObject), /* tp_basicsize */
4552 : : sizeof(PyMemberDef), /* tp_itemsize */
4553 : : (destructor)type_dealloc, /* tp_dealloc */
4554 : : offsetof(PyTypeObject, tp_vectorcall), /* tp_vectorcall_offset */
4555 : : 0, /* tp_getattr */
4556 : : 0, /* tp_setattr */
4557 : : 0, /* tp_as_async */
4558 : : (reprfunc)type_repr, /* tp_repr */
4559 : : &type_as_number, /* tp_as_number */
4560 : : 0, /* tp_as_sequence */
4561 : : 0, /* tp_as_mapping */
4562 : : 0, /* tp_hash */
4563 : : (ternaryfunc)type_call, /* tp_call */
4564 : : 0, /* tp_str */
4565 : : (getattrofunc)type_getattro, /* tp_getattro */
4566 : : (setattrofunc)type_setattro, /* tp_setattro */
4567 : : 0, /* tp_as_buffer */
4568 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
4569 : : Py_TPFLAGS_BASETYPE | Py_TPFLAGS_TYPE_SUBCLASS |
4570 : : Py_TPFLAGS_HAVE_VECTORCALL, /* tp_flags */
4571 : : type_doc, /* tp_doc */
4572 : : (traverseproc)type_traverse, /* tp_traverse */
4573 : : (inquiry)type_clear, /* tp_clear */
4574 : : 0, /* tp_richcompare */
4575 : : offsetof(PyTypeObject, tp_weaklist), /* tp_weaklistoffset */
4576 : : 0, /* tp_iter */
4577 : : 0, /* tp_iternext */
4578 : : type_methods, /* tp_methods */
4579 : : type_members, /* tp_members */
4580 : : type_getsets, /* tp_getset */
4581 : : 0, /* tp_base */
4582 : : 0, /* tp_dict */
4583 : : 0, /* tp_descr_get */
4584 : : 0, /* tp_descr_set */
4585 : : offsetof(PyTypeObject, tp_dict), /* tp_dictoffset */
4586 : : type_init, /* tp_init */
4587 : : 0, /* tp_alloc */
4588 : : type_new, /* tp_new */
4589 : : PyObject_GC_Del, /* tp_free */
4590 : : (inquiry)type_is_gc, /* tp_is_gc */
4591 : : .tp_vectorcall = type_vectorcall,
4592 : : };
4593 : :
4594 : :
4595 : : /* The base type of all types (eventually)... except itself. */
4596 : :
4597 : : /* You may wonder why object.__new__() only complains about arguments
4598 : : when object.__init__() is not overridden, and vice versa.
4599 : :
4600 : : Consider the use cases:
4601 : :
4602 : : 1. When neither is overridden, we want to hear complaints about
4603 : : excess (i.e., any) arguments, since their presence could
4604 : : indicate there's a bug.
4605 : :
4606 : : 2. When defining an Immutable type, we are likely to override only
4607 : : __new__(), since __init__() is called too late to initialize an
4608 : : Immutable object. Since __new__() defines the signature for the
4609 : : type, it would be a pain to have to override __init__() just to
4610 : : stop it from complaining about excess arguments.
4611 : :
4612 : : 3. When defining a Mutable type, we are likely to override only
4613 : : __init__(). So here the converse reasoning applies: we don't
4614 : : want to have to override __new__() just to stop it from
4615 : : complaining.
4616 : :
4617 : : 4. When __init__() is overridden, and the subclass __init__() calls
4618 : : object.__init__(), the latter should complain about excess
4619 : : arguments; ditto for __new__().
4620 : :
4621 : : Use cases 2 and 3 make it unattractive to unconditionally check for
4622 : : excess arguments. The best solution that addresses all four use
4623 : : cases is as follows: __init__() complains about excess arguments
4624 : : unless __new__() is overridden and __init__() is not overridden
4625 : : (IOW, if __init__() is overridden or __new__() is not overridden);
4626 : : symmetrically, __new__() complains about excess arguments unless
4627 : : __init__() is overridden and __new__() is not overridden
4628 : : (IOW, if __new__() is overridden or __init__() is not overridden).
4629 : :
4630 : : However, for backwards compatibility, this breaks too much code.
4631 : : Therefore, in 2.6, we'll *warn* about excess arguments when both
4632 : : methods are overridden; for all other cases we'll use the above
4633 : : rules.
4634 : :
4635 : : */
4636 : :
4637 : : /* Forward */
4638 : : static PyObject *
4639 : : object_new(PyTypeObject *type, PyObject *args, PyObject *kwds);
4640 : :
4641 : : static int
4642 : 29679672 : excess_args(PyObject *args, PyObject *kwds)
4643 : : {
4644 [ + + + + ]: 29889394 : return PyTuple_GET_SIZE(args) ||
4645 [ + - + + ]: 209722 : (kwds && PyDict_Check(kwds) && PyDict_GET_SIZE(kwds));
4646 : : }
4647 : :
4648 : : static int
4649 : 19177108 : object_init(PyObject *self, PyObject *args, PyObject *kwds)
4650 : : {
4651 : 19177108 : PyTypeObject *type = Py_TYPE(self);
4652 [ + + ]: 19177108 : if (excess_args(args, kwds)) {
4653 [ + + ]: 17427132 : if (type->tp_init != object_init) {
4654 : 5 : PyErr_SetString(PyExc_TypeError,
4655 : : "object.__init__() takes exactly one argument (the instance to initialize)");
4656 : 5 : return -1;
4657 : : }
4658 [ + + ]: 17427127 : if (type->tp_new == object_new) {
4659 : 3 : PyErr_Format(PyExc_TypeError,
4660 : : "%.200s.__init__() takes exactly one argument (the instance to initialize)",
4661 : : type->tp_name);
4662 : 3 : return -1;
4663 : : }
4664 : : }
4665 : 19177100 : return 0;
4666 : : }
4667 : :
4668 : : static PyObject *
4669 : 10502564 : object_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
4670 : : {
4671 [ + + ]: 10502564 : if (excess_args(args, kwds)) {
4672 [ + + ]: 5812860 : if (type->tp_new != object_new) {
4673 : 9 : PyErr_SetString(PyExc_TypeError,
4674 : : "object.__new__() takes exactly one argument (the type to instantiate)");
4675 : 9 : return NULL;
4676 : : }
4677 [ + + ]: 5812851 : if (type->tp_init == object_init) {
4678 : 12667 : PyErr_Format(PyExc_TypeError, "%.200s() takes no arguments",
4679 : : type->tp_name);
4680 : 12667 : return NULL;
4681 : : }
4682 : : }
4683 : :
4684 [ + + ]: 10489888 : if (type->tp_flags & Py_TPFLAGS_IS_ABSTRACT) {
4685 : : PyObject *abstract_methods;
4686 : : PyObject *sorted_methods;
4687 : : PyObject *joined;
4688 : : Py_ssize_t method_count;
4689 : :
4690 : : /* Compute ", ".join(sorted(type.__abstractmethods__))
4691 : : into joined. */
4692 : 80 : abstract_methods = type_abstractmethods(type, NULL);
4693 [ - + ]: 80 : if (abstract_methods == NULL)
4694 : 0 : return NULL;
4695 : 80 : sorted_methods = PySequence_List(abstract_methods);
4696 : 80 : Py_DECREF(abstract_methods);
4697 [ - + ]: 80 : if (sorted_methods == NULL)
4698 : 0 : return NULL;
4699 [ - + ]: 80 : if (PyList_Sort(sorted_methods)) {
4700 : 0 : Py_DECREF(sorted_methods);
4701 : 0 : return NULL;
4702 : : }
4703 : : _Py_DECLARE_STR(comma_sep, ", ");
4704 : 80 : joined = PyUnicode_Join(&_Py_STR(comma_sep), sorted_methods);
4705 : 80 : method_count = PyObject_Length(sorted_methods);
4706 : 80 : Py_DECREF(sorted_methods);
4707 [ - + ]: 80 : if (joined == NULL)
4708 : 0 : return NULL;
4709 [ - + ]: 80 : if (method_count == -1)
4710 : 0 : return NULL;
4711 : :
4712 [ + + ]: 80 : PyErr_Format(PyExc_TypeError,
4713 : : "Can't instantiate abstract class %s "
4714 : : "without an implementation for abstract method%s %U",
4715 : : type->tp_name,
4716 : : method_count > 1 ? "s" : "",
4717 : : joined);
4718 : 80 : Py_DECREF(joined);
4719 : 80 : return NULL;
4720 : : }
4721 : 10489808 : PyObject *obj = type->tp_alloc(type, 0);
4722 [ + + ]: 10489808 : if (obj == NULL) {
4723 : 23 : return NULL;
4724 : : }
4725 [ - + ]: 10489785 : if (_PyObject_InitializeDict(obj)) {
4726 : 0 : Py_DECREF(obj);
4727 : 0 : return NULL;
4728 : : }
4729 : 10489785 : return obj;
4730 : : }
4731 : :
4732 : : static void
4733 : 215458956 : object_dealloc(PyObject *self)
4734 : : {
4735 : 215458956 : Py_TYPE(self)->tp_free(self);
4736 : 215458956 : }
4737 : :
4738 : : static PyObject *
4739 : 4005 : object_repr(PyObject *self)
4740 : : {
4741 : : PyTypeObject *type;
4742 : : PyObject *mod, *name, *rtn;
4743 : :
4744 : 4005 : type = Py_TYPE(self);
4745 : 4005 : mod = type_module(type, NULL);
4746 [ - + ]: 4005 : if (mod == NULL)
4747 : 0 : PyErr_Clear();
4748 [ - + ]: 4005 : else if (!PyUnicode_Check(mod)) {
4749 : 0 : Py_DECREF(mod);
4750 : 0 : mod = NULL;
4751 : : }
4752 : 4005 : name = type_qualname(type, NULL);
4753 [ - + ]: 4005 : if (name == NULL) {
4754 : 0 : Py_XDECREF(mod);
4755 : 0 : return NULL;
4756 : : }
4757 [ + - + + ]: 4005 : if (mod != NULL && !_PyUnicode_Equal(mod, &_Py_ID(builtins)))
4758 : 3879 : rtn = PyUnicode_FromFormat("<%U.%U object at %p>", mod, name, self);
4759 : : else
4760 : 126 : rtn = PyUnicode_FromFormat("<%s object at %p>",
4761 : : type->tp_name, self);
4762 : 4005 : Py_XDECREF(mod);
4763 : 4005 : Py_DECREF(name);
4764 : 4005 : return rtn;
4765 : : }
4766 : :
4767 : : static PyObject *
4768 : 3829940 : object_str(PyObject *self)
4769 : : {
4770 : : unaryfunc f;
4771 : :
4772 : 3829940 : f = Py_TYPE(self)->tp_repr;
4773 [ - + ]: 3829940 : if (f == NULL)
4774 : 0 : f = object_repr;
4775 : 3829940 : return f(self);
4776 : : }
4777 : :
4778 : : static PyObject *
4779 : 11726380 : object_richcompare(PyObject *self, PyObject *other, int op)
4780 : : {
4781 : : PyObject *res;
4782 : :
4783 [ + + + ]: 11726380 : switch (op) {
4784 : :
4785 : 11685079 : case Py_EQ:
4786 : : /* Return NotImplemented instead of False, so if two
4787 : : objects are compared, both get a chance at the
4788 : : comparison. See issue #1393. */
4789 [ + + ]: 11685079 : res = (self == other) ? Py_True : Py_NotImplemented;
4790 : 11685079 : Py_INCREF(res);
4791 : 11685079 : break;
4792 : :
4793 : 39212 : case Py_NE:
4794 : : /* By default, __ne__() delegates to __eq__() and inverts the result,
4795 : : unless the latter returns NotImplemented. */
4796 [ - + ]: 39212 : if (Py_TYPE(self)->tp_richcompare == NULL) {
4797 : 0 : res = Py_NotImplemented;
4798 : 0 : Py_INCREF(res);
4799 : 0 : break;
4800 : : }
4801 : 39212 : res = (*Py_TYPE(self)->tp_richcompare)(self, other, Py_EQ);
4802 [ + + + + ]: 39212 : if (res != NULL && res != Py_NotImplemented) {
4803 : 14194 : int ok = PyObject_IsTrue(res);
4804 : 14194 : Py_DECREF(res);
4805 [ - + ]: 14194 : if (ok < 0)
4806 : 0 : res = NULL;
4807 : : else {
4808 [ + + ]: 14194 : if (ok)
4809 : 11437 : res = Py_False;
4810 : : else
4811 : 2757 : res = Py_True;
4812 : 14194 : Py_INCREF(res);
4813 : : }
4814 : : }
4815 : 39212 : break;
4816 : :
4817 : 2089 : default:
4818 : 2089 : res = Py_NotImplemented;
4819 : 2089 : Py_INCREF(res);
4820 : 2089 : break;
4821 : : }
4822 : :
4823 : 11726380 : return res;
4824 : : }
4825 : :
4826 : : static PyObject *
4827 : 26227758 : object_get_class(PyObject *self, void *closure)
4828 : : {
4829 : 26227758 : Py_INCREF(Py_TYPE(self));
4830 : 26227758 : return (PyObject *)(Py_TYPE(self));
4831 : : }
4832 : :
4833 : : static int
4834 : 4592 : compatible_with_tp_base(PyTypeObject *child)
4835 : : {
4836 : 4592 : PyTypeObject *parent = child->tp_base;
4837 : 4562 : return (parent != NULL &&
4838 [ + + ]: 4562 : child->tp_basicsize == parent->tp_basicsize &&
4839 [ + - ]: 1908 : child->tp_itemsize == parent->tp_itemsize &&
4840 [ + + ]: 1908 : child->tp_dictoffset == parent->tp_dictoffset &&
4841 [ + - ]: 1892 : child->tp_weaklistoffset == parent->tp_weaklistoffset &&
4842 : 1892 : ((child->tp_flags & Py_TPFLAGS_HAVE_GC) ==
4843 [ + + + + ]: 11030 : (parent->tp_flags & Py_TPFLAGS_HAVE_GC)) &&
4844 [ - + ]: 1876 : (child->tp_dealloc == subtype_dealloc ||
4845 [ # # ]: 0 : child->tp_dealloc == parent->tp_dealloc));
4846 : : }
4847 : :
4848 : : static int
4849 : 153 : same_slots_added(PyTypeObject *a, PyTypeObject *b)
4850 : : {
4851 : 153 : PyTypeObject *base = a->tp_base;
4852 : : Py_ssize_t size;
4853 : : PyObject *slots_a, *slots_b;
4854 : :
4855 : : assert(base == b->tp_base);
4856 : 153 : size = base->tp_basicsize;
4857 [ - + - - ]: 153 : if (a->tp_dictoffset == size && b->tp_dictoffset == size)
4858 : 0 : size += sizeof(PyObject *);
4859 [ + + + + ]: 153 : if (a->tp_weaklistoffset == size && b->tp_weaklistoffset == size)
4860 : 135 : size += sizeof(PyObject *);
4861 : :
4862 : : /* Check slots compliance */
4863 [ + + ]: 153 : if (!(a->tp_flags & Py_TPFLAGS_HEAPTYPE) ||
4864 [ - + ]: 151 : !(b->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
4865 : 2 : return 0;
4866 : : }
4867 : 151 : slots_a = ((PyHeapTypeObject *)a)->ht_slots;
4868 : 151 : slots_b = ((PyHeapTypeObject *)b)->ht_slots;
4869 [ + + + + ]: 151 : if (slots_a && slots_b) {
4870 [ + + ]: 18 : if (PyObject_RichCompareBool(slots_a, slots_b, Py_EQ) != 1)
4871 : 6 : return 0;
4872 : 12 : size += sizeof(PyObject *) * PyTuple_GET_SIZE(slots_a);
4873 : : }
4874 [ + + + + ]: 145 : return size == a->tp_basicsize && size == b->tp_basicsize;
4875 : : }
4876 : :
4877 : : static int
4878 : 1358 : compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, const char* attr)
4879 : : {
4880 : : PyTypeObject *newbase, *oldbase;
4881 : :
4882 [ - + ]: 1358 : if (newto->tp_free != oldto->tp_free) {
4883 : 0 : PyErr_Format(PyExc_TypeError,
4884 : : "%s assignment: "
4885 : : "'%s' deallocator differs from '%s'",
4886 : : attr,
4887 : : newto->tp_name,
4888 : : oldto->tp_name);
4889 : 0 : return 0;
4890 : : }
4891 : : /*
4892 : : It's tricky to tell if two arbitrary types are sufficiently compatible as
4893 : : to be interchangeable; e.g., even if they have the same tp_basicsize, they
4894 : : might have totally different struct fields. It's much easier to tell if a
4895 : : type and its supertype are compatible; e.g., if they have the same
4896 : : tp_basicsize, then that means they have identical fields. So to check
4897 : : whether two arbitrary types are compatible, we first find the highest
4898 : : supertype that each is compatible with, and then if those supertypes are
4899 : : compatible then the original types must also be compatible.
4900 : : */
4901 : 1358 : newbase = newto;
4902 : 1358 : oldbase = oldto;
4903 [ + + ]: 2505 : while (compatible_with_tp_base(newbase))
4904 : 1147 : newbase = newbase->tp_base;
4905 [ + + ]: 2087 : while (compatible_with_tp_base(oldbase))
4906 : 729 : oldbase = oldbase->tp_base;
4907 [ + + ]: 1358 : if (newbase != oldbase &&
4908 [ + + + + ]: 366 : (newbase->tp_base != oldbase->tp_base ||
4909 : 153 : !same_slots_added(newbase, oldbase))) {
4910 : 72 : goto differs;
4911 : : }
4912 : : /* The above does not check for managed __dicts__ */
4913 : 1286 : if ((oldto->tp_flags & Py_TPFLAGS_MANAGED_DICT) ==
4914 [ + + ]: 1286 : ((newto->tp_flags & Py_TPFLAGS_MANAGED_DICT)))
4915 : : {
4916 : 1284 : return 1;
4917 : : }
4918 : 2 : differs:
4919 : 74 : PyErr_Format(PyExc_TypeError,
4920 : : "%s assignment: "
4921 : : "'%s' object layout differs from '%s'",
4922 : : attr,
4923 : : newto->tp_name,
4924 : : oldto->tp_name);
4925 : 74 : return 0;
4926 : : }
4927 : :
4928 : : static int
4929 : 810 : object_set_class(PyObject *self, PyObject *value, void *closure)
4930 : : {
4931 : 810 : PyTypeObject *oldto = Py_TYPE(self);
4932 : :
4933 [ + + ]: 810 : if (value == NULL) {
4934 : 101 : PyErr_SetString(PyExc_TypeError,
4935 : : "can't delete __class__ attribute");
4936 : 101 : return -1;
4937 : : }
4938 [ + + ]: 709 : if (!PyType_Check(value)) {
4939 : 1 : PyErr_Format(PyExc_TypeError,
4940 : : "__class__ must be set to a class, not '%s' object",
4941 : 1 : Py_TYPE(value)->tp_name);
4942 : 1 : return -1;
4943 : : }
4944 : 708 : PyTypeObject *newto = (PyTypeObject *)value;
4945 : :
4946 [ - + ]: 708 : if (PySys_Audit("object.__setattr__", "OsO",
4947 : : self, "__class__", value) < 0) {
4948 : 0 : return -1;
4949 : : }
4950 : :
4951 : : /* In versions of CPython prior to 3.5, the code in
4952 : : compatible_for_assignment was not set up to correctly check for memory
4953 : : layout / slot / etc. compatibility for non-HEAPTYPE classes, so we just
4954 : : disallowed __class__ assignment in any case that wasn't HEAPTYPE ->
4955 : : HEAPTYPE.
4956 : :
4957 : : During the 3.5 development cycle, we fixed the code in
4958 : : compatible_for_assignment to correctly check compatibility between
4959 : : arbitrary types, and started allowing __class__ assignment in all cases
4960 : : where the old and new types did in fact have compatible slots and
4961 : : memory layout (regardless of whether they were implemented as HEAPTYPEs
4962 : : or not).
4963 : :
4964 : : Just before 3.5 was released, though, we discovered that this led to
4965 : : problems with immutable types like int, where the interpreter assumes
4966 : : they are immutable and interns some values. Formerly this wasn't a
4967 : : problem, because they really were immutable -- in particular, all the
4968 : : types where the interpreter applied this interning trick happened to
4969 : : also be statically allocated, so the old HEAPTYPE rules were
4970 : : "accidentally" stopping them from allowing __class__ assignment. But
4971 : : with the changes to __class__ assignment, we started allowing code like
4972 : :
4973 : : class MyInt(int):
4974 : : ...
4975 : : # Modifies the type of *all* instances of 1 in the whole program,
4976 : : # including future instances (!), because the 1 object is interned.
4977 : : (1).__class__ = MyInt
4978 : :
4979 : : (see https://bugs.python.org/issue24912).
4980 : :
4981 : : In theory the proper fix would be to identify which classes rely on
4982 : : this invariant and somehow disallow __class__ assignment only for them,
4983 : : perhaps via some mechanism like a new Py_TPFLAGS_IMMUTABLE flag (a
4984 : : "denylisting" approach). But in practice, since this problem wasn't
4985 : : noticed late in the 3.5 RC cycle, we're taking the conservative
4986 : : approach and reinstating the same HEAPTYPE->HEAPTYPE check that we used
4987 : : to have, plus an "allowlist". For now, the allowlist consists only of
4988 : : ModuleType subtypes, since those are the cases that motivated the patch
4989 : : in the first place -- see https://bugs.python.org/issue22986 -- and
4990 : : since module objects are mutable we can be sure that they are
4991 : : definitely not being interned. So now we allow HEAPTYPE->HEAPTYPE *or*
4992 : : ModuleType subtype -> ModuleType subtype.
4993 : :
4994 : : So far as we know, all the code beyond the following 'if' statement
4995 : : will correctly handle non-HEAPTYPE classes, and the HEAPTYPE check is
4996 : : needed only to protect that subset of non-HEAPTYPE classes for which
4997 : : the interpreter has baked in the assumption that all instances are
4998 : : truly immutable.
4999 : : */
5000 [ + + - + ]: 728 : if (!(PyType_IsSubtype(newto, &PyModule_Type) &&
5001 [ + + ]: 708 : PyType_IsSubtype(oldto, &PyModule_Type)) &&
5002 [ + + ]: 1359 : (_PyType_HasFeature(newto, Py_TPFLAGS_IMMUTABLETYPE) ||
5003 : 671 : _PyType_HasFeature(oldto, Py_TPFLAGS_IMMUTABLETYPE))) {
5004 : 35 : PyErr_Format(PyExc_TypeError,
5005 : : "__class__ assignment only supported for mutable types "
5006 : : "or ModuleType subclasses");
5007 : 35 : return -1;
5008 : : }
5009 : :
5010 [ + + ]: 673 : if (compatible_for_assignment(oldto, newto, "__class__")) {
5011 : : /* Changing the class will change the implicit dict keys,
5012 : : * so we must materialize the dictionary first. */
5013 : : assert((oldto->tp_flags & Py_TPFLAGS_MANAGED_DICT) == (newto->tp_flags & Py_TPFLAGS_MANAGED_DICT));
5014 : 601 : _PyObject_GetDictPtr(self);
5015 [ + + - + ]: 601 : if (oldto->tp_flags & Py_TPFLAGS_MANAGED_DICT && *_PyObject_ValuesPointer(self)) {
5016 : : /* Was unable to convert to dict */
5017 : : PyErr_NoMemory();
5018 : 0 : return -1;
5019 : : }
5020 [ + + ]: 601 : if (newto->tp_flags & Py_TPFLAGS_HEAPTYPE) {
5021 : 591 : Py_INCREF(newto);
5022 : : }
5023 : 601 : Py_SET_TYPE(self, newto);
5024 [ + + ]: 601 : if (oldto->tp_flags & Py_TPFLAGS_HEAPTYPE)
5025 : 591 : Py_DECREF(oldto);
5026 : 601 : return 0;
5027 : : }
5028 : : else {
5029 : 72 : return -1;
5030 : : }
5031 : : }
5032 : :
5033 : : static PyGetSetDef object_getsets[] = {
5034 : : {"__class__", object_get_class, object_set_class,
5035 : : PyDoc_STR("the object's class")},
5036 : : {0}
5037 : : };
5038 : :
5039 : :
5040 : : /* Stuff to implement __reduce_ex__ for pickle protocols >= 2.
5041 : : We fall back to helpers in copyreg for:
5042 : : - pickle protocols < 2
5043 : : - calculating the list of slot names (done only once per class)
5044 : : - the __newobj__ function (which is used as a token but never called)
5045 : : */
5046 : :
5047 : : static PyObject *
5048 : 51790 : import_copyreg(void)
5049 : : {
5050 : : /* Try to fetch cached copy of copyreg from sys.modules first in an
5051 : : attempt to avoid the import overhead. Previously this was implemented
5052 : : by storing a reference to the cached module in a static variable, but
5053 : : this broke when multiple embedded interpreters were in use (see issue
5054 : : #17408 and #19088). */
5055 : 51790 : PyObject *copyreg_module = PyImport_GetModule(&_Py_ID(copyreg));
5056 [ + - ]: 51790 : if (copyreg_module != NULL) {
5057 : 51790 : return copyreg_module;
5058 : : }
5059 [ # # ]: 0 : if (PyErr_Occurred()) {
5060 : 0 : return NULL;
5061 : : }
5062 : 0 : return PyImport_Import(&_Py_ID(copyreg));
5063 : : }
5064 : :
5065 : : static PyObject *
5066 : 44904 : _PyType_GetSlotNames(PyTypeObject *cls)
5067 : : {
5068 : : PyObject *copyreg;
5069 : : PyObject *slotnames;
5070 : :
5071 : : assert(PyType_Check(cls));
5072 : :
5073 : : /* Get the slot names from the cache in the class if possible. */
5074 : 44904 : slotnames = PyDict_GetItemWithError(cls->tp_dict, &_Py_ID(__slotnames__));
5075 [ + + ]: 44904 : if (slotnames != NULL) {
5076 [ + - - + ]: 43647 : if (slotnames != Py_None && !PyList_Check(slotnames)) {
5077 : 0 : PyErr_Format(PyExc_TypeError,
5078 : : "%.200s.__slotnames__ should be a list or None, "
5079 : : "not %.200s",
5080 : 0 : cls->tp_name, Py_TYPE(slotnames)->tp_name);
5081 : 0 : return NULL;
5082 : : }
5083 : 43647 : Py_INCREF(slotnames);
5084 : 43647 : return slotnames;
5085 : : }
5086 : : else {
5087 [ - + ]: 1257 : if (PyErr_Occurred()) {
5088 : 0 : return NULL;
5089 : : }
5090 : : /* The class does not have the slot names cached yet. */
5091 : : }
5092 : :
5093 : 1257 : copyreg = import_copyreg();
5094 [ - + ]: 1257 : if (copyreg == NULL)
5095 : 0 : return NULL;
5096 : :
5097 : : /* Use _slotnames function from the copyreg module to find the slots
5098 : : by this class and its bases. This function will cache the result
5099 : : in __slotnames__. */
5100 : 1257 : slotnames = PyObject_CallMethodOneArg(
5101 : : copyreg, &_Py_ID(_slotnames), (PyObject *)cls);
5102 : 1257 : Py_DECREF(copyreg);
5103 [ - + ]: 1257 : if (slotnames == NULL)
5104 : 0 : return NULL;
5105 : :
5106 [ + - - + ]: 1257 : if (slotnames != Py_None && !PyList_Check(slotnames)) {
5107 : 0 : PyErr_SetString(PyExc_TypeError,
5108 : : "copyreg._slotnames didn't return a list or None");
5109 : 0 : Py_DECREF(slotnames);
5110 : 0 : return NULL;
5111 : : }
5112 : :
5113 : 1257 : return slotnames;
5114 : : }
5115 : :
5116 : : static PyObject *
5117 : 44913 : object_getstate_default(PyObject *obj, int required)
5118 : : {
5119 : : PyObject *state;
5120 : : PyObject *slotnames;
5121 : :
5122 [ + + + + ]: 44913 : if (required && Py_TYPE(obj)->tp_itemsize) {
5123 : 9 : PyErr_Format(PyExc_TypeError,
5124 : : "cannot pickle %.200s objects",
5125 : 9 : Py_TYPE(obj)->tp_name);
5126 : 9 : return NULL;
5127 : : }
5128 : :
5129 [ + + ]: 44904 : if (_PyObject_IsInstanceDictEmpty(obj)) {
5130 : 3311 : state = Py_None;
5131 : 3311 : Py_INCREF(state);
5132 : : }
5133 : : else {
5134 : 41593 : state = PyObject_GenericGetDict(obj, NULL);
5135 [ - + ]: 41593 : if (state == NULL) {
5136 : 0 : return NULL;
5137 : : }
5138 : : }
5139 : :
5140 : 44904 : slotnames = _PyType_GetSlotNames(Py_TYPE(obj));
5141 [ - + ]: 44904 : if (slotnames == NULL) {
5142 : 0 : Py_DECREF(state);
5143 : 0 : return NULL;
5144 : : }
5145 : :
5146 : : assert(slotnames == Py_None || PyList_Check(slotnames));
5147 [ + + ]: 44904 : if (required) {
5148 : 40056 : Py_ssize_t basicsize = PyBaseObject_Type.tp_basicsize;
5149 [ + + ]: 40056 : if (Py_TYPE(obj)->tp_dictoffset &&
5150 [ + + ]: 38963 : (Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT) == 0)
5151 : : {
5152 : 36 : basicsize += sizeof(PyObject *);
5153 : : }
5154 [ + + ]: 40056 : if (Py_TYPE(obj)->tp_weaklistoffset) {
5155 : 38972 : basicsize += sizeof(PyObject *);
5156 : : }
5157 [ + - ]: 40056 : if (slotnames != Py_None) {
5158 : 40056 : basicsize += sizeof(PyObject *) * PyList_GET_SIZE(slotnames);
5159 : : }
5160 [ + + ]: 40056 : if (Py_TYPE(obj)->tp_basicsize > basicsize) {
5161 : 281 : Py_DECREF(slotnames);
5162 : 281 : Py_DECREF(state);
5163 : 281 : PyErr_Format(PyExc_TypeError,
5164 : : "cannot pickle '%.200s' object",
5165 : 281 : Py_TYPE(obj)->tp_name);
5166 : 281 : return NULL;
5167 : : }
5168 : : }
5169 : :
5170 [ + - + + ]: 44623 : if (slotnames != Py_None && PyList_GET_SIZE(slotnames) > 0) {
5171 : : PyObject *slots;
5172 : : Py_ssize_t slotnames_size, i;
5173 : :
5174 : 991 : slots = PyDict_New();
5175 [ - + ]: 991 : if (slots == NULL) {
5176 : 0 : Py_DECREF(slotnames);
5177 : 0 : Py_DECREF(state);
5178 : 0 : return NULL;
5179 : : }
5180 : :
5181 : 991 : slotnames_size = PyList_GET_SIZE(slotnames);
5182 [ + + ]: 17238 : for (i = 0; i < slotnames_size; i++) {
5183 : : PyObject *name, *value;
5184 : :
5185 : 16247 : name = PyList_GET_ITEM(slotnames, i);
5186 : 16247 : Py_INCREF(name);
5187 [ - + ]: 16247 : if (_PyObject_LookupAttr(obj, name, &value) < 0) {
5188 : 0 : Py_DECREF(name);
5189 : 0 : goto error;
5190 : : }
5191 [ + + ]: 16247 : if (value == NULL) {
5192 : 1901 : Py_DECREF(name);
5193 : : /* It is not an error if the attribute is not present. */
5194 : : }
5195 : : else {
5196 : 14346 : int err = PyDict_SetItem(slots, name, value);
5197 : 14346 : Py_DECREF(name);
5198 : 14346 : Py_DECREF(value);
5199 [ - + ]: 14346 : if (err) {
5200 : 0 : goto error;
5201 : : }
5202 : : }
5203 : :
5204 : : /* The list is stored on the class so it may mutate while we
5205 : : iterate over it */
5206 [ - + ]: 16247 : if (slotnames_size != PyList_GET_SIZE(slotnames)) {
5207 : 0 : PyErr_Format(PyExc_RuntimeError,
5208 : : "__slotsname__ changed size during iteration");
5209 : 0 : goto error;
5210 : : }
5211 : :
5212 : : /* We handle errors within the loop here. */
5213 : : if (0) {
5214 : 0 : error:
5215 : 0 : Py_DECREF(slotnames);
5216 : 0 : Py_DECREF(slots);
5217 : 0 : Py_DECREF(state);
5218 : 0 : return NULL;
5219 : : }
5220 : : }
5221 : :
5222 : : /* If we found some slot attributes, pack them in a tuple along
5223 : : the original attribute dictionary. */
5224 [ + + ]: 991 : if (PyDict_GET_SIZE(slots) > 0) {
5225 : : PyObject *state2;
5226 : :
5227 : 984 : state2 = PyTuple_Pack(2, state, slots);
5228 : 984 : Py_DECREF(state);
5229 [ - + ]: 984 : if (state2 == NULL) {
5230 : 0 : Py_DECREF(slotnames);
5231 : 0 : Py_DECREF(slots);
5232 : 0 : return NULL;
5233 : : }
5234 : 984 : state = state2;
5235 : : }
5236 : 991 : Py_DECREF(slots);
5237 : : }
5238 : 44623 : Py_DECREF(slotnames);
5239 : :
5240 : 44623 : return state;
5241 : : }
5242 : :
5243 : : static PyObject *
5244 : 49594 : object_getstate(PyObject *obj, int required)
5245 : : {
5246 : : PyObject *getstate, *state;
5247 : :
5248 : 49594 : getstate = PyObject_GetAttr(obj, &_Py_ID(__getstate__));
5249 [ - + ]: 49594 : if (getstate == NULL) {
5250 : 0 : return NULL;
5251 : : }
5252 [ + + + - ]: 92883 : if (PyCFunction_Check(getstate) &&
5253 [ + + ]: 86578 : PyCFunction_GET_SELF(getstate) == obj &&
5254 : 43289 : PyCFunction_GET_FUNCTION(getstate) == object___getstate__)
5255 : : {
5256 : : /* If __getstate__ is not overriden pass the required argument. */
5257 : 43183 : state = object_getstate_default(obj, required);
5258 : : }
5259 : : else {
5260 : 6411 : state = _PyObject_CallNoArgs(getstate);
5261 : : }
5262 : 49594 : Py_DECREF(getstate);
5263 : 49594 : return state;
5264 : : }
5265 : :
5266 : : PyObject *
5267 : 719 : _PyObject_GetState(PyObject *obj)
5268 : : {
5269 : 719 : return object_getstate(obj, 0);
5270 : : }
5271 : :
5272 : : /*[clinic input]
5273 : : object.__getstate__
5274 : :
5275 : : Helper for pickle.
5276 : : [clinic start generated code]*/
5277 : :
5278 : : static PyObject *
5279 : 1730 : object___getstate___impl(PyObject *self)
5280 : : /*[clinic end generated code: output=5a2500dcb6217e9e input=692314d8fbe194ee]*/
5281 : : {
5282 : 1730 : return object_getstate_default(self, 0);
5283 : : }
5284 : :
5285 : : static int
5286 : 48899 : _PyObject_GetNewArguments(PyObject *obj, PyObject **args, PyObject **kwargs)
5287 : : {
5288 : : PyObject *getnewargs, *getnewargs_ex;
5289 : :
5290 [ + - - + ]: 48899 : if (args == NULL || kwargs == NULL) {
5291 : 0 : PyErr_BadInternalCall();
5292 : 0 : return -1;
5293 : : }
5294 : :
5295 : : /* We first attempt to fetch the arguments for __new__ by calling
5296 : : __getnewargs_ex__ on the object. */
5297 : 48899 : getnewargs_ex = _PyObject_LookupSpecial(obj, &_Py_ID(__getnewargs_ex__));
5298 [ + + ]: 48899 : if (getnewargs_ex != NULL) {
5299 : 92 : PyObject *newargs = _PyObject_CallNoArgs(getnewargs_ex);
5300 : 92 : Py_DECREF(getnewargs_ex);
5301 [ + + ]: 92 : if (newargs == NULL) {
5302 : 4 : return -1;
5303 : : }
5304 [ + + ]: 88 : if (!PyTuple_Check(newargs)) {
5305 : 4 : PyErr_Format(PyExc_TypeError,
5306 : : "__getnewargs_ex__ should return a tuple, "
5307 : 4 : "not '%.200s'", Py_TYPE(newargs)->tp_name);
5308 : 4 : Py_DECREF(newargs);
5309 : 4 : return -1;
5310 : : }
5311 [ + + ]: 84 : if (PyTuple_GET_SIZE(newargs) != 2) {
5312 : 4 : PyErr_Format(PyExc_ValueError,
5313 : : "__getnewargs_ex__ should return a tuple of "
5314 : : "length 2, not %zd", PyTuple_GET_SIZE(newargs));
5315 : 4 : Py_DECREF(newargs);
5316 : 4 : return -1;
5317 : : }
5318 : 80 : *args = PyTuple_GET_ITEM(newargs, 0);
5319 : 80 : Py_INCREF(*args);
5320 : 80 : *kwargs = PyTuple_GET_ITEM(newargs, 1);
5321 : 80 : Py_INCREF(*kwargs);
5322 : 80 : Py_DECREF(newargs);
5323 : :
5324 : : /* XXX We should perhaps allow None to be passed here. */
5325 [ + + ]: 80 : if (!PyTuple_Check(*args)) {
5326 : 4 : PyErr_Format(PyExc_TypeError,
5327 : : "first item of the tuple returned by "
5328 : : "__getnewargs_ex__ must be a tuple, not '%.200s'",
5329 : 4 : Py_TYPE(*args)->tp_name);
5330 [ + - ]: 4 : Py_CLEAR(*args);
5331 [ + - ]: 4 : Py_CLEAR(*kwargs);
5332 : 4 : return -1;
5333 : : }
5334 [ + + ]: 76 : if (!PyDict_Check(*kwargs)) {
5335 : 4 : PyErr_Format(PyExc_TypeError,
5336 : : "second item of the tuple returned by "
5337 : : "__getnewargs_ex__ must be a dict, not '%.200s'",
5338 : 4 : Py_TYPE(*kwargs)->tp_name);
5339 [ + - ]: 4 : Py_CLEAR(*args);
5340 [ + - ]: 4 : Py_CLEAR(*kwargs);
5341 : 4 : return -1;
5342 : : }
5343 : 72 : return 0;
5344 [ - + ]: 48807 : } else if (PyErr_Occurred()) {
5345 : 0 : return -1;
5346 : : }
5347 : :
5348 : : /* The object does not have __getnewargs_ex__ so we fallback on using
5349 : : __getnewargs__ instead. */
5350 : 48807 : getnewargs = _PyObject_LookupSpecial(obj, &_Py_ID(__getnewargs__));
5351 [ + + ]: 48807 : if (getnewargs != NULL) {
5352 : 1222 : *args = _PyObject_CallNoArgs(getnewargs);
5353 : 1222 : Py_DECREF(getnewargs);
5354 [ - + ]: 1222 : if (*args == NULL) {
5355 : 0 : return -1;
5356 : : }
5357 [ + + ]: 1222 : if (!PyTuple_Check(*args)) {
5358 : 4 : PyErr_Format(PyExc_TypeError,
5359 : : "__getnewargs__ should return a tuple, "
5360 : 4 : "not '%.200s'", Py_TYPE(*args)->tp_name);
5361 [ + - ]: 4 : Py_CLEAR(*args);
5362 : 4 : return -1;
5363 : : }
5364 : 1218 : *kwargs = NULL;
5365 : 1218 : return 0;
5366 [ - + ]: 47585 : } else if (PyErr_Occurred()) {
5367 : 0 : return -1;
5368 : : }
5369 : :
5370 : : /* The object does not have __getnewargs_ex__ and __getnewargs__. This may
5371 : : mean __new__ does not takes any arguments on this object, or that the
5372 : : object does not implement the reduce protocol for pickling or
5373 : : copying. */
5374 : 47585 : *args = NULL;
5375 : 47585 : *kwargs = NULL;
5376 : 47585 : return 0;
5377 : : }
5378 : :
5379 : : static int
5380 : 48508 : _PyObject_GetItemsIter(PyObject *obj, PyObject **listitems,
5381 : : PyObject **dictitems)
5382 : : {
5383 [ + - - + ]: 48508 : if (listitems == NULL || dictitems == NULL) {
5384 : 0 : PyErr_BadInternalCall();
5385 : 0 : return -1;
5386 : : }
5387 : :
5388 [ + + ]: 48508 : if (!PyList_Check(obj)) {
5389 : 47602 : *listitems = Py_None;
5390 : 47602 : Py_INCREF(*listitems);
5391 : : }
5392 : : else {
5393 : 906 : *listitems = PyObject_GetIter(obj);
5394 [ - + ]: 906 : if (*listitems == NULL)
5395 : 0 : return -1;
5396 : : }
5397 : :
5398 [ + + ]: 48508 : if (!PyDict_Check(obj)) {
5399 : 48228 : *dictitems = Py_None;
5400 : 48228 : Py_INCREF(*dictitems);
5401 : : }
5402 : : else {
5403 : 280 : PyObject *items = PyObject_CallMethodNoArgs(obj, &_Py_ID(items));
5404 [ - + ]: 280 : if (items == NULL) {
5405 [ # # ]: 0 : Py_CLEAR(*listitems);
5406 : 0 : return -1;
5407 : : }
5408 : 280 : *dictitems = PyObject_GetIter(items);
5409 : 280 : Py_DECREF(items);
5410 [ - + ]: 280 : if (*dictitems == NULL) {
5411 [ # # ]: 0 : Py_CLEAR(*listitems);
5412 : 0 : return -1;
5413 : : }
5414 : : }
5415 : :
5416 : : assert(*listitems != NULL && *dictitems != NULL);
5417 : :
5418 : 48508 : return 0;
5419 : : }
5420 : :
5421 : : static PyObject *
5422 : 48948 : reduce_newobj(PyObject *obj)
5423 : : {
5424 : 48948 : PyObject *args = NULL, *kwargs = NULL;
5425 : : PyObject *copyreg;
5426 : : PyObject *newobj, *newargs, *state, *listitems, *dictitems;
5427 : : PyObject *result;
5428 : : int hasargs;
5429 : :
5430 [ + + ]: 48948 : if (Py_TYPE(obj)->tp_new == NULL) {
5431 : 49 : PyErr_Format(PyExc_TypeError,
5432 : : "cannot pickle '%.200s' object",
5433 : 49 : Py_TYPE(obj)->tp_name);
5434 : 49 : return NULL;
5435 : : }
5436 [ + + ]: 48899 : if (_PyObject_GetNewArguments(obj, &args, &kwargs) < 0)
5437 : 24 : return NULL;
5438 : :
5439 : 48875 : copyreg = import_copyreg();
5440 [ - + ]: 48875 : if (copyreg == NULL) {
5441 : 0 : Py_XDECREF(args);
5442 : 0 : Py_XDECREF(kwargs);
5443 : 0 : return NULL;
5444 : : }
5445 : 48875 : hasargs = (args != NULL);
5446 [ + + + + ]: 97686 : if (kwargs == NULL || PyDict_GET_SIZE(kwargs) == 0) {
5447 : : PyObject *cls;
5448 : : Py_ssize_t i, n;
5449 : :
5450 : 48811 : Py_XDECREF(kwargs);
5451 : 48811 : newobj = PyObject_GetAttr(copyreg, &_Py_ID(__newobj__));
5452 : 48811 : Py_DECREF(copyreg);
5453 [ - + ]: 48811 : if (newobj == NULL) {
5454 : 0 : Py_XDECREF(args);
5455 : 0 : return NULL;
5456 : : }
5457 [ + + ]: 48811 : n = args ? PyTuple_GET_SIZE(args) : 0;
5458 : 48811 : newargs = PyTuple_New(n+1);
5459 [ - + ]: 48811 : if (newargs == NULL) {
5460 : 0 : Py_XDECREF(args);
5461 : 0 : Py_DECREF(newobj);
5462 : 0 : return NULL;
5463 : : }
5464 : 48811 : cls = (PyObject *) Py_TYPE(obj);
5465 : 48811 : Py_INCREF(cls);
5466 : 48811 : PyTuple_SET_ITEM(newargs, 0, cls);
5467 [ + + ]: 51382 : for (i = 0; i < n; i++) {
5468 : 2571 : PyObject *v = PyTuple_GET_ITEM(args, i);
5469 : 2571 : Py_INCREF(v);
5470 : 2571 : PyTuple_SET_ITEM(newargs, i+1, v);
5471 : : }
5472 : 48811 : Py_XDECREF(args);
5473 : : }
5474 [ + - ]: 64 : else if (args != NULL) {
5475 : 64 : newobj = PyObject_GetAttr(copyreg, &_Py_ID(__newobj_ex__));
5476 : 64 : Py_DECREF(copyreg);
5477 [ - + ]: 64 : if (newobj == NULL) {
5478 : 0 : Py_DECREF(args);
5479 : 0 : Py_DECREF(kwargs);
5480 : 0 : return NULL;
5481 : : }
5482 : 64 : newargs = PyTuple_Pack(3, Py_TYPE(obj), args, kwargs);
5483 : 64 : Py_DECREF(args);
5484 : 64 : Py_DECREF(kwargs);
5485 [ - + ]: 64 : if (newargs == NULL) {
5486 : 0 : Py_DECREF(newobj);
5487 : 0 : return NULL;
5488 : : }
5489 : : }
5490 : : else {
5491 : : /* args == NULL */
5492 : 0 : Py_DECREF(kwargs);
5493 : 0 : PyErr_BadInternalCall();
5494 : 0 : return NULL;
5495 : : }
5496 : :
5497 [ + + + + : 48875 : state = object_getstate(obj, !(hasargs || PyList_Check(obj) || PyDict_Check(obj)));
+ + ]
5498 [ + + ]: 48875 : if (state == NULL) {
5499 : 367 : Py_DECREF(newobj);
5500 : 367 : Py_DECREF(newargs);
5501 : 367 : return NULL;
5502 : : }
5503 [ - + ]: 48508 : if (_PyObject_GetItemsIter(obj, &listitems, &dictitems) < 0) {
5504 : 0 : Py_DECREF(newobj);
5505 : 0 : Py_DECREF(newargs);
5506 : 0 : Py_DECREF(state);
5507 : 0 : return NULL;
5508 : : }
5509 : :
5510 : 48508 : result = PyTuple_Pack(5, newobj, newargs, state, listitems, dictitems);
5511 : 48508 : Py_DECREF(newobj);
5512 : 48508 : Py_DECREF(newargs);
5513 : 48508 : Py_DECREF(state);
5514 : 48508 : Py_DECREF(listitems);
5515 : 48508 : Py_DECREF(dictitems);
5516 : 48508 : return result;
5517 : : }
5518 : :
5519 : : /*
5520 : : * There were two problems when object.__reduce__ and object.__reduce_ex__
5521 : : * were implemented in the same function:
5522 : : * - trying to pickle an object with a custom __reduce__ method that
5523 : : * fell back to object.__reduce__ in certain circumstances led to
5524 : : * infinite recursion at Python level and eventual RecursionError.
5525 : : * - Pickling objects that lied about their type by overwriting the
5526 : : * __class__ descriptor could lead to infinite recursion at C level
5527 : : * and eventual segfault.
5528 : : *
5529 : : * Because of backwards compatibility, the two methods still have to
5530 : : * behave in the same way, even if this is not required by the pickle
5531 : : * protocol. This common functionality was moved to the _common_reduce
5532 : : * function.
5533 : : */
5534 : : static PyObject *
5535 : 50606 : _common_reduce(PyObject *self, int proto)
5536 : : {
5537 : : PyObject *copyreg, *res;
5538 : :
5539 [ + + ]: 50606 : if (proto >= 2)
5540 : 48948 : return reduce_newobj(self);
5541 : :
5542 : 1658 : copyreg = import_copyreg();
5543 [ - + ]: 1658 : if (!copyreg)
5544 : 0 : return NULL;
5545 : :
5546 : 1658 : res = PyObject_CallMethod(copyreg, "_reduce_ex", "Oi", self, proto);
5547 : 1658 : Py_DECREF(copyreg);
5548 : :
5549 : 1658 : return res;
5550 : : }
5551 : :
5552 : : /*[clinic input]
5553 : : object.__reduce__
5554 : :
5555 : : Helper for pickle.
5556 : : [clinic start generated code]*/
5557 : :
5558 : : static PyObject *
5559 : 57 : object___reduce___impl(PyObject *self)
5560 : : /*[clinic end generated code: output=d4ca691f891c6e2f input=11562e663947e18b]*/
5561 : : {
5562 : 57 : return _common_reduce(self, 0);
5563 : : }
5564 : :
5565 : : /*[clinic input]
5566 : : object.__reduce_ex__
5567 : :
5568 : : protocol: int
5569 : : /
5570 : :
5571 : : Helper for pickle.
5572 : : [clinic start generated code]*/
5573 : :
5574 : : static PyObject *
5575 : 136841 : object___reduce_ex___impl(PyObject *self, int protocol)
5576 : : /*[clinic end generated code: output=2e157766f6b50094 input=f326b43fb8a4c5ff]*/
5577 : : {
5578 : : static PyObject *objreduce;
5579 : : PyObject *reduce, *res;
5580 : :
5581 [ + + ]: 136841 : if (objreduce == NULL) {
5582 : 244 : objreduce = PyDict_GetItemWithError(
5583 : : PyBaseObject_Type.tp_dict, &_Py_ID(__reduce__));
5584 [ - + - - ]: 244 : if (objreduce == NULL && PyErr_Occurred()) {
5585 : 0 : return NULL;
5586 : : }
5587 : : }
5588 : :
5589 [ - + ]: 136841 : if (_PyObject_LookupAttr(self, &_Py_ID(__reduce__), &reduce) < 0) {
5590 : 0 : return NULL;
5591 : : }
5592 [ + - ]: 136841 : if (reduce != NULL) {
5593 : : PyObject *cls, *clsreduce;
5594 : : int override;
5595 : :
5596 : 136841 : cls = (PyObject *) Py_TYPE(self);
5597 : 136841 : clsreduce = PyObject_GetAttr(cls, &_Py_ID(__reduce__));
5598 [ - + ]: 136841 : if (clsreduce == NULL) {
5599 : 0 : Py_DECREF(reduce);
5600 : 0 : return NULL;
5601 : : }
5602 : 136841 : override = (clsreduce != objreduce);
5603 : 136841 : Py_DECREF(clsreduce);
5604 [ + + ]: 136841 : if (override) {
5605 : 86292 : res = _PyObject_CallNoArgs(reduce);
5606 : 86292 : Py_DECREF(reduce);
5607 : 86292 : return res;
5608 : : }
5609 : : else
5610 : 50549 : Py_DECREF(reduce);
5611 : : }
5612 : :
5613 : 50549 : return _common_reduce(self, protocol);
5614 : : }
5615 : :
5616 : : static PyObject *
5617 : 39923 : object_subclasshook(PyObject *cls, PyObject *args)
5618 : : {
5619 : 39923 : Py_RETURN_NOTIMPLEMENTED;
5620 : : }
5621 : :
5622 : : PyDoc_STRVAR(object_subclasshook_doc,
5623 : : "Abstract classes can override this to customize issubclass().\n"
5624 : : "\n"
5625 : : "This is invoked early on by abc.ABCMeta.__subclasscheck__().\n"
5626 : : "It should return True, False or NotImplemented. If it returns\n"
5627 : : "NotImplemented, the normal algorithm is used. Otherwise, it\n"
5628 : : "overrides the normal algorithm (and the outcome is cached).\n");
5629 : :
5630 : : static PyObject *
5631 : 1199036 : object_init_subclass(PyObject *cls, PyObject *arg)
5632 : : {
5633 : 1199036 : Py_RETURN_NONE;
5634 : : }
5635 : :
5636 : : PyDoc_STRVAR(object_init_subclass_doc,
5637 : : "This method is called when a class is subclassed.\n"
5638 : : "\n"
5639 : : "The default implementation does nothing. It may be\n"
5640 : : "overridden to extend subclasses.\n");
5641 : :
5642 : : /*[clinic input]
5643 : : object.__format__
5644 : :
5645 : : format_spec: unicode
5646 : : /
5647 : :
5648 : : Default object formatter.
5649 : : [clinic start generated code]*/
5650 : :
5651 : : static PyObject *
5652 : 15149 : object___format___impl(PyObject *self, PyObject *format_spec)
5653 : : /*[clinic end generated code: output=34897efb543a974b input=7c3b3bc53a6fb7fa]*/
5654 : : {
5655 : : /* Issue 7994: If we're converting to a string, we
5656 : : should reject format specifications */
5657 [ + + ]: 15149 : if (PyUnicode_GET_LENGTH(format_spec) > 0) {
5658 : 10 : PyErr_Format(PyExc_TypeError,
5659 : : "unsupported format string passed to %.200s.__format__",
5660 : 10 : Py_TYPE(self)->tp_name);
5661 : 10 : return NULL;
5662 : : }
5663 : 15139 : return PyObject_Str(self);
5664 : : }
5665 : :
5666 : : /*[clinic input]
5667 : : object.__sizeof__
5668 : :
5669 : : Size of object in memory, in bytes.
5670 : : [clinic start generated code]*/
5671 : :
5672 : : static PyObject *
5673 : 91 : object___sizeof___impl(PyObject *self)
5674 : : /*[clinic end generated code: output=73edab332f97d550 input=1200ff3dfe485306]*/
5675 : : {
5676 : : Py_ssize_t res, isize;
5677 : :
5678 : 91 : res = 0;
5679 : 91 : isize = Py_TYPE(self)->tp_itemsize;
5680 [ + + ]: 91 : if (isize > 0)
5681 : 14 : res = Py_SIZE(self) * isize;
5682 : 91 : res += Py_TYPE(self)->tp_basicsize;
5683 : :
5684 : 91 : return PyLong_FromSsize_t(res);
5685 : : }
5686 : :
5687 : : /* __dir__ for generic objects: returns __dict__, __class__,
5688 : : and recursively up the __class__.__bases__ chain.
5689 : : */
5690 : : /*[clinic input]
5691 : : object.__dir__
5692 : :
5693 : : Default dir() implementation.
5694 : : [clinic start generated code]*/
5695 : :
5696 : : static PyObject *
5697 : 12569 : object___dir___impl(PyObject *self)
5698 : : /*[clinic end generated code: output=66dd48ea62f26c90 input=0a89305bec669b10]*/
5699 : : {
5700 : 12569 : PyObject *result = NULL;
5701 : 12569 : PyObject *dict = NULL;
5702 : 12569 : PyObject *itsclass = NULL;
5703 : :
5704 : : /* Get __dict__ (which may or may not be a real dict...) */
5705 [ - + ]: 12569 : if (_PyObject_LookupAttr(self, &_Py_ID(__dict__), &dict) < 0) {
5706 : 0 : return NULL;
5707 : : }
5708 [ + + ]: 12569 : if (dict == NULL) {
5709 : 8990 : dict = PyDict_New();
5710 : : }
5711 [ - + ]: 3579 : else if (!PyDict_Check(dict)) {
5712 : 0 : Py_DECREF(dict);
5713 : 0 : dict = PyDict_New();
5714 : : }
5715 : : else {
5716 : : /* Copy __dict__ to avoid mutating it. */
5717 : 3579 : PyObject *temp = PyDict_Copy(dict);
5718 : 3579 : Py_DECREF(dict);
5719 : 3579 : dict = temp;
5720 : : }
5721 : :
5722 [ - + ]: 12569 : if (dict == NULL)
5723 : 0 : goto error;
5724 : :
5725 : : /* Merge in attrs reachable from its class. */
5726 [ - + ]: 12569 : if (_PyObject_LookupAttr(self, &_Py_ID(__class__), &itsclass) < 0) {
5727 : 0 : goto error;
5728 : : }
5729 : : /* XXX(tomer): Perhaps fall back to Py_TYPE(obj) if no
5730 : : __class__ exists? */
5731 [ + + - + ]: 12569 : if (itsclass != NULL && merge_class_dict(dict, itsclass) < 0)
5732 : 0 : goto error;
5733 : :
5734 : 12569 : result = PyDict_Keys(dict);
5735 : : /* fall through */
5736 : 12569 : error:
5737 : 12569 : Py_XDECREF(itsclass);
5738 : 12569 : Py_XDECREF(dict);
5739 : 12569 : return result;
5740 : : }
5741 : :
5742 : : static PyMethodDef object_methods[] = {
5743 : : OBJECT___REDUCE_EX___METHODDEF
5744 : : OBJECT___REDUCE___METHODDEF
5745 : : OBJECT___GETSTATE___METHODDEF
5746 : : {"__subclasshook__", object_subclasshook, METH_CLASS | METH_VARARGS,
5747 : : object_subclasshook_doc},
5748 : : {"__init_subclass__", object_init_subclass, METH_CLASS | METH_NOARGS,
5749 : : object_init_subclass_doc},
5750 : : OBJECT___FORMAT___METHODDEF
5751 : : OBJECT___SIZEOF___METHODDEF
5752 : : OBJECT___DIR___METHODDEF
5753 : : {0}
5754 : : };
5755 : :
5756 : : PyDoc_STRVAR(object_doc,
5757 : : "object()\n--\n\n"
5758 : : "The base class of the class hierarchy.\n\n"
5759 : : "When called, it accepts no arguments and returns a new featureless\n"
5760 : : "instance that has no instance attributes and cannot be given any.\n");
5761 : :
5762 : : PyTypeObject PyBaseObject_Type = {
5763 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
5764 : : "object", /* tp_name */
5765 : : sizeof(PyObject), /* tp_basicsize */
5766 : : 0, /* tp_itemsize */
5767 : : object_dealloc, /* tp_dealloc */
5768 : : 0, /* tp_vectorcall_offset */
5769 : : 0, /* tp_getattr */
5770 : : 0, /* tp_setattr */
5771 : : 0, /* tp_as_async */
5772 : : object_repr, /* tp_repr */
5773 : : 0, /* tp_as_number */
5774 : : 0, /* tp_as_sequence */
5775 : : 0, /* tp_as_mapping */
5776 : : (hashfunc)_Py_HashPointer, /* tp_hash */
5777 : : 0, /* tp_call */
5778 : : object_str, /* tp_str */
5779 : : PyObject_GenericGetAttr, /* tp_getattro */
5780 : : PyObject_GenericSetAttr, /* tp_setattro */
5781 : : 0, /* tp_as_buffer */
5782 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE, /* tp_flags */
5783 : : object_doc, /* tp_doc */
5784 : : 0, /* tp_traverse */
5785 : : 0, /* tp_clear */
5786 : : object_richcompare, /* tp_richcompare */
5787 : : 0, /* tp_weaklistoffset */
5788 : : 0, /* tp_iter */
5789 : : 0, /* tp_iternext */
5790 : : object_methods, /* tp_methods */
5791 : : 0, /* tp_members */
5792 : : object_getsets, /* tp_getset */
5793 : : 0, /* tp_base */
5794 : : 0, /* tp_dict */
5795 : : 0, /* tp_descr_get */
5796 : : 0, /* tp_descr_set */
5797 : : 0, /* tp_dictoffset */
5798 : : object_init, /* tp_init */
5799 : : PyType_GenericAlloc, /* tp_alloc */
5800 : : object_new, /* tp_new */
5801 : : PyObject_Del, /* tp_free */
5802 : : };
5803 : :
5804 : :
5805 : : static int
5806 : 2379008 : type_add_method(PyTypeObject *type, PyMethodDef *meth)
5807 : : {
5808 : : PyObject *descr;
5809 : 2379008 : int isdescr = 1;
5810 [ + + ]: 2379008 : if (meth->ml_flags & METH_CLASS) {
5811 [ - + ]: 95990 : if (meth->ml_flags & METH_STATIC) {
5812 : 0 : PyErr_SetString(PyExc_ValueError,
5813 : : "method cannot be both class and static");
5814 : 0 : return -1;
5815 : : }
5816 : 95990 : descr = PyDescr_NewClassMethod(type, meth);
5817 : : }
5818 [ + + ]: 2283018 : else if (meth->ml_flags & METH_STATIC) {
5819 : 15923 : PyObject *cfunc = PyCFunction_NewEx(meth, (PyObject*)type, NULL);
5820 [ - + ]: 15923 : if (cfunc == NULL) {
5821 : 0 : return -1;
5822 : : }
5823 : 15923 : descr = PyStaticMethod_New(cfunc);
5824 : 15923 : isdescr = 0; // PyStaticMethod is not PyDescrObject
5825 : 15923 : Py_DECREF(cfunc);
5826 : : }
5827 : : else {
5828 : 2267095 : descr = PyDescr_NewMethod(type, meth);
5829 : : }
5830 [ - + ]: 2379008 : if (descr == NULL) {
5831 : 0 : return -1;
5832 : : }
5833 : :
5834 : : PyObject *name;
5835 [ + + ]: 2379008 : if (isdescr) {
5836 : 2363085 : name = PyDescr_NAME(descr);
5837 : : }
5838 : : else {
5839 : 15923 : name = PyUnicode_FromString(meth->ml_name);
5840 [ - + ]: 15923 : if (name == NULL) {
5841 : 0 : Py_DECREF(descr);
5842 : 0 : return -1;
5843 : : }
5844 : : }
5845 : :
5846 : : int err;
5847 [ + + ]: 2379008 : if (!(meth->ml_flags & METH_COEXIST)) {
5848 : 2364179 : err = PyDict_SetDefault(type->tp_dict, name, descr) == NULL;
5849 : : }
5850 : : else {
5851 : 14829 : err = PyDict_SetItem(type->tp_dict, name, descr) < 0;
5852 : : }
5853 [ + + ]: 2379008 : if (!isdescr) {
5854 : 15923 : Py_DECREF(name);
5855 : : }
5856 : 2379008 : Py_DECREF(descr);
5857 [ - + ]: 2379008 : if (err) {
5858 : 0 : return -1;
5859 : : }
5860 : 2379008 : return 0;
5861 : : }
5862 : :
5863 : :
5864 : : /* Add the methods from tp_methods to the __dict__ in a type object */
5865 : : static int
5866 : 2005280 : type_add_methods(PyTypeObject *type)
5867 : : {
5868 : 2005280 : PyMethodDef *meth = type->tp_methods;
5869 [ + + ]: 2005280 : if (meth == NULL) {
5870 : 1529387 : return 0;
5871 : : }
5872 : :
5873 [ + + ]: 2854901 : for (; meth->ml_name != NULL; meth++) {
5874 [ - + ]: 2379008 : if (type_add_method(type, meth) < 0) {
5875 : 0 : return -1;
5876 : : }
5877 : : }
5878 : 475893 : return 0;
5879 : : }
5880 : :
5881 : :
5882 : : static int
5883 : 2005280 : type_add_members(PyTypeObject *type)
5884 : : {
5885 : 2005280 : PyMemberDef *memb = type->tp_members;
5886 [ + + ]: 2005280 : if (memb == NULL) {
5887 : 529578 : return 0;
5888 : : }
5889 : :
5890 : 1475702 : PyObject *dict = type->tp_dict;
5891 [ + + ]: 2506010 : for (; memb->name != NULL; memb++) {
5892 : 1030308 : PyObject *descr = PyDescr_NewMember(type, memb);
5893 [ - + ]: 1030308 : if (descr == NULL)
5894 : 0 : return -1;
5895 : :
5896 [ - + ]: 1030308 : if (PyDict_SetDefault(dict, PyDescr_NAME(descr), descr) == NULL) {
5897 : 0 : Py_DECREF(descr);
5898 : 0 : return -1;
5899 : : }
5900 : 1030308 : Py_DECREF(descr);
5901 : : }
5902 : 1475702 : return 0;
5903 : : }
5904 : :
5905 : :
5906 : : static int
5907 : 2005280 : type_add_getset(PyTypeObject *type)
5908 : : {
5909 : 2005280 : PyGetSetDef *gsp = type->tp_getset;
5910 [ + + ]: 2005280 : if (gsp == NULL) {
5911 : 1305787 : return 0;
5912 : : }
5913 : :
5914 : 699493 : PyObject *dict = type->tp_dict;
5915 [ + + ]: 2102784 : for (; gsp->name != NULL; gsp++) {
5916 : 1403291 : PyObject *descr = PyDescr_NewGetSet(type, gsp);
5917 [ - + ]: 1403291 : if (descr == NULL) {
5918 : 0 : return -1;
5919 : : }
5920 : :
5921 [ - + ]: 1403291 : if (PyDict_SetDefault(dict, PyDescr_NAME(descr), descr) == NULL) {
5922 : 0 : Py_DECREF(descr);
5923 : 0 : return -1;
5924 : : }
5925 : 1403291 : Py_DECREF(descr);
5926 : : }
5927 : 699493 : return 0;
5928 : : }
5929 : :
5930 : :
5931 : : static void
5932 : 2002316 : inherit_special(PyTypeObject *type, PyTypeObject *base)
5933 : : {
5934 : : /* Copying tp_traverse and tp_clear is connected to the GC flags */
5935 [ + + ]: 2002316 : if (!(type->tp_flags & Py_TPFLAGS_HAVE_GC) &&
5936 [ + + ]: 163909 : (base->tp_flags & Py_TPFLAGS_HAVE_GC) &&
5937 [ + - + - ]: 26788 : (!type->tp_traverse && !type->tp_clear)) {
5938 : 26788 : type->tp_flags |= Py_TPFLAGS_HAVE_GC;
5939 [ + - ]: 26788 : if (type->tp_traverse == NULL)
5940 : 26788 : type->tp_traverse = base->tp_traverse;
5941 [ + - ]: 26788 : if (type->tp_clear == NULL)
5942 : 26788 : type->tp_clear = base->tp_clear;
5943 : : }
5944 : 2002316 : type->tp_flags |= (base->tp_flags & Py_TPFLAGS_MANAGED_DICT);
5945 : :
5946 [ + + ]: 2002316 : if (type->tp_basicsize == 0)
5947 : 30731 : type->tp_basicsize = base->tp_basicsize;
5948 : :
5949 : : /* Copy other non-function slots */
5950 : :
5951 : : #define COPYVAL(SLOT) \
5952 : : if (type->SLOT == 0) { type->SLOT = base->SLOT; }
5953 : :
5954 [ + + ]: 2002316 : COPYVAL(tp_itemsize);
5955 [ + + ]: 2002316 : COPYVAL(tp_weaklistoffset);
5956 [ + + ]: 2002316 : COPYVAL(tp_dictoffset);
5957 : : #undef COPYVAL
5958 : :
5959 : : /* Setup fast subclass flags */
5960 [ + + ]: 2002316 : if (PyType_IsSubtype(base, (PyTypeObject*)PyExc_BaseException)) {
5961 : 298657 : type->tp_flags |= Py_TPFLAGS_BASE_EXC_SUBCLASS;
5962 : : }
5963 [ + + ]: 1703659 : else if (PyType_IsSubtype(base, &PyType_Type)) {
5964 : 16014 : type->tp_flags |= Py_TPFLAGS_TYPE_SUBCLASS;
5965 : : }
5966 [ + + ]: 1687645 : else if (PyType_IsSubtype(base, &PyLong_Type)) {
5967 : 26092 : type->tp_flags |= Py_TPFLAGS_LONG_SUBCLASS;
5968 : : }
5969 [ + + ]: 1661553 : else if (PyType_IsSubtype(base, &PyBytes_Type)) {
5970 : 715 : type->tp_flags |= Py_TPFLAGS_BYTES_SUBCLASS;
5971 : : }
5972 [ + + ]: 1660838 : else if (PyType_IsSubtype(base, &PyUnicode_Type)) {
5973 : 13588 : type->tp_flags |= Py_TPFLAGS_UNICODE_SUBCLASS;
5974 : : }
5975 [ + + ]: 1647250 : else if (PyType_IsSubtype(base, &PyTuple_Type)) {
5976 : 99847 : type->tp_flags |= Py_TPFLAGS_TUPLE_SUBCLASS;
5977 : : }
5978 [ + + ]: 1547403 : else if (PyType_IsSubtype(base, &PyList_Type)) {
5979 : 5742 : type->tp_flags |= Py_TPFLAGS_LIST_SUBCLASS;
5980 : : }
5981 [ + + ]: 1541661 : else if (PyType_IsSubtype(base, &PyDict_Type)) {
5982 : 12566 : type->tp_flags |= Py_TPFLAGS_DICT_SUBCLASS;
5983 : : }
5984 [ + + ]: 2002316 : if (PyType_HasFeature(base, _Py_TPFLAGS_MATCH_SELF)) {
5985 : 159510 : type->tp_flags |= _Py_TPFLAGS_MATCH_SELF;
5986 : : }
5987 : 2002316 : }
5988 : :
5989 : : static int
5990 : 1959158 : overrides_hash(PyTypeObject *type)
5991 : : {
5992 : 1959158 : PyObject *dict = type->tp_dict;
5993 : :
5994 : : assert(dict != NULL);
5995 : 1959158 : int r = PyDict_Contains(dict, &_Py_ID(__eq__));
5996 [ + + ]: 1959158 : if (r == 0) {
5997 : 1809844 : r = PyDict_Contains(dict, &_Py_ID(__hash__));
5998 : : }
5999 : 1959158 : return r;
6000 : : }
6001 : :
6002 : : static int
6003 : 4629456 : inherit_slots(PyTypeObject *type, PyTypeObject *base)
6004 : : {
6005 : : PyTypeObject *basebase;
6006 : :
6007 : : #undef SLOTDEFINED
6008 : : #undef COPYSLOT
6009 : : #undef COPYNUM
6010 : : #undef COPYSEQ
6011 : : #undef COPYMAP
6012 : : #undef COPYBUF
6013 : :
6014 : : #define SLOTDEFINED(SLOT) \
6015 : : (base->SLOT != 0 && \
6016 : : (basebase == NULL || base->SLOT != basebase->SLOT))
6017 : :
6018 : : #define COPYSLOT(SLOT) \
6019 : : if (!type->SLOT && SLOTDEFINED(SLOT)) type->SLOT = base->SLOT
6020 : :
6021 : : #define COPYASYNC(SLOT) COPYSLOT(tp_as_async->SLOT)
6022 : : #define COPYNUM(SLOT) COPYSLOT(tp_as_number->SLOT)
6023 : : #define COPYSEQ(SLOT) COPYSLOT(tp_as_sequence->SLOT)
6024 : : #define COPYMAP(SLOT) COPYSLOT(tp_as_mapping->SLOT)
6025 : : #define COPYBUF(SLOT) COPYSLOT(tp_as_buffer->SLOT)
6026 : :
6027 : : /* This won't inherit indirect slots (from tp_as_number etc.)
6028 : : if type doesn't provide the space. */
6029 : :
6030 [ + + + + ]: 4629456 : if (type->tp_as_number != NULL && base->tp_as_number != NULL) {
6031 : 1597484 : basebase = base->tp_base;
6032 [ + + ]: 1597484 : if (basebase->tp_as_number == NULL)
6033 : 959862 : basebase = NULL;
6034 [ + + + + : 1597484 : COPYNUM(nb_add);
+ + + + ]
6035 [ + + + + : 1597484 : COPYNUM(nb_subtract);
+ + + + ]
6036 [ + + + + : 1597484 : COPYNUM(nb_multiply);
+ + + + ]
6037 [ + + + + : 1597484 : COPYNUM(nb_remainder);
+ + + + ]
6038 [ + + + + : 1597484 : COPYNUM(nb_divmod);
+ + + + ]
6039 [ + + + + : 1597484 : COPYNUM(nb_power);
+ + + + ]
6040 [ + + + + : 1597484 : COPYNUM(nb_negative);
+ + + + ]
6041 [ + + + + : 1597484 : COPYNUM(nb_positive);
+ + + + ]
6042 [ + + + + : 1597484 : COPYNUM(nb_absolute);
+ + + + ]
6043 [ + + + + : 1597484 : COPYNUM(nb_bool);
+ + + + ]
6044 [ + + + + : 1597484 : COPYNUM(nb_invert);
+ + + + ]
6045 [ + + + + : 1597484 : COPYNUM(nb_lshift);
+ + + + ]
6046 [ + + + + : 1597484 : COPYNUM(nb_rshift);
+ + - + ]
6047 [ + + + + : 1597484 : COPYNUM(nb_and);
+ + + + ]
6048 [ + + + + : 1597484 : COPYNUM(nb_xor);
+ + + + ]
6049 [ + + + + : 1597484 : COPYNUM(nb_or);
+ + + + ]
6050 [ + + + + : 1597484 : COPYNUM(nb_int);
+ + + + ]
6051 [ + + + + : 1597484 : COPYNUM(nb_float);
+ + + + ]
6052 [ + + + + : 1597484 : COPYNUM(nb_inplace_add);
+ + + + ]
6053 [ + + + + : 1597484 : COPYNUM(nb_inplace_subtract);
+ + + + ]
6054 [ + + + + : 1597484 : COPYNUM(nb_inplace_multiply);
+ - + - ]
6055 [ + - - + : 1597484 : COPYNUM(nb_inplace_remainder);
- - - - ]
6056 [ + - + + : 1597484 : COPYNUM(nb_inplace_power);
- + - - ]
6057 [ + + + + : 1597484 : COPYNUM(nb_inplace_lshift);
+ - + - ]
6058 [ + - - + : 1597484 : COPYNUM(nb_inplace_rshift);
- - - - ]
6059 [ + + + + : 1597484 : COPYNUM(nb_inplace_and);
+ + + + ]
6060 [ + + + + : 1597484 : COPYNUM(nb_inplace_xor);
+ + + + ]
6061 [ + + + + : 1597484 : COPYNUM(nb_inplace_or);
+ + + + ]
6062 [ + + + + : 1597484 : COPYNUM(nb_true_divide);
+ + + + ]
6063 [ + + + + : 1597484 : COPYNUM(nb_floor_divide);
+ + + + ]
6064 [ + - - + : 1597484 : COPYNUM(nb_inplace_true_divide);
- - - - ]
6065 [ + - - + : 1597484 : COPYNUM(nb_inplace_floor_divide);
- - - - ]
6066 [ + + + + : 1597484 : COPYNUM(nb_index);
+ + - + ]
6067 [ + - + + : 1597484 : COPYNUM(nb_matrix_multiply);
- + - - ]
6068 [ + - - + : 1597484 : COPYNUM(nb_inplace_matrix_multiply);
- - - - ]
6069 : : }
6070 : :
6071 [ + + + + ]: 4629456 : if (type->tp_as_async != NULL && base->tp_as_async != NULL) {
6072 : 1514675 : basebase = base->tp_base;
6073 [ + + ]: 1514675 : if (basebase->tp_as_async == NULL)
6074 : 908045 : basebase = NULL;
6075 [ + + + + : 1514675 : COPYASYNC(am_await);
+ + - + ]
6076 [ + + + + : 1514675 : COPYASYNC(am_aiter);
+ + - + ]
6077 [ + + + + : 1514675 : COPYASYNC(am_anext);
+ - + + ]
6078 : : }
6079 : :
6080 [ + + + + ]: 4629456 : if (type->tp_as_sequence != NULL && base->tp_as_sequence != NULL) {
6081 : 1618400 : basebase = base->tp_base;
6082 [ + + ]: 1618400 : if (basebase->tp_as_sequence == NULL)
6083 : 988875 : basebase = NULL;
6084 [ + + + + : 1618400 : COPYSEQ(sq_length);
+ + + + ]
6085 [ + + + + : 1618400 : COPYSEQ(sq_concat);
+ + - + ]
6086 [ + + + + : 1618400 : COPYSEQ(sq_repeat);
+ + - + ]
6087 [ + + + + : 1618400 : COPYSEQ(sq_item);
+ + + + ]
6088 [ + + + + : 1618400 : COPYSEQ(sq_ass_item);
+ + + + ]
6089 [ + + + + : 1618400 : COPYSEQ(sq_contains);
+ + + + ]
6090 [ + + + + : 1618400 : COPYSEQ(sq_inplace_concat);
+ + - + ]
6091 [ + + + + : 1618400 : COPYSEQ(sq_inplace_repeat);
+ + - + ]
6092 : : }
6093 : :
6094 [ + + + + ]: 4629456 : if (type->tp_as_mapping != NULL && base->tp_as_mapping != NULL) {
6095 : 1623354 : basebase = base->tp_base;
6096 [ + + ]: 1623354 : if (basebase->tp_as_mapping == NULL)
6097 : 993833 : basebase = NULL;
6098 [ + + + + : 1623354 : COPYMAP(mp_length);
+ + + + ]
6099 [ + + + + : 1623354 : COPYMAP(mp_subscript);
+ + + + ]
6100 [ + + + + : 1623354 : COPYMAP(mp_ass_subscript);
+ + + + ]
6101 : : }
6102 : :
6103 [ + + + + ]: 4629456 : if (type->tp_as_buffer != NULL && base->tp_as_buffer != NULL) {
6104 : 1541864 : basebase = base->tp_base;
6105 [ + + ]: 1541864 : if (basebase->tp_as_buffer == NULL)
6106 : 922497 : basebase = NULL;
6107 [ + + + + : 1541864 : COPYBUF(bf_getbuffer);
+ + - + ]
6108 [ + - + + : 1541864 : COPYBUF(bf_releasebuffer);
- + - - ]
6109 : : }
6110 : :
6111 : 4629456 : basebase = base->tp_base;
6112 : :
6113 [ + + + - : 4629456 : COPYSLOT(tp_dealloc);
+ + + + ]
6114 [ + - + + ]: 4629456 : if (type->tp_getattr == NULL && type->tp_getattro == NULL) {
6115 : 1661112 : type->tp_getattr = base->tp_getattr;
6116 : 1661112 : type->tp_getattro = base->tp_getattro;
6117 : : }
6118 [ + + + + ]: 4629456 : if (type->tp_setattr == NULL && type->tp_setattro == NULL) {
6119 : 1955758 : type->tp_setattr = base->tp_setattr;
6120 : 1955758 : type->tp_setattro = base->tp_setattro;
6121 : : }
6122 [ + + + + : 4629456 : COPYSLOT(tp_repr);
+ + + + ]
6123 : : /* tp_hash see tp_richcompare */
6124 : : {
6125 : : /* Always inherit tp_vectorcall_offset to support PyVectorcall_Call().
6126 : : * If Py_TPFLAGS_HAVE_VECTORCALL is not inherited, then vectorcall
6127 : : * won't be used automatically. */
6128 [ + + + + : 4629456 : COPYSLOT(tp_vectorcall_offset);
+ - + + ]
6129 : :
6130 : : /* Inherit Py_TPFLAGS_HAVE_VECTORCALL for non-heap types
6131 : : * if tp_call is not overridden */
6132 [ + + + + ]: 9021098 : if (!type->tp_call &&
6133 [ + + ]: 4418396 : _PyType_HasFeature(base, Py_TPFLAGS_HAVE_VECTORCALL) &&
6134 : 26754 : _PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE))
6135 : : {
6136 : 6065 : type->tp_flags |= Py_TPFLAGS_HAVE_VECTORCALL;
6137 : : }
6138 [ + + + + : 4629456 : COPYSLOT(tp_call);
+ - + + ]
6139 : : }
6140 [ + + + + : 4629456 : COPYSLOT(tp_str);
+ + + + ]
6141 : : {
6142 : : /* Copy comparison-related slots only when
6143 : : not overriding them anywhere */
6144 [ + + ]: 4629456 : if (type->tp_richcompare == NULL &&
6145 [ + + ]: 2002918 : type->tp_hash == NULL)
6146 : : {
6147 : 1959158 : int r = overrides_hash(type);
6148 [ - + ]: 1959158 : if (r < 0) {
6149 : 0 : return -1;
6150 : : }
6151 [ + + ]: 1959158 : if (!r) {
6152 : 1800689 : type->tp_richcompare = base->tp_richcompare;
6153 : 1800689 : type->tp_hash = base->tp_hash;
6154 : : }
6155 : : }
6156 : : }
6157 : : {
6158 [ + + + + : 4629456 : COPYSLOT(tp_iter);
+ - + + ]
6159 [ + + + + : 4629456 : COPYSLOT(tp_iternext);
+ - + + ]
6160 : : }
6161 : : {
6162 [ + + + + : 4629456 : COPYSLOT(tp_descr_get);
+ - + - ]
6163 : : /* Inherit Py_TPFLAGS_METHOD_DESCRIPTOR if tp_descr_get was inherited,
6164 : : * but only for extension types */
6165 [ + + ]: 4629456 : if (base->tp_descr_get &&
6166 [ + + + + ]: 28544 : type->tp_descr_get == base->tp_descr_get &&
6167 [ + - ]: 16027 : _PyType_HasFeature(type, Py_TPFLAGS_IMMUTABLETYPE) &&
6168 : 2340 : _PyType_HasFeature(base, Py_TPFLAGS_METHOD_DESCRIPTOR))
6169 : : {
6170 : 2340 : type->tp_flags |= Py_TPFLAGS_METHOD_DESCRIPTOR;
6171 : : }
6172 [ + + + + : 4629456 : COPYSLOT(tp_descr_set);
+ - + - ]
6173 [ + + - + : 4629456 : COPYSLOT(tp_dictoffset);
- - - - ]
6174 [ + + + + : 4629456 : COPYSLOT(tp_init);
+ + + + ]
6175 [ + + + - : 4629456 : COPYSLOT(tp_alloc);
+ + + + ]
6176 [ + + + + : 4629456 : COPYSLOT(tp_is_gc);
+ - + + ]
6177 [ + + + + : 4629456 : COPYSLOT(tp_finalize);
+ - + + ]
6178 : 4629456 : if ((type->tp_flags & Py_TPFLAGS_HAVE_GC) ==
6179 [ + + ]: 4629456 : (base->tp_flags & Py_TPFLAGS_HAVE_GC)) {
6180 : : /* They agree about gc. */
6181 [ + + + - : 2696682 : COPYSLOT(tp_free);
+ + + + ]
6182 : : }
6183 [ + - ]: 1932774 : else if ((type->tp_flags & Py_TPFLAGS_HAVE_GC) &&
6184 [ + + ]: 1932774 : type->tp_free == NULL &&
6185 [ + - ]: 217996 : base->tp_free == PyObject_Free) {
6186 : : /* A bit of magic to plug in the correct default
6187 : : * tp_free function when a derived class adds gc,
6188 : : * didn't define tp_free, and the base uses the
6189 : : * default non-gc tp_free.
6190 : : */
6191 : 217996 : type->tp_free = PyObject_GC_Del;
6192 : : }
6193 : : /* else they didn't agree about gc, and there isn't something
6194 : : * obvious to be done -- the type is on its own.
6195 : : */
6196 : : }
6197 : 4629456 : return 0;
6198 : : }
6199 : :
6200 : : static int add_operators(PyTypeObject *);
6201 : : static int add_tp_new_wrapper(PyTypeObject *type);
6202 : :
6203 : : #define COLLECTION_FLAGS (Py_TPFLAGS_SEQUENCE | Py_TPFLAGS_MAPPING)
6204 : :
6205 : : static int
6206 : 2005296 : type_ready_pre_checks(PyTypeObject *type)
6207 : : {
6208 : : /* Consistency checks for PEP 590:
6209 : : * - Py_TPFLAGS_METHOD_DESCRIPTOR requires tp_descr_get
6210 : : * - Py_TPFLAGS_HAVE_VECTORCALL requires tp_call and
6211 : : * tp_vectorcall_offset > 0
6212 : : * To avoid mistakes, we require this before inheriting.
6213 : : */
6214 : 2005296 : if (type->tp_flags & Py_TPFLAGS_METHOD_DESCRIPTOR) {
6215 : : _PyObject_ASSERT((PyObject *)type, type->tp_descr_get != NULL);
6216 : : }
6217 : 2005296 : if (type->tp_flags & Py_TPFLAGS_HAVE_VECTORCALL) {
6218 : : _PyObject_ASSERT((PyObject *)type, type->tp_vectorcall_offset > 0);
6219 : : _PyObject_ASSERT((PyObject *)type, type->tp_call != NULL);
6220 : : }
6221 : :
6222 : : /* Consistency checks for pattern matching
6223 : : * Py_TPFLAGS_SEQUENCE and Py_TPFLAGS_MAPPING are mutually exclusive */
6224 : : _PyObject_ASSERT((PyObject *)type, (type->tp_flags & COLLECTION_FLAGS) != COLLECTION_FLAGS);
6225 : :
6226 [ - + ]: 2005296 : if (type->tp_name == NULL) {
6227 : 0 : PyErr_Format(PyExc_SystemError,
6228 : : "Type does not define the tp_name field.");
6229 : 0 : return -1;
6230 : : }
6231 : 2005296 : return 0;
6232 : : }
6233 : :
6234 : :
6235 : : static int
6236 : 2005296 : type_ready_set_bases(PyTypeObject *type)
6237 : : {
6238 : : /* Initialize tp_base (defaults to BaseObject unless that's us) */
6239 : 2005296 : PyTypeObject *base = type->tp_base;
6240 [ + + + + ]: 2005296 : if (base == NULL && type != &PyBaseObject_Type) {
6241 : 386206 : base = &PyBaseObject_Type;
6242 [ - + ]: 386206 : if (type->tp_flags & Py_TPFLAGS_HEAPTYPE) {
6243 : 0 : type->tp_base = (PyTypeObject*)Py_NewRef((PyObject*)base);
6244 : : }
6245 : : else {
6246 : 386206 : type->tp_base = base;
6247 : : }
6248 : : }
6249 : : assert(type->tp_base != NULL || type == &PyBaseObject_Type);
6250 : :
6251 : : /* Now the only way base can still be NULL is if type is
6252 : : * &PyBaseObject_Type. */
6253 : :
6254 : : /* Initialize the base class */
6255 [ + + - + ]: 2005296 : if (base != NULL && !_PyType_IsReady(base)) {
6256 [ # # ]: 0 : if (PyType_Ready(base) < 0) {
6257 : 0 : return -1;
6258 : : }
6259 : : }
6260 : :
6261 : : /* Initialize ob_type if NULL. This means extensions that want to be
6262 : : compilable separately on Windows can call PyType_Ready() instead of
6263 : : initializing the ob_type field of their type objects. */
6264 : : /* The test for base != NULL is really unnecessary, since base is only
6265 : : NULL when type is &PyBaseObject_Type, and we know its ob_type is
6266 : : not NULL (it's initialized to &PyType_Type). But coverity doesn't
6267 : : know that. */
6268 [ + + + - ]: 2005296 : if (Py_IS_TYPE(type, NULL) && base != NULL) {
6269 : 348631 : Py_SET_TYPE(type, Py_TYPE(base));
6270 : : }
6271 : :
6272 : : /* Initialize tp_bases */
6273 : 2005296 : PyObject *bases = type->tp_bases;
6274 [ + + ]: 2005296 : if (bases == NULL) {
6275 : 672918 : PyTypeObject *base = type->tp_base;
6276 [ + + ]: 672918 : if (base == NULL) {
6277 : 2964 : bases = PyTuple_New(0);
6278 : : }
6279 : : else {
6280 : 669954 : bases = PyTuple_Pack(1, base);
6281 : : }
6282 [ - + ]: 672918 : if (bases == NULL) {
6283 : 0 : return -1;
6284 : : }
6285 : 672918 : type->tp_bases = bases;
6286 : : }
6287 : 2005296 : return 0;
6288 : : }
6289 : :
6290 : :
6291 : : static int
6292 : 2005296 : type_ready_set_dict(PyTypeObject *type)
6293 : : {
6294 [ + + ]: 2005296 : if (type->tp_dict != NULL) {
6295 : 1216589 : return 0;
6296 : : }
6297 : :
6298 : 788707 : PyObject *dict = PyDict_New();
6299 [ - + ]: 788707 : if (dict == NULL) {
6300 : 0 : return -1;
6301 : : }
6302 : 788707 : type->tp_dict = dict;
6303 : 788707 : return 0;
6304 : : }
6305 : :
6306 : :
6307 : : /* If the type dictionary doesn't contain a __doc__, set it from
6308 : : the tp_doc slot. */
6309 : : static int
6310 : 2005280 : type_dict_set_doc(PyTypeObject *type)
6311 : : {
6312 : 2005280 : int r = PyDict_Contains(type->tp_dict, &_Py_ID(__doc__));
6313 [ - + ]: 2005280 : if (r < 0) {
6314 : 0 : return -1;
6315 : : }
6316 [ + + ]: 2005280 : if (r > 0) {
6317 : 784693 : return 0;
6318 : : }
6319 : :
6320 [ + + ]: 1220587 : if (type->tp_doc != NULL) {
6321 : : const char *doc_str;
6322 : 505943 : doc_str = _PyType_DocWithoutSignature(type->tp_name, type->tp_doc);
6323 : 505943 : PyObject *doc = PyUnicode_FromString(doc_str);
6324 [ - + ]: 505943 : if (doc == NULL) {
6325 : 0 : return -1;
6326 : : }
6327 : :
6328 [ - + ]: 505943 : if (PyDict_SetItem(type->tp_dict, &_Py_ID(__doc__), doc) < 0) {
6329 : 0 : Py_DECREF(doc);
6330 : 0 : return -1;
6331 : : }
6332 : 505943 : Py_DECREF(doc);
6333 : : }
6334 : : else {
6335 [ - + ]: 714644 : if (PyDict_SetItem(type->tp_dict, &_Py_ID(__doc__), Py_None) < 0) {
6336 : 0 : return -1;
6337 : : }
6338 : : }
6339 : 1220587 : return 0;
6340 : : }
6341 : :
6342 : :
6343 : : static int
6344 : 2005280 : type_ready_fill_dict(PyTypeObject *type)
6345 : : {
6346 : : /* Add type-specific descriptors to tp_dict */
6347 [ - + ]: 2005280 : if (add_operators(type) < 0) {
6348 : 0 : return -1;
6349 : : }
6350 [ - + ]: 2005280 : if (type_add_methods(type) < 0) {
6351 : 0 : return -1;
6352 : : }
6353 [ - + ]: 2005280 : if (type_add_members(type) < 0) {
6354 : 0 : return -1;
6355 : : }
6356 [ - + ]: 2005280 : if (type_add_getset(type) < 0) {
6357 : 0 : return -1;
6358 : : }
6359 [ - + ]: 2005280 : if (type_dict_set_doc(type) < 0) {
6360 : 0 : return -1;
6361 : : }
6362 : 2005280 : return 0;
6363 : : }
6364 : :
6365 : :
6366 : : static int
6367 : 2005296 : type_ready_mro(PyTypeObject *type)
6368 : : {
6369 : : /* Calculate method resolution order */
6370 [ + + ]: 2005296 : if (mro_internal(type, NULL) < 0) {
6371 : 16 : return -1;
6372 : : }
6373 : : assert(type->tp_mro != NULL);
6374 : : assert(PyTuple_Check(type->tp_mro));
6375 : :
6376 : : /* All bases of statically allocated type should be statically allocated */
6377 [ + + ]: 2005280 : if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
6378 : 672918 : PyObject *mro = type->tp_mro;
6379 : 672918 : Py_ssize_t n = PyTuple_GET_SIZE(mro);
6380 [ + + ]: 2643945 : for (Py_ssize_t i = 0; i < n; i++) {
6381 : 1971027 : PyTypeObject *base = _PyType_CAST(PyTuple_GET_ITEM(mro, i));
6382 [ - + ]: 1971027 : if (base->tp_flags & Py_TPFLAGS_HEAPTYPE) {
6383 : 0 : PyErr_Format(PyExc_TypeError,
6384 : : "type '%.100s' is not dynamically allocated but "
6385 : : "its base type '%.100s' is dynamically allocated",
6386 : : type->tp_name, base->tp_name);
6387 : 0 : return -1;
6388 : : }
6389 : : }
6390 : : }
6391 : 2005280 : return 0;
6392 : : }
6393 : :
6394 : :
6395 : : // For static types, inherit tp_as_xxx structures from the base class
6396 : : // if it's NULL.
6397 : : //
6398 : : // For heap types, tp_as_xxx structures are not NULL: they are set to the
6399 : : // PyHeapTypeObject.as_xxx fields by type_new_alloc().
6400 : : static void
6401 : 2002316 : type_ready_inherit_as_structs(PyTypeObject *type, PyTypeObject *base)
6402 : : {
6403 [ + + ]: 2002316 : if (type->tp_as_async == NULL) {
6404 : 649797 : type->tp_as_async = base->tp_as_async;
6405 : : }
6406 [ + + ]: 2002316 : if (type->tp_as_number == NULL) {
6407 : 595885 : type->tp_as_number = base->tp_as_number;
6408 : : }
6409 [ + + ]: 2002316 : if (type->tp_as_sequence == NULL) {
6410 : 611575 : type->tp_as_sequence = base->tp_as_sequence;
6411 : : }
6412 [ + + ]: 2002316 : if (type->tp_as_mapping == NULL) {
6413 : 612591 : type->tp_as_mapping = base->tp_as_mapping;
6414 : : }
6415 [ + + ]: 2002316 : if (type->tp_as_buffer == NULL) {
6416 : 652829 : type->tp_as_buffer = base->tp_as_buffer;
6417 : : }
6418 : 2002316 : }
6419 : :
6420 : : static void
6421 : 4629456 : inherit_patma_flags(PyTypeObject *type, PyTypeObject *base) {
6422 [ + + ]: 4629456 : if ((type->tp_flags & COLLECTION_FLAGS) == 0) {
6423 : 4303925 : type->tp_flags |= base->tp_flags & COLLECTION_FLAGS;
6424 : : }
6425 : 4629456 : }
6426 : :
6427 : : static int
6428 : 2005280 : type_ready_inherit(PyTypeObject *type)
6429 : : {
6430 : : /* Inherit special flags from dominant base */
6431 : 2005280 : PyTypeObject *base = type->tp_base;
6432 [ + + ]: 2005280 : if (base != NULL) {
6433 : 2002316 : inherit_special(type, base);
6434 : : }
6435 : :
6436 : : // Inherit slots
6437 : 2005280 : PyObject *mro = type->tp_mro;
6438 : 2005280 : Py_ssize_t n = PyTuple_GET_SIZE(type->tp_mro);
6439 [ + + ]: 6634736 : for (Py_ssize_t i = 1; i < n; i++) {
6440 : 4629456 : PyObject *b = PyTuple_GET_ITEM(mro, i);
6441 [ + - ]: 4629456 : if (PyType_Check(b)) {
6442 [ - + ]: 4629456 : if (inherit_slots(type, (PyTypeObject *)b) < 0) {
6443 : 0 : return -1;
6444 : : }
6445 : 4629456 : inherit_patma_flags(type, (PyTypeObject *)b);
6446 : : }
6447 : : }
6448 : :
6449 [ + + ]: 2005280 : if (base != NULL) {
6450 : 2002316 : type_ready_inherit_as_structs(type, base);
6451 : : }
6452 : :
6453 : : /* Sanity check for tp_free. */
6454 [ + + + + ]: 2005280 : if (_PyType_IS_GC(type) && (type->tp_flags & Py_TPFLAGS_BASETYPE) &&
6455 [ + - - + ]: 1569675 : (type->tp_free == NULL || type->tp_free == PyObject_Del))
6456 : : {
6457 : : /* This base class needs to call tp_free, but doesn't have
6458 : : * one, or its tp_free is for non-gc'ed objects.
6459 : : */
6460 : 0 : PyErr_Format(PyExc_TypeError, "type '%.100s' participates in "
6461 : : "gc and is a base type but has inappropriate "
6462 : : "tp_free slot",
6463 : : type->tp_name);
6464 : 0 : return -1;
6465 : : }
6466 : :
6467 : 2005280 : return 0;
6468 : : }
6469 : :
6470 : :
6471 : : /* Hack for tp_hash and __hash__.
6472 : : If after all that, tp_hash is still NULL, and __hash__ is not in
6473 : : tp_dict, set tp_hash to PyObject_HashNotImplemented and
6474 : : tp_dict['__hash__'] equal to None.
6475 : : This signals that __hash__ is not inherited. */
6476 : : static int
6477 : 2005280 : type_ready_set_hash(PyTypeObject *type)
6478 : : {
6479 [ + + ]: 2005280 : if (type->tp_hash != NULL) {
6480 : 1902345 : return 0;
6481 : : }
6482 : :
6483 : 102935 : int r = PyDict_Contains(type->tp_dict, &_Py_ID(__hash__));
6484 [ - + ]: 102935 : if (r < 0) {
6485 : 0 : return -1;
6486 : : }
6487 [ + + ]: 102935 : if (r > 0) {
6488 : 43249 : return 0;
6489 : : }
6490 : :
6491 [ - + ]: 59686 : if (PyDict_SetItem(type->tp_dict, &_Py_ID(__hash__), Py_None) < 0) {
6492 : 0 : return -1;
6493 : : }
6494 : 59686 : type->tp_hash = PyObject_HashNotImplemented;
6495 : 59686 : return 0;
6496 : : }
6497 : :
6498 : :
6499 : : /* Link into each base class's list of subclasses */
6500 : : static int
6501 : 2005280 : type_ready_add_subclasses(PyTypeObject *type)
6502 : : {
6503 : 2005280 : PyObject *bases = type->tp_bases;
6504 : 2005280 : Py_ssize_t nbase = PyTuple_GET_SIZE(bases);
6505 [ + + ]: 4147573 : for (Py_ssize_t i = 0; i < nbase; i++) {
6506 : 2142293 : PyObject *b = PyTuple_GET_ITEM(bases, i);
6507 [ + - - + ]: 2142293 : if (PyType_Check(b) && add_subclass((PyTypeObject *)b, type) < 0) {
6508 : 0 : return -1;
6509 : : }
6510 : : }
6511 : 2005280 : return 0;
6512 : : }
6513 : :
6514 : :
6515 : : // Set tp_new and the "__new__" key in the type dictionary.
6516 : : // Use the Py_TPFLAGS_DISALLOW_INSTANTIATION flag.
6517 : : static int
6518 : 2005280 : type_ready_set_new(PyTypeObject *type)
6519 : : {
6520 : 2005280 : PyTypeObject *base = type->tp_base;
6521 : : /* The condition below could use some explanation.
6522 : :
6523 : : It appears that tp_new is not inherited for static types whose base
6524 : : class is 'object'; this seems to be a precaution so that old extension
6525 : : types don't suddenly become callable (object.__new__ wouldn't insure the
6526 : : invariants that the extension type's own factory function ensures).
6527 : :
6528 : : Heap types, of course, are under our control, so they do inherit tp_new;
6529 : : static extension types that specify some other built-in type as the
6530 : : default also inherit object.__new__. */
6531 [ + + ]: 2005280 : if (type->tp_new == NULL
6532 [ + + ]: 1556866 : && base == &PyBaseObject_Type
6533 [ + + ]: 601008 : && !(type->tp_flags & Py_TPFLAGS_HEAPTYPE))
6534 : : {
6535 : 188125 : type->tp_flags |= Py_TPFLAGS_DISALLOW_INSTANTIATION;
6536 : : }
6537 : :
6538 [ + + ]: 2005280 : if (!(type->tp_flags & Py_TPFLAGS_DISALLOW_INSTANTIATION)) {
6539 [ + + ]: 1779712 : if (type->tp_new != NULL) {
6540 : : // If "__new__" key does not exists in the type dictionary,
6541 : : // set it to tp_new_wrapper().
6542 [ - + ]: 442476 : if (add_tp_new_wrapper(type) < 0) {
6543 : 0 : return -1;
6544 : : }
6545 : : }
6546 : : else {
6547 : : // tp_new is NULL: inherit tp_new from base
6548 : 1337236 : type->tp_new = base->tp_new;
6549 : : }
6550 : : }
6551 : : else {
6552 : : // Py_TPFLAGS_DISALLOW_INSTANTIATION sets tp_new to NULL
6553 : 225568 : type->tp_new = NULL;
6554 : : }
6555 : 2005280 : return 0;
6556 : : }
6557 : :
6558 : :
6559 : : static int
6560 : 2005280 : type_ready_post_checks(PyTypeObject *type)
6561 : : {
6562 : : // bpo-44263: tp_traverse is required if Py_TPFLAGS_HAVE_GC is set.
6563 : : // Note: tp_clear is optional.
6564 [ + + ]: 2005280 : if (type->tp_flags & Py_TPFLAGS_HAVE_GC
6565 [ - + ]: 1865195 : && type->tp_traverse == NULL)
6566 : : {
6567 : 0 : PyErr_Format(PyExc_SystemError,
6568 : : "type %s has the Py_TPFLAGS_HAVE_GC flag "
6569 : : "but has no traverse function",
6570 : : type->tp_name);
6571 : 0 : return -1;
6572 : : }
6573 : 2005280 : return 0;
6574 : : }
6575 : :
6576 : :
6577 : : static int
6578 : 2005296 : type_ready(PyTypeObject *type)
6579 : : {
6580 [ - + ]: 2005296 : if (type_ready_pre_checks(type) < 0) {
6581 : 0 : return -1;
6582 : : }
6583 : :
6584 : : #ifdef Py_TRACE_REFS
6585 : : /* PyType_Ready is the closest thing we have to a choke point
6586 : : * for type objects, so is the best place I can think of to try
6587 : : * to get type objects into the doubly-linked list of all objects.
6588 : : * Still, not all type objects go through PyType_Ready.
6589 : : */
6590 : : _Py_AddToAllObjects((PyObject *)type, 0);
6591 : : #endif
6592 : :
6593 : : /* Initialize tp_dict: _PyType_IsReady() tests if tp_dict != NULL */
6594 [ - + ]: 2005296 : if (type_ready_set_dict(type) < 0) {
6595 : 0 : return -1;
6596 : : }
6597 [ - + ]: 2005296 : if (type_ready_set_bases(type) < 0) {
6598 : 0 : return -1;
6599 : : }
6600 [ + + ]: 2005296 : if (type_ready_mro(type) < 0) {
6601 : 16 : return -1;
6602 : : }
6603 [ - + ]: 2005280 : if (type_ready_set_new(type) < 0) {
6604 : 0 : return -1;
6605 : : }
6606 [ - + ]: 2005280 : if (type_ready_fill_dict(type) < 0) {
6607 : 0 : return -1;
6608 : : }
6609 [ - + ]: 2005280 : if (type_ready_inherit(type) < 0) {
6610 : 0 : return -1;
6611 : : }
6612 [ - + ]: 2005280 : if (type_ready_set_hash(type) < 0) {
6613 : 0 : return -1;
6614 : : }
6615 [ - + ]: 2005280 : if (type_ready_add_subclasses(type) < 0) {
6616 : 0 : return -1;
6617 : : }
6618 [ - + ]: 2005280 : if (type_ready_post_checks(type) < 0) {
6619 : 0 : return -1;
6620 : : }
6621 : 2005280 : return 0;
6622 : : }
6623 : :
6624 : :
6625 : : int
6626 : 2081225 : PyType_Ready(PyTypeObject *type)
6627 : : {
6628 [ + + ]: 2081225 : if (type->tp_flags & Py_TPFLAGS_READY) {
6629 : : assert(_PyType_CheckConsistency(type));
6630 : 75929 : return 0;
6631 : : }
6632 : : _PyObject_ASSERT((PyObject *)type,
6633 : : (type->tp_flags & Py_TPFLAGS_READYING) == 0);
6634 : :
6635 : 2005296 : type->tp_flags |= Py_TPFLAGS_READYING;
6636 : :
6637 : : /* Historically, all static types were immutable. See bpo-43908 */
6638 [ + + ]: 2005296 : if (!(type->tp_flags & Py_TPFLAGS_HEAPTYPE)) {
6639 : 672918 : type->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE;
6640 : : }
6641 : :
6642 [ + + ]: 2005296 : if (type_ready(type) < 0) {
6643 : 16 : type->tp_flags &= ~Py_TPFLAGS_READYING;
6644 : 16 : return -1;
6645 : : }
6646 : :
6647 : : /* All done -- set the ready flag */
6648 : 2005280 : type->tp_flags = (type->tp_flags & ~Py_TPFLAGS_READYING) | Py_TPFLAGS_READY;
6649 : : assert(_PyType_CheckConsistency(type));
6650 : 2005280 : return 0;
6651 : : }
6652 : :
6653 : :
6654 : : static int
6655 : 2142974 : add_subclass(PyTypeObject *base, PyTypeObject *type)
6656 : : {
6657 : 2142974 : PyObject *key = PyLong_FromVoidPtr((void *) type);
6658 [ - + ]: 2142974 : if (key == NULL)
6659 : 0 : return -1;
6660 : :
6661 : 2142974 : PyObject *ref = PyWeakref_NewRef((PyObject *)type, NULL);
6662 [ - + ]: 2142974 : if (ref == NULL) {
6663 : 0 : Py_DECREF(key);
6664 : 0 : return -1;
6665 : : }
6666 : :
6667 : : // Only get tp_subclasses after creating the key and value.
6668 : : // PyWeakref_NewRef() can trigger a garbage collection which can execute
6669 : : // arbitrary Python code and so modify base->tp_subclasses.
6670 : 2142974 : PyObject *subclasses = base->tp_subclasses;
6671 [ + + ]: 2142974 : if (subclasses == NULL) {
6672 : 385216 : base->tp_subclasses = subclasses = PyDict_New();
6673 [ - + ]: 385216 : if (subclasses == NULL) {
6674 : 0 : Py_DECREF(key);
6675 : 0 : Py_DECREF(ref);
6676 : 0 : return -1;
6677 : : }
6678 : : }
6679 : : assert(PyDict_CheckExact(subclasses));
6680 : :
6681 : 2142974 : int result = PyDict_SetItem(subclasses, key, ref);
6682 : 2142974 : Py_DECREF(ref);
6683 : 2142974 : Py_DECREF(key);
6684 : 2142974 : return result;
6685 : : }
6686 : :
6687 : : static int
6688 : 675 : add_all_subclasses(PyTypeObject *type, PyObject *bases)
6689 : : {
6690 : 675 : Py_ssize_t n = PyTuple_GET_SIZE(bases);
6691 : 675 : int res = 0;
6692 [ + + ]: 1356 : for (Py_ssize_t i = 0; i < n; i++) {
6693 : 681 : PyObject *obj = PyTuple_GET_ITEM(bases, i);
6694 : : // bases tuple must only contain types
6695 : 681 : PyTypeObject *base = _PyType_CAST(obj);
6696 [ - + ]: 681 : if (add_subclass(base, type) < 0) {
6697 : 0 : res = -1;
6698 : : }
6699 : : }
6700 : 675 : return res;
6701 : : }
6702 : :
6703 : : static void
6704 : 2019341 : remove_subclass(PyTypeObject *base, PyTypeObject *type)
6705 : : {
6706 : 2019341 : PyObject *subclasses = base->tp_subclasses; // borrowed ref
6707 [ + + ]: 2019341 : if (subclasses == NULL) {
6708 : 12 : return;
6709 : : }
6710 : : assert(PyDict_CheckExact(subclasses));
6711 : :
6712 : 2019329 : PyObject *key = PyLong_FromVoidPtr((void *) type);
6713 [ + + + + ]: 2019329 : if (key == NULL || PyDict_DelItem(subclasses, key)) {
6714 : : /* This can happen if the type initialization errored out before
6715 : : the base subclasses were updated (e.g. a non-str __qualname__
6716 : : was passed in the type dict). */
6717 : 859 : PyErr_Clear();
6718 : : }
6719 : 2019329 : Py_XDECREF(key);
6720 : :
6721 [ + + ]: 2019329 : if (PyDict_Size(subclasses) == 0) {
6722 : : // Delete the dictionary to save memory. _PyStaticType_Dealloc()
6723 : : // callers also test if tp_subclasses is NULL to check if a static type
6724 : : // has no subclass.
6725 [ + - ]: 366534 : Py_CLEAR(base->tp_subclasses);
6726 : : }
6727 : : }
6728 : :
6729 : : static void
6730 : 1882266 : remove_all_subclasses(PyTypeObject *type, PyObject *bases)
6731 : : {
6732 : : assert(bases != NULL);
6733 : : // remove_subclass() can clear the current exception
6734 : : assert(!PyErr_Occurred());
6735 : :
6736 [ + + ]: 3901607 : for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(bases); i++) {
6737 : 2019341 : PyObject *base = PyTuple_GET_ITEM(bases, i);
6738 [ + - ]: 2019341 : if (PyType_Check(base)) {
6739 : 2019341 : remove_subclass((PyTypeObject*) base, type);
6740 : : }
6741 : : }
6742 : : assert(!PyErr_Occurred());
6743 : 1882266 : }
6744 : :
6745 : : static int
6746 : 7705064 : check_num_args(PyObject *ob, int n)
6747 : : {
6748 [ - + ]: 7705064 : if (!PyTuple_CheckExact(ob)) {
6749 : 0 : PyErr_SetString(PyExc_SystemError,
6750 : : "PyArg_UnpackTuple() argument list is not a tuple");
6751 : 0 : return 0;
6752 : : }
6753 [ + + ]: 7705064 : if (n == PyTuple_GET_SIZE(ob))
6754 : 7705029 : return 1;
6755 [ + + ]: 35 : PyErr_Format(
6756 : : PyExc_TypeError,
6757 : : "expected %d argument%s, got %zd", n, n == 1 ? "" : "s", PyTuple_GET_SIZE(ob));
6758 : 35 : return 0;
6759 : : }
6760 : :
6761 : : /* Generic wrappers for overloadable 'operators' such as __getitem__ */
6762 : :
6763 : : /* There's a wrapper *function* for each distinct function typedef used
6764 : : for type object slots (e.g. binaryfunc, ternaryfunc, etc.). There's a
6765 : : wrapper *table* for each distinct operation (e.g. __len__, __add__).
6766 : : Most tables have only one entry; the tables for binary operators have two
6767 : : entries, one regular and one with reversed arguments. */
6768 : :
6769 : : static PyObject *
6770 : 4689 : wrap_lenfunc(PyObject *self, PyObject *args, void *wrapped)
6771 : : {
6772 : 4689 : lenfunc func = (lenfunc)wrapped;
6773 : : Py_ssize_t res;
6774 : :
6775 [ - + ]: 4689 : if (!check_num_args(args, 0))
6776 : 0 : return NULL;
6777 : 4689 : res = (*func)(self);
6778 [ - + - - ]: 4689 : if (res == -1 && PyErr_Occurred())
6779 : 0 : return NULL;
6780 : 4689 : return PyLong_FromSsize_t(res);
6781 : : }
6782 : :
6783 : : static PyObject *
6784 : 2 : wrap_inquirypred(PyObject *self, PyObject *args, void *wrapped)
6785 : : {
6786 : 2 : inquiry func = (inquiry)wrapped;
6787 : : int res;
6788 : :
6789 [ - + ]: 2 : if (!check_num_args(args, 0))
6790 : 0 : return NULL;
6791 : 2 : res = (*func)(self);
6792 [ - + - - ]: 2 : if (res == -1 && PyErr_Occurred())
6793 : 0 : return NULL;
6794 : 2 : return PyBool_FromLong((long)res);
6795 : : }
6796 : :
6797 : : static PyObject *
6798 : 4608425 : wrap_binaryfunc(PyObject *self, PyObject *args, void *wrapped)
6799 : : {
6800 : 4608425 : binaryfunc func = (binaryfunc)wrapped;
6801 : : PyObject *other;
6802 : :
6803 [ + + ]: 4608425 : if (!check_num_args(args, 1))
6804 : 14 : return NULL;
6805 : 4608411 : other = PyTuple_GET_ITEM(args, 0);
6806 : 4608411 : return (*func)(self, other);
6807 : : }
6808 : :
6809 : : static PyObject *
6810 : 45707 : wrap_binaryfunc_l(PyObject *self, PyObject *args, void *wrapped)
6811 : : {
6812 : 45707 : binaryfunc func = (binaryfunc)wrapped;
6813 : : PyObject *other;
6814 : :
6815 [ + + ]: 45707 : if (!check_num_args(args, 1))
6816 : 1 : return NULL;
6817 : 45706 : other = PyTuple_GET_ITEM(args, 0);
6818 : 45706 : return (*func)(self, other);
6819 : : }
6820 : :
6821 : : static PyObject *
6822 : 30 : wrap_binaryfunc_r(PyObject *self, PyObject *args, void *wrapped)
6823 : : {
6824 : 30 : binaryfunc func = (binaryfunc)wrapped;
6825 : : PyObject *other;
6826 : :
6827 [ - + ]: 30 : if (!check_num_args(args, 1))
6828 : 0 : return NULL;
6829 : 30 : other = PyTuple_GET_ITEM(args, 0);
6830 : 30 : return (*func)(other, self);
6831 : : }
6832 : :
6833 : : static PyObject *
6834 : 8 : wrap_ternaryfunc(PyObject *self, PyObject *args, void *wrapped)
6835 : : {
6836 : 8 : ternaryfunc func = (ternaryfunc)wrapped;
6837 : : PyObject *other;
6838 : 8 : PyObject *third = Py_None;
6839 : :
6840 : : /* Note: This wrapper only works for __pow__() */
6841 : :
6842 [ - + ]: 8 : if (!PyArg_UnpackTuple(args, "", 1, 2, &other, &third))
6843 : 0 : return NULL;
6844 : 8 : return (*func)(self, other, third);
6845 : : }
6846 : :
6847 : : static PyObject *
6848 : 1 : wrap_ternaryfunc_r(PyObject *self, PyObject *args, void *wrapped)
6849 : : {
6850 : 1 : ternaryfunc func = (ternaryfunc)wrapped;
6851 : : PyObject *other;
6852 : 1 : PyObject *third = Py_None;
6853 : :
6854 : : /* Note: This wrapper only works for __pow__() */
6855 : :
6856 [ - + ]: 1 : if (!PyArg_UnpackTuple(args, "", 1, 2, &other, &third))
6857 : 0 : return NULL;
6858 : 1 : return (*func)(other, self, third);
6859 : : }
6860 : :
6861 : : static PyObject *
6862 : 49810 : wrap_unaryfunc(PyObject *self, PyObject *args, void *wrapped)
6863 : : {
6864 : 49810 : unaryfunc func = (unaryfunc)wrapped;
6865 : :
6866 [ + + ]: 49810 : if (!check_num_args(args, 0))
6867 : 1 : return NULL;
6868 : 49809 : return (*func)(self);
6869 : : }
6870 : :
6871 : : static PyObject *
6872 : 67 : wrap_indexargfunc(PyObject *self, PyObject *args, void *wrapped)
6873 : : {
6874 : 67 : ssizeargfunc func = (ssizeargfunc)wrapped;
6875 : : PyObject* o;
6876 : : Py_ssize_t i;
6877 : :
6878 [ + + ]: 67 : if (!PyArg_UnpackTuple(args, "", 1, 1, &o))
6879 : 1 : return NULL;
6880 : 66 : i = PyNumber_AsSsize_t(o, PyExc_OverflowError);
6881 [ + + + + ]: 66 : if (i == -1 && PyErr_Occurred())
6882 : 27 : return NULL;
6883 : 39 : return (*func)(self, i);
6884 : : }
6885 : :
6886 : : static Py_ssize_t
6887 : 4 : getindex(PyObject *self, PyObject *arg)
6888 : : {
6889 : : Py_ssize_t i;
6890 : :
6891 : 4 : i = PyNumber_AsSsize_t(arg, PyExc_OverflowError);
6892 [ + + - + ]: 4 : if (i == -1 && PyErr_Occurred())
6893 : 0 : return -1;
6894 [ + + ]: 4 : if (i < 0) {
6895 : 2 : PySequenceMethods *sq = Py_TYPE(self)->tp_as_sequence;
6896 [ + - + - ]: 2 : if (sq && sq->sq_length) {
6897 : 2 : Py_ssize_t n = (*sq->sq_length)(self);
6898 [ - + ]: 2 : if (n < 0) {
6899 : : assert(PyErr_Occurred());
6900 : 0 : return -1;
6901 : : }
6902 : 2 : i += n;
6903 : : }
6904 : : }
6905 : 4 : return i;
6906 : : }
6907 : :
6908 : : static PyObject *
6909 : 2 : wrap_sq_item(PyObject *self, PyObject *args, void *wrapped)
6910 : : {
6911 : 2 : ssizeargfunc func = (ssizeargfunc)wrapped;
6912 : : PyObject *arg;
6913 : : Py_ssize_t i;
6914 : :
6915 [ + - ]: 2 : if (PyTuple_GET_SIZE(args) == 1) {
6916 : 2 : arg = PyTuple_GET_ITEM(args, 0);
6917 : 2 : i = getindex(self, arg);
6918 [ + + - + ]: 2 : if (i == -1 && PyErr_Occurred())
6919 : 0 : return NULL;
6920 : 2 : return (*func)(self, i);
6921 : : }
6922 : 0 : check_num_args(args, 1);
6923 : : assert(PyErr_Occurred());
6924 : 0 : return NULL;
6925 : : }
6926 : :
6927 : : static PyObject *
6928 : 0 : wrap_sq_setitem(PyObject *self, PyObject *args, void *wrapped)
6929 : : {
6930 : 0 : ssizeobjargproc func = (ssizeobjargproc)wrapped;
6931 : : Py_ssize_t i;
6932 : : int res;
6933 : : PyObject *arg, *value;
6934 : :
6935 [ # # ]: 0 : if (!PyArg_UnpackTuple(args, "", 2, 2, &arg, &value))
6936 : 0 : return NULL;
6937 : 0 : i = getindex(self, arg);
6938 [ # # # # ]: 0 : if (i == -1 && PyErr_Occurred())
6939 : 0 : return NULL;
6940 : 0 : res = (*func)(self, i, value);
6941 [ # # # # ]: 0 : if (res == -1 && PyErr_Occurred())
6942 : 0 : return NULL;
6943 : 0 : Py_RETURN_NONE;
6944 : : }
6945 : :
6946 : : static PyObject *
6947 : 2 : wrap_sq_delitem(PyObject *self, PyObject *args, void *wrapped)
6948 : : {
6949 : 2 : ssizeobjargproc func = (ssizeobjargproc)wrapped;
6950 : : Py_ssize_t i;
6951 : : int res;
6952 : : PyObject *arg;
6953 : :
6954 [ - + ]: 2 : if (!check_num_args(args, 1))
6955 : 0 : return NULL;
6956 : 2 : arg = PyTuple_GET_ITEM(args, 0);
6957 : 2 : i = getindex(self, arg);
6958 [ + + - + ]: 2 : if (i == -1 && PyErr_Occurred())
6959 : 0 : return NULL;
6960 : 2 : res = (*func)(self, i, NULL);
6961 [ + - + - ]: 2 : if (res == -1 && PyErr_Occurred())
6962 : 2 : return NULL;
6963 : 0 : Py_RETURN_NONE;
6964 : : }
6965 : :
6966 : : /* XXX objobjproc is a misnomer; should be objargpred */
6967 : : static PyObject *
6968 : 68 : wrap_objobjproc(PyObject *self, PyObject *args, void *wrapped)
6969 : : {
6970 : 68 : objobjproc func = (objobjproc)wrapped;
6971 : : int res;
6972 : : PyObject *value;
6973 : :
6974 [ + + ]: 68 : if (!check_num_args(args, 1))
6975 : 4 : return NULL;
6976 : 64 : value = PyTuple_GET_ITEM(args, 0);
6977 : 64 : res = (*func)(self, value);
6978 [ + + + - ]: 64 : if (res == -1 && PyErr_Occurred())
6979 : 6 : return NULL;
6980 : : else
6981 : 58 : return PyBool_FromLong(res);
6982 : : }
6983 : :
6984 : : static PyObject *
6985 : 273611 : wrap_objobjargproc(PyObject *self, PyObject *args, void *wrapped)
6986 : : {
6987 : 273611 : objobjargproc func = (objobjargproc)wrapped;
6988 : : int res;
6989 : : PyObject *key, *value;
6990 : :
6991 [ + + ]: 273611 : if (!PyArg_UnpackTuple(args, "", 2, 2, &key, &value))
6992 : 29 : return NULL;
6993 : 273582 : res = (*func)(self, key, value);
6994 [ + + + - ]: 273582 : if (res == -1 && PyErr_Occurred())
6995 : 452 : return NULL;
6996 : 273130 : Py_RETURN_NONE;
6997 : : }
6998 : :
6999 : : static PyObject *
7000 : 21757 : wrap_delitem(PyObject *self, PyObject *args, void *wrapped)
7001 : : {
7002 : 21757 : objobjargproc func = (objobjargproc)wrapped;
7003 : : int res;
7004 : : PyObject *key;
7005 : :
7006 [ + + ]: 21757 : if (!check_num_args(args, 1))
7007 : 14 : return NULL;
7008 : 21743 : key = PyTuple_GET_ITEM(args, 0);
7009 : 21743 : res = (*func)(self, key, NULL);
7010 [ + + + - ]: 21743 : if (res == -1 && PyErr_Occurred())
7011 : 50 : return NULL;
7012 : 21693 : Py_RETURN_NONE;
7013 : : }
7014 : :
7015 : : /* Helper to check for object.__setattr__ or __delattr__ applied to a type.
7016 : : This is called the Carlo Verre hack after its discoverer. See
7017 : : https://mail.python.org/pipermail/python-dev/2003-April/034535.html
7018 : : */
7019 : : static int
7020 : 1151010 : hackcheck(PyObject *self, setattrofunc func, const char *what)
7021 : : {
7022 : 1151010 : PyTypeObject *type = Py_TYPE(self);
7023 : 1151010 : PyObject *mro = type->tp_mro;
7024 [ - + ]: 1151010 : if (!mro) {
7025 : : /* Probably ok not to check the call in this case. */
7026 : 0 : return 1;
7027 : : }
7028 : : assert(PyTuple_Check(mro));
7029 : :
7030 : : /* Find the (base) type that defined the type's slot function. */
7031 : 1151010 : PyTypeObject *defining_type = type;
7032 : : Py_ssize_t i;
7033 [ + + ]: 5371919 : for (i = PyTuple_GET_SIZE(mro) - 1; i >= 0; i--) {
7034 : 4220932 : PyTypeObject *base = _PyType_CAST(PyTuple_GET_ITEM(mro, i));
7035 [ + + ]: 4220932 : if (base->tp_setattro == slot_tp_setattro) {
7036 : : /* Ignore Python classes:
7037 : : they never define their own C-level setattro. */
7038 : : }
7039 [ + + ]: 2453987 : else if (base->tp_setattro == type->tp_setattro) {
7040 : 23 : defining_type = base;
7041 : 23 : break;
7042 : : }
7043 : : }
7044 : :
7045 : : /* Reject calls that jump over intermediate C-level overrides. */
7046 [ + - ]: 2463672 : for (PyTypeObject *base = defining_type; base; base = base->tp_base) {
7047 [ + + ]: 2463672 : if (base->tp_setattro == func) {
7048 : : /* 'func' is the right slot function to call. */
7049 : 1151007 : break;
7050 : : }
7051 [ + + ]: 1312665 : else if (base->tp_setattro != slot_tp_setattro) {
7052 : : /* 'base' is not a Python class and overrides 'func'.
7053 : : Its tp_setattro should be called instead. */
7054 : 3 : PyErr_Format(PyExc_TypeError,
7055 : : "can't apply this %s to %s object",
7056 : : what,
7057 : : type->tp_name);
7058 : 3 : return 0;
7059 : : }
7060 : : }
7061 : 1151007 : return 1;
7062 : : }
7063 : :
7064 : : static PyObject *
7065 : 1051230 : wrap_setattr(PyObject *self, PyObject *args, void *wrapped)
7066 : : {
7067 : 1051230 : setattrofunc func = (setattrofunc)wrapped;
7068 : : int res;
7069 : : PyObject *name, *value;
7070 : :
7071 [ - + ]: 1051230 : if (!PyArg_UnpackTuple(args, "", 2, 2, &name, &value))
7072 : 0 : return NULL;
7073 [ + + ]: 1051230 : if (!hackcheck(self, func, "__setattr__"))
7074 : 2 : return NULL;
7075 : 1051228 : res = (*func)(self, name, value);
7076 [ + + ]: 1051228 : if (res < 0)
7077 : 3 : return NULL;
7078 : 1051225 : Py_RETURN_NONE;
7079 : : }
7080 : :
7081 : : static PyObject *
7082 : 99781 : wrap_delattr(PyObject *self, PyObject *args, void *wrapped)
7083 : : {
7084 : 99781 : setattrofunc func = (setattrofunc)wrapped;
7085 : : int res;
7086 : : PyObject *name;
7087 : :
7088 [ + + ]: 99781 : if (!check_num_args(args, 1))
7089 : 1 : return NULL;
7090 : 99780 : name = PyTuple_GET_ITEM(args, 0);
7091 [ + + ]: 99780 : if (!hackcheck(self, func, "__delattr__"))
7092 : 1 : return NULL;
7093 : 99779 : res = (*func)(self, name, NULL);
7094 [ + + ]: 99779 : if (res < 0)
7095 : 20 : return NULL;
7096 : 99759 : Py_RETURN_NONE;
7097 : : }
7098 : :
7099 : : static PyObject *
7100 : 606648 : wrap_hashfunc(PyObject *self, PyObject *args, void *wrapped)
7101 : : {
7102 : 606648 : hashfunc func = (hashfunc)wrapped;
7103 : : Py_hash_t res;
7104 : :
7105 [ - + ]: 606648 : if (!check_num_args(args, 0))
7106 : 0 : return NULL;
7107 : 606648 : res = (*func)(self);
7108 [ + + + - ]: 606648 : if (res == -1 && PyErr_Occurred())
7109 : 4 : return NULL;
7110 : 606644 : return PyLong_FromSsize_t(res);
7111 : : }
7112 : :
7113 : : static PyObject *
7114 : 24 : wrap_call(PyObject *self, PyObject *args, void *wrapped, PyObject *kwds)
7115 : : {
7116 : 24 : ternaryfunc func = (ternaryfunc)wrapped;
7117 : :
7118 : 24 : return (*func)(self, args, kwds);
7119 : : }
7120 : :
7121 : : static PyObject *
7122 : 9 : wrap_del(PyObject *self, PyObject *args, void *wrapped)
7123 : : {
7124 : 9 : destructor func = (destructor)wrapped;
7125 : :
7126 [ - + ]: 9 : if (!check_num_args(args, 0))
7127 : 0 : return NULL;
7128 : :
7129 : 9 : (*func)(self);
7130 : 9 : Py_RETURN_NONE;
7131 : : }
7132 : :
7133 : : static PyObject *
7134 : 126623 : wrap_richcmpfunc(PyObject *self, PyObject *args, void *wrapped, int op)
7135 : : {
7136 : 126623 : richcmpfunc func = (richcmpfunc)wrapped;
7137 : : PyObject *other;
7138 : :
7139 [ - + ]: 126623 : if (!check_num_args(args, 1))
7140 : 0 : return NULL;
7141 : 126623 : other = PyTuple_GET_ITEM(args, 0);
7142 : 126623 : return (*func)(self, other, op);
7143 : : }
7144 : :
7145 : : #undef RICHCMP_WRAPPER
7146 : : #define RICHCMP_WRAPPER(NAME, OP) \
7147 : : static PyObject * \
7148 : : richcmp_##NAME(PyObject *self, PyObject *args, void *wrapped) \
7149 : : { \
7150 : : return wrap_richcmpfunc(self, args, wrapped, OP); \
7151 : : }
7152 : :
7153 : 54 : RICHCMP_WRAPPER(lt, Py_LT)
7154 : 29 : RICHCMP_WRAPPER(le, Py_LE)
7155 : 117546 : RICHCMP_WRAPPER(eq, Py_EQ)
7156 : 8930 : RICHCMP_WRAPPER(ne, Py_NE)
7157 : 37 : RICHCMP_WRAPPER(gt, Py_GT)
7158 : 27 : RICHCMP_WRAPPER(ge, Py_GE)
7159 : :
7160 : : static PyObject *
7161 : 2141510 : wrap_next(PyObject *self, PyObject *args, void *wrapped)
7162 : : {
7163 : 2141510 : unaryfunc func = (unaryfunc)wrapped;
7164 : : PyObject *res;
7165 : :
7166 [ - + ]: 2141510 : if (!check_num_args(args, 0))
7167 : 0 : return NULL;
7168 : 2141510 : res = (*func)(self);
7169 [ + + + + ]: 2141510 : if (res == NULL && !PyErr_Occurred())
7170 : 7165 : PyErr_SetNone(PyExc_StopIteration);
7171 : 2141510 : return res;
7172 : : }
7173 : :
7174 : : static PyObject *
7175 : 1172 : wrap_descr_get(PyObject *self, PyObject *args, void *wrapped)
7176 : : {
7177 : 1172 : descrgetfunc func = (descrgetfunc)wrapped;
7178 : : PyObject *obj;
7179 : 1172 : PyObject *type = NULL;
7180 : :
7181 [ - + ]: 1172 : if (!PyArg_UnpackTuple(args, "", 1, 2, &obj, &type))
7182 : 0 : return NULL;
7183 [ + + ]: 1172 : if (obj == Py_None)
7184 : 68 : obj = NULL;
7185 [ + + ]: 1172 : if (type == Py_None)
7186 : 1 : type = NULL;
7187 [ + + + + ]: 1172 : if (type == NULL && obj == NULL) {
7188 : 1 : PyErr_SetString(PyExc_TypeError,
7189 : : "__get__(None, None) is invalid");
7190 : 1 : return NULL;
7191 : : }
7192 : 1171 : return (*func)(self, obj, type);
7193 : : }
7194 : :
7195 : : static PyObject *
7196 : 634 : wrap_descr_set(PyObject *self, PyObject *args, void *wrapped)
7197 : : {
7198 : 634 : descrsetfunc func = (descrsetfunc)wrapped;
7199 : : PyObject *obj, *value;
7200 : : int ret;
7201 : :
7202 [ - + ]: 634 : if (!PyArg_UnpackTuple(args, "", 2, 2, &obj, &value))
7203 : 0 : return NULL;
7204 : 634 : ret = (*func)(self, obj, value);
7205 [ + + ]: 634 : if (ret < 0)
7206 : 16 : return NULL;
7207 : 618 : Py_RETURN_NONE;
7208 : : }
7209 : :
7210 : : static PyObject *
7211 : 3 : wrap_descr_delete(PyObject *self, PyObject *args, void *wrapped)
7212 : : {
7213 : 3 : descrsetfunc func = (descrsetfunc)wrapped;
7214 : : PyObject *obj;
7215 : : int ret;
7216 : :
7217 [ - + ]: 3 : if (!check_num_args(args, 1))
7218 : 0 : return NULL;
7219 : 3 : obj = PyTuple_GET_ITEM(args, 0);
7220 : 3 : ret = (*func)(self, obj, NULL);
7221 [ + + ]: 3 : if (ret < 0)
7222 : 2 : return NULL;
7223 : 1 : Py_RETURN_NONE;
7224 : : }
7225 : :
7226 : : static PyObject *
7227 : 5030238 : wrap_init(PyObject *self, PyObject *args, void *wrapped, PyObject *kwds)
7228 : : {
7229 : 5030238 : initproc func = (initproc)wrapped;
7230 : :
7231 [ + + ]: 5030238 : if (func(self, args, kwds) < 0)
7232 : 63 : return NULL;
7233 : 5030175 : Py_RETURN_NONE;
7234 : : }
7235 : :
7236 : : static PyObject *
7237 : 10995367 : tp_new_wrapper(PyObject *self, PyObject *args, PyObject *kwds)
7238 : : {
7239 : : PyTypeObject *staticbase;
7240 : : PyObject *arg0, *res;
7241 : :
7242 [ + - - + ]: 10995367 : if (self == NULL || !PyType_Check(self)) {
7243 : 0 : PyErr_Format(PyExc_SystemError,
7244 : : "__new__() called with non-type 'self'");
7245 : 0 : return NULL;
7246 : : }
7247 : 10995367 : PyTypeObject *type = (PyTypeObject *)self;
7248 : :
7249 [ + - + + ]: 10995367 : if (!PyTuple_Check(args) || PyTuple_GET_SIZE(args) < 1) {
7250 : 3 : PyErr_Format(PyExc_TypeError,
7251 : : "%s.__new__(): not enough arguments",
7252 : : type->tp_name);
7253 : 3 : return NULL;
7254 : : }
7255 : 10995364 : arg0 = PyTuple_GET_ITEM(args, 0);
7256 [ + + ]: 10995364 : if (!PyType_Check(arg0)) {
7257 : 5 : PyErr_Format(PyExc_TypeError,
7258 : : "%s.__new__(X): X is not a type object (%s)",
7259 : : type->tp_name,
7260 : 5 : Py_TYPE(arg0)->tp_name);
7261 : 5 : return NULL;
7262 : : }
7263 : 10995359 : PyTypeObject *subtype = (PyTypeObject *)arg0;
7264 : :
7265 [ + + ]: 10995359 : if (!PyType_IsSubtype(subtype, type)) {
7266 : 1 : PyErr_Format(PyExc_TypeError,
7267 : : "%s.__new__(%s): %s is not a subtype of %s",
7268 : : type->tp_name,
7269 : : subtype->tp_name,
7270 : : subtype->tp_name,
7271 : : type->tp_name);
7272 : 1 : return NULL;
7273 : : }
7274 : :
7275 : : /* Check that the use doesn't do something silly and unsafe like
7276 : : object.__new__(dict). To do this, we check that the
7277 : : most derived base that's not a heap type is this type. */
7278 : 10995358 : staticbase = subtype;
7279 [ + - + + ]: 30604879 : while (staticbase && (staticbase->tp_new == slot_tp_new))
7280 : 19609521 : staticbase = staticbase->tp_base;
7281 : : /* If staticbase is NULL now, it is a really weird type.
7282 : : In the spirit of backwards compatibility (?), just shut up. */
7283 [ + - + + ]: 10995358 : if (staticbase && staticbase->tp_new != type->tp_new) {
7284 : 4 : PyErr_Format(PyExc_TypeError,
7285 : : "%s.__new__(%s) is not safe, use %s.__new__()",
7286 : : type->tp_name,
7287 : : subtype->tp_name,
7288 : : staticbase->tp_name);
7289 : 4 : return NULL;
7290 : : }
7291 : :
7292 : 10995354 : args = PyTuple_GetSlice(args, 1, PyTuple_GET_SIZE(args));
7293 [ - + ]: 10995354 : if (args == NULL)
7294 : 0 : return NULL;
7295 : 10995354 : res = type->tp_new(subtype, args, kwds);
7296 : 10995354 : Py_DECREF(args);
7297 : 10995354 : return res;
7298 : : }
7299 : :
7300 : : static struct PyMethodDef tp_new_methoddef[] = {
7301 : : {"__new__", _PyCFunction_CAST(tp_new_wrapper), METH_VARARGS|METH_KEYWORDS,
7302 : : PyDoc_STR("__new__($type, *args, **kwargs)\n--\n\n"
7303 : : "Create and return a new object. "
7304 : : "See help(type) for accurate signature.")},
7305 : : {0}
7306 : : };
7307 : :
7308 : : static int
7309 : 442476 : add_tp_new_wrapper(PyTypeObject *type)
7310 : : {
7311 : 442476 : int r = PyDict_Contains(type->tp_dict, &_Py_ID(__new__));
7312 [ - + ]: 442476 : if (r > 0) {
7313 : 0 : return 0;
7314 : : }
7315 [ - + ]: 442476 : if (r < 0) {
7316 : 0 : return -1;
7317 : : }
7318 : :
7319 : 442476 : PyObject *func = PyCFunction_NewEx(tp_new_methoddef, (PyObject *)type, NULL);
7320 [ - + ]: 442476 : if (func == NULL) {
7321 : 0 : return -1;
7322 : : }
7323 : 442476 : r = PyDict_SetItem(type->tp_dict, &_Py_ID(__new__), func);
7324 : 442476 : Py_DECREF(func);
7325 : 442476 : return r;
7326 : : }
7327 : :
7328 : : /* Slot wrappers that call the corresponding __foo__ slot. See comments
7329 : : below at override_slots() for more explanation. */
7330 : :
7331 : : #define SLOT0(FUNCNAME, DUNDER) \
7332 : : static PyObject * \
7333 : : FUNCNAME(PyObject *self) \
7334 : : { \
7335 : : PyObject* stack[1] = {self}; \
7336 : : return vectorcall_method(&_Py_ID(DUNDER), stack, 1); \
7337 : : }
7338 : :
7339 : : #define SLOT1(FUNCNAME, DUNDER, ARG1TYPE) \
7340 : : static PyObject * \
7341 : : FUNCNAME(PyObject *self, ARG1TYPE arg1) \
7342 : : { \
7343 : : PyObject* stack[2] = {self, arg1}; \
7344 : : return vectorcall_method(&_Py_ID(DUNDER), stack, 2); \
7345 : : }
7346 : :
7347 : : /* Boolean helper for SLOT1BINFULL().
7348 : : right.__class__ is a nontrivial subclass of left.__class__. */
7349 : : static int
7350 : 10 : method_is_overloaded(PyObject *left, PyObject *right, PyObject *name)
7351 : : {
7352 : : PyObject *a, *b;
7353 : : int ok;
7354 : :
7355 [ - + ]: 10 : if (_PyObject_LookupAttr((PyObject *)(Py_TYPE(right)), name, &b) < 0) {
7356 : 0 : return -1;
7357 : : }
7358 [ - + ]: 10 : if (b == NULL) {
7359 : : /* If right doesn't have it, it's not overloaded */
7360 : 0 : return 0;
7361 : : }
7362 : :
7363 [ - + ]: 10 : if (_PyObject_LookupAttr((PyObject *)(Py_TYPE(left)), name, &a) < 0) {
7364 : 0 : Py_DECREF(b);
7365 : 0 : return -1;
7366 : : }
7367 [ - + ]: 10 : if (a == NULL) {
7368 : 0 : Py_DECREF(b);
7369 : : /* If right has it but left doesn't, it's overloaded */
7370 : 0 : return 1;
7371 : : }
7372 : :
7373 : 10 : ok = PyObject_RichCompareBool(a, b, Py_NE);
7374 : 10 : Py_DECREF(a);
7375 : 10 : Py_DECREF(b);
7376 : 10 : return ok;
7377 : : }
7378 : :
7379 : :
7380 : : #define SLOT1BINFULL(FUNCNAME, TESTFUNC, SLOTNAME, DUNDER, RDUNDER) \
7381 : : static PyObject * \
7382 : : FUNCNAME(PyObject *self, PyObject *other) \
7383 : : { \
7384 : : PyObject* stack[2]; \
7385 : : PyThreadState *tstate = _PyThreadState_GET(); \
7386 : : int do_other = !Py_IS_TYPE(self, Py_TYPE(other)) && \
7387 : : Py_TYPE(other)->tp_as_number != NULL && \
7388 : : Py_TYPE(other)->tp_as_number->SLOTNAME == TESTFUNC; \
7389 : : if (Py_TYPE(self)->tp_as_number != NULL && \
7390 : : Py_TYPE(self)->tp_as_number->SLOTNAME == TESTFUNC) { \
7391 : : PyObject *r; \
7392 : : if (do_other && PyType_IsSubtype(Py_TYPE(other), Py_TYPE(self))) { \
7393 : : int ok = method_is_overloaded(self, other, &_Py_ID(RDUNDER)); \
7394 : : if (ok < 0) { \
7395 : : return NULL; \
7396 : : } \
7397 : : if (ok) { \
7398 : : stack[0] = other; \
7399 : : stack[1] = self; \
7400 : : r = vectorcall_maybe(tstate, &_Py_ID(RDUNDER), stack, 2); \
7401 : : if (r != Py_NotImplemented) \
7402 : : return r; \
7403 : : Py_DECREF(r); \
7404 : : do_other = 0; \
7405 : : } \
7406 : : } \
7407 : : stack[0] = self; \
7408 : : stack[1] = other; \
7409 : : r = vectorcall_maybe(tstate, &_Py_ID(DUNDER), stack, 2); \
7410 : : if (r != Py_NotImplemented || \
7411 : : Py_IS_TYPE(other, Py_TYPE(self))) \
7412 : : return r; \
7413 : : Py_DECREF(r); \
7414 : : } \
7415 : : if (do_other) { \
7416 : : stack[0] = other; \
7417 : : stack[1] = self; \
7418 : : return vectorcall_maybe(tstate, &_Py_ID(RDUNDER), stack, 2); \
7419 : : } \
7420 : : Py_RETURN_NOTIMPLEMENTED; \
7421 : : }
7422 : :
7423 : : #define SLOT1BIN(FUNCNAME, SLOTNAME, DUNDER, RDUNDER) \
7424 : : SLOT1BINFULL(FUNCNAME, FUNCNAME, SLOTNAME, DUNDER, RDUNDER)
7425 : :
7426 : : static Py_ssize_t
7427 : 1250589 : slot_sq_length(PyObject *self)
7428 : : {
7429 : 1250589 : PyObject* stack[1] = {self};
7430 : 1250589 : PyObject *res = vectorcall_method(&_Py_ID(__len__), stack, 1);
7431 : : Py_ssize_t len;
7432 : :
7433 [ + + ]: 1250589 : if (res == NULL)
7434 : 11 : return -1;
7435 : :
7436 : 1250578 : Py_SETREF(res, _PyNumber_Index(res));
7437 [ + + ]: 1250578 : if (res == NULL)
7438 : 4 : return -1;
7439 : :
7440 : : assert(PyLong_Check(res));
7441 [ + + ]: 1250574 : if (Py_SIZE(res) < 0) {
7442 : 5 : Py_DECREF(res);
7443 : 5 : PyErr_SetString(PyExc_ValueError,
7444 : : "__len__() should return >= 0");
7445 : 5 : return -1;
7446 : : }
7447 : :
7448 : 1250569 : len = PyNumber_AsSsize_t(res, PyExc_OverflowError);
7449 : : assert(len >= 0 || PyErr_ExceptionMatches(PyExc_OverflowError));
7450 : 1250569 : Py_DECREF(res);
7451 : 1250569 : return len;
7452 : : }
7453 : :
7454 : : static PyObject *
7455 : 1123603 : slot_sq_item(PyObject *self, Py_ssize_t i)
7456 : : {
7457 : 1123603 : PyObject *ival = PyLong_FromSsize_t(i);
7458 [ - + ]: 1123603 : if (ival == NULL) {
7459 : 0 : return NULL;
7460 : : }
7461 : 1123603 : PyObject *stack[2] = {self, ival};
7462 : 1123603 : PyObject *retval = vectorcall_method(&_Py_ID(__getitem__), stack, 2);
7463 : 1123603 : Py_DECREF(ival);
7464 : 1123603 : return retval;
7465 : : }
7466 : :
7467 : : static int
7468 : 863 : slot_sq_ass_item(PyObject *self, Py_ssize_t index, PyObject *value)
7469 : : {
7470 : : PyObject *stack[3];
7471 : : PyObject *res;
7472 : : PyObject *index_obj;
7473 : :
7474 : 863 : index_obj = PyLong_FromSsize_t(index);
7475 [ - + ]: 863 : if (index_obj == NULL) {
7476 : 0 : return -1;
7477 : : }
7478 : :
7479 : 863 : stack[0] = self;
7480 : 863 : stack[1] = index_obj;
7481 [ - + ]: 863 : if (value == NULL) {
7482 : 0 : res = vectorcall_method(&_Py_ID(__delitem__), stack, 2);
7483 : : }
7484 : : else {
7485 : 863 : stack[2] = value;
7486 : 863 : res = vectorcall_method(&_Py_ID(__setitem__), stack, 3);
7487 : : }
7488 : 863 : Py_DECREF(index_obj);
7489 : :
7490 [ + + ]: 863 : if (res == NULL) {
7491 : 15 : return -1;
7492 : : }
7493 : 848 : Py_DECREF(res);
7494 : 848 : return 0;
7495 : : }
7496 : :
7497 : : static int
7498 : 423956 : slot_sq_contains(PyObject *self, PyObject *value)
7499 : : {
7500 : 423956 : PyThreadState *tstate = _PyThreadState_GET();
7501 : : PyObject *func, *res;
7502 : 423956 : int result = -1, unbound;
7503 : :
7504 : 423956 : func = lookup_maybe_method(self, &_Py_ID(__contains__), &unbound);
7505 [ + + ]: 423956 : if (func == Py_None) {
7506 : 1 : Py_DECREF(func);
7507 : 1 : PyErr_Format(PyExc_TypeError,
7508 : : "'%.200s' object is not a container",
7509 : 1 : Py_TYPE(self)->tp_name);
7510 : 1 : return -1;
7511 : : }
7512 [ + - ]: 423955 : if (func != NULL) {
7513 : 423955 : PyObject *args[2] = {self, value};
7514 : 423955 : res = vectorcall_unbound(tstate, unbound, func, args, 2);
7515 : 423955 : Py_DECREF(func);
7516 [ + + ]: 423955 : if (res != NULL) {
7517 : 423952 : result = PyObject_IsTrue(res);
7518 : 423952 : Py_DECREF(res);
7519 : : }
7520 : : }
7521 [ # # ]: 0 : else if (! PyErr_Occurred()) {
7522 : : /* Possible results: -1 and 1 */
7523 : 0 : result = (int)_PySequence_IterSearch(self, value,
7524 : : PY_ITERSEARCH_CONTAINS);
7525 : : }
7526 : 423955 : return result;
7527 : : }
7528 : :
7529 : : #define slot_mp_length slot_sq_length
7530 : :
7531 : 1264013 : SLOT1(slot_mp_subscript, __getitem__, PyObject *)
7532 : :
7533 : : static int
7534 : 1260759 : slot_mp_ass_subscript(PyObject *self, PyObject *key, PyObject *value)
7535 : : {
7536 : : PyObject *stack[3];
7537 : : PyObject *res;
7538 : :
7539 : 1260759 : stack[0] = self;
7540 : 1260759 : stack[1] = key;
7541 [ + + ]: 1260759 : if (value == NULL) {
7542 : 57721 : res = vectorcall_method(&_Py_ID(__delitem__), stack, 2);
7543 : : }
7544 : : else {
7545 : 1203038 : stack[2] = value;
7546 : 1203038 : res = vectorcall_method(&_Py_ID(__setitem__), stack, 3);
7547 : : }
7548 : :
7549 [ + + ]: 1260759 : if (res == NULL)
7550 : 251 : return -1;
7551 : 1260508 : Py_DECREF(res);
7552 : 1260508 : return 0;
7553 : : }
7554 : :
7555 [ + + + + : 157334 : SLOT1BIN(slot_nb_add, nb_add, __add__, __radd__)
+ + + + +
+ + + - +
- - - - -
- + + + +
+ + ]
7556 [ + + + + : 23076 : SLOT1BIN(slot_nb_subtract, nb_subtract, __sub__, __rsub__)
+ + + - +
+ + + - +
- - - - -
- + + + +
+ + ]
7557 [ + + + + : 2630 : SLOT1BIN(slot_nb_multiply, nb_multiply, __mul__, __rmul__)
+ + + - +
+ + + - +
- - - - -
- + + + +
+ + ]
7558 [ + + + - : 19 : SLOT1BIN(slot_nb_matrix_multiply, nb_matrix_multiply, __matmul__, __rmatmul__)
+ + + - +
+ - + - -
- - - - -
- + + + +
+ + ]
7559 [ + + + - : 49 : SLOT1BIN(slot_nb_remainder, nb_remainder, __mod__, __rmod__)
+ + + - +
+ + + + +
- + + - +
- + + + +
+ + ]
7560 [ + + + - : 2599 : SLOT1BIN(slot_nb_divmod, nb_divmod, __divmod__, __rdivmod__)
+ + + - +
+ + + - +
- - - - -
- + + + +
+ + ]
7561 : :
7562 : : static PyObject *slot_nb_power(PyObject *, PyObject *, PyObject *);
7563 : :
7564 [ + + + - : 117450 : SLOT1BINFULL(slot_nb_power_binary, slot_nb_power, nb_power, __pow__, __rpow__)
+ + + + +
+ + + - +
- - - - -
- + + + +
+ + ]
7565 : :
7566 : : static PyObject *
7567 : 117453 : slot_nb_power(PyObject *self, PyObject *other, PyObject *modulus)
7568 : : {
7569 [ + + ]: 117453 : if (modulus == Py_None)
7570 : 117450 : return slot_nb_power_binary(self, other);
7571 : : /* Three-arg power doesn't use __rpow__. But ternary_op
7572 : : can call this when the second argument's type uses
7573 : : slot_nb_power, so check before calling self.__pow__. */
7574 [ + - ]: 3 : if (Py_TYPE(self)->tp_as_number != NULL &&
7575 [ + + ]: 3 : Py_TYPE(self)->tp_as_number->nb_power == slot_nb_power) {
7576 : 2 : PyObject* stack[3] = {self, other, modulus};
7577 : 2 : return vectorcall_method(&_Py_ID(__pow__), stack, 3);
7578 : : }
7579 : 1 : Py_RETURN_NOTIMPLEMENTED;
7580 : : }
7581 : :
7582 : 11861 : SLOT0(slot_nb_negative, __neg__)
7583 : 11 : SLOT0(slot_nb_positive, __pos__)
7584 : 39989 : SLOT0(slot_nb_absolute, __abs__)
7585 : :
7586 : : static int
7587 : 361282 : slot_nb_bool(PyObject *self)
7588 : : {
7589 : : PyObject *func, *value;
7590 : : int result, unbound;
7591 : 361282 : int using_len = 0;
7592 : :
7593 : 361282 : func = lookup_maybe_method(self, &_Py_ID(__bool__), &unbound);
7594 [ - + ]: 361282 : if (func == NULL) {
7595 [ # # ]: 0 : if (PyErr_Occurred()) {
7596 : 0 : return -1;
7597 : : }
7598 : :
7599 : 0 : func = lookup_maybe_method(self, &_Py_ID(__len__), &unbound);
7600 [ # # ]: 0 : if (func == NULL) {
7601 [ # # ]: 0 : if (PyErr_Occurred()) {
7602 : 0 : return -1;
7603 : : }
7604 : 0 : return 1;
7605 : : }
7606 : 0 : using_len = 1;
7607 : : }
7608 : :
7609 : 361282 : value = call_unbound_noarg(unbound, func, self);
7610 [ + + ]: 361282 : if (value == NULL) {
7611 : 85 : goto error;
7612 : : }
7613 : :
7614 [ - + ]: 361197 : if (using_len) {
7615 : : /* bool type enforced by slot_nb_len */
7616 : 0 : result = PyObject_IsTrue(value);
7617 : : }
7618 [ + + ]: 361197 : else if (PyBool_Check(value)) {
7619 : 361192 : result = PyObject_IsTrue(value);
7620 : : }
7621 : : else {
7622 : 5 : PyErr_Format(PyExc_TypeError,
7623 : : "__bool__ should return "
7624 : : "bool, returned %s",
7625 : 5 : Py_TYPE(value)->tp_name);
7626 : 5 : result = -1;
7627 : : }
7628 : :
7629 : 361197 : Py_DECREF(value);
7630 : 361197 : Py_DECREF(func);
7631 : 361197 : return result;
7632 : :
7633 : 85 : error:
7634 : 85 : Py_DECREF(func);
7635 : 85 : return -1;
7636 : : }
7637 : :
7638 : :
7639 : : static PyObject *
7640 : 3337 : slot_nb_index(PyObject *self)
7641 : : {
7642 : 3337 : PyObject *stack[1] = {self};
7643 : 3337 : return vectorcall_method(&_Py_ID(__index__), stack, 1);
7644 : : }
7645 : :
7646 : :
7647 : 310 : SLOT0(slot_nb_invert, __invert__)
7648 [ + + + - : 23 : SLOT1BIN(slot_nb_lshift, nb_lshift, __lshift__, __rlshift__)
+ + + - +
+ - + - -
- - - - -
- + + + +
+ + ]
7649 [ + + + - : 12 : SLOT1BIN(slot_nb_rshift, nb_rshift, __rshift__, __rrshift__)
+ + + + +
+ - + - -
- - - - -
- + + + +
+ + ]
7650 [ + + + + : 107296 : SLOT1BIN(slot_nb_and, nb_and, __and__, __rand__)
+ + + - +
+ + + - +
- - - - -
- + + + +
+ + ]
7651 [ + + + + : 236 : SLOT1BIN(slot_nb_xor, nb_xor, __xor__, __rxor__)
+ + + - +
+ + + - +
- - - - -
- + + + +
+ + ]
7652 [ + + + + : 12367 : SLOT1BIN(slot_nb_or, nb_or, __or__, __ror__)
+ + + - +
+ + + + +
- + + + +
- + + + +
+ + ]
7653 : :
7654 : 25456 : SLOT0(slot_nb_int, __int__)
7655 : 1988 : SLOT0(slot_nb_float, __float__)
7656 : 5754 : SLOT1(slot_nb_inplace_add, __iadd__, PyObject *)
7657 : 11 : SLOT1(slot_nb_inplace_subtract, __isub__, PyObject *)
7658 : 18 : SLOT1(slot_nb_inplace_multiply, __imul__, PyObject *)
7659 : 9 : SLOT1(slot_nb_inplace_matrix_multiply, __imatmul__, PyObject *)
7660 : 6 : SLOT1(slot_nb_inplace_remainder, __imod__, PyObject *)
7661 : : /* Can't use SLOT1 here, because nb_inplace_power is ternary */
7662 : : static PyObject *
7663 : 9 : slot_nb_inplace_power(PyObject *self, PyObject * arg1, PyObject *arg2)
7664 : : {
7665 : 9 : PyObject *stack[2] = {self, arg1};
7666 : 9 : return vectorcall_method(&_Py_ID(__ipow__), stack, 2);
7667 : : }
7668 : 6 : SLOT1(slot_nb_inplace_lshift, __ilshift__, PyObject *)
7669 : 6 : SLOT1(slot_nb_inplace_rshift, __irshift__, PyObject *)
7670 : 14 : SLOT1(slot_nb_inplace_and, __iand__, PyObject *)
7671 : 10 : SLOT1(slot_nb_inplace_xor, __ixor__, PyObject *)
7672 : 36 : SLOT1(slot_nb_inplace_or, __ior__, PyObject *)
7673 [ + + + - : 1744 : SLOT1BIN(slot_nb_floor_divide, nb_floor_divide,
+ + + - +
+ + + + +
- + + + +
- + + + +
+ + ]
7674 : : __floordiv__, __rfloordiv__)
7675 [ + + + - : 163777 : SLOT1BIN(slot_nb_true_divide, nb_true_divide, __truediv__, __rtruediv__)
+ + + - +
+ + + - +
- - - - -
- + + + +
+ + ]
7676 : 7 : SLOT1(slot_nb_inplace_floor_divide, __ifloordiv__, PyObject *)
7677 : 7 : SLOT1(slot_nb_inplace_true_divide, __itruediv__, PyObject *)
7678 : :
7679 : : static PyObject *
7680 : 32637 : slot_tp_repr(PyObject *self)
7681 : : {
7682 : : PyObject *func, *res;
7683 : : int unbound;
7684 : :
7685 : 32637 : func = lookup_maybe_method(self, &_Py_ID(__repr__), &unbound);
7686 [ + - ]: 32637 : if (func != NULL) {
7687 : 32637 : res = call_unbound_noarg(unbound, func, self);
7688 : 32637 : Py_DECREF(func);
7689 : 32637 : return res;
7690 : : }
7691 : 0 : PyErr_Clear();
7692 : 0 : return PyUnicode_FromFormat("<%s object at %p>",
7693 : 0 : Py_TYPE(self)->tp_name, self);
7694 : : }
7695 : :
7696 : 528652 : SLOT0(slot_tp_str, __str__)
7697 : :
7698 : : static Py_hash_t
7699 : 1346669 : slot_tp_hash(PyObject *self)
7700 : : {
7701 : : PyObject *func, *res;
7702 : : Py_ssize_t h;
7703 : : int unbound;
7704 : :
7705 : 1346669 : func = lookup_maybe_method(self, &_Py_ID(__hash__), &unbound);
7706 : :
7707 [ - + ]: 1346669 : if (func == Py_None) {
7708 : 0 : Py_DECREF(func);
7709 : 0 : func = NULL;
7710 : : }
7711 : :
7712 [ - + ]: 1346669 : if (func == NULL) {
7713 : 0 : return PyObject_HashNotImplemented(self);
7714 : : }
7715 : :
7716 : 1346669 : res = call_unbound_noarg(unbound, func, self);
7717 : 1346669 : Py_DECREF(func);
7718 [ + + ]: 1346669 : if (res == NULL)
7719 : 452 : return -1;
7720 : :
7721 [ - + ]: 1346217 : if (!PyLong_Check(res)) {
7722 : 0 : PyErr_SetString(PyExc_TypeError,
7723 : : "__hash__ method should return an integer");
7724 : 0 : return -1;
7725 : : }
7726 : : /* Transform the PyLong `res` to a Py_hash_t `h`. For an existing
7727 : : hashable Python object x, hash(x) will always lie within the range of
7728 : : Py_hash_t. Therefore our transformation must preserve values that
7729 : : already lie within this range, to ensure that if x.__hash__() returns
7730 : : hash(y) then hash(x) == hash(y). */
7731 : 1346217 : h = PyLong_AsSsize_t(res);
7732 [ + + + - ]: 1346217 : if (h == -1 && PyErr_Occurred()) {
7733 : : /* res was not within the range of a Py_hash_t, so we're free to
7734 : : use any sufficiently bit-mixing transformation;
7735 : : long.__hash__ will do nicely. */
7736 : 1 : PyErr_Clear();
7737 : 1 : h = PyLong_Type.tp_hash(res);
7738 : : }
7739 : : /* -1 is reserved for errors. */
7740 [ - + ]: 1346217 : if (h == -1)
7741 : 0 : h = -2;
7742 : 1346217 : Py_DECREF(res);
7743 : 1346217 : return h;
7744 : : }
7745 : :
7746 : : static PyObject *
7747 : 473657 : slot_tp_call(PyObject *self, PyObject *args, PyObject *kwds)
7748 : : {
7749 : 473657 : PyThreadState *tstate = _PyThreadState_GET();
7750 : : int unbound;
7751 : :
7752 : 473657 : PyObject *meth = lookup_method(self, &_Py_ID(__call__), &unbound);
7753 [ - + ]: 473657 : if (meth == NULL) {
7754 : 0 : return NULL;
7755 : : }
7756 : :
7757 : : PyObject *res;
7758 [ + + ]: 473657 : if (unbound) {
7759 : 471690 : res = _PyObject_Call_Prepend(tstate, meth, self, args, kwds);
7760 : : }
7761 : : else {
7762 : 1967 : res = _PyObject_Call(tstate, meth, args, kwds);
7763 : : }
7764 : :
7765 : 473657 : Py_DECREF(meth);
7766 : 473657 : return res;
7767 : : }
7768 : :
7769 : : /* There are two slot dispatch functions for tp_getattro.
7770 : :
7771 : : - slot_tp_getattro() is used when __getattribute__ is overridden
7772 : : but no __getattr__ hook is present;
7773 : :
7774 : : - slot_tp_getattr_hook() is used when a __getattr__ hook is present.
7775 : :
7776 : : The code in update_one_slot() always installs slot_tp_getattr_hook(); this
7777 : : detects the absence of __getattr__ and then installs the simpler slot if
7778 : : necessary. */
7779 : :
7780 : : static PyObject *
7781 : 20006 : slot_tp_getattro(PyObject *self, PyObject *name)
7782 : : {
7783 : 20006 : PyObject *stack[2] = {self, name};
7784 : 20006 : return vectorcall_method(&_Py_ID(__getattribute__), stack, 2);
7785 : : }
7786 : :
7787 : : static inline PyObject *
7788 : 4642521 : call_attribute(PyObject *self, PyObject *attr, PyObject *name)
7789 : : {
7790 : 4642521 : PyObject *res, *descr = NULL;
7791 : :
7792 [ + + ]: 4642521 : if (_PyType_HasFeature(Py_TYPE(attr), Py_TPFLAGS_METHOD_DESCRIPTOR)) {
7793 : 4642518 : PyObject *args[] = { self, name };
7794 : 4642518 : res = PyObject_Vectorcall(attr, args, 2, NULL);
7795 : 4642518 : return res;
7796 : : }
7797 : :
7798 : 3 : descrgetfunc f = Py_TYPE(attr)->tp_descr_get;
7799 : :
7800 [ + - ]: 3 : if (f != NULL) {
7801 : 3 : descr = f(attr, self, (PyObject *)(Py_TYPE(self)));
7802 [ - + ]: 3 : if (descr == NULL)
7803 : 0 : return NULL;
7804 : : else
7805 : 3 : attr = descr;
7806 : : }
7807 : 3 : res = PyObject_CallOneArg(attr, name);
7808 : 3 : Py_XDECREF(descr);
7809 : 3 : return res;
7810 : : }
7811 : :
7812 : : static PyObject *
7813 : 9681932 : slot_tp_getattr_hook(PyObject *self, PyObject *name)
7814 : : {
7815 : 9681932 : PyTypeObject *tp = Py_TYPE(self);
7816 : : PyObject *getattr, *getattribute, *res;
7817 : :
7818 : : /* speed hack: we could use lookup_maybe, but that would resolve the
7819 : : method fully for each attribute lookup for classes with
7820 : : __getattr__, even when the attribute is present. So we use
7821 : : _PyType_Lookup and create the method only when needed, with
7822 : : call_attribute. */
7823 : 9681932 : getattr = _PyType_Lookup(tp, &_Py_ID(__getattr__));
7824 [ + + ]: 9681932 : if (getattr == NULL) {
7825 : : /* No __getattr__ hook: use a simpler dispatcher */
7826 : 921 : tp->tp_getattro = slot_tp_getattro;
7827 : 921 : return slot_tp_getattro(self, name);
7828 : : }
7829 : 9681011 : Py_INCREF(getattr);
7830 : : /* speed hack: we could use lookup_maybe, but that would resolve the
7831 : : method fully for each attribute lookup for classes with
7832 : : __getattr__, even when self has the default __getattribute__
7833 : : method. So we use _PyType_Lookup and create the method only when
7834 : : needed, with call_attribute. */
7835 : 9681011 : getattribute = _PyType_Lookup(tp, &_Py_ID(__getattribute__));
7836 [ + - + + ]: 19362022 : if (getattribute == NULL ||
7837 : 9681011 : (Py_IS_TYPE(getattribute, &PyWrapperDescr_Type) &&
7838 [ + + ]: 9670172 : ((PyWrapperDescrObject *)getattribute)->d_wrapped ==
7839 : : (void *)PyObject_GenericGetAttr))
7840 : 5135566 : res = PyObject_GenericGetAttr(self, name);
7841 : : else {
7842 : 4545445 : Py_INCREF(getattribute);
7843 : 4545445 : res = call_attribute(self, getattribute, name);
7844 : 4545445 : Py_DECREF(getattribute);
7845 : : }
7846 [ + + + - ]: 9681011 : if (res == NULL && PyErr_ExceptionMatches(PyExc_AttributeError)) {
7847 : 97076 : PyErr_Clear();
7848 : 97076 : res = call_attribute(self, getattr, name);
7849 : : }
7850 : 9681011 : Py_DECREF(getattr);
7851 : 9681011 : return res;
7852 : : }
7853 : :
7854 : : static int
7855 : 1195752 : slot_tp_setattro(PyObject *self, PyObject *name, PyObject *value)
7856 : : {
7857 : : PyObject *stack[3];
7858 : : PyObject *res;
7859 : :
7860 : 1195752 : stack[0] = self;
7861 : 1195752 : stack[1] = name;
7862 [ + + ]: 1195752 : if (value == NULL) {
7863 : 157379 : res = vectorcall_method(&_Py_ID(__delattr__), stack, 2);
7864 : : }
7865 : : else {
7866 : 1038373 : stack[2] = value;
7867 : 1038373 : res = vectorcall_method(&_Py_ID(__setattr__), stack, 3);
7868 : : }
7869 [ + + ]: 1195752 : if (res == NULL)
7870 : 329 : return -1;
7871 : 1195423 : Py_DECREF(res);
7872 : 1195423 : return 0;
7873 : : }
7874 : :
7875 : : static PyObject *name_op[] = {
7876 : : &_Py_ID(__lt__),
7877 : : &_Py_ID(__le__),
7878 : : &_Py_ID(__eq__),
7879 : : &_Py_ID(__ne__),
7880 : : &_Py_ID(__gt__),
7881 : : &_Py_ID(__ge__),
7882 : : };
7883 : :
7884 : : static PyObject *
7885 : 9857592 : slot_tp_richcompare(PyObject *self, PyObject *other, int op)
7886 : : {
7887 : 9857592 : PyThreadState *tstate = _PyThreadState_GET();
7888 : :
7889 : : int unbound;
7890 : 9857592 : PyObject *func = lookup_maybe_method(self, name_op[op], &unbound);
7891 [ + + ]: 9857592 : if (func == NULL) {
7892 : 2 : PyErr_Clear();
7893 : 2 : Py_RETURN_NOTIMPLEMENTED;
7894 : : }
7895 : :
7896 : 9857590 : PyObject *stack[2] = {self, other};
7897 : 9857590 : PyObject *res = vectorcall_unbound(tstate, unbound, func, stack, 2);
7898 : 9857590 : Py_DECREF(func);
7899 : 9857590 : return res;
7900 : : }
7901 : :
7902 : : static PyObject *
7903 : 103115 : slot_tp_iter(PyObject *self)
7904 : : {
7905 : : int unbound;
7906 : : PyObject *func, *res;
7907 : :
7908 : 103115 : func = lookup_maybe_method(self, &_Py_ID(__iter__), &unbound);
7909 [ + + ]: 103115 : if (func == Py_None) {
7910 : 28 : Py_DECREF(func);
7911 : 28 : PyErr_Format(PyExc_TypeError,
7912 : : "'%.200s' object is not iterable",
7913 : 28 : Py_TYPE(self)->tp_name);
7914 : 28 : return NULL;
7915 : : }
7916 : :
7917 [ + - ]: 103087 : if (func != NULL) {
7918 : 103087 : res = call_unbound_noarg(unbound, func, self);
7919 : 103087 : Py_DECREF(func);
7920 : 103087 : return res;
7921 : : }
7922 : :
7923 : 0 : PyErr_Clear();
7924 : 0 : func = lookup_maybe_method(self, &_Py_ID(__getitem__), &unbound);
7925 [ # # ]: 0 : if (func == NULL) {
7926 : 0 : PyErr_Format(PyExc_TypeError,
7927 : : "'%.200s' object is not iterable",
7928 : 0 : Py_TYPE(self)->tp_name);
7929 : 0 : return NULL;
7930 : : }
7931 : 0 : Py_DECREF(func);
7932 : 0 : return PySeqIter_New(self);
7933 : : }
7934 : :
7935 : : static PyObject *
7936 : 242391 : slot_tp_iternext(PyObject *self)
7937 : : {
7938 : 242391 : PyObject *stack[1] = {self};
7939 : 242391 : return vectorcall_method(&_Py_ID(__next__), stack, 1);
7940 : : }
7941 : :
7942 : : static PyObject *
7943 : 893443 : slot_tp_descr_get(PyObject *self, PyObject *obj, PyObject *type)
7944 : : {
7945 : 893443 : PyTypeObject *tp = Py_TYPE(self);
7946 : : PyObject *get;
7947 : :
7948 : 893443 : get = _PyType_Lookup(tp, &_Py_ID(__get__));
7949 [ - + ]: 893443 : if (get == NULL) {
7950 : : /* Avoid further slowdowns */
7951 [ # # ]: 0 : if (tp->tp_descr_get == slot_tp_descr_get)
7952 : 0 : tp->tp_descr_get = NULL;
7953 : 0 : Py_INCREF(self);
7954 : 0 : return self;
7955 : : }
7956 [ + + ]: 893443 : if (obj == NULL)
7957 : 851332 : obj = Py_None;
7958 [ - + ]: 893443 : if (type == NULL)
7959 : 0 : type = Py_None;
7960 : 893443 : return PyObject_CallFunctionObjArgs(get, self, obj, type, NULL);
7961 : : }
7962 : :
7963 : : static int
7964 : 31 : slot_tp_descr_set(PyObject *self, PyObject *target, PyObject *value)
7965 : : {
7966 : : PyObject* stack[3];
7967 : : PyObject *res;
7968 : :
7969 : 31 : stack[0] = self;
7970 : 31 : stack[1] = target;
7971 [ + + ]: 31 : if (value == NULL) {
7972 : 15 : res = vectorcall_method(&_Py_ID(__delete__), stack, 2);
7973 : : }
7974 : : else {
7975 : 16 : stack[2] = value;
7976 : 16 : res = vectorcall_method(&_Py_ID(__set__), stack, 3);
7977 : : }
7978 [ + + ]: 31 : if (res == NULL)
7979 : 14 : return -1;
7980 : 17 : Py_DECREF(res);
7981 : 17 : return 0;
7982 : : }
7983 : :
7984 : : static int
7985 : 12704199 : slot_tp_init(PyObject *self, PyObject *args, PyObject *kwds)
7986 : : {
7987 : 12704199 : PyThreadState *tstate = _PyThreadState_GET();
7988 : :
7989 : : int unbound;
7990 : 12704199 : PyObject *meth = lookup_method(self, &_Py_ID(__init__), &unbound);
7991 [ + + ]: 12704199 : if (meth == NULL) {
7992 : 1 : return -1;
7993 : : }
7994 : :
7995 : : PyObject *res;
7996 [ + + ]: 12704198 : if (unbound) {
7997 : 12704196 : res = _PyObject_Call_Prepend(tstate, meth, self, args, kwds);
7998 : : }
7999 : : else {
8000 : 2 : res = _PyObject_Call(tstate, meth, args, kwds);
8001 : : }
8002 : 12704190 : Py_DECREF(meth);
8003 [ + + ]: 12704190 : if (res == NULL)
8004 : 40775 : return -1;
8005 [ + + ]: 12663415 : if (res != Py_None) {
8006 : 1 : PyErr_Format(PyExc_TypeError,
8007 : : "__init__() should return None, not '%.200s'",
8008 : 1 : Py_TYPE(res)->tp_name);
8009 : 1 : Py_DECREF(res);
8010 : 1 : return -1;
8011 : : }
8012 : 12663414 : Py_DECREF(res);
8013 : 12663414 : return 0;
8014 : : }
8015 : :
8016 : : static PyObject *
8017 : 10604812 : slot_tp_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
8018 : : {
8019 : 10604812 : PyThreadState *tstate = _PyThreadState_GET();
8020 : : PyObject *func, *result;
8021 : :
8022 : 10604812 : func = PyObject_GetAttr((PyObject *)type, &_Py_ID(__new__));
8023 [ - + ]: 10604812 : if (func == NULL) {
8024 : 0 : return NULL;
8025 : : }
8026 : :
8027 : 10604812 : result = _PyObject_Call_Prepend(tstate, func, (PyObject *)type, args, kwds);
8028 : 10604812 : Py_DECREF(func);
8029 : 10604812 : return result;
8030 : : }
8031 : :
8032 : : static void
8033 : 4256295 : slot_tp_finalize(PyObject *self)
8034 : : {
8035 : : int unbound;
8036 : : PyObject *del, *res;
8037 : : PyObject *error_type, *error_value, *error_traceback;
8038 : :
8039 : : /* Save the current exception, if any. */
8040 : 4256295 : PyErr_Fetch(&error_type, &error_value, &error_traceback);
8041 : :
8042 : : /* Execute __del__ method, if any. */
8043 : 4256295 : del = lookup_maybe_method(self, &_Py_ID(__del__), &unbound);
8044 [ + - ]: 4256295 : if (del != NULL) {
8045 : 4256295 : res = call_unbound_noarg(unbound, del, self);
8046 [ + + ]: 4256295 : if (res == NULL)
8047 : 16 : PyErr_WriteUnraisable(del);
8048 : : else
8049 : 4256279 : Py_DECREF(res);
8050 : 4256295 : Py_DECREF(del);
8051 : : }
8052 : :
8053 : : /* Restore the saved exception. */
8054 : 4256295 : PyErr_Restore(error_type, error_value, error_traceback);
8055 : 4256295 : }
8056 : :
8057 : : static PyObject *
8058 : 226 : slot_am_await(PyObject *self)
8059 : : {
8060 : : int unbound;
8061 : : PyObject *func, *res;
8062 : :
8063 : 226 : func = lookup_maybe_method(self, &_Py_ID(__await__), &unbound);
8064 [ + - ]: 226 : if (func != NULL) {
8065 : 226 : res = call_unbound_noarg(unbound, func, self);
8066 : 226 : Py_DECREF(func);
8067 : 226 : return res;
8068 : : }
8069 : 0 : PyErr_Format(PyExc_AttributeError,
8070 : : "object %.50s does not have __await__ method",
8071 : 0 : Py_TYPE(self)->tp_name);
8072 : 0 : return NULL;
8073 : : }
8074 : :
8075 : : static PyObject *
8076 : 31 : slot_am_aiter(PyObject *self)
8077 : : {
8078 : : int unbound;
8079 : : PyObject *func, *res;
8080 : :
8081 : 31 : func = lookup_maybe_method(self, &_Py_ID(__aiter__), &unbound);
8082 [ + - ]: 31 : if (func != NULL) {
8083 : 31 : res = call_unbound_noarg(unbound, func, self);
8084 : 31 : Py_DECREF(func);
8085 : 31 : return res;
8086 : : }
8087 : 0 : PyErr_Format(PyExc_AttributeError,
8088 : : "object %.50s does not have __aiter__ method",
8089 : 0 : Py_TYPE(self)->tp_name);
8090 : 0 : return NULL;
8091 : : }
8092 : :
8093 : : static PyObject *
8094 : 365 : slot_am_anext(PyObject *self)
8095 : : {
8096 : : int unbound;
8097 : : PyObject *func, *res;
8098 : :
8099 : 365 : func = lookup_maybe_method(self, &_Py_ID(__anext__), &unbound);
8100 [ + - ]: 365 : if (func != NULL) {
8101 : 365 : res = call_unbound_noarg(unbound, func, self);
8102 : 365 : Py_DECREF(func);
8103 : 365 : return res;
8104 : : }
8105 : 0 : PyErr_Format(PyExc_AttributeError,
8106 : : "object %.50s does not have __anext__ method",
8107 : 0 : Py_TYPE(self)->tp_name);
8108 : 0 : return NULL;
8109 : : }
8110 : :
8111 : : /*
8112 : : Table mapping __foo__ names to tp_foo offsets and slot_tp_foo wrapper functions.
8113 : :
8114 : : The table is ordered by offsets relative to the 'PyHeapTypeObject' structure,
8115 : : which incorporates the additional structures used for numbers, sequences and
8116 : : mappings. Note that multiple names may map to the same slot (e.g. __eq__,
8117 : : __ne__ etc. all map to tp_richcompare) and one name may map to multiple slots
8118 : : (e.g. __str__ affects tp_str as well as tp_repr). The table is terminated with
8119 : : an all-zero entry. (This table is further initialized in
8120 : : _PyTypes_InitSlotDefs().)
8121 : : */
8122 : :
8123 : : typedef struct wrapperbase slotdef;
8124 : :
8125 : : #undef TPSLOT
8126 : : #undef FLSLOT
8127 : : #undef AMSLOT
8128 : : #undef ETSLOT
8129 : : #undef SQSLOT
8130 : : #undef MPSLOT
8131 : : #undef NBSLOT
8132 : : #undef UNSLOT
8133 : : #undef IBSLOT
8134 : : #undef BINSLOT
8135 : : #undef RBINSLOT
8136 : :
8137 : : #define TPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
8138 : : {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
8139 : : PyDoc_STR(DOC)}
8140 : : #define FLSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC, FLAGS) \
8141 : : {NAME, offsetof(PyTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
8142 : : PyDoc_STR(DOC), FLAGS}
8143 : : #define ETSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
8144 : : {NAME, offsetof(PyHeapTypeObject, SLOT), (void *)(FUNCTION), WRAPPER, \
8145 : : PyDoc_STR(DOC)}
8146 : : #define AMSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
8147 : : ETSLOT(NAME, as_async.SLOT, FUNCTION, WRAPPER, DOC)
8148 : : #define SQSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
8149 : : ETSLOT(NAME, as_sequence.SLOT, FUNCTION, WRAPPER, DOC)
8150 : : #define MPSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
8151 : : ETSLOT(NAME, as_mapping.SLOT, FUNCTION, WRAPPER, DOC)
8152 : : #define NBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
8153 : : ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, DOC)
8154 : : #define UNSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
8155 : : ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \
8156 : : NAME "($self, /)\n--\n\n" DOC)
8157 : : #define IBSLOT(NAME, SLOT, FUNCTION, WRAPPER, DOC) \
8158 : : ETSLOT(NAME, as_number.SLOT, FUNCTION, WRAPPER, \
8159 : : NAME "($self, value, /)\n--\n\nReturn self" DOC "value.")
8160 : : #define BINSLOT(NAME, SLOT, FUNCTION, DOC) \
8161 : : ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \
8162 : : NAME "($self, value, /)\n--\n\nReturn self" DOC "value.")
8163 : : #define RBINSLOT(NAME, SLOT, FUNCTION, DOC) \
8164 : : ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \
8165 : : NAME "($self, value, /)\n--\n\nReturn value" DOC "self.")
8166 : : #define BINSLOTNOTINFIX(NAME, SLOT, FUNCTION, DOC) \
8167 : : ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_l, \
8168 : : NAME "($self, value, /)\n--\n\n" DOC)
8169 : : #define RBINSLOTNOTINFIX(NAME, SLOT, FUNCTION, DOC) \
8170 : : ETSLOT(NAME, as_number.SLOT, FUNCTION, wrap_binaryfunc_r, \
8171 : : NAME "($self, value, /)\n--\n\n" DOC)
8172 : :
8173 : : static slotdef slotdefs[] = {
8174 : : TPSLOT("__getattribute__", tp_getattr, NULL, NULL, ""),
8175 : : TPSLOT("__getattr__", tp_getattr, NULL, NULL, ""),
8176 : : TPSLOT("__setattr__", tp_setattr, NULL, NULL, ""),
8177 : : TPSLOT("__delattr__", tp_setattr, NULL, NULL, ""),
8178 : : TPSLOT("__repr__", tp_repr, slot_tp_repr, wrap_unaryfunc,
8179 : : "__repr__($self, /)\n--\n\nReturn repr(self)."),
8180 : : TPSLOT("__hash__", tp_hash, slot_tp_hash, wrap_hashfunc,
8181 : : "__hash__($self, /)\n--\n\nReturn hash(self)."),
8182 : : FLSLOT("__call__", tp_call, slot_tp_call, (wrapperfunc)(void(*)(void))wrap_call,
8183 : : "__call__($self, /, *args, **kwargs)\n--\n\nCall self as a function.",
8184 : : PyWrapperFlag_KEYWORDS),
8185 : : TPSLOT("__str__", tp_str, slot_tp_str, wrap_unaryfunc,
8186 : : "__str__($self, /)\n--\n\nReturn str(self)."),
8187 : : TPSLOT("__getattribute__", tp_getattro, slot_tp_getattr_hook,
8188 : : wrap_binaryfunc,
8189 : : "__getattribute__($self, name, /)\n--\n\nReturn getattr(self, name)."),
8190 : : TPSLOT("__getattr__", tp_getattro, slot_tp_getattr_hook, NULL, ""),
8191 : : TPSLOT("__setattr__", tp_setattro, slot_tp_setattro, wrap_setattr,
8192 : : "__setattr__($self, name, value, /)\n--\n\nImplement setattr(self, name, value)."),
8193 : : TPSLOT("__delattr__", tp_setattro, slot_tp_setattro, wrap_delattr,
8194 : : "__delattr__($self, name, /)\n--\n\nImplement delattr(self, name)."),
8195 : : TPSLOT("__lt__", tp_richcompare, slot_tp_richcompare, richcmp_lt,
8196 : : "__lt__($self, value, /)\n--\n\nReturn self<value."),
8197 : : TPSLOT("__le__", tp_richcompare, slot_tp_richcompare, richcmp_le,
8198 : : "__le__($self, value, /)\n--\n\nReturn self<=value."),
8199 : : TPSLOT("__eq__", tp_richcompare, slot_tp_richcompare, richcmp_eq,
8200 : : "__eq__($self, value, /)\n--\n\nReturn self==value."),
8201 : : TPSLOT("__ne__", tp_richcompare, slot_tp_richcompare, richcmp_ne,
8202 : : "__ne__($self, value, /)\n--\n\nReturn self!=value."),
8203 : : TPSLOT("__gt__", tp_richcompare, slot_tp_richcompare, richcmp_gt,
8204 : : "__gt__($self, value, /)\n--\n\nReturn self>value."),
8205 : : TPSLOT("__ge__", tp_richcompare, slot_tp_richcompare, richcmp_ge,
8206 : : "__ge__($self, value, /)\n--\n\nReturn self>=value."),
8207 : : TPSLOT("__iter__", tp_iter, slot_tp_iter, wrap_unaryfunc,
8208 : : "__iter__($self, /)\n--\n\nImplement iter(self)."),
8209 : : TPSLOT("__next__", tp_iternext, slot_tp_iternext, wrap_next,
8210 : : "__next__($self, /)\n--\n\nImplement next(self)."),
8211 : : TPSLOT("__get__", tp_descr_get, slot_tp_descr_get, wrap_descr_get,
8212 : : "__get__($self, instance, owner=None, /)\n--\n\nReturn an attribute of instance, which is of type owner."),
8213 : : TPSLOT("__set__", tp_descr_set, slot_tp_descr_set, wrap_descr_set,
8214 : : "__set__($self, instance, value, /)\n--\n\nSet an attribute of instance to value."),
8215 : : TPSLOT("__delete__", tp_descr_set, slot_tp_descr_set,
8216 : : wrap_descr_delete,
8217 : : "__delete__($self, instance, /)\n--\n\nDelete an attribute of instance."),
8218 : : FLSLOT("__init__", tp_init, slot_tp_init, (wrapperfunc)(void(*)(void))wrap_init,
8219 : : "__init__($self, /, *args, **kwargs)\n--\n\n"
8220 : : "Initialize self. See help(type(self)) for accurate signature.",
8221 : : PyWrapperFlag_KEYWORDS),
8222 : : TPSLOT("__new__", tp_new, slot_tp_new, NULL,
8223 : : "__new__(type, /, *args, **kwargs)\n--\n\n"
8224 : : "Create and return new object. See help(type) for accurate signature."),
8225 : : TPSLOT("__del__", tp_finalize, slot_tp_finalize, (wrapperfunc)wrap_del, ""),
8226 : :
8227 : : AMSLOT("__await__", am_await, slot_am_await, wrap_unaryfunc,
8228 : : "__await__($self, /)\n--\n\nReturn an iterator to be used in await expression."),
8229 : : AMSLOT("__aiter__", am_aiter, slot_am_aiter, wrap_unaryfunc,
8230 : : "__aiter__($self, /)\n--\n\nReturn an awaitable, that resolves in asynchronous iterator."),
8231 : : AMSLOT("__anext__", am_anext, slot_am_anext, wrap_unaryfunc,
8232 : : "__anext__($self, /)\n--\n\nReturn a value or raise StopAsyncIteration."),
8233 : :
8234 : : BINSLOT("__add__", nb_add, slot_nb_add,
8235 : : "+"),
8236 : : RBINSLOT("__radd__", nb_add, slot_nb_add,
8237 : : "+"),
8238 : : BINSLOT("__sub__", nb_subtract, slot_nb_subtract,
8239 : : "-"),
8240 : : RBINSLOT("__rsub__", nb_subtract, slot_nb_subtract,
8241 : : "-"),
8242 : : BINSLOT("__mul__", nb_multiply, slot_nb_multiply,
8243 : : "*"),
8244 : : RBINSLOT("__rmul__", nb_multiply, slot_nb_multiply,
8245 : : "*"),
8246 : : BINSLOT("__mod__", nb_remainder, slot_nb_remainder,
8247 : : "%"),
8248 : : RBINSLOT("__rmod__", nb_remainder, slot_nb_remainder,
8249 : : "%"),
8250 : : BINSLOTNOTINFIX("__divmod__", nb_divmod, slot_nb_divmod,
8251 : : "Return divmod(self, value)."),
8252 : : RBINSLOTNOTINFIX("__rdivmod__", nb_divmod, slot_nb_divmod,
8253 : : "Return divmod(value, self)."),
8254 : : NBSLOT("__pow__", nb_power, slot_nb_power, wrap_ternaryfunc,
8255 : : "__pow__($self, value, mod=None, /)\n--\n\nReturn pow(self, value, mod)."),
8256 : : NBSLOT("__rpow__", nb_power, slot_nb_power, wrap_ternaryfunc_r,
8257 : : "__rpow__($self, value, mod=None, /)\n--\n\nReturn pow(value, self, mod)."),
8258 : : UNSLOT("__neg__", nb_negative, slot_nb_negative, wrap_unaryfunc, "-self"),
8259 : : UNSLOT("__pos__", nb_positive, slot_nb_positive, wrap_unaryfunc, "+self"),
8260 : : UNSLOT("__abs__", nb_absolute, slot_nb_absolute, wrap_unaryfunc,
8261 : : "abs(self)"),
8262 : : UNSLOT("__bool__", nb_bool, slot_nb_bool, wrap_inquirypred,
8263 : : "True if self else False"),
8264 : : UNSLOT("__invert__", nb_invert, slot_nb_invert, wrap_unaryfunc, "~self"),
8265 : : BINSLOT("__lshift__", nb_lshift, slot_nb_lshift, "<<"),
8266 : : RBINSLOT("__rlshift__", nb_lshift, slot_nb_lshift, "<<"),
8267 : : BINSLOT("__rshift__", nb_rshift, slot_nb_rshift, ">>"),
8268 : : RBINSLOT("__rrshift__", nb_rshift, slot_nb_rshift, ">>"),
8269 : : BINSLOT("__and__", nb_and, slot_nb_and, "&"),
8270 : : RBINSLOT("__rand__", nb_and, slot_nb_and, "&"),
8271 : : BINSLOT("__xor__", nb_xor, slot_nb_xor, "^"),
8272 : : RBINSLOT("__rxor__", nb_xor, slot_nb_xor, "^"),
8273 : : BINSLOT("__or__", nb_or, slot_nb_or, "|"),
8274 : : RBINSLOT("__ror__", nb_or, slot_nb_or, "|"),
8275 : : UNSLOT("__int__", nb_int, slot_nb_int, wrap_unaryfunc,
8276 : : "int(self)"),
8277 : : UNSLOT("__float__", nb_float, slot_nb_float, wrap_unaryfunc,
8278 : : "float(self)"),
8279 : : IBSLOT("__iadd__", nb_inplace_add, slot_nb_inplace_add,
8280 : : wrap_binaryfunc, "+="),
8281 : : IBSLOT("__isub__", nb_inplace_subtract, slot_nb_inplace_subtract,
8282 : : wrap_binaryfunc, "-="),
8283 : : IBSLOT("__imul__", nb_inplace_multiply, slot_nb_inplace_multiply,
8284 : : wrap_binaryfunc, "*="),
8285 : : IBSLOT("__imod__", nb_inplace_remainder, slot_nb_inplace_remainder,
8286 : : wrap_binaryfunc, "%="),
8287 : : IBSLOT("__ipow__", nb_inplace_power, slot_nb_inplace_power,
8288 : : wrap_ternaryfunc, "**="),
8289 : : IBSLOT("__ilshift__", nb_inplace_lshift, slot_nb_inplace_lshift,
8290 : : wrap_binaryfunc, "<<="),
8291 : : IBSLOT("__irshift__", nb_inplace_rshift, slot_nb_inplace_rshift,
8292 : : wrap_binaryfunc, ">>="),
8293 : : IBSLOT("__iand__", nb_inplace_and, slot_nb_inplace_and,
8294 : : wrap_binaryfunc, "&="),
8295 : : IBSLOT("__ixor__", nb_inplace_xor, slot_nb_inplace_xor,
8296 : : wrap_binaryfunc, "^="),
8297 : : IBSLOT("__ior__", nb_inplace_or, slot_nb_inplace_or,
8298 : : wrap_binaryfunc, "|="),
8299 : : BINSLOT("__floordiv__", nb_floor_divide, slot_nb_floor_divide, "//"),
8300 : : RBINSLOT("__rfloordiv__", nb_floor_divide, slot_nb_floor_divide, "//"),
8301 : : BINSLOT("__truediv__", nb_true_divide, slot_nb_true_divide, "/"),
8302 : : RBINSLOT("__rtruediv__", nb_true_divide, slot_nb_true_divide, "/"),
8303 : : IBSLOT("__ifloordiv__", nb_inplace_floor_divide,
8304 : : slot_nb_inplace_floor_divide, wrap_binaryfunc, "//="),
8305 : : IBSLOT("__itruediv__", nb_inplace_true_divide,
8306 : : slot_nb_inplace_true_divide, wrap_binaryfunc, "/="),
8307 : : NBSLOT("__index__", nb_index, slot_nb_index, wrap_unaryfunc,
8308 : : "__index__($self, /)\n--\n\n"
8309 : : "Return self converted to an integer, if self is suitable "
8310 : : "for use as an index into a list."),
8311 : : BINSLOT("__matmul__", nb_matrix_multiply, slot_nb_matrix_multiply,
8312 : : "@"),
8313 : : RBINSLOT("__rmatmul__", nb_matrix_multiply, slot_nb_matrix_multiply,
8314 : : "@"),
8315 : : IBSLOT("__imatmul__", nb_inplace_matrix_multiply, slot_nb_inplace_matrix_multiply,
8316 : : wrap_binaryfunc, "@="),
8317 : : MPSLOT("__len__", mp_length, slot_mp_length, wrap_lenfunc,
8318 : : "__len__($self, /)\n--\n\nReturn len(self)."),
8319 : : MPSLOT("__getitem__", mp_subscript, slot_mp_subscript,
8320 : : wrap_binaryfunc,
8321 : : "__getitem__($self, key, /)\n--\n\nReturn self[key]."),
8322 : : MPSLOT("__setitem__", mp_ass_subscript, slot_mp_ass_subscript,
8323 : : wrap_objobjargproc,
8324 : : "__setitem__($self, key, value, /)\n--\n\nSet self[key] to value."),
8325 : : MPSLOT("__delitem__", mp_ass_subscript, slot_mp_ass_subscript,
8326 : : wrap_delitem,
8327 : : "__delitem__($self, key, /)\n--\n\nDelete self[key]."),
8328 : :
8329 : : SQSLOT("__len__", sq_length, slot_sq_length, wrap_lenfunc,
8330 : : "__len__($self, /)\n--\n\nReturn len(self)."),
8331 : : /* Heap types defining __add__/__mul__ have sq_concat/sq_repeat == NULL.
8332 : : The logic in abstract.c always falls back to nb_add/nb_multiply in
8333 : : this case. Defining both the nb_* and the sq_* slots to call the
8334 : : user-defined methods has unexpected side-effects, as shown by
8335 : : test_descr.notimplemented() */
8336 : : SQSLOT("__add__", sq_concat, NULL, wrap_binaryfunc,
8337 : : "__add__($self, value, /)\n--\n\nReturn self+value."),
8338 : : SQSLOT("__mul__", sq_repeat, NULL, wrap_indexargfunc,
8339 : : "__mul__($self, value, /)\n--\n\nReturn self*value."),
8340 : : SQSLOT("__rmul__", sq_repeat, NULL, wrap_indexargfunc,
8341 : : "__rmul__($self, value, /)\n--\n\nReturn value*self."),
8342 : : SQSLOT("__getitem__", sq_item, slot_sq_item, wrap_sq_item,
8343 : : "__getitem__($self, key, /)\n--\n\nReturn self[key]."),
8344 : : SQSLOT("__setitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_setitem,
8345 : : "__setitem__($self, key, value, /)\n--\n\nSet self[key] to value."),
8346 : : SQSLOT("__delitem__", sq_ass_item, slot_sq_ass_item, wrap_sq_delitem,
8347 : : "__delitem__($self, key, /)\n--\n\nDelete self[key]."),
8348 : : SQSLOT("__contains__", sq_contains, slot_sq_contains, wrap_objobjproc,
8349 : : "__contains__($self, key, /)\n--\n\nReturn key in self."),
8350 : : SQSLOT("__iadd__", sq_inplace_concat, NULL,
8351 : : wrap_binaryfunc,
8352 : : "__iadd__($self, value, /)\n--\n\nImplement self+=value."),
8353 : : SQSLOT("__imul__", sq_inplace_repeat, NULL,
8354 : : wrap_indexargfunc,
8355 : : "__imul__($self, value, /)\n--\n\nImplement self*=value."),
8356 : :
8357 : : {NULL}
8358 : : };
8359 : :
8360 : : /* Given a type pointer and an offset gotten from a slotdef entry, return a
8361 : : pointer to the actual slot. This is not quite the same as simply adding
8362 : : the offset to the type pointer, since it takes care to indirect through the
8363 : : proper indirection pointer (as_buffer, etc.); it returns NULL if the
8364 : : indirection pointer is NULL. */
8365 : : static void **
8366 : 280043802 : slotptr(PyTypeObject *type, int ioffset)
8367 : : {
8368 : : char *ptr;
8369 : 280043802 : long offset = ioffset;
8370 : :
8371 : : /* Note: this depends on the order of the members of PyHeapTypeObject! */
8372 : : assert(offset >= 0);
8373 : : assert((size_t)offset < offsetof(PyHeapTypeObject, as_buffer));
8374 [ + + ]: 280043802 : if ((size_t)offset >= offsetof(PyHeapTypeObject, as_sequence)) {
8375 : 30764281 : ptr = (char *)type->tp_as_sequence;
8376 : 30764281 : offset -= offsetof(PyHeapTypeObject, as_sequence);
8377 : : }
8378 [ + + ]: 249279521 : else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_mapping)) {
8379 : 11993000 : ptr = (char *)type->tp_as_mapping;
8380 : 11993000 : offset -= offsetof(PyHeapTypeObject, as_mapping);
8381 : : }
8382 [ + + ]: 237286521 : else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_number)) {
8383 : 142485066 : ptr = (char *)type->tp_as_number;
8384 : 142485066 : offset -= offsetof(PyHeapTypeObject, as_number);
8385 : : }
8386 [ + + ]: 94801455 : else if ((size_t)offset >= offsetof(PyHeapTypeObject, as_async)) {
8387 : 9678221 : ptr = (char *)type->tp_as_async;
8388 : 9678221 : offset -= offsetof(PyHeapTypeObject, as_async);
8389 : : }
8390 : : else {
8391 : 85123234 : ptr = (char *)type;
8392 : : }
8393 [ + + ]: 280043802 : if (ptr != NULL)
8394 : 240134308 : ptr += offset;
8395 : 280043802 : return (void **)ptr;
8396 : : }
8397 : :
8398 : : /* Length of array of slotdef pointers used to store slots with the
8399 : : same __name__. There should be at most MAX_EQUIV-1 slotdef entries with
8400 : : the same __name__, for any __name__. Since that's a static property, it is
8401 : : appropriate to declare fixed-size arrays for this. */
8402 : : #define MAX_EQUIV 10
8403 : :
8404 : : /* Return a slot pointer for a given name, but ONLY if the attribute has
8405 : : exactly one slot function. The name must be an interned string. */
8406 : : static void **
8407 : 19887518 : resolve_slotdups(PyTypeObject *type, PyObject *name)
8408 : : {
8409 : : /* XXX Maybe this could be optimized more -- but is it worth it? */
8410 : :
8411 : : /* pname and ptrs act as a little cache */
8412 : : static PyObject *pname;
8413 : : static slotdef *ptrs[MAX_EQUIV];
8414 : : slotdef *p, **pp;
8415 : : void **res, **ptr;
8416 : :
8417 [ + + ]: 19887518 : if (pname != name) {
8418 : : /* Collect all slotdefs that match name into ptrs. */
8419 : 19872649 : pname = name;
8420 : 19872649 : pp = ptrs;
8421 [ + + ]: 1848156357 : for (p = slotdefs; p->name_strobj; p++) {
8422 [ + + ]: 1828283708 : if (p->name_strobj == name)
8423 : 27943194 : *pp++ = p;
8424 : : }
8425 : 19872649 : *pp = NULL;
8426 : : }
8427 : :
8428 : : /* Look in all slots of the type matching the name. If exactly one of these
8429 : : has a filled-in slot, return a pointer to that slot.
8430 : : Otherwise, return NULL. */
8431 : 19887518 : res = NULL;
8432 [ + + ]: 47586153 : for (pp = ptrs; *pp; pp++) {
8433 : 27969402 : ptr = slotptr(type, (*pp)->offset);
8434 [ + - + + ]: 27969402 : if (ptr == NULL || *ptr == NULL)
8435 : 8203507 : continue;
8436 [ + + ]: 19765895 : if (res != NULL)
8437 : 270767 : return NULL;
8438 : 19495128 : res = ptr;
8439 : : }
8440 : 19616751 : return res;
8441 : : }
8442 : :
8443 : :
8444 : : /* Common code for update_slots_callback() and fixup_slot_dispatchers().
8445 : : *
8446 : : * This is meant to set a "slot" like type->tp_repr or
8447 : : * type->tp_as_sequence->sq_concat by looking up special methods like
8448 : : * __repr__ or __add__. The opposite (adding special methods from slots) is
8449 : : * done by add_operators(), called from PyType_Ready(). Since update_one_slot()
8450 : : * calls PyType_Ready() if needed, the special methods are already in place.
8451 : : *
8452 : : * The special methods corresponding to each slot are defined in the "slotdef"
8453 : : * array. Note that one slot may correspond to multiple special methods and vice
8454 : : * versa. For example, tp_richcompare uses 6 methods __lt__, ..., __ge__ and
8455 : : * tp_as_number->nb_add uses __add__ and __radd__. In the other direction,
8456 : : * __add__ is used by the number and sequence protocols and __getitem__ by the
8457 : : * sequence and mapping protocols. This causes a lot of complications.
8458 : : *
8459 : : * In detail, update_one_slot() does the following:
8460 : : *
8461 : : * First of all, if the slot in question does not exist, return immediately.
8462 : : * This can happen for example if it's tp_as_number->nb_add but tp_as_number
8463 : : * is NULL.
8464 : : *
8465 : : * For the given slot, we loop over all the special methods with a name
8466 : : * corresponding to that slot (for example, for tp_descr_set, this would be
8467 : : * __set__ and __delete__) and we look up these names in the MRO of the type.
8468 : : * If we don't find any special method, the slot is set to NULL (regardless of
8469 : : * what was in the slot before).
8470 : : *
8471 : : * Suppose that we find exactly one special method. If it's a wrapper_descriptor
8472 : : * (i.e. a special method calling a slot, for example str.__repr__ which calls
8473 : : * the tp_repr for the 'str' class) with the correct name ("__repr__" for
8474 : : * tp_repr), for the right class, calling the right wrapper C function (like
8475 : : * wrap_unaryfunc for tp_repr), then the slot is set to the slot that the
8476 : : * wrapper_descriptor originally wrapped. For example, a class inheriting
8477 : : * from 'str' and not redefining __repr__ will have tp_repr set to the tp_repr
8478 : : * of 'str'.
8479 : : * In all other cases where the special method exists, the slot is set to a
8480 : : * wrapper calling the special method. There is one exception: if the special
8481 : : * method is a wrapper_descriptor with the correct name but the type has
8482 : : * precisely one slot set for that name and that slot is not the one that we
8483 : : * are updating, then NULL is put in the slot (this exception is the only place
8484 : : * in update_one_slot() where the *existing* slots matter).
8485 : : *
8486 : : * When there are multiple special methods for the same slot, the above is
8487 : : * applied for each special method. As long as the results agree, the common
8488 : : * resulting slot is applied. If the results disagree, then a wrapper for
8489 : : * the special methods is installed. This is always safe, but less efficient
8490 : : * because it uses method lookup instead of direct C calls.
8491 : : *
8492 : : * There are some further special cases for specific slots, like supporting
8493 : : * __hash__ = None for tp_hash and special code for tp_new.
8494 : : *
8495 : : * When done, return a pointer to the next slotdef with a different offset,
8496 : : * because that's convenient for fixup_slot_dispatchers(). This function never
8497 : : * sets an exception: if an internal error happens (unlikely), it's ignored. */
8498 : : static slotdef *
8499 : 79620320 : update_one_slot(PyTypeObject *type, slotdef *p)
8500 : : {
8501 : : PyObject *descr;
8502 : : PyWrapperDescrObject *d;
8503 : 79620320 : void *generic = NULL, *specific = NULL;
8504 : 79620320 : int use_generic = 0;
8505 : 79620320 : int offset = p->offset;
8506 : : int error;
8507 : 79620320 : void **ptr = slotptr(type, offset);
8508 : :
8509 [ - + ]: 79620320 : if (ptr == NULL) {
8510 : : do {
8511 : 0 : ++p;
8512 [ # # ]: 0 : } while (p->offset == offset);
8513 : 0 : return p;
8514 : : }
8515 : : /* We may end up clearing live exceptions below, so make sure it's ours. */
8516 : : assert(!PyErr_Occurred());
8517 : : do {
8518 : : /* Use faster uncached lookup as we won't get any cache hits during type setup. */
8519 : 112883582 : descr = find_name_in_mro(type, p->name_strobj, &error);
8520 [ + + ]: 112883582 : if (descr == NULL) {
8521 [ - + ]: 88224098 : if (error == -1) {
8522 : : /* It is unlikely but not impossible that there has been an exception
8523 : : during lookup. Since this function originally expected no errors,
8524 : : we ignore them here in order to keep up the interface. */
8525 : 0 : PyErr_Clear();
8526 : : }
8527 [ + + ]: 88224098 : if (ptr == (void**)&type->tp_iternext) {
8528 : 1168934 : specific = (void *)_PyObject_NextNotImplemented;
8529 : : }
8530 : 88224098 : continue;
8531 : : }
8532 [ + + ]: 24659484 : if (Py_IS_TYPE(descr, &PyWrapperDescr_Type) &&
8533 [ + + ]: 39792406 : ((PyWrapperDescrObject *)descr)->d_base->name_strobj == p->name_strobj) {
8534 : 19887518 : void **tptr = resolve_slotdups(type, p->name_strobj);
8535 [ + + + + ]: 19887518 : if (tptr == NULL || tptr == ptr)
8536 : 15979246 : generic = p->function;
8537 : 19887518 : d = (PyWrapperDescrObject *)descr;
8538 [ + + + + ]: 19887518 : if ((specific == NULL || specific == d->d_wrapped) &&
8539 [ + + + + ]: 35804778 : d->d_base->wrapper == p->wrapper &&
8540 : 15919644 : PyType_IsSubtype(type, PyDescr_TYPE(d)))
8541 : : {
8542 : 15919643 : specific = d->d_wrapped;
8543 : : }
8544 : : else {
8545 : : /* We cannot use the specific slot function because either
8546 : : - it is not unique: there are multiple methods for this
8547 : : slot and they conflict
8548 : : - the signature is wrong (as checked by the ->wrapper
8549 : : comparison above)
8550 : : - it's wrapping the wrong class
8551 : : */
8552 : 3967875 : use_generic = 1;
8553 : : }
8554 : : }
8555 [ + + + + ]: 5859048 : else if (Py_IS_TYPE(descr, &PyCFunction_Type) &&
8556 : 1087082 : PyCFunction_GET_FUNCTION(descr) ==
8557 : 1086186 : _PyCFunction_CAST(tp_new_wrapper) &&
8558 [ + - ]: 1086186 : ptr == (void**)&type->tp_new)
8559 : : {
8560 : : /* The __new__ wrapper is not a wrapper descriptor,
8561 : : so must be special-cased differently.
8562 : : If we don't do this, creating an instance will
8563 : : always use slot_tp_new which will look up
8564 : : __new__ in the MRO which will call tp_new_wrapper
8565 : : which will look through the base classes looking
8566 : : for a static base and call its tp_new (usually
8567 : : PyType_GenericNew), after performing various
8568 : : sanity checks and constructing a new argument
8569 : : list. Cut all that nonsense short -- this speeds
8570 : : up instance creation tremendously. */
8571 : 1086186 : specific = (void *)type->tp_new;
8572 : : /* XXX I'm not 100% sure that there isn't a hole
8573 : : in this reasoning that requires additional
8574 : : sanity checks. I'll buy the first person to
8575 : : point out a bug in this reasoning a beer. */
8576 : : }
8577 [ + + ]: 3685780 : else if (descr == Py_None &&
8578 [ + + ]: 78067 : ptr == (void**)&type->tp_hash) {
8579 : : /* We specifically allow __hash__ to be set to None
8580 : : to prevent inheritance of the default
8581 : : implementation from object.__hash__ */
8582 : 69525 : specific = (void *)PyObject_HashNotImplemented;
8583 : : }
8584 : : else {
8585 : 3616255 : use_generic = 1;
8586 : 3616255 : generic = p->function;
8587 : : }
8588 [ + + ]: 112883582 : } while ((++p)->offset == offset);
8589 [ + + + + ]: 79620320 : if (specific && !use_generic)
8590 : 10510964 : *ptr = specific;
8591 : : else
8592 : 69109356 : *ptr = generic;
8593 : 79620320 : return p;
8594 : : }
8595 : :
8596 : : /* In the type, update the slots whose slotdefs are gathered in the pp array.
8597 : : This is a callback for update_subclasses(). */
8598 : : static int
8599 : 479372 : update_slots_callback(PyTypeObject *type, void *data)
8600 : : {
8601 : 479372 : slotdef **pp = (slotdef **)data;
8602 [ + + ]: 1022447 : for (; *pp; pp++) {
8603 : 543075 : update_one_slot(type, *pp);
8604 : : }
8605 : 479372 : return 0;
8606 : : }
8607 : :
8608 : : static int slotdefs_initialized = 0;
8609 : : /* Initialize the slotdefs table by adding interned string objects for the
8610 : : names. */
8611 : : PyStatus
8612 : 2967 : _PyTypes_InitSlotDefs(void)
8613 : : {
8614 [ - + ]: 2967 : if (slotdefs_initialized) {
8615 : 0 : return _PyStatus_OK();
8616 : : }
8617 : :
8618 [ + + ]: 275931 : for (slotdef *p = slotdefs; p->name; p++) {
8619 : : /* Slots must be ordered by their offset in the PyHeapTypeObject. */
8620 : : assert(!p[1].name || p->offset <= p[1].offset);
8621 : : /* bpo-40521: Interned strings are shared by all subinterpreters */
8622 : 272964 : p->name_strobj = PyUnicode_InternFromString(p->name);
8623 [ + - - + ]: 272964 : if (!p->name_strobj || !PyUnicode_CHECK_INTERNED(p->name_strobj)) {
8624 : 0 : return _PyStatus_NO_MEMORY();
8625 : : }
8626 : : }
8627 : 2967 : slotdefs_initialized = 1;
8628 : 2967 : return _PyStatus_OK();
8629 : : }
8630 : :
8631 : : /* Undo _PyTypes_InitSlotDefs(), releasing the interned strings. */
8632 : 2956 : static void clear_slotdefs(void)
8633 : : {
8634 [ + + ]: 274908 : for (slotdef *p = slotdefs; p->name; p++) {
8635 [ + - ]: 271952 : Py_CLEAR(p->name_strobj);
8636 : : }
8637 : 2956 : slotdefs_initialized = 0;
8638 : 2956 : }
8639 : :
8640 : : /* Update the slots after assignment to a class (type) attribute. */
8641 : : static int
8642 : 878788 : update_slot(PyTypeObject *type, PyObject *name)
8643 : : {
8644 : : slotdef *ptrs[MAX_EQUIV];
8645 : : slotdef *p;
8646 : : slotdef **pp;
8647 : : int offset;
8648 : :
8649 : : assert(PyUnicode_CheckExact(name));
8650 : : assert(PyUnicode_CHECK_INTERNED(name));
8651 : :
8652 : : assert(slotdefs_initialized);
8653 : 878788 : pp = ptrs;
8654 [ + + ]: 81727284 : for (p = slotdefs; p->name; p++) {
8655 : : assert(PyUnicode_CheckExact(p->name_strobj));
8656 : : assert(PyUnicode_CheckExact(name));
8657 : : /* bpo-40521: Using interned strings. */
8658 [ + + ]: 80848496 : if (p->name_strobj == name) {
8659 : 539049 : *pp++ = p;
8660 : : }
8661 : : }
8662 : 878788 : *pp = NULL;
8663 [ + + ]: 1417837 : for (pp = ptrs; *pp; pp++) {
8664 : 539049 : p = *pp;
8665 : 539049 : offset = p->offset;
8666 [ + + + + ]: 746005 : while (p > slotdefs && (p-1)->offset == offset)
8667 : 206956 : --p;
8668 : 539049 : *pp = p;
8669 : : }
8670 [ + + ]: 878788 : if (ptrs[0] == NULL)
8671 : 402550 : return 0; /* Not an attribute that affects any slots */
8672 : 476238 : return update_subclasses(type, name,
8673 : : update_slots_callback, (void *)ptrs);
8674 : : }
8675 : :
8676 : : /* Store the proper functions in the slot dispatches at class (type)
8677 : : definition time, based upon which operations the class overrides in its
8678 : : dict. */
8679 : : static void
8680 : 1216573 : fixup_slot_dispatchers(PyTypeObject *type)
8681 : : {
8682 : : assert(!PyErr_Occurred());
8683 : : assert(slotdefs_initialized);
8684 [ + + ]: 80293818 : for (slotdef *p = slotdefs; p->name; ) {
8685 : 79077245 : p = update_one_slot(type, p);
8686 : : }
8687 : 1216573 : }
8688 : :
8689 : : static void
8690 : 675 : update_all_slots(PyTypeObject* type)
8691 : : {
8692 : : slotdef *p;
8693 : :
8694 : : /* Clear the VALID_VERSION flag of 'type' and all its subclasses. */
8695 : 675 : PyType_Modified(type);
8696 : :
8697 : : assert(slotdefs_initialized);
8698 [ + + ]: 62775 : for (p = slotdefs; p->name; p++) {
8699 : : /* update_slot returns int but can't actually fail */
8700 : 62100 : update_slot(type, p->name_strobj);
8701 : : }
8702 : 675 : }
8703 : :
8704 : :
8705 : : /* Call __set_name__ on all attributes (including descriptors)
8706 : : in a newly generated type */
8707 : : static int
8708 : 1216573 : type_new_set_names(PyTypeObject *type)
8709 : : {
8710 : 1216573 : PyObject *names_to_set = PyDict_Copy(type->tp_dict);
8711 [ - + ]: 1216573 : if (names_to_set == NULL) {
8712 : 0 : return -1;
8713 : : }
8714 : :
8715 : 1216573 : Py_ssize_t i = 0;
8716 : : PyObject *key, *value;
8717 [ + + ]: 11748400 : while (PyDict_Next(names_to_set, &i, &key, &value)) {
8718 : 10531839 : PyObject *set_name = _PyObject_LookupSpecial(value,
8719 : : &_Py_ID(__set_name__));
8720 [ + + ]: 10531839 : if (set_name == NULL) {
8721 [ - + ]: 10332326 : if (PyErr_Occurred()) {
8722 : 0 : goto error;
8723 : : }
8724 : 10332326 : continue;
8725 : : }
8726 : :
8727 : 199513 : PyObject *res = PyObject_CallFunctionObjArgs(set_name, type, key, NULL);
8728 : 199513 : Py_DECREF(set_name);
8729 : :
8730 [ + + ]: 199513 : if (res == NULL) {
8731 : 12 : _PyErr_FormatFromCause(PyExc_RuntimeError,
8732 : : "Error calling __set_name__ on '%.100s' instance %R "
8733 : : "in '%.100s'",
8734 : 12 : Py_TYPE(value)->tp_name, key, type->tp_name);
8735 : 12 : goto error;
8736 : : }
8737 : 199501 : Py_DECREF(res);
8738 : : }
8739 : :
8740 : 1216561 : Py_DECREF(names_to_set);
8741 : 1216561 : return 0;
8742 : :
8743 : 12 : error:
8744 : 12 : Py_DECREF(names_to_set);
8745 : 12 : return -1;
8746 : : }
8747 : :
8748 : :
8749 : : /* Call __init_subclass__ on the parent of a newly generated type */
8750 : : static int
8751 : 1216561 : type_new_init_subclass(PyTypeObject *type, PyObject *kwds)
8752 : : {
8753 : 1216561 : PyObject *args[2] = {(PyObject *)type, (PyObject *)type};
8754 : 1216561 : PyObject *super = _PyObject_FastCall((PyObject *)&PySuper_Type, args, 2);
8755 [ + + ]: 1216561 : if (super == NULL) {
8756 : 1 : return -1;
8757 : : }
8758 : :
8759 : 1216560 : PyObject *func = PyObject_GetAttr(super, &_Py_ID(__init_subclass__));
8760 : 1216560 : Py_DECREF(super);
8761 [ - + ]: 1216560 : if (func == NULL) {
8762 : 0 : return -1;
8763 : : }
8764 : :
8765 : 1216560 : PyObject *result = PyObject_VectorcallDict(func, NULL, 0, kwds);
8766 : 1216560 : Py_DECREF(func);
8767 [ + + ]: 1216560 : if (result == NULL) {
8768 : 43 : return -1;
8769 : : }
8770 : :
8771 : 1216517 : Py_DECREF(result);
8772 : 1216517 : return 0;
8773 : : }
8774 : :
8775 : :
8776 : : /* recurse_down_subclasses() and update_subclasses() are mutually
8777 : : recursive functions to call a callback for all subclasses,
8778 : : but refraining from recursing into subclasses that define 'attr_name'. */
8779 : :
8780 : : static int
8781 : 479372 : update_subclasses(PyTypeObject *type, PyObject *attr_name,
8782 : : update_callback callback, void *data)
8783 : : {
8784 [ - + ]: 479372 : if (callback(type, data) < 0) {
8785 : 0 : return -1;
8786 : : }
8787 : 479372 : return recurse_down_subclasses(type, attr_name, callback, data);
8788 : : }
8789 : :
8790 : : static int
8791 : 479372 : recurse_down_subclasses(PyTypeObject *type, PyObject *attr_name,
8792 : : update_callback callback, void *data)
8793 : : {
8794 : : // It is safe to use a borrowed reference because update_subclasses() is
8795 : : // only used with update_slots_callback() which doesn't modify
8796 : : // tp_subclasses.
8797 : 479372 : PyObject *subclasses = type->tp_subclasses; // borrowed ref
8798 [ + + ]: 479372 : if (subclasses == NULL) {
8799 : 477695 : return 0;
8800 : : }
8801 : : assert(PyDict_CheckExact(subclasses));
8802 : :
8803 : 1677 : Py_ssize_t i = 0;
8804 : : PyObject *ref;
8805 [ + + ]: 4831 : while (PyDict_Next(subclasses, &i, NULL, &ref)) {
8806 : : assert(PyWeakref_CheckRef(ref));
8807 : 3154 : PyObject *obj = PyWeakref_GET_OBJECT(ref);
8808 : : assert(obj != NULL);
8809 [ - + ]: 3154 : if (obj == Py_None) {
8810 : 0 : continue;
8811 : : }
8812 : 3154 : PyTypeObject *subclass = _PyType_CAST(obj);
8813 : :
8814 : : /* Avoid recursing down into unaffected classes */
8815 : 3154 : PyObject *dict = subclass->tp_dict;
8816 [ + - + - ]: 3154 : if (dict != NULL && PyDict_Check(dict)) {
8817 : 3154 : int r = PyDict_Contains(dict, attr_name);
8818 [ - + ]: 3154 : if (r < 0) {
8819 : 0 : return -1;
8820 : : }
8821 [ + + ]: 3154 : if (r > 0) {
8822 : 20 : continue;
8823 : : }
8824 : : }
8825 : :
8826 [ - + ]: 3134 : if (update_subclasses(subclass, attr_name, callback, data) < 0) {
8827 : 0 : return -1;
8828 : : }
8829 : : }
8830 : 1677 : return 0;
8831 : : }
8832 : :
8833 : : /* This function is called by PyType_Ready() to populate the type's
8834 : : dictionary with method descriptors for function slots. For each
8835 : : function slot (like tp_repr) that's defined in the type, one or more
8836 : : corresponding descriptors are added in the type's tp_dict dictionary
8837 : : under the appropriate name (like __repr__). Some function slots
8838 : : cause more than one descriptor to be added (for example, the nb_add
8839 : : slot adds both __add__ and __radd__ descriptors) and some function
8840 : : slots compete for the same descriptor (for example both sq_item and
8841 : : mp_subscript generate a __getitem__ descriptor).
8842 : :
8843 : : In the latter case, the first slotdef entry encountered wins. Since
8844 : : slotdef entries are sorted by the offset of the slot in the
8845 : : PyHeapTypeObject, this gives us some control over disambiguating
8846 : : between competing slots: the members of PyHeapTypeObject are listed
8847 : : from most general to least general, so the most general slot is
8848 : : preferred. In particular, because as_mapping comes before as_sequence,
8849 : : for a type that defines both mp_subscript and sq_item, mp_subscript
8850 : : wins.
8851 : :
8852 : : This only adds new descriptors and doesn't overwrite entries in
8853 : : tp_dict that were previously defined. The descriptors contain a
8854 : : reference to the C function they must call, so that it's safe if they
8855 : : are copied into a subtype's __dict__ and the subtype has a different
8856 : : C function in its slot -- calling the method defined by the
8857 : : descriptor will call the C function that was used to create it,
8858 : : rather than the C function present in the slot when it is called.
8859 : : (This is important because a subtype may have a C function in the
8860 : : slot that calls the method from the dictionary, and we want to avoid
8861 : : infinite recursion here.) */
8862 : :
8863 : : static int
8864 : 2005280 : add_operators(PyTypeObject *type)
8865 : : {
8866 : 2005280 : PyObject *dict = type->tp_dict;
8867 : : slotdef *p;
8868 : : PyObject *descr;
8869 : : void **ptr;
8870 : :
8871 : : assert(slotdefs_initialized);
8872 [ + + ]: 186491040 : for (p = slotdefs; p->name; p++) {
8873 [ + + ]: 184485760 : if (p->wrapper == NULL)
8874 : 12031680 : continue;
8875 : 172454080 : ptr = slotptr(type, p->offset);
8876 [ + + + + ]: 172454080 : if (!ptr || !*ptr)
8877 : 168924040 : continue;
8878 : 3530040 : int r = PyDict_Contains(dict, p->name_strobj);
8879 [ + + ]: 3530040 : if (r > 0)
8880 : 66177 : continue;
8881 [ - + ]: 3463863 : if (r < 0) {
8882 : 0 : return -1;
8883 : : }
8884 [ + + ]: 3463863 : if (*ptr == (void *)PyObject_HashNotImplemented) {
8885 : : /* Classes may prevent the inheritance of the tp_hash
8886 : : slot by storing PyObject_HashNotImplemented in it. Make it
8887 : : visible as a None value for the __hash__ attribute. */
8888 [ - + ]: 33516 : if (PyDict_SetItem(dict, p->name_strobj, Py_None) < 0)
8889 : 0 : return -1;
8890 : : }
8891 : : else {
8892 : 3430347 : descr = PyDescr_NewWrapper(type, p, *ptr);
8893 [ - + ]: 3430347 : if (descr == NULL)
8894 : 0 : return -1;
8895 [ - + ]: 3430347 : if (PyDict_SetItem(dict, p->name_strobj, descr) < 0) {
8896 : 0 : Py_DECREF(descr);
8897 : 0 : return -1;
8898 : : }
8899 : 3430347 : Py_DECREF(descr);
8900 : : }
8901 : : }
8902 : 2005280 : return 0;
8903 : : }
8904 : :
8905 : :
8906 : : /* Cooperative 'super' */
8907 : :
8908 : : typedef struct {
8909 : : PyObject_HEAD
8910 : : PyTypeObject *type;
8911 : : PyObject *obj;
8912 : : PyTypeObject *obj_type;
8913 : : } superobject;
8914 : :
8915 : : static PyMemberDef super_members[] = {
8916 : : {"__thisclass__", T_OBJECT, offsetof(superobject, type), READONLY,
8917 : : "the class invoking super()"},
8918 : : {"__self__", T_OBJECT, offsetof(superobject, obj), READONLY,
8919 : : "the instance invoking super(); may be None"},
8920 : : {"__self_class__", T_OBJECT, offsetof(superobject, obj_type), READONLY,
8921 : : "the type of the instance invoking super(); may be None"},
8922 : : {0}
8923 : : };
8924 : :
8925 : : static void
8926 : 12225416 : super_dealloc(PyObject *self)
8927 : : {
8928 : 12225416 : superobject *su = (superobject *)self;
8929 : :
8930 : 12225416 : _PyObject_GC_UNTRACK(self);
8931 : 12225416 : Py_XDECREF(su->obj);
8932 : 12225416 : Py_XDECREF(su->type);
8933 : 12225416 : Py_XDECREF(su->obj_type);
8934 : 12225416 : Py_TYPE(self)->tp_free(self);
8935 : 12225416 : }
8936 : :
8937 : : static PyObject *
8938 : 0 : super_repr(PyObject *self)
8939 : : {
8940 : 0 : superobject *su = (superobject *)self;
8941 : :
8942 [ # # ]: 0 : if (su->obj_type)
8943 : 0 : return PyUnicode_FromFormat(
8944 : : "<super: <class '%s'>, <%s object>>",
8945 : 0 : su->type ? su->type->tp_name : "NULL",
8946 [ # # ]: 0 : su->obj_type->tp_name);
8947 : : else
8948 : 0 : return PyUnicode_FromFormat(
8949 : : "<super: <class '%s'>, NULL>",
8950 [ # # ]: 0 : su->type ? su->type->tp_name : "NULL");
8951 : : }
8952 : :
8953 : : static PyObject *
8954 : 12225536 : super_getattro(PyObject *self, PyObject *name)
8955 : : {
8956 : 12225536 : superobject *su = (superobject *)self;
8957 : : PyTypeObject *starttype;
8958 : : PyObject *mro;
8959 : : Py_ssize_t i, n;
8960 : :
8961 : 12225536 : starttype = su->obj_type;
8962 [ + + ]: 12225536 : if (starttype == NULL)
8963 : 2 : goto skip;
8964 : :
8965 : : /* We want __class__ to return the class of the super object
8966 : : (i.e. super, or a subclass), not the class of su->obj. */
8967 [ + - + + ]: 24451068 : if (PyUnicode_Check(name) &&
8968 [ + + ]: 12311164 : PyUnicode_GET_LENGTH(name) == 9 &&
8969 : 85630 : _PyUnicode_Equal(name, &_Py_ID(__class__)))
8970 : 1 : goto skip;
8971 : :
8972 : 12225533 : mro = starttype->tp_mro;
8973 [ + + ]: 12225533 : if (mro == NULL)
8974 : 1 : goto skip;
8975 : :
8976 : : assert(PyTuple_Check(mro));
8977 : 12225532 : n = PyTuple_GET_SIZE(mro);
8978 : :
8979 : : /* No need to check the last one: it's gonna be skipped anyway. */
8980 [ + + ]: 13869948 : for (i = 0; i+1 < n; i++) {
8981 [ + + ]: 13869947 : if ((PyObject *)(su->type) == PyTuple_GET_ITEM(mro, i))
8982 : 12225531 : break;
8983 : : }
8984 : 12225532 : i++; /* skip su->type (if any) */
8985 [ + + ]: 12225532 : if (i >= n)
8986 : 1 : goto skip;
8987 : :
8988 : : /* keep a strong reference to mro because starttype->tp_mro can be
8989 : : replaced during PyDict_GetItemWithError(dict, name) */
8990 : 12225531 : Py_INCREF(mro);
8991 : : do {
8992 : 19652161 : PyObject *obj = PyTuple_GET_ITEM(mro, i);
8993 : 19652161 : PyObject *dict = _PyType_CAST(obj)->tp_dict;
8994 : : assert(dict != NULL && PyDict_Check(dict));
8995 : :
8996 : 19652161 : PyObject *res = PyDict_GetItemWithError(dict, name);
8997 [ + + ]: 19652161 : if (res != NULL) {
8998 : 12225445 : Py_INCREF(res);
8999 : :
9000 : 12225445 : descrgetfunc f = Py_TYPE(res)->tp_descr_get;
9001 [ + + ]: 12225445 : if (f != NULL) {
9002 : : PyObject *res2;
9003 : 11104765 : res2 = f(res,
9004 : : /* Only pass 'obj' param if this is instance-mode super
9005 : : (See SF ID #743627) */
9006 [ + + ]: 11104765 : (su->obj == (PyObject *)starttype) ? NULL : su->obj,
9007 : : (PyObject *)starttype);
9008 : 11104765 : Py_DECREF(res);
9009 : 11104765 : res = res2;
9010 : : }
9011 : :
9012 : 12225445 : Py_DECREF(mro);
9013 : 12225445 : return res;
9014 : : }
9015 [ - + ]: 7426716 : else if (PyErr_Occurred()) {
9016 : 0 : Py_DECREF(mro);
9017 : 0 : return NULL;
9018 : : }
9019 : :
9020 : 7426716 : i++;
9021 [ + + ]: 7426716 : } while (i < n);
9022 : 86 : Py_DECREF(mro);
9023 : :
9024 : 91 : skip:
9025 : 91 : return PyObject_GenericGetAttr(self, name);
9026 : : }
9027 : :
9028 : : static PyTypeObject *
9029 : 12226400 : supercheck(PyTypeObject *type, PyObject *obj)
9030 : : {
9031 : : /* Check that a super() call makes sense. Return a type object.
9032 : :
9033 : : obj can be a class, or an instance of one:
9034 : :
9035 : : - If it is a class, it must be a subclass of 'type'. This case is
9036 : : used for class methods; the return value is obj.
9037 : :
9038 : : - If it is an instance, it must be an instance of 'type'. This is
9039 : : the normal case; the return value is obj.__class__.
9040 : :
9041 : : But... when obj is an instance, we want to allow for the case where
9042 : : Py_TYPE(obj) is not a subclass of type, but obj.__class__ is!
9043 : : This will allow using super() with a proxy for obj.
9044 : : */
9045 : :
9046 : : /* Check for first bullet above (special case) */
9047 [ + + + + ]: 12226400 : if (PyType_Check(obj) && PyType_IsSubtype((PyTypeObject *)obj, type)) {
9048 : 2359529 : Py_INCREF(obj);
9049 : 2359529 : return (PyTypeObject *)obj;
9050 : : }
9051 : :
9052 : : /* Normal case */
9053 [ + + ]: 9866871 : if (PyType_IsSubtype(Py_TYPE(obj), type)) {
9054 : 9866864 : Py_INCREF(Py_TYPE(obj));
9055 : 9866864 : return Py_TYPE(obj);
9056 : : }
9057 : : else {
9058 : : /* Try the slow way */
9059 : : PyObject *class_attr;
9060 : :
9061 [ - + ]: 7 : if (_PyObject_LookupAttr(obj, &_Py_ID(__class__), &class_attr) < 0) {
9062 : 1 : return NULL;
9063 : : }
9064 [ + - + - ]: 14 : if (class_attr != NULL &&
9065 : 7 : PyType_Check(class_attr) &&
9066 [ + + ]: 7 : (PyTypeObject *)class_attr != Py_TYPE(obj))
9067 : : {
9068 : 1 : int ok = PyType_IsSubtype(
9069 : : (PyTypeObject *)class_attr, type);
9070 [ + - ]: 1 : if (ok) {
9071 : 1 : return (PyTypeObject *)class_attr;
9072 : : }
9073 : : }
9074 : 6 : Py_XDECREF(class_attr);
9075 : : }
9076 : :
9077 : 6 : PyErr_SetString(PyExc_TypeError,
9078 : : "super(type, obj): "
9079 : : "obj must be an instance or subtype of type");
9080 : 6 : return NULL;
9081 : : }
9082 : :
9083 : : static PyObject *
9084 : 16 : super_descr_get(PyObject *self, PyObject *obj, PyObject *type)
9085 : : {
9086 : 16 : superobject *su = (superobject *)self;
9087 : : superobject *newobj;
9088 : :
9089 [ + - + - : 16 : if (obj == NULL || obj == Py_None || su->obj != NULL) {
- + ]
9090 : : /* Not binding to an object, or already bound */
9091 : 0 : Py_INCREF(self);
9092 : 0 : return self;
9093 : : }
9094 [ + + ]: 16 : if (!Py_IS_TYPE(su, &PySuper_Type))
9095 : : /* If su is an instance of a (strict) subclass of super,
9096 : : call its type */
9097 : 1 : return PyObject_CallFunctionObjArgs((PyObject *)Py_TYPE(su),
9098 : : su->type, obj, NULL);
9099 : : else {
9100 : : /* Inline the common case */
9101 : 15 : PyTypeObject *obj_type = supercheck(su->type, obj);
9102 [ + + ]: 15 : if (obj_type == NULL)
9103 : 2 : return NULL;
9104 : 13 : newobj = (superobject *)PySuper_Type.tp_new(&PySuper_Type,
9105 : : NULL, NULL);
9106 [ - + ]: 13 : if (newobj == NULL)
9107 : 0 : return NULL;
9108 : 13 : Py_INCREF(su->type);
9109 : 13 : Py_INCREF(obj);
9110 : 13 : newobj->type = su->type;
9111 : 13 : newobj->obj = obj;
9112 : 13 : newobj->obj_type = obj_type;
9113 : 13 : return (PyObject *)newobj;
9114 : : }
9115 : : }
9116 : :
9117 : : static int
9118 : 9543163 : super_init_without_args(_PyInterpreterFrame *cframe, PyCodeObject *co,
9119 : : PyTypeObject **type_p, PyObject **obj_p)
9120 : : {
9121 [ + + ]: 9543163 : if (co->co_argcount == 0) {
9122 : 1 : PyErr_SetString(PyExc_RuntimeError,
9123 : : "super(): no arguments");
9124 : 1 : return -1;
9125 : : }
9126 : :
9127 : : assert(cframe->f_code->co_nlocalsplus > 0);
9128 : 9543162 : PyObject *firstarg = _PyFrame_GetLocalsArray(cframe)[0];
9129 : : // The first argument might be a cell.
9130 [ + + + + ]: 9543162 : if (firstarg != NULL && (_PyLocals_GetKind(co->co_localspluskinds, 0) & CO_FAST_CELL)) {
9131 : : // "firstarg" is a cell here unless (very unlikely) super()
9132 : : // was called from the C-API before the first MAKE_CELL op.
9133 [ + - ]: 8538 : if (_PyInterpreterFrame_LASTI(cframe) >= 0) {
9134 : : // MAKE_CELL and COPY_FREE_VARS have no quickened forms, so no need
9135 : : // to use _PyOpcode_Deopt here:
9136 : : assert(_Py_OPCODE(_PyCode_CODE(co)[0]) == MAKE_CELL ||
9137 : : _Py_OPCODE(_PyCode_CODE(co)[0]) == COPY_FREE_VARS);
9138 : : assert(PyCell_Check(firstarg));
9139 : 8538 : firstarg = PyCell_GET(firstarg);
9140 : : }
9141 : : }
9142 [ + + ]: 9543162 : if (firstarg == NULL) {
9143 : 1 : PyErr_SetString(PyExc_RuntimeError,
9144 : : "super(): arg[0] deleted");
9145 : 1 : return -1;
9146 : : }
9147 : :
9148 : : // Look for __class__ in the free vars.
9149 : 9543161 : PyTypeObject *type = NULL;
9150 : 9543161 : int i = co->co_nlocals + co->co_nplaincellvars;
9151 [ + - ]: 9543168 : for (; i < co->co_nlocalsplus; i++) {
9152 : : assert((_PyLocals_GetKind(co->co_localspluskinds, i) & CO_FAST_FREE) != 0);
9153 : 9543168 : PyObject *name = PyTuple_GET_ITEM(co->co_localsplusnames, i);
9154 : : assert(PyUnicode_Check(name));
9155 [ + + ]: 9543168 : if (_PyUnicode_Equal(name, &_Py_ID(__class__))) {
9156 : 9543161 : PyObject *cell = _PyFrame_GetLocalsArray(cframe)[i];
9157 [ + - - + ]: 9543161 : if (cell == NULL || !PyCell_Check(cell)) {
9158 : 0 : PyErr_SetString(PyExc_RuntimeError,
9159 : : "super(): bad __class__ cell");
9160 : 0 : return -1;
9161 : : }
9162 : 9543161 : type = (PyTypeObject *) PyCell_GET(cell);
9163 [ + + ]: 9543161 : if (type == NULL) {
9164 : 1 : PyErr_SetString(PyExc_RuntimeError,
9165 : : "super(): empty __class__ cell");
9166 : 1 : return -1;
9167 : : }
9168 [ - + ]: 9543160 : if (!PyType_Check(type)) {
9169 : 0 : PyErr_Format(PyExc_RuntimeError,
9170 : : "super(): __class__ is not a type (%s)",
9171 : 0 : Py_TYPE(type)->tp_name);
9172 : 0 : return -1;
9173 : : }
9174 : 9543160 : break;
9175 : : }
9176 : : }
9177 [ - + ]: 9543160 : if (type == NULL) {
9178 : 0 : PyErr_SetString(PyExc_RuntimeError,
9179 : : "super(): __class__ cell not found");
9180 : 0 : return -1;
9181 : : }
9182 : :
9183 : 9543160 : *type_p = type;
9184 : 9543160 : *obj_p = firstarg;
9185 : 9543160 : return 0;
9186 : : }
9187 : :
9188 : : static int super_init_impl(PyObject *self, PyTypeObject *type, PyObject *obj);
9189 : :
9190 : : static int
9191 : 1004 : super_init(PyObject *self, PyObject *args, PyObject *kwds)
9192 : : {
9193 : 1004 : PyTypeObject *type = NULL;
9194 : 1004 : PyObject *obj = NULL;
9195 : :
9196 [ - + - - ]: 1004 : if (!_PyArg_NoKeywords("super", kwds))
9197 : 0 : return -1;
9198 [ - + ]: 1004 : if (!PyArg_ParseTuple(args, "|O!O:super", &PyType_Type, &type, &obj))
9199 : 0 : return -1;
9200 [ - + ]: 1004 : if (super_init_impl(self, type, obj) < 0) {
9201 : 0 : return -1;
9202 : : }
9203 : 1004 : return 0;
9204 : : }
9205 : :
9206 : : static inline int
9207 : 12226402 : super_init_impl(PyObject *self, PyTypeObject *type, PyObject *obj) {
9208 : 12226402 : superobject *su = (superobject *)self;
9209 : 12226402 : PyTypeObject *obj_type = NULL;
9210 [ + + ]: 12226402 : if (type == NULL) {
9211 : : /* Call super(), without args -- fill in from __class__
9212 : : and first local variable on the stack. */
9213 : 9543163 : PyThreadState *tstate = _PyThreadState_GET();
9214 : 9543163 : _PyInterpreterFrame *cframe = tstate->cframe->current_frame;
9215 [ - + ]: 9543163 : if (cframe == NULL) {
9216 : 0 : PyErr_SetString(PyExc_RuntimeError,
9217 : : "super(): no current frame");
9218 : 0 : return -1;
9219 : : }
9220 : 9543163 : int res = super_init_without_args(cframe, cframe->f_code, &type, &obj);
9221 : :
9222 [ + + ]: 9543163 : if (res < 0) {
9223 : 3 : return -1;
9224 : : }
9225 : : }
9226 : :
9227 [ - + ]: 12226399 : if (obj == Py_None)
9228 : 0 : obj = NULL;
9229 [ + + ]: 12226399 : if (obj != NULL) {
9230 : 12226385 : obj_type = supercheck(type, obj);
9231 [ + + ]: 12226385 : if (obj_type == NULL)
9232 : 4 : return -1;
9233 : 12226381 : Py_INCREF(obj);
9234 : : }
9235 : 12226395 : Py_INCREF(type);
9236 : 12226395 : Py_XSETREF(su->type, type);
9237 : 12226395 : Py_XSETREF(su->obj, obj);
9238 : 12226395 : Py_XSETREF(su->obj_type, obj_type);
9239 : 12226395 : return 0;
9240 : : }
9241 : :
9242 : : PyDoc_STRVAR(super_doc,
9243 : : "super() -> same as super(__class__, <first argument>)\n"
9244 : : "super(type) -> unbound super object\n"
9245 : : "super(type, obj) -> bound super object; requires isinstance(obj, type)\n"
9246 : : "super(type, type2) -> bound super object; requires issubclass(type2, type)\n"
9247 : : "Typical use to call a cooperative superclass method:\n"
9248 : : "class C(B):\n"
9249 : : " def meth(self, arg):\n"
9250 : : " super().meth(arg)\n"
9251 : : "This works for class methods too:\n"
9252 : : "class C(B):\n"
9253 : : " @classmethod\n"
9254 : : " def cmeth(cls, arg):\n"
9255 : : " super().cmeth(arg)\n");
9256 : :
9257 : : static int
9258 : 6500 : super_traverse(PyObject *self, visitproc visit, void *arg)
9259 : : {
9260 : 6500 : superobject *su = (superobject *)self;
9261 : :
9262 [ + + - + ]: 6500 : Py_VISIT(su->obj);
9263 [ + - - + ]: 6500 : Py_VISIT(su->type);
9264 [ + + - + ]: 6500 : Py_VISIT(su->obj_type);
9265 : :
9266 : 6500 : return 0;
9267 : : }
9268 : :
9269 : : static PyObject *
9270 : 12225401 : super_vectorcall(PyObject *self, PyObject *const *args,
9271 : : size_t nargsf, PyObject *kwnames)
9272 : : {
9273 : : assert(PyType_Check(self));
9274 [ + + + - ]: 12225401 : if (!_PyArg_NoKwnames("super", kwnames)) {
9275 : 1 : return NULL;
9276 : : }
9277 : 12225400 : Py_ssize_t nargs = PyVectorcall_NARGS(nargsf);
9278 [ + - + + : 12225400 : if (!_PyArg_CheckPositional("super()", nargs, 0, 2)) {
+ - ]
9279 : 1 : return NULL;
9280 : : }
9281 : 12225399 : PyTypeObject *type = NULL;
9282 : 12225399 : PyObject *obj = NULL;
9283 : 12225399 : PyTypeObject *self_type = (PyTypeObject *)self;
9284 : 12225399 : PyObject *su = self_type->tp_alloc(self_type, 0);
9285 [ - + ]: 12225399 : if (su == NULL) {
9286 : 0 : return NULL;
9287 : : }
9288 : : // 1 or 2 argument form super().
9289 [ + + ]: 12225399 : if (nargs != 0) {
9290 : 2682236 : PyObject *arg0 = args[0];
9291 [ + + ]: 2682236 : if (!PyType_Check(arg0)) {
9292 : 1 : PyErr_Format(PyExc_TypeError,
9293 : 1 : "super() argument 1 must be a type, not %.200s", Py_TYPE(arg0)->tp_name);
9294 : 1 : goto fail;
9295 : : }
9296 : 2682235 : type = (PyTypeObject *)arg0;
9297 : : }
9298 [ + + ]: 12225398 : if (nargs == 2) {
9299 : 2682222 : obj = args[1];
9300 : : }
9301 [ + + ]: 12225398 : if (super_init_impl(su, type, obj) < 0) {
9302 : 7 : goto fail;
9303 : : }
9304 : 12225391 : return su;
9305 : 8 : fail:
9306 : 8 : Py_DECREF(su);
9307 : 8 : return NULL;
9308 : : }
9309 : :
9310 : : PyTypeObject PySuper_Type = {
9311 : : PyVarObject_HEAD_INIT(&PyType_Type, 0)
9312 : : "super", /* tp_name */
9313 : : sizeof(superobject), /* tp_basicsize */
9314 : : 0, /* tp_itemsize */
9315 : : /* methods */
9316 : : super_dealloc, /* tp_dealloc */
9317 : : 0, /* tp_vectorcall_offset */
9318 : : 0, /* tp_getattr */
9319 : : 0, /* tp_setattr */
9320 : : 0, /* tp_as_async */
9321 : : super_repr, /* tp_repr */
9322 : : 0, /* tp_as_number */
9323 : : 0, /* tp_as_sequence */
9324 : : 0, /* tp_as_mapping */
9325 : : 0, /* tp_hash */
9326 : : 0, /* tp_call */
9327 : : 0, /* tp_str */
9328 : : super_getattro, /* tp_getattro */
9329 : : 0, /* tp_setattro */
9330 : : 0, /* tp_as_buffer */
9331 : : Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
9332 : : Py_TPFLAGS_BASETYPE, /* tp_flags */
9333 : : super_doc, /* tp_doc */
9334 : : super_traverse, /* tp_traverse */
9335 : : 0, /* tp_clear */
9336 : : 0, /* tp_richcompare */
9337 : : 0, /* tp_weaklistoffset */
9338 : : 0, /* tp_iter */
9339 : : 0, /* tp_iternext */
9340 : : 0, /* tp_methods */
9341 : : super_members, /* tp_members */
9342 : : 0, /* tp_getset */
9343 : : 0, /* tp_base */
9344 : : 0, /* tp_dict */
9345 : : super_descr_get, /* tp_descr_get */
9346 : : 0, /* tp_descr_set */
9347 : : 0, /* tp_dictoffset */
9348 : : super_init, /* tp_init */
9349 : : PyType_GenericAlloc, /* tp_alloc */
9350 : : PyType_GenericNew, /* tp_new */
9351 : : PyObject_GC_Del, /* tp_free */
9352 : : .tp_vectorcall = (vectorcallfunc)super_vectorcall,
9353 : : };
|
