Fail to compile with MI via class_ ctor parameters

We can't support this for classes from imported modules (which is the
primary purpose of a ctor argument base class) because we *have* to
have both parent and derived to properly extract a multiple-inheritance
base class pointer from a derived class pointer.

We could support this for actual `class_<Base, ...> instances, but since
in that case the `Base` is already present in the code, it seems more
consistent to simply always require MI to go via template options.

This also adds a new "number_of" template, mostly based on the `count_t`
removed in PR pybind#554, to count the number of satisfied templates; this is
basically just `constexpr_sum`, and uses that except for under MSVC
which doesn't think the constexpr is a constexpr.

Author: jagerman

include/pybind11/attr.h

@@ -333,7 +333,7 @@ template <> struct process_attribute<arg_v> : process_attribute_default<arg_v> {
     }
 };
 
-/// Process a parent class attribute
+/// Process a parent class attribute.  Single inheritance only (class_ itself already guarantees that)
 template <typename T>
 struct process_attribute<T, enable_if_t<is_pyobject<T>::value>> : process_attribute_default<handle> {
     static void init(const handle &h, type_record *r) { r->bases.append(h); }

include/pybind11/common.h

@@ -452,6 +452,16 @@ constexpr size_t constexpr_sum() { return 0; }
 template <typename T, typename... Ts>
 constexpr size_t constexpr_sum(T n, Ts... ns) { return size_t{n} + constexpr_sum(ns...); }
 
+/// Returns the number of the given template types with true ::values
+#if !defined(_MSC_VER)
+template <class... Ts> using number_of = std::integral_constant<size_t, constexpr_sum((size_t) (bool) Ts::value...)>;
+#else
+// MSVC workaround (2015 Update 3 has issues with some member type aliases and the above constexpr)
+template <class... Ts> struct number_of : std::integral_constant<size_t, 0> {};
+template <class T, class... Ts> struct number_of<T, Ts...>
+    : std::integral_constant<size_t, (bool) Ts::value + number_of<Ts...>::value> {};
+#endif
+
 NAMESPACE_BEGIN(constexpr_impl)
 /// Implementation details for constexpr functions
 constexpr int first(int i) { return i; }

include/pybind11/pybind11.h

@@ -885,11 +885,21 @@ class class_ : public detail::generic_type {
 
     template <typename... Extra>
     class_(handle scope, const char *name, const Extra &... extra) {
-        detail::type_record record;
+        using namespace detail;
+
+        // MI can only be specified via class_ template options, not constructor parameters
+        static_assert(
+            none_of<is_pyobject<Extra>...>::value || // no base class arguments, or:
+            (number_of<is_pyobject<Extra>...>::value == 1 &&                   // Exactly one base
+                none_of<is_base<options>...>::value &&                         // no template option bases
+                none_of<std::is_same<multiple_inheritance, Extra>...>::value), // no multiple_inheritance attr
+            "Error: multiple inheritance bases must be specified via class_ template options");
+
+        type_record record;
         record.scope = scope;
         record.name = name;
         record.type = &typeid(type);
-        record.type_size = sizeof(detail::conditional_t<has_alias, type_alias, type>);
+        record.type_size = sizeof(conditional_t<has_alias, type_alias, type>);
         record.instance_size = sizeof(instance_type);
         record.init_holder = init_holder;
         record.dealloc = dealloc;
@@ -900,12 +910,12 @@ class class_ : public detail::generic_type {
         (void) unused;
 
         /* Process optional arguments, if any */
-        detail::process_attributes<Extra...>::init(extra..., &record);
+        process_attributes<Extra...>::init(extra..., &record);
 
-        detail::generic_type::initialize(record);
+        generic_type::initialize(record);
 
         if (has_alias) {
-            auto &instances = pybind11::detail::get_internals().registered_types_cpp;
+            auto &instances = get_internals().registered_types_cpp;
             instances[std::type_index(typeid(type_alias))] = instances[std::type_index(typeid(type))];
         }
     }

tests/test_multiple_inheritance.cpp

@@ -26,23 +26,33 @@ struct Base12 : Base1, Base2 {
     Base12(int i, int j) : Base1(i), Base2(j) { }
 };
 
+struct Base12v2 : Base1, Base2 {
+    Base12v2(int i, int j) : Base1(i), Base2(j) { }
+};
+
 struct MIType : Base12 {
     MIType(int i, int j) : Base12(i, j) { }
 };
 
 test_initializer multiple_inheritance([](py::module &m) {
-    py::class_<Base1>(m, "Base1")
-        .def(py::init<int>())
-        .def("foo", &Base1::foo);
+    py::class_<Base1> b1(m, "Base1");
+    b1.def(py::init<int>())
+      .def("foo", &Base1::foo);
 
-    py::class_<Base2>(m, "Base2")
-        .def(py::init<int>())
-        .def("bar", &Base2::bar);
+    py::class_<Base2> b2(m, "Base2");
+    b2.def(py::init<int>())
+      .def("bar", &Base2::bar);
 
     py::class_<Base12, Base1, Base2>(m, "Base12");
 
     py::class_<MIType, Base12>(m, "MIType")
         .def(py::init<int, int>());
+
+    // Uncommenting this should result in a compile time failure (MI can only be specified via
+    // template parameters because pybind has to know the types involved; see discussion in #742 for
+    // details).
+//    py::class_<Base12v2>(m, "Base12v2", b1, b2)
+//        .def(py::init<int, int>());
 });
 
 /* Test the case where not all base classes are specified,