Simplify alias-from-base construction logic

Author: jagerman

include/pybind11/detail/init.h

@@ -45,6 +45,8 @@ template <typename Class> using Cpp = typename Class::type;
 template <typename Class> using Alias = typename Class::type_alias;
 template <typename Class> using Holder = typename Class::holder_type;
 
+template <typename Class> using is_alias_constructible = std::is_constructible<Alias<Class>, Cpp<Class> &&>;
+
 // Takes a Cpp pointer and returns true if it actually is a polymorphic Alias instance.
 template <typename Class, enable_if_t<Class::has_alias, int> = 0>
 bool is_alias(Cpp<Class> *ptr) {
@@ -59,15 +61,17 @@ constexpr bool is_alias(void *) { return false; }
 // constructed from an rvalue reference of the base Cpp type.  This means that Alias classes
 // can, when appropriate, simply define a `Alias(Cpp &&)` constructor rather than needing to
 // inherit all the base class constructors.
-template <typename Class, enable_if_t<std::is_constructible<Alias<Class>, Cpp<Class> &&>::value, int> = 0>
-bool construct_alias_from_cpp(value_and_holder &v_h, Cpp<Class> &&base) {
+template <typename Class>
+void construct_alias_from_cpp(std::true_type /*is_alias_constructible*/,
+                              value_and_holder &v_h, Cpp<Class> &&base) {
     deallocate(v_h) = new Alias<Class>(std::move(base));
-    return true;
 }
-// Fallback of the above for aliases without an `Alias(Cpp &&) constructor; does nothing and
-// returns false to signal the non-availability of the special constructor.
-template <typename Class, enable_if_t<!std::is_constructible<Alias<Class>, Cpp<Class> &&>::value, int> = 0>
-constexpr bool construct_alias_from_cpp(value_and_holder &, Cpp<Class> &&) { return false; }
+template <typename Class>
+[[noreturn]] void construct_alias_from_cpp(std::false_type /*!is_alias_constructible*/,
+                                           value_and_holder &, Cpp<Class> &&) {
+    throw type_error("pybind11::init(): unable to convert returned instance to required "
+                     "alias class: no `Alias<Class>(Class &&)` constructor available");
+}
 
 // Error-generating fallback for factories that don't match one of the below construction
 // mechanisms.
@@ -101,15 +105,13 @@ void construct(value_and_holder &v_h, Cpp<Class> *ptr, bool need_alias) {
         v_h.type->dealloc(v_h); // Destroys the moved-out holder remains, resets value ptr to null
         v_h.set_instance_registered(false);
 
-        if (construct_alias_from_cpp<Class>(v_h, std::move(*ptr)))
-            return;
-        else
-            throw type_error("pybind11::init(): pointer could not be cast or "
-                             "converted to an alias instance");
+        construct_alias_from_cpp<Class>(is_alias_constructible<Class>{}, v_h, std::move(*ptr));
+    }
+    else {
+        // Otherwise the type isn't inherited, so we don't need an Alias and can just store the Cpp
+        // pointer directory:
+        deallocate(v_h) = ptr;
     }
-    // Otherwise the type isn't inherited, so we don't need an Alias and can just store the Cpp
-    // pointer directory:
-    deallocate(v_h) = ptr;
 }
 
 // Pointer return v2: a factory that always returns an alias instance ptr.  We simply take over
@@ -143,14 +145,10 @@ template <typename Class>
 void construct(value_and_holder &v_h, Cpp<Class> &&result, bool need_alias) {
     static_assert(std::is_move_constructible<Cpp<Class>>::value,
         "pybind11::init() return-by-value factory function requires a movable class");
-    if (Class::has_alias && need_alias) {
-        if (!construct_alias_from_cpp<Class>(v_h, std::move(result)))
-            throw type_error("pybind11::init(): unable to convert returned instance to "
-                             "required alias class: no `Alias<Class>(Class &&)` constructor available");
-    }
-    else {
+    if (Class::has_alias && need_alias)
+        construct_alias_from_cpp<Class>(is_alias_constructible<Class>{}, v_h, std::move(result));
+    else
         deallocate(v_h) = new Cpp<Class>(std::move(result));
-    }
 }
 
 // return-by-value version 2: returning a value of the alias type itself.  We move-construct an