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); 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 struct DirectoryData
{ {
// Project Stuff: // Project Stuff:
@@ -83,7 +67,7 @@ struct DirectoryData
QByteArray toolset; QByteArray toolset;
QByteArray sysroot; QByteArray sysroot;
QtProjectImporter::QtVersionData qt; QtProjectImporter::QtVersionData qt;
QVector<CMakeToolChainData> toolChains; QVector<ToolChainDescription> toolChains;
}; };
static QStringList scanDirectory(const QString &path, const QString &prefix) static QStringList scanDirectory(const QString &path, const QString &prefix)
@@ -218,14 +202,21 @@ static Utils::FilePath qmakeFromCMakeCache(const CMakeConfig &config)
return Utils::FilePath(); 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) { for (const CMakeConfigItem &i : config) {
if (!i.key.startsWith("CMAKE_") || !i.key.endsWith("_COMPILER")) if (!i.key.startsWith("CMAKE_") || !i.key.endsWith("_COMPILER"))
continue; continue;
const QByteArray language = i.key.mid(6, i.key.count() - 6 - 9); // skip "CMAKE_" and "_COMPILER" 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; 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()) if (data->qt.qt && QtSupport::QtKitAspect::qtVersionId(k) != data->qt.qt->uniqueId())
return false; return false;
for (const CMakeToolChainData &tcd : data->toolChains) { for (const ToolChainDescription &tcd : data->toolChains) {
ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.mapLanguageIdToQtC()); ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
if (!tc || tc->compilerCommand() != tcd.compilerPath) if (!tc || tc->compilerCommand() != tcd.compilerPath)
return false; return false;
} }
@@ -328,9 +319,8 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
SysRootKitAspect::setSysRoot(k, Utils::FilePath::fromUtf8(data->sysroot)); SysRootKitAspect::setSysRoot(k, Utils::FilePath::fromUtf8(data->sysroot));
for (const CMakeToolChainData &cmtcd : data->toolChains) { for (const ToolChainDescription &cmtcd : data->toolChains) {
const ToolChainData tcd const ToolChainData tcd = findOrCreateToolChains(cmtcd);
= findOrCreateToolChains(cmtcd.compilerPath, cmtcd.mapLanguageIdToQtC());
QTC_ASSERT(!tcd.tcs.isEmpty(), continue); QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
if (tcd.areTemporary) { if (tcd.areTemporary) {
@@ -464,17 +454,17 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
<< QStringList("CMAKE_SOMETHING_ELSE=/tmp") << QByteArrayList() << QStringList(); << QStringList("CMAKE_SOMETHING_ELSE=/tmp") << QByteArrayList() << QStringList();
QTest::newRow("CXX compiler") QTest::newRow("CXX compiler")
<< QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++"}) << QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++"})
<< QByteArrayList({"CXX"}) << QByteArrayList({"Cxx"})
<< QStringList({"/usr/bin/g++"}); << QStringList({"/usr/bin/g++"});
QTest::newRow("CXX compiler, C compiler") QTest::newRow("CXX compiler, C compiler")
<< QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++", "CMAKE_C_COMPILER=/usr/bin/clang"}) << 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"}); << QStringList({"/usr/bin/g++", "/usr/bin/clang"});
QTest::newRow("CXX compiler, C compiler, strange compiler") QTest::newRow("CXX compiler, C compiler, strange compiler")
<< QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++", << QStringList({"CMAKE_CXX_COMPILER=/usr/bin/g++",
"CMAKE_C_COMPILER=/usr/bin/clang", "CMAKE_C_COMPILER=/usr/bin/clang",
"CMAKE_STRANGE_LANGUAGE_COMPILER=/tmp/strange/compiler"}) "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"}); << QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"});
QTest::newRow("CXX compiler, C compiler, strange compiler (with junk)") QTest::newRow("CXX compiler, C compiler, strange compiler (with junk)")
<< QStringList({"FOO=test", << QStringList({"FOO=test",
@@ -484,7 +474,7 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain_data()
"SOMETHING_COMPILER=/usr/bin/something", "SOMETHING_COMPILER=/usr/bin/something",
"CMAKE_STRANGE_LANGUAGE_COMPILER=/tmp/strange/compiler", "CMAKE_STRANGE_LANGUAGE_COMPILER=/tmp/strange/compiler",
"BAR=more test"}) "BAR=more test"})
<< QByteArrayList({"CXX", "C", "STRANGE_LANGUAGE"}) << QByteArrayList({"Cxx", "C", "STRANGE_LANGUAGE"})
<< QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"}); << QStringList({"/usr/bin/g++", "/usr/bin/clang", "/tmp/strange/compiler"});
} }
@@ -505,10 +495,10 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
config.append(CMakeConfigItem(key.toUtf8(), value.toUtf8())); config.append(CMakeConfigItem(key.toUtf8(), value.toUtf8()));
} }
QVector<CMakeToolChainData> tcs = extractToolChainsFromCache(config); const QVector<ToolChainDescription> tcs = extractToolChainsFromCache(config);
QCOMPARE(tcs.count(), expectedLanguages.count()); QCOMPARE(tcs.count(), expectedLanguages.count());
for (int i = 0; i < tcs.count(); ++i) { 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)); 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; return result;
} }
QList<ToolChain *> NimToolChainFactory::detectForImport(const FilePath &compilerPath, const Core::Id &language) QList<ToolChain *> NimToolChainFactory::detectForImport(const ToolChainDescription &tcd)
{ {
QList<ToolChain *> result; QList<ToolChain *> result;
if (language == Constants::C_NIMLANGUAGE_ID) { if (tcd.language == Constants::C_NIMLANGUAGE_ID) {
auto tc = new NimToolChain; auto tc = new NimToolChain;
tc->setDetection(ToolChain::ManualDetection); // FIXME: sure? tc->setDetection(ToolChain::ManualDetection); // FIXME: sure?
tc->setCompilerCommand(compilerPath); tc->setCompilerCommand(tcd.compilerPath);
result.append(tc); result.append(tc);
} }
return result; return result;

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

@@ -42,7 +42,7 @@ public:
NimToolChainFactory(); NimToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(const QList<ProjectExplorer::ToolChain *> &alreadyKnown) final; 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 class NimToolChainConfigWidget : public ProjectExplorer::ToolChainConfigWidget

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

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

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

@@ -55,7 +55,7 @@ public:
GccToolChainFactory(); GccToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override; 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: protected:
enum class DetectVariants { Yes, No }; enum class DetectVariants { Yes, No };
@@ -65,7 +65,7 @@ protected:
const Core::Id requiredTypeId, const QList<ToolChain *> &alreadyKnown, const Core::Id requiredTypeId, const QList<ToolChain *> &alreadyKnown,
const ToolchainChecker &checker = {}); const ToolchainChecker &checker = {});
QList<ToolChain *> autoDetectToolChain( QList<ToolChain *> autoDetectToolChain(
const Utils::FilePath &compilerPath, const Core::Id language, const ToolChainDescription &tcd,
const ToolchainChecker &checker = {}); const ToolchainChecker &checker = {});
}; };
@@ -138,7 +138,7 @@ public:
ClangToolChainFactory(); ClangToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override; 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(); MingwToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override; 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(); LinuxIccToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override; 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 } // 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 static ProjectImporter::ToolChainData createToolChains(const ToolChainDescription &tcd)
createToolChains(const Utils::FilePath &toolChainPath, const Core::Id &language)
{ {
ProjectImporter::ToolChainData data; ProjectImporter::ToolChainData data;
for (ToolChainFactory *factory : ToolChainFactory::allToolChainFactories()) { for (ToolChainFactory *factory : ToolChainFactory::allToolChainFactories()) {
data.tcs = factory->detectForImport(toolChainPath, language); data.tcs = factory->detectForImport(tcd);
if (data.tcs.isEmpty()) if (data.tcs.isEmpty())
continue; continue;
@@ -387,12 +386,11 @@ createToolChains(const Utils::FilePath &toolChainPath, const Core::Id &language)
} }
ProjectImporter::ToolChainData ProjectImporter::ToolChainData
ProjectImporter::findOrCreateToolChains(const Utils::FilePath &toolChainPath, ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
const Core::Id &language) const
{ {
ToolChainData result; ToolChainData result;
result.tcs = ToolChainManager::toolChains([toolChainPath, language](const ToolChain *tc) { result.tcs = ToolChainManager::toolChains([&tcd](const ToolChain *tc) {
return tc->language() == language && tc->compilerCommand() == toolChainPath; return tc->language() == tcd.language && tc->compilerCommand() == tcd.compilerPath;
}); });
for (const ToolChain *tc : result.tcs) { for (const ToolChain *tc : result.tcs) {
const QByteArray tcId = tc->id(); const QByteArray tcId = tc->id();
@@ -403,7 +401,7 @@ ProjectImporter::findOrCreateToolChains(const Utils::FilePath &toolChainPath,
// Create a new toolchain: // Create a new toolchain:
UpdateGuard guard(*this); UpdateGuard guard(*this);
return createToolChains(toolChainPath, language); return createToolChains(tcd);
} }
} // namespace ProjectExplorer } // namespace ProjectExplorer

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

@@ -27,12 +27,10 @@
#include "projectexplorer_export.h" #include "projectexplorer_export.h"
#include <coreplugin/id.h> #include "toolchain.h"
#include <utils/fileutils.h> #include <utils/fileutils.h>
#include <QVariant>
namespace ProjectExplorer { namespace ProjectExplorer {
class BuildInfo; class BuildInfo;
@@ -110,7 +108,7 @@ protected:
// Does *any* kit feature the requested data yet? // Does *any* kit feature the requested data yet?
bool hasKitWithTemporaryData(Core::Id id, const QVariant &data) const; 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: private:
void markKitAsTemporary(Kit *k) const; 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) QList<ToolChain *> ToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
{ {
Q_UNUSED(alreadyKnown); Q_UNUSED(alreadyKnown)
return QList<ToolChain *>(); 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(tcd)
Q_UNUSED(language); return {};
return QList<ToolChain *>();
} }
bool ToolChainFactory::canCreate() const bool ToolChainFactory::canCreate() const

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

@@ -72,6 +72,13 @@ class Kit;
namespace Internal { class ToolChainSettingsAccessor; } namespace Internal { class ToolChainSettingsAccessor; }
class PROJECTEXPLORER_EXPORT ToolChainDescription
{
public:
Utils::FilePath compilerPath;
Core::Id language;
};
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
// ToolChain (documentation inside) // ToolChain (documentation inside)
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
@@ -199,7 +206,7 @@ public:
Core::Id supportedToolChainType() const; Core::Id supportedToolChainType() const;
virtual QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown); 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 bool canCreate() const;
virtual ToolChain *create(); 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 { return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void {
QList<ToolChainData> tcData; QList<ToolChainData> tcData;
if (!bgData->cxxCompilerPath.isEmpty()) if (!bgData->cxxCompilerPath.isEmpty())
tcData << findOrCreateToolChains(bgData->cxxCompilerPath, Constants::CXX_LANGUAGE_ID); tcData << findOrCreateToolChains({bgData->cxxCompilerPath, Constants::CXX_LANGUAGE_ID});
if (!bgData->cCompilerPath.isEmpty()) 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) { foreach (const ToolChainData &tc, tcData) {
if (!tc.tcs.isEmpty()) if (!tc.tcs.isEmpty())
ToolChainKitAspect::setToolChain(k, tc.tcs.first()); ToolChainKitAspect::setToolChain(k, tc.tcs.first());