Use py::init(...) for py::init<...>()

This simplifies the py::init<...> implementations slightly (especially
the Base-vs-Alias one), while also no longer requiring that a class
support placement new to be able to use `py::init<...>()`.

This also exposes a few warnings (fixed here) from deleting a pointer
to a base class with virtual functions but without a virtual
destructor.  These look like legitimate warnings that we shouldn't
suppress; this adds virtual destructors to the appropriate classes.

Author: jagerman

include/pybind11/pybind11.h

@@ -1364,8 +1364,7 @@ template <typename... Args> struct init {
     template <typename Class, typename... Extra, enable_if_t<!Class::has_alias, int> = 0>
     static void execute(Class &cl, const Extra&... extra) {
         using Base = typename Class::type;
-        /// Function which calls a specific C++ in-place constructor
-        cl.def("__init__", [](Base *self_, Args... args) { new (self_) Base(args...); }, extra...);
+        cl.def(pybind11::init([](Args... args) { return new Base(args...); }), extra...);
     }
 
     template <typename Class, typename... Extra,
@@ -1374,13 +1373,10 @@ template <typename... Args> struct init {
     static void execute(Class &cl, const Extra&... extra) {
         using Base = typename Class::type;
         using Alias = typename Class::type_alias;
-        handle cl_type = cl;
-        cl.def("__init__", [cl_type](handle self_, Args... args) {
-                if (self_.get_type().is(cl_type))
-                    new (self_.cast<Base *>()) Base(args...);
-                else
-                    new (self_.cast<Alias *>()) Alias(args...);
-            }, extra...);
+        cl.def(pybind11::init(
+                [](Args... args) { return new Base(args...); },
+                [](Args... args) { return new Alias(args...); }),
+                extra...);
     }
 
     template <typename Class, typename... Extra,
@@ -1395,7 +1391,8 @@ template <typename... Args> struct init_alias {
               enable_if_t<Class::has_alias && std::is_constructible<typename Class::type_alias, Args...>::value, int> = 0>
     static void execute(Class &cl, const Extra&... extra) {
         using Alias = typename Class::type_alias;
-        cl.def("__init__", [](Alias *self_, Args... args) { new (self_) Alias(args...); }, extra...);
+        cl.def(pybind11::init([](Args... args) { return new Alias(args...); }),
+                extra...);
     }
 };
 

tests/test_class.py

@@ -141,20 +141,17 @@ class SubAliased(m.AliasedHasOpNewDelSize):
         d = m.HasOpNewDelBoth()
     assert capture == """
         A new 8
-        A placement-new 8
         B new 4
-        B placement-new 4
         D new 32
-        D placement-new 32
     """
     sz_alias = str(m.AliasedHasOpNewDelSize.size_alias)
     sz_noalias = str(m.AliasedHasOpNewDelSize.size_noalias)
     with capture:
         c = m.AliasedHasOpNewDelSize()
         c2 = SubAliased()
     assert capture == (
-        "C new " + sz_alias + "\nC placement-new " + sz_noalias + "\n" +
-        "C new " + sz_alias + "\nC placement-new " + sz_alias + "\n"
+        "C new " + sz_noalias + "\n" +
+        "C new " + sz_alias + "\n"
     )
 
     with capture:

tests/test_multiple_inheritance.py

@@ -71,9 +71,9 @@ def __init__(self, i, j):
             MI2.__init__(self, i, j)
 
     class MI4(MI3, m.Base2):
-        def __init__(self, i, j, k):
-            MI3.__init__(self, j, k)
-            m.Base2.__init__(self, i)
+        def __init__(self, i, j):
+            MI3.__init__(self, i, j)
+            # m.Base2 already initialized via MI2
 
     class MI5(m.Base2, B1, m.Base1):
         def __init__(self, i, j):
@@ -127,10 +127,10 @@ def __init__(self, i):
     assert mi3.foo() == 5
     assert mi3.bar() == 6
 
-    mi4 = MI4(7, 8, 9)
+    mi4 = MI4(7, 8)
     assert mi4.v() == 1
-    assert mi4.foo() == 8
-    assert mi4.bar() == 7
+    assert mi4.foo() == 7
+    assert mi4.bar() == 8
 
     mi5 = MI5(10, 11)
     assert mi5.v() == 1

tests/test_virtual_functions.cpp

@@ -179,6 +179,7 @@ public: \
         return say_something(1) + " " + std::to_string(unlucky_number()); \
     }
 A_METHODS
+    virtual ~A_Repeat() = default;
 };
 class B_Repeat : public A_Repeat {
 #define B_METHODS \
@@ -203,7 +204,7 @@ D_METHODS
 };
 
 // Base classes for templated inheritance trampolines.  Identical to the repeat-everything version:
-class A_Tpl { A_METHODS };
+class A_Tpl { A_METHODS; virtual ~A_Tpl() = default; };
 class B_Tpl : public A_Tpl { B_METHODS };
 class C_Tpl : public B_Tpl { C_METHODS };
 class D_Tpl : public C_Tpl { D_METHODS };
@@ -314,6 +315,7 @@ void initialize_inherited_virtuals(py::module &m) {
 struct Base {
     /* for some reason MSVC2015 can't compile this if the function is pure virtual */
     virtual std::string dispatch() const { return {}; };
+    virtual ~Base() = default;
 };
 
 struct DispatchIssue : Base {
@@ -416,6 +418,7 @@ TEST_SUBMODULE(virtual_functions, m) {
         virtual std::string &str_ref() { return v; }
         virtual A A_value() { return a; }
         virtual A &A_ref() { return a; }
+        virtual ~OverrideTest() = default;
     };
 
     class PyOverrideTest : public OverrideTest {