Make buildDerivedTypeHierarchy() a static method

Drop CppTools namespace when being in this namespace.
Move a call to filesDependingOn() into buildDerived().
Make filesDependingOn() a static method.

Change-Id: I6139f87597286bddf8298b06f8cf492066c8bedd
Reviewed-by: hjk <hjk@qt.io>

src/plugins/cpptools/cppelementevaluator.cpp

@@ -50,7 +50,7 @@ static void handleLookupItemMatch(QFutureInterface<QSharedPointer<CppElement>> &
                                   const Snapshot &snapshot,
                                   const LookupItem &lookupItem,
                                   const LookupContext &context,
-                                  CppTools::SymbolFinder symbolFinder,
+                                  SymbolFinder symbolFinder,
                                   bool lookupBaseClasses,
                                   bool lookupDerivedClasses);
 
@@ -211,13 +211,13 @@ void CppClass::lookupBases(QFutureInterfaceBase &futureInterface,
 void CppClass::lookupDerived(QFutureInterfaceBase &futureInterface,
                              Symbol *declaration, const Snapshot &snapshot)
 {
-    using Data = QPair<CppClass*, CppTools::TypeHierarchy>;
+    using Data = QPair<CppClass*, TypeHierarchy>;
 
     snapshot.updateDependencyTable(futureInterface);
     if (futureInterface.isCanceled())
         return;
-    CppTools::TypeHierarchyBuilder builder(declaration, snapshot);
+    const TypeHierarchy &completeHierarchy
-    const CppTools::TypeHierarchy &completeHierarchy = builder.buildDerivedTypeHierarchy(futureInterface);
+            = TypeHierarchyBuilder::buildDerivedTypeHierarchy(futureInterface, declaration, snapshot);
 
     QQueue<Data> q;
     q.enqueue(qMakePair(this, completeHierarchy));
@@ -226,8 +226,8 @@ void CppClass::lookupDerived(QFutureInterfaceBase &futureInterface,
             return;
         const Data &current = q.dequeue();
         CppClass *clazz = current.first;
-        const CppTools::TypeHierarchy &classHierarchy = current.second;
+        const TypeHierarchy &classHierarchy = current.second;
-        foreach (const CppTools::TypeHierarchy &derivedHierarchy, classHierarchy.hierarchy()) {
+        foreach (const TypeHierarchy &derivedHierarchy, classHierarchy.hierarchy()) {
             clazz->derived.append(CppClass(derivedHierarchy.symbol()));
             q.enqueue(qMakePair(&clazz->derived.last(), derivedHierarchy));
         }
@@ -349,7 +349,7 @@ public:
 
 CppElementEvaluator::CppElementEvaluator(TextEditor::TextEditorWidget *editor) :
     m_editor(editor),
-    m_modelManager(CppTools::CppModelManager::instance()),
+    m_modelManager(CppModelManager::instance()),
     m_tc(editor->textCursor()),
     m_lookupBaseClasses(false),
     m_lookupDerivedClasses(false)
@@ -497,7 +497,7 @@ static void handleLookupItemMatch(QFutureInterface<QSharedPointer<CppElement>> &
                                   const Snapshot &snapshot,
                                   const LookupItem &lookupItem,
                                   const LookupContext &context,
-                                  CppTools::SymbolFinder symbolFinder,
+                                  SymbolFinder symbolFinder,
                                   bool lookupBaseClasses,
                                   bool lookupDerivedClasses)
 {

src/plugins/cpptools/functionutils.cpp

@@ -161,8 +161,8 @@ QList<Function *> FunctionUtils::overrides(Function *function, Class *functionsC
     QTC_ASSERT(referenceName && referenceType.isValid(), return result);
 
     // Find overrides
-    TypeHierarchyBuilder builder(staticClass, snapshot);
+    const TypeHierarchy &staticClassHierarchy
-    const TypeHierarchy &staticClassHierarchy = builder.buildDerivedTypeHierarchy();
+            = TypeHierarchyBuilder::buildDerivedTypeHierarchy(staticClass, snapshot);
 
     QList<TypeHierarchy> l;
     if (functionsClass != staticClass)

src/plugins/cpptools/typehierarchybuilder.cpp

@@ -134,34 +134,42 @@ const QList<TypeHierarchy> &TypeHierarchy::hierarchy() const
     return _hierarchy;
 }
 
-TypeHierarchyBuilder::TypeHierarchyBuilder(CPlusPlus::Symbol *symbol, const CPlusPlus::Snapshot &snapshot)
+TypeHierarchy TypeHierarchyBuilder::buildDerivedTypeHierarchy(CPlusPlus::Symbol *symbol,
-    : _symbol(symbol)
+                                                              const CPlusPlus::Snapshot &snapshot)
-    , _snapshot(snapshot)
-{}
-
-void TypeHierarchyBuilder::reset()
-{
-    _visited.clear();
-    _candidates.clear();
-}
-
-TypeHierarchy TypeHierarchyBuilder::buildDerivedTypeHierarchy()
 {
     QFutureInterfaceBase dummy;
-    return buildDerivedTypeHierarchy(dummy);
+    return TypeHierarchyBuilder::buildDerivedTypeHierarchy(dummy, symbol, snapshot);
 }
 
-TypeHierarchy TypeHierarchyBuilder::buildDerivedTypeHierarchy(QFutureInterfaceBase &futureInterface)
+TypeHierarchy TypeHierarchyBuilder::buildDerivedTypeHierarchy(QFutureInterfaceBase &futureInterface,
+                                                              CPlusPlus::Symbol *symbol,
+                                                              const CPlusPlus::Snapshot &snapshot)
 {
-    reset();
+    TypeHierarchy hierarchy(symbol);
-    TypeHierarchy hierarchy(_symbol);
+    TypeHierarchyBuilder builder;
-    buildDerived(futureInterface, &hierarchy, filesDependingOn(_symbol));
+    builder.buildDerived(futureInterface, &hierarchy, snapshot);
     return hierarchy;
 }
 
+static QStringList filesDependingOn(const CPlusPlus::Snapshot &snapshot,
+                                    CPlusPlus::Symbol *symbol)
+{
+    QStringList deps;
+    if (!symbol)
+        return deps;
+
+    const Utils::FilePath file = Utils::FilePath::fromUtf8(symbol->fileName(), symbol->fileNameLength());
+    deps << file.toString();
+    const Utils::FilePaths filePaths = snapshot.filesDependingOn(file);
+    for (const Utils::FilePath &fileName : filePaths)
+        deps.append(fileName.toString());
+    return deps;
+}
+
 void TypeHierarchyBuilder::buildDerived(QFutureInterfaceBase &futureInterface,
                                         TypeHierarchy *typeHierarchy,
-                                        const QStringList &dependingFiles, int depth)
+                                        const CPlusPlus::Snapshot &snapshot,
+                                        int depth)
 {
     CPlusPlus::Symbol *symbol = typeHierarchy->_symbol;
     if (_visited.contains(symbol))
@@ -172,6 +180,7 @@ void TypeHierarchyBuilder::buildDerived(QFutureInterfaceBase &futureInterface,
     const QString &symbolName = _overview.prettyName(CPlusPlus::LookupContext::fullyQualifiedName(symbol));
     DerivedHierarchyVisitor visitor(symbolName);
 
+    const QStringList &dependingFiles = filesDependingOn(snapshot, symbol);
     if (depth == 0)
         futureInterface.setProgressRange(0, dependingFiles.size());
 
@@ -181,37 +190,23 @@ void TypeHierarchyBuilder::buildDerived(QFutureInterfaceBase &futureInterface,
             return;
         if (depth == 0)
             futureInterface.setProgressValue(++i);
-        CPlusPlus::Document::Ptr doc = _snapshot.document(fileName);
+        CPlusPlus::Document::Ptr doc = snapshot.document(fileName);
         if ((_candidates.contains(fileName) && !_candidates.value(fileName).contains(symbolName))
                 || !doc->control()->findIdentifier(symbol->identifier()->chars(),
                                                    symbol->identifier()->size())) {
             continue;
         }
 
-        visitor.execute(doc, _snapshot);
+        visitor.execute(doc, snapshot);
         _candidates.insert(fileName, visitor.otherBases());
 
         const QList<CPlusPlus::Symbol *> &derived = visitor.derived();
         for (CPlusPlus::Symbol *s : derived) {
             TypeHierarchy derivedHierarchy(s);
-            buildDerived(futureInterface, &derivedHierarchy, filesDependingOn(s), depth + 1);
+            buildDerived(futureInterface, &derivedHierarchy, snapshot, depth + 1);
             if (futureInterface.isCanceled())
                 return;
             typeHierarchy->_hierarchy.append(derivedHierarchy);
         }
     }
 }
-
-QStringList TypeHierarchyBuilder::filesDependingOn(CPlusPlus::Symbol *symbol) const
-{
-    QStringList deps;
-    if (!symbol)
-        return deps;
-
-    const Utils::FilePath file = Utils::FilePath::fromUtf8(symbol->fileName(), symbol->fileNameLength());
-    deps << file.toString();
-    const Utils::FilePaths filePaths = _snapshot.filesDependingOn(file);
-    for (const Utils::FilePath &fileName : filePaths)
-        deps.append(fileName.toString());
-    return deps;
-}

src/plugins/cpptools/typehierarchybuilder.h

@@ -58,19 +58,17 @@ private:
 class CPPTOOLS_EXPORT TypeHierarchyBuilder
 {
 public:
-    TypeHierarchyBuilder(CPlusPlus::Symbol *symbol, const CPlusPlus::Snapshot &snapshot);
+    static TypeHierarchy buildDerivedTypeHierarchy(CPlusPlus::Symbol *symbol,
-
+                                            const CPlusPlus::Snapshot &snapshot);
-    TypeHierarchy buildDerivedTypeHierarchy();
+    static TypeHierarchy buildDerivedTypeHierarchy(QFutureInterfaceBase &futureInterface,
-    TypeHierarchy buildDerivedTypeHierarchy(QFutureInterfaceBase &futureInterface);
+                                            CPlusPlus::Symbol *symbol,
+                                            const CPlusPlus::Snapshot &snapshot);
 
 private:
-    void reset();
+    TypeHierarchyBuilder() = default;
-    void buildDerived(QFutureInterfaceBase &futureInterface,
+    void buildDerived(QFutureInterfaceBase &futureInterface, TypeHierarchy *typeHierarchy,
-                      TypeHierarchy *typeHierarchy, const QStringList &dependencies, int depth = 0);
+                      const CPlusPlus::Snapshot &snapshot, int depth = 0);
-    QStringList filesDependingOn(CPlusPlus::Symbol *symbol) const;
 
-    CPlusPlus::Symbol *_symbol;
-    CPlusPlus::Snapshot _snapshot;
     QSet<CPlusPlus::Symbol *> _visited;
     QHash<QString, QSet<QString> > _candidates;
     CPlusPlus::Overview _overview;

src/plugins/cpptools/typehierarchybuilder_test.cpp

@@ -124,8 +124,8 @@ public:
         QVERIFY(clazz);
 
         // Generate and compare hierarchies
-        TypeHierarchyBuilder typeHierarchyBuilder(clazz, snapshot);
+        const TypeHierarchy hierarchy
-        const TypeHierarchy hierarchy = typeHierarchyBuilder.buildDerivedTypeHierarchy();
+                = TypeHierarchyBuilder::buildDerivedTypeHierarchy(clazz, snapshot);
 
         const QString actualHierarchy = toString(hierarchy);
 //        Uncomment for updating/generating reference data: