Sync with WIP branch: Limit feature to C++14, disable tests on C++11, fix CI failures

Author: EricCousineau-TRI

include/pybind11/detail/inference.h

@@ -48,6 +48,9 @@ struct type_pack {
     using type_at = typename type_at_internal<N>::type;
 };
 
+
+#if defined(PYBIND11_CPP14)
+
 template <typename... A, typename... B>
 auto type_pack_concat(type_pack<A...> = {}, type_pack<B...> = {}) {
   return type_pack<A..., B...>{};
@@ -136,6 +139,8 @@ struct function_inference {
     }
 };
 
+#endif  // defined(PYBIND_CPP14)
+
 NAMESPACE_END(detail)
 
 NAMESPACE_END(PYBIND11_NAMESPACE)

include/pybind11/detail/numpy_ufunc.h

@@ -12,6 +12,8 @@
 #include "../numpy.h"
 #include "inference.h"
 
+#if defined(PYBIND11_CPP14)
+
 NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
 NAMESPACE_BEGIN(detail)
 
@@ -31,11 +33,11 @@ auto ufunc_to_ptr(Func func, type_pack<Arg0, Out>) {
     auto ufunc = [](
             char** args, npy_intp* dimensions, npy_intp* steps, void* data) {
         Func& func = *(Func*)data;
-        int step_0 = steps[0];
-        int step_out = steps[1];
-        int n = *dimensions;
+        npy_intp step_0 = steps[0];
+        npy_intp step_out = steps[1];
+        npy_intp n = *dimensions;
         char *in_0 = args[0], *out = args[1];
-        for (int k = 0; k < n; k++) {
+        for (npy_intp k = 0; k < n; k++) {
             // TODO(eric.cousineau): Support pointers being changed.
             *(Out*)out = func(*(Arg0*)in_0);
             in_0 += step_0;
@@ -51,12 +53,12 @@ template <typename Arg0, typename Arg1, typename Out, typename Func = void>
 auto ufunc_to_ptr(Func func, type_pack<Arg0, Arg1, Out>) {
     auto ufunc = [](char** args, npy_intp* dimensions, npy_intp* steps, void* data) {
         Func& func = *(Func*)data;
-        int step_0 = steps[0];
-        int step_1 = steps[1];
-        int step_out = steps[2];
-        int n = *dimensions;
+        npy_intp step_0 = steps[0];
+        npy_intp step_1 = steps[1];
+        npy_intp step_out = steps[2];
+        npy_intp n = *dimensions;
         char *in_0 = args[0], *in_1 = args[1], *out = args[2];
-        for (int k = 0; k < n; k++) {
+        for (npy_intp k = 0; k < n; k++) {
             // TODO(eric.cousineau): Support pointers being fed in.
             *(Out*)out = func(*(Arg0*)in_0, *(Arg1*)in_1);
             in_0 += step_0;
@@ -86,7 +88,7 @@ void ufunc_register_cast(
   static auto cast_lambda = detail::function_inference::run(func).func;
   auto cast_func = +[](
         void* from_, void* to_, npy_intp n,
-        void* fromarr, void* toarr) {
+        void* /*fromarr*/, void* /*toarr*/) {
       const From* from = (From*)from_;
       To* to = (To*)to_;
       for (npy_intp i = 0; i < n; i++)
@@ -156,6 +158,7 @@ class ufunc : public object {
                 pybind11_fail("dtype: unspecified name");
             // TODO(eric.cousineau): Fix unfreed memory with `name`.
             auto leak = new std::string(name_);
+            char* name = (char*)&(*leak)[0];
             // The following dummy stuff is to allow monkey-patching existing ufuncs.
             // This is a bit sketchy, as calling the wrong thing may cause a segfault.
             // TODO(eric.cousineau): Figure out how to more elegantly specify preallocation...
@@ -179,7 +182,7 @@ class ufunc : public object {
             }
             auto h = api.PyUFunc_FromFuncAndData_(
                 dummy_funcs, dummy_data, dummy_types, ntypes,
-                nin, nout, constants::PyUFunc_None_, &(*leak)[0], "", 0);
+                nin, nout, constants::PyUFunc_None_, name, nullptr, 0);
             self() = reinterpret_borrow<object>((PyObject*)h);
             scope_.attr(name_) = self();
         }
@@ -209,8 +212,10 @@ class ufunc : public object {
     }
 
     // These are only used if we have something new.
-    const char* name_{};
     handle scope_{}; 
+    const char* name_{};
 };
 
 NAMESPACE_END(PYBIND11_NAMESPACE)
+
+#endif  // defined(PYBIND11_CPP14)

include/pybind11/numpy_dtype_user.h

@@ -18,6 +18,8 @@
 #include <utility>
 #include <typeindex>
 
+#if defined(PYBIND11_CPP14)
+
 // N.B. For NumPy dtypes, `custom` tends to mean record-like structures, while
 // `user-defined` means teaching NumPy about previously opaque C structures.
 
@@ -109,7 +111,7 @@ struct dtype_user_instance {
   }
 
   // Implementation for `tp_new` slot.
-  static PyObject* tp_new(PyTypeObject* type, PyObject* args, PyObject* kwds) {
+  static PyObject* tp_new(PyTypeObject* /*type*/, PyObject* /*args*/, PyObject* /*kwds*/) {
     // N.B. `__init__` should call the in-place constructor.
     auto obj = alloc_py();
     // // Register.
@@ -308,7 +310,7 @@ class dtype_user : public class_<Class_> {
   }
 
   template <typename ... Args, typename... Extra>
-  dtype_user& def(detail::initimpl::constructor<Args...>&& init, const Extra&... extra) {
+  dtype_user& def(detail::initimpl::constructor<Args...>&&, const Extra&... extra) {
     // See notes in `add_init`.
     // N.B. Do NOT use `Class*` as the argument, since that may incur recursion.
     add_init([](object py_self, Args... args) {
@@ -322,7 +324,7 @@ class dtype_user : public class_<Class_> {
   template <detail::op_id id, detail::op_type ot,
       typename L, typename R, typename... Extra>
   dtype_user& def_ufunc(
-      const detail::op_<id, ot, L, R>& op, const Extra&... extra) {
+      const detail::op_<id, ot, L, R>&, const Extra&... extra) {
     using op_ = detail::op_<id, ot, L, R>;
     using op_impl = typename op_::template info<dtype_user>::op;
     auto func = &op_impl::execute;
@@ -433,7 +435,6 @@ class dtype_user : public class_<Class_> {
         'V',                    /* kind (V = arbitrary) */
         'r',                    /* type */
         '=',                    /* byteorder */
-        // TODO(eric.cousineau): NPY_NEEDS_INIT?
         npy_api::NPY_NEEDS_PYAPI_ | npy_api::NPY_USE_GETITEM_ |
             npy_api::NPY_USE_SETITEM_ |
             npy_api::NPY_NEEDS_INIT_, /* flags */
@@ -454,11 +455,11 @@ class dtype_user : public class_<Class_> {
     using detail::npy_intp;
 
     // https://docs.scipy.org/doc/numpy/reference/c-api.types-and-structures.html
-    arrfuncs.getitem = (void*)+[](void* in, void* arr) -> PyObject* {
+    arrfuncs.getitem = (void*)+[](void* in, void* /*arr*/) -> PyObject* {
         auto item = (const Class*)in;
         return cast(*item).release().ptr();
     };
-    arrfuncs.setitem = (void*)+[](PyObject* in, void* out, void* arr) {
+    arrfuncs.setitem = (void*)+[](PyObject* in, void* out, void* /*arr*/) {
         detail::dtype_user_caster<Class> caster;
         if (!caster.load(in, true)) {
           PyErr_SetString(
@@ -470,7 +471,7 @@ class dtype_user : public class_<Class_> {
         print("setitem: in = ", handle(in));
         return 0;
     };
-    arrfuncs.copyswap = (void*)+[](void* dst, void* src, int swap, void* arr) {
+    arrfuncs.copyswap = (void*)+[](void* dst, void* src, int swap, void* /*arr*/) {
         // TODO(eric.cousineau): Figure out actual purpose of this.
         if (!src) return;
         Class* r_dst = (Class*)dst;
@@ -484,23 +485,12 @@ class dtype_user : public class_<Class_> {
             *r_dst = *r_src;
         }
     };
-    // - Test and ensure this doesn't overwrite our `equal` unfunc.
-    arrfuncs.compare = (void*)+[](const void* d1, const void* d2, void* arr) {
-      return 0;
+    // - Ensure this doesn't overwrite our `equal` unfunc.
+    arrfuncs.compare = (void*)+[](const void* /*d1*/, const void* /*d2*/, void* /*arr*/) {
+      pybind11_fail("dtype: `compare` should not be called for pybind11 custom dtype");
     };
-    // arrfuncs.fill = (void*)+[](void* data_, npy_intp length, void* arr) {
-    //   Class* data = (Class*)data_;
-    //   Class delta = data[1] - data[0];
-    //   Class r = data[1];
-    //   npy_intp i;
-    //   for (i = 2; i < length; i++) {
-    //       r += delta;
-    //       data[i] = r;
-    //   }
-    //   return 0;
-    // };
     arrfuncs.fillwithscalar = (void*)+[](
-            void* buffer_raw, npy_intp length, void* value_raw, void* arr) {
+            void* buffer_raw, npy_intp length, void* value_raw, void* /*arr*/) {
         const Class* value = (const Class*)value_raw;
         Class* buffer = (Class*)buffer_raw;
         for (int k = 0; k < length; k++) {
@@ -529,3 +519,5 @@ NAMESPACE_END(PYBIND11_NAMESPACE)
         struct npy_format_descriptor<Type> \
             : public dtype_user_npy_format_descriptor<Type> {}; \
     }}
+
+#endif  // defined(PYBIND11_CPP14)

tests/pybind11_tests.h

@@ -1,4 +1,7 @@
 #pragma once
+
+#include <functional>
+
 #include <pybind11/pybind11.h>
 
 #if defined(_MSC_VER) && _MSC_VER < 1910

tests/test_numpy_dtype_user.cpp

@@ -14,14 +14,14 @@
 #include <pybind11/stl.h>
 #include <pybind11/operators.h>
 #include <pybind11/numpy_dtype_user.h>
-#include <pybind11/embed.h>
 
-using std::make_unique;
 using std::string;
 using std::unique_ptr;
 
 namespace py = pybind11;
 
+namespace {
+
 // Trivial string class.
 class CustomStr {
 public:
@@ -43,8 +43,6 @@ class CustomStr {
     char buffer[len];
 };
 
-PYBIND11_NUMPY_DTYPE_USER(CustomStr);
-
 // Basic structure, meant to be an implicitly convertible value for `Custom`.
 // Would have used a struct type, but the scalars are only tuples.
 struct SimpleStruct {
@@ -53,14 +51,12 @@ struct SimpleStruct {
     SimpleStruct(double value_in) : value(value_in) {}
 };
 
-PYBIND11_NUMPY_DTYPE_USER(SimpleStruct);
-
 template <typename T>
 void clone(const unique_ptr<T>& src, unique_ptr<T>& dst) {
     if (!src)
         dst.reset();
     else
-        dst = make_unique<T>(*src);
+        dst.reset(new T(*src));
 }
 
 class Custom {
@@ -75,7 +71,7 @@ class Custom {
         print_created(this, value);
     }
     Custom(double value, string str)
-        : value_{value}, str_{make_unique<string>(str)} {
+        : value_{value}, str_{unique_ptr<string>(new string(str))} {
         print_created(this, value, str);
     }
     Custom(const Custom& other) {
@@ -150,6 +146,12 @@ class Custom {
     std::unique_ptr<string> str_;
 };
 
+}  // namespace
+
+#if defined(PYBIND11_CPP14)
+
+PYBIND11_NUMPY_DTYPE_USER(CustomStr);
+PYBIND11_NUMPY_DTYPE_USER(SimpleStruct);
 PYBIND11_NUMPY_DTYPE_USER(Custom);
 
 TEST_SUBMODULE(numpy_dtype_user, m) {
@@ -165,7 +167,7 @@ TEST_SUBMODULE(numpy_dtype_user, m) {
         .def(py::init<const char*>())
         .def("__str__", &CustomStr::str)
         .def("__repr__", &CustomStr::str)
-        .def_ufunc_cast([](const CustomStr& in) -> double {
+        .def_ufunc_cast([](const CustomStr&) -> double {
             py::pybind11_fail("Cannot cast");
         })
         .def(py::self == py::self);
@@ -231,3 +233,11 @@ TEST_SUBMODULE(numpy_dtype_user, m) {
         // Define this for checking logicals.
         .def_loop<bool>([](bool a, bool b) { return a == b; });
 }
+
+#else  // defined(PYBIND11_CPP14)
+
+TEST_SUBMODULE(numpy_dtype_user, m) {
+    m.attr("DISABLED") = true;
+}
+
+#endif  // defined(PYBIND11_CPP14)

tests/test_numpy_dtype_user.py

@@ -1,21 +1,25 @@
 import pytest
 
 from pybind11_tests import ConstructorStats
+from pybind11_tests import numpy_dtype_user as m
 
-pytestmark = pytest.requires_numpy
-
+np = None
 with pytest.suppress(ImportError):
     import numpy as np
+    import sys
+    sys.stderr.write("numpy version: {} {}\n".format(
+        np.version.full_version, np.version.git_revision))
 
-    from pybind11_tests import numpy_dtype_user as m
-    stats = ConstructorStats.get(m.Custom)
+pytestmark = pytest.mark.skipif(
+    not np or hasattr(m, "DISABLED"), reason="requires numpy and C++ >= 14")
 
 
 def test_scalar_meta():
     """Tests basic metadata."""
     assert issubclass(m.Custom, np.generic)
     assert isinstance(np.dtype(m.Custom), np.dtype)
 
+
 def test_scalar_ctor():
     """Tests instance lifetime management since we had to redo the instance
     registry to inherit from `np.generic` :( """
@@ -26,8 +30,10 @@ def test_scalar_ctor():
     del c
     del c1
     pytest.gc_collect()
+    stats = ConstructorStats.get(m.Custom)
     assert stats.alive() == 0
 
+
 def test_scalar_op():
     """Tests scalar operators."""
     a = m.Custom(1)
@@ -56,6 +62,7 @@ def test_scalar_op():
     assert m.same(a == b, m.CustomStr("6 == 2 && '' == ''"))
     assert m.same(a < b, False)
 
+
 def test_array_creation():
     # Zeros.
     x = np.zeros((2, 2), dtype=m.Custom)
@@ -68,8 +75,10 @@ def test_array_creation():
     x = np.array([m.Custom(10), 1.])
     assert x.dtype == object
     # - At present, we will be leaking memory. This doesn't show up in instance
-    # count, since these items are only mutated via `operator=`; however, we're
-    # gonna be leaking.
+    # count, since these items are only mutated via `operator=`; however, it will
+    # still be the case for resizing.
+    # See https://github.com/numpy/numpy/issues/10721 for more information.
+
 
 def check_array(actual, expected):
     """Checks if two arrays are exactly similar (shape, type, and data)."""
@@ -82,6 +91,7 @@ def check_array(actual, expected):
         return False
     return True
 
+
 def test_array_cast():
     def check(x, dtype):
         dx = x.astype(dtype)
@@ -103,6 +113,7 @@ def check(x, dtype):
     dx = check(x, m.Custom)
     assert check_array(dx, [m.Custom(1), m.Custom(10), m.Custom(100)])
 
+
 def test_array_cast_implicit():
     a = np.array([1.]).astype(m.Custom)
     # - We registered `Custom{} + double{}`.
@@ -139,6 +150,7 @@ def test_array_cast_implicit():
     assert not check_array(d, [ds])
     assert check_array(d, [m.Custom(100)])
 
+
 def test_array_ufunc():
     x = np.array([m.Custom(4)])
     y = np.array([m.Custom(2, "World")])