Instantiate ProjectTreeBuilder in ProjectResolver

It's silly to run the ProjectTreeBuilder elsewhere and forward the
result to ProjectResolver when that's the only place it is needed.

Change-Id: If6ce01be57e2f144bdc6a1409b8f1057eaa5218e
Reviewed-by: Ivan Komissarov <ABBAPOH@gmail.com>

5 files changed, 78 insertions, 34 deletions

diff --git a/src/lib/corelib/language/moduleproviderinfo.h b/src/lib/corelib/language/moduleproviderinfo.h
index d4c375f4a..500d370cc 100644
--- a/src/lib/corelib/language/moduleproviderinfo.h
+++ b/src/lib/corelib/language/moduleproviderinfo.h
@@ -90,8 +90,9 @@ public:
 using ModuleProviderInfoList = std::vector<ModuleProviderInfo>;
 
 // Persistent info stored between sessions
-struct StoredModuleProviderInfo
+class StoredModuleProviderInfo
 {
+public:
     using CacheKey = std::tuple<
         QString /*name*/,
         QVariantMap /*config*/,
diff --git a/src/lib/corelib/loader/loader.cpp b/src/lib/corelib/loader/loader.cpp
index 47108ffdf..e0ef3ca64 100644
--- a/src/lib/corelib/loader/loader.cpp
+++ b/src/lib/corelib/loader/loader.cpp
@@ -40,10 +40,7 @@
 #include "loader.h"
 
 #include "projectresolver.h"
-#include "projecttreebuilder.h"
 
-#include <language/evaluator.h>
-#include <language/itempool.h>
 #include <language/language.h>
 #include <language/scriptengine.h>
 #include <logging/translator.h>
@@ -134,17 +131,13 @@ TopLevelProjectPtr Loader::loadProject(const SetupProjectParameters &_parameters
     }
 
     const FileTime resolveTime = FileTime::currentTime();
-    Evaluator evaluator(m_engine);
-    ItemPool pool;
-    ProjectTreeBuilder projectTreeBuilder(parameters, pool, evaluator, m_logger);
-    projectTreeBuilder.setProgressObserver(m_progressObserver);
-    projectTreeBuilder.setOldProjectProbes(m_oldProjectProbes);
-    projectTreeBuilder.setOldProductProbes(m_oldProductProbes);
-    projectTreeBuilder.setLastResolveTime(m_lastResolveTime);
-    projectTreeBuilder.setStoredProfiles(m_storedProfiles);
-    projectTreeBuilder.setStoredModuleProviderInfo(m_storedModuleProviderInfo);
-    ProjectResolver resolver(parameters, projectTreeBuilder.load(), evaluator, m_logger);
+    ProjectResolver resolver(parameters, m_engine, m_logger);
     resolver.setProgressObserver(m_progressObserver);
+    resolver.setOldProjectProbes(m_oldProjectProbes);
+    resolver.setOldProductProbes(m_oldProductProbes);
+    resolver.setLastResolveTime(m_lastResolveTime);
+    resolver.setStoredProfiles(m_storedProfiles);
+    resolver.setStoredModuleProviderInfo(m_storedModuleProviderInfo);
     TopLevelProjectPtr project = resolver.resolve();
     project->lastStartResolveTime = resolveTime;
     project->lastEndResolveTime = FileTime::currentTime();
diff --git a/src/lib/corelib/loader/projectresolver.cpp b/src/lib/corelib/loader/projectresolver.cpp
index f218bc497..a7eb562c3 100644
--- a/src/lib/corelib/loader/projectresolver.cpp
+++ b/src/lib/corelib/loader/projectresolver.cpp
@@ -39,6 +39,8 @@
 
 #include "projectresolver.h"
 
+#include "projecttreebuilder.h"
+
 #include <jsextensions/jsextensions.h>
 #include <jsextensions/moduleproperties.h>
 #include <language/artifactproperties.h>
@@ -47,6 +49,7 @@
 #include <language/filecontext.h>
 #include <language/filetags.h>
 #include <language/item.h>
+#include <language/itempool.h>
 #include <language/language.h>
 #include <language/propertymapinternal.h>
 #include <language/resolvedfilecontext.h>
@@ -125,10 +128,9 @@ class ProjectResolver::Private
 {
 public:
     Private(const SetupProjectParameters &setupParameters,
-            ProjectTreeBuilder::Result &&loadResult,
-            Evaluator &evaluator, Logger &logger)
-        : setupParams(setupParameters), loadResult(std::move(loadResult)), evaluator(evaluator),
-          logger(logger), engine(evaluator.engine())
+            ScriptEngine *engine, Logger &logger)
+        : setupParams(setupParameters), engine(engine), evaluator(engine),
+          logger(logger)
     {}
 
     static void applyFileTaggers(const SourceArtifactPtr &artifact,
@@ -215,17 +217,17 @@ public:
     void setupExportedProperties(const Item *item, const QString &namePrefix,
                                  std::vector<ExportedProperty> &properties);
 
-
-    typedef void (ProjectResolver::Private::*ItemFuncPtr)(Item *item,
-                                                          ProjectContext *projectContext);
+    using ItemFuncPtr = void (ProjectResolver::Private::*)(Item *item,
+                                                           ProjectContext *projectContext);
     using ItemFuncMap = QMap<ItemType, ItemFuncPtr>;
     void callItemFunction(const ItemFuncMap &mappings, Item *item, ProjectContext *projectContext);
 
     const SetupProjectParameters &setupParams;
     ProjectTreeBuilder::Result loadResult;
-    Evaluator &evaluator;
-    Logger &logger;
     ScriptEngine * const engine;
+    Evaluator evaluator;
+    Logger &logger;
+    ItemPool itemPool;
     ProgressObserver *progressObserver = nullptr;
     ProductContext *productContext = nullptr;
     ModuleContext *moduleContext = nullptr;
@@ -239,15 +241,20 @@ public:
     Set<CodeLocation> groupLocationWarnings;
     std::vector<std::pair<ResolvedProductPtr, Item *>> productExportInfo;
     std::vector<ErrorInfo> queuedErrors;
+    std::vector<ProbeConstPtr> oldProjectProbes;
+    QHash<QString, std::vector<ProbeConstPtr>> oldProductProbes;
+    StoredModuleProviderInfo storedModuleProviderInfo;
+    QVariantMap storedProfiles;
+    FileTime lastResolveTime;
     qint64 elapsedTimeModPropEval = 0;
     qint64 elapsedTimeAllPropEval = 0;
     qint64 elapsedTimeGroups = 0;
 };
 
 
-ProjectResolver::ProjectResolver(const SetupProjectParameters &setupParameters, ProjectTreeBuilder::Result &&loadResult,
-    Evaluator &evaluator, Logger &logger)
-    : d(new Private(setupParameters, std::move(loadResult), evaluator, logger))
+ProjectResolver::ProjectResolver(const SetupProjectParameters &setupParameters,
+                                 ScriptEngine *engine, Logger &logger)
+    : d(new Private(setupParameters, engine, logger))
 {
     QBS_CHECK(FileInfo::isAbsolute(d->setupParams.buildRoot()));
 }
@@ -262,6 +269,32 @@ void ProjectResolver::setProgressObserver(ProgressObserver *observer)
     d->progressObserver = observer;
 }
 
+void ProjectResolver::setOldProjectProbes(const std::vector<ProbeConstPtr> &oldProbes)
+{
+    d->oldProjectProbes = oldProbes;
+}
+
+void ProjectResolver::setOldProductProbes(
+    const QHash<QString, std::vector<ProbeConstPtr>> &oldProbes)
+{
+    d->oldProductProbes = oldProbes;
+}
+
+void ProjectResolver::setLastResolveTime(const FileTime &time)
+{
+    d->lastResolveTime = time;
+}
+
+void ProjectResolver::setStoredProfiles(const QVariantMap &profiles)
+{
+    d->storedProfiles = profiles;
+}
+
+void ProjectResolver::setStoredModuleProviderInfo(const StoredModuleProviderInfo &providerInfo)
+{
+    d->storedModuleProviderInfo = providerInfo;
+}
+
 static void checkForDuplicateProductNames(const TopLevelProjectConstPtr &project)
 {
     const std::vector<ResolvedProductPtr> allProducts = project->allProducts();
@@ -285,7 +318,16 @@ TopLevelProjectPtr ProjectResolver::resolve()
 {
     TimedActivityLogger projectResolverTimer(d->logger, Tr::tr("ProjectResolver"),
                                              d->setupParams.logElapsedTime());
-    qCDebug(lcProjectResolver) << "resolving" << d->loadResult.root->file()->filePath();
+    qCDebug(lcProjectResolver) << "resolving" << d->setupParams.projectFilePath();
+
+    ProjectTreeBuilder projectTreeBuilder(d->setupParams, d->itemPool, d->evaluator, d->logger);
+    projectTreeBuilder.setProgressObserver(d->progressObserver);
+    projectTreeBuilder.setOldProjectProbes(d->oldProjectProbes);
+    projectTreeBuilder.setOldProductProbes(d->oldProductProbes);
+    projectTreeBuilder.setLastResolveTime(d->lastResolveTime);
+    projectTreeBuilder.setStoredProfiles(d->storedProfiles);
+    projectTreeBuilder.setStoredModuleProviderInfo(d->storedModuleProviderInfo);
+    d->loadResult = projectTreeBuilder.load();
 
     TopLevelProjectPtr tlp;
     try {
diff --git a/src/lib/corelib/loader/projectresolver.h b/src/lib/corelib/loader/projectresolver.h
index a74ea4a8f..eaa88fd63 100644
--- a/src/lib/corelib/loader/projectresolver.h
+++ b/src/lib/corelib/loader/projectresolver.h
@@ -40,24 +40,35 @@
 #ifndef PROJECTRESOLVER_H
 #define PROJECTRESOLVER_H
 
-#include "projecttreebuilder.h"
+#include <language/forward_decls.h>
+
+#include <QHash>
+#include <QVariant>
+
+#include <vector>
 
 namespace qbs {
 class SetupProjectParameters;
 namespace Internal {
-class Evaluator;
+class FileTime;
 class Logger;
 class ProgressObserver;
+class ScriptEngine;
+class StoredModuleProviderInfo;
 
 class ProjectResolver
 {
 public:
     ProjectResolver(const SetupProjectParameters &setupParameters,
-                    ProjectTreeBuilder::Result &&loadResult,
-                    Evaluator &evaluator, Logger &logger);
+                    ScriptEngine *engine, Logger &logger);
     ~ProjectResolver();
 
     void setProgressObserver(ProgressObserver *observer);
+    void setOldProjectProbes(const std::vector<ProbeConstPtr> &oldProbes);
+    void setOldProductProbes(const QHash<QString, std::vector<ProbeConstPtr>> &oldProbes);
+    void setLastResolveTime(const FileTime &time);
+    void setStoredProfiles(const QVariantMap &profiles);
+    void setStoredModuleProviderInfo(const StoredModuleProviderInfo &providerInfo);
     TopLevelProjectPtr resolve();
 
 private:
diff --git a/src/lib/corelib/loader/projecttreebuilder.h b/src/lib/corelib/loader/projecttreebuilder.h
index 663b65a55..15a329e19 100644
--- a/src/lib/corelib/loader/projecttreebuilder.h
+++ b/src/lib/corelib/loader/projecttreebuilder.h
@@ -59,9 +59,6 @@ class ProgressObserver;
 
 using ModulePropertiesPerGroup = std::unordered_map<const Item *, QualifiedIdSet>;
 
-// TODO: This class only needs to be known inside the ProjectResolver; no need to
-//       instantiate them separately when they always appear together.
-//       Possibly we can get rid of the Loader class altogether.
 class ProjectTreeBuilder
 {
 public: