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

ProjectExplorer: Use a struct for toolchain autodetection parameters

Browse Source 
Also, make some functions const and use an alias for QList<ToolChain *>.

Change-Id: I6a1cbcb79bfaa9d252c4b69e00aa93e5d0dabe2f
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2022-01-14 17:29:02 +01:00
parent 3749cfc896
commit 5cfe69b049
24 changed files with 262 additions and 296 deletions
Download Patch File Download Diff File Expand all files Collapse all files

21
src/plugins/baremetal/iarewtoolchain.cpp
View File

@@ -431,10 +431,8 @@ IarToolChainFactory::IarToolChainFactory()
setUserCreatable(true);
}
QList<ToolChain *> IarToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains IarToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
Q_UNUSED(device);
Candidates candidates;
#ifdef Q_OS_WIN
@@ -501,23 +499,21 @@ QList<ToolChain *> IarToolChainFactory::autoDetect(const QList<ToolChain *> &alr
#endif // Q_OS_WIN
return autoDetectToolchains(candidates, alreadyKnown);
return autoDetectToolchains(candidates, detector.alreadyKnown);
}
QList<ProjectExplorer::ToolChain *> IarToolChainFactory::detectForImport(
const ProjectExplorer::ToolChainDescription &tcd)
Toolchains IarToolChainFactory::detectForImport(const ToolChainDescription &tcd) const
{
return { autoDetectToolchain({tcd.compilerPath, {}}, tcd.language) };
}
QList<ToolChain *> IarToolChainFactory::autoDetectToolchains(
const Candidates &candidates, const QList<ToolChain *> &alreadyKnown) const
Toolchains IarToolChainFactory::autoDetectToolchains(
const Candidates &candidates, const Toolchains &alreadyKnown) const
{
QList<ToolChain *> result;
Toolchains result;
for (const Candidate &candidate : qAsConst(candidates)) {
const QList<ToolChain *> filtered = Utils::filtered(
alreadyKnown, [candidate](ToolChain *tc) {
const Toolchains filtered = Utils::filtered(alreadyKnown, [candidate](ToolChain *tc) {
return tc->typeId() == Constants::IAREW_TOOLCHAIN_TYPEID
&& tc->compilerCommand() == candidate.compilerPath
&& (tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID
@@ -537,8 +533,7 @@ QList<ToolChain *> IarToolChainFactory::autoDetectToolchains(
return result;
}
QList<ToolChain *> IarToolChainFactory::autoDetectToolchain(
const Candidate &candidate, Utils::Id languageId) const
Toolchains IarToolChainFactory::autoDetectToolchain(const Candidate &candidate, Id languageId) const
{
const auto env = Environment::systemEnvironment();
const Macros macros = dumpPredefinedMacros(candidate.compilerPath, {}, languageId, env);

15
src/plugins/baremetal/iarewtoolchain.h
View File

@@ -90,16 +90,15 @@ class IarToolChainFactory final : public ProjectExplorer::ToolChainFactory
public:
IarToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(
const QList<ProjectExplorer::ToolChain *> &alreadyKnown,
const ProjectExplorer::IDevice::Ptr &device) final;
QList<ProjectExplorer::ToolChain *> detectForImport(
const ProjectExplorer::ToolChainDescription &tcd) final;
ProjectExplorer::Toolchains autoDetect(
const ProjectExplorer::ToolchainDetector &detector) const final;
ProjectExplorer::Toolchains detectForImport(
const ProjectExplorer::ToolChainDescription &tcd) const final;
private:
QList<ProjectExplorer::ToolChain *> autoDetectToolchains(const Candidates &candidates,
const QList<ProjectExplorer::ToolChain *> &alreadyKnown) const;
QList<ProjectExplorer::ToolChain *> autoDetectToolchain(
ProjectExplorer::Toolchains autoDetectToolchains(const Candidates &candidates,
const ProjectExplorer::Toolchains &alreadyKnown) const;
ProjectExplorer::Toolchains autoDetectToolchain(
const Candidate &candidate, Utils::Id languageId) const;
};

17
src/plugins/baremetal/keiltoolchain.cpp
View File

@@ -601,10 +601,8 @@ static QString extractVersion(const QString &toolsFile, const QString &section)
return {};
}
QList<ToolChain *> KeilToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains KeilToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
Q_UNUSED(device)
#ifdef Q_OS_WIN64
static const char kRegistryNode[] = "HKEY_LOCAL_MACHINE\\SOFTWARE\\WOW6432Node\\Microsoft\\" \
"Windows\\CurrentVersion\\Uninstall\\Keil µVision4";
@@ -651,16 +649,16 @@ QList<ToolChain *> KeilToolChainFactory::autoDetect(const QList<ToolChain *> &al
registry.endGroup();
}
return autoDetectToolchains(candidates, alreadyKnown);
return autoDetectToolchains(candidates, detector.alreadyKnown);
}
QList<ToolChain *> KeilToolChainFactory::autoDetectToolchains(
const Candidates &candidates, const QList<ToolChain *> &alreadyKnown) const
Toolchains KeilToolChainFactory::autoDetectToolchains(
const Candidates &candidates, const Toolchains &alreadyKnown) const
{
QList<ToolChain *> result;
Toolchains result;
for (const Candidate &candidate : qAsConst(candidates)) {
const QList<ToolChain *> filtered = Utils::filtered(
const Toolchains filtered = Utils::filtered(
alreadyKnown, [candidate](ToolChain *tc) {
return tc->typeId() == Constants::IAREW_TOOLCHAIN_TYPEID
&& tc->compilerCommand() == candidate.compilerPath
@@ -681,8 +679,7 @@ QList<ToolChain *> KeilToolChainFactory::autoDetectToolchains(
return result;
}
QList<ToolChain *> KeilToolChainFactory::autoDetectToolchain(
const Candidate &candidate, Utils::Id language) const
Toolchains KeilToolChainFactory::autoDetectToolchain(const Candidate &candidate, Id language) const
{
const auto env = Environment::systemEnvironment();

11
src/plugins/baremetal/keiltoolchain.h
View File

@@ -91,14 +91,13 @@ class KeilToolChainFactory final : public ProjectExplorer::ToolChainFactory
public:
KeilToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(
const QList<ProjectExplorer::ToolChain *> &alreadyKnown,
const ProjectExplorer::IDevice::Ptr &device) final;
ProjectExplorer::Toolchains autoDetect(
const ProjectExplorer::ToolchainDetector &detector) const final;
private:
QList<ProjectExplorer::ToolChain *> autoDetectToolchains(const Candidates &candidates,
const QList<ProjectExplorer::ToolChain *> &alreadyKnown) const;
QList<ProjectExplorer::ToolChain *> autoDetectToolchain(
ProjectExplorer::Toolchains autoDetectToolchains(const Candidates &candidates,
const ProjectExplorer::Toolchains &alreadyKnown) const;
ProjectExplorer::Toolchains autoDetectToolchain(
const Candidate &candidate, Utils::Id language) const;
};

20
src/plugins/baremetal/sdcctoolchain.cpp
View File

@@ -306,10 +306,8 @@ SdccToolChainFactory::SdccToolChainFactory()
setUserCreatable(true);
}
QList<ToolChain *> SdccToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains SdccToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
Q_UNUSED(device)
Candidates candidates;
if (Utils::HostOsInfo::isWindowsHost()) {
@@ -362,17 +360,16 @@ QList<ToolChain *> SdccToolChainFactory::autoDetect(const QList<ToolChain *> &al
candidates.push_back(candidate);
}
return autoDetectToolchains(candidates, alreadyKnown);
return autoDetectToolchains(candidates, detector.alreadyKnown);
}
QList<ToolChain *> SdccToolChainFactory::autoDetectToolchains(
const Candidates &candidates, const QList<ToolChain *> &alreadyKnown) const
Toolchains SdccToolChainFactory::autoDetectToolchains(
const Candidates &candidates, const Toolchains &alreadyKnown) const
{
QList<ToolChain *> result;
Toolchains result;
for (const Candidate &candidate : qAsConst(candidates)) {
const QList<ToolChain *> filtered = Utils::filtered(
alreadyKnown, [candidate](ToolChain *tc) {
const Toolchains filtered = Utils::filtered(alreadyKnown, [candidate](ToolChain *tc) {
return tc->typeId() == Constants::SDCC_TOOLCHAIN_TYPEID
&& tc->compilerCommand() == candidate.compilerPath
&& (tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID);
@@ -390,8 +387,7 @@ QList<ToolChain *> SdccToolChainFactory::autoDetectToolchains(
return result;
}
QList<ToolChain *> SdccToolChainFactory::autoDetectToolchain(
const Candidate &candidate, Utils::Id language) const
Toolchains SdccToolChainFactory::autoDetectToolchain(const Candidate &candidate, Id language) const
{
const auto env = Environment::systemEnvironment();
@@ -401,7 +397,7 @@ QList<ToolChain *> SdccToolChainFactory::autoDetectToolchain(
{Abi::Stm8Architecture}
};
QList<ToolChain *> tcs;
Toolchains tcs;
// Probe each ABI from the table, because the SDCC compiler
// can be compiled with or without the specified architecture.

11
src/plugins/baremetal/sdcctoolchain.h
View File

@@ -82,14 +82,13 @@ class SdccToolChainFactory final : public ProjectExplorer::ToolChainFactory
public:
SdccToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(
const QList<ProjectExplorer::ToolChain *> &alreadyKnown,
const ProjectExplorer::IDevice::Ptr &device) final;
ProjectExplorer::Toolchains autoDetect(
const ProjectExplorer::ToolchainDetector &detector) const final;
private:
QList<ProjectExplorer::ToolChain *> autoDetectToolchains(const Candidates &candidates,
const QList<ProjectExplorer::ToolChain *> &alreadyKnown) const;
QList<ProjectExplorer::ToolChain *> autoDetectToolchain(
ProjectExplorer::Toolchains autoDetectToolchains(const Candidates &candidates,
const ProjectExplorer::Toolchains &alreadyKnown) const;
ProjectExplorer::Toolchains autoDetectToolchain(
const Candidate &candidate, Utils::Id language) const;
};

9
src/plugins/docker/dockerdevice.cpp
View File

@@ -729,17 +729,18 @@ QList<BaseQtVersion *> KitDetectorPrivate::autoDetectQtVersions() const
return qtVersions;
}
QList<ToolChain *> KitDetectorPrivate::autoDetectToolChains()
Toolchains KitDetectorPrivate::autoDetectToolChains()
{
const QList<ToolChainFactory *> factories = ToolChainFactory::allToolChainFactories();
QList<ToolChain *> alreadyKnown = ToolChainManager::toolChains();
QList<ToolChain *> allNewToolChains;
Toolchains alreadyKnown = ToolChainManager::toolChains();
Toolchains allNewToolChains;
QApplication::processEvents();
emit q->logOutput('\n' + tr("Searching toolchains..."));
for (ToolChainFactory *factory : factories) {
emit q->logOutput(tr("Searching toolchains of type %1").arg(factory->displayName()));
const QList<ToolChain *> newToolChains = factory->autoDetect(alreadyKnown, m_device.constCast<IDevice>());
const ToolchainDetector detector(alreadyKnown, m_device);
const Toolchains newToolChains = factory->autoDetect(detector);
for (ToolChain *toolChain : newToolChains) {
emit q->logOutput(tr("Found \"%1\"").arg(toolChain->compilerCommand().toUserOutput()));
toolChain->setDetectionSource(m_sharedId);

8
src/plugins/ios/iosconfigurations.cpp
View File

@@ -588,13 +588,11 @@ IosToolChainFactory::IosToolChainFactory()
ProjectExplorer::Constants::CXX_LANGUAGE_ID});
}
QList<ToolChain *> IosToolChainFactory::autoDetect(const QList<ToolChain *> &existingToolChains,
const IDevice::Ptr &device)
Toolchains IosToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
Q_UNUSED(device);
QList<ClangToolChain *> existingClangToolChains = clangToolChains(existingToolChains);
QList<ClangToolChain *> existingClangToolChains = clangToolChains(detector.alreadyKnown);
const QList<XcodePlatform> platforms = XcodeProbe::detectPlatforms().values();
QList<ToolChain *> toolChains;
Toolchains toolChains;
toolChains.reserve(platforms.size());
for (const XcodePlatform &platform : platforms) {
for (const XcodePlatform::ToolchainTarget &target : platform.targets) {

5
src/plugins/ios/iosconfigurations.h
View File

@@ -98,9 +98,8 @@ class IosToolChainFactory : public ProjectExplorer::ToolChainFactory
public:
IosToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(
const QList<ProjectExplorer::ToolChain *> &existingToolChains,
const ProjectExplorer::IDevice::Ptr &device) override;
ProjectExplorer::Toolchains autoDetect(
const ProjectExplorer::ToolchainDetector &detector) const final;
};
class IosConfigurations : public QObject

2
src/plugins/mcusupport/mcusupportoptions.cpp
View File

@@ -439,7 +439,7 @@ static ToolChain *iarToolChain(const FilePath &path, Id language)
return f->supportedToolChainType() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID;
});
if (iarFactory) {
QList<ToolChain*> detected = iarFactory->autoDetect({}, {});
Toolchains detected = iarFactory->autoDetect(ToolchainDetector({}, {}));
if (detected.isEmpty())
detected = iarFactory->detectForImport({path, language});
for (auto tc: detected) {

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

@@ -51,17 +51,18 @@ NimToolChainFactory::NimToolChainFactory()
setUserCreatable(true);
}
QList<ToolChain *> NimToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains NimToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
QList<ToolChain *> result;
Toolchains result;
IDevice::ConstPtr dev =
detector.device ? detector.device : DeviceManager::defaultDesktopDevice();
IDevice::ConstPtr dev = device ? device : DeviceManager::defaultDesktopDevice();
const FilePath compilerPath = dev->searchExecutableInPath("nim");
if (compilerPath.isEmpty())
return result;
result = Utils::filtered(alreadyKnown, [compilerPath](ToolChain *tc) {
result = Utils::filtered(detector.alreadyKnown, [compilerPath](ToolChain *tc) {
return tc->typeId() == Constants::C_NIMTOOLCHAIN_TYPEID
&& tc->compilerCommand() == compilerPath;
});
@@ -76,9 +77,9 @@ QList<ToolChain *> NimToolChainFactory::autoDetect(const QList<ToolChain *> &alr
return result;
}
QList<ToolChain *> NimToolChainFactory::detectForImport(const ToolChainDescription &tcd)
Toolchains NimToolChainFactory::detectForImport(const ToolChainDescription &tcd) const
{
QList<ToolChain *> result;
Toolchains result;
if (tcd.language == Constants::C_NIMLANGUAGE_ID) {
auto tc = new NimToolChain;
tc->setDetection(ToolChain::ManualDetection); // FIXME: sure?

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

@@ -39,9 +39,8 @@ class NimToolChainFactory : public ProjectExplorer::ToolChainFactory
public:
NimToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(const QList<ProjectExplorer::ToolChain *> &alreadyKnown,
const ProjectExplorer::IDevice::Ptr &device) final;
QList<ProjectExplorer::ToolChain *> detectForImport(const ProjectExplorer::ToolChainDescription &tcd) final;
ProjectExplorer::Toolchains autoDetect(const ProjectExplorer::ToolchainDetector &detector) const final;
ProjectExplorer::Toolchains detectForImport(const ProjectExplorer::ToolChainDescription &tcd) const final;
};
class NimToolChainConfigWidget : public ProjectExplorer::ToolChainConfigWidget

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

@@ -997,28 +997,25 @@ GccToolChainFactory::GccToolChainFactory()
setUserCreatable(true);
}
QList<ToolChain *> GccToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains GccToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
// GCC is almost never what you want on macOS, but it is by default found in /usr/bin
if (HostOsInfo::isMacHost())
return {};
QList<ToolChain *> tcs;
Toolchains tcs;
static const auto tcChecker = [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor
&& tc->compilerCommand().fileName() != "c89-gcc"
&& tc->compilerCommand().fileName() != "c99-gcc";
};
tcs.append(autoDetectToolchains("g++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID,
Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown,
device, tcChecker));
Constants::GCC_TOOLCHAIN_TYPEID, detector, tcChecker));
tcs.append(autoDetectToolchains("gcc", DetectVariants::Yes, Constants::C_LANGUAGE_ID,
Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown,
device, tcChecker));
Constants::GCC_TOOLCHAIN_TYPEID, detector, tcChecker));
return tcs;
}
QList<ToolChain *> GccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
Toolchains GccToolChainFactory::detectForImport(const ToolChainDescription &tcd) const
{
const QString fileName = tcd.compilerPath.completeBaseName();
if ((tcd.language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
@@ -1030,11 +1027,10 @@ QList<ToolChain *> GccToolChainFactory::detectForImport(const ToolChainDescripti
return autoDetectToolChain(tcd, [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor;
});
return QList<ToolChain *>();
return {};
}
static FilePaths findCompilerCandidates(const IDevice::Ptr &device,
static FilePaths findCompilerCandidates(const IDevice::ConstPtr &device,
const QString &compilerName,
bool detectVariants)
{
@@ -1106,20 +1102,19 @@ static FilePaths findCompilerCandidates(const IDevice::Ptr &device,
return compilerPaths;
}
QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
Toolchains GccToolChainFactory::autoDetectToolchains(
const QString &compilerName,
DetectVariants detectVariants,
const Id language,
const Id requiredTypeId,
const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device,
const ToolchainChecker &checker)
const ToolchainDetector &detector,
const ToolchainChecker &checker) const
{
const FilePaths compilerPaths =
findCompilerCandidates(device, compilerName, detectVariants == DetectVariants::Yes);
findCompilerCandidates(detector.device, compilerName, detectVariants == DetectVariants::Yes);
QList<ToolChain *> existingCandidates
= filtered(alreadyKnown, [requiredTypeId, language, &checker](const ToolChain *tc) {
Toolchains existingCandidates
= filtered(detector.alreadyKnown, [requiredTypeId, language, &checker](const ToolChain *tc) {
if (tc->typeId() != requiredTypeId)
return false;
if (tc->language() != language)
@@ -1128,7 +1123,8 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
return false;
return true;
});
QList<ToolChain *> result;
Toolchains result;
for (const FilePath &compilerPath : qAsConst(compilerPaths)) {
bool alreadyExists = false;
for (ToolChain * const existingTc : existingCandidates) {
@@ -1168,10 +1164,10 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(
return result;
}
QList<ToolChain *> GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &tcd,
const ToolchainChecker &checker)
Toolchains GccToolChainFactory::autoDetectToolChain(const ToolChainDescription &tcd,
const ToolchainChecker &checker) const
{
QList<ToolChain *> result;
Toolchains result;
Environment systemEnvironment = Environment::systemEnvironment();
GccToolChain::addCommandPathToEnvironment(tcd.compilerPath, systemEnvironment);
@@ -1626,16 +1622,15 @@ ClangToolChainFactory::ClangToolChainFactory()
setToolchainConstructor([] { return new ClangToolChain; });
}
QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains ClangToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
QList<ToolChain *> tcs;
QList<ToolChain *> known = alreadyKnown;
Toolchains tcs;
Toolchains known = detector.alreadyKnown;
tcs.append(autoDetectToolchains("clang++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID, alreadyKnown, device));
Constants::CLANG_TOOLCHAIN_TYPEID, detector));
tcs.append(autoDetectToolchains("clang", DetectVariants::Yes, Constants::C_LANGUAGE_ID,
Constants::CLANG_TOOLCHAIN_TYPEID, alreadyKnown, device));
Constants::CLANG_TOOLCHAIN_TYPEID, detector));
known.append(tcs);
const FilePath compilerPath = Core::ICore::clangExecutable(CLANG_BINDIR);
@@ -1643,13 +1638,13 @@ QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &a
const FilePath clang = compilerPath.parentDir().pathAppended("clang").withExecutableSuffix();
tcs.append(autoDetectToolchains(clang.toString(), DetectVariants::No,
Constants::C_LANGUAGE_ID, Constants::CLANG_TOOLCHAIN_TYPEID,
tcs, device));
ToolchainDetector(tcs, detector.device)));
}
return tcs;
}
QList<ToolChain *> ClangToolChainFactory::detectForImport(const ToolChainDescription &tcd)
Toolchains ClangToolChainFactory::detectForImport(const ToolChainDescription &tcd) const
{
const QString fileName = tcd.compilerPath.toString();
if ((tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("clang") && !fileName.startsWith("clang++"))
@@ -1814,21 +1809,20 @@ MingwToolChainFactory::MingwToolChainFactory()
setToolchainConstructor([] { return new MingwToolChain; });
}
QList<ToolChain *> MingwToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains MingwToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
static const auto tcChecker = [](const ToolChain *tc) {
return tc->targetAbi().osFlavor() == Abi::WindowsMSysFlavor;
};
QList<ToolChain *> result = autoDetectToolchains(
Toolchains result = autoDetectToolchains(
"g++", DetectVariants::Yes, Constants::CXX_LANGUAGE_ID,
Constants::MINGW_TOOLCHAIN_TYPEID, alreadyKnown, device, tcChecker);
Constants::MINGW_TOOLCHAIN_TYPEID, detector, tcChecker);
result += autoDetectToolchains("gcc", DetectVariants::Yes, Constants::C_LANGUAGE_ID,
Constants::MINGW_TOOLCHAIN_TYPEID, alreadyKnown, device, tcChecker);
Constants::MINGW_TOOLCHAIN_TYPEID, detector, tcChecker);
return result;
}
QList<ToolChain *> MingwToolChainFactory::detectForImport(const ToolChainDescription &tcd)
Toolchains MingwToolChainFactory::detectForImport(const ToolChainDescription &tcd) const
{
const QString fileName = tcd.compilerPath.completeBaseName();
if ((tcd.language == Constants::C_LANGUAGE_ID && (fileName.startsWith("gcc")
@@ -1896,18 +1890,17 @@ LinuxIccToolChainFactory::LinuxIccToolChainFactory()
setToolchainConstructor([] { return new LinuxIccToolChain; });
}
QList<ToolChain *> LinuxIccToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains LinuxIccToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
QList<ToolChain *> result
Toolchains result
= autoDetectToolchains("icpc", DetectVariants::No, Constants::CXX_LANGUAGE_ID,
Constants::LINUXICC_TOOLCHAIN_TYPEID, alreadyKnown, device);
Constants::LINUXICC_TOOLCHAIN_TYPEID, detector);
result += autoDetectToolchains("icc", DetectVariants::Yes, Constants::C_LANGUAGE_ID,
Constants::LINUXICC_TOOLCHAIN_TYPEID, alreadyKnown, device);
Constants::LINUXICC_TOOLCHAIN_TYPEID, detector);
return result;
}
QList<ToolChain *> LinuxIccToolChainFactory::detectForImport(const ToolChainDescription &tcd)
Toolchains LinuxIccToolChainFactory::detectForImport(const ToolChainDescription &tcd) const
{
const QString fileName = tcd.compilerPath.toString();
if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||

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

@@ -52,21 +52,19 @@ class GccToolChainFactory : public ToolChainFactory
public:
GccToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device) override;
QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) override;
Toolchains autoDetect(const ToolchainDetector &detector) const override;
Toolchains detectForImport(const ToolChainDescription &tcd) const override;
protected:
enum class DetectVariants { Yes, No };
using ToolchainChecker = std::function<bool(const ToolChain *)>;
QList<ToolChain *> autoDetectToolchains(
Toolchains autoDetectToolchains(
const QString &compilerName, DetectVariants detectVariants, const Utils::Id language,
const Utils::Id requiredTypeId, const QList<ToolChain *> &alreadyKnown,
const ProjectExplorer::IDevice::Ptr &device,
const ToolchainChecker &checker = {});
QList<ToolChain *> autoDetectToolChain(
const Utils::Id requiredTypeId, const ToolchainDetector &detector,
const ToolchainChecker &checker = {}) const;
Toolchains autoDetectToolChain(
const ToolChainDescription &tcd,
const ToolchainChecker &checker = {});
const ToolchainChecker &checker = {}) const;
};
// --------------------------------------------------------------------------
@@ -134,9 +132,8 @@ class ClangToolChainFactory : public GccToolChainFactory
public:
ClangToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device) override;
QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
Toolchains autoDetect(const ToolchainDetector &detector) const final;
Toolchains detectForImport(const ToolChainDescription &tcd) const final;
};
// --------------------------------------------------------------------------
@@ -148,9 +145,8 @@ class MingwToolChainFactory : public GccToolChainFactory
public:
MingwToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device) override;
QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
Toolchains autoDetect(const ToolchainDetector &detector) const final;
Toolchains detectForImport(const ToolChainDescription &tcd) const final;
};
// --------------------------------------------------------------------------
@@ -162,8 +158,8 @@ class LinuxIccToolChainFactory : public GccToolChainFactory
public:
LinuxIccToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown, const IDevice::Ptr &) override;
QList<ToolChain *> detectForImport(const ToolChainDescription &tcd) final;
Toolchains autoDetect(const ToolchainDetector &detector) const final;
Toolchains detectForImport(const ToolChainDescription &tcd) const final;
};
} // namespace Internal

76
src/plugins/projectexplorer/msvctoolchain.cpp
View File

@@ -1586,12 +1586,12 @@ static const MsvcToolChain *selectMsvcToolChain(const QString &displayedVarsBat,
return toolChain;
}
static QList<ToolChain *> detectClangClToolChainInPath(const FilePath &clangClPath,
const QList<ToolChain *> &alreadyKnown,
const QString &displayedVarsBat,
bool isDefault = false)
static Toolchains detectClangClToolChainInPath(const FilePath &clangClPath,
const Toolchains &alreadyKnown,
const QString &displayedVarsBat,
bool isDefault = false)
{
QList<ToolChain *> res;
Toolchains res;
const unsigned char wordWidth = Utils::is64BitWindowsBinary(clangClPath) ? 64 : 32;
const MsvcToolChain *toolChain = selectMsvcToolChain(displayedVarsBat, clangClPath, wordWidth);
@@ -1647,9 +1647,7 @@ void ClangClToolChainConfigWidget::applyImpl()
}
const QString displayedVarsBat = m_varsBatDisplayCombo->currentText();
QList<ToolChain *> results = detectClangClToolChainInPath(clangClPath,
{},
displayedVarsBat);
Toolchains results = detectClangClToolChainInPath(clangClPath, {}, displayedVarsBat);
if (results.isEmpty()) {
clangClToolChain->resetVarsBat();
@@ -1831,14 +1829,15 @@ QString MsvcToolChainFactory::vcVarsBatFor(const QString &basePath,
return result;
}
static QList<ToolChain *> findOrCreateToolChain(const QList<ToolChain *> &alreadyKnown, const QString &name,
const Abi &abi,
const QString &varsBat,
const QString &varsBatArg)
static Toolchains findOrCreateToolchains(const ToolchainDetector &detector,
const QString &name,
const Abi &abi,
const QString &varsBat,
const QString &varsBatArg)
{
QList<ToolChain *> res;
Toolchains res;
for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
ToolChain *tc = Utils::findOrDefault(alreadyKnown, [&](ToolChain *tc) -> bool {
ToolChain *tc = Utils::findOrDefault(detector.alreadyKnown, [&](ToolChain *tc) -> bool {
if (tc->typeId() != Constants::MSVC_TOOLCHAIN_TYPEID)
return false;
if (tc->targetAbi() != abi)
@@ -1862,7 +1861,7 @@ static QList<ToolChain *> findOrCreateToolChain(const QList<ToolChain *> &alread
}
// Detect build tools introduced with MSVC2015
static void detectCppBuildTools2015(QList<ToolChain *> *list)
static void detectCppBuildTools2015(Toolchains *list)
{
struct Entry
{
@@ -1901,15 +1900,14 @@ static void detectCppBuildTools2015(QList<ToolChain *> *list)
}
}
QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains MsvcToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
if (!device.isNull()) {
if (!detector.device.isNull()) {
// FIXME currently no support for msvc toolchains on a device
return {};
}
QList<ToolChain *> results;
Toolchains results;
// 1) Installed SDKs preferred over standalone Visual studio
const QSettings
@@ -1940,15 +1938,15 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &al
{MsvcToolChain::ia64, "ia64"},
};
for (const auto &platform : platforms) {
tmp.append(findOrCreateToolChain(alreadyKnown,
generateDisplayName(name,
MsvcToolChain::WindowsSDK,
platform.first),
findAbiOfMsvc(MsvcToolChain::WindowsSDK,
platform.first,
sdkKey),
fi.absoluteFilePath(),
"/" + platform.second));
tmp.append(findOrCreateToolchains(detector.alreadyKnown,
generateDisplayName(name,
MsvcToolChain::WindowsSDK,
platform.first),
findAbiOfMsvc(MsvcToolChain::WindowsSDK,
platform.first,
sdkKey),
fi.absoluteFilePath(),
"/" + platform.second));
}
// Make sure the default is front.
if (folder == defaultSdkPath)
@@ -1981,11 +1979,11 @@ QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &al
= QFileInfo(vcVarsBatFor(i.vcVarsPath, platform, i.version)).isFile();
if (hostSupportsPlatform(platform) && toolchainInstalled) {
results.append(
findOrCreateToolChain(alreadyKnown,
generateDisplayName(i.vsName, MsvcToolChain::VS, platform),
findAbiOfMsvc(MsvcToolChain::VS, platform, i.vsName),
i.vcVarsAll,
platformName(platform)));
findOrCreateToolchains(detector.alreadyKnown,
generateDisplayName(i.vsName, MsvcToolChain::VS, platform),
findAbiOfMsvc(MsvcToolChain::VS, platform, i.vsName),
i.vcVarsAll,
platformName(platform)));
}
}
}
@@ -2011,11 +2009,9 @@ bool ClangClToolChainFactory::canCreate() const
return !g_availableMsvcToolchains.isEmpty();
}
QList<ToolChain *> ClangClToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains ClangClToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
Q_UNUSED(alreadyKnown)
if (!device.isNull()) {
if (!detector.device.isNull()) {
// FIXME currently no support for msvc toolchains on a device
return {};
}
@@ -2025,14 +2021,14 @@ QList<ToolChain *> ClangClToolChainFactory::autoDetect(const QList<ToolChain *>
const char registryNode[] = "HKEY_LOCAL_MACHINE\\SOFTWARE\\LLVM\\LLVM";
#endif
QList<ToolChain *> results;
QList<ToolChain *> known = alreadyKnown;
Toolchains results;
Toolchains known = detector.alreadyKnown;
FilePath qtCreatorsClang = Core::ICore::clangExecutable(CLANG_BINDIR);
if (!qtCreatorsClang.isEmpty()) {
qtCreatorsClang = qtCreatorsClang.parentDir().pathAppended("clang-cl.exe");
results.append(detectClangClToolChainInPath(qtCreatorsClang,
alreadyKnown, "", true));
detector.alreadyKnown, "", true));
known.append(results);
}

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

@@ -204,10 +204,9 @@ class MsvcToolChainFactory : public ToolChainFactory
public:
MsvcToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device) override;
Toolchains autoDetect(const ToolchainDetector &detector) const final;
bool canCreate() const override;
bool canCreate() const final;
static QString vcVarsBatFor(const QString &basePath,
MsvcToolChain::Platform platform,
@@ -219,10 +218,9 @@ class ClangClToolChainFactory : public ToolChainFactory
public:
ClangClToolChainFactory();
QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device) override;
Toolchains autoDetect(const ToolchainDetector &detector) const final;
bool canCreate() const override;
bool canCreate() const final;
};
// --------------------------------------------------------------------------

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

@@ -539,15 +539,13 @@ const QList<ToolChainFactory *> ToolChainFactory::allToolChainFactories()
return Internal::g_toolChainFactories;
}
QList<ToolChain *> ToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains ToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
Q_UNUSED(alreadyKnown)
Q_UNUSED(device)
Q_UNUSED(detector)
return {};
}
QList<ToolChain *> ToolChainFactory::detectForImport(const ToolChainDescription &tcd)
Toolchains ToolChainFactory::detectForImport(const ToolChainDescription &tcd) const
{
Q_UNUSED(tcd)
return {};
@@ -558,7 +556,7 @@ bool ToolChainFactory::canCreate() const
return m_userCreatable;
}
ToolChain *ToolChainFactory::create()
ToolChain *ToolChainFactory::create() const
{
return m_toolchainConstructor ? m_toolchainConstructor() : nullptr;
}
@@ -650,4 +648,8 @@ void ToolChainFactory::setUserCreatable(bool userCreatable)
m_userCreatable = userCreatable;
}
ToolchainDetector::ToolchainDetector(const Toolchains &alreadyKnown, const IDevice::ConstPtr &device)
: alreadyKnown(alreadyKnown), device(device)
{}
} // namespace ProjectExplorer

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

@@ -212,6 +212,17 @@ private:
friend class ToolChainFactory;
};
using Toolchains = QList<ToolChain *>;
class PROJECTEXPLORER_EXPORT ToolchainDetector
{
public:
ToolchainDetector(const Toolchains &alreadyKnown = {}, const IDevice::ConstPtr &device = {});
const Toolchains alreadyKnown;
const IDevice::ConstPtr device;
};
class PROJECTEXPLORER_EXPORT ToolChainFactory
{
ToolChainFactory(const ToolChainFactory &) = delete;
@@ -226,12 +237,11 @@ public:
QString displayName() const { return m_displayName; }
Utils::Id supportedToolChainType() const;
virtual QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device);
virtual QList<ToolChain *> detectForImport(const ToolChainDescription &tcd);
virtual Toolchains autoDetect(const ToolchainDetector &detector) const;
virtual Toolchains detectForImport(const ToolChainDescription &tcd) const;
virtual bool canCreate() const;
virtual ToolChain *create();
virtual ToolChain *create() const;
ToolChain *restore(const QVariantMap &data);

7
src/plugins/projectexplorer/toolchainoptionspage.cpp
View File

@@ -398,7 +398,7 @@ StaticTreeItem *ToolChainOptionsWidget::parentForToolChain(ToolChain *tc)
void ToolChainOptionsWidget::redetectToolchains()
{
QList<ToolChainTreeItem *> itemsToRemove;
QList<ToolChain *> knownTcs;
Toolchains knownTcs;
m_model.forAllItems([&itemsToRemove, &knownTcs](TreeItem *item) {
if (item->level() != 3)
return;
@@ -410,10 +410,11 @@ void ToolChainOptionsWidget::redetectToolchains()
knownTcs << tcItem->toolChain;
}
});
QList<ToolChain *> toAdd;
Toolchains toAdd;
QSet<ToolChain *> toDelete;
for (ToolChainFactory *f : ToolChainFactory::allToolChainFactories()) {
for (ToolChain * const tc : f->autoDetect(knownTcs, {})) { // FIXME: Pass device.
const ToolchainDetector detector(knownTcs, {}); // FIXME: Pass device.
for (ToolChain * const tc : f->autoDetect(detector)) {
if (knownTcs.contains(tc) || toDelete.contains(tc))
continue;
const auto matchItem = [tc](const ToolChainTreeItem *item) {

148
src/plugins/projectexplorer/toolchainsettingsaccessor.cpp
View File

@@ -62,25 +62,24 @@ static const char TOOLCHAIN_FILENAME[] = "toolchains.xml";
struct ToolChainOperations
{
QList<ToolChain *> toDemote;
QList<ToolChain *> toRegister;
QList<ToolChain *> toDelete;
Toolchains toDemote;
Toolchains toRegister;
Toolchains toDelete;
};
static QList<ToolChain *> autoDetectToolChains(const QList<ToolChain *> alreadyKnownTcs,
const IDevice::Ptr &device)
static Toolchains autoDetectToolChains(const ToolchainDetector &detector)
{
QList<ToolChain *> result;
Toolchains result;
for (ToolChainFactory *f : ToolChainFactory::allToolChainFactories())
result.append(f->autoDetect(alreadyKnownTcs, device));
result.append(f->autoDetect(detector));
// Remove invalid toolchains that might have sneaked in.
return Utils::filtered(result, [](const ToolChain *tc) { return tc->isValid(); });
}
static QList<ToolChain *> makeUniqueByEqual(const QList<ToolChain *> &a)
static Toolchains makeUniqueByEqual(const Toolchains &a)
{
QList<ToolChain *> result;
Toolchains result;
foreach (ToolChain *tc, a) {
if (!Utils::contains(result, [tc](ToolChain *rtc) { return *tc == *rtc; }))
result.append(tc);
@@ -88,42 +87,42 @@ static QList<ToolChain *> makeUniqueByEqual(const QList<ToolChain *> &a)
return result;
}
static QList<ToolChain *> makeUniqueByPointerEqual(const QList<ToolChain *> &a)
static Toolchains makeUniqueByPointerEqual(const Toolchains &a)
{
return Utils::toList(Utils::toSet(a));
}
static QList<ToolChain *> subtractById(const QList<ToolChain *> &a, const QList<ToolChain *> &b)
static Toolchains subtractById(const Toolchains &a, const Toolchains &b)
{
return Utils::filtered(a, [&b](ToolChain *atc) {
return !Utils::anyOf(b, Utils::equal(&ToolChain::id, atc->id()));
});
}
static bool containsByEqual(const QList<ToolChain *> &a, const ToolChain *atc)
static bool containsByEqual(const Toolchains &a, const ToolChain *atc)
{
return Utils::anyOf(a, [atc](ToolChain *btc) { return *atc == *btc; });
}
static QList<ToolChain *> subtractByEqual(const QList<ToolChain *> &a, const QList<ToolChain *> &b)
static Toolchains subtractByEqual(const Toolchains &a, const Toolchains &b)
{
return Utils::filtered(a, [&b](ToolChain *atc) {
return !Utils::anyOf(b, [atc](ToolChain *btc) { return *atc == *btc; });
});
}
static QList<ToolChain *> subtractByPointerEqual(const QList<ToolChain *> &a, const QList<ToolChain *> &b)
static Toolchains subtractByPointerEqual(const Toolchains &a, const Toolchains &b)
{
return Utils::filtered(a, [&b](ToolChain *atc) { return !b.contains(atc); });
}
static QList<ToolChain *> stabilizeOrder(const QList<ToolChain *> &toRegister,
const QList<ToolChain *> &userFileTcs)
static Toolchains stabilizeOrder(const Toolchains &toRegister,
const Toolchains &userFileTcs)
{
// Keep the toolchains in their position in the user toolchain file to minimize diff!
QList<ToolChain *> result;
Toolchains result;
result.reserve(toRegister.size());
QList<ToolChain *> toHandle = toRegister;
Toolchains toHandle = toRegister;
for (int i = 0; i < userFileTcs.count(); ++i) {
const QByteArray userId = userFileTcs.at(i)->id();
@@ -139,30 +138,30 @@ static QList<ToolChain *> stabilizeOrder(const QList<ToolChain *> &toRegister,
return result;
}
static ToolChainOperations mergeToolChainLists(const QList<ToolChain *> &systemFileTcs,
const QList<ToolChain *> &userFileTcs,
const QList<ToolChain *> &autodetectedTcs)
static ToolChainOperations mergeToolChainLists(const Toolchains &systemFileTcs,
const Toolchains &userFileTcs,
const Toolchains &autodetectedTcs)
{
const QList<ToolChain *> uniqueUserFileTcs = makeUniqueByEqual(userFileTcs);
QList<ToolChain *> manualUserFileTcs;
QList<ToolChain *> autodetectedUserFileTcs;
const Toolchains uniqueUserFileTcs = makeUniqueByEqual(userFileTcs);
Toolchains manualUserFileTcs;
Toolchains autodetectedUserFileTcs;
std::tie(autodetectedUserFileTcs, manualUserFileTcs)
= Utils::partition(uniqueUserFileTcs, &ToolChain::isAutoDetected);
const QList<ToolChain *> autodetectedUserTcs = subtractById(autodetectedUserFileTcs, systemFileTcs);
const Toolchains autodetectedUserTcs = subtractById(autodetectedUserFileTcs, systemFileTcs);
// Calculate a set of Tcs that were detected before (and saved to userFile) and that
// got re-detected again. Take the userTcs (to keep Ids) over the same in autodetectedTcs.
QList<ToolChain *> redetectedUserTcs;
QList<ToolChain *> notRedetectedUserTcs;
Toolchains redetectedUserTcs;
Toolchains notRedetectedUserTcs;
std::tie(redetectedUserTcs, notRedetectedUserTcs)
= Utils::partition(autodetectedUserTcs,
[&autodetectedTcs](ToolChain *tc) { return containsByEqual(autodetectedTcs, tc); });
// Remove redetected tcs from autodetectedTcs:
const QList<ToolChain *> newlyAutodetectedTcs
const Toolchains newlyAutodetectedTcs
= subtractByEqual(autodetectedTcs, redetectedUserTcs);
const QList<ToolChain *> notRedetectedButValidUserTcs
const Toolchains notRedetectedButValidUserTcs
= Utils::filtered(notRedetectedUserTcs, &ToolChain::isValid);
ToolChainOperations result;
@@ -190,22 +189,23 @@ ToolChainSettingsAccessor::ToolChainSettingsAccessor() :
addVersionUpgrader(std::make_unique<ToolChainSettingsUpgraderV0>());
}
QList<ToolChain *> ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
{
// read all tool chains from SDK
const QList<ToolChain *> systemFileTcs = toolChains(
const Toolchains systemFileTcs = toolChains(
restoreSettings(Core::ICore::installerResourcePath(TOOLCHAIN_FILENAME), parent));
for (ToolChain * const systemTc : systemFileTcs)
systemTc->setDetection(ToolChain::AutoDetectionFromSdk);
// read all tool chains from user file.
const QList<ToolChain *> userFileTcs = toolChains(restoreSettings(parent));
const Toolchains userFileTcs = toolChains(restoreSettings(parent));
// Autodetect: Pass autodetected toolchains from user file so the information can be reused:
const QList<ToolChain *> autodetectedUserFileTcs
const Toolchains autodetectedUserFileTcs
= Utils::filtered(userFileTcs, &ToolChain::isAutoDetected);
// FIXME: Use real device?
const QList<ToolChain *> autodetectedTcs = autoDetectToolChains(autodetectedUserFileTcs, {});
const Toolchains autodetectedTcs =
autoDetectToolChains(ToolchainDetector(autodetectedUserFileTcs, {}));
// merge tool chains and register those that we need to keep:
const ToolChainOperations ops = mergeToolChainLists(systemFileTcs, userFileTcs, autodetectedTcs);
@@ -219,7 +219,7 @@ QList<ToolChain *> ToolChainSettingsAccessor::restoreToolChains(QWidget *parent)
return ops.toRegister;
}
void ToolChainSettingsAccessor::saveToolChains(const QList<ToolChain *> &toolchains, QWidget *parent)
void ToolChainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWidget *parent)
{
QVariantMap data;
@@ -240,9 +240,9 @@ void ToolChainSettingsAccessor::saveToolChains(const QList<ToolChain *> &toolcha
saveSettings(data, parent);
}
QList<ToolChain *> ToolChainSettingsAccessor::toolChains(const QVariantMap &data) const
Toolchains ToolChainSettingsAccessor::toolChains(const QVariantMap &data) const
{
QList<ToolChain *> result;
Toolchains result;
const QList<ToolChainFactory *> factories = ToolChainFactory::allToolChainFactories();
const int count = data.value(TOOLCHAIN_COUNT_KEY, 0).toInt();
@@ -291,8 +291,6 @@ QList<ToolChain *> ToolChainSettingsAccessor::toolChains(const QVariantMap &data
namespace ProjectExplorer {
using TCList = QList<ToolChain *>;
const char TestTokenKey[] = "TestTokenKey";
const char TestToolChainType[] = "TestToolChainType";
@@ -375,11 +373,11 @@ void ProjectExplorerPlugin::testToolChainMerging_data()
TestToolChainFactory factory;
QTest::addColumn<TCList>("system");
QTest::addColumn<TCList>("user");
QTest::addColumn<TCList>("autodetect");
QTest::addColumn<TCList>("toDemote");
QTest::addColumn<TCList>("toRegister");
QTest::addColumn<Toolchains>("system");
QTest::addColumn<Toolchains>("user");
QTest::addColumn<Toolchains>("autodetect");
QTest::addColumn<Toolchains>("toDemote");
QTest::addColumn<Toolchains>("toRegister");
TTC *system1 = nullptr;
ToolChain *system1c = nullptr;
@@ -422,57 +420,57 @@ void ProjectExplorerPlugin::testToolChainMerging_data()
}
QTest::newRow("no toolchains")
<< (TCList()) << (TCList()) << (TCList())
<< (TCList()) << (TCList());
<< (Toolchains()) << (Toolchains()) << (Toolchains())
<< (Toolchains()) << (Toolchains());
QTest::newRow("System: system, no user")
<< (TCList() << system1) << (TCList()) << (TCList())
<< (TCList()) << (TCList() << system1);
<< (Toolchains() << system1) << (Toolchains()) << (Toolchains())
<< (Toolchains()) << (Toolchains() << system1);
QTest::newRow("System: system, user")
<< (TCList() << system1) << (TCList() << system1) << (TCList())
<< (TCList()) << (TCList() << system1);
<< (Toolchains() << system1) << (Toolchains() << system1) << (Toolchains())
<< (Toolchains()) << (Toolchains() << system1);
QTest::newRow("System: no system, user") // keep, the user tool chain as it is still found
<< (TCList()) << (TCList() << system1) << (TCList())
<< (TCList() << system1) << (TCList() << system1);
<< (Toolchains()) << (Toolchains() << system1) << (Toolchains())
<< (Toolchains() << system1) << (Toolchains() << system1);
QTest::newRow("System: no system, invalid user")
<< (TCList()) << (TCList() << system3i) << (TCList())
<< (TCList()) << (TCList());
<< (Toolchains()) << (Toolchains() << system3i) << (Toolchains())
<< (Toolchains()) << (Toolchains());
QTest::newRow("Auto: no auto, user")
<< (TCList()) << (TCList() << auto1) << (TCList())
<< (TCList() << auto1) << (TCList() << auto1);
<< (Toolchains()) << (Toolchains() << auto1) << (Toolchains())
<< (Toolchains() << auto1) << (Toolchains() << auto1);
QTest::newRow("Auto: auto, no user")
<< (TCList()) << (TCList()) << (TCList() << auto1)
<< (TCList()) << (TCList() << auto1);
<< (Toolchains()) << (Toolchains()) << (Toolchains() << auto1)
<< (Toolchains()) << (Toolchains() << auto1);
QTest::newRow("Auto: auto, user")
<< (TCList()) << (TCList() << auto1) << (TCList() << auto1)
<< (TCList()) << (TCList() << auto1);
<< (Toolchains()) << (Toolchains() << auto1) << (Toolchains() << auto1)
<< (Toolchains()) << (Toolchains() << auto1);
QTest::newRow("Auto: auto-redetect, user")
<< (TCList()) << (TCList() << auto1) << (TCList() << auto1_2)
<< (TCList()) << (TCList() << auto1);
<< (Toolchains()) << (Toolchains() << auto1) << (Toolchains() << auto1_2)
<< (Toolchains()) << (Toolchains() << auto1);
QTest::newRow("Auto: auto-redetect, duplicate users")
<< (TCList()) << (TCList() << auto1 << auto1c) << (TCList() << auto1_2)
<< (TCList()) << (TCList() << auto1);
<< (Toolchains()) << (Toolchains() << auto1 << auto1c) << (Toolchains() << auto1_2)
<< (Toolchains()) << (Toolchains() << auto1);
QTest::newRow("Auto: (no) auto, invalid user")
<< (TCList()) << (TCList() << auto3i) << (TCList())
<< (TCList()) << (TCList());
<< (Toolchains()) << (Toolchains() << auto3i) << (Toolchains())
<< (Toolchains()) << (Toolchains());
QTest::newRow("invalid user")
<< (TCList()) << (TCList() << user3i) << (TCList())
<< (TCList()) << (TCList{user3i});
<< (Toolchains()) << (Toolchains() << user3i) << (Toolchains())
<< (Toolchains()) << (Toolchains{user3i});
QTest::newRow("one of everything")
<< (TCList() << system1) << (TCList() << user1) << (TCList() << auto1)
<< (TCList()) << (TCList() << system1 << user1 << auto1);
<< (Toolchains() << system1) << (Toolchains() << user1) << (Toolchains() << auto1)
<< (Toolchains()) << (Toolchains() << system1 << user1 << auto1);
}
void ProjectExplorerPlugin::testToolChainMerging()
{
QFETCH(TCList, system);
QFETCH(TCList, user);
QFETCH(TCList, autodetect);
QFETCH(TCList, toRegister);
QFETCH(TCList, toDemote);
QFETCH(Toolchains, system);
QFETCH(Toolchains, user);
QFETCH(Toolchains, autodetect);
QFETCH(Toolchains, toRegister);
QFETCH(Toolchains, toDemote);
Internal::ToolChainOperations ops = Internal::mergeToolChainLists(system, user, autodetect);

15
src/plugins/qnx/qnxtoolchain.cpp
View File

@@ -218,17 +218,12 @@ QnxToolChainFactory::QnxToolChainFactory()
setUserCreatable(true);
}
QList<ProjectExplorer::ToolChain *> QnxToolChainFactory::autoDetect(
const QList<ProjectExplorer::ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains QnxToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
Q_UNUSED(device);
QList<ToolChain *> tcs;
QList<QnxConfiguration *> configurations =
QnxConfigurationManager::instance()->configurations();
foreach (QnxConfiguration *configuration, configurations)
tcs += configuration->autoDetect(alreadyKnown);
Toolchains tcs;
const auto configurations = QnxConfigurationManager::instance()->configurations();
for (QnxConfiguration *configuration : configurations)
tcs += configuration->autoDetect(detector.alreadyKnown);
return tcs;
}

5
src/plugins/qnx/qnxtoolchain.h
View File

@@ -70,9 +70,8 @@ class QnxToolChainFactory : public ProjectExplorer::ToolChainFactory
public:
QnxToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(
const QList<ProjectExplorer::ToolChain *> &alreadyKnown,
const ProjectExplorer::IDevice::Ptr &device) final;
ProjectExplorer::Toolchains autoDetect(
const ProjectExplorer::ToolchainDetector &detector) const final;
};
//----------------------------------------------------------------------------

14
src/plugins/webassembly/webassemblytoolchain.cpp
View File

@@ -126,7 +126,7 @@ void WebAssemblyToolChain::registerToolChains()
return f->supportedToolChainType() == Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID;
});
QTC_ASSERT(factory, return);
for (auto toolChain : factory->autoDetect({}, {}))
for (auto toolChain : factory->autoDetect(ToolchainDetector({}, {})))
ToolChainManager::registerToolChain(toolChain);
// Let kits pick up the new toolchains
@@ -155,19 +155,15 @@ WebAssemblyToolChainFactory::WebAssemblyToolChainFactory()
setUserCreatable(true);
}
QList<ToolChain *> WebAssemblyToolChainFactory::autoDetect(
const QList<ToolChain *> &alreadyKnown,
const IDevice::Ptr &device)
Toolchains WebAssemblyToolChainFactory::autoDetect(const ToolchainDetector &detector) const
{
Q_UNUSED(alreadyKnown)
const FilePath sdk = WebAssemblyEmSdk::registeredEmSdk();
if (!WebAssemblyEmSdk::isValid(sdk))
return {};
if (device) {
if (detector.device) {
// Only detect toolchains from the emsdk installation device
const FilePath deviceRoot = device->mapToGlobalPath({});
const FilePath deviceRoot = detector.device->mapToGlobalPath({});
if (deviceRoot.host() != sdk.host())
return {};
}
@@ -175,7 +171,7 @@ QList<ToolChain *> WebAssemblyToolChainFactory::autoDetect(
Environment env = sdk.deviceEnvironment();
WebAssemblyEmSdk::addToEnvironment(sdk, env);
QList<ToolChain *> result;
Toolchains result;
for (auto languageId : {ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID}) {
auto toolChain = new WebAssemblyToolChain;

5
src/plugins/webassembly/webassemblytoolchain.h
View File

@@ -57,9 +57,8 @@ class WebAssemblyToolChainFactory : public ProjectExplorer::ToolChainFactory
public:
WebAssemblyToolChainFactory();
QList<ProjectExplorer::ToolChain *> autoDetect(
const QList<ProjectExplorer::ToolChain *> &alreadyKnown,
const ProjectExplorer::IDevice::Ptr &device) override;
ProjectExplorer::Toolchains autoDetect(
const ProjectExplorer::ToolchainDetector &detector) const final;
};
} // namespace Internal