python_packaging/src/external/pybind/include/pybind11/detail/class.h

   1 /*
   2     pybind11/detail/class.h: Python C API implementation details for py::class_
   3
   4     Copyright (c) 2017 Wenzel Jakob <wenzel.jakob@epfl.ch>
   5
   6     All rights reserved. Use of this source code is governed by a
   7     BSD-style license that can be found in the LICENSE file.
   8 */
   9
  10 #pragma once
  11
  12 #include "../attr.h"
  13 #include "../options.h"
  14
  15 NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
  16 NAMESPACE_BEGIN(detail)
  17
  18 #if PY_VERSION_HEX >= 0x03030000
  19 #  define PYBIND11_BUILTIN_QUALNAME
  20 #  define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj)
  21 #else
  22 // In pre-3.3 Python, we still set __qualname__ so that we can produce reliable function type
  23 // signatures; in 3.3+ this macro expands to nothing:
  24 #  define PYBIND11_SET_OLDPY_QUALNAME(obj, nameobj) setattr((PyObject *) obj, "__qualname__", nameobj)
  25 #endif
  26
  27 inline PyTypeObject *type_incref(PyTypeObject *type) {
  28     Py_INCREF(type);
  29     return type;
  30 }
  31
  32 #if !defined(PYPY_VERSION)
  33
  34 /// `pybind11_static_property.__get__()`: Always pass the class instead of the instance.
  35 extern "C" inline PyObject *pybind11_static_get(PyObject *self, PyObject * /*ob*/, PyObject *cls) {
  36     return PyProperty_Type.tp_descr_get(self, cls, cls);
  37 }
  38
  39 /// `pybind11_static_property.__set__()`: Just like the above `__get__()`.
  40 extern "C" inline int pybind11_static_set(PyObject *self, PyObject *obj, PyObject *value) {
  41     PyObject *cls = PyType_Check(obj) ? obj : (PyObject *) Py_TYPE(obj);
  42     return PyProperty_Type.tp_descr_set(self, cls, value);
  43 }
  44
  45 /** A `static_property` is the same as a `property` but the `__get__()` and `__set__()`
  46     methods are modified to always use the object type instead of a concrete instance.
  47     Return value: New reference. */
  48 inline PyTypeObject *make_static_property_type() {
  49     constexpr auto *name = "pybind11_static_property";
  50     auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
  51
  52     /* Danger zone: from now (and until PyType_Ready), make sure to
  53        issue no Python C API calls which could potentially invoke the
  54        garbage collector (the GC will call type_traverse(), which will in
  55        turn find the newly constructed type in an invalid state) */
  56     auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
  57     if (!heap_type)
  58         pybind11_fail("make_static_property_type(): error allocating type!");
  59
  60     heap_type->ht_name = name_obj.inc_ref().ptr();
  61 #ifdef PYBIND11_BUILTIN_QUALNAME
  62     heap_type->ht_qualname = name_obj.inc_ref().ptr();
  63 #endif
  64
  65     auto type = &heap_type->ht_type;
  66     type->tp_name = name;
  67     type->tp_base = type_incref(&PyProperty_Type);
  68     type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
  69     type->tp_descr_get = pybind11_static_get;
  70     type->tp_descr_set = pybind11_static_set;
  71
  72     if (PyType_Ready(type) < 0)
  73         pybind11_fail("make_static_property_type(): failure in PyType_Ready()!");
  74
  75     setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
  76     PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
  77
  78     return type;
  79 }
  80
  81 #else // PYPY
  82
  83 /** PyPy has some issues with the above C API, so we evaluate Python code instead.
  84     This function will only be called once so performance isn't really a concern.
  85     Return value: New reference. */
  86 inline PyTypeObject *make_static_property_type() {
  87     auto d = dict();
  88     PyObject *result = PyRun_String(R"(\
  89         class pybind11_static_property(property):
  90             def __get__(self, obj, cls):
  91                 return property.__get__(self, cls, cls)
  92
  93             def __set__(self, obj, value):
  94                 cls = obj if isinstance(obj, type) else type(obj)
  95                 property.__set__(self, cls, value)
  96         )", Py_file_input, d.ptr(), d.ptr()
  97     );
  98     if (result == nullptr)
  99         throw error_already_set();
 100     Py_DECREF(result);
 101     return (PyTypeObject *) d["pybind11_static_property"].cast<object>().release().ptr();
 102 }
 103
 104 #endif // PYPY
 105
 106 /** Types with static properties need to handle `Type.static_prop = x` in a specific way.
 107     By default, Python replaces the `static_property` itself, but for wrapped C++ types
 108     we need to call `static_property.__set__()` in order to propagate the new value to
 109     the underlying C++ data structure. */
 110 extern "C" inline int pybind11_meta_setattro(PyObject* obj, PyObject* name, PyObject* value) {
 111     // Use `_PyType_Lookup()` instead of `PyObject_GetAttr()` in order to get the raw
 112     // descriptor (`property`) instead of calling `tp_descr_get` (`property.__get__()`).
 113     PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name);
 114
 115     // The following assignment combinations are possible:
 116     //   1. `Type.static_prop = value`             --> descr_set: `Type.static_prop.__set__(value)`
 117     //   2. `Type.static_prop = other_static_prop` --> setattro:  replace existing `static_prop`
 118     //   3. `Type.regular_attribute = value`       --> setattro:  regular attribute assignment
 119     const auto static_prop = (PyObject *) get_internals().static_property_type;
 120     const auto call_descr_set = descr && PyObject_IsInstance(descr, static_prop)
 121                                 && !PyObject_IsInstance(value, static_prop);
 122     if (call_descr_set) {
 123         // Call `static_property.__set__()` instead of replacing the `static_property`.
 124 #if !defined(PYPY_VERSION)
 125         return Py_TYPE(descr)->tp_descr_set(descr, obj, value);
 126 #else
 127         if (PyObject *result = PyObject_CallMethod(descr, "__set__", "OO", obj, value)) {
 128             Py_DECREF(result);
 129             return 0;
 130         } else {
 131             return -1;
 132         }
 133 #endif
 134     } else {
 135         // Replace existing attribute.
 136         return PyType_Type.tp_setattro(obj, name, value);
 137     }
 138 }
 139
 140 #if PY_MAJOR_VERSION >= 3
 141 /**
 142  * Python 3's PyInstanceMethod_Type hides itself via its tp_descr_get, which prevents aliasing
 143  * methods via cls.attr("m2") = cls.attr("m1"): instead the tp_descr_get returns a plain function,
 144  * when called on a class, or a PyMethod, when called on an instance.  Override that behaviour here
 145  * to do a special case bypass for PyInstanceMethod_Types.
 146  */
 147 extern "C" inline PyObject *pybind11_meta_getattro(PyObject *obj, PyObject *name) {
 148     PyObject *descr = _PyType_Lookup((PyTypeObject *) obj, name);
 149     if (descr && PyInstanceMethod_Check(descr)) {
 150         Py_INCREF(descr);
 151         return descr;
 152     }
 153     else {
 154         return PyType_Type.tp_getattro(obj, name);
 155     }
 156 }
 157 #endif
 158
 159 /** This metaclass is assigned by default to all pybind11 types and is required in order
 160     for static properties to function correctly. Users may override this using `py::metaclass`.
 161     Return value: New reference. */
 162 inline PyTypeObject* make_default_metaclass() {
 163     constexpr auto *name = "pybind11_type";
 164     auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
 165
 166     /* Danger zone: from now (and until PyType_Ready), make sure to
 167        issue no Python C API calls which could potentially invoke the
 168        garbage collector (the GC will call type_traverse(), which will in
 169        turn find the newly constructed type in an invalid state) */
 170     auto heap_type = (PyHeapTypeObject *) PyType_Type.tp_alloc(&PyType_Type, 0);
 171     if (!heap_type)
 172         pybind11_fail("make_default_metaclass(): error allocating metaclass!");
 173
 174     heap_type->ht_name = name_obj.inc_ref().ptr();
 175 #ifdef PYBIND11_BUILTIN_QUALNAME
 176     heap_type->ht_qualname = name_obj.inc_ref().ptr();
 177 #endif
 178
 179     auto type = &heap_type->ht_type;
 180     type->tp_name = name;
 181     type->tp_base = type_incref(&PyType_Type);
 182     type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
 183
 184     type->tp_setattro = pybind11_meta_setattro;
 185 #if PY_MAJOR_VERSION >= 3
 186     type->tp_getattro = pybind11_meta_getattro;
 187 #endif
 188
 189     if (PyType_Ready(type) < 0)
 190         pybind11_fail("make_default_metaclass(): failure in PyType_Ready()!");
 191
 192     setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
 193     PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
 194
 195     return type;
 196 }
 197
 198 /// For multiple inheritance types we need to recursively register/deregister base pointers for any
 199 /// base classes with pointers that are difference from the instance value pointer so that we can
 200 /// correctly recognize an offset base class pointer. This calls a function with any offset base ptrs.
 201 inline void traverse_offset_bases(void *valueptr, const detail::type_info *tinfo, instance *self,
 202         bool (*f)(void * /*parentptr*/, instance * /*self*/)) {
 203     for (handle h : reinterpret_borrow<tuple>(tinfo->type->tp_bases)) {
 204         if (auto parent_tinfo = get_type_info((PyTypeObject *) h.ptr())) {
 205             for (auto &c : parent_tinfo->implicit_casts) {
 206                 if (c.first == tinfo->cpptype) {
 207                     auto *parentptr = c.second(valueptr);
 208                     if (parentptr != valueptr)
 209                         f(parentptr, self);
 210                     traverse_offset_bases(parentptr, parent_tinfo, self, f);
 211                     break;
 212                 }
 213             }
 214         }
 215     }
 216 }
 217
 218 inline bool register_instance_impl(void *ptr, instance *self) {
 219     get_internals().registered_instances.emplace(ptr, self);
 220     return true; // unused, but gives the same signature as the deregister func
 221 }
 222 inline bool deregister_instance_impl(void *ptr, instance *self) {
 223     auto &registered_instances = get_internals().registered_instances;
 224     auto range = registered_instances.equal_range(ptr);
 225     for (auto it = range.first; it != range.second; ++it) {
 226         if (Py_TYPE(self) == Py_TYPE(it->second)) {
 227             registered_instances.erase(it);
 228             return true;
 229         }
 230     }
 231     return false;
 232 }
 233
 234 inline void register_instance(instance *self, void *valptr, const type_info *tinfo) {
 235     register_instance_impl(valptr, self);
 236     if (!tinfo->simple_ancestors)
 237         traverse_offset_bases(valptr, tinfo, self, register_instance_impl);
 238 }
 239
 240 inline bool deregister_instance(instance *self, void *valptr, const type_info *tinfo) {
 241     bool ret = deregister_instance_impl(valptr, self);
 242     if (!tinfo->simple_ancestors)
 243         traverse_offset_bases(valptr, tinfo, self, deregister_instance_impl);
 244     return ret;
 245 }
 246
 247 /// Instance creation function for all pybind11 types. It allocates the internal instance layout for
 248 /// holding C++ objects and holders.  Allocation is done lazily (the first time the instance is cast
 249 /// to a reference or pointer), and initialization is done by an `__init__` function.
 250 inline PyObject *make_new_instance(PyTypeObject *type) {
 251 #if defined(PYPY_VERSION)
 252     // PyPy gets tp_basicsize wrong (issue 2482) under multiple inheritance when the first inherited
 253     // object is a a plain Python type (i.e. not derived from an extension type).  Fix it.
 254     ssize_t instance_size = static_cast<ssize_t>(sizeof(instance));
 255     if (type->tp_basicsize < instance_size) {
 256         type->tp_basicsize = instance_size;
 257     }
 258 #endif
 259     PyObject *self = type->tp_alloc(type, 0);
 260     auto inst = reinterpret_cast<instance *>(self);
 261     // Allocate the value/holder internals:
 262     inst->allocate_layout();
 263
 264     inst->owned = true;
 265
 266     return self;
 267 }
 268
 269 /// Instance creation function for all pybind11 types. It only allocates space for the
 270 /// C++ object, but doesn't call the constructor -- an `__init__` function must do that.
 271 extern "C" inline PyObject *pybind11_object_new(PyTypeObject *type, PyObject *, PyObject *) {
 272     return make_new_instance(type);
 273 }
 274
 275 /// An `__init__` function constructs the C++ object. Users should provide at least one
 276 /// of these using `py::init` or directly with `.def(__init__, ...)`. Otherwise, the
 277 /// following default function will be used which simply throws an exception.
 278 extern "C" inline int pybind11_object_init(PyObject *self, PyObject *, PyObject *) {
 279     PyTypeObject *type = Py_TYPE(self);
 280     std::string msg;
 281 #if defined(PYPY_VERSION)
 282     msg += handle((PyObject *) type).attr("__module__").cast<std::string>() + ".";
 283 #endif
 284     msg += type->tp_name;
 285     msg += ": No constructor defined!";
 286     PyErr_SetString(PyExc_TypeError, msg.c_str());
 287     return -1;
 288 }
 289
 290 inline void add_patient(PyObject *nurse, PyObject *patient) {
 291     auto &internals = get_internals();
 292     auto instance = reinterpret_cast<detail::instance *>(nurse);
 293     instance->has_patients = true;
 294     Py_INCREF(patient);
 295     internals.patients[nurse].push_back(patient);
 296 }
 297
 298 inline void clear_patients(PyObject *self) {
 299     auto instance = reinterpret_cast<detail::instance *>(self);
 300     auto &internals = get_internals();
 301     auto pos = internals.patients.find(self);
 302     assert(pos != internals.patients.end());
 303     // Clearing the patients can cause more Python code to run, which
 304     // can invalidate the iterator. Extract the vector of patients
 305     // from the unordered_map first.
 306     auto patients = std::move(pos->second);
 307     internals.patients.erase(pos);
 308     instance->has_patients = false;
 309     for (PyObject *&patient : patients)
 310         Py_CLEAR(patient);
 311 }
 312
 313 /// Clears all internal data from the instance and removes it from registered instances in
 314 /// preparation for deallocation.
 315 inline void clear_instance(PyObject *self) {
 316     auto instance = reinterpret_cast<detail::instance *>(self);
 317
 318     // Deallocate any values/holders, if present:
 319     for (auto &v_h : values_and_holders(instance)) {
 320         if (v_h) {
 321
 322             // We have to deregister before we call dealloc because, for virtual MI types, we still
 323             // need to be able to get the parent pointers.
 324             if (v_h.instance_registered() && !deregister_instance(instance, v_h.value_ptr(), v_h.type))
 325                 pybind11_fail("pybind11_object_dealloc(): Tried to deallocate unregistered instance!");
 326
 327             if (instance->owned || v_h.holder_constructed())
 328                 v_h.type->dealloc(v_h);
 329         }
 330     }
 331     // Deallocate the value/holder layout internals:
 332     instance->deallocate_layout();
 333
 334     if (instance->weakrefs)
 335         PyObject_ClearWeakRefs(self);
 336
 337     PyObject **dict_ptr = _PyObject_GetDictPtr(self);
 338     if (dict_ptr)
 339         Py_CLEAR(*dict_ptr);
 340
 341     if (instance->has_patients)
 342         clear_patients(self);
 343 }
 344
 345 /// Instance destructor function for all pybind11 types. It calls `type_info.dealloc`
 346 /// to destroy the C++ object itself, while the rest is Python bookkeeping.
 347 extern "C" inline void pybind11_object_dealloc(PyObject *self) {
 348     clear_instance(self);
 349
 350     auto type = Py_TYPE(self);
 351     type->tp_free(self);
 352
 353 #if PY_VERSION_HEX < 0x03080000
 354     // `type->tp_dealloc != pybind11_object_dealloc` means that we're being called
 355     // as part of a derived type's dealloc, in which case we're not allowed to decref
 356     // the type here. For cross-module compatibility, we shouldn't compare directly
 357     // with `pybind11_object_dealloc`, but with the common one stashed in internals.
 358     auto pybind11_object_type = (PyTypeObject *) get_internals().instance_base;
 359     if (type->tp_dealloc == pybind11_object_type->tp_dealloc)
 360         Py_DECREF(type);
 361 #else
 362     // This was not needed before Python 3.8 (Python issue 35810)
 363     // https://github.com/pybind/pybind11/issues/1946
 364     Py_DECREF(type);
 365 #endif
 366 }
 367
 368 /** Create the type which can be used as a common base for all classes.  This is
 369     needed in order to satisfy Python's requirements for multiple inheritance.
 370     Return value: New reference. */
 371 inline PyObject *make_object_base_type(PyTypeObject *metaclass) {
 372     constexpr auto *name = "pybind11_object";
 373     auto name_obj = reinterpret_steal<object>(PYBIND11_FROM_STRING(name));
 374
 375     /* Danger zone: from now (and until PyType_Ready), make sure to
 376        issue no Python C API calls which could potentially invoke the
 377        garbage collector (the GC will call type_traverse(), which will in
 378        turn find the newly constructed type in an invalid state) */
 379     auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
 380     if (!heap_type)
 381         pybind11_fail("make_object_base_type(): error allocating type!");
 382
 383     heap_type->ht_name = name_obj.inc_ref().ptr();
 384 #ifdef PYBIND11_BUILTIN_QUALNAME
 385     heap_type->ht_qualname = name_obj.inc_ref().ptr();
 386 #endif
 387
 388     auto type = &heap_type->ht_type;
 389     type->tp_name = name;
 390     type->tp_base = type_incref(&PyBaseObject_Type);
 391     type->tp_basicsize = static_cast<ssize_t>(sizeof(instance));
 392     type->tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
 393
 394     type->tp_new = pybind11_object_new;
 395     type->tp_init = pybind11_object_init;
 396     type->tp_dealloc = pybind11_object_dealloc;
 397
 398     /* Support weak references (needed for the keep_alive feature) */
 399     type->tp_weaklistoffset = offsetof(instance, weakrefs);
 400
 401     if (PyType_Ready(type) < 0)
 402         pybind11_fail("PyType_Ready failed in make_object_base_type():" + error_string());
 403
 404     setattr((PyObject *) type, "__module__", str("pybind11_builtins"));
 405     PYBIND11_SET_OLDPY_QUALNAME(type, name_obj);
 406
 407     assert(!PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
 408     return (PyObject *) heap_type;
 409 }
 410
 411 /// dynamic_attr: Support for `d = instance.__dict__`.
 412 extern "C" inline PyObject *pybind11_get_dict(PyObject *self, void *) {
 413     PyObject *&dict = *_PyObject_GetDictPtr(self);
 414     if (!dict)
 415         dict = PyDict_New();
 416     Py_XINCREF(dict);
 417     return dict;
 418 }
 419
 420 /// dynamic_attr: Support for `instance.__dict__ = dict()`.
 421 extern "C" inline int pybind11_set_dict(PyObject *self, PyObject *new_dict, void *) {
 422     if (!PyDict_Check(new_dict)) {
 423         PyErr_Format(PyExc_TypeError, "__dict__ must be set to a dictionary, not a '%.200s'",
 424                      Py_TYPE(new_dict)->tp_name);
 425         return -1;
 426     }
 427     PyObject *&dict = *_PyObject_GetDictPtr(self);
 428     Py_INCREF(new_dict);
 429     Py_CLEAR(dict);
 430     dict = new_dict;
 431     return 0;
 432 }
 433
 434 /// dynamic_attr: Allow the garbage collector to traverse the internal instance `__dict__`.
 435 extern "C" inline int pybind11_traverse(PyObject *self, visitproc visit, void *arg) {
 436     PyObject *&dict = *_PyObject_GetDictPtr(self);
 437     Py_VISIT(dict);
 438     return 0;
 439 }
 440
 441 /// dynamic_attr: Allow the GC to clear the dictionary.
 442 extern "C" inline int pybind11_clear(PyObject *self) {
 443     PyObject *&dict = *_PyObject_GetDictPtr(self);
 444     Py_CLEAR(dict);
 445     return 0;
 446 }
 447
 448 /// Give instances of this type a `__dict__` and opt into garbage collection.
 449 inline void enable_dynamic_attributes(PyHeapTypeObject *heap_type) {
 450     auto type = &heap_type->ht_type;
 451 #if defined(PYPY_VERSION)
 452     pybind11_fail(std::string(type->tp_name) + ": dynamic attributes are "
 453                                                "currently not supported in "
 454                                                "conjunction with PyPy!");
 455 #endif
 456     type->tp_flags |= Py_TPFLAGS_HAVE_GC;
 457     type->tp_dictoffset = type->tp_basicsize; // place dict at the end
 458     type->tp_basicsize += (ssize_t)sizeof(PyObject *); // and allocate enough space for it
 459     type->tp_traverse = pybind11_traverse;
 460     type->tp_clear = pybind11_clear;
 461
 462     static PyGetSetDef getset[] = {
 463         {const_cast<char*>("__dict__"), pybind11_get_dict, pybind11_set_dict, nullptr, nullptr},
 464         {nullptr, nullptr, nullptr, nullptr, nullptr}
 465     };
 466     type->tp_getset = getset;
 467 }
 468
 469 /// buffer_protocol: Fill in the view as specified by flags.
 470 extern "C" inline int pybind11_getbuffer(PyObject *obj, Py_buffer *view, int flags) {
 471     // Look for a `get_buffer` implementation in this type's info or any bases (following MRO).
 472     type_info *tinfo = nullptr;
 473     for (auto type : reinterpret_borrow<tuple>(Py_TYPE(obj)->tp_mro)) {
 474         tinfo = get_type_info((PyTypeObject *) type.ptr());
 475         if (tinfo && tinfo->get_buffer)
 476             break;
 477     }
 478     if (view == nullptr || !tinfo || !tinfo->get_buffer) {
 479         if (view)
 480             view->obj = nullptr;
 481         PyErr_SetString(PyExc_BufferError, "pybind11_getbuffer(): Internal error");
 482         return -1;
 483     }
 484     std::memset(view, 0, sizeof(Py_buffer));
 485     buffer_info *info = tinfo->get_buffer(obj, tinfo->get_buffer_data);
 486     view->obj = obj;
 487     view->ndim = 1;
 488     view->internal = info;
 489     view->buf = info->ptr;
 490     view->itemsize = info->itemsize;
 491     view->len = view->itemsize;
 492     for (auto s : info->shape)
 493         view->len *= s;
 494     view->readonly = info->readonly;
 495     if ((flags & PyBUF_WRITABLE) == PyBUF_WRITABLE && info->readonly) {
 496         if (view)
 497             view->obj = nullptr;
 498         PyErr_SetString(PyExc_BufferError, "Writable buffer requested for readonly storage");
 499         return -1;
 500     }
 501     if ((flags & PyBUF_FORMAT) == PyBUF_FORMAT)
 502         view->format = const_cast<char *>(info->format.c_str());
 503     if ((flags & PyBUF_STRIDES) == PyBUF_STRIDES) {
 504         view->ndim = (int) info->ndim;
 505         view->strides = &info->strides[0];
 506         view->shape = &info->shape[0];
 507     }
 508     Py_INCREF(view->obj);
 509     return 0;
 510 }
 511
 512 /// buffer_protocol: Release the resources of the buffer.
 513 extern "C" inline void pybind11_releasebuffer(PyObject *, Py_buffer *view) {
 514     delete (buffer_info *) view->internal;
 515 }
 516
 517 /// Give this type a buffer interface.
 518 inline void enable_buffer_protocol(PyHeapTypeObject *heap_type) {
 519     heap_type->ht_type.tp_as_buffer = &heap_type->as_buffer;
 520 #if PY_MAJOR_VERSION < 3
 521     heap_type->ht_type.tp_flags |= Py_TPFLAGS_HAVE_NEWBUFFER;
 522 #endif
 523
 524     heap_type->as_buffer.bf_getbuffer = pybind11_getbuffer;
 525     heap_type->as_buffer.bf_releasebuffer = pybind11_releasebuffer;
 526 }
 527
 528 /** Create a brand new Python type according to the `type_record` specification.
 529     Return value: New reference. */
 530 inline PyObject* make_new_python_type(const type_record &rec) {
 531     auto name = reinterpret_steal<object>(PYBIND11_FROM_STRING(rec.name));
 532
 533     auto qualname = name;
 534     if (rec.scope && !PyModule_Check(rec.scope.ptr()) && hasattr(rec.scope, "__qualname__")) {
 535 #if PY_MAJOR_VERSION >= 3
 536         qualname = reinterpret_steal<object>(
 537             PyUnicode_FromFormat("%U.%U", rec.scope.attr("__qualname__").ptr(), name.ptr()));
 538 #else
 539         qualname = str(rec.scope.attr("__qualname__").cast<std::string>() + "." + rec.name);
 540 #endif
 541     }
 542
 543     object module;
 544     if (rec.scope) {
 545         if (hasattr(rec.scope, "__module__"))
 546             module = rec.scope.attr("__module__");
 547         else if (hasattr(rec.scope, "__name__"))
 548             module = rec.scope.attr("__name__");
 549     }
 550
 551     auto full_name = c_str(
 552 #if !defined(PYPY_VERSION)
 553         module ? str(module).cast<std::string>() + "." + rec.name :
 554 #endif
 555         rec.name);
 556
 557     char *tp_doc = nullptr;
 558     if (rec.doc && options::show_user_defined_docstrings()) {
 559         /* Allocate memory for docstring (using PyObject_MALLOC, since
 560            Python will free this later on) */
 561         size_t size = strlen(rec.doc) + 1;
 562         tp_doc = (char *) PyObject_MALLOC(size);
 563         memcpy((void *) tp_doc, rec.doc, size);
 564     }
 565
 566     auto &internals = get_internals();
 567     auto bases = tuple(rec.bases);
 568     auto base = (bases.size() == 0) ? internals.instance_base
 569                                     : bases[0].ptr();
 570
 571     /* Danger zone: from now (and until PyType_Ready), make sure to
 572        issue no Python C API calls which could potentially invoke the
 573        garbage collector (the GC will call type_traverse(), which will in
 574        turn find the newly constructed type in an invalid state) */
 575     auto metaclass = rec.metaclass.ptr() ? (PyTypeObject *) rec.metaclass.ptr()
 576                                          : internals.default_metaclass;
 577
 578     auto heap_type = (PyHeapTypeObject *) metaclass->tp_alloc(metaclass, 0);
 579     if (!heap_type)
 580         pybind11_fail(std::string(rec.name) + ": Unable to create type object!");
 581
 582     heap_type->ht_name = name.release().ptr();
 583 #ifdef PYBIND11_BUILTIN_QUALNAME
 584     heap_type->ht_qualname = qualname.inc_ref().ptr();
 585 #endif
 586
 587     auto type = &heap_type->ht_type;
 588     type->tp_name = full_name;
 589     type->tp_doc = tp_doc;
 590     type->tp_base = type_incref((PyTypeObject *)base);
 591     type->tp_basicsize = static_cast<ssize_t>(sizeof(instance));
 592     if (bases.size() > 0)
 593         type->tp_bases = bases.release().ptr();
 594
 595     /* Don't inherit base __init__ */
 596     type->tp_init = pybind11_object_init;
 597
 598     /* Supported protocols */
 599     type->tp_as_number = &heap_type->as_number;
 600     type->tp_as_sequence = &heap_type->as_sequence;
 601     type->tp_as_mapping = &heap_type->as_mapping;
 602 #if PY_VERSION_HEX >= 0x03050000
 603     type->tp_as_async = &heap_type->as_async;
 604 #endif
 605
 606     /* Flags */
 607     type->tp_flags |= Py_TPFLAGS_DEFAULT | Py_TPFLAGS_BASETYPE | Py_TPFLAGS_HEAPTYPE;
 608 #if PY_MAJOR_VERSION < 3
 609     type->tp_flags |= Py_TPFLAGS_CHECKTYPES;
 610 #endif
 611
 612     if (rec.dynamic_attr)
 613         enable_dynamic_attributes(heap_type);
 614
 615     if (rec.buffer_protocol)
 616         enable_buffer_protocol(heap_type);
 617
 618     if (PyType_Ready(type) < 0)
 619         pybind11_fail(std::string(rec.name) + ": PyType_Ready failed (" + error_string() + ")!");
 620
 621     assert(rec.dynamic_attr ? PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC)
 622                             : !PyType_HasFeature(type, Py_TPFLAGS_HAVE_GC));
 623
 624     /* Register type with the parent scope */
 625     if (rec.scope)
 626         setattr(rec.scope, rec.name, (PyObject *) type);
 627     else
 628         Py_INCREF(type); // Keep it alive forever (reference leak)
 629
 630     if (module) // Needed by pydoc
 631         setattr((PyObject *) type, "__module__", module);
 632
 633     PYBIND11_SET_OLDPY_QUALNAME(type, qualname);
 634
 635     return (PyObject *) type;
 636 }
 637
 638 NAMESPACE_END(detail)
 639 NAMESPACE_END(PYBIND11_NAMESPACE)