Clang: Reduce database accesses

If we prefetch data from the database to the caches we reduce the database
transaction calls which are quite expensive.

Change-Id: I617a0d886807402e0a94291a913a77f989970b55
Reviewed-by: Tim Jenssen <tim.jenssen@qt.io>

23 files changed, 350 insertions, 79 deletions

diff --git a/tests/unit/unittest/builddependencycollector-test.cpp b/tests/unit/unittest/builddependencycollector-test.cpp
index 352a60f1de..7bfe6de4cc 100644
--- a/tests/unit/unittest/builddependencycollector-test.cpp
+++ b/tests/unit/unittest/builddependencycollector-test.cpp
@@ -106,6 +106,7 @@ protected:
 
         collector.addUnsavedFiles(
             {{{TESTDATA_DIR, "BuildDependencyCollector/project/generated_file.h"},
+              id(TESTDATA_DIR "/BuildDependencyCollector/project/generated_file.h"),
               "#pragma once",
               {}}});
 
@@ -741,6 +742,7 @@ TEST_F(BuildDependencyCollector, GeneratedFile)
 {
     generatedFiles.update(
         {{TESTDATA_DIR "/builddependencycollector/project/generated/generated_file.h",
+          id(TESTDATA_DIR "/builddependencycollector/project/generated/generated_file.h"),
           "#pragma once"}});
     emptyCollector.addFile(id(TESTDATA_DIR "/builddependencycollector/project/main6.cpp"),
                            {"cc",
@@ -754,9 +756,9 @@ TEST_F(BuildDependencyCollector, GeneratedFile)
 
     emptyCollector.collect();
 
-    ASSERT_THAT(
-        emptyCollector.sourceEntries(),
-        ElementsAre(HasSource(id(TESTDATA_DIR "/builddependencycollector/project/main6.cpp"),
+    ASSERT_THAT(emptyCollector.sourceEntries(),
+                UnorderedElementsAre(
+                    HasSource(id(TESTDATA_DIR "/builddependencycollector/project/main6.cpp"),
                               SourceType::Source),
                     HasSource(id(TESTDATA_DIR
                                  "/builddependencycollector/project/generated/generated_file.h"),
@@ -783,8 +785,9 @@ TEST_F(BuildDependencyCollector, Create)
 {
     using ClangBackEnd::IncludeSearchPathType;
     ClangBackEnd::BuildDependencyCollector collector{filePathCache, generatedFiles, environment};
-    generatedFiles.update(
-        {{TESTDATA_DIR "/builddependencycollector/project/generated_file.h", "#pragma once"}});
+    generatedFiles.update({{TESTDATA_DIR "/builddependencycollector/project/generated_file.h",
+                            id(TESTDATA_DIR "/builddependencycollector/project/generated_file.h"),
+                            "#pragma once"}});
     ClangBackEnd::ProjectPartContainer projectPart{
         1,
         {},
diff --git a/tests/unit/unittest/clangquery-test.cpp b/tests/unit/unittest/clangquery-test.cpp
index 77a049210b..f17d416613 100644
--- a/tests/unit/unittest/clangquery-test.cpp
+++ b/tests/unit/unittest/clangquery-test.cpp
@@ -40,6 +40,7 @@
 #include <mutex>
 
 using ClangBackEnd::ClangQuery;
+using ClangBackEnd::FilePath;
 using ClangBackEnd::FilePathCaching;
 using ClangBackEnd::RefactoringDatabaseInitializer;
 
@@ -98,7 +99,11 @@ TEST_F(ClangQuerySlowTest, SourceRangeInUnsavedFileDeclarationRange)
                   "#include \"unsaved.h\"",
                   {"cc", "-std=c++14"});
     query.setQuery("functionDecl()");
-    ClangBackEnd::V2::FileContainer unsavedFile{{TESTDATA_DIR, "unsaved.h"}, "void unsaved();", {}};
+    ClangBackEnd::V2::FileContainer unsavedFile{{TESTDATA_DIR, "unsaved.h"},
+                                                filePathCache.filePathId(
+                                                    FilePath{TESTDATA_DIR, "unsaved.h"}),
+                                                "void unsaved();",
+                                                {}};
     query.addUnsavedFiles({unsavedFile});
 
     query.findLocations();
@@ -125,6 +130,8 @@ TEST_F(ClangQuerySlowTest, DISABLED_SourceRangeInUnsavedFileDeclarationRangeOver
     query.addFile({TESTDATA_DIR "/query_simplefunction.cpp"}, "void f() {}", {"cc", "-std=c++14"});
     query.setQuery("functionDecl()");
     ClangBackEnd::V2::FileContainer unsavedFile{{TESTDATA_DIR "/query_simplefunction.cpp"},
+                                                filePathCache.filePathId(
+                                                    FilePath{TESTDATA_DIR, "query_simplefunction.cpp"}),
                                                 "void unsaved();",
                                                 {}};
     query.addUnsavedFiles({unsavedFile});
diff --git a/tests/unit/unittest/clangquerygatherer-test.cpp b/tests/unit/unittest/clangquerygatherer-test.cpp
index 3b5f9239fe..c301af4ad0 100644
--- a/tests/unit/unittest/clangquerygatherer-test.cpp
+++ b/tests/unit/unittest/clangquerygatherer-test.cpp
@@ -59,10 +59,10 @@ using testing::SizeIs;
 using testing::UnorderedElementsAre;
 using testing::_;
 
-using ClangBackEnd::V2::FileContainer;
-using ClangBackEnd::SourceRangesForQueryMessage;
-using ClangBackEnd::SourceRangesContainer;
+using ClangBackEnd::FilePath;
 using ClangBackEnd::SourceRangesContainer;
+using ClangBackEnd::SourceRangesForQueryMessage;
+using ClangBackEnd::V2::FileContainer;
 
 MATCHER_P2(Contains, line, column,
            std::string(negation ? "isn't " : "is ")
@@ -86,22 +86,20 @@ protected:
     ClangBackEnd::FilePathCaching filePathCache{database};
     Utils::SmallString sourceContent{"#include \"query_simplefunction.h\"\nvoid f() {}"};
     FileContainer source{{TESTDATA_DIR, "query_simplefunction.cpp"},
+                         filePathCache.filePathId(FilePath{TESTDATA_DIR, "query_simplefunction.cpp"}),
                          sourceContent.clone(),
-                         {"cc",
-                          "-I",
-                          TESTDATA_DIR}};
+                         {"cc", "-I", TESTDATA_DIR}};
     FileContainer source2{{TESTDATA_DIR, "query_simplefunction2.cpp"},
+                          filePathCache.filePathId(FilePath{TESTDATA_DIR, "query_simplefunction2.cpp"}),
                           {},
-                          {"cc",
-                           "-I",
-                           TESTDATA_DIR}};
+                          {"cc", "-I", TESTDATA_DIR}};
     FileContainer source3{{TESTDATA_DIR, "query_simplefunction3.cpp"},
+                          filePathCache.filePathId(FilePath{TESTDATA_DIR, "query_simplefunction3.cpp"}),
                           {},
-                          {"cc",
-                           "-I",
-                           TESTDATA_DIR}};
+                          {"cc", "-I", TESTDATA_DIR}};
     Utils::SmallString unsavedContent{"void f();"};
     FileContainer unsaved{{TESTDATA_DIR, "query_simplefunction.h"},
+                          filePathCache.filePathId(FilePath{TESTDATA_DIR, "query_simplefunction.h"}),
                           unsavedContent.clone(),
                           {}};
     Utils::SmallString query{"functionDecl()"};
diff --git a/tests/unit/unittest/clangqueryprojectfindfilter-test.cpp b/tests/unit/unittest/clangqueryprojectfindfilter-test.cpp
index 3981980902..65169cb745 100644
--- a/tests/unit/unittest/clangqueryprojectfindfilter-test.cpp
+++ b/tests/unit/unittest/clangqueryprojectfindfilter-test.cpp
@@ -122,9 +122,7 @@ protected:
     QString unsavedDocumentContent{"void f();"};
     std::vector<Utils::SmallStringVector> commandLines;
     std::vector<CppTools::ProjectPart::Ptr> projectsParts;
-    ClangBackEnd::V2::FileContainer unsavedContent{{"/path/to", "unsaved.cpp"},
-                                                  "void f();",
-                                                  {}};
+    ClangBackEnd::V2::FileContainer unsavedContent{{"/path/to", "unsaved.cpp"}, 1, "void f();", {}};
     ProjectExplorer::Project project;
 };
 
@@ -186,17 +184,12 @@ TEST_F(ClangQueryProjectFindFilter, FindAllIsSettingExprectedResultCountInTheRef
 
 TEST_F(ClangQueryProjectFindFilter, FindAllIsCallingRequestSourceRangesAndDiagnosticsForQueryMessage)
 {
-    ClangBackEnd::RequestSourceRangesForQueryMessage message(findDeclQueryText,
-                                                             {{{"/path/to", "file1.h"},
-                                                               "",
-                                                               commandLines[0].clone()},
-                                                              {{"/path/to", "file1.cpp"},
-                                                               "",
-                                                               commandLines[1].clone()},
-                                                              {{"/path/to", "file2.cpp"},
-                                                               "",
-                                                               commandLines[2].clone()}},
-                                                             {unsavedContent.clone()});
+    ClangBackEnd::RequestSourceRangesForQueryMessage message(
+        findDeclQueryText,
+        {{{"/path/to", "file1.h"}, 1, "", commandLines[0].clone()},
+         {{"/path/to", "file1.cpp"}, 2, "", commandLines[1].clone()},
+         {{"/path/to", "file2.cpp"}, 3, "", commandLines[2].clone()}},
+        {unsavedContent.clone()});
 
     EXPECT_CALL(mockRefactoringServer, requestSourceRangesForQueryMessage(message));
 
diff --git a/tests/unit/unittest/filepathcache-test.cpp b/tests/unit/unittest/filepathcache-test.cpp
index 789eb66451..9555796116 100644
--- a/tests/unit/unittest/filepathcache-test.cpp
+++ b/tests/unit/unittest/filepathcache-test.cpp
@@ -79,6 +79,7 @@ protected:
     NiceMock<MockFilePathStorage> mockStorage{mockDatabase};
     Cache cache{mockStorage};
     NiceMock<MockFilePathStorage> mockStorageFilled{mockDatabase};
+    Cache cacheNotFilled{mockStorageFilled};
 };
 
 TEST_F(FilePathCache, FilePathIdWithOutAnyEntryCallDirectoryId)
@@ -439,4 +440,51 @@ TEST_F(FilePathCache, UseTransactionIfAddingFilesOnlyInAddFilePathsCalls)
 
     cacheFilled.addFilePaths(FilePathViews{"/path/to/file.h"});
 }
+
+TEST_F(FilePathCache, GetFileIdInAfterPopulateIfEmpty)
+{
+    cacheNotFilled.populateIfEmpty();
+
+    auto id = cacheNotFilled.filePathId("/path2/to/file.cpp");
+
+    ASSERT_THAT(id, Eq(72));
+}
+
+TEST_F(FilePathCache, DontPopulateIfNotEmpty)
+{
+    cacheNotFilled.filePathId("/path/to/file.cpp");
+    cacheNotFilled.populateIfEmpty();
+
+    auto id = cacheNotFilled.filePathId("/path2/to/file.cpp");
+
+    ASSERT_FALSE(id.isValid());
+}
+
+TEST_F(FilePathCache, GetDirectoryIdAfterPopulateIfEmpty)
+{
+    cacheNotFilled.populateIfEmpty();
+
+    auto id = cacheNotFilled.directoryPathId(42);
+
+    ASSERT_THAT(id, Eq(5));
+}
+
+TEST_F(FilePathCache, GetDirectoryPathAfterPopulateIfEmpty)
+{
+    cacheNotFilled.populateIfEmpty();
+
+    auto path = cacheNotFilled.directoryPath(5);
+
+    ASSERT_THAT(path, Eq("/path/to"));
+}
+
+TEST_F(FilePathCache, GetFilePathAfterPopulateIfEmptye)
+{
+    cacheNotFilled.populateIfEmpty();
+
+    auto path = cacheNotFilled.filePath(42);
+
+    ASSERT_THAT(path, Eq("/path/to/file.cpp"));
+}
+
 } // namespace
diff --git a/tests/unit/unittest/generatedfiles-test.cpp b/tests/unit/unittest/generatedfiles-test.cpp
index 9db9c4b0ae..8e5a34ffd7 100644
--- a/tests/unit/unittest/generatedfiles-test.cpp
+++ b/tests/unit/unittest/generatedfiles-test.cpp
@@ -35,12 +35,12 @@ using ClangBackEnd::V2::FileContainers;
 class GeneratedFiles : public testing::Test
 {
 protected:
-    FileContainer file1{"/file1", "content1"};
-    FileContainer file1b{"/file1", "content1b"};
-    FileContainer file2{"/file2", "content2"};
-    FileContainer file2b{"/file2", "content2b"};
-    FileContainer file3{"/file3", "content3"};
-    FileContainer file4{"/file4", "content4"};
+    FileContainer file1{"/file1", 1, "content1"};
+    FileContainer file1b{"/file1", 1, "content1b"};
+    FileContainer file2{"/file2", 2, "content2"};
+    FileContainer file2b{"/file2", 2, "content2b"};
+    FileContainer file3{"/file3", 3, "content3"};
+    FileContainer file4{"/file4", 4, "content4"};
     ClangBackEnd::GeneratedFiles generatedFiles;
 };
 
@@ -76,7 +76,7 @@ TEST_F(GeneratedFiles, IsValidForNoGeneratedFiles)
 
 TEST_F(GeneratedFiles, IsNotValidIfFilesWithNotContentExists)
 {
-    generatedFiles.update({{"/file2", ""}});
+    generatedFiles.update({{"/file2", 2, ""}});
 
     ASSERT_FALSE(generatedFiles.isValid());
 }
@@ -86,4 +86,15 @@ TEST_F(GeneratedFiles, IsValidIfAllFilesHasContent)
     generatedFiles.update({file1, file2, file3, file4});
 
     ASSERT_TRUE(generatedFiles.isValid());
-}}
+}
+
+TEST_F(GeneratedFiles, GetFilePathIds)
+{
+    generatedFiles.update({file3, file2, file1, file4});
+
+    auto ids = generatedFiles.filePathIds();
+
+    ASSERT_THAT(ids, ElementsAre(1, 2, 3, 4));
+}
+
+} // namespace
diff --git a/tests/unit/unittest/gtest-creator-printing.h b/tests/unit/unittest/gtest-creator-printing.h
index b533186739..624288ee98 100644
--- a/tests/unit/unittest/gtest-creator-printing.h
+++ b/tests/unit/unittest/gtest-creator-printing.h
@@ -106,7 +106,7 @@ void PrintTo(Utils::SmallStringView text, ::std::ostream *os);
 void PrintTo(const Utils::SmallString &text, ::std::ostream *os);
 void PrintTo(const Utils::PathString &text, ::std::ostream *os);
 
-} // namespace ProjectExplorer
+} // namespace Utils
 
 namespace ClangBackEnd {
 class SourceLocationEntry;
diff --git a/tests/unit/unittest/mockfilepathcaching.h b/tests/unit/unittest/mockfilepathcaching.h
index bec249a5a5..155aa491c9 100644
--- a/tests/unit/unittest/mockfilepathcaching.h
+++ b/tests/unit/unittest/mockfilepathcaching.h
@@ -43,4 +43,5 @@ public:
     MOCK_CONST_METHOD1(directoryPathId,
                        ClangBackEnd::DirectoryPathId(ClangBackEnd::FilePathId filePathId));
     MOCK_METHOD1(addFilePaths, void(const ClangBackEnd::FilePaths &filePaths));
+    MOCK_METHOD0(populateIfEmpty, void());
 };
diff --git a/tests/unit/unittest/mockgeneratedfiles.h b/tests/unit/unittest/mockgeneratedfiles.h
index 75b182355c..481747c27f 100644
--- a/tests/unit/unittest/mockgeneratedfiles.h
+++ b/tests/unit/unittest/mockgeneratedfiles.h
@@ -38,6 +38,7 @@ public:
                  void (const ClangBackEnd::FilePaths &filePaths));
     MOCK_CONST_METHOD0(fileContainers,
                        const ClangBackEnd::V2::FileContainers &());
+    MOCK_CONST_METHOD0(filePathIds, ClangBackEnd::FilePathIds());
     MOCK_CONST_METHOD0(isValid, bool());
 
     void update(ClangBackEnd::V2::FileContainers &&fileContainers)
diff --git a/tests/unit/unittest/mockprojectpartsstorage.h b/tests/unit/unittest/mockprojectpartsstorage.h
index e8dcbc94b2..cdca4ef78e 100644
--- a/tests/unit/unittest/mockprojectpartsstorage.h
+++ b/tests/unit/unittest/mockprojectpartsstorage.h
@@ -36,8 +36,11 @@ public:
     MOCK_CONST_METHOD1(
         fetchProjectParts,
         ClangBackEnd::ProjectPartContainers(const ClangBackEnd::ProjectPartIds &projectPartIds));
+    MOCK_CONST_METHOD0(fetchAllProjectPartNamesAndIds, ClangBackEnd::Internal::ProjectPartNameIds());
     MOCK_CONST_METHOD1(fetchProjectPartId,
                        ClangBackEnd::ProjectPartId(Utils::SmallStringView projectPartName));
+    MOCK_CONST_METHOD1(fetchProjectPartIdUnguarded,
+                       ClangBackEnd::ProjectPartId(Utils::SmallStringView projectPartName));
     MOCK_CONST_METHOD1(fetchProjectPartName,
                        Utils::PathString(ClangBackEnd::ProjectPartId projectPartId));
     MOCK_METHOD8(updateProjectPart,
diff --git a/tests/unit/unittest/mocksqlitereadstatement.cpp b/tests/unit/unittest/mocksqlitereadstatement.cpp
index 9a949e4b0a..0a63f3c284 100644
--- a/tests/unit/unittest/mocksqlitereadstatement.cpp
+++ b/tests/unit/unittest/mocksqlitereadstatement.cpp
@@ -109,6 +109,12 @@ std::vector<Sources::Source> MockSqliteReadStatement::values<Sources::Source, 3>
     return valuesReturnStdVectorSource(reserveSize);
 }
 
+template<>
+ProjectPartNameIds MockSqliteReadStatement::values<ProjectPartNameId, 2>(std::size_t reserveSize)
+{
+    return valuesReturnProjectPartNameIds(reserveSize);
+}
+
 template <>
 Utils::optional<int>
 MockSqliteReadStatement::value<int>(const Utils::SmallStringView &text)
diff --git a/tests/unit/unittest/mocksqlitereadstatement.h b/tests/unit/unittest/mocksqlitereadstatement.h
index 8ebcb6e13b..0048fd6276 100644
--- a/tests/unit/unittest/mocksqlitereadstatement.h
+++ b/tests/unit/unittest/mocksqlitereadstatement.h
@@ -34,6 +34,7 @@
 #include <projectpartartefact.h>
 #include <projectpartcontainer.h>
 #include <projectpartpch.h>
+#include <projectpartstoragestructs.h>
 #include <sourceentry.h>
 #include <stringcachefwd.h>
 #include <symbol.h>
@@ -59,6 +60,8 @@ using std::int64_t;
 namespace Sources = ClangBackEnd::Sources;
 using ClangBackEnd::PrecompiledHeaderTimeStamps;
 using ClangBackEnd::UsedMacros;
+using ClangBackEnd::Internal::ProjectPartNameId;
+using ClangBackEnd::Internal::ProjectPartNameIds;
 using ClangRefactoring::Symbol;
 using ClangRefactoring::Symbols;
 
@@ -91,6 +94,8 @@ public:
 
     MOCK_METHOD2(valuesReturnFilePathIds, FilePathIds(std::size_t, int));
 
+    MOCK_METHOD1(valuesReturnProjectPartNameIds, ProjectPartNameIds(std::size_t));
+
     MOCK_METHOD1(valueReturnInt32, Utils::optional<int>(Utils::SmallStringView));
 
     MOCK_METHOD2(valueReturnInt32, Utils::optional<int>(int, Utils::SmallStringView));
@@ -226,9 +231,11 @@ std::vector<Sources::Directory> MockSqliteReadStatement::values<Sources::Directo
 template<>
 std::vector<Sources::Source> MockSqliteReadStatement::values<Sources::Source, 3>(std::size_t reserveSize);
 
-template <>
-Utils::optional<int>
-MockSqliteReadStatement::value<int>(const Utils::SmallStringView&);
+template<>
+ProjectPartNameIds MockSqliteReadStatement::values<ProjectPartNameId, 2>(std::size_t reserveSize);
+
+template<>
+Utils::optional<int> MockSqliteReadStatement::value<int>(const Utils::SmallStringView &);
 
 template <>
 Utils::optional<int>
diff --git a/tests/unit/unittest/mocksymbolindexertaskqueue.h b/tests/unit/unittest/mocksymbolindexertaskqueue.h
index 7fb0d3f0bd..cef60ac776 100644
--- a/tests/unit/unittest/mocksymbolindexertaskqueue.h
+++ b/tests/unit/unittest/mocksymbolindexertaskqueue.h
@@ -34,7 +34,6 @@ class MockSymbolIndexerTaskQueue : public ClangBackEnd::SymbolIndexerTaskQueueIn
 public:
     MOCK_METHOD1(addOrUpdateTasks,
                  void (std::vector<ClangBackEnd::SymbolIndexerTask> &&tasks));
-    MOCK_METHOD1(removeTasks,
-                 void (const std::vector<int> &projectPartIds));
+    MOCK_METHOD1(removeTasks, void(const ClangBackEnd::ProjectPartIds &projectPartIds));
     MOCK_METHOD0(processEntries, void());
 };
diff --git a/tests/unit/unittest/pchcreator-test.cpp b/tests/unit/unittest/pchcreator-test.cpp
index e97f60b9f5..ad5b57b4f5 100644
--- a/tests/unit/unittest/pchcreator-test.cpp
+++ b/tests/unit/unittest/pchcreator-test.cpp
@@ -91,7 +91,7 @@ protected:
 
     ClangBackEnd::FilePathId id(ClangBackEnd::FilePathView path)
     {
-        return creator.filePathCache().filePathId(path);
+        return filePathCache.filePathId(path);
     }
 
     FilePathIds sorted(FilePathIds &&filePathIds)
@@ -104,17 +104,17 @@ protected:
 protected:
     Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
     ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> databaseInitializer{database};
+    ClangBackEnd::FilePathCaching filePathCache{database};
     FilePath main1Path = TESTDATA_DIR "/builddependencycollector/project/main3.cpp";
     FilePath main2Path = TESTDATA_DIR "/builddependencycollector/project/main2.cpp";
     FilePath header1Path = TESTDATA_DIR "/builddependencycollector/project/header1.h";
     FilePath header2Path = TESTDATA_DIR "/builddependencycollector/project/header2.h";
     FilePath generatedFilePath = TESTDATA_DIR "/builddependencycollector/project/generated_file.h";
     TestEnvironment environment;
-    FileContainer generatedFile{generatedFilePath.clone(), "#pragma once", {}};
+    FileContainer generatedFile{generatedFilePath.clone(), id(generatedFilePath), "#pragma once", {}};
     NiceMock<MockPchManagerClient> mockPchManagerClient;
     NiceMock<MockClangPathWatcher> mockClangPathWatcher;
     NiceMock<MockBuildDependenciesStorage> mockBuildDependenciesStorage;
-    ClangBackEnd::FilePathCaching filePathCache{database};
     ClangBackEnd::PchCreator creator{environment,
                                      filePathCache,
                                      mockPchManagerClient,
diff --git a/tests/unit/unittest/pchmanagerclientserverinprocess-test.cpp b/tests/unit/unittest/pchmanagerclientserverinprocess-test.cpp
index 194f52afd3..e468521a54 100644
--- a/tests/unit/unittest/pchmanagerclientserverinprocess-test.cpp
+++ b/tests/unit/unittest/pchmanagerclientserverinprocess-test.cpp
@@ -117,7 +117,7 @@ TEST_F(PchManagerClientServerInProcess, SendUpdateProjectPartsMessage)
 
 TEST_F(PchManagerClientServerInProcess, SendUpdateGeneratedFilesMessage)
 {
-    FileContainer fileContainer{{"/path/to/", "file"}, "content", {}};
+    FileContainer fileContainer{{"/path/to/", "file"}, 1, "content", {}};
     UpdateGeneratedFilesMessage message{{fileContainer}};
 
     EXPECT_CALL(mockPchManagerServer, updateGeneratedFiles(message));
diff --git a/tests/unit/unittest/pchmanagerserver-test.cpp b/tests/unit/unittest/pchmanagerserver-test.cpp
index d7e6c492f9..bf14b628b8 100644
--- a/tests/unit/unittest/pchmanagerserver-test.cpp
+++ b/tests/unit/unittest/pchmanagerserver-test.cpp
@@ -27,6 +27,7 @@
 
 #include "mockbuilddependenciesstorage.h"
 #include "mockclangpathwatcher.h"
+#include "mockfilepathcaching.h"
 #include "mockgeneratedfiles.h"
 #include "mockpchmanagerclient.h"
 #include "mockpchtaskgenerator.h"
@@ -77,11 +78,13 @@ protected:
     Sqlite::Database database{":memory:", Sqlite::JournalMode::Memory};
     ClangBackEnd::RefactoringDatabaseInitializer<Sqlite::Database> initializer{database};
     ClangBackEnd::FilePathCaching filePathCache{database};
+    NiceMock<MockFilePathCaching> mockFilePathCache;
     ClangBackEnd::PchManagerServer server{mockClangPathWatcher,
                                           mockPchTaskGenerator,
                                           mockProjectPartsManager,
                                           mockGeneratedFiles,
-                                          mockBuildDependenciesStorage};
+                                          mockBuildDependenciesStorage,
+                                          mockFilePathCache};
     NiceMock<MockPchManagerClient> mockPchManagerClient;
     ClangBackEnd::ProjectPartId projectPartId1{1};
     ClangBackEnd::ProjectPartId projectPartId2{2};
@@ -98,7 +101,7 @@ protected:
         projectPartId1,
         {"-I", TESTDATA_DIR, "-Wno-pragma-once-outside-header"},
         {{"DEFINE", "1", 1}},
-        {{"/includes", 1, ClangBackEnd::IncludeSearchPathType::BuiltIn}},
+        {{TESTDATA_DIR "/symbolscollector/include", 1, ClangBackEnd::IncludeSearchPathType::BuiltIn}},
         {{"/project/includes", 1, ClangBackEnd::IncludeSearchPathType::User}},
         {id(header1Path)},
         {id(main1Path)},
@@ -110,7 +113,7 @@ protected:
         {"-x", "c++-header", "-Wno-pragma-once-outside-header"},
         {{"DEFINE", "1", 1}},
         {{"/includes", 1, ClangBackEnd::IncludeSearchPathType::BuiltIn}},
-        {{"/project/includes", 1, ClangBackEnd::IncludeSearchPathType::User}},
+        {{TESTDATA_DIR "/builddependencycollector", 1, ClangBackEnd::IncludeSearchPathType::User}},
         {id(header2Path)},
         {id(main2Path)},
         Utils::Language::C,
@@ -165,7 +168,7 @@ protected:
     std::vector<ProjectPartContainer> projectParts2{projectPart2};
     std::vector<ProjectPartContainer> projectParts3{projectPart3};
     std::vector<ProjectPartContainer> projectParts4{projectPart3, projectPart4};
-    FileContainer generatedFile{{"/path/to/", "file"}, "content", {}};
+    FileContainer generatedFile{{"/path/to/", "file"}, id("/path/to/file"), "content", {}};
     ClangBackEnd::UpdateProjectPartsMessage updateProjectPartsMessage{
         Utils::clone(projectParts), {"toolChainArgument"}};
     ClangBackEnd::RemoveProjectPartsMessage removeProjectPartsMessage{
@@ -226,7 +229,8 @@ TEST_F(PchManagerServer, SetPathWatcherNotifier)
                                           mockPchTaskGenerator,
                                           mockProjectPartsManager,
                                           mockGeneratedFiles,
-                                          mockBuildDependenciesStorage};
+                                          mockBuildDependenciesStorage,
+                                          filePathCache};
 }
 
 TEST_F(PchManagerServer, UpdateProjectPartQueueByPathIds)
@@ -419,4 +423,20 @@ TEST_F(PchManagerServer, SentUpToDateProjectPartIdsToClient)
 
     server.updateProjectParts(updateProjectPartsMessage.clone());
 }
+
+TEST_F(PchManagerServer, AddingIncludesToFileCacheForProjectUpdates)
+{
+    InSequence s;
+
+    EXPECT_CALL(mockFilePathCache, populateIfEmpty());
+    EXPECT_CALL(mockFilePathCache,
+                addFilePaths(AllOf(
+                    Contains(Eq(TESTDATA_DIR "/symbolscollector/include/unmodified_header.h")),
+                    Contains(Eq(TESTDATA_DIR "/symbolscollector/include/unmodified_header2.h")),
+                    Contains(Eq(TESTDATA_DIR "/builddependencycollector/project/header2.h")),
+                    Contains(Eq(TESTDATA_DIR "/builddependencycollector/external/external3.h")))));
+    EXPECT_CALL(mockProjectPartsManager, update(_));
+
+    server.updateProjectParts(updateProjectPartsMessage.clone());
+}
 } // namespace
diff --git a/tests/unit/unittest/projectpartsstorage-test.cpp b/tests/unit/unittest/projectpartsstorage-test.cpp
index 6c887ca3f0..b67cd5a37c 100644
--- a/tests/unit/unittest/projectpartsstorage-test.cpp
+++ b/tests/unit/unittest/projectpartsstorage-test.cpp
@@ -29,11 +29,13 @@
 
 #include <builddependenciesstorage.h>
 #include <projectpartsstorage.h>
+#include <projectpartstoragestructs.h>
 #include <refactoringdatabaseinitializer.h>
 #include <sqlitedatabase.h>
 #include <sqlitereadstatement.h>
 #include <sqlitewritestatement.h>
 #include <symbolstorage.h>
+
 namespace {
 
 using ClangBackEnd::FilePathId;
@@ -107,6 +109,7 @@ protected:
     MockSqliteReadStatement &fetchProjectPrecompiledHeaderPathStatement = storage.fetchProjectPrecompiledHeaderBuildTimeStatement;
     MockSqliteReadStatement &fetchProjectPrecompiledHeaderBuildTimeStatement = storage.fetchProjectPrecompiledHeaderBuildTimeStatement;
     MockSqliteWriteStatement &resetDependentIndexingTimeStampsStatement = storage.resetDependentIndexingTimeStampsStatement;
+    MockSqliteReadStatement &fetchAllProjectPartNamesAndIdsStatement = storage.fetchAllProjectPartNamesAndIdsStatement;
     IncludeSearchPaths systemIncludeSearchPaths{{"/includes", 1, IncludeSearchPathType::BuiltIn},
                                                 {"/other/includes", 2, IncludeSearchPathType::System}};
     IncludeSearchPaths projectIncludeSearchPaths{{"/project/includes", 1, IncludeSearchPathType::User},
@@ -124,6 +127,7 @@ protected:
                                                Utils::Language::Cxx,
                                                Utils::LanguageVersion::CXX11,
                                                Utils::LanguageExtension::None};
+    ClangBackEnd::Internal::ProjectPartNameIds projectPartNameIds{{"projectPartName", 2}};
 };
 
 TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithNonExistingProjectPartName)
@@ -139,6 +143,17 @@ TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithNonExistingProjectPartName)
     storage.fetchProjectPartId("test");
 }
 
+TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithNonExistingProjectPartNameUnguarded)
+{
+    InSequence s;
+
+    EXPECT_CALL(fetchProjectPartIdStatement,
+                valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")));
+    EXPECT_CALL(insertProjectPartNameStatement, write(TypedEq<Utils::SmallStringView>("test")));
+
+    storage.fetchProjectPartIdUnguarded("test");
+}
+
 TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithExistingProjectPart)
 {
     InSequence s;
@@ -153,6 +168,18 @@ TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithExistingProjectPart)
     storage.fetchProjectPartId("test");
 }
 
+TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithExistingProjectPartUnguarded)
+{
+    InSequence s;
+
+    EXPECT_CALL(fetchProjectPartIdStatement,
+                valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
+        .WillOnce(Return(Utils::optional<ProjectPartId>{20}));
+    EXPECT_CALL(insertProjectPartNameStatement, write(TypedEq<Utils::SmallStringView>("test"))).Times(0);
+
+    storage.fetchProjectPartIdUnguarded("test");
+}
+
 TEST_F(ProjectPartsStorage, CallsFetchProjectIdWithBusyDatabaset)
 {
     InSequence s;
@@ -184,6 +211,18 @@ TEST_F(ProjectPartsStorage, FetchProjectIdWithNonExistingProjectPartName)
     ASSERT_THAT(id.projectPathId, 21);
 }
 
+TEST_F(ProjectPartsStorage, FetchProjectIdWithNonExistingProjectPartNameUnguarded)
+{
+    ON_CALL(fetchProjectPartIdStatement,
+            valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
+        .WillByDefault(Return(Utils::optional<ProjectPartId>{}));
+    ON_CALL(mockDatabase, lastInsertedRowId()).WillByDefault(Return(21));
+
+    auto id = storage.fetchProjectPartIdUnguarded("test");
+
+    ASSERT_THAT(id.projectPathId, 21);
+}
+
 TEST_F(ProjectPartsStorage, FetchProjectIdWithNonExistingProjectPartNameAndIsBusy)
 {
     InSequence s;
@@ -211,6 +250,17 @@ TEST_F(ProjectPartsStorage, FetchProjectIdWithExistingProjectPartName)
     ASSERT_THAT(id.projectPathId, 20);
 }
 
+TEST_F(ProjectPartsStorage, FetchProjectIdWithExistingProjectPartNameUnguarded)
+{
+    ON_CALL(fetchProjectPartIdStatement,
+            valueReturnProjectPartId(TypedEq<Utils::SmallStringView>("test")))
+        .WillByDefault(Return(Utils::optional<ProjectPartId>{20}));
+
+    auto id = storage.fetchProjectPartIdUnguarded("test");
+
+    ASSERT_THAT(id.projectPathId, 20);
+}
+
 TEST_F(ProjectPartsStorage, FetchProjectPartName)
 {
     InSequence s;
@@ -418,6 +468,7 @@ TEST_F(ProjectPartsStorage, FetchProjectPartArtefactBySourceIdCallsValueInStatem
 
     storage.fetchProjectPartArtefact(FilePathId{1});
 }
+
 TEST_F(ProjectPartsStorage, FetchProjectPartArtefactBySourceIdReturnArtefact)
 {
     EXPECT_CALL(getProjectPartArtefactsBySourceId, valueReturnProjectPartArtefact(1))
@@ -495,6 +546,34 @@ TEST_F(ProjectPartsStorage, ResetDependentIndexingTimeStampsIsBusy)
     storage.resetIndexingTimeStamps({projectPart1, projectPart2});
 }
 
+TEST_F(ProjectPartsStorage, FetchAllProjectPartNamesAndIdsCalls)
+{
+    InSequence s;
+
+    EXPECT_CALL(mockDatabase, deferredBegin());
+    EXPECT_CALL(fetchAllProjectPartNamesAndIdsStatement, valuesReturnProjectPartNameIds(_))
+        .WillRepeatedly(Return(projectPartNameIds));
+    EXPECT_CALL(mockDatabase, commit());
+
+    storage.fetchAllProjectPartNamesAndIds();
+}
+
+TEST_F(ProjectPartsStorage, FetchAllProjectPartNamesAndIdsCallsIsBusy)
+{
+    InSequence s;
+
+    EXPECT_CALL(mockDatabase, deferredBegin());
+    EXPECT_CALL(fetchAllProjectPartNamesAndIdsStatement, valuesReturnProjectPartNameIds(_))
+        .WillOnce(Throw(Sqlite::StatementIsBusy{""}));
+    EXPECT_CALL(mockDatabase, rollback());
+    EXPECT_CALL(mockDatabase, deferredBegin());
+    EXPECT_CALL(fetchAllProjectPartNamesAndIdsStatement, valuesReturnProjectPartNameIds(_))
+        .WillRepeatedly(Return(projectPartNameIds));
+    EXPECT_CALL(mockDatabase, commit());
+
+    storage.fetchAllProjectPartNamesAndIds();
+}
+
 class ProjectPartsStorageSlow : public testing::Test, public Data
 {
     using Storage = ClangBackEnd::ProjectPartsStorage<Sqlite::Database>;
@@ -530,6 +609,15 @@ TEST_F(ProjectPartsStorageSlow, FetchProjectPartId)
     ASSERT_THAT(first, Eq(second));
 }
 
+TEST_F(ProjectPartsStorageSlow, FetchProjectPartIdUnguarded)
+{
+    auto first = storage.fetchProjectPartId("test");
+
+    auto second = storage.fetchProjectPartIdUnguarded("test");
+
+    ASSERT_THAT(first, Eq(second));
+}
+
 TEST_F(ProjectPartsStorageSlow, FetchProjectParts)
 {
     projectPart1.projectPartId = storage.fetchProjectPartId("project1");
@@ -563,4 +651,16 @@ TEST_F(ProjectPartsStorageSlow, ResetDependentIndexingTimeStamps)
                             SourceTimeStamp{10, 34}));
 }
 
+TEST_F(ProjectPartsStorageSlow, FetchAllProjectPartNamesAndIdsy)
+{
+    using ClangBackEnd::Internal::ProjectPartNameId;
+    auto id = storage.fetchProjectPartId("projectPartName");
+    auto id2 = storage.fetchProjectPartId("projectPartName2");
+
+    auto values = storage.fetchAllProjectPartNamesAndIds();
+
+    ASSERT_THAT(values,
+                UnorderedElementsAre(ProjectPartNameId{"projectPartName", id},
+                                     ProjectPartNameId{"projectPartName2", id2}));
+}
 } // namespace
diff --git a/tests/unit/unittest/projectupdater-test.cpp b/tests/unit/unittest/projectupdater-test.cpp
index 73f5359df0..1b9f271687 100644
--- a/tests/unit/unittest/projectupdater-test.cpp
+++ b/tests/unit/unittest/projectupdater-test.cpp
@@ -66,10 +66,11 @@ using testing::NiceMock;
 using testing::AnyNumber;
 
 using ClangBackEnd::CompilerMacro;
+using ClangBackEnd::FilePath;
 using ClangBackEnd::IncludeSearchPath;
 using ClangBackEnd::IncludeSearchPathType;
-using ClangBackEnd::V2::FileContainer;
 using ClangBackEnd::ProjectPartContainer;
+using ClangBackEnd::V2::FileContainer;
 using CppTools::CompilerOptionsBuilder;
 using ProjectExplorer::HeaderPath;
 
@@ -182,9 +183,18 @@ protected:
     CppTools::ProjectPart nonBuildingProjectPart;
     ProjectPartContainer expectedContainer;
     ProjectPartContainer expectedContainer2;
-    FileContainer generatedFile{{"/path/to", "header1.h"}, "content", {}};
-    FileContainer generatedFile2{{"/path/to2", "header1.h"}, "content", {}};
-    FileContainer generatedFile3{{"/path/to", "header2.h"}, "content", {}};
+    FileContainer generatedFile{{"/path/to", "header1.h"},
+                                filePathCache.filePathId(FilePath{"/path/to", "header1.h"}),
+                                "content",
+                                {}};
+    FileContainer generatedFile2{{"/path/to2", "header1.h"},
+                                 filePathCache.filePathId(FilePath{"/path/to2", "header1.h"}),
+                                 "content",
+                                 {}};
+    FileContainer generatedFile3{{"/path/to", "header2.h"},
+                                 filePathCache.filePathId(FilePath{"/path/to", "header2.h"}),
+                                 "content",
+                                 {}};
 };
 
 TEST_F(ProjectUpdater, CallUpdateProjectParts)
@@ -271,6 +281,7 @@ TEST_F(ProjectUpdater, CallPrecompiledHeaderRemovedInPchManagerProjectUpdater)
 TEST_F(ProjectUpdater, ConvertProjectPartToProjectPartContainer)
 {
     updater.setExcludedPaths({"/path/to/header1.h"});
+    updater.fetchProjectPartIds({&projectPart});
 
     auto container = updater.toProjectPartContainer(&projectPart);
 
@@ -279,21 +290,23 @@ TEST_F(ProjectUpdater, ConvertProjectPartToProjectPartContainer)
 
 TEST_F(ProjectUpdater, ConvertProjectPartToProjectPartContainersHaveSameSizeLikeProjectParts)
 {
+    updater.fetchProjectPartIds({&projectPart, &nonBuildingProjectPart});
+
     auto containers = updater.toProjectPartContainers(
         {&projectPart, &projectPart, &nonBuildingProjectPart});
 
     ASSERT_THAT(containers, SizeIs(2));
 }
 
-TEST_F(ProjectUpdater, CallStorageInsideTransaction)
+TEST_F(ProjectUpdater, ProjectPartIdsPrefetchingInsideTransaction)
 {
     InSequence s;
     CppTools::ProjectPart projectPart;
     projectPart.project = &project;
     projectPart.displayName = "project";
     Utils::SmallString projectPartName = projectPart.id();
-    MockSqliteTransactionBackend mockSqliteTransactionBackend;
-    MockProjectPartsStorage mockProjectPartsStorage;
+    NiceMock<MockSqliteTransactionBackend> mockSqliteTransactionBackend;
+    NiceMock<MockProjectPartsStorage> mockProjectPartsStorage;
     ON_CALL(mockProjectPartsStorage, transactionBackend())
         .WillByDefault(ReturnRef(mockSqliteTransactionBackend));
     ClangPchManager::ClangIndexingSettingsManager settingsManager;
@@ -302,9 +315,11 @@ TEST_F(ProjectUpdater, CallStorageInsideTransaction)
                                             mockProjectPartsStorage,
                                             settingsManager};
 
-    EXPECT_CALL(mockProjectPartsStorage, fetchProjectPartId(Eq(projectPartName)));
+    EXPECT_CALL(mockSqliteTransactionBackend, deferredBegin());
+    EXPECT_CALL(mockProjectPartsStorage, fetchProjectPartIdUnguarded(Eq(projectPartName)));
+    EXPECT_CALL(mockSqliteTransactionBackend, commit());
 
-    updater.toProjectPartContainers({&projectPart});
+    updater.fetchProjectPartIds({&projectPart});
 }
 
 TEST_F(ProjectUpdater, CreateSortedExcludedPaths)
@@ -476,7 +491,8 @@ TEST_F(ProjectUpdater, AddProjectFilesToFilePathCache)
     NiceMock<MockFilePathCaching> mockFilePathCaching;
     ClangPchManager::ProjectUpdater updater{mockPchManagerServer,
                                             mockFilePathCaching,
-                                            projectPartsStorage};
+                                            projectPartsStorage,
+                                            settingsManager};
 
     EXPECT_CALL(mockFilePathCaching,
                 addFilePaths(UnorderedElementsAre(Eq(headerPaths[0]),
@@ -487,6 +503,39 @@ TEST_F(ProjectUpdater, AddProjectFilesToFilePathCache)
     updater.updateProjectParts({&projectPart}, {});
 }
 
-// test for update many time and get the same id
+TEST_F(ProjectUpdater, FillProjectPartIdCacheAtCreation)
+{
+    NiceMock<MockProjectPartsStorage> mockProjectPartsStorage;
+
+    EXPECT_CALL(mockProjectPartsStorage, fetchAllProjectPartNamesAndIds());
+
+    ClangPchManager::ProjectUpdater updater{mockPchManagerServer,
+                                            filePathCache,
+                                            mockProjectPartsStorage,
+                                            settingsManager};
+}
+
+TEST_F(ProjectUpdater, DontFetchProjectPartIdFromDatabaseIfItIsInCache)
+{
+    projectPart.files.clear();
+    NiceMock<MockSqliteTransactionBackend> mockSqliteTransactionBackend;
+    NiceMock<MockProjectPartsStorage> mockProjectPartsStorage;
+    ON_CALL(mockProjectPartsStorage, transactionBackend())
+        .WillByDefault(ReturnRef(mockSqliteTransactionBackend));
+    ON_CALL(mockProjectPartsStorage, fetchAllProjectPartNamesAndIds())
+        .WillByDefault(Return(
+            ClangBackEnd::Internal::ProjectPartNameIds{{Utils::PathString(projectPart.id()), 55}}));
+    ClangPchManager::ProjectUpdater updater{mockPchManagerServer,
+                                            filePathCache,
+                                            mockProjectPartsStorage,
+                                            settingsManager};
+
+    EXPECT_CALL(mockSqliteTransactionBackend, deferredBegin()).Times(0);
+    EXPECT_CALL(mockProjectPartsStorage, fetchProjectPartId(_)).Times(0);
+    EXPECT_CALL(mockProjectPartsStorage, fetchProjectPartIdUnguarded(_)).Times(0);
+    EXPECT_CALL(mockSqliteTransactionBackend, commit()).Times(0);
+
+    updater.updateProjectParts({&projectPart}, {});
+}
 
 } // namespace
diff --git a/tests/unit/unittest/refactoringclientserverinprocess-test.cpp b/tests/unit/unittest/refactoringclientserverinprocess-test.cpp
index 8b6237bfad..344eb08f03 100644
--- a/tests/unit/unittest/refactoringclientserverinprocess-test.cpp
+++ b/tests/unit/unittest/refactoringclientserverinprocess-test.cpp
@@ -129,8 +129,8 @@ TEST_F(RefactoringClientServerInProcess, RequestSourceRangesAndDiagnosticsForQue
 {
     RequestSourceRangesForQueryMessage message{
         "functionDecl()",
-        {{{TESTDATA_DIR, "query_simplefunction.cpp"}, "void f();", {"cc"}, 1}},
-        {{{TESTDATA_DIR, "query_simplefunction.h"}, "void f();", {}, 1}}};
+        {{{TESTDATA_DIR, "query_simplefunction.cpp"}, 1, "void f();", {"cc"}, 1}},
+        {{{TESTDATA_DIR, "query_simplefunction.h"}, 2, "void f();", {}, 1}}};
 
     EXPECT_CALL(mockRefactoringServer, requestSourceRangesForQueryMessage(message));
 
@@ -143,12 +143,13 @@ TEST_F(RefactoringClientServerInProcess, RequestSourceRangesForQueryMessage)
     RequestSourceRangesForQueryMessage message{
         "functionDecl()",
         {{{TESTDATA_DIR, "query_simplefunction.cpp"},
+          1,
           "void f();",
           {
               "cc",
           },
           1}},
-        {{{TESTDATA_DIR, "query_simplefunction.h"}, "void f();", {}, 1}}};
+        {{{TESTDATA_DIR, "query_simplefunction.h"}, 2, "void f();", {}, 1}}};
 
     EXPECT_CALL(mockRefactoringServer, requestSourceRangesForQueryMessage(message));
 
@@ -182,7 +183,7 @@ TEST_F(RefactoringClientServerInProcess, SendUpdateProjectPartsMessage)
 
 TEST_F(RefactoringClientServerInProcess, SendUpdateGeneratedFilesMessage)
 {
-    FileContainer fileContainer{{"/path/to/", "file"}, "content", {}};
+    FileContainer fileContainer{{"/path/to/", "file"}, 1, "content", {}};
     UpdateGeneratedFilesMessage message{{fileContainer}};
 
     EXPECT_CALL(mockRefactoringServer, updateGeneratedFiles(message));
diff --git a/tests/unit/unittest/refactoringprojectupdater-test.cpp b/tests/unit/unittest/refactoringprojectupdater-test.cpp
index eddeefa24c..8b16adc619 100644
--- a/tests/unit/unittest/refactoringprojectupdater-test.cpp
+++ b/tests/unit/unittest/refactoringprojectupdater-test.cpp
@@ -64,6 +64,10 @@ MATCHER_P(IsProjectPartContainer,
 class RefactoringProjectUpdater : public testing::Test
 {
 protected:
+    RefactoringProjectUpdater()
+    {
+        ON_CALL(mockProjectPartsStorage, transactionBackend()).WillByDefault(ReturnRef(database));
+    }
     ProjectPart::Ptr createProjectPart(const char *name)
     {
         ProjectPart::Ptr projectPart{new ProjectPart};
@@ -115,8 +119,6 @@ TEST_F(RefactoringProjectUpdater, UpdateProjectPart)
         .WillRepeatedly(Return(QString(" project1")));
     EXPECT_CALL(mockCppModelManager, projectPartForId(Eq(QString(" project1"))))
         .WillRepeatedly(Return(createProjectPart("project1")));
-    EXPECT_CALL(mockProjectPartsStorage, fetchProjectPartId(Eq(" project1")))
-        .WillOnce(Return(ClangBackEnd::ProjectPartId{3}));
     EXPECT_CALL(mockRefactoringServer,
                 updateProjectParts(Field(&UpdateProjectPartsMessage::projectsParts,
                                          ElementsAre(IsProjectPartContainer(3)))));
diff --git a/tests/unit/unittest/refactoringserver-test.cpp b/tests/unit/unittest/refactoringserver-test.cpp
index 74363de35f..2cc3f26efd 100644
--- a/tests/unit/unittest/refactoringserver-test.cpp
+++ b/tests/unit/unittest/refactoringserver-test.cpp
@@ -26,6 +26,7 @@
 #include "googletest.h"
 
 #include "filesystem-utilities.h"
+#include "mockfilepathcaching.h"
 #include "mockrefactoringclient.h"
 #include "mocksymbolindexing.h"
 #include "sourcerangecontainer-matcher.h"
@@ -98,7 +99,11 @@ protected:
     ClangBackEnd::GeneratedFiles generatedFiles;
     ClangBackEnd::RefactoringServer refactoringServer{mockSymbolIndexing, filePathCache, generatedFiles};
     Utils::SmallString sourceContent{"void f()\n {}"};
-    FileContainer source{{TESTDATA_DIR, "query_simplefunction.cpp"}, sourceContent.clone(), {"cc"}};
+    ClangBackEnd::FilePath filePath{TESTDATA_DIR, "query_simplefunction.cpp"};
+    FileContainer source{filePath.clone(),
+                         filePathCache.filePathId(filePath),
+                         sourceContent.clone(),
+                         {"cc"}};
     QTemporaryFile temporaryFile{Utils::TemporaryDirectory::masterDirectoryPath()
                                  + "/clangQuery-XXXXXX.cpp"};
     int processingSlotCount = 2;
@@ -126,9 +131,13 @@ TEST_F(RefactoringServerSlowTest, RequestSingleSourceRangesAndDiagnosticsWithUns
 {
     Utils::SmallString unsavedContent{"void f();"};
     FileContainer source{{TESTDATA_DIR, "query_simplefunction.cpp"},
+                         filePathCache.filePathId(FilePath{TESTDATA_DIR, "query_simplefunction.cpp"}),
                          "#include \"query_simplefunction.h\"",
                          {"cc"}};
-    FileContainer unsaved{{TESTDATA_DIR, "query_simplefunction.h"}, unsavedContent.clone(), {}};
+    FileContainer unsaved{{TESTDATA_DIR, "query_simplefunction.h"},
+                          filePathCache.filePathId(FilePath{TESTDATA_DIR, "query_simplefunction.h"}),
+                          unsavedContent.clone(),
+                          {}};
     RequestSourceRangesForQueryMessage message{"functionDecl()", {source.clone()}, {unsaved.clone()}};
 
     EXPECT_CALL(mockRefactoringClient,
@@ -240,6 +249,8 @@ TEST_F(RefactoringServerSlowTest, ForValidRequestSourceRangesAndDiagnosticsGetSo
 {
     RequestSourceRangesAndDiagnosticsForQueryMessage message("functionDecl()",
                                                              {FilePath(temporaryFile.fileName()),
+                                                              filePathCache.filePathId(FilePath(
+                                                                  temporaryFile.fileName())),
                                                               "void f() {}",
                                                               {"cc"}});
 
@@ -259,6 +270,8 @@ TEST_F(RefactoringServerSlowTest, ForInvalidRequestSourceRangesAndDiagnosticsGet
 {
     RequestSourceRangesAndDiagnosticsForQueryMessage message("func()",
                                                              {FilePath(temporaryFile.fileName()),
+                                                              filePathCache.filePathId(FilePath(
+                                                                  temporaryFile.fileName())),
                                                               "void f() {}",
                                                               {"cc"}});
 
@@ -277,6 +290,7 @@ TEST_F(RefactoringServerSlowTest, ForInvalidRequestSourceRangesAndDiagnosticsGet
 TEST_F(RefactoringServer, UpdateGeneratedFilesSetMemberWhichIsUsedForSymbolIndexing)
 {
     FileContainers unsaved{{{TESTDATA_DIR, "query_simplefunction.h"},
+                            filePathCache.filePathId(FilePath{TESTDATA_DIR, "query_simplefunction.h"}),
                             "void f();",
                             {}}};
 
@@ -288,6 +302,7 @@ TEST_F(RefactoringServer, UpdateGeneratedFilesSetMemberWhichIsUsedForSymbolIndex
 TEST_F(RefactoringServer, RemoveGeneratedFilesSetMemberWhichIsUsedForSymbolIndexing)
 {
     FileContainers unsaved{{{TESTDATA_DIR, "query_simplefunction.h"},
+                            filePathCache.filePathId(FilePath{TESTDATA_DIR, "query_simplefunction.h"}),
                             "void f();",
                             {}}};
     refactoringServer.updateGeneratedFiles(Utils::clone(unsaved));
@@ -297,8 +312,12 @@ TEST_F(RefactoringServer, RemoveGeneratedFilesSetMemberWhichIsUsedForSymbolIndex
     ASSERT_THAT(generatedFiles.fileContainers(), IsEmpty());
 }
 
-TEST_F(RefactoringServer, UpdateProjectPartsCallsSymbolIndexingUpdateProjectParts)
+TEST_F(RefactoringServer, UpdateProjectPartsCalls)
 {
+    NiceMock<MockFilePathCaching> mockFilePathCaching;
+    ClangBackEnd::RefactoringServer refactoringServer{mockSymbolIndexing,
+                                                      mockFilePathCaching,
+                                                      generatedFiles};
     ProjectPartContainers projectParts{
         {{1,
           {"-I", TESTDATA_DIR},
@@ -313,8 +332,8 @@ TEST_F(RefactoringServer, UpdateProjectPartsCallsSymbolIndexingUpdateProjectPart
           Utils::LanguageVersion::C11,
           Utils::LanguageExtension::All}}};
 
-    EXPECT_CALL(mockSymbolIndexing,
-                updateProjectParts(projectParts));
+    EXPECT_CALL(mockFilePathCaching, populateIfEmpty());
+    EXPECT_CALL(mockSymbolIndexing, updateProjectParts(projectParts));
 
     refactoringServer.updateProjectParts({Utils::clone(projectParts), {}});
 }
diff --git a/tests/unit/unittest/symbolindexer-test.cpp b/tests/unit/unittest/symbolindexer-test.cpp
index 127921ca98..25c7056f02 100644
--- a/tests/unit/unittest/symbolindexer-test.cpp
+++ b/tests/unit/unittest/symbolindexer-test.cpp
@@ -203,6 +203,7 @@ protected:
                                       Utils::LanguageVersion::CXX14,
                                       Utils::LanguageExtension::None};
     FileContainers unsaved{{{TESTDATA_DIR, "query_simplefunction.h"},
+                            filePathId(TESTDATA_DIR "/query_simplefunction.h"),
                             "void f();",
                             {}}};
     SymbolEntries symbolEntries{{1, {"function", "function", SymbolKind::Function}}};
diff --git a/tests/unit/unittest/symbolscollector-test.cpp b/tests/unit/unittest/symbolscollector-test.cpp
index cdefde2a31..675a4af6d4 100644
--- a/tests/unit/unittest/symbolscollector-test.cpp
+++ b/tests/unit/unittest/symbolscollector-test.cpp
@@ -264,8 +264,10 @@ TEST_F(SymbolsCollector, ReferencedSymboldMatchesLocation)
 
 TEST_F(SymbolsCollector, DISABLED_ON_WINDOWS(CollectInUnsavedFile))
 {
-    FileContainers unsaved{
-        {{TESTDATA_DIR, "symbolscollector/generated_file.h"}, "void function();", {}}};
+    FileContainers unsaved{{{TESTDATA_DIR, "symbolscollector/generated_file.h"},
+                            filePathId({TESTDATA_DIR, "symbolscollector/generated_file.h"}),
+                            "void function();",
+                            {}}};
     collector.setFile(filePathId(TESTDATA_DIR "/symbolscollector/unsaved.cpp"), {"cc"});
     collector.setUnsavedFiles(std::move(unsaved));