Merge remote-tracking branch 'origin/4.9'

 Conflicts:
	qbs/modules/qtc/qtc.qbs
	qtcreator.pri
	src/plugins/pythoneditor/pythoneditorplugin.cpp

Change-Id: I9a95df5e16b34538539ced7dfc5d326b700794e6

36 files changed, 352 insertions, 718 deletions

diff --git a/src/tools/clangbackend/clangbackendmain.cpp b/src/tools/clangbackend/clangbackendmain.cpp
index 5cbac3ce60..1e95db3ef3 100644
--- a/src/tools/clangbackend/clangbackendmain.cpp
+++ b/src/tools/clangbackend/clangbackendmain.cpp
@@ -57,8 +57,25 @@ QString processArguments(QCoreApplication &application)
 }
 
 #ifdef Q_OS_WIN
-static void messageOutput(QtMsgType type, const QMessageLogContext &, const QString &msg)
+struct MessageHandler {
+    MessageHandler(QtMessageHandler handler)
+    {
+        defaultHandler = qInstallMessageHandler(handler);
+    }
+
+    ~MessageHandler()
+    {
+        qInstallMessageHandler(defaultHandler);
+    }
+
+    static QtMessageHandler defaultHandler;
+};
+
+QtMessageHandler MessageHandler::defaultHandler = nullptr;
+
+static void messageOutput(QtMsgType type, const QMessageLogContext &context, const QString &msg)
 {
+    MessageHandler::defaultHandler(type, context, msg);
     std::wcout << msg.toStdWString() << std::endl;
     if (type == QtFatalMsg)
         abort();
@@ -68,7 +85,7 @@ static void messageOutput(QtMsgType type, const QMessageLogContext &, const QStr
 int main(int argc, char *argv[])
 {
 #ifdef Q_OS_WIN
-    qInstallMessageHandler(messageOutput);
+    MessageHandler messageHandler(&messageOutput);
 #endif
     QCoreApplication::setOrganizationName(QStringLiteral("QtProject"));
     QCoreApplication::setOrganizationDomain(QStringLiteral("qt-project.org"));
diff --git a/src/tools/clangpchmanagerbackend/clangpchmanagerbackendmain.cpp b/src/tools/clangpchmanagerbackend/clangpchmanagerbackendmain.cpp
index 3237aab2fb..b2a58b0d66 100644
--- a/src/tools/clangpchmanagerbackend/clangpchmanagerbackendmain.cpp
+++ b/src/tools/clangpchmanagerbackend/clangpchmanagerbackendmain.cpp
@@ -30,11 +30,12 @@
 #include <connectionserver.h>
 #include <environment.h>
 #include <executeinloop.h>
+#include <filepathcaching.h>
 #include <generatedfiles.h>
 #include <modifiedtimechecker.h>
 #include <pchcreator.h>
-#include <pchmanagerserver.h>
 #include <pchmanagerclientproxy.h>
+#include <pchmanagerserver.h>
 #include <pchtaskgenerator.h>
 #include <pchtaskqueue.h>
 #include <pchtasksmerger.h>
@@ -42,7 +43,7 @@
 #include <processormanager.h>
 #include <progresscounter.h>
 #include <projectpartsmanager.h>
-#include <filepathcaching.h>
+#include <projectpartsstorage.h>
 #include <refactoringdatabaseinitializer.h>
 #include <sqlitedatabase.h>
 #include <taskscheduler.h>
@@ -63,14 +64,15 @@ using namespace std::chrono_literals;
 
 using ClangBackEnd::ClangPathWatcher;
 using ClangBackEnd::ConnectionServer;
+using ClangBackEnd::FilePathCache;
+using ClangBackEnd::FilePathView;
 using ClangBackEnd::GeneratedFiles;
 using ClangBackEnd::PchCreator;
 using ClangBackEnd::PchManagerClientProxy;
 using ClangBackEnd::PchManagerServer;
 using ClangBackEnd::PrecompiledHeaderStorage;
 using ClangBackEnd::ProjectPartsManager;
-using ClangBackEnd::FilePathCache;
-using ClangBackEnd::FilePathView;
+using ClangBackEnd::ProjectPartsStorage;
 using ClangBackEnd::TimeStamp;
 
 class PchManagerApplication final : public QCoreApplication
@@ -179,7 +181,8 @@ struct Data // because we have a cycle dependency
     ClangBackEnd::FilePathCaching filePathCache{database};
     ClangPathWatcher<QFileSystemWatcher, QTimer> includeWatcher{filePathCache};
     ApplicationEnvironment environment;
-    ProjectPartsManager projectParts;
+    ProjectPartsStorage<> projectPartsStorage{database};
+    ProjectPartsManager projectParts{projectPartsStorage};
     GeneratedFiles generatedFiles;
     PchCreatorManager pchCreatorManager{generatedFiles,
                                         environment,
diff --git a/src/tools/clangpchmanagerbackend/source/builddependenciesprovider.cpp b/src/tools/clangpchmanagerbackend/source/builddependenciesprovider.cpp
index a2a7a813ac..bf00f39098 100644
--- a/src/tools/clangpchmanagerbackend/source/builddependenciesprovider.cpp
+++ b/src/tools/clangpchmanagerbackend/source/builddependenciesprovider.cpp
@@ -101,19 +101,15 @@ UsedMacros BuildDependenciesProvider::createUsedMacrosFromStorage(const SourceEn
     return usedMacros;
 }
 
-std::pair<SourceEntries, int>
-BuildDependenciesProvider::createSourceEntriesFromStorage(
-    const FilePathIds &sourcePathIds,
-    Utils::SmallStringView projectPartName) const {
+std::pair<SourceEntries, ProjectPartId> BuildDependenciesProvider::createSourceEntriesFromStorage(
+    const FilePathIds &sourcePathIds, ProjectPartId projectPartId) const
+{
     SourceEntries includes;
 
     Sqlite::DeferredTransaction transaction(m_transactionBackend);
 
-    int projectPartId = m_storage.fetchProjectPartId(projectPartName);
-
     for (FilePathId sourcePathId : sourcePathIds) {
-        SourceEntries entries =
-            m_storage.fetchDependSources(sourcePathId, projectPartId);
+        SourceEntries entries = m_storage.fetchDependSources(sourcePathId, projectPartId);
         SourceEntries mergedEntries = setUnion<SourceEntries>(includes, entries);
 
         includes = std::move(mergedEntries);
@@ -124,8 +120,9 @@ BuildDependenciesProvider::createSourceEntriesFromStorage(
     return {includes, projectPartId};
 }
 
-void BuildDependenciesProvider::storeBuildDependency(
-    const BuildDependency &buildDependency, int projectPartId) {
+void BuildDependenciesProvider::storeBuildDependency(const BuildDependency &buildDependency,
+                                                     ProjectPartId projectPartId)
+{
     Sqlite::ImmediateTransaction transaction(m_transactionBackend);
     m_storage.insertOrUpdateSources(buildDependency.sources, projectPartId);
     m_storage.insertOrUpdateFileStatuses(buildDependency.fileStatuses);
diff --git a/src/tools/clangpchmanagerbackend/source/builddependenciesprovider.h b/src/tools/clangpchmanagerbackend/source/builddependenciesprovider.h
index 2eb5210518..9700b83aa3 100644
--- a/src/tools/clangpchmanagerbackend/source/builddependenciesprovider.h
+++ b/src/tools/clangpchmanagerbackend/source/builddependenciesprovider.h
@@ -55,9 +55,9 @@ public:
 private:
     BuildDependency createBuildDependencyFromStorage(SourceEntries &&includes) const;
     UsedMacros createUsedMacrosFromStorage(const SourceEntries &includes) const;
-    std::pair<SourceEntries, int> createSourceEntriesFromStorage(
-        const FilePathIds &sourcePathIds, Utils::SmallStringView projectPartName) const;
-    void storeBuildDependency(const BuildDependency &buildDependency, int projectPartId);
+    std::pair<SourceEntries, ProjectPartId> createSourceEntriesFromStorage(
+        const FilePathIds &sourcePathIds, ProjectPartId projectPartId) const;
+    void storeBuildDependency(const BuildDependency &buildDependency, ProjectPartId projectPartId);
 
 private:
     BuildDependenciesStorageInterface &m_storage;
diff --git a/src/tools/clangpchmanagerbackend/source/builddependenciesstorage.h b/src/tools/clangpchmanagerbackend/source/builddependenciesstorage.h
index 3e6d00da3f..e7269dd0f9 100644
--- a/src/tools/clangpchmanagerbackend/source/builddependenciesstorage.h
+++ b/src/tools/clangpchmanagerbackend/source/builddependenciesstorage.h
@@ -53,17 +53,16 @@ public:
         transaction.commit();
     }
 
-    void insertOrUpdateSources(const SourceEntries &sourceEntries, int projectPartId) override
+    void insertOrUpdateSources(const SourceEntries &sourceEntries, ProjectPartId projectPartId) override
     {
-        deleteAllProjectPartsSourcesWithProjectPartNameStatement.write(
-            projectPartId);
+        deleteAllProjectPartsFilesWithProjectPartNameStatement.write(projectPartId.projectPathId);
 
         for (const SourceEntry &entry : sourceEntries) {
-            insertOrUpdateProjectPartsSourcesStatement.write(
-                entry.sourceId.filePathId,
-                projectPartId,
-                static_cast<uchar>(entry.sourceType),
-                static_cast<uchar>(entry.hasMissingIncludes));
+            insertOrUpdateProjectPartsFilesStatement.write(entry.sourceId.filePathId,
+                                                             projectPartId.projectPathId,
+                                                             static_cast<uchar>(entry.sourceType),
+                                                             static_cast<uchar>(
+                                                                 entry.hasMissingIncludes));
         }
     }
 
@@ -108,22 +107,22 @@ public:
         deleteNewSourceDependenciesStatement.execute();
     }
 
-    int fetchProjectPartId(Utils::SmallStringView projectPartName) override
+    ProjectPartId fetchProjectPartId(Utils::SmallStringView projectPartName) override
     {
-        auto projectPartId = fetchProjectPartIdStatement.template value<int>(projectPartName);
+        auto projectPartId = fetchProjectPartIdStatement.template value<ProjectPartId>(projectPartName);
 
         if (projectPartId)
-            return projectPartId.value();
+            return *projectPartId;
 
         insertProjectPartNameStatement.write(projectPartName);
 
         return static_cast<int>(database.lastInsertedRowId());
     }
 
-    SourceEntries fetchDependSources(FilePathId sourceId, int projectPartId) const override
+    SourceEntries fetchDependSources(FilePathId sourceId, ProjectPartId projectPartId) const override
     {
-        return fetchSourceDependenciesStatement.template values<SourceEntry, 4>(
-            300, sourceId.filePathId, projectPartId);
+        return fetchSourceDependenciesStatement
+            .template values<SourceEntry, 4>(300, sourceId.filePathId, projectPartId.projectPathId);
     }
 
     UsedMacros fetchUsedMacros(FilePathId sourceId) const override
@@ -131,13 +130,11 @@ public:
         return fetchUsedMacrosStatement.template values<UsedMacro, 2>(128, sourceId.filePathId);
     }
 
-    void updatePchCreationTimeStamp(
-        long long pchCreationTimeStamp,
-        Utils::SmallStringView projectPartName) override {
+    void updatePchCreationTimeStamp(long long pchCreationTimeStamp, ProjectPartId projectPartId) override
+    {
         Sqlite::ImmediateTransaction transaction{database};
 
-        updatePchCreationTimeStampStatement.write(pchCreationTimeStamp,
-                                                  projectPartName);
+        updatePchCreationTimeStampStatement.write(pchCreationTimeStamp, projectPartId.projectPathId);
 
         transaction.commit();
     }
@@ -243,8 +240,8 @@ public:
         "DELETE FROM newSourceDependencies",
         database
     };
-    WriteStatement insertOrUpdateProjectPartsSourcesStatement{
-        "INSERT INTO projectPartsSources(sourceId, projectPartId, "
+    WriteStatement insertOrUpdateProjectPartsFilesStatement{
+        "INSERT INTO projectPartsFiles(sourceId, projectPartId, "
         "sourceType, hasMissingIncludes) VALUES (?001, ?002, ?003, ?004) ON "
         "CONFLICT(sourceId, projectPartId) DO UPDATE SET sourceType = ?003, "
         "hasMissingIncludes = ?004",
@@ -255,7 +252,7 @@ public:
         "collectedDependencies WHERE sourceDependencies.sourceId == "
         "collectedDependencies.sourceId) SELECT sourceId, "
         "pchCreationTimeStamp, sourceType, hasMissingIncludes FROM "
-        "collectedDependencies NATURAL JOIN projectPartsSources WHERE "
+        "collectedDependencies NATURAL JOIN projectPartsFiles WHERE "
         "projectPartId = ? ORDER BY sourceId",
         database};
     mutable ReadStatement fetchProjectPartIdStatement{
@@ -269,11 +266,9 @@ public:
         database
     };
     WriteStatement updatePchCreationTimeStampStatement{
-        "UPDATE projectPartsSources SET pchCreationTimeStamp = ?001 WHERE "
-        "projectPartId = (SELECT "
-        "projectPartId FROM projectParts WHERE projectPartName = ?002)",
+        "UPDATE projectPartsFiles SET pchCreationTimeStamp = ?001 WHERE projectPartId = ?002",
         database};
-    WriteStatement deleteAllProjectPartsSourcesWithProjectPartNameStatement{
-        "DELETE FROM projectPartsSources WHERE projectPartId = ?", database};
+    WriteStatement deleteAllProjectPartsFilesWithProjectPartNameStatement{
+        "DELETE FROM projectPartsFiles WHERE projectPartId = ?", database};
 };
 }
diff --git a/src/tools/clangpchmanagerbackend/source/builddependenciesstorageinterface.h b/src/tools/clangpchmanagerbackend/source/builddependenciesstorageinterface.h
index 4edc47fce1..a56e88b1f2 100644
--- a/src/tools/clangpchmanagerbackend/source/builddependenciesstorageinterface.h
+++ b/src/tools/clangpchmanagerbackend/source/builddependenciesstorageinterface.h
@@ -30,6 +30,7 @@
 #include <builddependency.h>
 #include <filepathid.h>
 #include <filestatus.h>
+#include <projectpartid.h>
 #include <sourcedependency.h>
 #include <usedmacro.h>
 
@@ -44,20 +45,17 @@ public:
     BuildDependenciesStorageInterface(const BuildDependenciesStorageInterface &) = delete;
     BuildDependenciesStorageInterface &operator=(const BuildDependenciesStorageInterface &) = delete;
 
-    virtual void insertOrUpdateSources(const SourceEntries &sourceIds,
-                                       int projectPartId) = 0;
+    virtual void insertOrUpdateSources(const SourceEntries &sourceIds, ProjectPartId projectPartId) = 0;
     virtual void insertOrUpdateUsedMacros(const UsedMacros &usedMacros) = 0;
     virtual void
     insertOrUpdateFileStatuses(const FileStatuses &fileStatuses) = 0;
     virtual void insertOrUpdateSourceDependencies(const SourceDependencies &sourceDependencies) = 0;
     virtual long long fetchLowestLastModifiedTime(FilePathId sourceId) const = 0;
     virtual SourceEntries fetchDependSources(FilePathId sourceId,
-                                             int projectPartId) const = 0;
+                                             ProjectPartId projectPartId) const = 0;
     virtual UsedMacros fetchUsedMacros(FilePathId sourceId) const = 0;
-    virtual int fetchProjectPartId(Utils::SmallStringView projectPartName) = 0;
-    virtual void updatePchCreationTimeStamp(long long pchCreationTimeStamp,
-                                            Utils::SmallStringView projectPartName)
-        = 0;
+    virtual ProjectPartId fetchProjectPartId(Utils::SmallStringView projectPartName) = 0;
+    virtual void updatePchCreationTimeStamp(long long pchCreationTimeStamp, ProjectPartId projectPartId) = 0;
 
 protected:
     ~BuildDependenciesStorageInterface() = default;
diff --git a/src/tools/clangpchmanagerbackend/source/pchmanagerserver.cpp b/src/tools/clangpchmanagerbackend/source/pchmanagerserver.cpp
index 89ad912640..c1c12121aa 100644
--- a/src/tools/clangpchmanagerbackend/source/pchmanagerserver.cpp
+++ b/src/tools/clangpchmanagerbackend/source/pchmanagerserver.cpp
@@ -83,9 +83,9 @@ void PchManagerServer::removeProjectParts(RemoveProjectPartsMessage &&message)
 }
 
 namespace {
-Utils::SmallStringVector projectPartIds(const ProjectPartContainers &projectParts)
+ProjectPartIds projectPartIds(const ProjectPartContainers &projectParts)
 {
-    Utils::SmallStringVector ids;
+    ProjectPartIds ids;
     ids.reserve(projectParts.size());
 
     std::transform(projectParts.cbegin(),
@@ -118,7 +118,7 @@ void PchManagerServer::removeGeneratedFiles(RemoveGeneratedFilesMessage &&messag
     m_generatedFiles.remove(message.takeGeneratedFiles());
 }
 
-void PchManagerServer::pathsWithIdsChanged(const Utils::SmallStringVector &ids)
+void PchManagerServer::pathsWithIdsChanged(const ProjectPartIds &ids)
 {
     ArgumentsEntries entries = m_toolChainsArgumentsCache.arguments(ids);
 
diff --git a/src/tools/clangpchmanagerbackend/source/pchmanagerserver.h b/src/tools/clangpchmanagerbackend/source/pchmanagerserver.h
index 9cf8aa8321..cc9daa7aa4 100644
--- a/src/tools/clangpchmanagerbackend/source/pchmanagerserver.h
+++ b/src/tools/clangpchmanagerbackend/source/pchmanagerserver.h
@@ -57,7 +57,7 @@ public:
     void updateGeneratedFiles(UpdateGeneratedFilesMessage &&message) override;
     void removeGeneratedFiles(RemoveGeneratedFilesMessage &&message) override;
 
-    void pathsWithIdsChanged(const Utils::SmallStringVector &ids) override;
+    void pathsWithIdsChanged(const ProjectPartIds &ids) override;
     void pathsChanged(const FilePathIds &filePathIds) override;
 
     void setPchCreationProgress(int progress, int total);
diff --git a/src/tools/clangpchmanagerbackend/source/pchtask.h b/src/tools/clangpchmanagerbackend/source/pchtask.h
index 528d6e63f1..7d8879fcbd 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtask.h
+++ b/src/tools/clangpchmanagerbackend/source/pchtask.h
@@ -30,6 +30,7 @@
 #include <compilermacro.h>
 #include <filepath.h>
 #include <includesearchpath.h>
+#include <projectpartid.h>
 
 #include <utils/smallstringvector.h>
 #include <utils/cpplanguage_details.h>
@@ -39,11 +40,11 @@ namespace ClangBackEnd {
 class PchTask
 {
 public:
-    PchTask(Utils::SmallString &&projectPartId,
+    PchTask(ProjectPartId projectPartId,
             FilePathIds &&includes,
             FilePathIds &&sources,
             CompilerMacros &&compilerMacros,
-            Utils::SmallStringVector &&usedMacros,
+            Utils::SmallStringVector &&usedMacros, // TODO remove
             Utils::SmallStringVector toolChainArguments,
             IncludeSearchPaths systemIncludeSearchPaths,
             IncludeSearchPaths projectIncludeSearchPaths,
@@ -62,11 +63,11 @@ public:
         , languageExtension(languageExtension)
     {}
 
-    PchTask(Utils::SmallStringVector &&projectPartIds,
+    PchTask(ProjectPartIds &&projectPartIds,
             FilePathIds &&includes,
             FilePathIds &&sources,
             CompilerMacros &&compilerMacros,
-            Utils::SmallStringVector &&usedMacros,
+            Utils::SmallStringVector &&usedMacros, // TODO remove
             Utils::SmallStringVector toolChainArguments,
             IncludeSearchPaths systemIncludeSearchPaths,
             IncludeSearchPaths projectIncludeSearchPaths,
@@ -98,11 +99,11 @@ public:
                && first.languageExtension == second.languageExtension;
     }
 
-    Utils::SmallStringView projectPartId() const { return projectPartIds.front(); }
+    ProjectPartId projectPartId() const { return projectPartIds.front(); }
 
 public:
     FilePath systemPchPath;
-    Utils::SmallStringVector projectPartIds;
+    ProjectPartIds projectPartIds;
     FilePathIds includes;
     FilePathIds sources;
     CompilerMacros compilerMacros;
diff --git a/src/tools/clangpchmanagerbackend/source/pchtaskgenerator.cpp b/src/tools/clangpchmanagerbackend/source/pchtaskgenerator.cpp
index a44fc91b16..c0a42eae39 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtaskgenerator.cpp
+++ b/src/tools/clangpchmanagerbackend/source/pchtaskgenerator.cpp
@@ -49,7 +49,7 @@ void PchTaskGenerator::addProjectParts(ProjectPartContainers &&projectParts,
                                buildDependency.usedMacros,
                                projectPart.compilerMacros};
 
-        pchTaskSets.emplace_back(PchTask{projectPart.projectPartId.clone(),
+        pchTaskSets.emplace_back(PchTask{projectPart.projectPartId,
                                          std::move(filter.topSystemIncludes),
                                          {},
                                          std::move(filter.systemCompilerMacros),
@@ -60,7 +60,7 @@ void PchTaskGenerator::addProjectParts(ProjectPartContainers &&projectParts,
                                          projectPart.language,
                                          projectPart.languageVersion,
                                          projectPart.languageExtension},
-                                 PchTask{std::move(projectPart.projectPartId),
+                                 PchTask{projectPart.projectPartId,
                                          std::move(filter.topProjectIncludes),
                                          std::move(filter.sources),
                                          std::move(filter.projectCompilerMacros),
@@ -77,7 +77,7 @@ void PchTaskGenerator::addProjectParts(ProjectPartContainers &&projectParts,
     m_pchTasksMergerInterface.mergeTasks(std::move(pchTaskSets), std::move(toolChainArguments));
 }
 
-void PchTaskGenerator::removeProjectParts(const Utils::SmallStringVector &projectsPartIds)
+void PchTaskGenerator::removeProjectParts(const ProjectPartIds &projectsPartIds)
 {
     m_pchTasksMergerInterface.removePchTasks(projectsPartIds);
 }
diff --git a/src/tools/clangpchmanagerbackend/source/pchtaskgenerator.h b/src/tools/clangpchmanagerbackend/source/pchtaskgenerator.h
index 38376ce2a2..dc7d201cde 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtaskgenerator.h
+++ b/src/tools/clangpchmanagerbackend/source/pchtaskgenerator.h
@@ -50,8 +50,8 @@ public:
     {}
 
     void addProjectParts(ProjectPartContainers &&projectParts,
-                         Utils::SmallStringVector &&toolChainArguments);
-    void removeProjectParts(const Utils::SmallStringVector &projectsPartIds);
+                         Utils::SmallStringVector &&toolChainArguments) override;
+    void removeProjectParts(const ProjectPartIds &projectsPartIds) override;
 
 private:
     BuildDependenciesProviderInterface &m_buildDependenciesProvider;
diff --git a/src/tools/clangpchmanagerbackend/source/pchtaskgeneratorinterface.h b/src/tools/clangpchmanagerbackend/source/pchtaskgeneratorinterface.h
index 4546284265..abb25d2ef1 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtaskgeneratorinterface.h
+++ b/src/tools/clangpchmanagerbackend/source/pchtaskgeneratorinterface.h
@@ -35,7 +35,7 @@ public:
     virtual void addProjectParts(ProjectPartContainers &&projectParts,
                                  Utils::SmallStringVector &&toolChainArguments)
         = 0;
-    virtual void removeProjectParts(const Utils::SmallStringVector &projectsPartIds) = 0;
+    virtual void removeProjectParts(const ProjectPartIds &projectsPartIds) = 0;
 
 protected:
     ~PchTaskGeneratorInterface() = default;
diff --git a/src/tools/clangpchmanagerbackend/source/pchtaskqueue.cpp b/src/tools/clangpchmanagerbackend/source/pchtaskqueue.cpp
index 6c1a09fd3e..2abe3fa394 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtaskqueue.cpp
+++ b/src/tools/clangpchmanagerbackend/source/pchtaskqueue.cpp
@@ -54,18 +54,18 @@ void PchTaskQueue::addPchTasks(PchTasks &&newPchTasks, PchTasks &destination)
     m_progressCounter.addTotal(int(destination.size() - oldSize));
 }
 
-void PchTaskQueue::removePchTasksByProjectPartId(const Utils::SmallStringVector &projectsPartIds,
+void PchTaskQueue::removePchTasksByProjectPartId(const ProjectPartIds &projectsPartIds,
                                                  PchTasks &destination)
 {
     class CompareDifference
     {
     public:
-        bool operator()(const PchTask &first, const Utils::SmallString &second)
+        bool operator()(const PchTask &first, ProjectPartId second)
         {
             return first.projectPartId() < second;
         }
 
-        bool operator()(const Utils::SmallString &first, const PchTask &second)
+        bool operator()(ProjectPartId first, const PchTask &second)
         {
             return first < second.projectPartId();
         }
@@ -97,7 +97,7 @@ void PchTaskQueue::addProjectPchTasks(PchTasks &&pchTasks)
     addPchTasks(std::move(pchTasks), m_projectPchTasks);
 }
 
-void PchTaskQueue::removePchTasks(const Utils::SmallStringVector &projectsPartIds)
+void PchTaskQueue::removePchTasks(const ProjectPartIds &projectsPartIds)
 {
     removePchTasksByProjectPartId(projectsPartIds, m_projectPchTasks);
 }
diff --git a/src/tools/clangpchmanagerbackend/source/pchtaskqueue.h b/src/tools/clangpchmanagerbackend/source/pchtaskqueue.h
index 5d00419817..2d6d76ee58 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtaskqueue.h
+++ b/src/tools/clangpchmanagerbackend/source/pchtaskqueue.h
@@ -56,7 +56,7 @@ public:
 
     void addSystemPchTasks(PchTasks &&pchTasks) override;
     void addProjectPchTasks(PchTasks &&pchTasks) override;
-    void removePchTasks(const Utils::SmallStringVector &projectsPartIds) override;
+    void removePchTasks(const ProjectPartIds &projectsPartIds) override;
 
     void processEntries() override;
 
@@ -68,8 +68,7 @@ public:
 
 private:
     void addPchTasks(PchTasks &&pchTasks, PchTasks &destination);
-    void removePchTasksByProjectPartId(const Utils::SmallStringVector &projectsPartIds,
-                                       PchTasks &destination);
+    void removePchTasksByProjectPartId(const ProjectPartIds &projectsPartIds, PchTasks &destination);
     void processProjectPchTasks();
     void processSystemPchTasks();
 
diff --git a/src/tools/clangpchmanagerbackend/source/pchtaskqueueinterface.h b/src/tools/clangpchmanagerbackend/source/pchtaskqueueinterface.h
index 45e1db8f9d..31c709d1a9 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtaskqueueinterface.h
+++ b/src/tools/clangpchmanagerbackend/source/pchtaskqueueinterface.h
@@ -35,7 +35,7 @@ class PchTaskQueueInterface : public QueueInterface
 public:
     virtual void addSystemPchTasks(PchTasks &&pchTasks) = 0;
     virtual void addProjectPchTasks(PchTasks &&pchTasks) = 0;
-    virtual void removePchTasks(const Utils::SmallStringVector &projectsPartIds) = 0;
+    virtual void removePchTasks(const ProjectPartIds &projectsPartIds) = 0;
 
 protected:
     ~PchTaskQueueInterface() = default;
diff --git a/src/tools/clangpchmanagerbackend/source/pchtasksmerger.cpp b/src/tools/clangpchmanagerbackend/source/pchtasksmerger.cpp
index 65d1a3e9fe..7e850b8947 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtasksmerger.cpp
+++ b/src/tools/clangpchmanagerbackend/source/pchtasksmerger.cpp
@@ -37,7 +37,7 @@ void PchTasksMerger::mergeTasks(PchTaskSets &&taskSets,
     m_pchTaskQueue.processEntries();
 }
 
-void PchTasksMerger::removePchTasks(const Utils::SmallStringVector &projectPartIds)
+void PchTasksMerger::removePchTasks(const ProjectPartIds &projectPartIds)
 {
     m_pchTaskQueue.removePchTasks(projectPartIds);
 }
diff --git a/src/tools/clangpchmanagerbackend/source/pchtasksmerger.h b/src/tools/clangpchmanagerbackend/source/pchtasksmerger.h
index 26df2022b4..5481a50dff 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtasksmerger.h
+++ b/src/tools/clangpchmanagerbackend/source/pchtasksmerger.h
@@ -40,7 +40,7 @@ public:
     {}
 
     void mergeTasks(PchTaskSets &&taskSets, Utils::SmallStringVector &&toolChainArguments) override;
-    void removePchTasks(const Utils::SmallStringVector &projectPartIds) override;
+    void removePchTasks(const ProjectPartIds &projectPartIds) override;
 
     static CompilerMacros mergeMacros(const CompilerMacros &firstCompilerMacros,
                                       const CompilerMacros &secondCompilerMacros);
diff --git a/src/tools/clangpchmanagerbackend/source/pchtasksmergerinterface.h b/src/tools/clangpchmanagerbackend/source/pchtasksmergerinterface.h
index a691766b49..69f1e0470a 100644
--- a/src/tools/clangpchmanagerbackend/source/pchtasksmergerinterface.h
+++ b/src/tools/clangpchmanagerbackend/source/pchtasksmergerinterface.h
@@ -32,7 +32,7 @@ class PchTasksMergerInterface
 {
 public:
     virtual void mergeTasks(PchTaskSets &&taskSets, Utils::SmallStringVector &&toolChainArguments) = 0;
-    virtual void removePchTasks(const Utils::SmallStringVector &projectPartIds) = 0;
+    virtual void removePchTasks(const ProjectPartIds &projectPartIds) = 0;
 
 protected:
     ~PchTasksMergerInterface() = default;
diff --git a/src/tools/clangpchmanagerbackend/source/precompiledheaderstorage.h b/src/tools/clangpchmanagerbackend/source/precompiledheaderstorage.h
index 7d1069b998..e1b2f8aa2e 100644
--- a/src/tools/clangpchmanagerbackend/source/precompiledheaderstorage.h
+++ b/src/tools/clangpchmanagerbackend/source/precompiledheaderstorage.h
@@ -41,129 +41,125 @@ class PrecompiledHeaderStorage final : public PrecompiledHeaderStorageInterface
     using WriteStatement = typename Database::WriteStatement;
 public:
     PrecompiledHeaderStorage(Database &database)
-        : m_transaction(database),
-          m_database(database)
+        : transaction(database)
+        , database(database)
     {
-        m_transaction.commit();
+        transaction.commit();
     }
 
-    void insertProjectPrecompiledHeader(Utils::SmallStringView projectPartName,
+    void insertProjectPrecompiledHeader(ProjectPartId projectPartId,
                                         Utils::SmallStringView pchPath,
                                         long long pchBuildTime) override
     {
         try {
-            Sqlite::ImmediateTransaction transaction{m_database};
+            Sqlite::ImmediateTransaction transaction{database};
 
-            m_insertProjectPartStatement.write(projectPartName);
-            m_insertProjectPrecompiledHeaderStatement.write(projectPartName, pchPath, pchBuildTime);
+            insertProjectPrecompiledHeaderStatement.write(projectPartId.projectPathId,
+                                                          pchPath,
+                                                          pchBuildTime);
 
             transaction.commit();
-        } catch (const Sqlite::StatementIsBusy) {
-            insertProjectPrecompiledHeader(projectPartName, pchPath, pchBuildTime);
+        } catch (const Sqlite::StatementIsBusy &) {
+            insertProjectPrecompiledHeader(projectPartId, pchPath, pchBuildTime);
         }
     }
 
-    void deleteProjectPrecompiledHeader(Utils::SmallStringView projectPartName) override
+    void deleteProjectPrecompiledHeader(ProjectPartId projectPartId) override
     {
         try {
-            Sqlite::ImmediateTransaction transaction{m_database};
+            Sqlite::ImmediateTransaction transaction{database};
 
-            m_deleteProjectPrecompiledHeaderStatement.write(projectPartName);
+            deleteProjectPrecompiledHeaderStatement.write(projectPartId.projectPathId);
 
             transaction.commit();
         } catch (const Sqlite::StatementIsBusy) {
-            deleteProjectPrecompiledHeader(projectPartName);
+            deleteProjectPrecompiledHeader(projectPartId);
         }
     }
 
-    void insertSystemPrecompiledHeaders(const Utils::SmallStringVector &projectPartNames,
+    void insertSystemPrecompiledHeaders(const ProjectPartIds &projectPartIds,
                                         Utils::SmallStringView pchPath,
                                         long long pchBuildTime) override
     {
         try {
-            Sqlite::ImmediateTransaction transaction{m_database};
+            Sqlite::ImmediateTransaction transaction{database};
 
-            for (Utils::SmallStringView projectPartName : projectPartNames) {
-                m_insertProjectPartStatement.write(projectPartName);
-                m_insertSystemPrecompiledHeaderStatement.write(projectPartName, pchPath, pchBuildTime);
+            for (ProjectPartId projectPartId : projectPartIds) {
+                insertSystemPrecompiledHeaderStatement.write(projectPartId.projectPathId,
+                                                             pchPath,
+                                                             pchBuildTime);
             }
             transaction.commit();
         } catch (const Sqlite::StatementIsBusy) {
-            insertSystemPrecompiledHeaders(projectPartNames, pchPath, pchBuildTime);
+            insertSystemPrecompiledHeaders(projectPartIds, pchPath, pchBuildTime);
         }
     }
 
-    void deleteSystemPrecompiledHeaders(const Utils::SmallStringVector &projectPartNames) override
+    void deleteSystemPrecompiledHeaders(const ProjectPartIds &projectPartIds) override
     {
         try {
-            Sqlite::ImmediateTransaction transaction{m_database};
+            Sqlite::ImmediateTransaction transaction{database};
 
-            for (Utils::SmallStringView projectPartName : projectPartNames)
-                m_deleteSystemPrecompiledHeaderStatement.write(projectPartName);
+            for (ProjectPartId projectPartId : projectPartIds)
+                deleteSystemPrecompiledHeaderStatement.write(projectPartId.projectPathId);
 
             transaction.commit();
         } catch (const Sqlite::StatementIsBusy) {
-            deleteSystemPrecompiledHeaders(projectPartNames);
+            deleteSystemPrecompiledHeaders(projectPartIds);
         }
     }
 
-    FilePath fetchSystemPrecompiledHeaderPath(Utils::SmallStringView projectPartName) override
+    FilePath fetchSystemPrecompiledHeaderPath(ProjectPartId projectPartId) override
     {
         try {
-            Sqlite::DeferredTransaction transaction{m_database};
+            Sqlite::DeferredTransaction transaction{database};
 
-            auto value = m_fetchSystemPrecompiledHeaderPathStatement.template value<FilePath>(
-                projectPartName);
+            auto value = fetchSystemPrecompiledHeaderPathStatement.template value<FilePath>(
+                projectPartId.projectPathId);
 
             if (value)
-                return value.value();
+                return *value;
 
             transaction.commit();
         } catch (const Sqlite::StatementIsBusy) {
-            return fetchSystemPrecompiledHeaderPath(projectPartName);
+            return fetchSystemPrecompiledHeaderPath(projectPartId);
         }
 
         return FilePath("");
     }
 
-    Utils::optional<ProjectPartPch> fetchPrecompiledHeader(int projectPartId) const
+    Utils::optional<ProjectPartPch> fetchPrecompiledHeader(ProjectPartId projectPartId) const
     {
-        return m_getPrecompiledHeader.template value<ProjectPartPch, 2>(projectPartId);
+        return getPrecompiledHeader.template value<ProjectPartPch, 3>(projectPartId.projectPathId);
     }
 
 public:
-    Sqlite::ImmediateNonThrowingDestructorTransaction m_transaction;
-    Database &m_database;
-    WriteStatement m_insertProjectPrecompiledHeaderStatement{
+    Sqlite::ImmediateNonThrowingDestructorTransaction transaction;
+    Database &database;
+    WriteStatement insertProjectPrecompiledHeaderStatement{
         "INSERT INTO precompiledHeaders(projectPartId, projectPchPath, projectPchBuildTime) "
         "VALUES((SELECT projectPartId FROM projectParts WHERE projectPartName = ?001),?002,?003) "
         "ON CONFLICT (projectPartId) DO UPDATE SET projectPchPath=?002,projectPchBuildTime=?003",
-        m_database};
-    WriteStatement m_insertSystemPrecompiledHeaderStatement{
+        database};
+    WriteStatement insertSystemPrecompiledHeaderStatement{
         "INSERT INTO precompiledHeaders(projectPartId, systemPchPath, systemPchBuildTime) "
-        "VALUES((SELECT projectPartId FROM projectParts WHERE projectPartName = ?001),?002,?003) "
+        "VALUES(?001,?002,?003) "
         "ON CONFLICT (projectPartId) DO UPDATE SET systemPchPath=?002,systemPchBuildTime=?003",
-        m_database};
-    WriteStatement m_insertProjectPartStatement{
-        "INSERT OR IGNORE INTO projectParts(projectPartName) VALUES (?)", m_database};
-    WriteStatement m_deleteProjectPrecompiledHeaderStatement{
+        database};
+    WriteStatement deleteProjectPrecompiledHeaderStatement{
         "UPDATE OR IGNORE precompiledHeaders SET projectPchPath=NULL,projectPchBuildTime=NULL "
-        "WHERE projectPartId = (SELECT projectPartId FROM "
-        "projectParts WHERE projectPartName = ?)",
-        m_database};
-    WriteStatement m_deleteSystemPrecompiledHeaderStatement{
+        "WHERE projectPartId = ?",
+        database};
+    WriteStatement deleteSystemPrecompiledHeaderStatement{
         "UPDATE OR IGNORE precompiledHeaders SET systemPchPath=NULL,systemPchBuildTime=NULL "
-        "WHERE projectPartId = (SELECT projectPartId FROM "
-        "projectParts WHERE projectPartName = ?)",
-        m_database};
-    ReadStatement m_fetchSystemPrecompiledHeaderPathStatement{
-        "SELECT systemPchPath FROM precompiledHeaders WHERE projectPartId = (SELECT projectPartId "
-        "FROM projectParts WHERE projectPartName = ?)",
-        m_database};
-    mutable ReadStatement m_getPrecompiledHeader{
-        "SELECT ifnull(nullif(projectPchPath, ''), systemPchPath), "
+        "WHERE projectPartId = ?",
+        database};
+    ReadStatement fetchSystemPrecompiledHeaderPathStatement{
+        "SELECT systemPchPath FROM precompiledHeaders WHERE projectPartId = ?", database};
+    mutable ReadStatement getPrecompiledHeader{
+        "SELECT projectPartId, ifnull(nullif(projectPchPath, ''), systemPchPath), "
         "projectPchBuildTime FROM precompiledHeaders WHERE projectPartId = ?",
-        m_database};
+        database};
 };
 
 }
diff --git a/src/tools/clangpchmanagerbackend/source/precompiledheaderstorageinterface.h b/src/tools/clangpchmanagerbackend/source/precompiledheaderstorageinterface.h
index 06833be4a2..e2a2b4a3b6 100644
--- a/src/tools/clangpchmanagerbackend/source/precompiledheaderstorageinterface.h
+++ b/src/tools/clangpchmanagerbackend/source/precompiledheaderstorageinterface.h
@@ -28,6 +28,7 @@
 #include "projectpartpch.h"
 
 #include <filepath.h>
+#include <projectpartid.h>
 
 #include <utils/smallstringvector.h>
 #include <utils/optional.h>
@@ -42,18 +43,18 @@ public:
     PrecompiledHeaderStorageInterface(const PrecompiledHeaderStorageInterface &) = delete;
     PrecompiledHeaderStorageInterface &operator=(const PrecompiledHeaderStorageInterface &) = delete;
 
-    virtual void insertProjectPrecompiledHeader(Utils::SmallStringView projectPartName,
+    virtual void insertProjectPrecompiledHeader(ProjectPartId projectPartId,
                                                 Utils::SmallStringView pchPath,
                                                 long long pchBuildTime)
         = 0;
-    virtual void deleteProjectPrecompiledHeader(Utils::SmallStringView projectPartName) = 0;
-    virtual void insertSystemPrecompiledHeaders(const Utils::SmallStringVector &projectPartNames,
+    virtual void deleteProjectPrecompiledHeader(ProjectPartId projectPartName) = 0;
+    virtual void insertSystemPrecompiledHeaders(const ProjectPartIds &projectPartIds,
                                                 Utils::SmallStringView pchPath,
                                                 long long pchBuildTime)
         = 0;
-    virtual void deleteSystemPrecompiledHeaders(const Utils::SmallStringVector &projectPartNames) = 0;
-    virtual FilePath fetchSystemPrecompiledHeaderPath(Utils::SmallStringView projectPartName) = 0;
-    virtual Utils::optional<ProjectPartPch> fetchPrecompiledHeader(int projectPartId) const = 0;
+    virtual void deleteSystemPrecompiledHeaders(const ProjectPartIds &projectPartIds) = 0;
+    virtual FilePath fetchSystemPrecompiledHeaderPath(ProjectPartId projectPartId) = 0;
+    virtual Utils::optional<ProjectPartPch> fetchPrecompiledHeader(ProjectPartId projectPartId) const = 0;
 
 protected:
     ~PrecompiledHeaderStorageInterface() = default;
diff --git a/src/tools/clangpchmanagerbackend/source/projectpartsmanager.cpp b/src/tools/clangpchmanagerbackend/source/projectpartsmanager.cpp
index 8333ed9674..ada99f44cd 100644
--- a/src/tools/clangpchmanagerbackend/source/projectpartsmanager.cpp
+++ b/src/tools/clangpchmanagerbackend/source/projectpartsmanager.cpp
@@ -32,44 +32,115 @@
 namespace ClangBackEnd {
 
 inline namespace Pch {
+ProjectPartIds toProjectPartIds(const ProjectPartContainers &projectsParts)
+{
+    ProjectPartIds ids;
+    ids.reserve(projectsParts.size());
+    std::transform(projectsParts.begin(),
+                   projectsParts.end(),
+                   std::back_inserter(ids),
+                   [](const auto &projectPart) { return projectPart.projectPartId; });
+
+    return ids;
+}
 
 ProjectPartContainers ProjectPartsManager::update(ProjectPartContainers &&projectsParts)
 {
-    auto updatedProjectPartContainers = newProjectParts(std::move(projectsParts));
+    auto updatedProjectParts = filterNewProjectParts(std::move(projectsParts), m_projectParts);
 
-    mergeProjectParts(updatedProjectPartContainers);
+    if (updatedProjectParts.empty())
+        return {};
 
-    return updatedProjectPartContainers;
+    auto persistentProjectParts = m_projectPartsStorage.fetchProjectParts(
+        toProjectPartIds(updatedProjectParts));
+
+    if (persistentProjectParts.size() > 0) {
+        mergeProjectParts(persistentProjectParts);
+
+        updatedProjectParts = filterNewProjectParts(std::move(updatedProjectParts),
+                                                    persistentProjectParts);
+
+        if (updatedProjectParts.empty())
+            return {};
+    }
+
+    m_projectPartsStorage.updateProjectParts(updatedProjectParts);
+
+    mergeProjectParts(updatedProjectParts);
+
+    return updatedProjectParts;
 }
 
-void ProjectPartsManager::remove(const Utils::SmallStringVector &ids)
+void ProjectPartsManager::remove(const ProjectPartIds &projectPartIds)
 {
-    auto shouldRemove = [&] (const ProjectPartContainer &projectPart) {
-        return std::find(ids.begin(), ids.end(), projectPart.projectPartId) != ids.end();
+    ProjectPartContainers projectPartsWithoutIds;
+
+    struct Compare
+    {
+        bool operator()(ProjectPartId first, const ProjectPartContainer &second)
+        {
+            return first < second.projectPartId;
+        }
+
+        bool operator()(ProjectPartId first, const ProjectPartId &second) { return first < second; }
+
+        bool operator()(const ProjectPartContainer &first, const ProjectPartContainer &second)
+        {
+            return first.projectPartId < second.projectPartId;
+        }
+
+        bool operator()(const ProjectPartContainer &first, ProjectPartId second)
+        {
+            return first.projectPartId < second;
+        }
     };
 
-    auto newEnd = std::remove_if(m_projectParts.begin(), m_projectParts.end(), shouldRemove);
-    m_projectParts.erase(newEnd, m_projectParts.end());
+    std::set_difference(std::make_move_iterator(m_projectParts.begin()),
+                        std::make_move_iterator(m_projectParts.end()),
+                        projectPartIds.begin(),
+                        projectPartIds.end(),
+                        std::back_inserter(projectPartsWithoutIds),
+                        Compare{});
+
+    m_projectParts = std::move(projectPartsWithoutIds);
 }
 
-ProjectPartContainers ProjectPartsManager::projects(const Utils::SmallStringVector &projectPartIds) const
+ProjectPartContainers ProjectPartsManager::projects(const ProjectPartIds &projectPartIds) const
 {
     ProjectPartContainers projectPartsWithIds;
 
-    std::copy_if(m_projectParts.begin(),
-                 m_projectParts.end(),
-                 std::back_inserter(projectPartsWithIds),
-                 [&] (const ProjectPartContainer &projectPart) {
-        return std::binary_search(projectPartIds.begin(), projectPartIds.end(), projectPart.projectPartId);
-    });
+    struct Compare
+    {
+        bool operator()(ProjectPartId first, const ProjectPartContainer &second)
+        {
+            return first < second.projectPartId;
+        }
+
+        bool operator()(ProjectPartId first, const ProjectPartId &second) { return first < second; }
+
+        bool operator()(const ProjectPartContainer &first, const ProjectPartContainer &second)
+        {
+            return first.projectPartId < second.projectPartId;
+        }
+
+        bool operator()(const ProjectPartContainer &first, ProjectPartId second)
+        {
+            return first.projectPartId < second;
+        }
+    };
+
+    std::set_intersection(m_projectParts.begin(),
+                          m_projectParts.end(),
+                          projectPartIds.begin(),
+                          projectPartIds.end(),
+                          std::back_inserter(projectPartsWithIds),
+                          Compare{});
 
     return projectPartsWithIds;
 }
 
 void ProjectPartsManager::updateDeferred(const ProjectPartContainers &deferredProjectsParts)
 {
-    using ProjectPartContainerReferences = std::vector<std::reference_wrapper<ProjectPartContainer>>;
-
     ProjectPartContainerReferences deferredProjectPartPointers;
     deferredProjectPartPointers.reserve(deferredProjectsParts.size());
 
@@ -102,15 +173,16 @@ ProjectPartContainers ProjectPartsManager::deferredUpdates()
     return deferredProjectParts;
 }
 
-ProjectPartContainers ProjectPartsManager::newProjectParts(ProjectPartContainers &&projectsParts) const
+ProjectPartContainers ProjectPartsManager::filterNewProjectParts(
+    ProjectPartContainers &&projectsParts, const ProjectPartContainers &oldProjectParts)
 {
     ProjectPartContainers updatedProjectPartContainers;
     updatedProjectPartContainers.reserve(projectsParts.size());
 
     std::set_difference(std::make_move_iterator(projectsParts.begin()),
                         std::make_move_iterator(projectsParts.end()),
-                        m_projectParts.begin(),
-                        m_projectParts.end(),
+                        oldProjectParts.begin(),
+                        oldProjectParts.end(),
                         std::back_inserter(updatedProjectPartContainers));
 
     return updatedProjectPartContainers;
diff --git a/src/tools/clangpchmanagerbackend/source/projectpartsmanager.h b/src/tools/clangpchmanagerbackend/source/projectpartsmanager.h
index 2b3c43ebc8..6583db25c6 100644
--- a/src/tools/clangpchmanagerbackend/source/projectpartsmanager.h
+++ b/src/tools/clangpchmanagerbackend/source/projectpartsmanager.h
@@ -28,6 +28,7 @@
 #include "clangpchmanagerbackend_global.h"
 
 #include <projectpartsmanagerinterface.h>
+#include <projectpartsstorageinterface.h>
 
 #include <utils/smallstringvector.h>
 
@@ -37,18 +38,24 @@ inline namespace Pch {
 class ProjectPartsManager final : public ProjectPartsManagerInterface
 {
 public:
+    ProjectPartsManager(ProjectPartsStorageInterface &projectPartsStorage)
+        : m_projectPartsStorage(projectPartsStorage)
+    {}
+
     ProjectPartContainers update(ProjectPartContainers &&projectsParts) override;
-    void remove(const Utils::SmallStringVector &projectPartIds) override;
-    ProjectPartContainers projects(const Utils::SmallStringVector &projectPartIds) const override;
+    void remove(const ProjectPartIds &projectPartIds) override;
+    ProjectPartContainers projects(const ProjectPartIds &projectPartIds) const override;
     void updateDeferred(const ProjectPartContainers &projectsParts) override;
     ProjectPartContainers deferredUpdates() override;
 
-    ProjectPartContainers newProjectParts(ProjectPartContainers &&projectsParts) const;
+    static ProjectPartContainers filterNewProjectParts(ProjectPartContainers &&newProjectsParts,
+                                                       const ProjectPartContainers &oldProjectParts);
     void mergeProjectParts(const ProjectPartContainers &projectsParts);
     const ProjectPartContainers &projectParts() const;
 
 private:
     ProjectPartContainers m_projectParts;
+    ProjectPartsStorageInterface &m_projectPartsStorage;
 };
 
 } // namespace Pch
diff --git a/src/tools/clangpchmanagerbackend/source/projectpartsmanagerinterface.h b/src/tools/clangpchmanagerbackend/source/projectpartsmanagerinterface.h
index f99674ddda..ee80173f8a 100644
--- a/src/tools/clangpchmanagerbackend/source/projectpartsmanagerinterface.h
+++ b/src/tools/clangpchmanagerbackend/source/projectpartsmanagerinterface.h
@@ -37,10 +37,11 @@ public:
     ProjectPartsManagerInterface &operator=(const ProjectPartsManagerInterface &) = delete;
 
     virtual ProjectPartContainers update(ProjectPartContainers &&projectsParts) = 0;
-    virtual void remove(const Utils::SmallStringVector &projectPartIds) = 0;
-    virtual ProjectPartContainers projects(const Utils::SmallStringVector &projectPartIds) const = 0;
+    virtual void remove(const ProjectPartIds &projectPartIds) = 0;
+    virtual ProjectPartContainers projects(const ProjectPartIds &projectPartIds) const = 0;
     virtual void updateDeferred(const ProjectPartContainers &projectsParts) = 0;
     virtual ProjectPartContainers deferredUpdates() = 0;
+
 protected:
     ~ProjectPartsManagerInterface() = default;
 };
diff --git a/src/tools/clangpchmanagerbackend/source/toolchainargumentscache.h b/src/tools/clangpchmanagerbackend/source/toolchainargumentscache.h
index 4921b29a21..ed5ab3b1fd 100644
--- a/src/tools/clangpchmanagerbackend/source/toolchainargumentscache.h
+++ b/src/tools/clangpchmanagerbackend/source/toolchainargumentscache.h
@@ -33,19 +33,19 @@ namespace ClangBackEnd {
 
 struct ArgumentsEntry
 {
-    ArgumentsEntry(Utils::SmallStringVector &&ids, const Utils::SmallStringVector &arguments)
+    ArgumentsEntry(ProjectPartIds &&ids, const Utils::SmallStringVector &arguments)
         : ids(std::move(ids))
         , arguments(arguments)
     {}
 
-    ArgumentsEntry(const Utils::SmallStringVector &ids, const Utils::SmallStringVector &arguments)
+    ArgumentsEntry(ProjectPartIds &ids, const Utils::SmallStringVector &arguments)
         : ids(ids)
         , arguments(arguments)
     {}
 
-    void mergeIds(Utils::SmallStringVector &&newIds)
+    void mergeIds(ProjectPartIds &&newIds)
     {
-        Utils::SmallStringVector mergedIds;
+        ProjectPartIds mergedIds;
         mergedIds.reserve(ids.size() + newIds.size());
 
         std::set_union(std::make_move_iterator(ids.begin()),
@@ -54,12 +54,12 @@ struct ArgumentsEntry
                        std::make_move_iterator(newIds.end()),
                        std::back_inserter(mergedIds));
 
-        ids = mergedIds;
+        ids = std::move(mergedIds);
     }
 
-    void removeIds(const Utils::SmallStringVector &idsToBeRemoved)
+    void removeIds(const ProjectPartIds &idsToBeRemoved)
     {
-        Utils::SmallStringVector idsWithout;
+        ProjectPartIds idsWithout;
         idsWithout.reserve(ids.size());
         std::set_difference(std::make_move_iterator(ids.begin()),
                             std::make_move_iterator(ids.end()),
@@ -67,10 +67,10 @@ struct ArgumentsEntry
                             idsToBeRemoved.end(),
                             std::back_inserter(idsWithout));
 
-        ids = idsWithout;
+        ids = std::move(idsWithout);
     }
 
-    Utils::SmallStringVector ids;
+    ProjectPartIds ids;
     Utils::SmallStringVector arguments;
 };
 
@@ -118,11 +118,11 @@ public:
         removeEmptyEntries();
     }
 
-    void remove(const Utils::SmallStringVector &idsToBeRemoved)
+    void remove(const ProjectPartIds &idsToBeRemoved)
     {
         ArgumentsEntries entries;
         for (ArgumentsEntry &entry : m_argumentEntries) {
-            Utils::SmallStringVector usedIds;
+            ProjectPartIds usedIds;
             std::set_difference(entry.ids.begin(),
                                 entry.ids.end(),
                                 idsToBeRemoved.begin(),
@@ -135,11 +135,11 @@ public:
         removeEmptyEntries();
     }
 
-    ArgumentsEntries arguments(const Utils::SmallStringVector &ids) const
+    ArgumentsEntries arguments(const ProjectPartIds &ids) const
     {
         ArgumentsEntries entries;
         for (const ArgumentsEntry &entry : m_argumentEntries) {
-            Utils::SmallStringVector usedIds;
+            ProjectPartIds usedIds;
             std::set_intersection(entry.ids.begin(),
                                   entry.ids.end(),
                                   ids.begin(),
@@ -159,9 +159,9 @@ public:
     }
 
 private:
-    static Utils::SmallStringVector createIds(const ProjectPartContainers &projectParts)
+    static ProjectPartIds createIds(const ProjectPartContainers &projectParts)
     {
-        Utils::SmallStringVector ids;
+        ProjectPartIds ids;
         ids.reserve(projectParts.size());
         for (const auto &projectPart : projectParts)
             ids.emplace_back(projectPart.projectPartId);
@@ -181,7 +181,7 @@ private:
     }
 
 private:
-    std::vector<ArgumentsEntry> m_argumentEntries;
+    ArgumentsEntries m_argumentEntries;
 };
 
 }
diff --git a/src/tools/clangrefactoringbackend/source/clangrefactoringbackend-source.pri b/src/tools/clangrefactoringbackend/source/clangrefactoringbackend-source.pri
index fb1671aaf7..fcac51f226 100644
--- a/src/tools/clangrefactoringbackend/source/clangrefactoringbackend-source.pri
+++ b/src/tools/clangrefactoringbackend/source/clangrefactoringbackend-source.pri
@@ -17,8 +17,6 @@ HEADERS += \
     $$PWD/usedmacro.h \
     $$PWD/sourcedependency.h \
     $$PWD/filestatus.h \
-    $$PWD/projectpartartefactexception.h \
-    $$PWD/projectpartartefact.h \
     $$PWD/filestatuscache.h \
     $$PWD/indexdataconsumer.h \
     $$PWD/sourcesmanager.h \
@@ -68,5 +66,4 @@ HEADERS += \
 SOURCES += \
     $$PWD/sourcerangefilter.cpp \
     $$PWD/symbolindexer.cpp \
-    $$PWD/projectpartartefact.cpp \
     $$PWD/filestatuscache.cpp
diff --git a/src/tools/clangrefactoringbackend/source/collectmacrospreprocessorcallbacks.h b/src/tools/clangrefactoringbackend/source/collectmacrospreprocessorcallbacks.h
index 689e291098..1d16b0f5e1 100644
--- a/src/tools/clangrefactoringbackend/source/collectmacrospreprocessorcallbacks.h
+++ b/src/tools/clangrefactoringbackend/source/collectmacrospreprocessorcallbacks.h
@@ -209,7 +209,7 @@ public:
                     if (usr) {
                         m_symbolEntries.emplace(std::piecewise_construct,
                                                 std::forward_as_tuple(globalId),
-                                                std::forward_as_tuple(std::move(usr.value()),
+                                                std::forward_as_tuple(std::move(*usr),
                                                                       macroName,
                                                                       SymbolKind::Macro));
                     }
diff --git a/src/tools/clangrefactoringbackend/source/indexdataconsumer.cpp b/src/tools/clangrefactoringbackend/source/indexdataconsumer.cpp
index 35cc0df219..86e5fb597c 100644
--- a/src/tools/clangrefactoringbackend/source/indexdataconsumer.cpp
+++ b/src/tools/clangrefactoringbackend/source/indexdataconsumer.cpp
@@ -149,7 +149,7 @@ bool IndexDataConsumer::handleDeclOccurence(
                 auto  kindAndTags = symbolKindAndTags(declaration);
                 m_symbolEntries.emplace(std::piecewise_construct,
                                         std::forward_as_tuple(globalId),
-                                        std::forward_as_tuple(std::move(usr.value()),
+                                        std::forward_as_tuple(std::move(*usr),
                                                               symbolName(namedDeclaration),
                                                               kindAndTags.first,
                                                               kindAndTags.second));
diff --git a/src/tools/clangrefactoringbackend/source/projectpartartefact.cpp b/src/tools/clangrefactoringbackend/source/projectpartartefact.cpp
deleted file mode 100644
index 7623f38796..0000000000
--- a/src/tools/clangrefactoringbackend/source/projectpartartefact.cpp
+++ /dev/null
@@ -1,130 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2017 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt Creator.
-**
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-****************************************************************************/
-
-#include "projectpartartefact.h"
-
-#include <utils/algorithm.h>
-
-#include <QJsonArray>
-#include <QJsonDocument>
-#include <QJsonObject>
-
-namespace ClangBackEnd {
-
-
-
-Utils::SmallStringVector ProjectPartArtefact::toStringVector(Utils::SmallStringView jsonText)
-{
-    if (jsonText.isEmpty())
-        return {};
-
-    QJsonDocument document = createJsonDocument(jsonText, "Compiler arguments parsing error");
-
-    return Utils::transform<Utils::SmallStringVector>(document.array(), [] (const QJsonValue &value) {
-        return Utils::SmallString{value.toString()};
-    });
-}
-
-CompilerMacros ProjectPartArtefact::createCompilerMacrosFromDocument(const QJsonDocument &document)
-{
-    QJsonArray array = document.array();
-    CompilerMacros macros;
-    macros.reserve(array.size());
-
-    for (const QJsonValueRef entry : array) {
-        const QJsonArray entryArray = entry.toArray();
-        macros.emplace_back(
-            entryArray[0].toString(), entryArray[1].toString(), entryArray[2].toInt());
-    }
-
-    std::sort(macros.begin(), macros.end());
-
-    return macros;
-}
-
-IncludeSearchPaths ProjectPartArtefact::createIncludeSearchPathsFromDocument(const QJsonDocument &document)
-{
-    QJsonArray array = document.array();
-    IncludeSearchPaths paths;
-    paths.reserve(array.size());
-
-    for (const QJsonValueRef entry : array) {
-        const QJsonArray entryArray = entry.toArray();
-        paths.emplace_back(entryArray[0].toString(), entryArray[1].toInt(), entryArray[2].toInt());
-    }
-
-    return paths;
-}
-
-CompilerMacros ProjectPartArtefact::toCompilerMacros(Utils::SmallStringView jsonText)
-{
-    if (jsonText.isEmpty())
-        return {};
-
-    QJsonDocument document = createJsonDocument(jsonText, "Compiler macros parsing error");
-
-    return createCompilerMacrosFromDocument(document);
-}
-
-QJsonDocument ProjectPartArtefact::createJsonDocument(Utils::SmallStringView jsonText,
-                                                      const char *whatError)
-{
-    QJsonParseError error;
-    QJsonDocument document = QJsonDocument::fromJson(QByteArray::fromRawData(jsonText.data(),
-                                                                             jsonText.size()),
-                                                     &error);
-    checkError(whatError, error);
-
-    return document;
-}
-
-IncludeSearchPaths ProjectPartArtefact::toIncludeSearchPaths(Utils::SmallStringView jsonText)
-{
-
-    if (jsonText.isEmpty())
-        return {};
-
-    QJsonDocument document = createJsonDocument(jsonText, "Include search paths parsing error");
-
-    return createIncludeSearchPathsFromDocument(document);
-}
-
-void ProjectPartArtefact::checkError(const char *whatError, const QJsonParseError &error)
-{
-    if (error.error != QJsonParseError::NoError) {
-        throw ProjectPartArtefactParseError(whatError,
-                                            error.errorString());
-    }
-}
-
-bool operator==(const ProjectPartArtefact &first, const ProjectPartArtefact &second)
-{
-    return first.toolChainArguments == second.toolChainArguments
-           && first.compilerMacros == second.compilerMacros
-           && first.systemIncludeSearchPaths == second.systemIncludeSearchPaths
-           && first.projectIncludeSearchPaths == second.projectIncludeSearchPaths;
-}
-
-} // namespace ClangBackEnd
diff --git a/src/tools/clangrefactoringbackend/source/projectpartartefact.h b/src/tools/clangrefactoringbackend/source/projectpartartefact.h
deleted file mode 100644
index 505326c375..0000000000
--- a/src/tools/clangrefactoringbackend/source/projectpartartefact.h
+++ /dev/null
@@ -1,101 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2017 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt Creator.
-**
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-****************************************************************************/
-
-#pragma once
-
-#include "projectpartartefactexception.h"
-
-#include <utils/cpplanguage_details.h>
-#include <utils/smallstringvector.h>
-
-#include <compilermacro.h>
-#include <includesearchpath.h>
-
-QT_FORWARD_DECLARE_CLASS(QJsonDocument)
-QT_FORWARD_DECLARE_STRUCT(QJsonParseError)
-
-namespace ClangBackEnd {
-
-class ProjectPartArtefact
-{
-public:
-    ProjectPartArtefact(Utils::SmallStringView compilerArgumentsText,
-                        Utils::SmallStringView compilerMacrosText,
-                        Utils::SmallStringView systemIncludeSearchPathsText,
-                        Utils::SmallStringView projectIncludeSearchPathsText,
-                        int projectPartId,
-                        int language,
-                        int languageVersion,
-                        int languageExtension)
-        : toolChainArguments(toStringVector(compilerArgumentsText))
-        , compilerMacros(toCompilerMacros(compilerMacrosText))
-        , systemIncludeSearchPaths(toIncludeSearchPaths(systemIncludeSearchPathsText))
-        , projectIncludeSearchPaths(toIncludeSearchPaths(projectIncludeSearchPathsText))
-        , projectPartId(projectPartId)
-        , language(static_cast<Utils::Language>(language))
-        , languageVersion(static_cast<Utils::LanguageVersion>(languageVersion))
-        , languageExtension(static_cast<Utils::LanguageExtension>(languageExtension))
-    {}
-
-    ProjectPartArtefact(Utils::SmallStringView compilerArgumentsText,
-                        Utils::SmallStringView compilerMacrosText,
-                        Utils::SmallStringView systemIncludeSearchPathsText,
-                        Utils::SmallStringView projectIncludeSearchPathsText,
-                        int projectPartId,
-                        Utils::Language language,
-                        Utils::LanguageVersion languageVersion,
-                        Utils::LanguageExtension languageExtension)
-        : toolChainArguments(toStringVector(compilerArgumentsText))
-        , compilerMacros(toCompilerMacros(compilerMacrosText))
-        , systemIncludeSearchPaths(toIncludeSearchPaths(systemIncludeSearchPathsText))
-        , projectIncludeSearchPaths(toIncludeSearchPaths(projectIncludeSearchPathsText))
-        , projectPartId(projectPartId)
-        , language(language)
-        , languageVersion(languageVersion)
-        , languageExtension(languageExtension)
-    {}
-
-    static Utils::SmallStringVector toStringVector(Utils::SmallStringView jsonText);
-    static CompilerMacros createCompilerMacrosFromDocument(const QJsonDocument &document);
-    static IncludeSearchPaths createIncludeSearchPathsFromDocument(const QJsonDocument &document);
-    static CompilerMacros toCompilerMacros(Utils::SmallStringView jsonText);
-    static QJsonDocument createJsonDocument(Utils::SmallStringView jsonText, const char *whatError);
-    static IncludeSearchPaths toIncludeSearchPaths(Utils::SmallStringView jsonText);
-    static void checkError(const char *whatError, const QJsonParseError &error);
-    friend bool operator==(const ProjectPartArtefact &first, const ProjectPartArtefact &second);
-
-public:
-    Utils::SmallStringVector toolChainArguments;
-    CompilerMacros compilerMacros;
-    IncludeSearchPaths systemIncludeSearchPaths;
-    IncludeSearchPaths projectIncludeSearchPaths;
-    int projectPartId = -1;
-    Utils::Language language = Utils::Language::Cxx;
-    Utils::LanguageVersion languageVersion = Utils::LanguageVersion::CXX98;
-    Utils::LanguageExtension languageExtension = Utils::LanguageExtension::None;
-};
-
-using ProjectPartArtefacts = std::vector<ProjectPartArtefact>;
-} // namespace ClangBackEnd
diff --git a/src/tools/clangrefactoringbackend/source/projectpartartefactexception.h b/src/tools/clangrefactoringbackend/source/projectpartartefactexception.h
deleted file mode 100644
index 22f1b3ed94..0000000000
--- a/src/tools/clangrefactoringbackend/source/projectpartartefactexception.h
+++ /dev/null
@@ -1,40 +0,0 @@
-/****************************************************************************
-**
-** Copyright (C) 2017 The Qt Company Ltd.
-** Contact: https://www.qt.io/licensing/
-**
-** This file is part of Qt Creator.
-**
-** Commercial License Usage
-** Licensees holding valid commercial Qt licenses may use this file in
-** accordance with the commercial license agreement provided with the
-** Software or, alternatively, in accordance with the terms contained in
-** a written agreement between you and The Qt Company. For licensing terms
-** and conditions see https://www.qt.io/terms-conditions. For further
-** information use the contact form at https://www.qt.io/contact-us.
-**
-** GNU General Public License Usage
-** Alternatively, this file may be used under the terms of the GNU
-** General Public License version 3 as published by the Free Software
-** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
-** included in the packaging of this file. Please review the following
-** information to ensure the GNU General Public License requirements will
-** be met: https://www.gnu.org/licenses/gpl-3.0.html.
-**
-****************************************************************************/
-
-#include <sqliteexception.h>
-
-namespace ClangBackEnd {
-
-class ProjectPartArtefactParseError : public Sqlite::Exception
-{
-public:
-    ProjectPartArtefactParseError(const char *whatErrorHasHappen,
-                                  Utils::SmallString &&errorMessage)
-        : Exception(whatErrorHasHappen, std::move(errorMessage))
-    {
-    }
-};
-
-}
diff --git a/src/tools/clangrefactoringbackend/source/symbolindexer.cpp b/src/tools/clangrefactoringbackend/source/symbolindexer.cpp
index aee8344fc9..e0315c6626 100644
--- a/src/tools/clangrefactoringbackend/source/symbolindexer.cpp
+++ b/src/tools/clangrefactoringbackend/source/symbolindexer.cpp
@@ -65,7 +65,8 @@ SymbolIndexer::SymbolIndexer(SymbolIndexerTaskQueueInterface &symbolIndexerTaskQ
                              ClangPathWatcherInterface &pathWatcher,
                              FilePathCachingInterface &filePathCache,
                              FileStatusCache &fileStatusCache,
-                             Sqlite::TransactionInterface &transactionInterface)
+                             Sqlite::TransactionInterface &transactionInterface,
+                             ProjectPartsStorageInterface &projectPartsStorage)
     : m_symbolIndexerTaskQueue(symbolIndexerTaskQueue)
     , m_symbolStorage(symbolStorage)
     , m_buildDependencyStorage(buildDependenciesStorage)
@@ -74,6 +75,7 @@ SymbolIndexer::SymbolIndexer(SymbolIndexerTaskQueueInterface &symbolIndexerTaskQ
     , m_filePathCache(filePathCache)
     , m_fileStatusCache(fileStatusCache)
     , m_transactionInterface(transactionInterface)
+    , m_projectPartsStorage(projectPartsStorage)
 {
     pathWatcher.setNotifier(this);
 }
@@ -86,26 +88,13 @@ void SymbolIndexer::updateProjectParts(ProjectPartContainers &&projectParts)
 
 void SymbolIndexer::updateProjectPart(ProjectPartContainer &&projectPart)
 {
-    Sqlite::ImmediateTransaction transaction{m_transactionInterface};
-    const auto optionalArtefact = m_symbolStorage.fetchProjectPartArtefact(projectPart.projectPartId);
-    int projectPartId = m_symbolStorage.insertOrUpdateProjectPart(
-        projectPart.projectPartId,
-        projectPart.toolChainArguments,
-        projectPart.compilerMacros,
-        projectPart.systemIncludeSearchPaths,
-        projectPart.projectIncludeSearchPaths,
-        projectPart.language,
-        projectPart.languageVersion,
-        projectPart.languageExtension);
-    if (optionalArtefact)
-        projectPartId = optionalArtefact->projectPartId;
+    Sqlite::DeferredTransaction transaction{m_transactionInterface};
+
+    ProjectPartId projectPartId = projectPart.projectPartId;
     const Utils::optional<ProjectPartPch> optionalProjectPartPch
         = m_precompiledHeaderStorage.fetchPrecompiledHeader(projectPartId);
 
-    FilePathIds sourcePathIds = updatableFilePathIds(projectPart, optionalArtefact);
     transaction.commit();
-    if (sourcePathIds.empty())
-        return;
 
     using Builder = CommandLineBuilder<ProjectPartContainer, Utils::SmallStringVector>;
     Builder commandLineBuilder{projectPart,
@@ -113,9 +102,8 @@ void SymbolIndexer::updateProjectPart(ProjectPartContainer &&projectPart)
                                InputFileType::Source,
                                {},
                                {},
-                               optionalProjectPartPch
-                                   ? FilePathView{optionalProjectPartPch.value().pchPath}
-                                   : FilePathView{}};
+                               optionalProjectPartPch ? FilePathView{optionalProjectPartPch->pchPath}
+                                                      : FilePathView{}};
 
     std::vector<SymbolIndexerTask> symbolIndexerTask;
     symbolIndexerTask.reserve(projectPart.sourcePathIds.size());
@@ -132,14 +120,6 @@ void SymbolIndexer::updateProjectPart(ProjectPartContainer &&projectPart)
 
                 m_symbolStorage.addSymbolsAndSourceLocations(symbolsCollector.symbols(),
                                                              symbolsCollector.sourceLocations());
-
-                m_buildDependencyStorage.insertOrUpdateUsedMacros(symbolsCollector.usedMacros());
-
-                m_buildDependencyStorage.insertOrUpdateFileStatuses(symbolsCollector.fileStatuses());
-
-                m_buildDependencyStorage.insertOrUpdateSourceDependencies(
-                    symbolsCollector.sourceDependencies());
-
                 transaction.commit();
             }
         };
@@ -151,9 +131,7 @@ void SymbolIndexer::updateProjectPart(ProjectPartContainer &&projectPart)
     m_symbolIndexerTaskQueue.processEntries();
 }
 
-void SymbolIndexer::pathsWithIdsChanged(const Utils::SmallStringVector &)
-{
-}
+void SymbolIndexer::pathsWithIdsChanged(const ProjectPartIds &) {}
 
 void SymbolIndexer::pathsChanged(const FilePathIds &filePathIds)
 {
@@ -173,8 +151,8 @@ void SymbolIndexer::updateChangedPath(FilePathId filePathId,
     m_fileStatusCache.update(filePathId);
 
     Sqlite::DeferredTransaction transaction{m_transactionInterface};
-    const Utils::optional<ProjectPartArtefact> optionalArtefact = m_symbolStorage.fetchProjectPartArtefact(
-        filePathId);
+    const Utils::optional<ProjectPartArtefact>
+        optionalArtefact = m_projectPartsStorage.fetchProjectPartArtefact(filePathId);
     if (!optionalArtefact)
         return;
 
@@ -182,9 +160,9 @@ void SymbolIndexer::updateChangedPath(FilePathId filePathId,
         = m_precompiledHeaderStorage.fetchPrecompiledHeader(optionalArtefact->projectPartId);
     transaction.commit();
 
-    const ProjectPartArtefact &artefact = optionalArtefact.value();
+    const ProjectPartArtefact &artefact = *optionalArtefact;
 
-    auto pchPath = optionalProjectPartPch ? optionalProjectPartPch.value().pchPath : FilePath{};
+    auto pchPath = optionalProjectPartPch ? optionalProjectPartPch->pchPath : FilePath{};
 
     CommandLineBuilder<ProjectPartArtefact, Utils::SmallStringVector>
         builder{artefact, artefact.toolChainArguments, InputFileType::Source, {}, {}, pchPath};
@@ -201,13 +179,6 @@ void SymbolIndexer::updateChangedPath(FilePathId filePathId,
             m_symbolStorage.addSymbolsAndSourceLocations(symbolsCollector.symbols(),
                                                          symbolsCollector.sourceLocations());
 
-            m_buildDependencyStorage.insertOrUpdateUsedMacros(symbolsCollector.usedMacros());
-
-            m_buildDependencyStorage.insertOrUpdateFileStatuses(symbolsCollector.fileStatuses());
-
-            m_buildDependencyStorage.insertOrUpdateSourceDependencies(
-                symbolsCollector.sourceDependencies());
-
             transaction.commit();
         }
     };
diff --git a/src/tools/clangrefactoringbackend/source/symbolindexer.h b/src/tools/clangrefactoringbackend/source/symbolindexer.h
index 33c691e4dd..c398c0f2bf 100644
--- a/src/tools/clangrefactoringbackend/source/symbolindexer.h
+++ b/src/tools/clangrefactoringbackend/source/symbolindexer.h
@@ -31,9 +31,10 @@
 #include "builddependenciesstorageinterface.h"
 #include "clangpathwatcher.h"
 
+#include <filecontainerv2.h>
 #include <precompiledheaderstorageinterface.h>
 #include <projectpartcontainer.h>
-#include <filecontainerv2.h>
+#include <projectpartsstorageinterface.h>
 
 namespace ClangBackEnd {
 
@@ -49,12 +50,13 @@ public:
                   ClangPathWatcherInterface &pathWatcher,
                   FilePathCachingInterface &filePathCache,
                   FileStatusCache &fileStatusCache,
-                  Sqlite::TransactionInterface &transactionInterface);
+                  Sqlite::TransactionInterface &transactionInterface,
+                  ProjectPartsStorageInterface &projectPartsStorage);
 
     void updateProjectParts(ProjectPartContainers &&projectParts);
     void updateProjectPart(ProjectPartContainer &&projectPart);
 
-    void pathsWithIdsChanged(const Utils::SmallStringVector &ids) override;
+    void pathsWithIdsChanged(const ProjectPartIds &ids) override;
     void pathsChanged(const FilePathIds &filePathIds) override;
     void updateChangedPath(FilePathId filePath,
                            std::vector<SymbolIndexerTask> &symbolIndexerTask);
@@ -78,6 +80,7 @@ private:
     FilePathCachingInterface &m_filePathCache;
     FileStatusCache &m_fileStatusCache;
     Sqlite::TransactionInterface &m_transactionInterface;
+    ProjectPartsStorageInterface &m_projectPartsStorage;
 };
 
 } // namespace ClangBackEnd
diff --git a/src/tools/clangrefactoringbackend/source/symbolindexertask.h b/src/tools/clangrefactoringbackend/source/symbolindexertask.h
index de3303815d..1695642522 100644
--- a/src/tools/clangrefactoringbackend/source/symbolindexertask.h
+++ b/src/tools/clangrefactoringbackend/source/symbolindexertask.h
@@ -26,6 +26,7 @@
 #pragma once
 
 #include <filepathid.h>
+#include <projectpartid.h>
 
 #include <functional>
 
@@ -43,12 +44,10 @@ class SymbolIndexerTask
 public:
     using Callable = std::function<void(SymbolsCollectorInterface &symbolsCollector)>;
 
-    SymbolIndexerTask(FilePathId filePathId,
-                      int projectPartId,
-                      Callable &&callable)
-        : callable(std::move(callable)),
-          filePathId(filePathId),
-          projectPartId(projectPartId)
+    SymbolIndexerTask(FilePathId filePathId, ProjectPartId projectPartId, Callable &&callable)
+        : callable(std::move(callable))
+        , filePathId(filePathId)
+        , projectPartId(projectPartId)
     {
     }
 
@@ -78,7 +77,7 @@ public:
 public:
     Callable callable;
     FilePathId filePathId;
-    int projectPartId;
+    ProjectPartId projectPartId;
 };
 
 } // namespace ClangBackEnd
diff --git a/src/tools/clangrefactoringbackend/source/symbolindexing.h b/src/tools/clangrefactoringbackend/source/symbolindexing.h
index 5b8b2221f0..c942059bad 100644
--- a/src/tools/clangrefactoringbackend/source/symbolindexing.h
+++ b/src/tools/clangrefactoringbackend/source/symbolindexing.h
@@ -36,6 +36,7 @@
 
 #include <builddependenciesstorage.h>
 #include <precompiledheaderstorage.h>
+#include <projectpartsstorage.h>
 
 #include <refactoringdatabaseinitializer.h>
 #include <filepathcachingfwd.h>
@@ -84,7 +85,8 @@ public:
                    ProgressCounter::SetProgressCallback &&setProgressCallback)
         : m_filePathCache(filePathCache)
         , m_buildDependencyStorage(database)
-        , m_recompiledHeaderStorage(database)
+        , m_precompiledHeaderStorage(database)
+        , m_projectPartsStorage(database)
         , m_symbolStorage(database)
         , m_collectorManger(generatedFiles, database)
         , m_progressCounter(std::move(setProgressCallback))
@@ -121,7 +123,8 @@ private:
     using SymbolIndexerTaskScheduler = TaskScheduler<SymbolsCollectorManager, SymbolIndexerTask::Callable>;
     FilePathCachingInterface &m_filePathCache;
     BuildDependenciesStorage m_buildDependencyStorage;
-    PrecompiledHeaderStorage<Sqlite::Database> m_recompiledHeaderStorage;
+    PrecompiledHeaderStorage<Sqlite::Database> m_precompiledHeaderStorage;
+    ProjectPartsStorage<Sqlite::Database> m_projectPartsStorage;
     SymbolStorage m_symbolStorage;
     ClangPathWatcher<QFileSystemWatcher, QTimer> m_sourceWatcher{m_filePathCache};
     FileStatusCache m_fileStatusCache{m_filePathCache};
@@ -130,11 +133,12 @@ private:
     SymbolIndexer m_indexer{m_indexerQueue,
                             m_symbolStorage,
                             m_buildDependencyStorage,
-                            m_recompiledHeaderStorage,
+                            m_precompiledHeaderStorage,
                             m_sourceWatcher,
                             m_filePathCache,
                             m_fileStatusCache,
-                            m_symbolStorage.m_database};
+                            m_symbolStorage.database,
+                            m_projectPartsStorage};
     SymbolIndexerTaskQueue m_indexerQueue{m_indexerScheduler, m_progressCounter};
     SymbolIndexerTaskScheduler m_indexerScheduler;
 };
diff --git a/src/tools/clangrefactoringbackend/source/symbolstorage.h b/src/tools/clangrefactoringbackend/source/symbolstorage.h
index 798fa26dd0..9dffe48c96 100644
--- a/src/tools/clangrefactoringbackend/source/symbolstorage.h
+++ b/src/tools/clangrefactoringbackend/source/symbolstorage.h
@@ -50,10 +50,10 @@ class SymbolStorage final : public SymbolStorageInterface
 
 public:
     SymbolStorage(Database &database)
-        : m_transaction(database),
-          m_database(database)
+        : transaction(database)
+        , database(database)
     {
-        m_transaction.commit();
+        transaction.commit();
     }
 
     void addSymbolsAndSourceLocations(const SymbolEntries &symbolEntries,
@@ -70,91 +70,9 @@ public:
         deleteNewLocationsTable();
     }
 
-    int insertOrUpdateProjectPart(Utils::SmallStringView projectPartName,
-                                  const Utils::SmallStringVector &toolChainArguments,
-                                  const CompilerMacros &compilerMacros,
-                                  const IncludeSearchPaths &systemIncludeSearchPaths,
-                                  const IncludeSearchPaths &projectIncludeSearchPaths,
-                                  Utils::Language language,
-                                  Utils::LanguageVersion languageVersion,
-                                  Utils::LanguageExtension languageExtension) override
-    {
-        Utils::SmallString toolChainArgumentsAsJson = toJson(toolChainArguments);
-        Utils::SmallString compilerMacrosAsJson = toJson(compilerMacros);
-        Utils::SmallString systemIncludeSearchPathsAsJason = toJson(systemIncludeSearchPaths);
-        Utils::SmallString projectIncludeSearchPathsAsJason = toJson(projectIncludeSearchPaths);
-
-        m_insertOrUpdateProjectPartStatement.write(projectPartName,
-                                                   toolChainArgumentsAsJson,
-                                                   compilerMacrosAsJson,
-                                                   systemIncludeSearchPathsAsJason,
-                                                   projectIncludeSearchPathsAsJason,
-                                                   static_cast<int>(language),
-                                                   static_cast<int>(languageVersion),
-                                                   static_cast<int>(languageExtension));
-
-        auto projectPartId = m_getProjectPartIdStatement.template value<int>(projectPartName);
-
-        return projectPartId.value();
-    }
-
-    Utils::optional<ProjectPartArtefact> fetchProjectPartArtefact(FilePathId sourceId) const override
-    {
-        ReadStatement &statement = m_getProjectPartArtefactsBySourceId;
-
-        return statement.template value<ProjectPartArtefact, 8>(sourceId.filePathId);
-    }
-
-    Utils::optional<ProjectPartArtefact> fetchProjectPartArtefact(Utils::SmallStringView projectPartName) const override
-    {
-        ReadStatement &statement = m_getProjectPartArtefactsByProjectPartName;
-
-        return statement.template value<ProjectPartArtefact, 8>(projectPartName);
-    }
-
-    static Utils::SmallString toJson(const Utils::SmallStringVector &strings)
-    {
-        QJsonDocument document;
-        QJsonArray array;
-
-        std::transform(strings.begin(), strings.end(), std::back_inserter(array), [] (const auto &string) {
-            return QJsonValue(string.data());
-        });
-
-        document.setArray(array);
-
-        return document.toJson(QJsonDocument::Compact);
-    }
-
-    static Utils::SmallString toJson(const CompilerMacros &compilerMacros)
-    {
-        QJsonDocument document;
-        QJsonArray array;
-
-        for (const CompilerMacro &macro : compilerMacros)
-            array.push_back(QJsonArray{{QString(macro.key), QString(macro.value), macro.index}});
-
-        document.setArray(array);
-
-        return document.toJson(QJsonDocument::Compact);
-    }
-
-    static Utils::SmallString toJson(const IncludeSearchPaths &includeSearchPaths)
-    {
-        QJsonDocument document;
-        QJsonArray array;
-
-        for (const IncludeSearchPath &path : includeSearchPaths)
-            array.push_back(QJsonArray{{path.path.data(), path.index, int(path.type)}});
-
-        document.setArray(array);
-
-        return document.toJson(QJsonDocument::Compact);
-    }
-
     void fillTemporarySymbolsTable(const SymbolEntries &symbolEntries)
     {
-        WriteStatement &statement = m_insertSymbolsToNewSymbolsStatement;
+        WriteStatement &statement = insertSymbolsToNewSymbolsStatement;
 
         for (const auto &symbolEntry : symbolEntries) {
             statement.write(symbolEntry.first,
@@ -166,7 +84,7 @@ public:
 
     void fillTemporaryLocationsTable(const SourceLocationEntries &sourceLocations)
     {
-        WriteStatement &statement = m_insertLocationsToNewLocationsStatement;
+        WriteStatement &statement = insertLocationsToNewLocationsStatement;
 
         for (const auto &locationEntry : sourceLocations) {
             statement.write(locationEntry.symbolId,
@@ -177,40 +95,22 @@ public:
         }
     }
 
-    void addNewSymbolsToSymbols()
-    {
-        m_addNewSymbolsToSymbolsStatement.execute();
-    }
+    void addNewSymbolsToSymbols() { addNewSymbolsToSymbolsStatement.execute(); }
 
-    void syncNewSymbolsFromSymbols()
-    {
-        m_syncNewSymbolsFromSymbolsStatement.execute();
-    }
+    void syncNewSymbolsFromSymbols() { syncNewSymbolsFromSymbolsStatement.execute(); }
 
-    void syncSymbolsIntoNewLocations()
-    {
-        m_syncSymbolsIntoNewLocationsStatement.execute();
-    }
+    void syncSymbolsIntoNewLocations() { syncSymbolsIntoNewLocationsStatement.execute(); }
 
     void deleteAllLocationsFromUpdatedFiles()
     {
-        m_deleteAllLocationsFromUpdatedFilesStatement.execute();
+        deleteAllLocationsFromUpdatedFilesStatement.execute();
     }
 
-    void insertNewLocationsInLocations()
-    {
-        m_insertNewLocationsInLocationsStatement.execute();
-    }
+    void insertNewLocationsInLocations() { insertNewLocationsInLocationsStatement.execute(); }
 
-    void deleteNewSymbolsTable()
-    {
-        m_deleteNewSymbolsTableStatement.execute();
-    }
+    void deleteNewSymbolsTable() { deleteNewSymbolsTableStatement.execute(); }
 
-    void deleteNewLocationsTable()
-    {
-        m_deleteNewLocationsTableStatement.execute();
-    }
+    void deleteNewLocationsTable() { deleteNewLocationsTableStatement.execute(); }
 
     SourceLocationEntries sourceLocations() const
     {
@@ -230,7 +130,7 @@ public:
         table.addIndex({usrColumn, symbolNameColumn});
         table.addIndex({symbolIdColumn});
 
-        table.initialize(m_database);
+        table.initialize(database);
 
         return table;
     }
@@ -248,85 +148,49 @@ public:
         table.addColumn("locationKind", Sqlite::ColumnType::Integer);
         table.addUniqueIndex({sourceIdColumn, lineColumn, columnColumn});
 
-        table.initialize(m_database);
+        table.initialize(database);
 
         return table;
     }
 
 public:
-    Sqlite::ImmediateNonThrowingDestructorTransaction m_transaction;
-    Database &m_database;
+    Sqlite::ImmediateNonThrowingDestructorTransaction transaction;
+    Database &database;
     Sqlite::Table newSymbolsTablet{createNewSymbolsTable()};
     Sqlite::Table newLocationsTable{createNewLocationsTable()};
-    WriteStatement m_insertSymbolsToNewSymbolsStatement{
+    WriteStatement insertSymbolsToNewSymbolsStatement{
         "INSERT INTO newSymbols(temporarySymbolId, usr, symbolName, symbolKind) VALUES(?,?,?,?)",
-        m_database};
-    WriteStatement m_insertLocationsToNewLocationsStatement{
-        "INSERT OR IGNORE INTO newLocations(temporarySymbolId, line, column, sourceId, locationKind) VALUES(?,?,?,?,?)",
-        m_database
-    };
-    ReadStatement m_selectNewSourceIdsStatement{
-        "SELECT DISTINCT sourceId FROM newLocations WHERE NOT EXISTS (SELECT sourceId FROM sources WHERE newLocations.sourceId == sources.sourceId)",
-        m_database
-    };
-    WriteStatement m_addNewSymbolsToSymbolsStatement{
+        database};
+    WriteStatement insertLocationsToNewLocationsStatement{
+        "INSERT OR IGNORE INTO newLocations(temporarySymbolId, line, column, sourceId, "
+        "locationKind) VALUES(?,?,?,?,?)",
+        database};
+    ReadStatement selectNewSourceIdsStatement{
+        "SELECT DISTINCT sourceId FROM newLocations WHERE NOT EXISTS (SELECT sourceId FROM sources "
+        "WHERE newLocations.sourceId == sources.sourceId)",
+        database};
+    WriteStatement addNewSymbolsToSymbolsStatement{
         "INSERT INTO symbols(usr, symbolName, symbolKind) "
         "SELECT usr, symbolName, symbolKind FROM newSymbols WHERE NOT EXISTS "
         "(SELECT usr FROM symbols WHERE symbols.usr == newSymbols.usr)",
-        m_database
-    };
-    WriteStatement m_syncNewSymbolsFromSymbolsStatement{
-        "UPDATE newSymbols SET symbolId = (SELECT symbolId FROM symbols WHERE newSymbols.usr = symbols.usr)",
-        m_database
-    };
-    WriteStatement m_syncSymbolsIntoNewLocationsStatement{
-        "UPDATE newLocations SET symbolId = (SELECT symbolId FROM newSymbols WHERE newSymbols.temporarySymbolId = newLocations.temporarySymbolId)",
-        m_database
-    };
-    WriteStatement m_deleteAllLocationsFromUpdatedFilesStatement{
+        database};
+    WriteStatement syncNewSymbolsFromSymbolsStatement{
+        "UPDATE newSymbols SET symbolId = (SELECT symbolId FROM symbols WHERE newSymbols.usr = "
+        "symbols.usr)",
+        database};
+    WriteStatement syncSymbolsIntoNewLocationsStatement{
+        "UPDATE newLocations SET symbolId = (SELECT symbolId FROM newSymbols WHERE "
+        "newSymbols.temporarySymbolId = newLocations.temporarySymbolId)",
+        database};
+    WriteStatement deleteAllLocationsFromUpdatedFilesStatement{
         "DELETE FROM locations WHERE sourceId IN (SELECT DISTINCT sourceId FROM newLocations)",
-        m_database
-    };
-    WriteStatement m_insertNewLocationsInLocationsStatement{
-        "INSERT INTO locations(symbolId, line, column, sourceId, locationKind) SELECT symbolId, line, column, sourceId, locationKind FROM newLocations",
-        m_database
-    };
-    WriteStatement m_deleteNewSymbolsTableStatement{
-        "DELETE FROM newSymbols",
-        m_database
-    };
-    WriteStatement m_deleteNewLocationsTableStatement{
-        "DELETE FROM newLocations",
-        m_database
-    };
-    WriteStatement m_insertOrUpdateProjectPartStatement{
-        "INSERT INTO projectParts(projectPartName, toolChainArguments, compilerMacros, "
-        "systemIncludeSearchPaths, projectIncludeSearchPaths, language, languageVersion, "
-        "languageExtension) VALUES (?001,?002,?003,?004,?005,?006,?007,?008) ON "
-        "CONFLICT(projectPartName) DO UPDATE SET toolChainArguments=?002, compilerMacros=?003, "
-        "systemIncludeSearchPaths=?004, projectIncludeSearchPaths=?005, language=?006, "
-        "languageVersion=?007, languageExtension=?008",
-        m_database};
-    mutable ReadStatement m_getProjectPartIdStatement{
-        "SELECT projectPartId FROM projectParts WHERE projectPartName = ?",
-        m_database
-    };
-
-    mutable ReadStatement m_getCompileArgumentsForFileIdStatement{
-        "SELECT toolChainArguments FROM projectParts WHERE projectPartId = (SELECT projectPartId "
-        "FROM projectPartsSources WHERE sourceId = ?)",
-        m_database};
-    mutable ReadStatement m_getProjectPartArtefactsBySourceId{
-        "SELECT toolChainArguments, compilerMacros, systemIncludeSearchPaths, "
-        "projectIncludeSearchPaths, projectPartId, language, languageVersion, languageExtension "
-        "FROM projectParts WHERE projectPartId = (SELECT "
-        "projectPartId FROM projectPartsSources WHERE sourceId = ?)",
-        m_database};
-    mutable ReadStatement m_getProjectPartArtefactsByProjectPartName{
-        "SELECT toolChainArguments, compilerMacros, systemIncludeSearchPaths, "
-        "projectIncludeSearchPaths, projectPartId, language, languageVersion, languageExtension "
-        "FROM projectParts WHERE projectPartName = ?",
-        m_database};
+        database};
+    WriteStatement insertNewLocationsInLocationsStatement{
+        "INSERT INTO locations(symbolId, line, column, sourceId, locationKind) SELECT symbolId, "
+        "line, column, sourceId, locationKind FROM newLocations",
+        database};
+    WriteStatement deleteNewSymbolsTableStatement{"DELETE FROM newSymbols", database};
+    WriteStatement deleteNewLocationsTableStatement{"DELETE FROM newLocations", database};
 };
 
 } // namespace ClangBackEnd
diff --git a/src/tools/clangrefactoringbackend/source/symbolstorageinterface.h b/src/tools/clangrefactoringbackend/source/symbolstorageinterface.h
index 210f66f7da..1d04c4d168 100644
--- a/src/tools/clangrefactoringbackend/source/symbolstorageinterface.h
+++ b/src/tools/clangrefactoringbackend/source/symbolstorageinterface.h
@@ -25,19 +25,13 @@
 
 #pragma once
 
-#include "filestatus.h"
-#include "projectpartentry.h"
-#include "projectpartartefact.h"
 #include "sourcelocationentry.h"
-#include "sourcedependency.h"
 #include "symbolentry.h"
-#include "usedmacro.h"
-
-#include <includesearchpath.h>
 
+#include <compilermacro.h>
 #include <sqlitetransaction.h>
 
-#include <compilermacro.h>
+#include <utils/cpplanguage_details.h>
 
 namespace ClangBackEnd {
 
@@ -51,20 +45,6 @@ public:
     virtual void addSymbolsAndSourceLocations(const SymbolEntries &symbolEntries,
                                               const SourceLocationEntries &sourceLocations)
         = 0;
-    virtual int insertOrUpdateProjectPart(
-        Utils::SmallStringView projectPartName,
-        const Utils::SmallStringVector &commandLineArguments,
-        const CompilerMacros &compilerMacros,
-        const ClangBackEnd::IncludeSearchPaths &systemIncludeSearchPaths,
-        const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths,
-        Utils::Language language,
-        Utils::LanguageVersion languageVersion,
-        Utils::LanguageExtension languageExtension)
-        = 0;
-    virtual Utils::optional<ProjectPartArtefact> fetchProjectPartArtefact(
-        FilePathId sourceId) const = 0;
-    virtual Utils::optional<ProjectPartArtefact> fetchProjectPartArtefact(
-        Utils::SmallStringView projectPartName) const = 0;
 
 protected:
     ~SymbolStorageInterface() = default;