feedc0de/qt-creator
1
0
Fork 0
forked from qt-creator/qt-creator
Code Pull Requests Activity

ClangRefactoring: Adapt project part in the database

Browse Source 
Extend ProjectPartArtefact and use CommandLineBuilder everywhere.

Task-number: QTCREATORBUG-21842
Change-Id: Ibc78849bc543512eccec8a558a1c3f57fec33fa2
Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>
This commit is contained in:
Marco Bubke
2019-01-23 14:10:58 +01:00
parent 1c2d41a63e
commit a179030a02
19 changed files with 376 additions and 125 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
src/libs/clangsupport/refactoringdatabaseinitializer.h
View File

@@ -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);

2
src/libs/utils/cpplanguage_details.h
View File

@@ -37,7 +37,7 @@ enum class LanguageVersion : unsigned char {
C11,
C18,
LatestC = C18,
CXX98,
CXX98 = 32,
CXX03,
CXX11,
CXX14,

2
src/tools/clangrefactoringbackend/source/projectpartartefact.cpp
View File

@@ -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;

34
src/tools/clangrefactoringbackend/source/projectpartartefact.h
View File

@@ -27,6 +27,7 @@
#include "projectpartartefactexception.h"
#include <utils/cpplanguage_details.h>
#include <utils/smallstringvector.h>
#include <compilermacro.h>
@@ -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<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);
@@ -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<ProjectPartArtefact>;

10
src/tools/clangrefactoringbackend/source/projectpartentry.h
View File

@@ -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<ProjectPartEntry>;

61
src/tools/clangrefactoringbackend/source/symbolindexer.cpp
View File

@@ -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<ProjectPartPch> 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<ProjectPartArtefact, Utils::SmallStringVector> 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<ProjectPartPch> 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

4
src/tools/clangrefactoringbackend/source/symbolindexer.h
View File

@@ -67,10 +67,6 @@ public:
FilePathIds updatableFilePathIds(const ProjectPartContainer &projectPart,
const Utils::optional<ProjectPartArtefact> &optionalArtefact) const;
Utils::SmallStringVector compilerArguments(
Utils::SmallStringVector arguments,
const Utils::optional<ProjectPartPch> optionalProjectPartPch) const;
private:
SymbolIndexerTaskQueueInterface &m_symbolIndexerTaskQueue;
SymbolStorageInterface &m_symbolStorage;

46
src/tools/clangrefactoringbackend/source/symbolstorage.h
View File

@@ -33,6 +33,8 @@
#include <sqlitetable.h>
#include <includesearchpath.h>
#include <utils/cpplanguage_details.h>
#include <QJsonArray>
#include <QJsonDocument>
#include <QJsonObject>
@@ -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<int>(language),
static_cast<int>(languageVersion),
static_cast<int>(languageExtension));
auto projectPartId = m_getProjectPartIdStatement.template value<int>(projectPartName);
@@ -94,14 +102,14 @@ public:
{
ReadStatement &statement = m_getProjectPartArtefactsBySourceId;
return statement.template value<ProjectPartArtefact, 5>(sourceId.filePathId);
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, 5>(projectPartName);
return statement.template value<ProjectPartArtefact, 8>(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{

5
src/tools/clangrefactoringbackend/source/symbolstorageinterface.h
View File

@@ -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<ProjectPartArtefact> fetchProjectPartArtefact(

33
tests/unit/unittest/commandlinebuilder-test.cpp
View File

@@ -28,6 +28,7 @@
#include <commandlinebuilder.h>
#include <pchtask.h>
#include <projectpartcontainer.h>
#include <projectpartartefact.h>
namespace {
template<typename ProjectInfo>
@@ -86,7 +87,37 @@ public:
Utils::LanguageExtension::None};
};
using ProjectInfos = testing::Types<ClangBackEnd::PchTask, ClangBackEnd::ProjectPartContainer>;
template <>
class CommandLineBuilder<ClangBackEnd::ProjectPartArtefact> : 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<ClangBackEnd::PchTask,
ClangBackEnd::ProjectPartContainer,
ClangBackEnd::ProjectPartArtefact>;
TYPED_TEST_SUITE(CommandLineBuilder, ProjectInfos);
TYPED_TEST(CommandLineBuilder, AddToolChainArguments)

2
tests/unit/unittest/gtest-creator-printing.cpp
View File

@@ -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
<<")";
}

4
tests/unit/unittest/mocksqlitereadstatement.cpp
View File

@@ -153,14 +153,14 @@ MockSqliteReadStatement::value<ClangBackEnd::FilePath>(const Utils::SmallStringV
template <>
Utils::optional<ClangBackEnd::ProjectPartArtefact>
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 5>(const int& sourceId)
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 8>(const int& sourceId)
{
return valueReturnProjectPartArtefact(sourceId);
}
template <>
Utils::optional<ClangBackEnd::ProjectPartArtefact>
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 5>(const Utils::SmallStringView &projectPartName)
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 8>(const Utils::SmallStringView &projectPartName)
{
return valueReturnProjectPartArtefact(projectPartName);
}

4
tests/unit/unittest/mocksqlitereadstatement.h
View File

@@ -237,11 +237,11 @@ MockSqliteReadStatement::value<Utils::PathString>(const Utils::SmallStringView&)
template <>
Utils::optional<ClangBackEnd::ProjectPartArtefact>
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 5>(const int&);
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 8>(const int&);
template <>
Utils::optional<ClangBackEnd::ProjectPartArtefact>
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 5>(const int&);
MockSqliteReadStatement::value<ClangBackEnd::ProjectPartArtefact, 8>(const int&);
template <>
Utils::optional<ClangBackEnd::ProjectPartPch>

10
tests/unit/unittest/mocksqlitewritestatement.h
View File

@@ -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));

7
tests/unit/unittest/mocksymbolstorage.h
View File

@@ -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));

120
tests/unit/unittest/projectpartartefact-test.cpp
View File

@@ -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);
}
}

19
tests/unit/unittest/refactoringdatabaseinitializer-test.cpp
View File

@@ -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);

113
tests/unit/unittest/symbolindexer-test.cpp
View File

@@ -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<ClangBackEnd::ProjectPartArtefact > nullArtefact;
ClangBackEnd::ProjectPartPch projectPartPch{"/path/to/pch", 4};
NiceMock<MockSqliteTransactionBackend> 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<Utils::SmallStringView>("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<Utils::SmallStringView>("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<FilePathId>(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> 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> 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<FilePathId>())).WillRepeatedly(Return(QDateTime::currentSecsSinceEpoch()));
EXPECT_CALL(mockSqliteTransactionBackend, commit());
EXPECT_CALL(mockCollector, setFile(_, _)).Times(0);

20
tests/unit/unittest/symbolstorage-test.cpp
View File

@@ -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<Utils::SmallStringView>(R"(["foo"])"),
TypedEq<Utils::SmallStringView>(R"([["FOO","1",1]])"),
TypedEq<Utils::SmallStringView>(systemIncludeSearchPathsText),
TypedEq<Utils::SmallStringView>(projectIncludeSearchPathsText)));
TypedEq<Utils::SmallStringView>(projectIncludeSearchPathsText),
1,
34,
0));
EXPECT_CALL(
getProjectPartIdStatement, valueReturnInt32(TypedEq<Utils::SmallStringView>("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);
}