Rename Py_TPFLAGS_INLINE_VALUES as _Py_TPFLAGS_INLINE_VALUES as it should not be used by third-party code.

markshannon · markshannon · commit f475d9df99cd · 2025-01-08T14:03:58.000Z
diff --git a/Include/internal/pycore_object.h b/Include/internal/pycore_object.h
@@ -944,7 +944,7 @@ _PyObject_InlineValues(PyObject *obj)
 {
     PyTypeObject *tp = Py_TYPE(obj);
     assert(tp->tp_basicsize > 0 && (size_t)tp->tp_basicsize % sizeof(PyObject *) == 0);
-    assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES);
+    assert(Py_TYPE(obj)->tp_flags & _Py_TPFLAGS_INLINE_VALUES);
     assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT);
     return (PyDictValues *)((char *)obj + tp->tp_basicsize);
 }
diff --git a/Include/object.h b/Include/object.h
@@ -513,7 +513,7 @@ given type object has a specified feature.
 /* The values array is placed inline directly after the rest of
  * the object. Implies Py_TPFLAGS_HAVE_GC.
  */
-#define Py_TPFLAGS_INLINE_VALUES (1 << 2)
+#define _Py_TPFLAGS_INLINE_VALUES (1 << 2)
 
 /* Placement of weakref pointers are managed by the VM, not by the type.
  * The VM will automatically set tp_weaklistoffset.
diff --git a/Modules/_testinternalcapi.c b/Modules/_testinternalcapi.c
@@ -1322,7 +1322,7 @@ static PyObject *
 get_object_dict_values(PyObject *self, PyObject *obj)
 {
     PyTypeObject *type = Py_TYPE(obj);
-    if (!_PyType_HasFeature(type, Py_TPFLAGS_INLINE_VALUES)) {
+    if (!_PyType_HasFeature(type, _Py_TPFLAGS_INLINE_VALUES)) {
         Py_RETURN_NONE;
     }
     PyDictValues *values = _PyObject_InlineValues(obj);
@@ -1982,7 +1982,7 @@ get_tlbc_id(PyObject *Py_UNUSED(module), PyObject *obj)
 static PyObject *
 has_inline_values(PyObject *self, PyObject *obj)
 {
-    if ((Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&
+    if ((Py_TYPE(obj)->tp_flags & _Py_TPFLAGS_INLINE_VALUES) &&
         _PyObject_InlineValues(obj)->valid) {
         Py_RETURN_TRUE;
     }
diff --git a/Objects/dictobject.c b/Objects/dictobject.c
@@ -6677,7 +6677,7 @@ void
 _PyObject_InitInlineValues(PyObject *obj, PyTypeObject *tp)
 {
     assert(tp->tp_flags & Py_TPFLAGS_HEAPTYPE);
-    assert(tp->tp_flags & Py_TPFLAGS_INLINE_VALUES);
+    assert(tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES);
     assert(tp->tp_flags & Py_TPFLAGS_MANAGED_DICT);
     PyDictKeysObject *keys = CACHED_KEYS(tp);
     assert(keys != NULL);
@@ -6798,7 +6798,7 @@ store_instance_attr_lock_held(PyObject *obj, PyDictValues *values,
     PyDictKeysObject *keys = CACHED_KEYS(Py_TYPE(obj));
     assert(keys != NULL);
     assert(values != NULL);
-    assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES);
+    assert(Py_TYPE(obj)->tp_flags & _Py_TPFLAGS_INLINE_VALUES);
     Py_ssize_t ix = DKIX_EMPTY;
     PyDictObject *dict = _PyObject_GetManagedDict(obj);
     assert(dict == NULL || ((PyDictObject *)dict)->ma_values == values);
@@ -7069,7 +7069,7 @@ _PyObject_IsInstanceDictEmpty(PyObject *obj)
         return 1;
     }
     PyDictObject *dict;
-    if (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         PyDictValues *values = _PyObject_InlineValues(obj);
         if (FT_ATOMIC_LOAD_UINT8(values->valid)) {
             PyDictKeysObject *keys = CACHED_KEYS(tp);
@@ -7102,7 +7102,7 @@ PyObject_VisitManagedDict(PyObject *obj, visitproc visit, void *arg)
     if((tp->tp_flags & Py_TPFLAGS_MANAGED_DICT) == 0) {
         return 0;
     }
-    if (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         PyDictValues *values = _PyObject_InlineValues(obj);
         if (values->valid) {
             for (Py_ssize_t i = 0; i < values->capacity; i++) {
@@ -7219,7 +7219,7 @@ set_or_clear_managed_dict(PyObject *obj, PyObject *new_dict, bool clear)
 #endif
     int err = 0;
     PyTypeObject *tp = Py_TYPE(obj);
-    if (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
 #ifdef Py_GIL_DISABLED
         PyDictObject *prev_dict;
         if (!try_set_dict_inline_only_or_other_dict(obj, new_dict, &prev_dict)) {
@@ -7335,7 +7335,7 @@ _PyDict_DetachFromObject(PyDictObject *mp, PyObject *obj)
     ASSERT_WORLD_STOPPED_OR_OBJ_LOCKED(mp);
     assert(mp->ma_values->embedded == 1);
     assert(mp->ma_values->valid == 1);
-    assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES);
+    assert(Py_TYPE(obj)->tp_flags & _Py_TPFLAGS_INLINE_VALUES);
 
     PyDictValues *values = copy_values(mp->ma_values);
 
@@ -7358,7 +7358,7 @@ ensure_managed_dict(PyObject *obj)
     PyDictObject *dict = _PyObject_GetManagedDict(obj);
     if (dict == NULL) {
         PyTypeObject *tp = Py_TYPE(obj);
-        if ((tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&
+        if ((tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) &&
             FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(obj)->valid)) {
             dict = _PyObject_MaterializeManagedDict(obj);
         }
@@ -7402,7 +7402,7 @@ ensure_nonmanaged_dict(PyObject *obj, PyObject **dictptr)
         PyTypeObject *tp = Py_TYPE(obj);
         if (_PyType_HasFeature(tp, Py_TPFLAGS_HEAPTYPE) && (cached = CACHED_KEYS(tp))) {
             PyInterpreterState *interp = _PyInterpreterState_GET();
-            assert(!_PyType_HasFeature(tp, Py_TPFLAGS_INLINE_VALUES));
+            assert(!_PyType_HasFeature(tp, _Py_TPFLAGS_INLINE_VALUES));
             dict = new_dict_with_shared_keys(interp, cached);
         }
         else {
@@ -7624,7 +7624,7 @@ _PyDict_SendEvent(int watcher_bits,
 static int
 _PyObject_InlineValuesConsistencyCheck(PyObject *obj)
 {
-    if ((Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES) == 0) {
+    if ((Py_TYPE(obj)->tp_flags & _Py_TPFLAGS_INLINE_VALUES) == 0) {
         return 1;
     }
     assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT);
diff --git a/Objects/object.c b/Objects/object.c
@@ -1518,7 +1518,7 @@ _PyObject_GetDictPtr(PyObject *obj)
         return _PyObject_ComputedDictPointer(obj);
     }
     PyDictObject *dict = _PyObject_GetManagedDict(obj);
-    if (dict == NULL && Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (dict == NULL && Py_TYPE(obj)->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         dict = _PyObject_MaterializeManagedDict(obj);
         if (dict == NULL) {
             PyErr_Clear();
@@ -1594,7 +1594,7 @@ _PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method)
         }
     }
     PyObject *dict, *attr;
-    if ((tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&
+    if ((tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) &&
          _PyObject_TryGetInstanceAttribute(obj, name, &attr)) {
         if (attr != NULL) {
             *method = attr;
@@ -1696,7 +1696,7 @@ _PyObject_GenericGetAttrWithDict(PyObject *obj, PyObject *name,
         }
     }
     if (dict == NULL) {
-        if ((tp->tp_flags & Py_TPFLAGS_INLINE_VALUES)) {
+        if ((tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES)) {
             if (PyUnicode_CheckExact(name) &&
                 _PyObject_TryGetInstanceAttribute(obj, name, &res)) {
                 if (res != NULL) {
@@ -1812,7 +1812,7 @@ _PyObject_GenericSetAttrWithDict(PyObject *obj, PyObject *name,
     if (dict == NULL) {
         PyObject **dictptr;
 
-        if ((tp->tp_flags & Py_TPFLAGS_INLINE_VALUES)) {
+        if ((tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES)) {
             res = _PyObject_StoreInstanceAttribute(obj, name, value);
             goto error_check;
         }
@@ -1883,7 +1883,7 @@ PyObject_GenericSetDict(PyObject *obj, PyObject *value, void *context)
 {
     PyObject **dictptr = _PyObject_GetDictPtr(obj);
     if (dictptr == NULL) {
-        if (_PyType_HasFeature(Py_TYPE(obj), Py_TPFLAGS_INLINE_VALUES) &&
+        if (_PyType_HasFeature(Py_TYPE(obj), _Py_TPFLAGS_INLINE_VALUES) &&
             _PyObject_GetManagedDict(obj) == NULL
         ) {
             /* Was unable to convert to dict */
diff --git a/Objects/typeobject.c b/Objects/typeobject.c
@@ -2197,7 +2197,7 @@ type_call(PyObject *self, PyObject *args, PyObject *kwds)
 PyObject *
 _PyType_NewManagedObject(PyTypeObject *type)
 {
-    assert(type->tp_flags & Py_TPFLAGS_INLINE_VALUES);
+    assert(type->tp_flags & _Py_TPFLAGS_INLINE_VALUES);
     assert(_PyType_IS_GC(type));
     assert(type->tp_new == PyBaseObject_Type.tp_new);
     assert(type->tp_alloc == PyType_GenericAlloc);
@@ -2222,7 +2222,7 @@ _PyType_AllocNoTrack(PyTypeObject *type, Py_ssize_t nitems)
     size_t size = _PyObject_VAR_SIZE(type, nitems+1);
 
     const size_t presize = _PyType_PreHeaderSize(type);
-    if (type->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (type->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         assert(type->tp_itemsize == 0);
         size += _PyInlineValuesSize(type);
     }
@@ -2246,7 +2246,7 @@ _PyType_AllocNoTrack(PyTypeObject *type, Py_ssize_t nitems)
     else {
         _PyObject_InitVar((PyVarObject *)obj, type, nitems);
     }
-    if (type->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (type->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         _PyObject_InitInlineValues(obj, type);
     }
     return obj;
@@ -2399,8 +2399,8 @@ subtype_clear(PyObject *self)
             PyObject_ClearManagedDict(self);
         }
         else {
-            assert((base->tp_flags & Py_TPFLAGS_INLINE_VALUES) ==
-                   (type->tp_flags & Py_TPFLAGS_INLINE_VALUES));
+            assert((base->tp_flags & _Py_TPFLAGS_INLINE_VALUES) ==
+                   (type->tp_flags & _Py_TPFLAGS_INLINE_VALUES));
         }
     }
     else if (type->tp_dictoffset != base->tp_dictoffset) {
@@ -5953,7 +5953,7 @@ type_setattro(PyObject *self, PyObject *name, PyObject *value)
     }
 
     PyTypeObject *metatype = Py_TYPE(type);
-    assert(!_PyType_HasFeature(metatype, Py_TPFLAGS_INLINE_VALUES));
+    assert(!_PyType_HasFeature(metatype, _Py_TPFLAGS_INLINE_VALUES));
     assert(!_PyType_HasFeature(metatype, Py_TPFLAGS_MANAGED_DICT));
 
     PyObject *old_value = NULL;
@@ -6769,8 +6769,8 @@ compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, const char*
          !same_slots_added(newbase, oldbase))) {
         goto differs;
     }
-    if ((oldto->tp_flags & Py_TPFLAGS_INLINE_VALUES) !=
-        ((newto->tp_flags & Py_TPFLAGS_INLINE_VALUES)))
+    if ((oldto->tp_flags & _Py_TPFLAGS_INLINE_VALUES) !=
+        ((newto->tp_flags & _Py_TPFLAGS_INLINE_VALUES)))
     {
         goto differs;
     }
@@ -6859,7 +6859,7 @@ object_set_class_world_stopped(PyObject *self, PyTypeObject *newto)
     if (compatible_for_assignment(oldto, newto, "__class__")) {
         /* Changing the class will change the implicit dict keys,
          * so we must materialize the dictionary first. */
-        if (oldto->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+        if (oldto->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
             PyDictObject *dict = _PyObject_GetManagedDict(self);
             if (dict == NULL) {
                 dict = _PyObject_MaterializeManagedDict_LockHeld(self);
@@ -8543,7 +8543,7 @@ type_ready_managed_dict(PyTypeObject *type)
         }
     }
     if (type->tp_itemsize == 0) {
-        type->tp_flags |= Py_TPFLAGS_INLINE_VALUES;
+        type->tp_flags |= _Py_TPFLAGS_INLINE_VALUES;
     }
     return 0;
 }
diff --git a/Python/bytecodes.c b/Python/bytecodes.c
@@ -2162,7 +2162,7 @@ dummy_func(
         op(_CHECK_MANAGED_OBJECT_HAS_VALUES, (owner -- owner)) {
             PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
             assert(Py_TYPE(owner_o)->tp_dictoffset < 0);
-            assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES);
+            assert(Py_TYPE(owner_o)->tp_flags & _Py_TPFLAGS_INLINE_VALUES);
             DEOPT_IF(!_PyObject_InlineValues(owner_o)->valid);
         }
 
@@ -2362,7 +2362,7 @@ dummy_func(
             PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
 
             assert(Py_TYPE(owner_o)->tp_dictoffset < 0);
-            assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES);
+            assert(Py_TYPE(owner_o)->tp_flags & _Py_TPFLAGS_INLINE_VALUES);
             if (_PyObject_GetManagedDict(owner_o) ||
                     !FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner_o)->valid)) {
                 UNLOCK_OBJECT(owner_o);
@@ -3254,7 +3254,7 @@ dummy_func(
 
         op(_GUARD_DORV_VALUES_INST_ATTR_FROM_DICT, (owner -- owner)) {
             PyObject *owner_o = PyStackRef_AsPyObjectBorrow(owner);
-            assert(Py_TYPE(owner_o)->tp_flags & Py_TPFLAGS_INLINE_VALUES);
+            assert(Py_TYPE(owner_o)->tp_flags & _Py_TPFLAGS_INLINE_VALUES);
             DEOPT_IF(!_PyObject_InlineValues(owner_o)->valid);
         }
 
diff --git a/Python/executor_cases.c.h b/Python/executor_cases.c.h
diff --git a/Python/gc.c b/Python/gc.c
@@ -2269,15 +2269,15 @@ _PyObject_GC_New(PyTypeObject *tp)
 {
     size_t presize = _PyType_PreHeaderSize(tp);
     size_t size = _PyObject_SIZE(tp);
-    if (_PyType_HasFeature(tp, Py_TPFLAGS_INLINE_VALUES)) {
+    if (_PyType_HasFeature(tp, _Py_TPFLAGS_INLINE_VALUES)) {
         size += _PyInlineValuesSize(tp);
     }
     PyObject *op = gc_alloc(tp, size, presize);
     if (op == NULL) {
         return NULL;
     }
     _PyObject_Init(op, tp);
-    if (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         _PyObject_InitInlineValues(op, tp);
     }
     return op;
diff --git a/Python/gc_free_threading.c b/Python/gc_free_threading.c
@@ -1839,15 +1839,15 @@ _PyObject_GC_New(PyTypeObject *tp)
 {
     size_t presize = _PyType_PreHeaderSize(tp);
     size_t size = _PyObject_SIZE(tp);
-    if (_PyType_HasFeature(tp, Py_TPFLAGS_INLINE_VALUES)) {
+    if (_PyType_HasFeature(tp, _Py_TPFLAGS_INLINE_VALUES)) {
         size += _PyInlineValuesSize(tp);
     }
     PyObject *op = gc_alloc(tp, size, presize);
     if (op == NULL) {
         return NULL;
     }
     _PyObject_Init(op, tp);
-    if (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         _PyObject_InitInlineValues(op, tp);
     }
     return op;
diff --git a/Python/generated_cases.c.h b/Python/generated_cases.c.h
diff --git a/Python/specialize.c b/Python/specialize.c
@@ -1027,7 +1027,7 @@ specialize_dict_access(
         SPECIALIZATION_FAIL(base_op, SPEC_FAIL_ATTR_NOT_MANAGED_DICT);
         return 0;
     }
-    if (type->tp_flags & Py_TPFLAGS_INLINE_VALUES &&
+    if (type->tp_flags & _Py_TPFLAGS_INLINE_VALUES &&
         FT_ATOMIC_LOAD_UINT8(_PyObject_InlineValues(owner)->valid) &&
         !(base_op == STORE_ATTR && _PyObject_GetManagedDict(owner) != NULL))
     {
@@ -1080,7 +1080,7 @@ instance_has_key(PyObject *obj, PyObject* name)
     if ((cls->tp_flags & Py_TPFLAGS_MANAGED_DICT) == 0) {
         return false;
     }
-    if (cls->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (cls->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         PyDictKeysObject *keys = ((PyHeapTypeObject *)cls)->ht_cached_keys;
         Py_ssize_t index = _PyDictKeys_StringLookup(keys, name);
         return index >= 0;
@@ -1525,7 +1525,7 @@ PyObject *descr, DescriptorClassification kind, bool is_method)
 
     assert(descr != NULL);
     assert((is_method && kind == METHOD) || (!is_method && kind == NON_DESCRIPTOR));
-    if (owner_cls->tp_flags & Py_TPFLAGS_INLINE_VALUES) {
+    if (owner_cls->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {
         PyDictKeysObject *keys = ((PyHeapTypeObject *)owner_cls)->ht_cached_keys;
         assert(_PyDictKeys_StringLookup(keys, name) < 0);
         uint32_t keys_version = _PyDictKeys_GetVersionForCurrentState(
diff --git a/Tools/gdb/libpython.py b/Tools/gdb/libpython.py
@@ -86,7 +86,7 @@ def interp_frame_has_tlbc_index():
                                            for field in interp_frame.fields())
     return _INTERP_FRAME_HAS_TLBC_INDEX
 
-Py_TPFLAGS_INLINE_VALUES     = (1 << 2)
+_Py_TPFLAGS_INLINE_VALUES     = (1 << 2)
 Py_TPFLAGS_MANAGED_DICT      = (1 << 4)
 Py_TPFLAGS_HEAPTYPE          = (1 << 9)
 Py_TPFLAGS_LONG_SUBCLASS     = (1 << 24)

Original file line number	Diff line number	Diff line change
`@@ -944,7 +944,7 @@ _PyObject_InlineValues(PyObject *obj)`
`944`	`944`	`{`
`945`	`945`	`PyTypeObject *tp = Py_TYPE(obj);`
`946`	`946`	`assert(tp->tp_basicsize > 0 && (size_t)tp->tp_basicsize % sizeof(PyObject *) == 0);`
`947`		`- assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES);`
	`947`	`+ assert(Py_TYPE(obj)->tp_flags & _Py_TPFLAGS_INLINE_VALUES);`
`948`	`948`	`assert(Py_TYPE(obj)->tp_flags & Py_TPFLAGS_MANAGED_DICT);`
`949`	`949`	`return (PyDictValues )((char )obj + tp->tp_basicsize);`
`950`	`950`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1322,7 +1322,7 @@ static PyObject *`
`1322`	`1322`	`get_object_dict_values(PyObject self, PyObject obj)`
`1323`	`1323`	`{`
`1324`	`1324`	`PyTypeObject *type = Py_TYPE(obj);`
`1325`		`- if (!_PyType_HasFeature(type, Py_TPFLAGS_INLINE_VALUES)) {`
	`1325`	`+ if (!_PyType_HasFeature(type, _Py_TPFLAGS_INLINE_VALUES)) {`
`1326`	`1326`	`Py_RETURN_NONE;`
`1327`	`1327`	`}`
`1328`	`1328`	`PyDictValues *values = _PyObject_InlineValues(obj);`
`@@ -1982,7 +1982,7 @@ get_tlbc_id(PyObject Py_UNUSED(module), PyObject obj)`
`1982`	`1982`	`static PyObject *`
`1983`	`1983`	`has_inline_values(PyObject self, PyObject obj)`
`1984`	`1984`	`{`
`1985`		`- if ((Py_TYPE(obj)->tp_flags & Py_TPFLAGS_INLINE_VALUES) &&`
	`1985`	`+ if ((Py_TYPE(obj)->tp_flags & _Py_TPFLAGS_INLINE_VALUES) &&`
`1986`	`1986`	`_PyObject_InlineValues(obj)->valid) {`
`1987`	`1987`	`Py_RETURN_TRUE;`
`1988`	`1988`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2197,7 +2197,7 @@ type_call(PyObject self, PyObject args, PyObject *kwds)`
`2197`	`2197`	`PyObject *`
`2198`	`2198`	`_PyType_NewManagedObject(PyTypeObject *type)`
`2199`	`2199`	`{`
`2200`		`- assert(type->tp_flags & Py_TPFLAGS_INLINE_VALUES);`
	`2200`	`+ assert(type->tp_flags & _Py_TPFLAGS_INLINE_VALUES);`
`2201`	`2201`	`assert(_PyType_IS_GC(type));`
`2202`	`2202`	`assert(type->tp_new == PyBaseObject_Type.tp_new);`
`2203`	`2203`	`assert(type->tp_alloc == PyType_GenericAlloc);`
`@@ -2222,7 +2222,7 @@ _PyType_AllocNoTrack(PyTypeObject *type, Py_ssize_t nitems)`
`2222`	`2222`	`size_t size = _PyObject_VAR_SIZE(type, nitems+1);`
`2223`	`2223`
`2224`	`2224`	`const size_t presize = _PyType_PreHeaderSize(type);`
`2225`		`- if (type->tp_flags & Py_TPFLAGS_INLINE_VALUES) {`
	`2225`	`+ if (type->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {`
`2226`	`2226`	`assert(type->tp_itemsize == 0);`
`2227`	`2227`	`size += _PyInlineValuesSize(type);`
`2228`	`2228`	`}`
`@@ -2246,7 +2246,7 @@ _PyType_AllocNoTrack(PyTypeObject *type, Py_ssize_t nitems)`
`2246`	`2246`	`else {`
`2247`	`2247`	`_PyObject_InitVar((PyVarObject *)obj, type, nitems);`
`2248`	`2248`	`}`
`2249`		`- if (type->tp_flags & Py_TPFLAGS_INLINE_VALUES) {`
	`2249`	`+ if (type->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {`
`2250`	`2250`	`_PyObject_InitInlineValues(obj, type);`
`2251`	`2251`	`}`
`2252`	`2252`	`return obj;`
`@@ -2399,8 +2399,8 @@ subtype_clear(PyObject *self)`
`2399`	`2399`	`PyObject_ClearManagedDict(self);`
`2400`	`2400`	`}`
`2401`	`2401`	`else {`
`2402`		`- assert((base->tp_flags & Py_TPFLAGS_INLINE_VALUES) ==`
`2403`		`- (type->tp_flags & Py_TPFLAGS_INLINE_VALUES));`
	`2402`	`+ assert((base->tp_flags & _Py_TPFLAGS_INLINE_VALUES) ==`
	`2403`	`+ (type->tp_flags & _Py_TPFLAGS_INLINE_VALUES));`
`2404`	`2404`	`}`
`2405`	`2405`	`}`
`2406`	`2406`	`else if (type->tp_dictoffset != base->tp_dictoffset) {`
`@@ -5953,7 +5953,7 @@ type_setattro(PyObject self, PyObject name, PyObject *value)`
`5953`	`5953`	`}`
`5954`	`5954`
`5955`	`5955`	`PyTypeObject *metatype = Py_TYPE(type);`
`5956`		`- assert(!_PyType_HasFeature(metatype, Py_TPFLAGS_INLINE_VALUES));`
	`5956`	`+ assert(!_PyType_HasFeature(metatype, _Py_TPFLAGS_INLINE_VALUES));`
`5957`	`5957`	`assert(!_PyType_HasFeature(metatype, Py_TPFLAGS_MANAGED_DICT));`
`5958`	`5958`
`5959`	`5959`	`PyObject *old_value = NULL;`
`@@ -6769,8 +6769,8 @@ compatible_for_assignment(PyTypeObject* oldto, PyTypeObject* newto, const char*`
`6769`	`6769`	`!same_slots_added(newbase, oldbase))) {`
`6770`	`6770`	`goto differs;`
`6771`	`6771`	`}`
`6772`		`- if ((oldto->tp_flags & Py_TPFLAGS_INLINE_VALUES) !=`
`6773`		`- ((newto->tp_flags & Py_TPFLAGS_INLINE_VALUES)))`
	`6772`	`+ if ((oldto->tp_flags & _Py_TPFLAGS_INLINE_VALUES) !=`
	`6773`	`+ ((newto->tp_flags & _Py_TPFLAGS_INLINE_VALUES)))`
`6774`	`6774`	`{`
`6775`	`6775`	`goto differs;`
`6776`	`6776`	`}`
`@@ -6859,7 +6859,7 @@ object_set_class_world_stopped(PyObject self, PyTypeObject newto)`
`6859`	`6859`	`if (compatible_for_assignment(oldto, newto, "__class__")) {`
`6860`	`6860`	`/* Changing the class will change the implicit dict keys,`
`6861`	`6861`	`* so we must materialize the dictionary first. */`
`6862`		`- if (oldto->tp_flags & Py_TPFLAGS_INLINE_VALUES) {`
	`6862`	`+ if (oldto->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {`
`6863`	`6863`	`PyDictObject *dict = _PyObject_GetManagedDict(self);`
`6864`	`6864`	`if (dict == NULL) {`
`6865`	`6865`	`dict = _PyObject_MaterializeManagedDict_LockHeld(self);`
`@@ -8543,7 +8543,7 @@ type_ready_managed_dict(PyTypeObject *type)`
`8543`	`8543`	`}`
`8544`	`8544`	`}`
`8545`	`8545`	`if (type->tp_itemsize == 0) {`
`8546`		`- type->tp_flags \|= Py_TPFLAGS_INLINE_VALUES;`
	`8546`	`+ type->tp_flags \|= _Py_TPFLAGS_INLINE_VALUES;`
`8547`	`8547`	`}`
`8548`	`8548`	`return 0;`
`8549`	`8549`	`}`
Original file line number	Diff line number	Diff line change
`@@ -2269,15 +2269,15 @@ _PyObject_GC_New(PyTypeObject *tp)`
`2269`	`2269`	`{`
`2270`	`2270`	`size_t presize = _PyType_PreHeaderSize(tp);`
`2271`	`2271`	`size_t size = _PyObject_SIZE(tp);`
`2272`		`- if (_PyType_HasFeature(tp, Py_TPFLAGS_INLINE_VALUES)) {`
	`2272`	`+ if (_PyType_HasFeature(tp, _Py_TPFLAGS_INLINE_VALUES)) {`
`2273`	`2273`	`size += _PyInlineValuesSize(tp);`
`2274`	`2274`	`}`
`2275`	`2275`	`PyObject *op = gc_alloc(tp, size, presize);`
`2276`	`2276`	`if (op == NULL) {`
`2277`	`2277`	`return NULL;`
`2278`	`2278`	`}`
`2279`	`2279`	`_PyObject_Init(op, tp);`
`2280`		`- if (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) {`
	`2280`	`+ if (tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {`
`2281`	`2281`	`_PyObject_InitInlineValues(op, tp);`
`2282`	`2282`	`}`
`2283`	`2283`	`return op;`
Original file line number	Diff line number	Diff line change
`@@ -1839,15 +1839,15 @@ _PyObject_GC_New(PyTypeObject *tp)`
`1839`	`1839`	`{`
`1840`	`1840`	`size_t presize = _PyType_PreHeaderSize(tp);`
`1841`	`1841`	`size_t size = _PyObject_SIZE(tp);`
`1842`		`- if (_PyType_HasFeature(tp, Py_TPFLAGS_INLINE_VALUES)) {`
	`1842`	`+ if (_PyType_HasFeature(tp, _Py_TPFLAGS_INLINE_VALUES)) {`
`1843`	`1843`	`size += _PyInlineValuesSize(tp);`
`1844`	`1844`	`}`
`1845`	`1845`	`PyObject *op = gc_alloc(tp, size, presize);`
`1846`	`1846`	`if (op == NULL) {`
`1847`	`1847`	`return NULL;`
`1848`	`1848`	`}`
`1849`	`1849`	`_PyObject_Init(op, tp);`
`1850`		`- if (tp->tp_flags & Py_TPFLAGS_INLINE_VALUES) {`
	`1850`	`+ if (tp->tp_flags & _Py_TPFLAGS_INLINE_VALUES) {`
`1851`	`1851`	`_PyObject_InitInlineValues(op, tp);`
`1852`	`1852`	`}`
`1853`	`1853`	`return op;`