CppProjectUpdater: Reuse TaskTree

Change-Id: I7474e5a31d169bf435d94536cffd77d218320977
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>

src/plugins/cmakeprojectmanager/cmakebuildsystem.cpp

@@ -27,6 +27,7 @@
 #include <cppeditor/generatedcodemodelsupport.h>
 
 #include <projectexplorer/buildsteplist.h>
+#include <projectexplorer/extracompiler.h>
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/projectexplorerconstants.h>

src/plugins/cppeditor/cppeditorplugin.cpp

@@ -68,6 +68,7 @@
 #include <extensionsystem/pluginmanager.h>
 
 #include <projectexplorer/project.h>
+#include <projectexplorer/projectnodes.h>
 #include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/projectpanelfactory.h>
 #include <projectexplorer/projecttree.h>

src/plugins/cppeditor/cppprojectupdater.cpp

@@ -7,15 +7,13 @@
 #include "cppprojectinfogenerator.h"
 #include "generatedcodemodelsupport.h"
 
-#include <coreplugin/progressmanager/progressmanager.h>
+#include <coreplugin/progressmanager/taskprogress.h>
 
-#include <projectexplorer/toolchainmanager.h>
+#include <projectexplorer/extracompiler.h>
 
 #include <utils/algorithm.h>
-#include <utils/fileutils.h>
+#include <utils/asynctask.h>
 #include <utils/qtcassert.h>
-#include <utils/runextensions.h>
-#include <utils/tasktree.h>
 
 #include <QFutureInterface>
 
@@ -26,17 +24,10 @@ namespace CppEditor {
 
 CppProjectUpdater::CppProjectUpdater()
 {
-    connect(&m_generateFutureWatcher,
-            &QFutureWatcher<ProjectInfo>::finished,
-            this,
-            &CppProjectUpdater::onProjectInfoGenerated);
     m_futureSynchronizer.setCancelOnWait(true);
 }
 
-CppProjectUpdater::~CppProjectUpdater()
+CppProjectUpdater::~CppProjectUpdater() = default;
-{
-    cancel();
-}
 
 void CppProjectUpdater::update(const ProjectUpdateInfo &projectUpdateInfo)
 {
@@ -49,104 +40,78 @@ void CppProjectUpdater::update(const ProjectUpdateInfo &projectUpdateInfo,
     // Stop previous update.
     cancel();
 
-    m_extraCompilers = Utils::transform(extraCompilers, [](ExtraCompiler *compiler) {
+    const QList<QPointer<ProjectExplorer::ExtraCompiler>> compilers =
-        return QPointer<ExtraCompiler>(compiler);
+        Utils::transform(extraCompilers, [](ExtraCompiler *compiler) {
-    });
+            return QPointer<ExtraCompiler>(compiler);
-    m_projectUpdateInfo = projectUpdateInfo;
+        });
 
     using namespace ProjectExplorer;
 
     // Run the project info generator in a worker thread and continue if that one is finished.
-    auto generateFuture = Utils::runAsync([=](QFutureInterface<ProjectInfo::ConstPtr> &futureInterface) {
+    const auto infoGenerator = [=](QFutureInterface<ProjectInfo::ConstPtr> &futureInterface) {
         ProjectUpdateInfo fullProjectUpdateInfo = projectUpdateInfo;
         if (fullProjectUpdateInfo.rppGenerator)
             fullProjectUpdateInfo.rawProjectParts = fullProjectUpdateInfo.rppGenerator();
         Internal::ProjectInfoGenerator generator(futureInterface, fullProjectUpdateInfo);
         futureInterface.reportResult(generator.generate());
-    });
+    };
-    m_generateFutureWatcher.setFuture(generateFuture);
-    m_futureSynchronizer.addFuture(generateFuture);
 
-    // extra compilers
+    using namespace Tasking;
-    for (QPointer<ExtraCompiler> compiler : std::as_const(m_extraCompilers)) {
+    struct UpdateStorage {
-        if (!compiler->isDirty())
+        ProjectInfo::ConstPtr projectInfo = nullptr;
-            continue;
+    };
-
+    const TreeStorage<UpdateStorage> storage;
-        const auto destroyTaskTree = [this](TaskTree *taskTree) {
+    const auto setupInfoGenerator = [=](AsyncTask<ProjectInfo::ConstPtr> &async) {
-            m_extraCompilerTasks.remove(taskTree);
+        async.setAsyncCallData(infoGenerator);
-            taskTree->deleteLater();
+        async.setFutureSynchronizer(&m_futureSynchronizer);
-        };
+    };
-        TaskTree *taskTree = new TaskTree({compiler->compileFileItem()});
+    const auto onInfoGeneratorDone = [=](const AsyncTask<ProjectInfo::ConstPtr> &async) {
-        connect(taskTree, &TaskTree::done, this, [this, taskTree, destroyTaskTree] {
+        storage->projectInfo = async.result();
-            destroyTaskTree(taskTree);
+    };
-            m_projectUpdateFutureInterface->setProgressValue(
+    QList<TaskItem> tasks{parallel};
-                m_projectUpdateFutureInterface->progressValue() + 1);
+    tasks.append(Async<ProjectInfo::ConstPtr>(setupInfoGenerator, onInfoGeneratorDone));
-            checkForExtraCompilersFinished();
+    for (QPointer<ExtraCompiler> compiler : compilers) {
-        });
+        if (compiler && compiler->isDirty())
-        connect(taskTree, &TaskTree::errorOccurred, this, [taskTree, destroyTaskTree] {
+            tasks.append(compiler->compileFileItem());
-            destroyTaskTree(taskTree);
-        });
-        m_extraCompilerTasks.insert(taskTree);
-        taskTree->start();
     }
 
-    m_projectUpdateFutureInterface.reset(new QFutureInterface<void>);
+    const auto onDone = [this, storage, compilers] {
-    m_projectUpdateFutureInterface->setProgressRange(0, m_extraCompilerTasks.size()
+        QList<ExtraCompiler *> extraCompilers;
-                                                        + 1 /*generateFuture*/);
+        QSet<FilePath> compilerFiles;
-    m_projectUpdateFutureInterface->setProgressValue(0);
+        for (const QPointer<ExtraCompiler> &compiler : compilers) {
-    m_projectUpdateFutureInterface->reportStarted();
+            if (compiler) {
-    Core::ProgressManager::addTask(m_projectUpdateFutureInterface->future(),
+                extraCompilers += compiler.data();
-                                   tr("Preparing C++ Code Model"),
+                compilerFiles += Utils::toSet(compiler->targets());
-                                   "CppProjectUpdater");
+            }
+        }
+        GeneratedCodeModelSupport::update(extraCompilers);
+        auto updateFuture = CppModelManager::instance()->updateProjectInfo(storage->projectInfo,
+                                                                           compilerFiles);
+        m_futureSynchronizer.addFuture(updateFuture);
+        m_taskTree.release()->deleteLater();
+    };
+    const auto onError = [this] {
+        m_taskTree.release()->deleteLater();
+    };
+
+    const Group root {
+        Storage(storage),
+        Group(tasks),
+        OnGroupDone(onDone),
+        OnGroupError(onError)
+    };
+    m_taskTree.reset(new TaskTree(root));
+    auto progress = new Core::TaskProgress(m_taskTree.get());
+    progress->setDisplayName(tr("Preparing C++ Code Model"));
+    m_taskTree->start();
 }
 
 void CppProjectUpdater::cancel()
 {
-    if (m_projectUpdateFutureInterface && m_projectUpdateFutureInterface->isRunning())
+    m_taskTree.reset();
-        m_projectUpdateFutureInterface->reportFinished();
-    m_generateFutureWatcher.setFuture({});
-    m_isProjectInfoGenerated = false;
-    qDeleteAll(m_extraCompilerTasks);
-    m_extraCompilerTasks.clear();
-    m_extraCompilers.clear();
     m_futureSynchronizer.cancelAllFutures();
 }
 
-void CppProjectUpdater::onProjectInfoGenerated()
-{
-    if (m_generateFutureWatcher.isCanceled() || m_generateFutureWatcher.future().resultCount() < 1)
-        return;
-
-    m_projectUpdateFutureInterface->setProgressValue(m_projectUpdateFutureInterface->progressValue()
-                                                     + 1);
-    m_isProjectInfoGenerated = true;
-    checkForExtraCompilersFinished();
-}
-
-void CppProjectUpdater::checkForExtraCompilersFinished()
-{
-    if (!m_extraCompilerTasks.isEmpty() || !m_isProjectInfoGenerated)
-        return; // still need to wait
-
-    m_projectUpdateFutureInterface->reportFinished();
-    m_projectUpdateFutureInterface.reset();
-
-    QList<ExtraCompiler *> extraCompilers;
-    QSet<FilePath> compilerFiles;
-    for (const QPointer<ExtraCompiler> &compiler : std::as_const(m_extraCompilers)) {
-        if (compiler) {
-            extraCompilers += compiler.data();
-            compilerFiles += Utils::toSet(compiler->targets());
-        }
-    }
-    GeneratedCodeModelSupport::update(extraCompilers);
-    m_extraCompilers.clear();
-
-    auto updateFuture = CppModelManager::instance()
-                            ->updateProjectInfo(m_generateFutureWatcher.result(), compilerFiles);
-    m_futureSynchronizer.addFuture(updateFuture);
-}
-
 namespace Internal {
 CppProjectUpdaterFactory::CppProjectUpdaterFactory()
 {

src/plugins/cppeditor/cppprojectupdater.h

@@ -4,18 +4,15 @@
 #pragma once
 
 #include "cppeditor_global.h"
-#include "cppprojectupdaterinterface.h"
-#include "projectinfo.h"
 
-#include <projectexplorer/extracompiler.h>
+#include "cppprojectupdaterinterface.h"
+
 #include <utils/futuresynchronizer.h>
 
-#include <QFutureWatcher>
+namespace ProjectExplorer { class ExtraCompiler; }
-
 namespace Utils { class TaskTree; }
 
 namespace CppEditor {
-class ProjectInfo;
 
 namespace Internal {
 
@@ -46,18 +43,8 @@ public:
     void cancel() override;
 
 private:
-    void onProjectInfoGenerated();
-    void checkForExtraCompilersFinished();
-
-private:
-    ProjectExplorer::ProjectUpdateInfo m_projectUpdateInfo;
-    QList<QPointer<ProjectExplorer::ExtraCompiler>> m_extraCompilers;
-
-    QFutureWatcher<ProjectInfo::ConstPtr> m_generateFutureWatcher;
-    bool m_isProjectInfoGenerated = false;
-    QSet<Utils::TaskTree *> m_extraCompilerTasks;
-    std::unique_ptr<QFutureInterface<void>> m_projectUpdateFutureInterface;
     Utils::FutureSynchronizer m_futureSynchronizer;
+    std::unique_ptr<Utils::TaskTree> m_taskTree;
 };
 
 } // namespace CppEditor

src/plugins/qmakeprojectmanager/qmakeproject.cpp

@@ -26,6 +26,7 @@
 #include <projectexplorer/buildsteplist.h>
 #include <projectexplorer/buildtargetinfo.h>
 #include <projectexplorer/deploymentdata.h>
+#include <projectexplorer/extracompiler.h>
 #include <projectexplorer/headerpath.h>
 #include <projectexplorer/projectexplorer.h>
 #include <projectexplorer/projectexplorerconstants.h>