python-native: When a base class is unpublished, now looks recursively

for published base classes to inherit from

This also required changing interrogatedb to record hierarchy for
unpublished classes

Author: rdb

src/interrogate/interfaceMakerPythonNative.cxx

@@ -2080,15 +2080,7 @@ write_module_class(ostream &out, Object *obj) {
   }
 
   std::vector<CPPType*> bases;
-  for (di = 0; di < num_derivations; di++) {
-    TypeIndex d_type_Index = obj->_itype.get_derivation(di);
-    if (!interrogate_type_is_unpublished(d_type_Index)) {
-      const InterrogateType &d_itype = idb->get_type(d_type_Index);
-      if (is_cpp_type_legal(d_itype._cpptype)) {
-        bases.push_back(d_itype._cpptype);
-      }
-    }
-  }
+  get_legal_bases(obj->_itype, bases);
 
   {
     SlottedFunctions::iterator rfi;
@@ -8161,6 +8153,27 @@ is_cpp_type_legal(CPPType *in_ctype) {
 
   return false;
 }
+
+/**
+ * Returns a list of base classes.  If one of the base classes is illegal,
+ * uses that class' bases.
+ */
+void InterfaceMakerPythonNative::
+get_legal_bases(const InterrogateType &itype, std::vector<CPPType*> &result) {
+  int num_derivations = itype.number_of_derivations();
+  for (int di = 0; di < num_derivations; ++di) {
+    TypeIndex d_type_Index = itype.get_derivation(di);
+
+    InterrogateDatabase *idb = InterrogateDatabase::get_ptr();
+    const InterrogateType &d_itype = idb->get_type(d_type_Index);
+    if (!interrogate_type_is_unpublished(d_type_Index) && is_cpp_type_legal(d_itype._cpptype)) {
+      result.push_back(d_itype._cpptype);
+    } else {
+      get_legal_bases(d_itype, result);
+    }
+  }
+}
+
 /**
 
  */

src/interrogate/interfaceMakerPythonNative.h

@@ -196,6 +196,7 @@ class InterfaceMakerPythonNative : public InterfaceMakerPython {
   bool is_remap_coercion_possible(FunctionRemap *remap);
   bool is_function_legal(Function *func);
   bool is_cpp_type_legal(CPPType *ctype);
+  void get_legal_bases(const InterrogateType &itype, std::vector<CPPType*> &result);
   bool isExportThisRun(CPPType *ctype);
   bool isExportThisRun(Function *func);
   bool isFunctionWithThis( Function *func);

src/interrogate/interrogateBuilder.cxx

@@ -2587,6 +2587,25 @@ define_struct_type(InterrogateType &itype, CPPStructType *cpptype,
   if (TypeManager::involves_unpublished(cpptype)) {
     itype._flags &= ~InterrogateType::F_fully_defined;
     itype._flags |= InterrogateType::F_unpublished;
+
+    // However, we still must record its base classes, so that we can record
+    // the full type hierarchy where an intermediate type is not published.
+    if (itype._derivations.empty()) {
+      for (const CPPStructType::Base &base : cpptype->_derivation) {
+        if (base._vis <= V_public) {
+          CPPType *base_type = TypeManager::resolve_type(base._base, cpptype->_scope);
+          TypeIndex base_index = get_type(base_type, false);
+          if (base_index != 0) {
+            InterrogateType::Derivation d;
+            d._flags = 0;
+            d._base = base_index;
+            d._upcast = 0;
+            d._downcast = 0;
+            itype._derivations.push_back(d);
+          }
+        }
+      }
+    }
     return;
   }
   if (TypeManager::involves_protected(cpptype)) {