Detect multiple base classes and fail if found

Author: jagerman

include/pybind11/pybind11.h

@@ -820,6 +820,34 @@ struct extract_first<Predicate, T, Ts...> {
     >::type;
 };
 
+
+template <template<class> class Predicate, class... Ts>
+struct extract_all;
+
+template <template<class> class Predicate>
+struct extract_all<Predicate> {
+    using tuple = std::tuple<>;
+};
+
+template <template<class> class Predicate, class T, class... Ts>
+struct extract_all<Predicate, T, Ts...> {
+    using tuple = typename std::conditional<
+        Predicate<T>::value,
+        decltype(std::tuple_cat(std::declval<std::tuple<T>>(), std::declval<typename extract_all<Predicate, Ts...>::tuple>())),
+        typename extract_all<Predicate, Ts...>::tuple
+    >::type;
+};
+
+template <typename... BaseTypes> struct class_bases;
+// Multiple inheritance support, if eventually supported, would use this specialization:
+//template <typename Base1, typename Base2, typename... Bases> struct class_bases<Base1, Base2, Bases...> {
+//    static inline void add_to(detail::type_record &) {}
+//};
+template <typename Base> struct class_bases<Base> { static inline void add_to(detail::type_record &record) { record.base_type = &typeid(Base); } };
+template <> struct class_bases<> { static inline void add_to(detail::type_record &) {} };
+
+template <typename... BaseTypes> struct class_bases<std::tuple<BaseTypes...>> : class_bases<BaseTypes...> {};
+
 NAMESPACE_END(detail)
 
 template <typename type_, typename... options>
@@ -828,7 +856,7 @@ class class_ : public detail::generic_type {
     template <typename T> using is_subtype = std::is_base_of<type_, T>;
     template <typename T> using is_supertype = std::is_base_of<T, type_>;
     using extracted_holder = detail::extract_first<is_holder, options...>;
-    using extracted_base = detail::extract_first<is_supertype, options...>;
+    using extracted_bases = typename detail::extract_all<is_supertype, options...>::tuple;
 
 public:
     using type = type_;
@@ -844,9 +872,12 @@ class class_ : public detail::generic_type {
     static_assert(0 == sizeof...(options) -
         (int) has_alias -
         (int) !std::is_void<typename extracted_holder::type>::value -
-        (int) !std::is_void<typename extracted_base::type>::value,
+        (int) std::tuple_size<extracted_bases>::value,
         "Unknown/invalid class_ template parameters provided");
 
+    static_assert(std::tuple_size<extracted_bases>::value <= 1,
+            "Invalid class_ base types: multiple inheritance is not supported");
+
     PYBIND11_OBJECT(class_, detail::generic_type, PyType_Check)
 
     template <typename... Extra>
@@ -860,8 +891,7 @@ class class_ : public detail::generic_type {
         record.init_holder = init_holder;
         record.dealloc = dealloc;
 
-        if (!std::is_void<typename extracted_base::type>::value)
-            record.base_type = &typeid(typename extracted_base::type);
+        detail::class_bases<extracted_bases>::add_to(record);
 
         /* Process optional arguments, if any */
         detail::process_attributes<Extra...>::init(extra..., &record);

tests/test_class_args.cpp

@@ -58,6 +58,10 @@ CHECK_HOLDER(6, shared); CHECK_HOLDER(7, shared); CHECK_HOLDER(8, shared);
 //// Invalid option (not a subclass or holder)
 //typedef py::class_<BreaksBase<-5>, BreaksTramp<-4>> Breaks5;
 //CHECK_BROKEN(5);
+//// Invalid option: multiple inheritance not supported:
+//template <> struct BreaksBase<-8> : BreaksBase<-6>, BreaksBase<-7> {};
+//typedef py::class_<BreaksBase<-8>, BreaksBase<-6>, BreaksBase<-7>> Breaks8;
+//CHECK_BROKEN(8);
 
 test_initializer class_args([](py::module &m) {
     // Just test that this compiled okay