Fix build failures from upstream removal of constructor for ndt::type

that constructs a type from its type id.

Author: insertinterestingnamehere

dynd/cpp/type.pxd

@@ -36,3 +36,13 @@ cdef extern from 'dynd/type.hpp' namespace 'dynd::ndt' nogil:
         type_id_t get_base_id() const
 
     type make_type[T]() except +translate_exception
+
+    cppclass reg_info_t:
+        type tp
+
+# Ideally we wouldn't use the detail namespace, but this is currently
+# needed to map a type id back to the corresponding type.
+cdef extern from "<dynd/type.hpp>" nogil:
+    # Function doesn't really exist.
+    # Use this to avoid Cython's odd handling of lvalue references
+    reg_info_t _get_reg_info "dynd::ndt::detail::infos().operator[]"(type_id_t) except +translate_exception

dynd/ndt/type.pyx

@@ -33,7 +33,7 @@ from ..cpp.types.callable_type cimport callable_type as _callable_type
 from ..cpp.types.string_type cimport string_type
 from ..cpp.types.bytes_type cimport bytes_type
 from ..cpp.types.fixed_bytes_type cimport fixed_bytes_type
-from ..cpp.type cimport make_type
+from ..cpp.type cimport make_type, _get_reg_info
 from ..cpp.complex cimport complex as dynd_complex
 
 from ..config cimport translate_exception
@@ -399,8 +399,6 @@ cdef _type as_cpp_type(object o) except *:
     elif _builtin_type(o) is str or PyUnicode_Check(<PyObject*>o):
         # Use Cython's automatic conversion to c++ strings.
         return _type(<string>o)
-    elif _builtin_type(o) is int or _builtin_type(o) is long:
-        return _type(<type_id_t>(<int>o))
     elif is_numpy_dtype(<PyObject*>o):
         return _type_from_numpy_dtype(<PyArray_Descr*>o)
     elif issubclass(o, _ctypes_base_type):
@@ -718,7 +716,8 @@ cdef as_numba_type(_type tp):
     return _to_numba_type[tp.get_id()]
 
 cdef _type from_numba_type(tp):
-    return _type(<type_id_t> _from_numba_type[tp])
+
+    return _get_reg_info((<type_id_t> _from_numba_type[tp])).tp
 
 cdef _type cpp_type_for(object obj) except *:
     cdef _type tp = xtype_for_prefix(obj)

dynd/src/array_from_py.cpp

@@ -235,7 +235,7 @@ static dynd::nd::array array_from_pylist(PyObject *obj)
   // TODO: Add ability to specify access flags (e.g. immutable)
   // Do a pass through all the data to deduce its type and shape
   vector<intptr_t> shape;
-  ndt::type tp(void_id);
+  ndt::type tp = ndt::make_type<void>();
   Py_ssize_t size = PyList_GET_SIZE(obj);
   shape.push_back(size);
   for (Py_ssize_t i = 0; i < size; ++i) {

dynd/src/assign.cpp

@@ -8,6 +8,7 @@
 
 #include <dynd/functional.hpp>
 #include <dynd/kernels/tuple_assignment_kernels.hpp>
+#include <dynd/type.hpp>
 
 #include "assign.hpp"
 #include "callables/assign_from_pyobject_callable.hpp"
@@ -26,12 +27,19 @@ PYDYND_API void assign_init()
       types;
 
   PyDateTime_IMPORT;
+  // TODO: There should be an interface that allows adding overloads
+  // based on type id rather than on actual type. The current interface
+  // makes for a lot of mapping back and forth between types and their
+  // corresponding type ids.
+  // For now, just use the infos vector from the type registry to map
+  // ids back to their corresponding types.
+  auto infos = ndt::detail::infos();
 
   for (const auto &pair : nd::callable::make_all<pydynd::nd::assign_from_pyobject_callable, types>()) {
-    nd::assign.overload(pair.first[0], {ndt::make_type<pyobject_type>()}, pair.second);
+    nd::assign.overload(infos[pair.first[0]].tp, {ndt::make_type<pyobject_type>()}, pair.second);
   }
   for (const auto &pair : nd::callable::make_all<pydynd::nd::assign_to_pyobject_callable, types>()) {
-    nd::assign.overload(ndt::make_type<pyobject_type>(), {ndt::type(pair.first[0])}, pair.second);
+    nd::assign.overload(ndt::make_type<pyobject_type>(), {infos[pair.first[0]].tp}, pair.second);
   }
 }
 

dynd/src/type_conversions.cpp

@@ -1,5 +1,9 @@
+#include <cstdint>
+
 #include "type_functions.hpp"
+
 #include "type_deduction.hpp"
+
 #include "type_api.h"
 
 dynd::ndt::type &pydynd::type_to_cpp_ref(PyObject *o)
@@ -70,15 +74,15 @@ dynd::ndt::type pydynd::ndt_type_from_pylist(PyObject *obj)
   // TODO: Add ability to specify access flags (e.g. immutable)
   // Do a pass through all the data to deduce its type and shape
   std::vector<intptr_t> shape;
-  dynd::ndt::type tp(dynd::void_id);
+  dynd::ndt::type tp = dynd::ndt::make_type<void>();
   Py_ssize_t size = PyList_GET_SIZE(obj);
   shape.push_back(size);
   for (Py_ssize_t i = 0; i < size; ++i) {
     deduce_pylist_shape_and_dtype(PyList_GET_ITEM(obj, i), shape, tp, 1);
   }
 
   if (tp.get_id() == dynd::void_id) {
-    tp = dynd::ndt::type(dynd::int32_id);
+    tp = dynd::ndt::make_type<int32_t>();
   }
 
   return dynd::ndt::make_type(shape.size(), shape.data(), tp);