From a179030a02d83e048b1c6032c619dec4e952fa2f Mon Sep 17 00:00:00 2001 From: Marco Bubke Date: Wed, 23 Jan 2019 14:10:58 +0100 Subject: [PATCH] ClangRefactoring: Adapt project part in the database Extend ProjectPartArtefact and use CommandLineBuilder everywhere. Task-number: QTCREATORBUG-21842 Change-Id: Ibc78849bc543512eccec8a558a1c3f57fec33fa2 Reviewed-by: Ivan Donchevskii --- .../refactoringdatabaseinitializer.h | 5 +- src/libs/utils/cpplanguage_details.h | 2 +- .../source/projectpartartefact.cpp | 2 +- .../source/projectpartartefact.h | 34 ++++- .../source/projectpartentry.h | 10 +- .../source/symbolindexer.cpp | 61 ++++----- .../source/symbolindexer.h | 4 - .../source/symbolstorage.h | 46 ++++--- .../source/symbolstorageinterface.h | 5 +- .../unit/unittest/commandlinebuilder-test.cpp | 33 ++++- .../unit/unittest/gtest-creator-printing.cpp | 2 +- .../unit/unittest/mocksqlitereadstatement.cpp | 4 +- tests/unit/unittest/mocksqlitereadstatement.h | 4 +- .../unit/unittest/mocksqlitewritestatement.h | 10 +- tests/unit/unittest/mocksymbolstorage.h | 7 +- .../unittest/projectpartartefact-test.cpp | 120 +++++++++++++++--- .../refactoringdatabaseinitializer-test.cpp | 19 ++- tests/unit/unittest/symbolindexer-test.cpp | 113 ++++++++++++++--- tests/unit/unittest/symbolstorage-test.cpp | 20 ++- 19 files changed, 376 insertions(+), 125 deletions(-) diff --git a/src/libs/clangsupport/refactoringdatabaseinitializer.h b/src/libs/clangsupport/refactoringdatabaseinitializer.h index 44c23e18a0a..cce203f0d44 100644 --- a/src/libs/clangsupport/refactoringdatabaseinitializer.h +++ b/src/libs/clangsupport/refactoringdatabaseinitializer.h @@ -123,10 +123,13 @@ public: table.setName("projectParts"); table.addColumn("projectPartId", Sqlite::ColumnType::Integer, Sqlite::Contraint::PrimaryKey); const Sqlite::Column &projectPartNameColumn = table.addColumn("projectPartName", Sqlite::ColumnType::Text); - table.addColumn("compilerArguments", Sqlite::ColumnType::Text); + table.addColumn("toolChainArguments", Sqlite::ColumnType::Text); table.addColumn("compilerMacros", Sqlite::ColumnType::Text); table.addColumn("systemIncludeSearchPaths", Sqlite::ColumnType::Text); table.addColumn("projectIncludeSearchPaths", Sqlite::ColumnType::Text); + table.addColumn("language", Sqlite::ColumnType::Integer); + table.addColumn("languageVersion", Sqlite::ColumnType::Integer); + table.addColumn("languageExtension", Sqlite::ColumnType::Integer); table.addUniqueIndex({projectPartNameColumn}); table.initialize(database); diff --git a/src/libs/utils/cpplanguage_details.h b/src/libs/utils/cpplanguage_details.h index 7666ee7fcf1..43474d03cbb 100644 --- a/src/libs/utils/cpplanguage_details.h +++ b/src/libs/utils/cpplanguage_details.h @@ -37,7 +37,7 @@ enum class LanguageVersion : unsigned char { C11, C18, LatestC = C18, - CXX98, + CXX98 = 32, CXX03, CXX11, CXX14, diff --git a/src/tools/clangrefactoringbackend/source/projectpartartefact.cpp b/src/tools/clangrefactoringbackend/source/projectpartartefact.cpp index 1c62bec8fea..7623f38796b 100644 --- a/src/tools/clangrefactoringbackend/source/projectpartartefact.cpp +++ b/src/tools/clangrefactoringbackend/source/projectpartartefact.cpp @@ -121,7 +121,7 @@ void ProjectPartArtefact::checkError(const char *whatError, const QJsonParseErro bool operator==(const ProjectPartArtefact &first, const ProjectPartArtefact &second) { - return first.compilerArguments == second.compilerArguments + return first.toolChainArguments == second.toolChainArguments && first.compilerMacros == second.compilerMacros && first.systemIncludeSearchPaths == second.systemIncludeSearchPaths && first.projectIncludeSearchPaths == second.projectIncludeSearchPaths; diff --git a/src/tools/clangrefactoringbackend/source/projectpartartefact.h b/src/tools/clangrefactoringbackend/source/projectpartartefact.h index 44ca9acadb5..505326c3753 100644 --- a/src/tools/clangrefactoringbackend/source/projectpartartefact.h +++ b/src/tools/clangrefactoringbackend/source/projectpartartefact.h @@ -27,6 +27,7 @@ #include "projectpartartefactexception.h" +#include #include #include @@ -44,12 +45,36 @@ public: Utils::SmallStringView compilerMacrosText, Utils::SmallStringView systemIncludeSearchPathsText, Utils::SmallStringView projectIncludeSearchPathsText, - int projectPartId) - : compilerArguments(toStringVector(compilerArgumentsText)) + 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(language)) + , languageVersion(static_cast(languageVersion)) + , languageExtension(static_cast(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); @@ -62,11 +87,14 @@ public: friend bool operator==(const ProjectPartArtefact &first, const ProjectPartArtefact &second); public: - Utils::SmallStringVector compilerArguments; + 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; diff --git a/src/tools/clangrefactoringbackend/source/projectpartentry.h b/src/tools/clangrefactoringbackend/source/projectpartentry.h index 4cadaa4aa1e..e7f9bec7e67 100644 --- a/src/tools/clangrefactoringbackend/source/projectpartentry.h +++ b/src/tools/clangrefactoringbackend/source/projectpartentry.h @@ -37,20 +37,22 @@ public: ProjectPartEntry(Utils::SmallStringView projectPathName, const FilePathIds &filePathIds, Utils::SmallStringVector &&compilerArguments) - : projectPathName(projectPathName), filePathIds(filePathIds), compilerArguments(compilerArguments) + : projectPathName(projectPathName) + , filePathIds(filePathIds) + , toolChainArguments(compilerArguments) {} friend bool operator==(const ProjectPartEntry &first, const ProjectPartEntry &second) { return first.projectPathName == second.projectPathName - && first.filePathIds == second.filePathIds - && first.compilerArguments == second.compilerArguments; + && first.filePathIds == second.filePathIds + && first.toolChainArguments == second.toolChainArguments; } public: Utils::PathString projectPathName; FilePathIds filePathIds; - Utils::SmallStringVector compilerArguments; + Utils::SmallStringVector toolChainArguments; }; using ProjectPartEntries = std::vector; diff --git a/src/tools/clangrefactoringbackend/source/symbolindexer.cpp b/src/tools/clangrefactoringbackend/source/symbolindexer.cpp index 0a45d361d9a..2ee454eadb1 100644 --- a/src/tools/clangrefactoringbackend/source/symbolindexer.cpp +++ b/src/tools/clangrefactoringbackend/source/symbolindexer.cpp @@ -91,7 +91,10 @@ void SymbolIndexer::updateProjectPart(ProjectPartContainer &&projectPart) projectPart.toolChainArguments, projectPart.compilerMacros, projectPart.systemIncludeSearchPaths, - projectPart.projectIncludeSearchPaths); + projectPart.projectIncludeSearchPaths, + projectPart.language, + projectPart.languageVersion, + projectPart.languageExtension); if (optionalArtefact) projectPartId = optionalArtefact->projectPartId; const Utils::optional optionalProjectPartPch = m_symbolStorage.fetchPrecompiledHeader(projectPartId); @@ -174,39 +177,37 @@ void SymbolIndexer::updateChangedPath(FilePathId filePathId, optionalArtefact->projectPartId); transaction.commit(); - if (!optionalArtefact.value().compilerArguments.empty()) { - const ProjectPartArtefact &artefact = optionalArtefact.value(); + const ProjectPartArtefact &artefact = optionalArtefact.value(); - const Utils::SmallStringVector arguments = compilerArguments(artefact.compilerArguments, - optionalProjectPartPch); + auto pchPath = optionalProjectPartPch ? optionalProjectPartPch.value().pchPath : FilePath{}; - auto indexing = [projectPartId = artefact.projectPartId, arguments, filePathId, this]( - SymbolsCollectorInterface &symbolsCollector) { - symbolsCollector.setFile(filePathId, arguments); + CommandLineBuilder builder{ + artefact, artefact.toolChainArguments, {}, {}, pchPath}; - symbolsCollector.collectSymbols(); + auto indexing = [projectPartId = artefact.projectPartId, arguments=builder.commandLine, filePathId, this]( + SymbolsCollectorInterface &symbolsCollector) { + symbolsCollector.setFile(filePathId, arguments); - Sqlite::ImmediateTransaction transaction{m_transactionInterface}; + symbolsCollector.collectSymbols(); - m_symbolStorage.addSymbolsAndSourceLocations(symbolsCollector.symbols(), - symbolsCollector.sourceLocations()); + Sqlite::ImmediateTransaction transaction{m_transactionInterface}; - m_symbolStorage.updateProjectPartSources(projectPartId, symbolsCollector.sourceFiles()); + m_symbolStorage.addSymbolsAndSourceLocations(symbolsCollector.symbols(), + symbolsCollector.sourceLocations()); - m_buildDependencyStorage.insertOrUpdateUsedMacros(symbolsCollector.usedMacros()); + m_symbolStorage.updateProjectPartSources(projectPartId, symbolsCollector.sourceFiles()); - m_buildDependencyStorage.insertFileStatuses(symbolsCollector.fileStatuses()); + m_buildDependencyStorage.insertOrUpdateUsedMacros(symbolsCollector.usedMacros()); - m_buildDependencyStorage.insertOrUpdateSourceDependencies( - symbolsCollector.sourceDependencies()); + m_buildDependencyStorage.insertFileStatuses(symbolsCollector.fileStatuses()); - transaction.commit(); - }; + m_buildDependencyStorage.insertOrUpdateSourceDependencies( + symbolsCollector.sourceDependencies()); - symbolIndexerTask.emplace_back(filePathId, - optionalArtefact->projectPartId, - std::move(indexing)); - } + transaction.commit(); + }; + + symbolIndexerTask.emplace_back(filePathId, optionalArtefact->projectPartId, std::move(indexing)); } bool SymbolIndexer::compilerMacrosOrIncludeSearchPathsAreDifferent( @@ -247,18 +248,4 @@ FilePathIds SymbolIndexer::updatableFilePathIds(const ProjectPartContainer &proj return filterChangedFiles(projectPart); } -Utils::SmallStringVector SymbolIndexer::compilerArguments( - Utils::SmallStringVector arguments, - const Utils::optional optionalProjectPartPch) const -{ - if (optionalProjectPartPch) { - arguments.emplace_back("-Xclang"); - arguments.emplace_back("-include-pch"); - arguments.emplace_back("-Xclang"); - arguments.emplace_back(std::move(optionalProjectPartPch.value().pchPath)); - } - - return arguments; -} - } // namespace ClangBackEnd diff --git a/src/tools/clangrefactoringbackend/source/symbolindexer.h b/src/tools/clangrefactoringbackend/source/symbolindexer.h index 55f62ffa5f2..bee726abf42 100644 --- a/src/tools/clangrefactoringbackend/source/symbolindexer.h +++ b/src/tools/clangrefactoringbackend/source/symbolindexer.h @@ -67,10 +67,6 @@ public: FilePathIds updatableFilePathIds(const ProjectPartContainer &projectPart, const Utils::optional &optionalArtefact) const; - Utils::SmallStringVector compilerArguments( - Utils::SmallStringVector arguments, - const Utils::optional optionalProjectPartPch) const; - private: SymbolIndexerTaskQueueInterface &m_symbolIndexerTaskQueue; SymbolStorageInterface &m_symbolStorage; diff --git a/src/tools/clangrefactoringbackend/source/symbolstorage.h b/src/tools/clangrefactoringbackend/source/symbolstorage.h index 0be04c04b66..f2993f9a43c 100644 --- a/src/tools/clangrefactoringbackend/source/symbolstorage.h +++ b/src/tools/clangrefactoringbackend/source/symbolstorage.h @@ -33,6 +33,8 @@ #include #include +#include + #include #include #include @@ -69,21 +71,27 @@ public: } int insertOrUpdateProjectPart(Utils::SmallStringView projectPartName, - const Utils::SmallStringVector &commandLineArguments, + const Utils::SmallStringVector &toolChainArguments, const CompilerMacros &compilerMacros, const IncludeSearchPaths &systemIncludeSearchPaths, - const IncludeSearchPaths &projectIncludeSearchPaths) override + const IncludeSearchPaths &projectIncludeSearchPaths, + Utils::Language language, + Utils::LanguageVersion languageVersion, + Utils::LanguageExtension languageExtension) override { - Utils::SmallString compilerArguementsAsJson = toJson(commandLineArguments); + Utils::SmallString toolChainArgumentsAsJson = toJson(toolChainArguments); Utils::SmallString compilerMacrosAsJson = toJson(compilerMacros); Utils::SmallString systemIncludeSearchPathsAsJason = toJson(systemIncludeSearchPaths); Utils::SmallString projectIncludeSearchPathsAsJason = toJson(projectIncludeSearchPaths); m_insertOrUpdateProjectPartStatement.write(projectPartName, - compilerArguementsAsJson, + toolChainArgumentsAsJson, compilerMacrosAsJson, systemIncludeSearchPathsAsJason, - projectIncludeSearchPathsAsJason); + projectIncludeSearchPathsAsJason, + static_cast(language), + static_cast(languageVersion), + static_cast(languageExtension)); auto projectPartId = m_getProjectPartIdStatement.template value(projectPartName); @@ -94,14 +102,14 @@ public: { ReadStatement &statement = m_getProjectPartArtefactsBySourceId; - return statement.template value(sourceId.filePathId); + return statement.template value(sourceId.filePathId); } Utils::optional fetchProjectPartArtefact(Utils::SmallStringView projectPartName) const override { ReadStatement &statement = m_getProjectPartArtefactsByProjectPartName; - return statement.template value(projectPartName); + return statement.template value(projectPartName); } void updateProjectPartSources(int projectPartId, @@ -308,10 +316,12 @@ public: m_database }; WriteStatement m_insertOrUpdateProjectPartStatement{ - "INSERT INTO projectParts(projectPartName, compilerArguments, compilerMacros, " - "systemIncludeSearchPaths, projectIncludeSearchPaths) VALUES (?001,?002,?003,?004,?005) ON " - "CONFLICT(projectPartName) DO UPDATE SET compilerArguments=?002, compilerMacros=?003, " - "systemIncludeSearchPaths=?004, projectIncludeSearchPaths=?005", + "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 = ?", @@ -326,16 +336,16 @@ public: m_database }; mutable ReadStatement m_getCompileArgumentsForFileIdStatement{ - "SELECT compilerArguments FROM projectParts WHERE projectPartId = (SELECT projectPartId FROM projectPartsSources WHERE sourceId = ?)", - m_database - }; + "SELECT toolChainArguments FROM projectParts WHERE projectPartId = (SELECT projectPartId " + "FROM projectPartsSources WHERE sourceId = ?)", + m_database}; mutable ReadStatement m_getProjectPartArtefactsBySourceId{ - "SELECT compilerArguments, compilerMacros, systemIncludeSearchPaths, projectIncludeSearchPaths, " - "projectPartId FROM projectParts WHERE projectPartId = (SELECT projectPartId FROM " - "projectPartsSources WHERE sourceId = ?)", + "SELECT toolChainArguments, compilerMacros, systemIncludeSearchPaths, " + "projectIncludeSearchPaths, projectPartId FROM projectParts WHERE projectPartId = (SELECT " + "projectPartId FROM projectPartsSources WHERE sourceId = ?)", m_database}; mutable ReadStatement m_getProjectPartArtefactsByProjectPartName{ - "SELECT compilerArguments, compilerMacros, systemIncludeSearchPaths, " + "SELECT toolChainArguments, compilerMacros, systemIncludeSearchPaths, " "projectIncludeSearchPaths, projectPartId FROM projectParts WHERE projectPartName = ?", m_database}; mutable ReadStatement m_getPrecompiledHeader{ diff --git a/src/tools/clangrefactoringbackend/source/symbolstorageinterface.h b/src/tools/clangrefactoringbackend/source/symbolstorageinterface.h index 3e51302c208..c10c7fca48e 100644 --- a/src/tools/clangrefactoringbackend/source/symbolstorageinterface.h +++ b/src/tools/clangrefactoringbackend/source/symbolstorageinterface.h @@ -57,7 +57,10 @@ public: const Utils::SmallStringVector &commandLineArguments, const CompilerMacros &compilerMacros, const ClangBackEnd::IncludeSearchPaths &systemIncludeSearchPaths, - const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths) + const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths, + Utils::Language language, + Utils::LanguageVersion languageVersion, + Utils::LanguageExtension languageExtension) = 0; virtual void updateProjectPartSources(int projectPartId, const FilePathIds &sourceFilePathIds) = 0; virtual Utils::optional fetchProjectPartArtefact( diff --git a/tests/unit/unittest/commandlinebuilder-test.cpp b/tests/unit/unittest/commandlinebuilder-test.cpp index 6cf673bf836..07b5a5b8dfd 100644 --- a/tests/unit/unittest/commandlinebuilder-test.cpp +++ b/tests/unit/unittest/commandlinebuilder-test.cpp @@ -28,6 +28,7 @@ #include #include #include +#include namespace { template @@ -86,7 +87,37 @@ public: Utils::LanguageExtension::None}; }; -using ProjectInfos = testing::Types; +template <> +class CommandLineBuilder : public testing::Test +{ +public: + CommandLineBuilder() + { + cppProjectInfo.language = Utils::Language::Cxx; + } + +public: + ClangBackEnd::ProjectPartArtefact emptyProjectInfo{{}, + {}, + {}, + {}, + {}, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX98, + Utils::LanguageExtension::None}; + ClangBackEnd::ProjectPartArtefact cppProjectInfo{{}, + {}, + {}, + {}, + {}, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX98, + Utils::LanguageExtension::None}; +}; + +using ProjectInfos = testing::Types; TYPED_TEST_SUITE(CommandLineBuilder, ProjectInfos); TYPED_TEST(CommandLineBuilder, AddToolChainArguments) diff --git a/tests/unit/unittest/gtest-creator-printing.cpp b/tests/unit/unittest/gtest-creator-printing.cpp index 8b2fbcd2260..682d28740b0 100644 --- a/tests/unit/unittest/gtest-creator-printing.cpp +++ b/tests/unit/unittest/gtest-creator-printing.cpp @@ -1023,7 +1023,7 @@ std::ostream &operator<<(std::ostream &out, const SourceDependency &sourceDepend std::ostream &operator<<(std::ostream &out, const ProjectPartArtefact &projectPartArtefact) { return out << "(" - << projectPartArtefact.compilerArguments << ", " + << projectPartArtefact.toolChainArguments << ", " << projectPartArtefact.compilerMacros <<")"; } diff --git a/tests/unit/unittest/mocksqlitereadstatement.cpp b/tests/unit/unittest/mocksqlitereadstatement.cpp index 79fb9879b75..b9cecd4d1aa 100644 --- a/tests/unit/unittest/mocksqlitereadstatement.cpp +++ b/tests/unit/unittest/mocksqlitereadstatement.cpp @@ -153,14 +153,14 @@ MockSqliteReadStatement::value(const Utils::SmallStringV template <> Utils::optional -MockSqliteReadStatement::value(const int& sourceId) +MockSqliteReadStatement::value(const int& sourceId) { return valueReturnProjectPartArtefact(sourceId); } template <> Utils::optional -MockSqliteReadStatement::value(const Utils::SmallStringView &projectPartName) +MockSqliteReadStatement::value(const Utils::SmallStringView &projectPartName) { return valueReturnProjectPartArtefact(projectPartName); } diff --git a/tests/unit/unittest/mocksqlitereadstatement.h b/tests/unit/unittest/mocksqlitereadstatement.h index a5c15e46b73..43c88eb0441 100644 --- a/tests/unit/unittest/mocksqlitereadstatement.h +++ b/tests/unit/unittest/mocksqlitereadstatement.h @@ -237,11 +237,11 @@ MockSqliteReadStatement::value(const Utils::SmallStringView&) template <> Utils::optional -MockSqliteReadStatement::value(const int&); +MockSqliteReadStatement::value(const int&); template <> Utils::optional -MockSqliteReadStatement::value(const int&); +MockSqliteReadStatement::value(const int&); template <> Utils::optional diff --git a/tests/unit/unittest/mocksqlitewritestatement.h b/tests/unit/unittest/mocksqlitewritestatement.h index 7e2cb0270aa..ee7df6362f7 100644 --- a/tests/unit/unittest/mocksqlitewritestatement.h +++ b/tests/unit/unittest/mocksqlitewritestatement.h @@ -78,12 +78,16 @@ public: Utils::SmallStringView, Utils::SmallStringView)); - MOCK_METHOD5(write, - void (Utils::SmallStringView, + MOCK_METHOD8(write, + void(Utils::SmallStringView, Utils::SmallStringView, Utils::SmallStringView, Utils::SmallStringView, - Utils::SmallStringView)); + Utils::SmallStringView, + int, + int, + int)); + MOCK_METHOD1(write, void (Utils::SmallStringView)); diff --git a/tests/unit/unittest/mocksymbolstorage.h b/tests/unit/unittest/mocksymbolstorage.h index 5b2451bf5ad..0e4422012e7 100644 --- a/tests/unit/unittest/mocksymbolstorage.h +++ b/tests/unit/unittest/mocksymbolstorage.h @@ -37,12 +37,15 @@ public: MOCK_METHOD2(addSymbolsAndSourceLocations, void(const ClangBackEnd::SymbolEntries &symbolEentries, const ClangBackEnd::SourceLocationEntries &sourceLocations)); - MOCK_METHOD5(insertOrUpdateProjectPart, + MOCK_METHOD8(insertOrUpdateProjectPart, int(Utils::SmallStringView projectPartName, const Utils::SmallStringVector &commandLineArgument, const ClangBackEnd::CompilerMacros &compilerMacros, const ClangBackEnd::IncludeSearchPaths &systemIncludeSearchPaths, - const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths)); + const ClangBackEnd::IncludeSearchPaths &projectIncludeSearchPaths, + Utils::Language language, + Utils::LanguageVersion languageVersion, + Utils::LanguageExtension languageExtension)); MOCK_METHOD2(updateProjectPartSources, void(int projectPartId, const ClangBackEnd::FilePathIds &sourceFilePathIds)); diff --git a/tests/unit/unittest/projectpartartefact-test.cpp b/tests/unit/unittest/projectpartartefact-test.cpp index b38f15333e3..7cb622f8bd8 100644 --- a/tests/unit/unittest/projectpartartefact-test.cpp +++ b/tests/unit/unittest/projectpartartefact-test.cpp @@ -35,27 +35,55 @@ using ClangBackEnd::IncludeSearchPathType; TEST(ProjectPartArtefact, CompilerArguments) { - ClangBackEnd::ProjectPartArtefact artefact{"[\"-DFoo\",\"-DBar\"]", "", "", "", 1}; + ClangBackEnd::ProjectPartArtefact artefact{"[\"-DFoo\",\"-DBar\"]", + "", + "", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; - ASSERT_THAT(artefact.compilerArguments, ElementsAre(Eq("-DFoo"), Eq("-DBar"))); + ASSERT_THAT(artefact.toolChainArguments, ElementsAre(Eq("-DFoo"), Eq("-DBar"))); } TEST(ProjectPartArtefact, EmptyCompilerArguments) { - ClangBackEnd::ProjectPartArtefact artefact{"", "", "", "", 1}; + ClangBackEnd::ProjectPartArtefact artefact{"", + "", + "", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; - ASSERT_THAT(artefact.compilerArguments, IsEmpty()); + ASSERT_THAT(artefact.toolChainArguments, IsEmpty()); } TEST(ProjectPartArtefact, CompilerArgumentsParseError) { - ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("\"-DFoo\",\"-DBar\"]", "", "", "", 1), + ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("\"-DFoo\",\"-DBar\"]", + "", + "", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None), ClangBackEnd::ProjectPartArtefactParseError); } TEST(ProjectPartArtefact, CompilerMacros) { - ClangBackEnd::ProjectPartArtefact artefact{"", R"([["Foo","1",1], ["Bar","42",2]])", "", "", 1}; + ClangBackEnd::ProjectPartArtefact artefact{"", + R"([["Foo","1",1], ["Bar","42",2]])", + "", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; ASSERT_THAT(artefact.compilerMacros, UnorderedElementsAre(Eq(CompilerMacro{"Foo", "1", 1}), Eq(CompilerMacro{"Bar", "42", 2}))); @@ -63,21 +91,41 @@ TEST(ProjectPartArtefact, CompilerMacros) TEST(ProjectPartArtefact, EmptyCompilerMacros) { - ClangBackEnd::ProjectPartArtefact artefact{"", "", "", "", 1}; + ClangBackEnd::ProjectPartArtefact artefact{"", + "", + "", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; ASSERT_THAT(artefact.compilerMacros, IsEmpty()); } TEST(ProjectPartArtefact, CompilerMacrosParseError) { - ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("", R"([["Foo":"1", 1], ["Bar", "42", 2]])", "", "", 1), + ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("", + R"([["Foo":"1", 1], ["Bar", "42", 2]])", + "", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None), ClangBackEnd::ProjectPartArtefactParseError); } TEST(ProjectPartArtefact, SystemIncludeSearchPaths) { - ClangBackEnd::ProjectPartArtefact artefact{ - "", "", R"([["/includes", 1, 2], ["/other/includes", 2, 3]])", "", 1}; + ClangBackEnd::ProjectPartArtefact artefact{"", + "", + R"([["/includes", 1, 2], ["/other/includes", 2, 3]])", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; ASSERT_THAT( artefact.systemIncludeSearchPaths, @@ -87,7 +135,14 @@ TEST(ProjectPartArtefact, SystemIncludeSearchPaths) TEST(ProjectPartArtefact, EmptySystemIncludeSearchPaths) { - ClangBackEnd::ProjectPartArtefact artefact{"", "", "", "", 1}; + ClangBackEnd::ProjectPartArtefact artefact{"", + "", + "", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; ASSERT_THAT(artefact.systemIncludeSearchPaths, IsEmpty()); } @@ -95,7 +150,14 @@ TEST(ProjectPartArtefact, EmptySystemIncludeSearchPaths) TEST(ProjectPartArtefact, ProjectIncludeSearchPaths) { ClangBackEnd::ProjectPartArtefact artefact{ - "", "", R"([["/project/includes", 1, 1], ["/other/project/includes", 2, 1]])", "", 1}; + "", + "", + R"([["/project/includes", 1, 1], ["/other/project/includes", 2, 1]])", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; ASSERT_THAT( artefact.systemIncludeSearchPaths, @@ -106,22 +168,42 @@ TEST(ProjectPartArtefact, ProjectIncludeSearchPaths) TEST(ProjectPartArtefact, EmptyProjectIncludeSearchPaths) { - ClangBackEnd::ProjectPartArtefact artefact{"", "", "", "", 1}; + ClangBackEnd::ProjectPartArtefact artefact{"", + "", + "", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; ASSERT_THAT(artefact.projectIncludeSearchPaths, IsEmpty()); } TEST(ProjectPartArtefact, IncludeSystemSearchPathsParseError) { - ASSERT_THROW( - ClangBackEnd::ProjectPartArtefact("", "", R"(["/includes", 1, 3], ["/other/includes", 2, 2]])", "", 1), - ClangBackEnd::ProjectPartArtefactParseError); + ASSERT_THROW(ClangBackEnd::ProjectPartArtefact("", + "", + R"(["/includes", 1, 3], ["/other/includes", 2, 2]])", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None), + ClangBackEnd::ProjectPartArtefactParseError); } TEST(ProjectPartArtefact, IncludeProjectSearchPathsParseError) { - ASSERT_THROW( - ClangBackEnd::ProjectPartArtefact("", "", R"(["/project/includes", 1, 1], ["/other/project/includes", 2, 1]])", "", 1), - ClangBackEnd::ProjectPartArtefactParseError); + ASSERT_THROW(ClangBackEnd::ProjectPartArtefact( + "", + "", + R"(["/project/includes", 1, 1], ["/other/project/includes", 2, 1]])", + "", + 1, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None), + ClangBackEnd::ProjectPartArtefactParseError); } } diff --git a/tests/unit/unittest/refactoringdatabaseinitializer-test.cpp b/tests/unit/unittest/refactoringdatabaseinitializer-test.cpp index cfae1d80f06..7e1e730b179 100644 --- a/tests/unit/unittest/refactoringdatabaseinitializer-test.cpp +++ b/tests/unit/unittest/refactoringdatabaseinitializer-test.cpp @@ -88,7 +88,11 @@ TEST_F(RefactoringDatabaseInitializer, AddProjectPartsTable) { InSequence s; - EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY KEY, projectPartName TEXT, compilerArguments TEXT, compilerMacros TEXT, systemIncludeSearchPaths TEXT, projectIncludeSearchPaths TEXT)"))); + EXPECT_CALL(mockDatabase, + execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY " + "KEY, projectPartName TEXT, toolChainArguments TEXT, compilerMacros " + "TEXT, systemIncludeSearchPaths TEXT, projectIncludeSearchPaths TEXT, " + "language INTEGER, languageVersion INTEGER, languageExtension INTEGER)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)"))); initializer.createProjectPartsTable(); @@ -160,7 +164,12 @@ TEST_F(RefactoringDatabaseInitializer, CreateInTheContructor) EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_sources_directoryId_sourceName ON sources(directoryId, sourceName)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS directories(directoryId INTEGER PRIMARY KEY, directoryPath TEXT)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_directories_directoryPath ON directories(directoryPath)"))); - EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY KEY, projectPartName TEXT, compilerArguments TEXT, compilerMacros TEXT, systemIncludeSearchPaths TEXT, projectIncludeSearchPaths TEXT)"))); + EXPECT_CALL(mockDatabase, + execute( + Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY " + "KEY, projectPartName TEXT, toolChainArguments TEXT, compilerMacros " + "TEXT, systemIncludeSearchPaths TEXT, projectIncludeSearchPaths TEXT, " + "language INTEGER, languageVersion INTEGER, languageExtension INTEGER)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectPartsSources(projectPartId INTEGER, sourceId INTEGER, sourceType INTEGER)"))); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectPartsSources_sourceId_projectPartId ON projectPartsSources(sourceId, projectPartId)"))); @@ -194,7 +203,11 @@ TEST_F(RefactoringDatabaseInitializer, DontCreateIfAlreadyInitialized) EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_sources_directoryId_sourceName ON sources(directoryId, sourceName)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS directories(directoryId INTEGER PRIMARY KEY, directoryPath TEXT)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_directories_directoryPath ON directories(directoryPath)"))).Times(0); - EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY KEY, projectPartName TEXT, compilerArguments TEXT, compilerMacros TEXT, includeSearchPaths TEXT)"))).Times(0); + EXPECT_CALL(mockDatabase, + execute(Eq("CREATE TABLE IF NOT EXISTS projectParts(projectPartId INTEGER PRIMARY " + "KEY, projectPartName TEXT, toolChainArguments TEXT, compilerMacros " + "TEXT, includeSearchPaths TEXT)"))) + .Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectParts_projectPartName ON projectParts(projectPartName)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE TABLE IF NOT EXISTS projectPartsSources(projectPartId INTEGER, sourceId INTEGER)"))).Times(0); EXPECT_CALL(mockDatabase, execute(Eq("CREATE UNIQUE INDEX IF NOT EXISTS index_projectPartsSources_sourceId_projectPartId ON projectPartsSources(sourceId, projectPartId)"))).Times(0); diff --git a/tests/unit/unittest/symbolindexer-test.cpp b/tests/unit/unittest/symbolindexer-test.cpp index a5ee83b2b8b..f28d0e66968 100644 --- a/tests/unit/unittest/symbolindexer-test.cpp +++ b/tests/unit/unittest/symbolindexer-test.cpp @@ -218,8 +218,18 @@ protected: R"([["FOO","1", 2],["BAR","1", 1]])", systemIncludeSearchPathsText, projectIncludeSearchPathsText, - 74}; - ClangBackEnd::ProjectPartArtefact emptyArtefact{"", "", "", "", 74}; + 74, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX14, + Utils::LanguageExtension::None}; + ClangBackEnd::ProjectPartArtefact emptyArtefact{"", + "", + "", + "", + 74, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX14, + Utils::LanguageExtension::None}; Utils::optional nullArtefact; ClangBackEnd::ProjectPartPch projectPartPch{"/path/to/pch", 4}; NiceMock mockSqliteTransactionBackend; @@ -398,7 +408,10 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartsInStorage) ElementsAre("-Wno-pragma-once-outside-header"), ElementsAre(CompilerMacro{"BAR", "1", 1}, CompilerMacro{"FOO", "1", 2}), Eq(systemIncludeSearchPaths), - Eq(projectIncludeSearchPaths))); + Eq(projectIncludeSearchPaths), + Eq(Utils::Language::Cxx), + Eq(Utils::LanguageVersion::CXX14), + Eq(Utils::LanguageExtension::None))); EXPECT_CALL( mockSymbolStorage, insertOrUpdateProjectPart( @@ -406,7 +419,10 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartsInStorage) ElementsAre("-Wno-pragma-once-outside-header"), ElementsAre(CompilerMacro{"BAR", "1", 1}, CompilerMacro{"FOO", "0", 2}), Eq(systemIncludeSearchPaths), - Eq(projectIncludeSearchPaths))); + Eq(projectIncludeSearchPaths), + Eq(Utils::Language::Cxx), + Eq(Utils::LanguageVersion::CXX14), + Eq(Utils::LanguageExtension::None))); indexer.updateProjectParts({projectPart1, projectPart2}); } @@ -414,7 +430,7 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartsInStorage) TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSourcesWithArtifact) { ON_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq("project1"))).WillByDefault(Return(artefact)); - ON_CALL(mockSymbolStorage, insertOrUpdateProjectPart(Eq("project1"), _, _, _, _)).WillByDefault(Return(-1)); + ON_CALL(mockSymbolStorage, insertOrUpdateProjectPart(Eq("project1"), _, _, _, _, _, _, _)).WillByDefault(Return(-1)); EXPECT_CALL(mockSymbolStorage, updateProjectPartSources(_, _)); @@ -424,7 +440,7 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSourcesWithArtifac TEST_F(SymbolIndexer, UpdateProjectPartsCallsUpdateProjectPartSourcesWithoutArtifact) { ON_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq("project2"))).WillByDefault(Return(nullArtefact)); - ON_CALL(mockSymbolStorage, insertOrUpdateProjectPart(Eq("project2"), _, _, _, _)).WillByDefault(Return(3)); + ON_CALL(mockSymbolStorage, insertOrUpdateProjectPart(Eq("project2"), _, _, _, _, _, _, _)).WillByDefault(Return(3)); EXPECT_CALL(mockSymbolStorage, updateProjectPartSources(3, ElementsAre(IsFileId(1), IsFileId(23)))); @@ -474,7 +490,10 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsInOrderWithoutProjectPartArtifact) Eq(projectPart1.toolChainArguments), Eq(projectPart1.compilerMacros), Eq(projectPart1.systemIncludeSearchPaths), - Eq(projectPart1.projectIncludeSearchPaths))) + Eq(projectPart1.projectIncludeSearchPaths), + Eq(Utils::Language::Cxx), + Eq(Utils::LanguageVersion::CXX14), + Eq(Utils::LanguageExtension::None))) .WillOnce(Return(12)); EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(12))); EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(Eq(main1PathId))).Times(0); @@ -521,7 +540,10 @@ TEST_F(SymbolIndexer, UpdateProjectPartsCallsInOrderWithProjectPartArtifact) Eq(projectPart1.toolChainArguments), Eq(projectPart1.compilerMacros), Eq(projectPart1.systemIncludeSearchPaths), - Eq(projectPart1.projectIncludeSearchPaths))) + Eq(projectPart1.projectIncludeSearchPaths), + Eq(Utils::Language::Cxx), + Eq(Utils::LanguageVersion::CXX14), + Eq(Utils::LanguageExtension::None))) .WillOnce(Return(-1)); EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(artefact.projectPartId))); EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(Eq(main1PathId))).WillOnce(Return(-1)); @@ -580,7 +602,25 @@ TEST_F(SymbolIndexer, UpdateChangedPathCallsInOrder) EXPECT_CALL(mockSymbolStorage, fetchProjectPartArtefact(TypedEq(sourceFileIds[0]))).WillOnce(Return(artefact)); EXPECT_CALL(mockSymbolStorage, fetchPrecompiledHeader(Eq(artefact.projectPartId))); EXPECT_CALL(mockSqliteTransactionBackend, commit()); - EXPECT_CALL(mockCollector, setFile(Eq(sourceFileIds[0]), Eq(artefact.compilerArguments))); + EXPECT_CALL(mockCollector, + setFile(Eq(sourceFileIds[0]), + ElementsAre("clang++", + "-DFOO", + "-x", + "c++-header", + "-std=c++14", + "-nostdinc", + "-nostdlibinc", + "-I", + "/project/includes", + "-I", + "/other/project/includes", + "-isystem", + TESTDATA_DIR, + "-isystem", + "/other/includes", + "-isystem", + "/includes"))); EXPECT_CALL(mockCollector, collectSymbols()); EXPECT_CALL(mockSqliteTransactionBackend, immediateBegin()); EXPECT_CALL(mockSymbolStorage, addSymbolsAndSourceLocations(symbolEntries, sourceLocations)); @@ -622,12 +662,29 @@ TEST_F(SymbolIndexer, UpdateChangedPathIsUsingPrecompiledHeader) .WillByDefault(Return(projectPartPch)); std::vector symbolIndexerTask; - EXPECT_CALL(mockCollector, setFile(Eq(sourceFileIds[0]), - ElementsAre(Eq("-DFOO"), - Eq("-Xclang"), - Eq("-include-pch"), - Eq("-Xclang"), - Eq("/path/to/pch")))); + EXPECT_CALL(mockCollector, + setFile(Eq(sourceFileIds[0]), + ElementsAre("clang++", + "-DFOO", + "-x", + "c++-header", + "-std=c++14", + "-nostdinc", + "-nostdlibinc", + "-I", + "/project/includes", + "-I", + "/other/project/includes", + "-isystem", + TESTDATA_DIR, + "-isystem", + "/other/includes", + "-isystem", + "/includes", + "-Xclang", + "-include-pch", + "-Xclang", + "/path/to/pch"))); indexer.pathsChanged({sourceFileIds[0]}); } @@ -638,8 +695,25 @@ TEST_F(SymbolIndexer, UpdateChangedPathIsNotUsingPrecompiledHeaderIfItNotExists) .WillByDefault(Return(artefact)); std::vector symbolIndexerTask; - EXPECT_CALL(mockCollector, setFile(Eq(sourceFileIds[0]), - ElementsAre(Eq("-DFOO")))); + EXPECT_CALL(mockCollector, + setFile(Eq(sourceFileIds[0]), + ElementsAre("clang++", + "-DFOO", + "-x", + "c++-header", + "-std=c++14", + "-nostdinc", + "-nostdlibinc", + "-I", + "/project/includes", + "-I", + "/other/project/includes", + "-isystem", + TESTDATA_DIR, + "-isystem", + "/other/includes", + "-isystem", + "/includes"))); indexer.pathsChanged({sourceFileIds[0]}); } @@ -728,7 +802,10 @@ TEST_F(SymbolIndexer, DontReparseInUpdateProjectPartsIfDefinesAreTheSame) Eq(projectPart1.toolChainArguments), Eq(projectPart1.compilerMacros), Eq(projectPart1.systemIncludeSearchPaths), - Eq(projectPart1.projectIncludeSearchPaths))); + Eq(projectPart1.projectIncludeSearchPaths), + Eq(Utils::Language::Cxx), + Eq(Utils::LanguageVersion::CXX14), + Eq(Utils::LanguageExtension::None))); EXPECT_CALL(mockBuildDependenciesStorage, fetchLowestLastModifiedTime(A())).WillRepeatedly(Return(QDateTime::currentSecsSinceEpoch())); EXPECT_CALL(mockSqliteTransactionBackend, commit()); EXPECT_CALL(mockCollector, setFile(_, _)).Times(0); diff --git a/tests/unit/unittest/symbolstorage-test.cpp b/tests/unit/unittest/symbolstorage-test.cpp index 4a3958212b2..c960a028bc3 100644 --- a/tests/unit/unittest/symbolstorage-test.cpp +++ b/tests/unit/unittest/symbolstorage-test.cpp @@ -94,7 +94,10 @@ protected: R"([["FOO","1",1]])", systemIncludeSearchPathsText, projectIncludeSearchPathsText, - 74}; + 74, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None}; }; TEST_F(SymbolStorage, CreateAndFillTemporaryLocationsTable) @@ -192,13 +195,22 @@ TEST_F(SymbolStorage, InsertOrUpdateProjectPart) TypedEq(R"(["foo"])"), TypedEq(R"([["FOO","1",1]])"), TypedEq(systemIncludeSearchPathsText), - TypedEq(projectIncludeSearchPathsText))); + TypedEq(projectIncludeSearchPathsText), + 1, + 34, + 0)); EXPECT_CALL( getProjectPartIdStatement, valueReturnInt32(TypedEq("project"))) .WillOnce(Return(74)); - storage.insertOrUpdateProjectPart( - "project", {"foo"}, {{"FOO", "1", 1}}, systemIncludeSearchPaths, projectIncludeSearchPaths); + storage.insertOrUpdateProjectPart("project", + {"foo"}, + {{"FOO", "1", 1}}, + systemIncludeSearchPaths, + projectIncludeSearchPaths, + Utils::Language::Cxx, + Utils::LanguageVersion::CXX11, + Utils::LanguageExtension::None); }