Port PyArrayDTypeMeta to HPy

Author: steve-s

numpy/core/include/numpy/ndarraytypes.h

@@ -1975,7 +1975,7 @@ typedef void (PyDataMem_EventHookFunc)(void *inp, void *outp, size_t size,
      * further modifications.
      */
     /* TODO: Make this definition public in the API, as soon as its settled */
-    NPY_NO_EXPORT extern PyTypeObject PyArrayDTypeMeta_Type;
+    NPY_NO_EXPORT extern PyTypeObject *PyArrayDTypeMeta_Type;
 
     /*
      * While NumPy DTypes would not need to be heap types the plan is to

numpy/core/src/multiarray/abstractdtypes.c

@@ -113,7 +113,7 @@ initialize_and_map_pytypes_to_dtypes(HPyContext *ctx)
 {
     int result = -1;
     HPy h_PyArrayDescr_Type = HPy_FromPyObject(ctx, (PyObject *) &PyArrayDescr_Type);
-    HPy h_PyArrayDTypeMeta_Type = HPy_FromPyObject(ctx, (PyObject*) &PyArrayDTypeMeta_Type);
+    HPy h_PyArrayDTypeMeta_Type = HPy_FromPyObject(ctx, (PyObject*) PyArrayDTypeMeta_Type);
     HPyType_SpecParam abstract_dtype_params[] = {
         {HPyType_SpecParam_Base, h_PyArrayDescr_Type},
         { HPyType_SpecParam_Metaclass, h_PyArrayDTypeMeta_Type },

numpy/core/src/multiarray/array_coercion.c

@@ -226,7 +226,7 @@ npy_discover_dtype_from_pytype(PyTypeObject *pytype)
     if (DType == Py_None) {
         return (PyArray_DTypeMeta *)Py_None;
     }
-    assert(PyObject_TypeCheck(DType, (PyTypeObject *)&PyArrayDTypeMeta_Type));
+    assert(PyObject_TypeCheck(DType, PyArrayDTypeMeta_Type));
     return (PyArray_DTypeMeta *)DType;
 }
 
@@ -1208,7 +1208,7 @@ PyArray_DiscoverDTypeAndShape(
     /* Validate input of requested descriptor and DType */
     if (fixed_DType != NULL) {
         assert(PyObject_TypeCheck(
-                (PyObject *)fixed_DType, (PyTypeObject *)&PyArrayDTypeMeta_Type));
+                (PyObject *)fixed_DType, PyArrayDTypeMeta_Type));
     }
 
     if (requested_descr != NULL) {
@@ -1469,13 +1469,13 @@ PyArray_ExtractDTypeAndDescriptor(PyObject *dtype,
     *out_descr = NULL;
 
     if (dtype != NULL) {
-        if (PyObject_TypeCheck(dtype, (PyTypeObject *)&PyArrayDTypeMeta_Type)) {
+        if (PyObject_TypeCheck(dtype, PyArrayDTypeMeta_Type)) {
             assert(dtype != (PyObject * )&PyArrayDescr_Type);  /* not np.dtype */
             *out_DType = (PyArray_DTypeMeta *)dtype;
             Py_INCREF(*out_DType);
         }
         else if (PyObject_TypeCheck((PyObject *)Py_TYPE(dtype),
-                    (PyTypeObject *)&PyArrayDTypeMeta_Type)) {
+                    PyArrayDTypeMeta_Type)) {
             *out_DType = NPY_DTYPE(dtype);
             Py_INCREF(*out_DType);
             if (!descr_is_legacy_parametric_instance((PyArray_Descr *)dtype)) {

numpy/core/src/multiarray/array_method.c

@@ -212,7 +212,7 @@ validate_spec(PyArrayMethod_Spec *spec)
                     "(method: %s)", spec->name);
             return -1;
         }
-        if (!PyObject_TypeCheck(spec->dtypes[i], &PyArrayDTypeMeta_Type)) {
+        if (!PyObject_TypeCheck(spec->dtypes[i], PyArrayDTypeMeta_Type)) {
             PyErr_Format(PyExc_TypeError,
                     "ArrayMethod provided object %R is not a DType."
                     "(method: %s)", spec->dtypes[i], spec->name);
@@ -372,7 +372,7 @@ NPY_NO_EXPORT PyObject *
 PyArrayMethod_FromSpec(PyArrayMethod_Spec *spec)
 {
     for (int i = 0; i < spec->nin + spec->nout; i++) {
-        if (!PyObject_TypeCheck(spec->dtypes[i], &PyArrayDTypeMeta_Type)) {
+        if (!PyObject_TypeCheck(spec->dtypes[i], PyArrayDTypeMeta_Type)) {
             PyErr_SetString(PyExc_RuntimeError,
                     "ArrayMethod spec contained a non DType.");
             return NULL;

numpy/core/src/multiarray/convert_datatype.c

@@ -200,7 +200,7 @@ _get_castingimpl(PyObject *NPY_UNUSED(module), PyObject *args)
 {
     PyArray_DTypeMeta *from, *to;
     if (!PyArg_ParseTuple(args, "O!O!:_get_castingimpl",
-            &PyArrayDTypeMeta_Type, &from, &PyArrayDTypeMeta_Type, &to)) {
+            PyArrayDTypeMeta_Type, &from, PyArrayDTypeMeta_Type, &to)) {
         return NULL;
     }
     return PyArray_GetBoundCastingImpl(from, to);

numpy/core/src/multiarray/descriptor.c

@@ -2447,7 +2447,7 @@ arraydescr_new(PyTypeObject *subtype,
                 PyObject *args, PyObject *kwds)
 {
     if (subtype != &PyArrayDescr_Type) {
-        if (Py_TYPE(subtype) == &PyArrayDTypeMeta_Type &&
+        if (Py_TYPE(subtype) == PyArrayDTypeMeta_Type &&
                 (NPY_DT_SLOTS((PyArray_DTypeMeta *)subtype)) != NULL &&
                 !NPY_DT_is_legacy((PyArray_DTypeMeta *)subtype) &&
                 subtype->tp_new != PyArrayDescr_Type.tp_new) {

numpy/core/src/multiarray/dtypemeta.c

@@ -70,10 +70,9 @@ dtypemeta_is_gc(PyObject *dtype_class)
     return PyType_Type.tp_is_gc(dtype_class);
 }
 
-
-static int
-dtypemeta_traverse(PyArray_DTypeMeta *type, visitproc visit, void *arg)
-{
+HPyDef_SLOT(DTypeMeta_traverse, DTypeMeta_traverse_impl, HPy_tp_traverse)
+static int DTypeMeta_traverse_impl(void *self, HPyFunc_visitproc visit, void *arg) {
+    // HPY TODO: implement
     /*
      * We have to traverse the base class (if it is a HeapType).
      * PyType_Type will handle this logic for us.
@@ -571,7 +570,7 @@ dtypemeta_wrap_legacy_descriptor(HPyContext *ctx, PyArray_Descr *descr)
     New_PyArrayDescr_spec.name = tp_name;
 
     HPy h_PyArrayDescr_Type = HPy_FromPyObject(ctx, (PyObject *) &PyArrayDescr_Type);
-    HPy h_PyArrayDTypeMeta_Type = HPy_FromPyObject(ctx, (PyObject*) &PyArrayDTypeMeta_Type);
+    HPy h_PyArrayDTypeMeta_Type = HPy_FromPyObject(ctx, (PyObject*) PyArrayDTypeMeta_Type);
     HPy h_new_dtype_type = HPy_NULL;
     PyObject *dtype_class = NULL; // to pass to legacy helpers
     int result = -1;
@@ -700,19 +699,30 @@ static PyMemberDef dtypemeta_members[] = {
     {NULL, 0, 0, 0, NULL},
 };
 
-NPY_NO_EXPORT PyTypeObject PyArrayDTypeMeta_Type = {
-    PyVarObject_HEAD_INIT(NULL, 0)
-    .tp_name = "numpy._DTypeMeta",
-    .tp_basicsize = sizeof(PyArray_DTypeMeta),
-    .tp_dealloc = (destructor)dtypemeta_dealloc,
-    /* Types are garbage collected (see dtypemeta_is_gc documentation) */
-    .tp_flags = Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
-    .tp_doc = "Preliminary NumPy API: The Type of NumPy DTypes (metaclass)",
-    .tp_getset = dtypemeta_getset,
-    .tp_members = dtypemeta_members,
-    .tp_base = NULL,  /* set to PyType_Type at import time */
-    .tp_init = (initproc)dtypemeta_init,
-    .tp_new = dtypemeta_new,
-    .tp_is_gc = dtypemeta_is_gc,
-    .tp_traverse = (traverseproc)dtypemeta_traverse,
+// HPY TODO: global set in module init:
+NPY_NO_EXPORT PyTypeObject *PyArrayDTypeMeta_Type;
+
+NPY_NO_EXPORT PyType_Slot PyArrayDTypeMeta_Type_legacy_slots[] = {
+    {Py_tp_getset, dtypemeta_getset},
+    {Py_tp_members, dtypemeta_members},
+    {Py_tp_init, dtypemeta_init},
+    {Py_tp_new, dtypemeta_new},
+    {0, 0},
 };
+
+NPY_NO_EXPORT HPyDef *PyArrayDTypeMeta_Type_slots[] = {
+    &DTypeMeta_traverse,
+    0,
+};
+
+NPY_NO_EXPORT HPyType_Spec PyArrayDTypeMeta_Type_spec = {
+    .name = "numpy._DTypeMeta",
+    .basicsize = sizeof(PyArray_DTypeMeta),
+    /* Types are garbage collected (see dtypemeta_is_gc documentation) */
+    .flags = HPy_TPFLAGS_DEFAULT | HPy_TPFLAGS_HAVE_GC,
+    .doc = "Preliminary NumPy API: The Type of NumPy DTypes (metaclass)",
+    .legacy = true,
+    .defines = PyArrayDTypeMeta_Type_slots,
+    .legacy_slots = &PyArrayDTypeMeta_Type_legacy_slots,
+    // HPY TODO: .tp_traverse = (traverseproc)dtypemeta_traverse,
+};

numpy/core/src/multiarray/dtypemeta.h

@@ -122,4 +122,6 @@ python_builtins_are_known_scalar_types(
 NPY_NO_EXPORT int
 dtypemeta_wrap_legacy_descriptor(HPyContext *ctx, PyArray_Descr *dtypem);
 
+NPY_NO_EXPORT HPyType_Spec PyArrayDTypeMeta_Type_spec;
+
 #endif  /* NUMPY_CORE_SRC_MULTIARRAY_DTYPEMETA_H_ */

numpy/core/src/multiarray/experimental_public_dtype_api.c

@@ -124,7 +124,7 @@ int
 PyArrayInitDTypeMeta_FromSpec(
         PyArray_DTypeMeta *DType, PyArrayDTypeMeta_Spec *spec)
 {
-    if (!PyObject_TypeCheck(DType, &PyArrayDTypeMeta_Type)) {
+    if (!PyObject_TypeCheck(DType, PyArrayDTypeMeta_Type)) {
         PyErr_SetString(PyExc_RuntimeError,
                 "Passed in DType must be a valid (initialized) DTypeMeta "
                 "instance!");
@@ -387,7 +387,7 @@ _get_experimental_dtype_api(PyObject *NPY_UNUSED(mod), PyObject *arg)
     static void *experimental_api_table[42] = {
             &PyUFunc_AddLoopFromSpec,
             &PyUFunc_AddPromoter,
-            &PyArrayDTypeMeta_Type,
+            NULL,
             &PyArrayInitDTypeMeta_FromSpec,
             &PyArray_CommonDType,
             &PyArray_PromoteDTypeSequence,
@@ -398,6 +398,7 @@ _get_experimental_dtype_api(PyObject *NPY_UNUSED(mod), PyObject *arg)
             /* NumPy's builtin DTypes (starting at offset 10 going to 41) */
     };
     if (experimental_api_table[10] == NULL) {
+        experimental_api_table[2] = PyArrayDTypeMeta_Type;
         experimental_api_table[10] = PyArray_DTypeFromTypeNum(NPY_BOOL);
         /* Integers */
         experimental_api_table[11] = PyArray_DTypeFromTypeNum(NPY_BYTE);

numpy/core/src/multiarray/multiarraymodule.c

@@ -4762,12 +4762,15 @@ static HPy init__multiarray_umath_impl(HPyContext *ctx) {
         goto err;
     }
 
-    PyArrayDTypeMeta_Type.tp_base = &PyType_Type;
-    if (PyType_Ready(&PyArrayDTypeMeta_Type) < 0) {
+    HPyType_SpecParam dtypemeta_params[] = {
+        { HPyType_SpecParam_Base, ctx->h_TypeType },
+        { 0 }
+    };
+    HPy h_PyArrayDTypeMeta_Type = HPyType_FromSpec(ctx, &PyArrayDTypeMeta_Type_spec, dtypemeta_params);
+    if (HPy_IsNull(h_PyArrayDTypeMeta_Type)) {
         goto err;
     }
 
-    HPy h_PyArrayDTypeMeta_Type = HPy_FromPyObject(ctx, (PyObject*) &PyArrayDTypeMeta_Type);
     HPyType_SpecParam dtype_params[] = {
         { HPyType_SpecParam_Metaclass, h_PyArrayDTypeMeta_Type },
         { 0 }
@@ -4783,12 +4786,14 @@ static HPy init__multiarray_umath_impl(HPyContext *ctx) {
     pyarry_descr_data->singleton = NULL;
     pyarry_descr_data->scalar_type = NULL;
 
-    // HPY TODO: storing the dtype to globals to support legacy code, and HPy code w/o module state
+    // HPY TODO: storing the types to globals to support legacy code, and HPy code w/o module state
     _PyArrayDescr_Type_p = (PyTypeObject*) HPy_AsPyObject(ctx, h_PyArrayDescr_Type);
+    PyArrayDTypeMeta_Type = (PyTypeObject*) HPy_AsPyObject(ctx, h_PyArrayDTypeMeta_Type);
     HPyArrayDescr_Type = HPy_Dup(ctx, h_PyArrayDescr_Type);
 
     HPy_Close(ctx, h_PyArrayDTypeMeta_Type);
     HPy_Close(ctx, h_PyArrayDescr_Type);
+    HPy_Close(ctx, h_PyArrayDTypeMeta_Type);
 
     initialize_casting_tables();
     initialize_numeric_types();

numpy/core/src/umath/dispatching.c

@@ -96,7 +96,7 @@ PyUFunc_AddLoop(PyUFuncObject *ufunc, PyObject *info, int ignore_duplicate)
     for (Py_ssize_t i = 0; i < PyTuple_GET_SIZE(DType_tuple); i++) {
         PyObject *item = PyTuple_GET_ITEM(DType_tuple, i);
         if (item != Py_None
-                && !PyObject_TypeCheck(item, &PyArrayDTypeMeta_Type)) {
+                && !PyObject_TypeCheck(item, PyArrayDTypeMeta_Type)) {
             PyErr_SetString(PyExc_TypeError,
                     "DType tuple may only contain None and DType classes");
             return -1;

numpy/core/src/umath/ufunc_object.c

@@ -4291,7 +4291,7 @@ _check_and_copy_sig_to_signature(
  */
 static PyArray_DTypeMeta *
 _get_dtype(PyObject *dtype_obj) {
-    if (PyObject_TypeCheck(dtype_obj, &PyArrayDTypeMeta_Type)) {
+    if (PyObject_TypeCheck(dtype_obj, PyArrayDTypeMeta_Type)) {
         Py_INCREF(dtype_obj);
         return (PyArray_DTypeMeta *)dtype_obj;
     }