Add ability to add NumPy user-defined types

Author: EricCousineau-TRI

include/pybind11/cast.h

@@ -1826,13 +1826,20 @@ template <typename T> struct move_if_unreferenced<T, enable_if_t<all_of<
 >::value>> : std::true_type {};
 template <typename T> using move_never = negation<move_common<T>>;
 
+template <typename type, typename SFINAE = void>
+struct cast_is_known_safe : public std::false_type {};
+
+template <typename type>
+struct cast_is_known_safe<type,
+    enable_if_t<std::is_base_of<type_caster_generic, make_caster<type>>::value>> : public std::true_type {};
+
 // Detect whether returning a `type` from a cast on type's type_caster is going to result in a
 // reference or pointer to a local variable of the type_caster.  Basically, only
 // non-reference/pointer `type`s and reference/pointers from a type_caster_generic are safe;
 // everything else returns a reference/pointer to a local variable.
 template <typename type> using cast_is_temporary_value_reference = bool_constant<
     (std::is_reference<type>::value || std::is_pointer<type>::value) &&
-    !std::is_base_of<type_caster_generic, make_caster<type>>::value
+    !cast_is_known_safe<type>::value
 >;
 
 // When a value returned from a C++ function is being cast back to Python, we almost always want to

include/pybind11/detail/inference.h

@@ -0,0 +1,147 @@
+/*
+    pybind11/detail/inference.h -- Simple inference for generic functions
+
+    Copyright (c) 2018 Eric Cousineau <[email protected]>
+
+    All rights reserved. Use of this source code is governed by a
+    BSD-style license that can be found in the LICENSE file.
+*/
+
+#pragma once
+
+#include "common.h"
+
+NAMESPACE_BEGIN(PYBIND11_NAMESPACE)
+NAMESPACE_BEGIN(detail)
+
+// SFINAE for functors.
+// N.B. This *only* distinguished between function / method pointers and
+// lambda objects. It does *not* distinguish among other types.
+template <typename Func, typename T = void>
+using enable_if_lambda_t = enable_if_t<!std::is_function<intrinsic_t<Func>>::value, T>;
+
+template <size_t N, size_t K, typename T, typename ... Ts>
+struct type_at_impl {
+  using type = typename type_at_impl<N, K + 1, Ts...>::type;
+};
+
+template <size_t N, typename T, typename ... Ts>
+struct type_at_impl<N, N, T, Ts...> {
+  using type = T;
+};
+
+// Convenient mechanism for passing sets of arguments.
+template <typename ... Ts>
+struct type_pack {
+    static constexpr int size = sizeof...(Ts);
+
+    template <template <typename...> class Tpl>
+    using bind = Tpl<Ts...>;
+
+    template <size_t N>
+    struct type_at_internal {
+      static_assert(N < size, "Invalid type index");
+      using type = typename type_at_impl<N, 0, Ts...>::type;
+    };
+
+    template <size_t N>
+    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...>{};
+}
+
+template <template <typename> class Apply, typename... T>
+auto type_pack_apply(type_pack<T...> = {}) {
+  return type_pack<Apply<T>...>{};
+}
+
+struct function_inference {
+    // Collects both a functor object and its signature for ease of inference.
+    template <typename Func_, typename ReturnT, typename ... ArgsT>
+    struct inferred_info {
+      // TODO(eric.cousineau): Ensure that this permits copy elision when combined
+      // with `std::forward<Func>(func)`, while still behaving well with primitive
+      // types.
+      using Func = std::decay_t<Func_>;
+      Func func;
+
+      using Return = ReturnT;
+      using Args = type_pack<ArgsT...>;
+    };
+
+    // Factory method for `inferred_info<>`, to be used by `run`.
+    template <typename Return, typename ... Args, typename Func>
+    static auto make_inferred_info(Func&& func, Return (*infer)(Args...) = nullptr) {
+      (void)infer;
+      return inferred_info<Func, Return, Args...>{std::forward<Func>(func)};
+    }
+
+    // Infers `inferred_info<>` from a function pointer.
+    template <typename Return, typename ... Args>
+    static auto run(Return (*func)(Args...)) {
+      return make_inferred_info<Return, Args...>(func);
+    }
+
+    // Infers `inferred_info<>` from a mutable method pointer.
+    template <typename Return, typename Class, typename ... Args>
+    static auto run(Return (Class::*method)(Args...)) {
+      auto func = [method](Class& self, Args... args) {
+        return (self.*method)(std::forward<Args>(args)...);
+      };
+      return make_inferred_info<Return, Class&, Args...>(func);
+    }
+
+    // Infers `inferred_info<>` from a const method pointer.
+    template <typename Return, typename Class, typename ... Args>
+    static auto run(Return (Class::*method)(Args...) const) {
+      auto func = [method](const Class& self, Args... args) {
+        return (self.*method)(std::forward<Args>(args)...);
+      };
+      return make_inferred_info<Return, const Class&, Args...>(func);
+    }
+
+    // Helpers for general functor objects.
+    struct infer_helper {
+      // Removes class from mutable method pointer for inferring signature
+      // of functor.
+      template <typename Class, typename Return, typename ... Args>
+      static auto remove_class_from_ptr(Return (Class::*)(Args...)) {
+        using Ptr = Return (*)(Args...);
+        return Ptr{};
+      }
+
+      // Removes class from const method pointer for inferring signature of functor.
+      template <typename Class, typename Return, typename ... Args>
+      static auto remove_class_from_ptr(Return (Class::*)(Args...) const) {
+        using Ptr = Return (*)(Args...);
+        return Ptr{};
+      }
+
+      // Infers funtion pointer from functor.
+      // @pre `Func` must have only *one* overload of `operator()`.
+      template <typename Func>
+      static auto infer_function_ptr() {
+        return remove_class_from_ptr(&Func::operator());
+      }
+    };
+
+    // Infers `inferred_info<>` from a generic functor.
+    template <typename Func, typename = detail::enable_if_lambda_t<Func>>
+    static auto run(Func&& func) {
+      return make_inferred_info(
+          std::forward<Func>(func),
+          infer_helper::infer_function_ptr<std::decay_t<Func>>());
+    }
+};
+
+#endif  // defined(PYBIND_CPP14)
+
+NAMESPACE_END(detail)
+
+NAMESPACE_END(PYBIND11_NAMESPACE)

include/pybind11/detail/internals.h

@@ -87,13 +87,15 @@ struct internals {
 /// Additional type information which does not fit into the PyTypeObject.
 /// Changes to this struct also require bumping `PYBIND11_INTERNALS_VERSION`.
 struct type_info {
+    using implicit_conversion_func = PyObject *(*)(PyObject *, PyTypeObject *);
+
     PyTypeObject *type;
     const std::type_info *cpptype;
     size_t type_size, holder_size_in_ptrs;
     void *(*operator_new)(size_t);
     void (*init_instance)(instance *, holder_erased);
     void (*dealloc)(value_and_holder &v_h);
-    std::vector<PyObject *(*)(PyObject *, PyTypeObject *)> implicit_conversions;
+    std::vector<implicit_conversion_func> implicit_conversions;
     std::vector<std::pair<const std::type_info *, void *(*)(void *)>> implicit_casts;
     std::vector<bool (*)(PyObject *, void *&)> *direct_conversions;
     buffer_info *(*get_buffer)(PyObject *, void *) = nullptr;

include/pybind11/eigen.h

@@ -114,7 +114,7 @@ template <typename PlainObjectType, int Options, typename StrideType>
 struct eigen_extract_stride<Eigen::Ref<PlainObjectType, Options, StrideType>> { using type = StrideType; };
 
 template <typename Scalar> bool is_pyobject_() {
-    return static_cast<pybind11::detail::npy_api::constants>(npy_format_descriptor<Scalar>::value) == npy_api::NPY_OBJECT_;
+    return static_cast<pybind11::detail::npy_api::constants>(npy_format_descriptor<Scalar>::dtype().num()) == npy_api::NPY_OBJECT_;
 }
 
 // Helper struct for extracting information from an Eigen type
@@ -223,7 +223,7 @@ template <typename props> handle eigen_array_cast(typename props::Type const &sr
     constexpr ssize_t elem_size = sizeof(typename props::Scalar);
     array a;
     using Scalar = typename props::Type::Scalar;
-    bool is_pyoject = static_cast<pybind11::detail::npy_api::constants>(npy_format_descriptor<Scalar>::value) == npy_api::NPY_OBJECT_;
+    bool is_pyoject = static_cast<pybind11::detail::npy_api::constants>(npy_format_descriptor<Scalar>::dtype().num()) == npy_api::NPY_OBJECT_;
 
     if (!is_pyoject) {
         if (props::vector)