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

ProjectExplorer: Promote CMakeToolChainData to a global structure

Browse Source 
... and use it in ToolChainFactory::detectForImport() overloads.

Change-Id: I107b9d5e185580b8fbef4c6e0233fdae5d253506
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2019-07-02 11:31:12 +02:00
parent 25f9d9c434
commit 2b7fab1668
10 changed files with 86 additions and 94 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp
View File

@@ -53,22 +53,6 @@ namespace {
Q_LOGGING_CATEGORY(cmInputLog, "qtc.cmake.import", QtWarningMsg);
struct CMakeToolChainData
{
QByteArray languageId;
Utils::FilePath compilerPath;
Core::Id mapLanguageIdToQtC() const
{
const QByteArray li = languageId.toLower();
if (li == "cxx")
return ProjectExplorer::Constants::CXX_LANGUAGE_ID;
else if (li == "c")
return ProjectExplorer::Constants::C_LANGUAGE_ID;
else
return Core::Id::fromName(languageId);
}
};
struct DirectoryData
{
// Project Stuff:
@@ -83,7 +67,7 @@ struct DirectoryData
QByteArray toolset;
QByteArray sysroot;
QtProjectImporter::QtVersionData qt;
QVector<CMakeToolChainData> toolChains;
QVector<ToolChainDescription> toolChains;
};
static QStringList scanDirectory(const QString &path, const QString &prefix)
@@ -218,14 +202,21 @@ static Utils::FilePath qmakeFromCMakeCache(const CMakeConfig &config)
return Utils::FilePath();
}
QVector<CMakeToolChainData> extractToolChainsFromCache(const CMakeConfig &config)
static QVector<ToolChainDescription> extractToolChainsFromCache(const CMakeConfig &config)
{
QVector<CMakeToolChainData> result;
QVector<ToolChainDescription> result;
for (const CMakeConfigItem &i : config) {
if (!i.key.startsWith("CMAKE_") || !i.key.endsWith("_COMPILER"))
continue;
const QByteArray language = i.key.mid(6, i.key.count() - 6 - 9); // skip "CMAKE_" and "_COMPILER"
result.append({language, Utils::FilePath::fromUtf8(i.value)});
Core::Id languageId;
if (language == "CXX")
languageId = ProjectExplorer::Constants::CXX_LANGUAGE_ID;
else if (language == "C")
languageId = ProjectExplorer::Constants::C_LANGUAGE_ID;
else
languageId = Core::Id::fromName(language);
result.append({Utils::FilePath::fromUtf8(i.value), languageId});
}
return result;
}
@@ -300,8 +291,8 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
if (data->qt.qt && QtSupport::QtKitAspect::qtVersionId(k) != data->qt.qt->uniqueId())
return false;
for (const CMakeToolChainData &tcd : data->toolChains) {
ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.mapLanguageIdToQtC());
for (const ToolChainDescription &tcd : data->toolChains) {
ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
if (!tc || tc->compilerCommand() != tcd.compilerPath)
return false;
}
@@ -328,9 +319,8 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
SysRootKitAspect::setSysRoot(k, Utils::FilePath::fromUtf8(data->sysroot));
for (const CMakeToolChainData &cmtcd : data->toolChains) {
const ToolChainData tcd
= findOrCreateToolChains(cmtcd.compilerPath, cmtcd.mapLanguageIdToQtC());
for (const ToolChainDescription &cmtcd : data->toolChains) {
const ToolChainData tcd = findOrCreateToolChains(cmtcd);
QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
if (tcd.areTemporary) {
@@ -464,17 +454,17 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
<< QStringList("CMAKE_SOMETHING_ELSE=/tmp") << QByteArrayList() << QStringList();
QTest::newRow("CXX compiler")
<< QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++"})
<< QByteArrayList({"CXX"})
<< QByteArrayList({"Cxx"})
<< QStringList({"/usr/bin/g++"});
QTest::newRow("CXX compiler, C compiler")
<< QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++", "CMAKE_C_COMPILER=/usr/bin/clang"})
<< QByteArrayList({"CXX", "C"})
<< QByteArrayList({"Cxx", "C"})
<< QStringList({"/usr/bin/g++", "/usr/bin/clang"});
QTest::newRow("CXX compiler, C compiler, strange compiler")
<< QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++",
"CMAKE_C_COMPILER=/usr/bin/clang",
"CMAKE_STRANGE_LANGUAGE_COMPILER=/tmp/strange/compiler"})
<< QByteArrayList({"CXX", "C", "STRANGE_LANGUAGE"})
<< QByteArrayList({"Cxx", "C", "STRANGE_LANGUAGE"})
<< QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"});
QTest::newRow("CXX compiler, C compiler, strange compiler (with junk)")
<< QStringList({"FOO=test",
@@ -484,7 +474,7 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
"SOMETHING_COMPILER=/usr/bin/something",
"CMAKE_STRANGE_LANGUAGE_COMPILER=/tmp/strange/compiler",
"BAR=more test"})
<< QByteArrayList({"CXX", "C", "STRANGE_LANGUAGE"})
<< QByteArrayList({"Cxx", "C", "STRANGE_LANGUAGE"})
<< QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"});
}
@@ -505,10 +495,10 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
config.append(CMakeConfigItem(key.toUtf8(), value.toUtf8()));
}
QVector<CMakeToolChainData> tcs = extractToolChainsFromCache(config);
const QVector<ToolChainDescription> tcs = extractToolChainsFromCache(config);
QCOMPARE(tcs.count(), expectedLanguages.count());
for (int i = 0; i < tcs.count(); ++i) {
QCOMPARE(tcs.at(i).languageId, expectedLanguages.at(i));
QCOMPARE(tcs.at(i).language, expectedLanguages.at(i));
QCOMPARE(tcs.at(i).compilerPath.toString(), expectedToolChains.at(i));
}
}

6
src/plugins/nim/project/nimtoolchainfactory.cpp
View File

@@ -73,13 +73,13 @@ QList<ToolChain *> NimToolChainFactory::autoDetect(const QList<ToolChain *> &alr
return result;
}
QList<ToolChain *> NimToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
QList<ToolChain *> NimToolChainFactory::detectForImport(const ToolChainDescription &tcd)
{
QList<ToolChain *> result;
if (language == Constants::C_NIMLANGUAGE_ID) {
if (tcd.language == Constants::C_NIMLANGUAGE_ID) {
auto tc = new NimToolChain;
tc->setDetection(ToolChain::ManualDetection); // FIXME: sure?
tc->setCompilerCommand(compilerPath);
tc->setCompilerCommand(tcd.compilerPath);
result.append(tc);
}
return result;

2
src/plugins/nim/project/nimtoolchainfactory.h
View File

@@ -42,7 +42,7 @@ public:
NimToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(const QList<ProjectExplorer::ToolChain *> &alreadyKnown) final;
QList<ProjectExplorer::ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) final;
QList<ProjectExplorer::ToolChain *> detectForImport(const ProjectExplorer::ToolChainDescription &tcd) final;
};
class NimToolChainConfigWidget : public ProjectExplorer::ToolChainConfigWidget

62
src/plugins/projectexplorer/gcctoolchain.cpp
View File

@@ -880,14 +880,14 @@ QList<ToolChain *> GccToolChainFactory::autoDetect(const QList<ToolChain *> &alr
return tcs;
}
QList<ToolChain *> GccToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
QList<ToolChain *> GccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
{
const QString fileName = compilerPath.fileName();
if ((language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
const QString fileName = tcd.compilerPath.toString();
if ((tcd.language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
|| fileName.endsWith("gcc")))
|| (language == Constants::CXX_LANGUAGE_ID && (fileName.startsWith("g++")
|| (tcd.language == Constants::CXX_LANGUAGE_ID && (fileName.startsWith("g++")
|| fileName.endsWith("g++"))))
return autoDetectToolChain(compilerPath, language, [](const ToolChain *tc) {
return autoDetectToolChain(tcd, [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor;
});
return QList<ToolChain *>();
@@ -973,7 +973,7 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
}
}
if (!alreadyExists) {
const QList<ToolChain *> newToolchains = autoDetectToolChain(compilerPath, language,
const QList<ToolChain *> newToolchains = autoDetectToolChain({compilerPath, language},
checker);
result << newToolchains;
existingCandidates << newToolchains;
@@ -983,17 +983,16 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
return result;
}
QList<ToolChain *> GccToolChainFactory::autoDetectToolChain(const FilePath &compilerPath,
const Core::Id language,
QList<ToolChain *> GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &tcd,
const ToolchainChecker &checker)
{
QList<ToolChain *> result;
Environment systemEnvironment = Environment::systemEnvironment();
GccToolChain::addCommandPathToEnvironment(compilerPath, systemEnvironment);
const FilePath localCompilerPath = findLocalCompiler(compilerPath, systemEnvironment);
GccToolChain::addCommandPathToEnvironment(tcd.compilerPath, systemEnvironment);
const FilePath localCompilerPath = findLocalCompiler(tcd.compilerPath, systemEnvironment);
Macros macros
= gccPredefinedMacros(localCompilerPath, gccPredefinedMacrosOptions(language),
= gccPredefinedMacros(localCompilerPath, gccPredefinedMacrosOptions(tcd.language),
systemEnvironment.toStringList());
const GccToolChain::DetectedAbisResult detectedAbis = guessGccAbi(localCompilerPath,
systemEnvironment.toStringList(),
@@ -1003,13 +1002,13 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolChain(const FilePath &comp
if (!tc)
return result;
tc->setLanguage(language);
tc->setLanguage(tcd.language);
tc->setDetection(ToolChain::AutoDetection);
tc->predefinedMacrosCache()
->insert(QStringList(),
ToolChain::MacroInspectionReport{macros,
ToolChain::languageVersion(language, macros)});
tc->setCompilerCommand(compilerPath);
ToolChain::languageVersion(tcd.language, macros)});
tc->setCompilerCommand(tcd.compilerPath);
tc->setSupportedAbis(detectedAbis.supportedAbis);
tc->setTargetAbi(abi);
tc->setOriginalTargetTriple(detectedAbis.originalTargetTriple);
@@ -1455,13 +1454,13 @@ QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &a
return tcs;
}
QList<ToolChain *> ClangToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
QList<ToolChain *> ClangToolChainFactory::detectForImport(const ToolChainDescription &tcd)
{
const QString fileName = compilerPath.fileName();
if ((language == Constants::C_LANGUAGE_ID && fileName.startsWith("clang") && !fileName.startsWith("clang++"))
|| (language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("clang++")))
return autoDetectToolChain(compilerPath, language);
return QList<ToolChain *>();
const QString fileName = tcd.compilerPath.toString();
if ((tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("clang") && !fileName.startsWith("clang++"))
|| (tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("clang++")))
return autoDetectToolChain(tcd);
return {};
}
ClangToolChainConfigWidget::ClangToolChainConfigWidget(ClangToolChain *tc) :
@@ -1637,17 +1636,18 @@ QList<ToolChain *> MingwToolChainFactory::autoDetect(const QList<ToolChain *> &a
return result;
}
QList<ToolChain *> MingwToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
QList<ToolChain *> MingwToolChainFactory::detectForImport(const ToolChainDescription &tcd)
{
const QString fileName = compilerPath.fileName();
if ((language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
const QString fileName = tcd.compilerPath.toString();
if ((tcd.language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
|| fileName.endsWith("gcc")))
|| (language == Constants::CXX_LANGUAGE_ID && (fileName.startsWith("g++")
|| (tcd.language == Constants::CXX_LANGUAGE_ID && (fileName.startsWith("g++")
|| fileName.endsWith("g++"))))
return autoDetectToolChain(compilerPath, language, [](const ToolChain *tc) {
return autoDetectToolChain(tcd, [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor;
});
return QList<ToolChain *>();
return {};
}
// --------------------------------------------------------------------------
@@ -1714,12 +1714,12 @@ QList<ToolChain *> LinuxIccToolChainFactory::autoDetect(const QList<ToolChain *>
return result;
}
QList<ToolChain *> LinuxIccToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language)
QList<ToolChain *> LinuxIccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
{
const QString fileName = compilerPath.fileName();
if ((language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||
(language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc")))
return autoDetectToolChain(compilerPath, language);
const QString fileName = tcd.compilerPath.toString();
if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||
(tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc")))
return autoDetectToolChain(tcd);
return {};
}

10
src/plugins/projectexplorer/gcctoolchainfactories.h
View File

@@ -55,7 +55,7 @@ public:
GccToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) override;
QList<ToolChain *> detectForImport(const ProjectExplorer::ToolChainDescription &tcd) override;
protected:
enum class DetectVariants { Yes, No };
@@ -65,7 +65,7 @@ protected:
const Core::Id requiredTypeId, const QList<ToolChain *> &alreadyKnown,
const ToolchainChecker &checker = {});
QList<ToolChain *> autoDetectToolChain(
const Utils::FilePath &compilerPath, const Core::Id language,
const ToolChainDescription &tcd,
const ToolchainChecker &checker = {});
};
@@ -138,7 +138,7 @@ public:
ClangToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) final;
QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
};
// --------------------------------------------------------------------------
@@ -153,7 +153,7 @@ public:
MingwToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) final;
QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
};
// --------------------------------------------------------------------------
@@ -168,7 +168,7 @@ public:
LinuxIccToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language) final;
QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
};
} // namespace Internal

14
src/plugins/projectexplorer/projectimporter.cpp
View File

@@ -366,13 +366,12 @@ bool ProjectImporter::hasKitWithTemporaryData(Core::Id id, const QVariant &data)
});
}
static ProjectImporter::ToolChainData
createToolChains(const Utils::FilePath &toolChainPath, const Core::Id &language)
static ProjectImporter::ToolChainData createToolChains(const ToolChainDescription &tcd)
{
ProjectImporter::ToolChainData data;
for (ToolChainFactory *factory : ToolChainFactory::allToolChainFactories()) {
data.tcs = factory->detectForImport(toolChainPath, language);
data.tcs = factory->detectForImport(tcd);
if (data.tcs.isEmpty())
continue;
@@ -387,12 +386,11 @@ createToolChains(const Utils::FilePath &toolChainPath, const Core::Id &language)
}
ProjectImporter::ToolChainData
ProjectImporter::findOrCreateToolChains(const Utils::FilePath &toolChainPath,
const Core::Id &language) const
ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
{
ToolChainData result;
result.tcs = ToolChainManager::toolChains([toolChainPath, language](const ToolChain *tc) {
return tc->language() == language && tc->compilerCommand() == toolChainPath;
result.tcs = ToolChainManager::toolChains([&tcd](const ToolChain *tc) {
return tc->language() == tcd.language && tc->compilerCommand() == tcd.compilerPath;
});
for (const ToolChain *tc : result.tcs) {
const QByteArray tcId = tc->id();
@@ -403,7 +401,7 @@ ProjectImporter::findOrCreateToolChains(const Utils::FilePath &toolChainPath,
// Create a new toolchain:
UpdateGuard guard(*this);
return createToolChains(toolChainPath, language);
return createToolChains(tcd);
}
} // namespace ProjectExplorer

6
src/plugins/projectexplorer/projectimporter.h
View File

@@ -27,12 +27,10 @@
#include "projectexplorer_export.h"
#include <coreplugin/id.h>
#include "toolchain.h"
#include <utils/fileutils.h>
#include <QVariant>
namespace ProjectExplorer {
class BuildInfo;
@@ -110,7 +108,7 @@ protected:
// Does *any* kit feature the requested data yet?
bool hasKitWithTemporaryData(Core::Id id, const QVariant &data) const;
ToolChainData findOrCreateToolChains(const Utils::FilePath &toolChainPath, const Core::Id &language) const;
ToolChainData findOrCreateToolChains(const ToolChainDescription &tcd) const;
private:
void markKitAsTemporary(Kit *k) const;

11
src/plugins/projectexplorer/toolchain.cpp
View File

@@ -438,15 +438,14 @@ const QList<ToolChainFactory *> ToolChainFactory::allToolChainFactories()
QList<ToolChain *> ToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
{
Q_UNUSED(alreadyKnown);
return QList<ToolChain *>();
Q_UNUSED(alreadyKnown)
return {};
}
QList<ToolChain *> ToolChainFactory::detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language)
QList<ToolChain *> ToolChainFactory::detectForImport(const ToolChainDescription &tcd)
{
Q_UNUSED(compilerPath);
Q_UNUSED(language);
return QList<ToolChain *>();
Q_UNUSED(tcd)
return {};
}
bool ToolChainFactory::canCreate() const

9
src/plugins/projectexplorer/toolchain.h
View File

@@ -72,6 +72,13 @@ class Kit;
namespace Internal { class ToolChainSettingsAccessor; }
class PROJECTEXPLORER_EXPORT ToolChainDescription
{
public:
Utils::FilePath compilerPath;
Core::Id language;
};
// --------------------------------------------------------------------------
// ToolChain (documentation inside)
// --------------------------------------------------------------------------
@@ -199,7 +206,7 @@ public:
Core::Id supportedToolChainType() const;
virtual QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown);
virtual QList<ToolChain *> detectForImport(const Utils::FilePath &compilerPath, const Core::Id &language);
virtual QList<ToolChain *> detectForImport(const ToolChainDescription &tcd);
virtual bool canCreate() const;
virtual ToolChain *create();

4
src/plugins/qbsprojectmanager/qbsprojectimporter.cpp
View File

@@ -208,9 +208,9 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void {
QList<ToolChainData> tcData;
if (!bgData->cxxCompilerPath.isEmpty())
tcData << findOrCreateToolChains(bgData->cxxCompilerPath, Constants::CXX_LANGUAGE_ID);
tcData << findOrCreateToolChains({bgData->cxxCompilerPath, Constants::CXX_LANGUAGE_ID});
if (!bgData->cCompilerPath.isEmpty())
tcData << findOrCreateToolChains(bgData->cCompilerPath, Constants::C_LANGUAGE_ID);
tcData << findOrCreateToolChains({bgData->cCompilerPath, Constants::C_LANGUAGE_ID});
foreach (const ToolChainData &tc, tcData) {
if (!tc.tcs.isEmpty())
ToolChainKitAspect::setToolChain(k, tc.tcs.first());