shiboken2: Refactor handling of invisible top level namespaces

To avoid having to add a
ShibokenGenerator::lookForFunctionsInClassesNotToBeGenerated()
to fix the function issue,
replace ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated()
by several helper functions:

- Add a list of top level invisible namespace to the generators
- Add functions to retrieve enumerations of nested invisible namespaces
  to AbstractMetaClass with recursion helpers.

Task-number: PYSIDE-1075
Change-Id: I421113770e622611caeb221498b872d0a6ba1aeb
Reviewed-by: Christian Tismer <tismer@stackless.com>

7 files changed, 64 insertions, 31 deletions

diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
index 2c693c70e..29c2f153d 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.cpp
@@ -1637,6 +1637,14 @@ bool AbstractMetaClass::isNamespace() const
     return m_typeEntry->isNamespace();
 }
 
+// Is an invisible namespaces whose functions/enums
+// should be mapped to the global space.
+bool AbstractMetaClass::isInvisibleNamespace() const
+{
+    return m_typeEntry->isNamespace() && m_typeEntry->generateCode()
+        && !NamespaceTypeEntry::isVisibleScope(m_typeEntry);
+}
+
 static bool qObjectPredicate(const AbstractMetaClass *c)
 {
     return c->qualifiedCppName() == QLatin1String("QObject");
@@ -2128,6 +2136,22 @@ AbstractMetaEnumValue *AbstractMetaClass::findEnumValue(const QString &enumValue
     return nullptr;
 }
 
+void AbstractMetaClass::getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const
+{
+    for (AbstractMetaEnum *metaEnum : m_enums) {
+        if (!metaEnum->isPrivate() && metaEnum->typeEntry()->generateCode())
+            enumList->append(metaEnum);
+    }
+}
+
+void AbstractMetaClass::getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMetaEnumList *enumList) const
+{
+    if (isNamespace()) {
+        invisibleNamespaceRecursion([enumList](AbstractMetaClass *c) {
+            c->getEnumsToBeGenerated(enumList);
+        });
+    }
+}
 
 static void addExtraIncludeForType(AbstractMetaClass *metaClass, const AbstractMetaType *type)
 {
diff --git a/sources/shiboken2/ApiExtractor/abstractmetalang.h b/sources/shiboken2/ApiExtractor/abstractmetalang.h
index 648c792b3..693ecc4d4 100644
--- a/sources/shiboken2/ApiExtractor/abstractmetalang.h
+++ b/sources/shiboken2/ApiExtractor/abstractmetalang.h
@@ -1426,6 +1426,8 @@ public:
 
     AbstractMetaEnum *findEnum(const QString &enumName);
     AbstractMetaEnumValue *findEnumValue(const QString &enumName);
+    void getEnumsToBeGenerated(AbstractMetaEnumList *enumList) const;
+    void getEnumsFromInvisibleNamespacesToBeGenerated(AbstractMetaEnumList *enumList) const;
 
     QString fullName() const
     {
@@ -1476,6 +1478,7 @@ public:
     QString package() const;
 
     bool isNamespace() const;
+    bool isInvisibleNamespace() const;
 
     bool isQObject() const;
 
@@ -1672,6 +1675,9 @@ public:
     SourceLocation sourceLocation() const;
     void setSourceLocation(const SourceLocation &sourceLocation);
 
+    template <class Function>
+    void invisibleNamespaceRecursion(Function f) const;
+
 private:
 #ifndef QT_NO_DEBUG_STREAM
     void format(QDebug &d) const;
@@ -1719,4 +1725,15 @@ private:
 Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::FunctionQueryOptions)
 Q_DECLARE_OPERATORS_FOR_FLAGS(AbstractMetaClass::OperatorQueryOptions)
 
+template <class Function>
+void AbstractMetaClass::invisibleNamespaceRecursion(Function f) const
+{
+    for (auto ic : m_innerClasses) {
+        if (ic->isInvisibleNamespace()) {
+            f(ic);
+            ic->invisibleNamespaceRecursion(f);
+        }
+    }
+}
+
 #endif // ABSTRACTMETALANG_H
diff --git a/sources/shiboken2/generator/generator.cpp b/sources/shiboken2/generator/generator.cpp
index 926840235..e39ead258 100644
--- a/sources/shiboken2/generator/generator.cpp
+++ b/sources/shiboken2/generator/generator.cpp
@@ -168,7 +168,7 @@ struct Generator::GeneratorPrivate
     QStringList instantiatedContainersNames;
     QVector<const AbstractMetaType *> instantiatedContainers;
     QVector<const AbstractMetaType *> instantiatedSmartPointers;
-
+    AbstractMetaClassList m_invisibleTopNamespaces;
 };
 
 Generator::Generator() : m_d(new GeneratorPrivate)
@@ -191,6 +191,15 @@ bool Generator::setup(const ApiExtractor &extractor)
 
     collectInstantiatedContainersAndSmartPointers();
 
+    for (auto c : classes()) {
+        if (c->enclosingClass() == nullptr && c->isInvisibleNamespace()) {
+            m_d->m_invisibleTopNamespaces.append(c);
+            c->invisibleNamespaceRecursion([&](AbstractMetaClass *ic) {
+                m_d->m_invisibleTopNamespaces.append(ic);
+            });
+        }
+    }
+
     return doSetup();
 }
 
@@ -344,6 +353,11 @@ const AbstractMetaClassList &Generator::classes() const
     return m_d->apiextractor->classes();
 }
 
+const AbstractMetaClassList &Generator::invisibleTopNamespaces() const
+{
+    return m_d->m_invisibleTopNamespaces;
+}
+
 AbstractMetaClassList Generator::classesTopologicalSorted(const Dependencies &additionalDependencies) const
 {
     return m_d->apiextractor->classesTopologicalSorted(additionalDependencies);
diff --git a/sources/shiboken2/generator/generator.h b/sources/shiboken2/generator/generator.h
index 324bb8474..cf6df528f 100644
--- a/sources/shiboken2/generator/generator.h
+++ b/sources/shiboken2/generator/generator.h
@@ -218,6 +218,9 @@ public:
     /// Returns the classes used to generate the binding code.
     const AbstractMetaClassList &classes() const;
 
+    /// Returns the top namespace made invisible
+    const AbstractMetaClassList &invisibleTopNamespaces() const;
+
     /// Returns the output directory
     QString outputDirectory() const;
 
diff --git a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
index 676cb4985..a366dfa1c 100644
--- a/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/cppgenerator.cpp
@@ -390,8 +390,7 @@ void CppGenerator::generateClass(QTextStream &s, const GeneratorContext &classCo
     }
 
     AbstractMetaEnumList classEnums = metaClass->enums();
-    for (AbstractMetaClass *innerClass : innerClasses)
-        lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
+    metaClass->getEnumsFromInvisibleNamespacesToBeGenerated(&classEnums);
 
     //Extra includes
     s << "\n// Extra includes\n";
@@ -1390,9 +1389,7 @@ void CppGenerator::writeConverterFunctions(QTextStream &s, const AbstractMetaCla
     s << "// Type conversion functions.\n\n";
 
     AbstractMetaEnumList classEnums = metaClass->enums();
-    const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
-    for (AbstractMetaClass *innerClass : innerClasses)
-        lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
+    metaClass->getEnumsFromInvisibleNamespacesToBeGenerated(&classEnums);
     if (!classEnums.isEmpty())
         s << "// Python to C++ enum conversion.\n";
     for (const AbstractMetaEnum *metaEnum : qAsConst(classEnums))
@@ -5334,9 +5331,7 @@ void CppGenerator::writeClassRegister(QTextStream &s,
     }
 
     AbstractMetaEnumList classEnums = metaClass->enums();
-    const AbstractMetaClassList &innerClasses = metaClass->innerClasses();
-    for (AbstractMetaClass *innerClass : innerClasses)
-        lookForEnumsInClassesNotToBeGenerated(classEnums, innerClass);
+    metaClass->getEnumsFromInvisibleNamespacesToBeGenerated(&classEnums);
 
     ErrorCode errorCode(QString::fromLatin1(""));
     writeEnumsInitialization(s, classEnums);
@@ -5843,11 +5838,8 @@ bool CppGenerator::finishGeneration()
 
     // Global enums
     AbstractMetaEnumList globalEnums = this->globalEnums();
-    for (const AbstractMetaClass *metaClass : classes()) {
-        const AbstractMetaClass *encClass = metaClass->enclosingClass();
-        if (!encClass || !NamespaceTypeEntry::isVisibleScope(encClass->typeEntry()))
-            lookForEnumsInClassesNotToBeGenerated(globalEnums, metaClass);
-    }
+    for (const AbstractMetaClass *nsp : invisibleTopNamespaces())
+        nsp->getEnumsToBeGenerated(&globalEnums);
 
     TypeDatabase *typeDb = TypeDatabase::instance();
     const TypeSystemTypeEntry *moduleEntry = typeDb->defaultTypeSystemType();
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
index b2c762115..3606f0af0 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.cpp
@@ -334,20 +334,6 @@ bool ShibokenGenerator::shouldWriteVirtualMethodNative(const AbstractMetaFunctio
             && (func->attributes() & AbstractMetaAttributes::FinalCppMethod) == 0);
 }
 
-void ShibokenGenerator::lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList &enumList, const AbstractMetaClass *metaClass)
-{
-    Q_ASSERT(metaClass);
-    // if a scope is not to be generated, collect its enums into the parent scope
-    if (!NamespaceTypeEntry::isVisibleScope(metaClass->typeEntry())) {
-        for (AbstractMetaEnum *metaEnum : metaClass->enums()) {
-            if (!metaEnum->isPrivate() && metaEnum->typeEntry()->generateCode()
-                && !enumList.contains(metaEnum)) {
-                enumList.append(metaEnum);
-            }
-        }
-    }
-}
-
 QString ShibokenGenerator::wrapperName(const AbstractMetaClass *metaClass) const
 {
     Q_ASSERT(shouldGenerateCppWrapper(metaClass));
diff --git a/sources/shiboken2/generator/shiboken2/shibokengenerator.h b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
index 83e7cf5b9..33da01a3a 100644
--- a/sources/shiboken2/generator/shiboken2/shibokengenerator.h
+++ b/sources/shiboken2/generator/shiboken2/shibokengenerator.h
@@ -228,9 +228,6 @@ protected:
     /// Condition to call WriteVirtualMethodNative. Was extracted because also used to count these calls.
     bool shouldWriteVirtualMethodNative(const AbstractMetaFunction *func);
 
-    /// Adds enums eligible for generation from classes/namespaces marked not to be generated.
-    static void lookForEnumsInClassesNotToBeGenerated(AbstractMetaEnumList &enumList, const AbstractMetaClass *metaClass);
-
     QString wrapperName(const AbstractMetaClass *metaClass) const;
 
     QString fullPythonClassName(const AbstractMetaClass *metaClass);