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

ProjectExplorer: Rename ToolChain to Toolchain

Browse Source 
Change-Id: Ibb520f14ff3e2a6147ca5d419b9351c50c141063
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2023-11-24 15:53:31 +01:00
parent 2d4867e73f
commit c28fb1fdbe
78 changed files with 533 additions and 533 deletions
Download Patch File Download Diff File Expand all files Collapse all files

28
src/plugins/android/androidconfigurations.cpp
View File

@@ -1130,7 +1130,7 @@ void AndroidConfigurations::setConfig(const AndroidConfig &devConfigs)
emit m_instance->updated();
}
static bool matchToolChain(const ToolChain *atc, const ToolChain *btc)
static bool matchToolChain(const Toolchain *atc, const Toolchain *btc)
{
if (atc == btc)
return true;
@@ -1147,12 +1147,12 @@ static bool matchToolChain(const ToolChain *atc, const ToolChain *btc)
void AndroidConfigurations::registerNewToolChains()
{
const Toolchains existingAndroidToolChains
= ToolChainManager::toolchains(Utils::equal(&ToolChain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
= ToolChainManager::toolchains(Utils::equal(&Toolchain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
const Toolchains newToolchains = AndroidToolchainFactory::autodetectToolChains(
existingAndroidToolChains);
for (ToolChain *tc : newToolchains)
for (Toolchain *tc : newToolchains)
ToolChainManager::registerToolChain(tc);
registerCustomToolChainsAndDebuggers();
@@ -1160,9 +1160,9 @@ void AndroidConfigurations::registerNewToolChains()
void AndroidConfigurations::removeOldToolChains()
{
const auto tcs = ToolChainManager::toolchains(Utils::equal(&ToolChain::typeId,
const auto tcs = ToolChainManager::toolchains(Utils::equal(&Toolchain::typeId,
Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
for (ToolChain *tc : tcs) {
for (Toolchain *tc : tcs) {
if (!tc->isValid())
ToolChainManager::deregisterToolChain(tc);
}
@@ -1241,7 +1241,7 @@ static const Debugger::DebuggerItem *existingDebugger(const FilePath &command,
return nullptr;
}
static QVariant findOrRegisterDebugger(ToolChain *tc,
static QVariant findOrRegisterDebugger(Toolchain *tc,
const QStringList &abisList,
bool customDebugger = false)
{
@@ -1307,14 +1307,14 @@ static QVariant findOrRegisterDebugger(ToolChain *tc,
void AndroidConfigurations::registerCustomToolChainsAndDebuggers()
{
const Toolchains existingAndroidToolChains = ToolChainManager::toolchains(
Utils::equal(&ToolChain::typeId, Utils::Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
Utils::equal(&Toolchain::typeId, Utils::Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
const FilePaths customNdks = FileUtils::toFilePathList(currentConfig().getCustomNdkList());
const Toolchains customToolchains
= AndroidToolchainFactory::autodetectToolChainsFromNdks(existingAndroidToolChains,
customNdks,
true);
for (ToolChain *tc : customToolchains) {
for (Toolchain *tc : customToolchains) {
ToolChainManager::registerToolChain(tc);
const auto androidToolChain = static_cast<AndroidToolChain *>(tc);
QString abiStr;
@@ -1359,12 +1359,12 @@ void AndroidConfigurations::updateAutomaticKitList()
}
// register new kits
const Toolchains toolchains = ToolChainManager::toolchains([](const ToolChain *tc) {
const Toolchains toolchains = ToolChainManager::toolchains([](const Toolchain *tc) {
return tc->isAutoDetected() && tc->typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
&& tc->isValid();
});
QList<Kit *> unhandledKits = existingKits;
for (ToolChain *tc : toolchains) {
for (Toolchain *tc : toolchains) {
if (tc->language() != ProjectExplorer::Constants::CXX_LANGUAGE_ID)
continue;
@@ -1374,13 +1374,13 @@ void AndroidConfigurations::updateAutomaticKitList()
continue;
const Toolchains allLanguages
= Utils::filtered(toolchains, [tc, tcNdk](ToolChain *otherTc) {
= Utils::filtered(toolchains, [tc, tcNdk](Toolchain *otherTc) {
FilePath otherNdk = static_cast<const AndroidToolChain *>(otherTc)->ndkLocation();
return tc->targetAbi() == otherTc->targetAbi() && tcNdk == otherNdk;
});
QHash<Id, ToolChain *> toolChainForLanguage;
for (ToolChain *tc : allLanguages)
QHash<Id, Toolchain *> toolChainForLanguage;
for (Toolchain *tc : allLanguages)
toolChainForLanguage[tc->language()] = tc;
Kit *existingKit = Utils::findOrDefault(existingKits, [&](const Kit *b) {
@@ -1396,7 +1396,7 @@ void AndroidConfigurations::updateAutomaticKitList()
k->setAutoDetected(true);
k->setAutoDetectionSource("AndroidConfiguration");
DeviceTypeKitAspect::setDeviceTypeId(k, Constants::ANDROID_DEVICE_TYPE);
for (ToolChain *tc : allLanguages)
for (Toolchain *tc : allLanguages)
ToolChainKitAspect::setToolChain(k, tc);
QtKitAspect::setQtVersion(k, qt);
QStringList abis = static_cast<const AndroidQtVersion *>(qt)->androidAbis();

2
src/plugins/android/androidpackageinstallationstep.cpp
View File

@@ -73,7 +73,7 @@ bool AndroidPackageInstallationStep::init()
return false;
}
ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit());
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit());
QTC_ASSERT(tc, reportWarningOrError(Tr::tr("\"%1\" step has an invalid C++ toolchain.")
.arg(displayName()), Task::TaskType::Error);
return false);

10
src/plugins/android/androidtoolchain.cpp
View File

@@ -34,10 +34,10 @@ Q_GLOBAL_STATIC_WITH_ARGS(ClangTargetsType, ClangTargets, ({
Abi(Abi::ArmArchitecture, Abi::LinuxOS, Abi::AndroidLinuxFlavor, Abi::ElfFormat, 64)}}
));
static ToolChain *findToolChain(FilePath &compilerPath, Id lang, const QString &target,
static Toolchain *findToolChain(FilePath &compilerPath, Id lang, const QString &target,
const ToolChainList &alreadyKnown)
{
ToolChain *tc = Utils::findOrDefault(alreadyKnown, [target, compilerPath, lang](ToolChain *tc) {
Toolchain *tc = Utils::findOrDefault(alreadyKnown, [target, compilerPath, lang](Toolchain *tc) {
return tc->typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID
&& tc->language() == lang
&& tc->targetAbi() == ClangTargets->value(target)
@@ -180,7 +180,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
const QList<FilePath> &ndkLocations,
const bool isCustom)
{
QList<ToolChain *> result;
QList<Toolchain *> result;
const AndroidConfig config = AndroidConfigurations::currentConfig();
const Id LanguageIds[] {
@@ -211,7 +211,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
while (targetItr != ClangTargets->constEnd()) {
const Abi &abi = targetItr.value();
const QString target = targetItr.key();
ToolChain *tc = findToolChain(compilerCommand, lang, target, alreadyKnown);
Toolchain *tc = findToolChain(compilerCommand, lang, target, alreadyKnown);
QLatin1String customStr = isCustom ? QLatin1String("Custom ") : QLatin1String();
const QString displayName(customStr + QString("Android Clang (%1, %2, NDK %3)")
@@ -241,7 +241,7 @@ ToolChainList AndroidToolchainFactory::autodetectToolChainsFromNdks(
if (auto gccTc = dynamic_cast<GccToolChain*>(tc))
gccTc->resetToolChain(compilerCommand);
tc->setDetection(ToolChain::AutoDetection);
tc->setDetection(Toolchain::AutoDetection);
result << tc;
++targetItr;
}

2
src/plugins/android/androidtoolchain.h
View File

@@ -9,7 +9,7 @@
namespace Android::Internal {
using ToolChainList = QList<ProjectExplorer::ToolChain *>;
using ToolChainList = QList<ProjectExplorer::Toolchain *>;
class AndroidToolChain : public ProjectExplorer::GccToolChain
{

2
src/plugins/autotest/autotestunittests.cpp
View File

@@ -59,7 +59,7 @@ void AutoTestUnitTests::initTestCase()
m_isQt4 = qtVersion->qtVersionString().startsWith('4');
else
QSKIP("Could not figure out which Qt version is used for default kit.");
const ToolChain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
if (!toolchain)
QSKIP("This test requires that there is a kit with a toolchain.");

2
src/plugins/autotest/loadprojectscenario.cpp
View File

@@ -56,7 +56,7 @@ bool LoadProjectScenario::init()
return false;
}
const ToolChain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
if (!toolchain) {
qWarning() << "This test requires that there is a kit with a toolchain.";
return false;

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

@@ -280,10 +280,10 @@ private:
// IarToolChain
class IarToolChain final : public ToolChain
class IarToolChain final : public Toolchain
{
public:
IarToolChain() : ToolChain(Constants::IAREW_TOOLCHAIN_TYPEID)
IarToolChain() : Toolchain(Constants::IAREW_TOOLCHAIN_TYPEID)
{
setTypeDisplayName(Tr::tr("IAREW"));
setTargetAbiKey("TargetAbi");
@@ -305,7 +305,7 @@ public:
std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() final;
bool operator==(const ToolChain &other) const final;
bool operator==(const Toolchain &other) const final;
QStringList extraCodeModelFlags() const final { return m_extraCodeModelFlags(); }
@@ -318,7 +318,7 @@ private:
friend class IarToolChainConfigWidget;
};
ToolChain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() const
Toolchain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() const
{
Environment env = Environment::systemEnvironment();
addToEnvironment(env);
@@ -340,7 +340,7 @@ ToolChain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() con
macros.append({"__spec_string", "", MacroType::Define});
macros.append({"__constrange(__a,__b)", "", MacroType::Define});
const auto languageVersion = ToolChain::languageVersion(languageId, macros);
const auto languageVersion = Toolchain::languageVersion(languageId, macros);
const auto report = MacroInspectionReport{macros, languageVersion};
macrosCache->insert({}, report);
@@ -359,7 +359,7 @@ WarningFlags IarToolChain::warningFlags(const QStringList &cxxflags) const
return WarningFlags::Default;
}
ToolChain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner(
const Environment &) const
{
Environment env = Environment::systemEnvironment();
@@ -394,9 +394,9 @@ std::unique_ptr<ToolchainConfigWidget> IarToolChain::createConfigurationWidget()
return std::make_unique<IarToolChainConfigWidget>(this);
}
bool IarToolChain::operator==(const ToolChain &other) const
bool IarToolChain::operator==(const Toolchain &other) const
{
if (!ToolChain::operator==(other))
if (!Toolchain::operator==(other))
return false;
const auto customTc = static_cast<const IarToolChain *>(&other);
@@ -518,7 +518,7 @@ Toolchains IarToolchainFactory::autoDetectToolchains(
Toolchains result;
for (const Candidate &candidate : std::as_const(candidates)) {
const Toolchains 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
@@ -551,14 +551,14 @@ Toolchains IarToolchainFactory::autoDetectToolchain(const Candidate &candidate,
const Abi abi = guessAbi(macros);
const auto tc = new IarToolChain;
tc->setDetection(ToolChain::AutoDetection);
tc->setDetection(Toolchain::AutoDetection);
tc->setLanguage(languageId);
tc->setCompilerCommand(candidate.compilerPath);
tc->setTargetAbi(abi);
tc->setDisplayName(buildDisplayName(abi.architecture(), languageId,
candidate.compilerVersion));
const auto languageVersion = ToolChain::languageVersion(languageId, macros);
const auto languageVersion = Toolchain::languageVersion(languageId, macros);
tc->predefinedMacrosCache()->insert({}, {macros, languageVersion});
return {tc};
}
@@ -608,7 +608,7 @@ void IarToolChainConfigWidget::applyImpl()
if (m_macros.isEmpty())
return;
const auto languageVersion = ToolChain::languageVersion(tc->language(), m_macros);
const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros);
tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion});
setFromToolchain();

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

@@ -418,11 +418,11 @@ private:
// KeilToolChain
class KeilToolChain final : public ToolChain
class KeilToolChain final : public Toolchain
{
public:
KeilToolChain() :
ToolChain(Constants::KEIL_TOOLCHAIN_TYPEID)
Toolchain(Constants::KEIL_TOOLCHAIN_TYPEID)
{
setTypeDisplayName(Tr::tr("KEIL"));
setTargetAbiKey("TargetAbi");
@@ -445,7 +445,7 @@ public:
std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() final;
bool operator==(const ToolChain &other) const final;
bool operator==(const Toolchain &other) const final;
QStringList extraCodeModelFlags() const final;
@@ -458,7 +458,7 @@ private:
friend class KeilToolChainConfigWidget;
};
ToolChain::MacroInspectionRunner KeilToolChain::createMacroInspectionRunner() const
Toolchain::MacroInspectionRunner KeilToolChain::createMacroInspectionRunner() const
{
Environment env = Environment::systemEnvironment();
addToEnvironment(env);
@@ -491,7 +491,7 @@ WarningFlags KeilToolChain::warningFlags(const QStringList &cxxflags) const
return WarningFlags::Default;
}
ToolChain::BuiltInHeaderPathsRunner KeilToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner KeilToolChain::createBuiltInHeaderPathsRunner(
const Environment &) const
{
const FilePath compiler = compilerCommand();
@@ -520,9 +520,9 @@ std::unique_ptr<ToolchainConfigWidget> KeilToolChain::createConfigurationWidget(
return std::make_unique<KeilToolChainConfigWidget>(this);
}
bool KeilToolChain::operator ==(const ToolChain &other) const
bool KeilToolChain::operator ==(const Toolchain &other) const
{
if (!ToolChain::operator ==(other))
if (!Toolchain::operator ==(other))
return false;
const auto customTc = static_cast<const KeilToolChain *>(&other);
@@ -667,7 +667,7 @@ Toolchains KeilToolchainFactory::autoDetectToolchains(
for (const Candidate &candidate : std::as_const(candidates)) {
const Toolchains filtered = Utils::filtered(
alreadyKnown, [candidate](ToolChain *tc) {
alreadyKnown, [candidate](Toolchain *tc) {
return tc->typeId() == Constants::IAREW_TOOLCHAIN_TYPEID
&& tc->compilerCommand() == candidate.compilerPath
&& (tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID
@@ -710,14 +710,14 @@ Toolchains KeilToolchainFactory::autoDetectToolchain(const Candidate &candidate,
}
const auto tc = new KeilToolChain;
tc->setDetection(ToolChain::AutoDetection);
tc->setDetection(Toolchain::AutoDetection);
tc->setLanguage(language);
tc->setCompilerCommand(candidate.compilerPath);
tc->m_extraCodeModelFlags.setValue(extraArgs);
tc->setTargetAbi(abi);
tc->setDisplayName(buildDisplayName(abi.architecture(), language, candidate.compilerVersion));
const auto languageVersion = ToolChain::languageVersion(language, macros);
const auto languageVersion = Toolchain::languageVersion(language, macros);
tc->predefinedMacrosCache()->insert({}, {macros, languageVersion});
return {tc};
}
@@ -765,7 +765,7 @@ void KeilToolChainConfigWidget::applyImpl()
if (m_macros.isEmpty())
return;
const auto languageVersion = ToolChain::languageVersion(tc->language(), m_macros);
const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros);
tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion});
setFromToolChain();

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

@@ -199,10 +199,10 @@ private:
// SdccToolChain
class SdccToolChain final : public ToolChain
class SdccToolChain final : public Toolchain
{
public:
SdccToolChain() : ToolChain(Constants::SDCC_TOOLCHAIN_TYPEID)
SdccToolChain() : Toolchain(Constants::SDCC_TOOLCHAIN_TYPEID)
{
setTypeDisplayName(Tr::tr("SDCC"));
setTargetAbiKey("TargetAbi");
@@ -220,7 +220,7 @@ public:
std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() final;
bool operator==(const ToolChain &other) const final;
bool operator==(const Toolchain &other) const final;
FilePath makeCommand(const Environment &) const final { return {}; }
@@ -229,7 +229,7 @@ private:
friend class SdccToolChainConfigWidget;
};
ToolChain::MacroInspectionRunner SdccToolChain::createMacroInspectionRunner() const
Toolchain::MacroInspectionRunner SdccToolChain::createMacroInspectionRunner() const
{
Environment env = Environment::systemEnvironment();
addToEnvironment(env);
@@ -263,7 +263,7 @@ WarningFlags SdccToolChain::warningFlags(const QStringList &cxxflags) const
return WarningFlags::Default;
}
ToolChain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunner(
const Environment &) const
{
Environment env = Environment::systemEnvironment();
@@ -288,9 +288,9 @@ std::unique_ptr<ToolchainConfigWidget> SdccToolChain::createConfigurationWidget(
return std::make_unique<SdccToolChainConfigWidget>(this);
}
bool SdccToolChain::operator==(const ToolChain &other) const
bool SdccToolChain::operator==(const Toolchain &other) const
{
if (!ToolChain::operator==(other))
if (!Toolchain::operator==(other))
return false;
const auto customTc = static_cast<const SdccToolChain *>(&other);
@@ -388,7 +388,7 @@ Toolchains SdccToolchainFactory::autoDetectToolchains(
Toolchains result;
for (const Candidate &candidate : std::as_const(candidates)) {
const Toolchains 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);
@@ -429,14 +429,14 @@ Toolchains SdccToolchainFactory::autoDetectToolchain(const Candidate &candidate,
continue;
const auto tc = new SdccToolChain;
tc->setDetection(ToolChain::AutoDetection);
tc->setDetection(Toolchain::AutoDetection);
tc->setLanguage(language);
tc->setCompilerCommand(candidate.compilerPath);
tc->setTargetAbi(abi);
tc->setDisplayName(buildDisplayName(abi.architecture(), language,
candidate.compilerVersion));
const auto languageVersion = ToolChain::languageVersion(language, macros);
const auto languageVersion = Toolchain::languageVersion(language, macros);
tc->predefinedMacrosCache()->insert({}, {macros, languageVersion});
tcs.push_back(tc);
@@ -482,7 +482,7 @@ void SdccToolChainConfigWidget::applyImpl()
if (m_macros.isEmpty())
return;
const auto languageVersion = ToolChain::languageVersion(tc->language(), m_macros);
const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros);
tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion});
setFromToolchain();

2
src/plugins/clangtools/clangtoolspreconfiguredsessiontests.cpp
View File

@@ -148,7 +148,7 @@ static QList<Target *> validTargets(Project *project)
return false;
}
const ToolChain * const toolchain = ToolChainKitAspect::cxxToolChain(kit);
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(kit);
QTC_ASSERT(toolchain, return false);
if (Core::ICore::clangExecutable(CLANG_BINDIR).isEmpty()) {

2
src/plugins/clangtools/clangtoolsunittests.cpp
View File

@@ -50,7 +50,7 @@ void ClangToolsUnitTests::initTestCase()
if (!m_kit)
QSKIP("This test requires at least one valid kit with a valid Qt");
const ToolChain *const toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
const Toolchain * const toolchain = ToolChainKitAspect::cxxToolChain(m_kit);
if (!toolchain)
QSKIP("This test requires that there is a kit with a toolchain.");

4
src/plugins/cmakeprojectmanager/cmakebuildconfiguration.cpp
View File

@@ -1091,7 +1091,7 @@ static bool isQnx(const Kit *k)
static bool isWindowsARM64(const Kit *k)
{
ToolChain *toolchain = ToolChainKitAspect::cxxToolChain(k);
Toolchain *toolchain = ToolChainKitAspect::cxxToolChain(k);
if (!toolchain)
return false;
const Abi targetAbi = toolchain->targetAbi();
@@ -1124,7 +1124,7 @@ static CommandLine defaultInitialCMakeCommand(const Kit *k, const QString &build
const QString sysRoot = SysRootKitAspect::sysRoot(k).path();
if (!sysRoot.isEmpty()) {
cmd.addArg("-DCMAKE_SYSROOT:PATH=" + sysRoot);
if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(k)) {
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(k)) {
const QString targetTriple = tc->originalTargetTriple();
cmd.addArg("-DCMAKE_C_COMPILER_TARGET:STRING=" + targetTriple);
cmd.addArg("-DCMAKE_CXX_COMPILER_TARGET:STRING=" + targetTriple);

2
src/plugins/cmakeprojectmanager/cmakebuildstep.cpp
View File

@@ -335,7 +335,7 @@ void CMakeBuildStep::setupOutputFormatter(Utils::OutputFormatter *formatter)
formatter->addLineParser(progressParser);
cmakeParser->setSourceDirectory(project()->projectDirectory());
formatter->addLineParsers({cmakeParser, new GnuMakeParser});
ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit());
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit());
OutputTaskParser *xcodeBuildParser = nullptr;
if (tc && tc->targetAbi().os() == Abi::DarwinOS) {
xcodeBuildParser = new XcodebuildParser;

6
src/plugins/cmakeprojectmanager/cmakekitaspect.cpp
View File

@@ -681,7 +681,7 @@ QVariant CMakeGeneratorKitAspectFactory::defaultValue(const Kit *k) const
if (tool->filePath().osType() == OsTypeWindows) {
// *sigh* Windows with its zoo of incompatible stuff again...
ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
if (tc && tc->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) {
it = std::find_if(known.constBegin(),
known.constEnd(),
@@ -1135,8 +1135,8 @@ Tasks CMakeConfigurationKitAspectFactory::validate(const Kit *k) const
return Tasks();
const QtSupport::QtVersion *const version = QtSupport::QtKitAspect::qtVersion(k);
const ToolChain *const tcC = ToolChainKitAspect::cToolChain(k);
const ToolChain *const tcCxx = ToolChainKitAspect::cxxToolChain(k);
const Toolchain *const tcC = ToolChainKitAspect::cToolChain(k);
const Toolchain *const tcCxx = ToolChainKitAspect::cxxToolChain(k);
const CMakeConfig config = CMakeConfigurationKitAspect::configuration(k);
const bool isQt4 = version && version->qtVersion() < QVersionNumber(5, 0, 0);

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

@@ -585,7 +585,7 @@ void updateConfigWithDirectoryData(CMakeConfig &config, const std::unique_ptr<Di
data->qt.qt->qmakeFilePath().toString().toUtf8());
}
ToolChain *findExternalToolchain(const QString &presetArchitecture, const QString &presetToolset)
Toolchain *findExternalToolchain(const QString &presetArchitecture, const QString &presetToolset)
{
// A compiler path example. Note that the compiler version is not the same version from MsvcToolChain
// ... \MSVC\14.29.30133\bin\Hostx64\x64\cl.exe
@@ -601,16 +601,16 @@ ToolChain *findExternalToolchain(const QString &presetArchitecture, const QStrin
// "strategy": "external"
// }
auto msvcToolchains = ToolChainManager::toolchains([](const ToolChain *tc) {
auto msvcToolchains = ToolChainManager::toolchains([](const Toolchain *tc) {
return tc->typeId() == ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID;
});
const QSet<Abi::OSFlavor> msvcFlavors = Utils::toSet(Utils::transform(msvcToolchains, [](const ToolChain *tc) {
const QSet<Abi::OSFlavor> msvcFlavors = Utils::toSet(Utils::transform(msvcToolchains, [](const Toolchain *tc) {
return tc->targetAbi().osFlavor();
}));
return ToolChainManager::toolChain(
[presetArchitecture, presetToolset, msvcFlavors](const ToolChain *tc) -> bool {
[presetArchitecture, presetToolset, msvcFlavors](const Toolchain *tc) -> bool {
if (tc->typeId() != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID)
return false;
@@ -732,7 +732,7 @@ QList<void *> CMakeProjectImporter::examineDirectory(const FilePath &importPath,
data->toolset = configurePreset.toolset.value().value.value();
if (architectureExternalStrategy && toolsetExternalStrategy) {
const ToolChain *tc
const Toolchain *tc
= findExternalToolchain(configurePreset.architecture->value.value_or(QString()),
configurePreset.toolset->value.value_or(QString()));
if (tc)
@@ -937,7 +937,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
if (!Utils::contains(allLanguages,
[&tcd](const Id &language) { return language == tcd.language; }))
continue;
ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
Toolchain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
if ((!tc || !tc->matchesCompilerCommand(tcd.compilerPath))) {
return false;
}
@@ -950,7 +950,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
if (!Utils::contains(allLanguages,
[&tcd](const Id &language) { return language == tcd.language; }))
continue;
ToolChain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
Toolchain *tc = ToolChainKitAspect::toolChain(k, tcd.language);
if (tc && tc->matchesCompilerCommand(tcd.compilerPath)) {
return false;
}
@@ -1000,7 +1000,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
if (tcd.areTemporary) {
for (ToolChain *tc : tcd.tcs)
for (Toolchain *tc : tcd.tcs)
addTemporaryData(ToolChainKitAspect::id(), tc->id(), k);
}

10
src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp
View File

@@ -75,9 +75,9 @@ Utils::Id getCompilerId(QString compilerName)
return ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID;
}
ToolChain *toolchainFromCompilerId(const Utils::Id &compilerId, const Utils::Id &language)
Toolchain *toolchainFromCompilerId(const Utils::Id &compilerId, const Utils::Id &language)
{
return ToolChainManager::toolChain([&compilerId, &language](const ToolChain *tc) {
return ToolChainManager::toolChain([&compilerId, &language](const Toolchain *tc) {
if (!tc->isValid() || tc->language() != language)
return false;
return tc->typeId() == compilerId;
@@ -105,14 +105,14 @@ QString compilerPath(QString pathFlag)
return QDir::fromNativeSeparators(pathFlag);
}
ToolChain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Utils::Id &language)
Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Utils::Id &language)
{
if (flags.empty())
return ToolChainKitAspect::toolChain(kit, language);
// Try exact compiler match.
const Utils::FilePath compiler = Utils::FilePath::fromUserInput(compilerPath(flags.front()));
ToolChain *toolchain = ToolChainManager::toolChain([&compiler, &language](const ToolChain *tc) {
Toolchain *toolchain = ToolChainManager::toolChain([&compiler, &language](const Toolchain *tc) {
return tc->isValid() && tc->language() == language && tc->compilerCommand() == compiler;
});
if (toolchain)
@@ -136,7 +136,7 @@ ToolChain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Ut
return toolchain;
}
void addDriverModeFlagIfNeeded(const ToolChain *toolchain,
void addDriverModeFlagIfNeeded(const Toolchain *toolchain,
QStringList &flags,
const QStringList &originalFlags)
{

2
src/plugins/compilationdatabaseprojectmanager/compilationdatabasetests.cpp
View File

@@ -39,7 +39,7 @@ void CompilationDatabaseTests::initTestCase()
if (allKits.empty())
QSKIP("This test requires at least one kit to be present.");
ToolChain *toolchain = ToolChainManager::toolChain([](const ToolChain *tc) {
Toolchain *toolchain = ToolChainManager::toolChain([](const Toolchain *tc) {
return tc->isValid() && tc->language() == ProjectExplorer::Constants::CXX_LANGUAGE_ID;
});
if (!toolchain)

4
src/plugins/conan/conaninstallstep.cpp
View File

@@ -104,7 +104,7 @@ ConanInstallStep::ConanInstallStep(BuildStepList *bsl, Id id)
});
setSummaryUpdater([this]() -> QString {
QList<ToolChain *> tcList = ToolChainKitAspect::toolChains(target()->kit());
QList<Toolchain *> tcList = ToolChainKitAspect::toolChains(target()->kit());
if (tcList.isEmpty())
return "<b>" + ToolChainKitAspect::msgNoToolChainInTarget() + "</b>";
ProcessParameters param;
@@ -124,7 +124,7 @@ bool ConanInstallStep::init()
if (!AbstractProcessStep::init())
return false;
const QList<ToolChain *> tcList = ToolChainKitAspect::toolChains(target()->kit());
const QList<Toolchain *> tcList = ToolChainKitAspect::toolChains(target()->kit());
if (tcList.isEmpty()) {
emit addTask(Task::compilerMissingTask());
emitFaultyConfigurationMessage();

2
src/plugins/cppeditor/compileroptionsbuilder_test.cpp
View File

@@ -46,7 +46,7 @@ public:
tcInfo.isMsvc2015ToolChain = isMsvc2015;
tcInfo.extraCodeModelFlags = extraFlags;
tcInfo.macroInspectionRunner = [this](const QStringList &) {
return ToolChain::MacroInspectionReport{toolchainMacros, languageVersion};
return Toolchain::MacroInspectionReport{toolchainMacros, languageVersion};
};
RawProjectPartFlags rppFlags;
rppFlags.commandLineFlags = flags;

6
src/plugins/cppeditor/cppmodelmanager.cpp
View File

@@ -409,7 +409,7 @@ void CppModelManager::showPreprocessedFile(bool inNextSplit)
return;
}
const ToolChain * tc = nullptr;
const Toolchain * tc = nullptr;
const ProjectFile classifier(filePath, ProjectFile::classify(filePath.toString()));
if (classifier.isC()) {
tc = ToolChainKitAspect::cToolChain(project->activeTarget()->kit());
@@ -1964,7 +1964,7 @@ void CppModelManager::setupFallbackProjectPart()
// TODO: Use different fallback toolchain for different kinds of files?
const Kit * const defaultKit = KitManager::isLoaded() ? KitManager::defaultKit() : nullptr;
const ToolChain * const defaultTc = defaultKit
const Toolchain * const defaultTc = defaultKit
? ToolChainKitAspect::cxxToolChain(defaultKit) : nullptr;
if (defaultKit && defaultTc) {
FilePath sysroot = SysRootKitAspect::sysRoot(defaultKit);
@@ -1974,7 +1974,7 @@ void CppModelManager::setupFallbackProjectPart()
tcInfo = ToolChainInfo(defaultTc, sysroot, env);
const auto macroInspectionWrapper = [runner = tcInfo.macroInspectionRunner](
const QStringList &flags) {
ToolChain::MacroInspectionReport report = runner(flags);
Toolchain::MacroInspectionReport report = runner(flags);
report.languageVersion = LanguageVersion::LatestCxx;
return report;
};

8
src/plugins/cppeditor/projectinfo_test.cpp
View File

@@ -69,7 +69,7 @@ public:
// Create project part for C
tcInfo.macroInspectionRunner = [](const QStringList &) {
return ToolChain::MacroInspectionReport{{}, Utils::LanguageVersion::C11};
return Toolchain::MacroInspectionReport{{}, Utils::LanguageVersion::C11};
};
const ProjectPart::ConstPtr cprojectpart = ProjectPart::create({}, {}, {}, {}, {}, {}, {},
tcInfo);
@@ -77,7 +77,7 @@ public:
// Create project part for CXX
tcInfo.macroInspectionRunner = [](const QStringList &) {
return ToolChain::MacroInspectionReport{{}, Utils::LanguageVersion::CXX98};
return Toolchain::MacroInspectionReport{{}, Utils::LanguageVersion::CXX98};
};
const ProjectPart::ConstPtr cxxprojectpart = ProjectPart::create({}, {}, {}, {}, {}, {}, {},
tcInfo);
@@ -330,10 +330,10 @@ void ProjectPartChooserTest::testDoNotIndicateFromDependencies()
}
namespace {
class TestToolchain : public ToolChain
class TestToolchain : public Toolchain
{
public:
TestToolchain() : ToolChain("dummy") {}
TestToolchain() : Toolchain("dummy") {}
private:
MacroInspectionRunner createMacroInspectionRunner() const override { return {}; }

4
src/plugins/cppeditor/projectpart.cpp
View File

@@ -96,10 +96,10 @@ static HeaderPaths getHeaderPaths(const RawProjectPart &rpp,
return headerPaths;
}
static ToolChain::MacroInspectionReport getToolchainMacros(
static Toolchain::MacroInspectionReport getToolchainMacros(
const RawProjectPartFlags &flags, const ToolChainInfo &tcInfo, Utils::Language language)
{
ToolChain::MacroInspectionReport report;
Toolchain::MacroInspectionReport report;
if (tcInfo.macroInspectionRunner) {
report = tcInfo.macroInspectionRunner(flags.commandLineFlags);
} else if (language == Utils::Language::C) { // No compiler set in kit.

2
src/plugins/cppeditor/projectpart.h
View File

@@ -110,7 +110,7 @@ private:
CPlusPlus::LanguageFeatures deriveLanguageFeatures() const;
const ProjectExplorer::ToolChain::MacroInspectionReport m_macroReport;
const ProjectExplorer::Toolchain::MacroInspectionReport m_macroReport;
public:
// Must come last due to initialization order.

12
src/plugins/docker/kitdetector.cpp
View File

@@ -46,7 +46,7 @@ public:
private:
QtVersions autoDetectQtVersions() const;
QList<ToolChain *> autoDetectToolChains();
QList<Toolchain *> autoDetectToolChains();
void autoDetectPython();
QList<Id> autoDetectCMake();
void autoDetectDebugger();
@@ -107,7 +107,7 @@ void KitDetectorPrivate::undoAutoDetect() const
emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Removing toolchain entries..."));
const Toolchains toolchains = ToolChainManager::toolchains();
for (ToolChain *toolChain : toolchains) {
for (Toolchain *toolChain : toolchains) {
if (toolChain && toolChain->detectionSource() == m_sharedId) {
emit q->logOutput(ProjectExplorer::Tr::tr("Removed \"%1\"").arg(toolChain->displayName()));
ToolChainManager::deregisterToolChain(toolChain);
@@ -164,7 +164,7 @@ void KitDetectorPrivate::listAutoDetected() const
}
emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Toolchains:"));
for (ToolChain *toolChain : ToolChainManager::toolchains()) {
for (Toolchain *toolChain : ToolChainManager::toolchains()) {
if (toolChain->detectionSource() == m_sharedId)
emit q->logOutput(toolChain->displayName());
}
@@ -259,7 +259,7 @@ Toolchains KitDetectorPrivate::autoDetectToolChains()
emit q->logOutput(ProjectExplorer::Tr::tr("Searching toolchains of type %1").arg(factory->displayName()));
const ToolchainDetector detector(alreadyKnown, m_device, m_searchPaths);
const Toolchains newToolChains = factory->autoDetect(detector);
for (ToolChain *toolChain : newToolChains) {
for (Toolchain *toolChain : newToolChains) {
emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolChain->compilerCommand().toUserOutput()));
toolChain->setDetectionSource(m_sharedId);
ToolChainManager::registerToolChain(toolChain);
@@ -359,11 +359,11 @@ void KitDetectorPrivate::autoDetect()
QtSupport::QtKitAspect::setQtVersion(k, qt);
}
Toolchains toolchainsToSet;
toolchainsToSet = ToolChainManager::toolchains([qt, this](const ToolChain *tc) {
toolchainsToSet = ToolChainManager::toolchains([qt, this](const Toolchain *tc) {
return tc->detectionSource() == m_sharedId
&& (!qt || qt->qtAbis().contains(tc->targetAbi()));
});
for (ToolChain *toolChain : toolchainsToSet)
for (Toolchain *toolChain : toolchainsToSet)
ToolChainKitAspect::setToolChain(k, toolChain);
if (cmakeId.isValid())

2
src/plugins/incredibuild/makecommandbuilder.cpp
View File

@@ -37,7 +37,7 @@ FilePath MakeCommandBuilder::defaultCommand() const
{
if (BuildConfiguration *buildConfig = buildStep()->buildConfiguration()) {
if (Target *target = buildStep()->target()) {
if (ToolChain *toolChain = ToolChainKitAspect::cxxToolChain(target->kit()))
if (Toolchain *toolChain = ToolChainKitAspect::cxxToolChain(target->kit()))
return toolChain->makeCommand(buildConfig->environment());
}
}

4
src/plugins/ios/iosbuildstep.cpp
View File

@@ -148,7 +148,7 @@ bool IosBuildStep::init()
if (!AbstractProcessStep::init())
return false;
ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit());
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit());
if (!tc) {
emit addTask(Task::compilerMissingTask());
emitFaultyConfigurationMessage();
@@ -195,7 +195,7 @@ QStringList IosBuildStep::defaultArguments() const
{
QStringList res;
Kit *kit = target()->kit();
ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit);
switch (buildConfiguration()->buildType()) {
case BuildConfiguration::Debug :
res << "-configuration" << "Debug";

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

@@ -101,7 +101,7 @@ static bool isSimulatorDeviceId(const Id &id)
static QList<GccToolChain *> clangToolChains(const Toolchains &toolChains)
{
QList<GccToolChain *> clangToolChains;
for (ToolChain *toolChain : toolChains)
for (Toolchain *toolChain : toolChains)
if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
clangToolChains.append(static_cast<GccToolChain *>(toolChain));
return clangToolChains;
@@ -593,8 +593,8 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
if (!toolChain) {
toolChain = new GccToolChain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID,
GccToolChain::Clang);
toolChain->setPriority(ToolChain::PriorityHigh);
toolChain->setDetection(ToolChain::AutoDetection);
toolChain->setPriority(Toolchain::PriorityHigh);
toolChain->setDetection(Toolchain::AutoDetection);
toolChain->setLanguage(l);
toolChain->setDisplayName(target.name);
toolChain->setPlatformCodeGenFlags(target.backendFlags);

30
src/plugins/mcusupport/mcupackage.cpp
View File

@@ -364,9 +364,9 @@ bool McuToolChainPackage::isDesktopToolchain() const
|| m_type == ToolChainType::MinGW;
}
ToolChain *McuToolChainPackage::msvcToolChain(Id language)
Toolchain *McuToolChainPackage::msvcToolChain(Id language)
{
ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
Toolchain *toolChain = ToolChainManager::toolChain([language](const Toolchain *t) {
const Abi abi = t->targetAbi();
return abi.osFlavor() == Abi::WindowsMsvc2019Flavor
&& abi.architecture() == Abi::X86Architecture && abi.wordWidth() == 64
@@ -376,9 +376,9 @@ ToolChain *McuToolChainPackage::msvcToolChain(Id language)
return toolChain;
}
ToolChain *McuToolChainPackage::gccToolChain(Id language)
Toolchain *McuToolChainPackage::gccToolChain(Id language)
{
ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
Toolchain *toolChain = ToolChainManager::toolChain([language](const Toolchain *t) {
const Abi abi = t->targetAbi();
return abi.os() != Abi::WindowsOS && abi.architecture() == Abi::X86Architecture
&& abi.wordWidth() == 64 && t->language() == language;
@@ -386,9 +386,9 @@ ToolChain *McuToolChainPackage::gccToolChain(Id language)
return toolChain;
}
static ToolChain *mingwToolChain(const FilePath &path, Id language)
static Toolchain *mingwToolChain(const FilePath &path, Id language)
{
ToolChain *toolChain = ToolChainManager::toolChain([&path, language](const ToolChain *t) {
Toolchain *toolChain = ToolChainManager::toolChain([&path, language](const Toolchain *t) {
// find a MinGW toolchain having the same path from registered toolchains
const Abi abi = t->targetAbi();
return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID
@@ -398,7 +398,7 @@ static ToolChain *mingwToolChain(const FilePath &path, Id language)
if (!toolChain) {
// if there's no MinGW toolchain having the same path,
// a proper MinGW would be selected from the registered toolchains.
toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
toolChain = ToolChainManager::toolChain([language](const Toolchain *t) {
const Abi abi = t->targetAbi();
return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID
&& abi.architecture() == Abi::X86Architecture && abi.wordWidth() == 64
@@ -408,9 +408,9 @@ static ToolChain *mingwToolChain(const FilePath &path, Id language)
return toolChain;
}
static ToolChain *armGccToolChain(const FilePath &path, Id language)
static Toolchain *armGccToolChain(const FilePath &path, Id language)
{
ToolChain *toolChain = ToolChainManager::toolChain([&path, language](const ToolChain *t) {
Toolchain *toolChain = ToolChainManager::toolChain([&path, language](const Toolchain *t) {
return t->compilerCommand() == path && t->language() == language;
});
if (!toolChain) {
@@ -421,10 +421,10 @@ static ToolChain *armGccToolChain(const FilePath &path, Id language)
== ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID;
});
if (gccFactory) {
const QList<ToolChain *> detected = gccFactory->detectForImport({path, language});
const QList<Toolchain *> detected = gccFactory->detectForImport({path, language});
if (!detected.isEmpty()) {
toolChain = detected.first();
toolChain->setDetection(ToolChain::ManualDetection);
toolChain->setDetection(Toolchain::ManualDetection);
toolChain->setDisplayName("Arm GCC");
ToolChainManager::registerToolChain(toolChain);
}
@@ -434,9 +434,9 @@ static ToolChain *armGccToolChain(const FilePath &path, Id language)
return toolChain;
}
static ToolChain *iarToolChain(const FilePath &path, Id language)
static Toolchain *iarToolChain(const FilePath &path, Id language)
{
ToolChain *toolChain = ToolChainManager::toolChain([language](const ToolChain *t) {
Toolchain *toolChain = ToolChainManager::toolChain([language](const Toolchain *t) {
return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID
&& t->language() == language;
});
@@ -455,7 +455,7 @@ static ToolChain *iarToolChain(const FilePath &path, Id language)
for (auto tc : detected) {
if (tc->language() == language) {
toolChain = tc;
toolChain->setDetection(ToolChain::ManualDetection);
toolChain->setDetection(Toolchain::ManualDetection);
toolChain->setDisplayName("IAREW");
ToolChainManager::registerToolChain(toolChain);
}
@@ -466,7 +466,7 @@ static ToolChain *iarToolChain(const FilePath &path, Id language)
return toolChain;
}
ToolChain *McuToolChainPackage::toolChain(Id language) const
Toolchain *McuToolChainPackage::toolChain(Id language) const
{
switch (m_type) {
case ToolChainType::MSVC:

8
src/plugins/mcusupport/mcupackage.h
View File

@@ -13,7 +13,7 @@
#include <QObject>
namespace ProjectExplorer {
class ToolChain;
class Toolchain;
}
namespace Utils {
@@ -116,12 +116,12 @@ public:
ToolChainType toolchainType() const;
bool isDesktopToolchain() const;
ProjectExplorer::ToolChain *toolChain(Utils::Id language) const;
ProjectExplorer::Toolchain *toolChain(Utils::Id language) const;
QString toolChainName() const;
QVariant debuggerId() const;
static ProjectExplorer::ToolChain *msvcToolChain(Utils::Id language);
static ProjectExplorer::ToolChain *gccToolChain(Utils::Id language);
static ProjectExplorer::Toolchain *msvcToolChain(Utils::Id language);
static ProjectExplorer::Toolchain *gccToolChain(Utils::Id language);
private:
const ToolChainType m_type;

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

@@ -21,7 +21,7 @@ class InfoLabel;
namespace ProjectExplorer {
class Kit;
class ToolChain;
class Toolchain;
} // namespace ProjectExplorer
namespace McuSupport {

8
src/plugins/mcusupport/mcusupportsdk.cpp
View File

@@ -184,7 +184,7 @@ McuToolChainPackagePtr createUnsupportedToolChainPackage(const SettingsHandler::
McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
const QStringList &versions)
{
ToolChain *toolChain = McuToolChainPackage::msvcToolChain(
Toolchain *toolChain = McuToolChainPackage::msvcToolChain(
ProjectExplorer::Constants::CXX_LANGUAGE_ID);
const FilePath detectionPath = FilePath("cl").withExecutableSuffix();
@@ -209,7 +209,7 @@ McuToolChainPackagePtr createMsvcToolChainPackage(const SettingsHandler::Ptr &se
McuToolChainPackagePtr createGccToolChainPackage(const SettingsHandler::Ptr &settingsHandler,
const QStringList &versions)
{
ToolChain *toolChain = McuToolChainPackage::gccToolChain(
Toolchain *toolChain = McuToolChainPackage::gccToolChain(
ProjectExplorer::Constants::CXX_LANGUAGE_ID);
const FilePath detectionPath = FilePath("bin/g++").withExecutableSuffix();
@@ -328,8 +328,8 @@ McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &set
if (qtcEnvironmentVariableIsSet(envVar))
defaultPath = FilePath::fromUserInput(qtcEnvironmentVariable(envVar));
else {
const ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainManager::toolChain(
[](const ProjectExplorer::ToolChain *t) {
const ProjectExplorer::Toolchain *tc = ProjectExplorer::ToolChainManager::toolChain(
[](const ProjectExplorer::Toolchain *t) {
return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID;
});
if (tc) {

2
src/plugins/mcusupport/mcutarget.h
View File

@@ -9,7 +9,7 @@
#include <QVersionNumber>
namespace ProjectExplorer {
class ToolChain;
class Toolchain;
}
namespace Utils {

8
src/plugins/mcusupport/test/unittest.cpp
View File

@@ -70,7 +70,7 @@ using Legacy::Constants::TOOLCHAIN_FILE_CMAKE_VARIABLE;
using CMakeProjectManager::CMakeConfigurationKitAspect;
using ProjectExplorer::Kit;
using ProjectExplorer::KitManager;
using ProjectExplorer::ToolChain;
using ProjectExplorer::Toolchain;
using ProjectExplorer::ToolChainManager;
using testing::_;
@@ -214,7 +214,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
{
ProjectExplorer::ToolchainFactory toolchainFactory;
Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID};
ToolChain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolChain(iarId)};
Toolchain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolChain(iarId)};
iarToolchain->setLanguage(cxxLanguageId);
ToolChainManager::registerToolChain(iarToolchain);
@@ -229,7 +229,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
iarToolchain = iarToolchainPackage->toolChain(cxxLanguageId);
QVERIFY(iarToolchain != nullptr);
QCOMPARE(iarToolchain->displayName(), "IAREW");
QCOMPARE(iarToolchain->detection(), ToolChain::UninitializedDetection);
QCOMPARE(iarToolchain->detection(), Toolchain::UninitializedDetection);
}
void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QStringList &versions)
@@ -238,7 +238,7 @@ void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QS
ProjectExplorer::ToolchainFactory toolchainFactory;
Id armGccId{ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID};
ToolChain *armToolchain{ProjectExplorer::ToolchainFactory::createToolChain(armGccId)};
Toolchain *armToolchain{ProjectExplorer::ToolchainFactory::createToolChain(armGccId)};
armToolchain->setLanguage(cxxLanguageId);
ToolChainManager::registerToolChain(armToolchain);

6
src/plugins/mesonprojectmanager/mesonprojectparser.cpp
View File

@@ -254,8 +254,8 @@ void MesonProjectParser::update(const QFuture<MesonProjectParser::ParserData *>
RawProjectPart MesonProjectParser::buildRawPart(
const Target &target,
const Target::SourceGroup &sources,
const ToolChain *cxxToolChain,
const ToolChain *cToolChain)
const Toolchain *cxxToolChain,
const Toolchain *cToolChain)
{
RawProjectPart part;
part.setDisplayName(target.name);
@@ -274,7 +274,7 @@ RawProjectPart MesonProjectParser::buildRawPart(
}
RawProjectParts MesonProjectParser::buildProjectParts(
const ToolChain *cxxToolChain, const ToolChain *cToolChain)
const Toolchain *cxxToolChain, const Toolchain *cToolChain)
{
RawProjectParts parts;
for_each_source_group(m_parserResult.targets,

8
src/plugins/mesonprojectmanager/mesonprojectparser.h
View File

@@ -57,8 +57,8 @@ public:
QList<ProjectExplorer::BuildTargetInfo> appsTargets() const;
ProjectExplorer::RawProjectParts buildProjectParts(
const ProjectExplorer::ToolChain *cxxToolChain,
const ProjectExplorer::ToolChain *cToolChain);
const ProjectExplorer::Toolchain *cxxToolChain,
const ProjectExplorer::Toolchain *cToolChain);
void setEnvironment(const Utils::Environment &environment) { m_env = environment; }
@@ -78,8 +78,8 @@ private:
void update(const QFuture<ParserData *> &data);
ProjectExplorer::RawProjectPart buildRawPart(const Target &target,
const Target::SourceGroup &sources,
const ProjectExplorer::ToolChain *cxxToolChain,
const ProjectExplorer::ToolChain *cToolChain);
const ProjectExplorer::Toolchain *cxxToolChain,
const ProjectExplorer::Toolchain *cToolChain);
MesonOutputParser m_outputParser;
Utils::Environment m_env;

18
src/plugins/nim/project/nimtoolchain.cpp
View File

@@ -32,7 +32,7 @@ NimToolChain::NimToolChain()
{}
NimToolChain::NimToolChain(Utils::Id typeId)
: ToolChain(typeId)
: Toolchain(typeId)
, m_version(std::make_tuple(-1,-1,-1))
{
setLanguage(Constants::C_NIMLANGUAGE_ID);
@@ -41,9 +41,9 @@ NimToolChain::NimToolChain(Utils::Id typeId)
setCompilerCommandKey("Nim.NimToolChain.CompilerCommand");
}
ToolChain::MacroInspectionRunner NimToolChain::createMacroInspectionRunner() const
Toolchain::MacroInspectionRunner NimToolChain::createMacroInspectionRunner() const
{
return ToolChain::MacroInspectionRunner();
return Toolchain::MacroInspectionRunner();
}
LanguageExtensions NimToolChain::languageExtensions(const QStringList &) const
@@ -56,10 +56,10 @@ WarningFlags NimToolChain::warningFlags(const QStringList &) const
return WarningFlags::NoWarnings;
}
ToolChain::BuiltInHeaderPathsRunner NimToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner NimToolChain::createBuiltInHeaderPathsRunner(
const Environment &) const
{
return ToolChain::BuiltInHeaderPathsRunner();
return Toolchain::BuiltInHeaderPathsRunner();
}
void NimToolChain::addToEnvironment(Environment &env) const
@@ -91,7 +91,7 @@ QString NimToolChain::compilerVersion() const
void NimToolChain::fromMap(const Store &data)
{
ToolChain::fromMap(data);
Toolchain::fromMap(data);
if (hasError())
return;
parseVersion(compilerCommand(), m_version);
@@ -220,7 +220,7 @@ Toolchains NimToolchainFactory::autoDetect(const ToolchainDetector &detector) co
if (compilerPath.isEmpty())
return result;
result = Utils::filtered(detector.alreadyKnown, [compilerPath](ToolChain *tc) {
result = Utils::filtered(detector.alreadyKnown, [compilerPath](Toolchain *tc) {
return tc->typeId() == Constants::C_NIMTOOLCHAIN_TYPEID
&& tc->compilerCommand() == compilerPath;
});
@@ -229,7 +229,7 @@ Toolchains NimToolchainFactory::autoDetect(const ToolchainDetector &detector) co
return result;
auto tc = new NimToolChain;
tc->setDetection(ToolChain::AutoDetection);
tc->setDetection(Toolchain::AutoDetection);
tc->setCompilerCommand(compilerPath);
result.append(tc);
return result;
@@ -240,7 +240,7 @@ Toolchains NimToolchainFactory::detectForImport(const ToolChainDescription &tcd)
Toolchains result;
if (tcd.language == Constants::C_NIMLANGUAGE_ID) {
auto tc = new NimToolChain;
tc->setDetection(ToolChain::ManualDetection); // FIXME: sure?
tc->setDetection(Toolchain::ManualDetection); // FIXME: sure?
tc->setCompilerCommand(tcd.compilerPath);
result.append(tc);
}

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

@@ -8,7 +8,7 @@
namespace Nim {
class NimToolChain : public ProjectExplorer::ToolChain
class NimToolChain : public ProjectExplorer::Toolchain
{
public:
NimToolChain();

20
src/plugins/projectexplorer/customtoolchain.cpp
View File

@@ -44,11 +44,11 @@ const char outputParserKeyC[] = "ProjectExplorer.CustomToolChain.OutputParser";
// CustomToolChain
// --------------------------------------------------------------------------
class CustomToolChain : public ToolChain
class CustomToolChain : public Toolchain
{
public:
CustomToolChain()
: ToolChain(Constants::CUSTOM_TOOLCHAIN_TYPEID)
: Toolchain(Constants::CUSTOM_TOOLCHAIN_TYPEID)
, m_outputParserId(GccParser::id())
{
setTypeDisplayName(Tr::tr("Custom"));
@@ -82,7 +82,7 @@ public:
std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() override;
bool operator ==(const ToolChain &) const override;
bool operator ==(const Toolchain &) const override;
void setMakeCommand(const FilePath &);
FilePath makeCommand(const Environment &environment) const override;
@@ -123,7 +123,7 @@ bool CustomToolChain::isValid() const
return true;
}
ToolChain::MacroInspectionRunner CustomToolChain::createMacroInspectionRunner() const
Toolchain::MacroInspectionRunner CustomToolChain::createMacroInspectionRunner() const
{
const Macros theMacros = m_predefinedMacros;
const Id lang = language();
@@ -138,7 +138,7 @@ ToolChain::MacroInspectionRunner CustomToolChain::createMacroInspectionRunner()
macros.append({cxxFlag.mid(2).trimmed().toUtf8(), MacroType::Undefine});
}
return MacroInspectionReport{macros, ToolChain::languageVersion(lang, macros)};
return MacroInspectionReport{macros, Toolchain::languageVersion(lang, macros)};
};
}
@@ -166,7 +166,7 @@ void CustomToolChain::setPredefinedMacros(const Macros &macros)
toolChainUpdated();
}
ToolChain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRunner(
const Environment &) const
{
const HeaderPaths builtInHeaderPaths = m_builtInHeaderPaths;
@@ -273,7 +273,7 @@ QString CustomToolChain::mkspecs() const
void CustomToolChain::toMap(Store &data) const
{
ToolChain::toMap(data);
Toolchain::toMap(data);
data.insert(makeCommandKeyC, m_makeCommand.toString());
QStringList macros = Utils::transform<QList>(m_predefinedMacros, [](const Macro &m) { return QString::fromUtf8(m.toByteArray()); });
data.insert(predefinedMacrosKeyC, macros);
@@ -285,7 +285,7 @@ void CustomToolChain::toMap(Store &data) const
void CustomToolChain::fromMap(const Store &data)
{
ToolChain::fromMap(data);
Toolchain::fromMap(data);
if (hasError())
return;
@@ -298,9 +298,9 @@ void CustomToolChain::fromMap(const Store &data)
setOutputParserId(Id::fromSetting(data.value(outputParserKeyC)));
}
bool CustomToolChain::operator ==(const ToolChain &other) const
bool CustomToolChain::operator ==(const Toolchain &other) const
{
if (!ToolChain::operator ==(other))
if (!Toolchain::operator ==(other))
return false;
auto customTc = static_cast<const CustomToolChain *>(&other);

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

@@ -363,7 +363,7 @@ static Id idForSubType(GccToolChain::SubType subType)
}
GccToolChain::GccToolChain(Id typeId, SubType subType)
: ToolChain(typeId.isValid() ? typeId : idForSubType(subType)), m_subType(subType)
: Toolchain(typeId.isValid() ? typeId : idForSubType(subType)), m_subType(subType)
{
setTypeDisplayName(Tr::tr("GCC"));
setTargetAbiKey(targetAbiKeyC);
@@ -437,7 +437,7 @@ LanguageExtensions GccToolChain::defaultLanguageExtensions() const
static const Toolchains mingwToolChains()
{
return ToolChainManager::toolchains([](const ToolChain *tc) -> bool {
return ToolChainManager::toolchains([](const Toolchain *tc) -> bool {
return tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID;
});
}
@@ -447,7 +447,7 @@ static const GccToolChain *mingwToolChainFromId(const QByteArray &id)
if (id.isEmpty())
return nullptr;
for (const ToolChain *tc : mingwToolChains()) {
for (const Toolchain *tc : mingwToolChains()) {
if (tc->id() == id)
return static_cast<const GccToolChain *>(tc);
}
@@ -546,7 +546,7 @@ static QStringList filteredFlags(const QStringList &allFlags, bool considerSysro
return filtered;
}
ToolChain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() const
Toolchain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() const
{
// Using a clean environment breaks ccache/distcc/etc.
Environment env = compilerCommand().deviceEnvironment();
@@ -702,7 +702,7 @@ WarningFlags GccToolChain::warningFlags(const QStringList &cflags) const
FilePaths GccToolChain::includedFiles(const QStringList &flags, const FilePath &directoryPath) const
{
return ToolChain::includedFiles("-include", flags, directoryPath, PossiblyConcatenatedFlag::No);
return Toolchain::includedFiles("-include", flags, directoryPath, PossiblyConcatenatedFlag::No);
}
static QStringList gccPrepareArguments(const QStringList &flags,
@@ -770,7 +770,7 @@ HeaderPaths GccToolChain::builtInHeaderPaths(const Environment &env,
return paths;
}
ToolChain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner GccToolChain::createBuiltInHeaderPathsRunner(
const Environment &env) const
{
// Using a clean environment breaks ccache/distcc/etc.
@@ -866,7 +866,7 @@ QStringList GccToolChain::suggestedMkspecList() const
}
if (m_subType == Clang) {
if (const ToolChain * const parentTc = ToolChainManager::findToolChain(m_parentToolChainId))
if (const Toolchain * const parentTc = ToolChainManager::findToolChain(m_parentToolChainId))
return parentTc->suggestedMkspecList();
const Abi abi = targetAbi();
if (abi.os() == Abi::DarwinOS)
@@ -1014,7 +1014,7 @@ QStringList GccToolChain::platformLinkerFlags() const
void GccToolChain::toMap(Store &data) const
{
ToolChain::toMap(data);
Toolchain::toMap(data);
data.insert(compilerPlatformCodeGenFlagsKeyC, m_platformCodeGenFlags);
data.insert(compilerPlatformLinkerFlagsKeyC, m_platformLinkerFlags);
data.insert(originalTargetTripleKeyC, m_originalTargetTriple);
@@ -1028,7 +1028,7 @@ void GccToolChain::toMap(Store &data) const
void GccToolChain::fromMap(const Store &data)
{
ToolChain::fromMap(data);
Toolchain::fromMap(data);
if (hasError())
return;
@@ -1051,9 +1051,9 @@ void GccToolChain::fromMap(const Store &data)
}
}
bool GccToolChain::operator ==(const ToolChain &other) const
bool GccToolChain::operator ==(const Toolchain &other) const
{
if (!ToolChain::operator ==(other))
if (!Toolchain::operator ==(other))
return false;
auto gccTc = static_cast<const GccToolChain *>(&other);
@@ -1254,22 +1254,22 @@ static Utils::FilePaths renesasRl78SearchPathsFromRegistry()
return searchPaths;
}
static ToolChain *constructRealGccToolchain()
static Toolchain *constructRealGccToolchain()
{
return new GccToolChain(Constants::GCC_TOOLCHAIN_TYPEID, GccToolChain::RealGcc);
}
static ToolChain *constructClangToolchain()
static Toolchain *constructClangToolchain()
{
return new GccToolChain(Constants::CLANG_TOOLCHAIN_TYPEID, GccToolChain::Clang);
}
static ToolChain *constructMinGWToolchain()
static Toolchain *constructMinGWToolchain()
{
return new GccToolChain(Constants::MINGW_TOOLCHAIN_TYPEID, GccToolChain::MinGW);
}
static ToolChain *constructLinuxIccToolchain()
static Toolchain *constructLinuxIccToolchain()
{
return new GccToolChain(Constants::LINUXICC_TOOLCHAIN_TYPEID, GccToolChain::LinuxIcc);
}
@@ -1557,7 +1557,7 @@ Toolchains GccToolchainFactory::autoDetectSdkClangToolchain(const Toolchains &kn
if (compilerPath.isEmpty())
return {};
for (ToolChain * const existingTc : known) {
for (Toolchain * const existingTc : known) {
if (existingTc->compilerCommand() == compilerPath)
return {existingTc};
}
@@ -1572,12 +1572,12 @@ Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPa
const GccToolChain::SubType subType)
{
Toolchains existingCandidates = filtered(known,
[language](const ToolChain *tc) { return tc->language() == language; });
[language](const Toolchain *tc) { return tc->language() == language; });
Toolchains result;
for (const FilePath &compilerPath : std::as_const(compilerPaths)) {
bool alreadyExists = false;
for (ToolChain * const existingTc : existingCandidates) {
for (Toolchain * const existingTc : existingCandidates) {
// We have a match if the existing toolchain ultimately refers to the same file
// as the candidate path, either directly or via a hard or soft link.
// Exceptions:
@@ -1644,11 +1644,11 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolChainDescription &
auto tc = new GccToolChain({}, detectedSubType);
tc->setLanguage(tcd.language);
tc->setDetection(ToolChain::AutoDetection);
tc->setDetection(Toolchain::AutoDetection);
tc->predefinedMacrosCache()
->insert(QStringList(),
ToolChain::MacroInspectionReport{macros,
ToolChain::languageVersion(tcd.language, macros)});
Toolchain::MacroInspectionReport{macros,
Toolchain::languageVersion(tcd.language, macros)});
tc->setCompilerCommand(tcd.compilerPath);
tc->setSupportedAbis(detectedAbis.supportedAbis);
tc->setTargetAbi(abi);
@@ -1656,7 +1656,7 @@ Toolchains GccToolchainFactory::autoDetectToolChain(const ToolChainDescription &
tc->setDisplayName(tc->defaultDisplayName()); // reset displayname
// lower priority of g++/gcc on macOS - usually just a frontend to clang
if (detectedSubType == GccToolChain::RealGcc && abi.binaryFormat() == Abi::MachOFormat)
tc->setPriority(ToolChain::PriorityLow);
tc->setPriority(Toolchain::PriorityLow);
result.append(tc);
}
return result;
@@ -1671,7 +1671,7 @@ class TargetTripleWidget : public QWidget
Q_OBJECT
public:
TargetTripleWidget(const ToolChain *toolchain)
TargetTripleWidget(const Toolchain *toolchain)
{
const auto layout = new QHBoxLayout(this);
layout->setContentsMargins(0, 0, 0, 0);
@@ -1759,17 +1759,17 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
ToolChainManager *tcManager = ToolChainManager::instance();
m_parentToolChainConnections.append(
connect(tcManager, &ToolChainManager::toolChainUpdated, this, [this](ToolChain *tc) {
connect(tcManager, &ToolChainManager::toolChainUpdated, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
updateParentToolChainComboBox();
}));
m_parentToolChainConnections.append(
connect(tcManager, &ToolChainManager::toolChainAdded, this, [this](ToolChain *tc) {
connect(tcManager, &ToolChainManager::toolChainAdded, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
updateParentToolChainComboBox();
}));
m_parentToolChainConnections.append(
connect(tcManager, &ToolChainManager::toolChainRemoved, this, [this](ToolChain *tc) {
connect(tcManager, &ToolChainManager::toolChainRemoved, this, [this](Toolchain *tc) {
if (tc->id() == toolChain()->id()) {
for (QMetaObject::Connection &connection : m_parentToolChainConnections)
QObject::disconnect(connection);
@@ -1808,8 +1808,8 @@ void GccToolChainConfigWidget::applyImpl()
tc->predefinedMacrosCache()
->insert(tc->platformCodeGenFlags(),
ToolChain::MacroInspectionReport{m_macros,
ToolChain::languageVersion(tc->language(),
Toolchain::MacroInspectionReport{m_macros,
Toolchain::languageVersion(tc->language(),
m_macros)});
if (m_subType == GccToolChain::Clang && m_parentToolchainCombo) {
@@ -1818,7 +1818,7 @@ void GccToolChainConfigWidget::applyImpl()
const QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
if (!parentId.isEmpty()) {
for (const ToolChain *mingwTC : mingwToolChains()) {
for (const Toolchain *mingwTC : mingwToolChains()) {
if (parentId == mingwTC->id()) {
tc->m_parentToolChainId = mingwTC->id();
tc->setTargetAbi(mingwTC->targetAbi());
@@ -1959,7 +1959,7 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
if (!ToolChainManager::isLoaded()) {
connect(ToolChainManager::instance(), &ToolChainManager::toolChainsLoaded, this,
[id = id()] {
if (ToolChain * const tc = ToolChainManager::findToolChain(id)) {
if (Toolchain * const tc = ToolChainManager::findToolChain(id)) {
if (tc->typeId() == Constants::CLANG_TOOLCHAIN_TYPEID)
static_cast<GccToolChain *>(tc)->syncAutodetectedWithParentToolchains();
}
@@ -1975,14 +1975,14 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
// Subscribe only autodetected toolchains.
ToolChainManager *tcManager = ToolChainManager::instance();
m_mingwToolchainAddedConnection
= connect(tcManager, &ToolChainManager::toolChainAdded, this, [this](ToolChain *tc) {
= connect(tcManager, &ToolChainManager::toolChainAdded, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID
&& !mingwToolChainFromId(m_parentToolChainId)) {
m_parentToolChainId = tc->id();
}
});
m_thisToolchainRemovedConnection
= connect(tcManager, &ToolChainManager::toolChainRemoved, this, [this](ToolChain *tc) {
= connect(tcManager, &ToolChainManager::toolChainRemoved, this, [this](Toolchain *tc) {
if (tc == this) {
QObject::disconnect(m_thisToolchainRemovedConnection);
QObject::disconnect(m_mingwToolchainAddedConnection);
@@ -2012,7 +2012,7 @@ bool GccToolChain::matchesCompilerCommand(const FilePath &command) const
&& m_resolvedCompilerCommand->isSameExecutable(command))
return true;
}
return ToolChain::matchesCompilerCommand(command);
return Toolchain::matchesCompilerCommand(command);
}
QString GccToolChain::sysRoot() const
@@ -2044,7 +2044,7 @@ void GccToolChainConfigWidget::updateParentToolChainComboBox()
if (tc->isAutoDetected())
return;
for (const ToolChain *mingwTC : mingwToolChains()) {
for (const Toolchain *mingwTC : mingwToolChains()) {
if (mingwTC->id() == parentId)
continue;
if (mingwTC->language() != tc->language())

4
src/plugins/projectexplorer/gcctoolchain.h
View File

@@ -26,7 +26,7 @@ const QStringList gccPredefinedMacrosOptions(Utils::Id languageId);
// GccToolChain
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT GccToolChain : public ToolChain
class PROJECTEXPLORER_EXPORT GccToolChain : public Toolchain
{
public:
enum SubType { RealGcc, Clang, MinGW, LinuxIcc };
@@ -57,7 +57,7 @@ public:
std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() override;
bool operator ==(const ToolChain &) const override;
bool operator ==(const Toolchain &) const override;
void resetToolChain(const Utils::FilePath &);
void setPlatformCodeGenFlags(const QStringList &);

86
src/plugins/projectexplorer/kitaspects.cpp
View File

@@ -160,7 +160,7 @@ FilePath SysRootKitAspect::sysRoot(const Kit *k)
if (!k->value(SysRootKitAspect::id()).toString().isEmpty())
return FilePath::fromSettings(k->value(SysRootKitAspect::id()));
for (ToolChain *tc : ToolChainKitAspect::toolChains(k)) {
for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) {
if (!tc->sysRoot().isEmpty())
return FilePath::fromString(tc->sysRoot());
}
@@ -172,7 +172,7 @@ void SysRootKitAspect::setSysRoot(Kit *k, const FilePath &v)
if (!k)
return;
for (ToolChain *tc : ToolChainKitAspect::toolChains(k)) {
for (Toolchain *tc : ToolChainKitAspect::toolChains(k)) {
if (!tc->sysRoot().isEmpty()) {
// It's the sysroot from toolchain, don't set it.
if (tc->sysRoot() == v.toString())
@@ -249,26 +249,26 @@ private:
const GuardLocker locker(m_ignoreChanges);
const QList<Id> keys = m_languageComboboxMap.keys();
for (const Id l : keys) {
const Toolchains ltcList = ToolChainManager::toolchains(equal(&ToolChain::language, l));
const Toolchains ltcList = ToolChainManager::toolchains(equal(&Toolchain::language, l));
QComboBox *cb = m_languageComboboxMap.value(l);
cb->clear();
cb->addItem(Tr::tr("<No compiler>"), QByteArray());
const QList<ToolChain *> same = Utils::filtered(ltcList, [device](ToolChain *tc) {
const QList<Toolchain *> same = Utils::filtered(ltcList, [device](Toolchain *tc) {
return tc->compilerCommand().isSameDevice(device->rootPath());
});
const QList<ToolChain *> other = Utils::filtered(ltcList, [device](ToolChain *tc) {
const QList<Toolchain *> other = Utils::filtered(ltcList, [device](Toolchain *tc) {
return !tc->compilerCommand().isSameDevice(device->rootPath());
});
for (ToolChain *item : same)
for (Toolchain *item : same)
cb->addItem(item->displayName(), item->id());
if (!same.isEmpty() && !other.isEmpty())
cb->insertSeparator(cb->count());
for (ToolChain *item : other)
for (Toolchain *item : other)
cb->addItem(item->displayName(), item->id());
cb->setEnabled(cb->count() > 1 && !m_isReadOnly);
@@ -292,7 +292,7 @@ private:
return;
const QByteArray id = m_languageComboboxMap.value(language)->itemData(idx).toByteArray();
ToolChain *tc = ToolChainManager::findToolChain(id);
Toolchain *tc = ToolChainManager::findToolChain(id);
QTC_ASSERT(!tc || tc->language() == language, return);
if (tc)
ToolChainKitAspect::setToolChain(m_kit, tc);
@@ -300,7 +300,7 @@ private:
ToolChainKitAspect::clearToolChain(m_kit, language);
}
int indexOf(QComboBox *cb, const ToolChain *tc)
int indexOf(QComboBox *cb, const Toolchain *tc)
{
const QByteArray id = tc ? tc->id() : QByteArray();
for (int i = 0; i < cb->count(); ++i) {
@@ -342,8 +342,8 @@ private:
void onKitsLoaded() override;
void toolChainUpdated(ToolChain *tc);
void toolChainRemoved(ToolChain *tc);
void toolChainUpdated(Toolchain *tc);
void toolChainRemoved(Toolchain *tc);
};
ToolChainKitAspectFactory::ToolChainKitAspectFactory()
@@ -361,10 +361,10 @@ static QMap<Id, QByteArray> defaultToolChainIds()
{
QMap<Id, QByteArray> toolChains;
const Abi abi = Abi::hostAbi();
const Toolchains tcList = ToolChainManager::toolchains(equal(&ToolChain::targetAbi, abi));
const Toolchains tcList = ToolChainManager::toolchains(equal(&Toolchain::targetAbi, abi));
const QList<Id> languages = ToolChainManager::allLanguages();
for (Id l : languages) {
ToolChain *tc = findOrDefault(tcList, equal(&ToolChain::language, l));
Toolchain *tc = findOrDefault(tcList, equal(&Toolchain::language, l));
toolChains.insert(l, tc ? tc->id() : QByteArray());
}
return toolChains;
@@ -384,12 +384,12 @@ Tasks ToolChainKitAspectFactory::validate(const Kit *k) const
{
Tasks result;
const QList<ToolChain*> tcList = ToolChainKitAspect::toolChains(k);
const QList<Toolchain*> tcList = ToolChainKitAspect::toolChains(k);
if (tcList.isEmpty()) {
result << BuildSystemTask(Task::Warning, ToolChainKitAspect::msgNoToolChainInTarget());
} else {
QSet<Abi> targetAbis;
for (const ToolChain *tc : tcList) {
for (const Toolchain *tc : tcList) {
targetAbis.insert(tc->targetAbi());
result << tc->validateKit(k);
}
@@ -443,18 +443,18 @@ void ToolChainKitAspectFactory::setup(Kit *k)
}
const QByteArray id = i.value().toByteArray();
ToolChain *tc = ToolChainManager::findToolChain(id);
Toolchain *tc = ToolChainManager::findToolChain(id);
if (tc)
continue;
// ID is not found: Might be an ABI string...
lockToolchains = false;
const QString abi = QString::fromUtf8(id);
const Toolchains possibleTcs = ToolChainManager::toolchains([abi, l](const ToolChain *t) {
const Toolchains possibleTcs = ToolChainManager::toolchains([abi, l](const Toolchain *t) {
return t->targetAbi().toString() == abi && t->language() == l;
});
ToolChain *bestTc = nullptr;
for (ToolChain *tc : possibleTcs) {
Toolchain *bestTc = nullptr;
for (Toolchain *tc : possibleTcs) {
if (!bestTc || tc->priority() > bestTc->priority())
bestTc = tc;
}
@@ -475,19 +475,19 @@ KitAspect *ToolChainKitAspectFactory::createKitAspect(Kit *k) const
QString ToolChainKitAspectFactory::displayNamePostfix(const Kit *k) const
{
ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
return tc ? tc->displayName() : QString();
}
KitAspectFactory::ItemList ToolChainKitAspectFactory::toUserOutput(const Kit *k) const
{
ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
return {{Tr::tr("Compiler"), tc ? tc->displayName() : Tr::tr("None")}};
}
void ToolChainKitAspectFactory::addToBuildEnvironment(const Kit *k, Environment &env) const
{
ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
if (tc)
tc->addToEnvironment(env);
}
@@ -499,25 +499,25 @@ void ToolChainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expa
// Compatibility with Qt Creator < 4.2:
expander->registerVariable("Compiler:Name", Tr::tr("Compiler"),
[kit] {
const ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit);
const Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit);
return tc ? tc->displayName() : Tr::tr("None");
});
expander->registerVariable("Compiler:Executable", Tr::tr("Path to the compiler executable"),
[kit] {
const ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit);
const Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit);
return tc ? tc->compilerCommand().path() : QString();
});
// After 4.2
expander->registerPrefix("Compiler:Name", Tr::tr("Compiler for different languages"),
[kit](const QString &ls) {
const ToolChain *tc = ToolChainKitAspect::toolChain(kit, findLanguage(ls));
const Toolchain *tc = ToolChainKitAspect::toolChain(kit, findLanguage(ls));
return tc ? tc->displayName() : Tr::tr("None");
});
expander->registerPrefix("Compiler:Executable", Tr::tr("Compiler executable for different languages"),
[kit](const QString &ls) {
const ToolChain *tc = ToolChainKitAspect::toolChain(kit, findLanguage(ls));
const Toolchain *tc = ToolChainKitAspect::toolChain(kit, findLanguage(ls));
return tc ? tc->compilerCommand().path() : QString();
});
}
@@ -525,7 +525,7 @@ void ToolChainKitAspectFactory::addToMacroExpander(Kit *kit, MacroExpander *expa
QList<OutputLineParser *> ToolChainKitAspectFactory::createOutputParsers(const Kit *k) const
{
for (const Id langId : {Constants::CXX_LANGUAGE_ID, Constants::C_LANGUAGE_ID}) {
if (const ToolChain * const tc = ToolChainKitAspect::toolChain(k, langId))
if (const Toolchain * const tc = ToolChainKitAspect::toolChain(k, langId))
return tc->createOutputParsers();
}
return {};
@@ -534,7 +534,7 @@ QList<OutputLineParser *> ToolChainKitAspectFactory::createOutputParsers(const K
QSet<Id> ToolChainKitAspectFactory::availableFeatures(const Kit *k) const
{
QSet<Id> result;
for (ToolChain *tc : ToolChainKitAspect::toolChains(k))
for (Toolchain *tc : ToolChainKitAspect::toolChains(k))
result.insert(tc->typeId().withPrefix("ToolChain."));
return result;
}
@@ -555,35 +555,35 @@ QByteArray ToolChainKitAspect::toolChainId(const Kit *k, Id language)
return value.value(language.toKey(), QByteArray()).toByteArray();
}
ToolChain *ToolChainKitAspect::toolChain(const Kit *k, Id language)
Toolchain *ToolChainKitAspect::toolChain(const Kit *k, Id language)
{
return ToolChainManager::findToolChain(toolChainId(k, language));
}
ToolChain *ToolChainKitAspect::cToolChain(const Kit *k)
Toolchain *ToolChainKitAspect::cToolChain(const Kit *k)
{
return ToolChainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::C_LANGUAGE_ID));
}
ToolChain *ToolChainKitAspect::cxxToolChain(const Kit *k)
Toolchain *ToolChainKitAspect::cxxToolChain(const Kit *k)
{
return ToolChainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID));
}
QList<ToolChain *> ToolChainKitAspect::toolChains(const Kit *k)
QList<Toolchain *> ToolChainKitAspect::toolChains(const Kit *k)
{
QTC_ASSERT(k, return {});
const Store value = storeFromVariant(k->value(ToolChainKitAspect::id()));
const QList<ToolChain *> tcList
const QList<Toolchain *> tcList
= transform<QList>(ToolChainManager::allLanguages(), [&value](Id l) {
return ToolChainManager::findToolChain(value.value(l.toKey()).toByteArray());
});
return filtered(tcList, [](ToolChain *tc) { return tc; });
return filtered(tcList, [](Toolchain *tc) { return tc; });
}
void ToolChainKitAspect::setToolChain(Kit *k, ToolChain *tc)
void ToolChainKitAspect::setToolChain(Kit *k, Toolchain *tc)
{
QTC_ASSERT(tc, return);
QTC_ASSERT(k, return);
@@ -603,7 +603,7 @@ void ToolChainKitAspect::setToolChain(Kit *k, ToolChain *tc)
* @param k The kit to set up
* @param tc The toolchain to match other languages for.
*/
void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, ToolChain *tc)
void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, Toolchain *tc)
{
QTC_ASSERT(tc, return);
QTC_ASSERT(k, return);
@@ -618,9 +618,9 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, ToolChain *tc)
if (l == tc->language())
continue;
ToolChain *match = nullptr;
ToolChain *bestMatch = nullptr;
for (ToolChain *other : allTcList) {
Toolchain *match = nullptr;
Toolchain *bestMatch = nullptr;
for (Toolchain *other : allTcList) {
if (!other->isValid() || other->language() != l)
continue;
if (other->targetAbi() == tc->targetAbi())
@@ -654,11 +654,11 @@ void ToolChainKitAspect::clearToolChain(Kit *k, Id language)
Abi ToolChainKitAspect::targetAbi(const Kit *k)
{
const QList<ToolChain *> tcList = toolChains(k);
const QList<Toolchain *> tcList = toolChains(k);
// Find the best possible ABI for all the tool chains...
Abi cxxAbi;
QHash<Abi, int> abiCount;
for (ToolChain *tc : tcList) {
for (Toolchain *tc : tcList) {
Abi ta = tc->targetAbi();
if (tc->language() == Id(Constants::CXX_LANGUAGE_ID))
cxxAbi = tc->targetAbi();
@@ -701,7 +701,7 @@ void ToolChainKitAspectFactory::onKitsLoaded()
this, &ToolChainKitAspectFactory::toolChainUpdated);
}
void ToolChainKitAspectFactory::toolChainUpdated(ToolChain *tc)
void ToolChainKitAspectFactory::toolChainUpdated(Toolchain *tc)
{
for (Kit *k : KitManager::kits()) {
if (ToolChainKitAspect::toolChain(k, tc->language()) == tc)
@@ -709,7 +709,7 @@ void ToolChainKitAspectFactory::toolChainUpdated(ToolChain *tc)
}
}
void ToolChainKitAspectFactory::toolChainRemoved(ToolChain *tc)
void ToolChainKitAspectFactory::toolChainRemoved(Toolchain *tc)
{
Q_UNUSED(tc)
for (Kit *k : KitManager::kits())

14
src/plugins/projectexplorer/kitaspects.h
View File

@@ -12,7 +12,7 @@
namespace ProjectExplorer {
class ToolChain;
class Toolchain;
// SysRootKitAspect
@@ -31,12 +31,12 @@ class PROJECTEXPLORER_EXPORT ToolChainKitAspect
public:
static Utils::Id id();
static QByteArray toolChainId(const Kit *k, Utils::Id language);
static ToolChain *toolChain(const Kit *k, Utils::Id language);
static ToolChain *cToolChain(const Kit *k);
static ToolChain *cxxToolChain(const Kit *k);
static QList<ToolChain *> toolChains(const Kit *k);
static void setToolChain(Kit *k, ToolChain *tc);
static void setAllToolChainsToMatch(Kit *k, ToolChain *tc);
static Toolchain *toolChain(const Kit *k, Utils::Id language);
static Toolchain *cToolChain(const Kit *k);
static Toolchain *cxxToolChain(const Kit *k);
static QList<Toolchain *> toolChains(const Kit *k);
static void setToolChain(Kit *k, Toolchain *tc);
static void setAllToolChainsToMatch(Kit *k, Toolchain *tc);
static void clearToolChain(Kit *k, Utils::Id language);
static Abi targetAbi(const Kit *k);

16
src/plugins/projectexplorer/kitmanager.cpp
View File

@@ -151,8 +151,8 @@ void KitManager::destroy()
static bool kitMatchesAbiList(const Kit *kit, const Abis &abis)
{
const QList<ToolChain *> toolchains = ToolChainKitAspect::toolChains(kit);
for (const ToolChain * const tc : toolchains) {
const QList<Toolchain *> toolchains = ToolChainKitAspect::toolChains(kit);
for (const Toolchain * const tc : toolchains) {
const Abi tcAbi = tc->targetAbi();
for (const Abi &abi : abis) {
if (tcAbi.os() == abi.os() && tcAbi.architecture() == abi.architecture()
@@ -183,8 +183,8 @@ static Id deviceTypeForKit(const Kit *kit)
{
if (isHostKit(kit))
return Constants::DESKTOP_DEVICE_TYPE;
const QList<ToolChain *> toolchains = ToolChainKitAspect::toolChains(kit);
for (const ToolChain * const tc : toolchains) {
const QList<Toolchain *> toolchains = ToolChainKitAspect::toolChains(kit);
for (const Toolchain * const tc : toolchains) {
const Abi tcAbi = tc->targetAbi();
switch (tcAbi.os()) {
case Abi::BareMetalOS:
@@ -298,7 +298,7 @@ void KitManager::restoreKits()
if (resultList.empty() || !haveKitForBinary) {
// No kits exist yet, so let's try to autoconfigure some from the toolchains we know.
QHash<Abi, QHash<Utils::Id, ToolChain *>> uniqueToolchains;
QHash<Abi, QHash<Utils::Id, Toolchain *>> uniqueToolchains;
// On Linux systems, we usually detect a plethora of same-ish toolchains. The following
// algorithm gives precedence to icecc and ccache and otherwise simply chooses the one with
@@ -306,8 +306,8 @@ void KitManager::restoreKits()
// TODO: This should not need to be done here. Instead, it should be a convenience
// operation on some lower level, e.g. in the toolchain class(es).
// Also, we shouldn't detect so many doublets in the first place.
for (ToolChain * const tc : ToolChainManager::toolchains()) {
ToolChain *&bestTc = uniqueToolchains[tc->targetAbi()][tc->language()];
for (Toolchain * const tc : ToolChainManager::toolchains()) {
Toolchain *&bestTc = uniqueToolchains[tc->targetAbi()][tc->language()];
if (!bestTc) {
bestTc = tc;
continue;
@@ -346,7 +346,7 @@ void KitManager::restoreKits()
auto kit = std::make_unique<Kit>();
kit->setSdkProvided(false);
kit->setAutoDetected(false); // TODO: Why false? What does autodetected mean here?
for (ToolChain * const tc : it.value())
for (Toolchain * const tc : it.value())
ToolChainKitAspect::setToolChain(kit.get(), tc);
if (contains(resultList, [&kit](const std::unique_ptr<Kit> &existingKit) {
return ToolChainKitAspect::toolChains(kit.get())

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

@@ -127,10 +127,10 @@ QString MakeStep::defaultDisplayName()
return Tr::tr("Make");
}
static const QList<ToolChain *> preferredToolChains(const Kit *kit)
static const QList<Toolchain *> preferredToolChains(const Kit *kit)
{
// prefer CXX, then C, then others
return Utils::sorted(ToolChainKitAspect::toolChains(kit), [](ToolChain *tcA, ToolChain *tcB) {
return Utils::sorted(ToolChainKitAspect::toolChains(kit), [](Toolchain *tcA, Toolchain *tcB) {
if (tcA->language() == tcB->language())
return false;
if (tcA->language() == Constants::CXX_LANGUAGE_ID)
@@ -146,7 +146,7 @@ static const QList<ToolChain *> preferredToolChains(const Kit *kit)
FilePath MakeStep::defaultMakeCommand() const
{
const Environment env = makeEnvironment();
for (const ToolChain *tc : preferredToolChains(kit())) {
for (const Toolchain *tc : preferredToolChains(kit())) {
FilePath make = tc->makeCommand(env);
if (!make.isEmpty()) {
IDevice::ConstPtr dev = BuildDeviceKitAspect::device(kit());
@@ -169,8 +169,8 @@ Task MakeStep::makeCommandMissingTask()
bool MakeStep::isJobCountSupported() const
{
const QList<ToolChain *> tcs = preferredToolChains(kit());
const ToolChain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
const QList<Toolchain *> tcs = preferredToolChains(kit());
const Toolchain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
return tc && tc->isJobCountSupported();
}
@@ -236,8 +236,8 @@ Environment MakeStep::makeEnvironment() const
env.setupEnglishOutput();
if (makeCommand().isEmpty()) {
// We also prepend "L" to the MAKEFLAGS, so that nmake / jom are less verbose
const QList<ToolChain *> tcs = preferredToolChains(target()->kit());
const ToolChain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
const QList<Toolchain *> tcs = preferredToolChains(target()->kit());
const Toolchain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
if (tc && tc->targetAbi().os() == Abi::WindowsOS
&& tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor) {
env.set(MAKEFLAGS, 'L' + env.expandedValueForKey(MAKEFLAGS));

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

@@ -709,7 +709,7 @@ Utils::LanguageVersion MsvcToolChain::msvcLanguageVersion(const QStringList & /*
if (language == Constants::CXX_LANGUAGE_ID) {
if (!msvcLang.isEmpty()) // >= Visual Studio 2015 Update 3
return ToolChain::cxxLanguageVersion(msvcLang);
return Toolchain::cxxLanguageVersion(msvcLang);
if (mscVer >= 1800) // >= Visual Studio 2013 (12.0)
return LanguageVersion::CXX14;
if (mscVer >= 1600) // >= Visual Studio 2010 (10.0)
@@ -854,7 +854,7 @@ static void addToAvailableMsvcToolchains(const MsvcToolChain *toolchain)
}
MsvcToolChain::MsvcToolChain(Utils::Id typeId)
: ToolChain(typeId)
: Toolchain(typeId)
{
setDisplayName("Microsoft Visual C++ Compiler");
setTypeDisplayName(Tr::tr("MSVC"));
@@ -979,7 +979,7 @@ Abis MsvcToolChain::supportedAbis() const
void MsvcToolChain::toMap(Store &data) const
{
ToolChain::toMap(data);
Toolchain::toMap(data);
data.insert(varsBatKeyC, m_vcvarsBat);
if (!m_varsBatArg.isEmpty())
data.insert(varsBatArgKeyC, m_varsBatArg);
@@ -989,7 +989,7 @@ void MsvcToolChain::toMap(Store &data) const
void MsvcToolChain::fromMap(const Store &data)
{
ToolChain::fromMap(data);
Toolchain::fromMap(data);
if (hasError()) {
g_availableMsvcToolchains.removeOne(this);
return;
@@ -1029,7 +1029,7 @@ bool static hasFlagEffectOnMacros(const QString &flag)
return true;
}
ToolChain::MacroInspectionRunner MsvcToolChain::createMacroInspectionRunner() const
Toolchain::MacroInspectionRunner MsvcToolChain::createMacroInspectionRunner() const
{
Utils::Environment env(m_lastEnvironment);
addToEnvironment(env);
@@ -1120,10 +1120,10 @@ WarningFlags MsvcToolChain::warningFlags(const QStringList &cflags) const
FilePaths MsvcToolChain::includedFiles(const QStringList &flags,
const FilePath &directoryPath) const
{
return ToolChain::includedFiles("/FI", flags, directoryPath, PossiblyConcatenatedFlag::Yes);
return Toolchain::includedFiles("/FI", flags, directoryPath, PossiblyConcatenatedFlag::Yes);
}
ToolChain::BuiltInHeaderPathsRunner MsvcToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner MsvcToolChain::createBuiltInHeaderPathsRunner(
const Environment &env) const
{
Utils::Environment fullEnv = env;
@@ -1266,7 +1266,7 @@ static QString msvcVarsToDisplay(const MsvcToolChain &tc)
class MsvcBasedToolChainConfigWidget : public ToolchainConfigWidget
{
public:
explicit MsvcBasedToolChainConfigWidget(ToolChain *tc)
explicit MsvcBasedToolChainConfigWidget(Toolchain *tc)
: ToolchainConfigWidget(tc)
, m_nameDisplayLabel(new QLabel(this))
, m_varsBatDisplayLabel(new QLabel(this))
@@ -1303,7 +1303,7 @@ protected:
class MsvcToolChainConfigWidget final : public MsvcBasedToolChainConfigWidget
{
public:
explicit MsvcToolChainConfigWidget(ToolChain *tc)
explicit MsvcToolChainConfigWidget(Toolchain *tc)
: MsvcBasedToolChainConfigWidget(tc)
, m_varsBatPathCombo(new QComboBox(this))
, m_varsBatArchCombo(new QComboBox(this))
@@ -1515,7 +1515,7 @@ std::unique_ptr<ToolchainConfigWidget> MsvcToolChain::createConfigurationWidget(
class ClangClToolChainConfigWidget final : public MsvcBasedToolChainConfigWidget
{
public:
explicit ClangClToolChainConfigWidget(ToolChain *tc)
explicit ClangClToolChainConfigWidget(Toolchain *tc)
: MsvcBasedToolChainConfigWidget(tc)
, m_varsBatDisplayCombo(new QComboBox(this))
{
@@ -1669,7 +1669,7 @@ static Toolchains detectClangClToolChainInPath(const FilePath &clangClPath,
.arg(Abi::toString(targetAbi.osFlavor()).toUpper());
for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
ClangClToolChain *tc = static_cast<ClangClToolChain *>(
Utils::findOrDefault(alreadyKnown, [&](ToolChain *tc) -> bool {
Utils::findOrDefault(alreadyKnown, [&](Toolchain *tc) -> bool {
if (tc->typeId() != Constants::CLANG_CL_TOOLCHAIN_TYPEID)
return false;
if (tc->targetAbi() != targetAbi)
@@ -1684,7 +1684,7 @@ static Toolchains detectClangClToolChainInPath(const FilePath &clangClPath,
auto cltc = new ClangClToolChain;
cltc->setClangPath(clangClPath);
cltc->setDisplayName(name);
cltc->setDetection(ToolChain::AutoDetection);
cltc->setDetection(Toolchain::AutoDetection);
cltc->setLanguage(language);
cltc->setupVarsBat(toolChain->targetAbi(), toolChain->varsBat(), toolChain->varsBatArg());
res << cltc;
@@ -1711,7 +1711,7 @@ void ClangClToolChainConfigWidget::applyImpl()
if (results.isEmpty()) {
clangClToolChain->resetVarsBat();
} else {
for (const ToolChain *toolchain : results) {
for (const Toolchain *toolchain : results) {
if (toolchain->language() == clangClToolChain->language()) {
auto mstc = static_cast<const MsvcToolChain *>(toolchain);
clangClToolChain->setupVarsBat(mstc->targetAbi(), mstc->varsBat(), mstc->varsBatArg());
@@ -1805,7 +1805,7 @@ std::unique_ptr<ToolchainConfigWidget> ClangClToolChain::createConfigurationWidg
return std::make_unique<ClangClToolChainConfigWidget>(this);
}
bool ClangClToolChain::operator==(const ToolChain &other) const
bool ClangClToolChain::operator==(const Toolchain &other) const
{
if (!MsvcToolChain::operator==(other))
return false;
@@ -1847,7 +1847,7 @@ LanguageVersion ClangClToolChain::msvcLanguageVersion(const QStringList &cxxflag
const Macros &macros) const
{
if (cxxflags.contains("--driver-mode=g++"))
return ToolChain::languageVersion(language, macros);
return Toolchain::languageVersion(language, macros);
return MsvcToolChain::msvcLanguageVersion(cxxflags, language, macros);
}
@@ -1910,7 +1910,7 @@ static Toolchains findOrCreateToolchains(const ToolchainDetector &detector,
{
Toolchains res;
for (auto language : {Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID}) {
ToolChain *tc = Utils::findOrDefault(detector.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)
@@ -1966,7 +1966,7 @@ static void detectCppBuildTools2015(Toolchains *list)
auto tc = new MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID);
tc->setupVarsBat(abi, vcVarsBat, QLatin1String(e.varsBatArg));
tc->setDisplayName(name + QLatin1String(e.postFix));
tc->setDetection(ToolChain::AutoDetection);
tc->setDetection(Toolchain::AutoDetection);
tc->setLanguage(language);
list->append(tc);
}
@@ -2005,7 +2005,7 @@ Toolchains MsvcToolchainFactory::autoDetect(const ToolchainDetector &detector) c
if (!fi.exists())
continue;
QList<ToolChain *> tmp;
QList<Toolchain *> tmp;
const QVector<QPair<MsvcToolChain::Platform, QString>> platforms = {
{MsvcToolChain::x86, "x86"},
{MsvcToolChain::amd64, "x64"},
@@ -2069,15 +2069,15 @@ Toolchains MsvcToolchainFactory::autoDetect(const ToolchainDetector &detector) c
detectCppBuildTools2015(&results);
for (ToolChain *tc : std::as_const(results))
tc->setDetection(ToolChain::AutoDetection);
for (Toolchain *tc : std::as_const(results))
tc->setDetection(Toolchain::AutoDetection);
return results;
}
bool MsvcToolChain::operator==(const ToolChain &other) const
bool MsvcToolChain::operator==(const Toolchain &other) const
{
if (!ToolChain::operator==(other))
if (!Toolchain::operator==(other))
return false;
const auto *msvcTc = dynamic_cast<const MsvcToolChain *>(&other);

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

@@ -20,7 +20,7 @@ namespace ProjectExplorer::Internal {
// MsvcToolChain
// --------------------------------------------------------------------------
class MsvcToolChain : public ToolChain
class MsvcToolChain : public Toolchain
{
public:
enum Type { WindowsSDK, VS };
@@ -61,7 +61,7 @@ public:
void resetVarsBat();
Platform platform() const;
bool operator==(const ToolChain &) const override;
bool operator==(const Toolchain &) const override;
bool isJobCountSupported() const override { return false; }
@@ -153,7 +153,7 @@ public:
const Utils::Id &language,
const Macros &macros) const override;
bool operator==(const ToolChain &) const override;
bool operator==(const Toolchain &) const override;
int priority() const override;

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

@@ -310,7 +310,7 @@ bool ProjectImporter::findTemporaryHandler(Utils::Id id) const
return Utils::contains(m_temporaryHandlers, [id](const TemporaryInformationHandler &ch) { return ch.id == id; });
}
static ToolChain *toolChainFromVariant(const QVariant &v)
static Toolchain *toolChainFromVariant(const QVariant &v)
{
const QByteArray tcId = v.toByteArray();
return ToolChainManager::findToolChain(tcId);
@@ -319,7 +319,7 @@ static ToolChain *toolChainFromVariant(const QVariant &v)
void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
{
for (const QVariant &v : vl) {
ToolChain *tc = toolChainFromVariant(v);
Toolchain *tc = toolChainFromVariant(v);
QTC_ASSERT(tc, continue);
ToolChainManager::deregisterToolChain(tc);
ToolChainKitAspect::setToolChain(k, nullptr);
@@ -329,9 +329,9 @@ void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
void ProjectImporter::persistTemporaryToolChains(Kit *k, const QVariantList &vl)
{
for (const QVariant &v : vl) {
ToolChain *tmpTc = toolChainFromVariant(v);
Toolchain *tmpTc = toolChainFromVariant(v);
QTC_ASSERT(tmpTc, continue);
ToolChain *actualTc = ToolChainKitAspect::toolChain(k, tmpTc->language());
Toolchain *actualTc = ToolChainKitAspect::toolChain(k, tmpTc->language());
if (tmpTc && actualTc != tmpTc)
ToolChainManager::deregisterToolChain(tmpTc);
}
@@ -375,7 +375,7 @@ static ProjectImporter::ToolChainData createToolChains(const ToolChainDescriptio
if (data.tcs.isEmpty())
continue;
for (ToolChain *tc : std::as_const(data.tcs))
for (Toolchain *tc : std::as_const(data.tcs))
ToolChainManager::registerToolChain(tc);
data.areTemporary = true;
@@ -389,10 +389,10 @@ ProjectImporter::ToolChainData
ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
{
ToolChainData result;
result.tcs = ToolChainManager::toolchains([&tcd](const ToolChain *tc) {
result.tcs = ToolChainManager::toolchains([&tcd](const Toolchain *tc) {
return tc->language() == tcd.language && tc->matchesCompilerCommand(tcd.compilerPath);
});
for (const ToolChain *tc : std::as_const(result.tcs)) {
for (const Toolchain *tc : std::as_const(result.tcs)) {
const QByteArray tcId = tc->id();
result.areTemporary = result.areTemporary ? true : hasKitWithTemporaryData(ToolChainKitAspect::id(), tcId);
}

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

@@ -15,7 +15,7 @@ class BuildInfo;
class Kit;
class Project;
class Target;
class ToolChain;
class Toolchain;
// Documentation inside.
class PROJECTEXPLORER_EXPORT ProjectImporter : public QObject
@@ -23,7 +23,7 @@ class PROJECTEXPLORER_EXPORT ProjectImporter : public QObject
Q_OBJECT
public:
struct ToolChainData {
QList<ToolChain *> tcs;
QList<Toolchain *> tcs;
bool areTemporary = false;
};

4
src/plugins/projectexplorer/rawprojectpart.cpp
View File

@@ -16,7 +16,7 @@
namespace ProjectExplorer {
RawProjectPartFlags::RawProjectPartFlags(const ToolChain *toolChain,
RawProjectPartFlags::RawProjectPartFlags(const Toolchain *toolChain,
const QStringList &commandLineFlags,
const Utils::FilePath &includeFileBaseDir)
{
@@ -155,7 +155,7 @@ bool KitInfo::isValid() const
return kit;
}
ToolChainInfo::ToolChainInfo(const ToolChain *toolChain,
ToolChainInfo::ToolChainInfo(const Toolchain *toolChain,
const Utils::FilePath &sysRootPath,
const Utils::Environment &env)
{

12
src/plugins/projectexplorer/rawprojectpart.h
View File

@@ -36,7 +36,7 @@ class PROJECTEXPLORER_EXPORT RawProjectPartFlags
{
public:
RawProjectPartFlags() = default;
RawProjectPartFlags(const ToolChain *toolChain, const QStringList &commandLineFlags,
RawProjectPartFlags(const Toolchain *toolChain, const QStringList &commandLineFlags,
const Utils::FilePath &includeFileBaseDir);
public:
@@ -119,8 +119,8 @@ public:
bool isValid() const;
Kit *kit = nullptr;
ToolChain *cToolChain = nullptr;
ToolChain *cxxToolChain = nullptr;
Toolchain *cToolChain = nullptr;
Toolchain *cxxToolChain = nullptr;
Utils::QtMajorVersion projectPartQtVersion = Utils::QtMajorVersion::None;
@@ -131,7 +131,7 @@ class PROJECTEXPLORER_EXPORT ToolChainInfo
{
public:
ToolChainInfo() = default;
ToolChainInfo(const ProjectExplorer::ToolChain *toolChain,
ToolChainInfo(const ProjectExplorer::Toolchain *toolChain,
const Utils::FilePath &sysRootPath,
const Utils::Environment &env);
@@ -148,8 +148,8 @@ public:
QStringList extraCodeModelFlags;
Utils::FilePath sysRootPath; // For headerPathsRunner.
ProjectExplorer::ToolChain::BuiltInHeaderPathsRunner headerPathsRunner;
ProjectExplorer::ToolChain::MacroInspectionRunner macroInspectionRunner;
ProjectExplorer::Toolchain::BuiltInHeaderPathsRunner headerPathsRunner;
ProjectExplorer::Toolchain::MacroInspectionRunner macroInspectionRunner;
};
class PROJECTEXPLORER_EXPORT ProjectUpdateInfo

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

@@ -41,13 +41,13 @@ QList<ToolchainFactory *> &toolchainFactories()
class ToolChainPrivate
{
public:
using Detection = ToolChain::Detection;
using Detection = Toolchain::Detection;
explicit ToolChainPrivate(Id typeId) :
m_id(QUuid::createUuid().toByteArray()),
m_typeId(typeId),
m_predefinedMacrosCache(new ToolChain::MacrosCache::element_type()),
m_headerPathsCache(new ToolChain::HeaderPathsCache::element_type())
m_predefinedMacrosCache(new Toolchain::MacrosCache::element_type()),
m_headerPathsCache(new Toolchain::HeaderPathsCache::element_type())
{
QTC_ASSERT(m_typeId.isValid(), return);
QTC_ASSERT(!m_typeId.name().contains(':'), return);
@@ -63,12 +63,12 @@ public:
QString m_typeDisplayName;
Id m_typeId;
Id m_language;
Detection m_detection = ToolChain::UninitializedDetection;
Detection m_detection = Toolchain::UninitializedDetection;
QString m_detectionSource;
QString m_explicitCodeModelTargetTriple;
ToolChain::MacrosCache m_predefinedMacrosCache;
ToolChain::HeaderPathsCache m_headerPathsCache;
Toolchain::MacrosCache m_predefinedMacrosCache;
Toolchain::HeaderPathsCache m_headerPathsCache;
std::optional<bool> m_isValid;
bool m_hasError = false;
};
@@ -119,12 +119,12 @@ using namespace Internal;
// --------------------------------------------------------------------------
ToolChain::ToolChain(Id typeId) :
Toolchain::Toolchain(Id typeId) :
d(std::make_unique<ToolChainPrivate>(typeId))
{
}
void ToolChain::setLanguage(Id language)
void Toolchain::setLanguage(Id language)
{
QTC_ASSERT(!d->m_language.isValid() || isAutoDetected(), return);
QTC_ASSERT(language.isValid(), return);
@@ -133,16 +133,16 @@ void ToolChain::setLanguage(Id language)
d->m_language = language;
}
ToolChain::~ToolChain() = default;
Toolchain::~Toolchain() = default;
QString ToolChain::displayName() const
QString Toolchain::displayName() const
{
if (d->m_displayName.isEmpty())
return typeDisplayName();
return d->m_displayName;
}
void ToolChain::setDisplayName(const QString &name)
void Toolchain::setDisplayName(const QString &name)
{
if (d->m_displayName == name)
return;
@@ -151,42 +151,42 @@ void ToolChain::setDisplayName(const QString &name)
toolChainUpdated();
}
bool ToolChain::isAutoDetected() const
bool Toolchain::isAutoDetected() const
{
return detection() == AutoDetection || detection() == AutoDetectionFromSdk;
}
ToolChain::Detection ToolChain::detection() const
Toolchain::Detection Toolchain::detection() const
{
return d->m_detection;
}
QString ToolChain::detectionSource() const
QString Toolchain::detectionSource() const
{
return d->m_detectionSource;
}
QByteArray ToolChain::id() const
QByteArray Toolchain::id() const
{
return d->m_id;
}
QStringList ToolChain::suggestedMkspecList() const
QStringList Toolchain::suggestedMkspecList() const
{
return {};
}
Id ToolChain::typeId() const
Id Toolchain::typeId() const
{
return d->m_typeId;
}
Abis ToolChain::supportedAbis() const
Abis Toolchain::supportedAbis() const
{
return {targetAbi()};
}
bool ToolChain::isValid() const
bool Toolchain::isValid() const
{
if (!d->m_isValid.has_value())
d->m_isValid = !compilerCommand().isEmpty() && compilerCommand().isExecutableFile();
@@ -194,19 +194,19 @@ bool ToolChain::isValid() const
return d->m_isValid.value_or(false);
}
FilePaths ToolChain::includedFiles(const QStringList &flags, const FilePath &directory) const
FilePaths Toolchain::includedFiles(const QStringList &flags, const FilePath &directory) const
{
Q_UNUSED(flags)
Q_UNUSED(directory)
return {};
}
Id ToolChain::language() const
Id Toolchain::language() const
{
return d->m_language;
}
bool ToolChain::operator == (const ToolChain &tc) const
bool Toolchain::operator == (const Toolchain &tc) const
{
if (this == &tc)
return true;
@@ -217,11 +217,11 @@ bool ToolChain::operator == (const ToolChain &tc) const
&& language() == tc.language();
}
ToolChain *ToolChain::clone() const
Toolchain *Toolchain::clone() const
{
for (ToolchainFactory *f : std::as_const(toolchainFactories())) {
if (f->supportedToolChainType() == d->m_typeId) {
ToolChain *tc = f->create();
Toolchain *tc = f->create();
QTC_ASSERT(tc, return nullptr);
Store data;
toMap(data);
@@ -241,7 +241,7 @@ ToolChain *ToolChain::clone() const
Make sure to call this function when deriving.
*/
void ToolChain::toMap(Store &result) const
void Toolchain::toMap(Store &result) const
{
AspectContainer::toMap(result);
@@ -267,7 +267,7 @@ void ToolChain::toMap(Store &result) const
result.insert(d->m_compilerCommandKey, d->m_compilerCommand.toSettings());
}
void ToolChain::toolChainUpdated()
void Toolchain::toolChainUpdated()
{
d->m_predefinedMacrosCache->invalidate();
d->m_headerPathsCache->invalidate();
@@ -275,27 +275,27 @@ void ToolChain::toolChainUpdated()
ToolChainManager::notifyAboutUpdate(this);
}
void ToolChain::setDetection(ToolChain::Detection de)
void Toolchain::setDetection(Toolchain::Detection de)
{
d->m_detection = de;
}
void ToolChain::setDetectionSource(const QString &source)
void Toolchain::setDetectionSource(const QString &source)
{
d->m_detectionSource = source;
}
QString ToolChain::typeDisplayName() const
QString Toolchain::typeDisplayName() const
{
return d->m_typeDisplayName;
}
Abi ToolChain::targetAbi() const
Abi Toolchain::targetAbi() const
{
return d->m_targetAbi;
}
void ToolChain::setTargetAbi(const Abi &abi)
void Toolchain::setTargetAbi(const Abi &abi)
{
if (abi == d->m_targetAbi)
return;
@@ -304,22 +304,22 @@ void ToolChain::setTargetAbi(const Abi &abi)
toolChainUpdated();
}
void ToolChain::setTargetAbiNoSignal(const Abi &abi)
void Toolchain::setTargetAbiNoSignal(const Abi &abi)
{
d->m_targetAbi = abi;
}
void ToolChain::setTargetAbiKey(const Key &abiKey)
void Toolchain::setTargetAbiKey(const Key &abiKey)
{
d->m_targetAbiKey = abiKey;
}
FilePath ToolChain::compilerCommand() const
FilePath Toolchain::compilerCommand() const
{
return d->m_compilerCommand;
}
void ToolChain::setCompilerCommand(const FilePath &command)
void Toolchain::setCompilerCommand(const FilePath &command)
{
d->m_isValid.reset();
@@ -329,17 +329,17 @@ void ToolChain::setCompilerCommand(const FilePath &command)
toolChainUpdated();
}
bool ToolChain::matchesCompilerCommand(const FilePath &command) const
bool Toolchain::matchesCompilerCommand(const FilePath &command) const
{
return compilerCommand().isSameExecutable(command);
}
void ToolChain::setCompilerCommandKey(const Key &commandKey)
void Toolchain::setCompilerCommandKey(const Key &commandKey)
{
d->m_compilerCommandKey = commandKey;
}
void ToolChain::setTypeDisplayName(const QString &typeName)
void Toolchain::setTypeDisplayName(const QString &typeName)
{
d->m_typeDisplayName = typeName;
}
@@ -350,7 +350,7 @@ void ToolChain::setTypeDisplayName(const QString &typeName)
Make sure to call this function when deriving.
*/
void ToolChain::fromMap(const Store &data)
void Toolchain::fromMap(const Store &data)
{
AspectContainer::fromMap(data);
@@ -392,22 +392,22 @@ void ToolChain::fromMap(const Store &data)
d->m_isValid.reset();
}
void ToolChain::reportError()
void Toolchain::reportError()
{
d->m_hasError = true;
}
bool ToolChain::hasError() const
bool Toolchain::hasError() const
{
return d->m_hasError;
}
const ToolChain::HeaderPathsCache &ToolChain::headerPathsCache() const
const Toolchain::HeaderPathsCache &Toolchain::headerPathsCache() const
{
return d->m_headerPathsCache;
}
const ToolChain::MacrosCache &ToolChain::predefinedMacrosCache() const
const Toolchain::MacrosCache &Toolchain::predefinedMacrosCache() const
{
return d->m_predefinedMacrosCache;
}
@@ -424,7 +424,7 @@ static long toLanguageVersionAsLong(QByteArray dateAsByteArray)
return result;
}
LanguageVersion ToolChain::cxxLanguageVersion(const QByteArray &cplusplusMacroValue)
LanguageVersion Toolchain::cxxLanguageVersion(const QByteArray &cplusplusMacroValue)
{
const long version = toLanguageVersionAsLong(cplusplusMacroValue);
@@ -440,7 +440,7 @@ LanguageVersion ToolChain::cxxLanguageVersion(const QByteArray &cplusplusMacroVa
return LanguageVersion::CXX03;
}
LanguageVersion ToolChain::languageVersion(const Id &language, const Macros &macros)
LanguageVersion Toolchain::languageVersion(const Id &language, const Macros &macros)
{
if (language == Constants::CXX_LANGUAGE_ID) {
for (const ProjectExplorer::Macro &macro : macros) {
@@ -477,7 +477,7 @@ LanguageVersion ToolChain::languageVersion(const Id &language, const Macros &mac
}
}
FilePaths ToolChain::includedFiles(const QString &option,
FilePaths Toolchain::includedFiles(const QString &option,
const QStringList &flags,
const FilePath &directoryPath,
PossiblyConcatenatedFlag possiblyConcatenated)
@@ -506,22 +506,22 @@ FilePaths ToolChain::includedFiles(const QString &option,
Used by the tool chain kit information to validate the kit.
*/
Tasks ToolChain::validateKit(const Kit *) const
Tasks Toolchain::validateKit(const Kit *) const
{
return {};
}
QString ToolChain::sysRoot() const
QString Toolchain::sysRoot() const
{
return {};
}
QString ToolChain::explicitCodeModelTargetTriple() const
QString Toolchain::explicitCodeModelTargetTriple() const
{
return d->m_explicitCodeModelTargetTriple;
}
QString ToolChain::effectiveCodeModelTargetTriple() const
QString Toolchain::effectiveCodeModelTargetTriple() const
{
const QString overridden = explicitCodeModelTargetTriple();
if (!overridden.isEmpty())
@@ -529,7 +529,7 @@ QString ToolChain::effectiveCodeModelTargetTriple() const
return originalTargetTriple();
}
void ToolChain::setExplicitCodeModelTargetTriple(const QString &triple)
void Toolchain::setExplicitCodeModelTargetTriple(const QString &triple)
{
d->m_explicitCodeModelTargetTriple = triple;
}
@@ -589,17 +589,17 @@ bool ToolchainFactory::canCreate() const
return m_userCreatable;
}
ToolChain *ToolchainFactory::create() const
Toolchain *ToolchainFactory::create() const
{
return m_toolchainConstructor ? m_toolchainConstructor() : nullptr;
}
ToolChain *ToolchainFactory::restore(const Store &data)
Toolchain *ToolchainFactory::restore(const Store &data)
{
if (!m_toolchainConstructor)
return nullptr;
ToolChain *tc = m_toolchainConstructor();
Toolchain *tc = m_toolchainConstructor();
QTC_ASSERT(tc, return nullptr);
tc->fromMap(data);
@@ -633,11 +633,11 @@ void ToolchainFactory::autoDetectionToMap(Store &data, bool detected)
data.insert(AUTODETECT_KEY, detected);
}
ToolChain *ToolchainFactory::createToolChain(Id toolChainType)
Toolchain *ToolchainFactory::createToolChain(Id toolChainType)
{
for (ToolchainFactory *factory : std::as_const(toolchainFactories())) {
if (factory->m_supportedToolChainType == toolChainType) {
if (ToolChain *tc = factory->create()) {
if (Toolchain *tc = factory->create()) {
tc->d->m_typeId = toolChainType;
return tc;
}

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

@@ -57,7 +57,7 @@ public:
// ToolChain (documentation inside)
// --------------------------------------------------------------------------
class PROJECTEXPLORER_EXPORT ToolChain : public Utils::AspectContainer
class PROJECTEXPLORER_EXPORT Toolchain : public Utils::AspectContainer
{
public:
enum Detection {
@@ -67,9 +67,9 @@ public:
UninitializedDetection,
};
using Predicate = std::function<bool(const ToolChain *)>;
using Predicate = std::function<bool(const Toolchain *)>;
virtual ~ToolChain();
virtual ~Toolchain();
QString displayName() const;
void setDisplayName(const QString &name);
@@ -113,7 +113,7 @@ public:
Utils::LanguageVersion languageVersion;
};
using MacrosCache = std::shared_ptr<Cache<QStringList, ToolChain::MacroInspectionReport, 64>>;
using MacrosCache = std::shared_ptr<Cache<QStringList, Toolchain::MacroInspectionReport, 64>>;
using HeaderPathsCache = std::shared_ptr<Cache<QPair<Utils::Environment, QStringList>, HeaderPaths>>;
// A MacroInspectionRunner is created in the ui thread and runs in another thread.
@@ -135,10 +135,10 @@ public:
virtual QList<Utils::OutputLineParser *> createOutputParsers() const = 0;
virtual bool operator ==(const ToolChain &) const;
virtual bool operator ==(const Toolchain &) const;
virtual std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() = 0;
ToolChain *clone() const;
Toolchain *clone() const;
// Used by the toolchainmanager to save user-generated tool chains.
// Make sure to call this function when deriving!
@@ -164,7 +164,7 @@ public:
virtual GccToolChain *asGccToolChain() { return nullptr; }
protected:
explicit ToolChain(Utils::Id typeId);
explicit Toolchain(Utils::Id typeId);
void setTypeDisplayName(const QString &typeName);
@@ -191,8 +191,8 @@ protected:
PossiblyConcatenatedFlag possiblyConcatenated);
private:
ToolChain(const ToolChain &) = delete;
ToolChain &operator=(const ToolChain &) = delete;
Toolchain(const Toolchain &) = delete;
Toolchain &operator=(const Toolchain &) = delete;
const std::unique_ptr<Internal::ToolChainPrivate> d;
@@ -200,7 +200,7 @@ private:
friend class ToolchainFactory;
};
using Toolchains = QList<ToolChain *>;
using Toolchains = QList<Toolchain *>;
class PROJECTEXPLORER_EXPORT BadToolchain
{
@@ -259,15 +259,15 @@ public:
virtual Toolchains detectForImport(const ToolChainDescription &tcd) const;
virtual bool canCreate() const;
ToolChain *create() const;
Toolchain *create() const;
ToolChain *restore(const Utils::Store &data);
Toolchain *restore(const Utils::Store &data);
static QByteArray idFromMap(const Utils::Store &data);
static Utils::Id typeIdFromMap(const Utils::Store &data);
static void autoDetectionToMap(Utils::Store &data, bool detected);
static ToolChain *createToolChain(Utils::Id toolChainType);
static Toolchain *createToolChain(Utils::Id toolChainType);
QList<Utils::Id> supportedLanguages() const;
@@ -278,7 +278,7 @@ protected:
void setSupportedToolChainType(const Utils::Id &supportedToolChainType);
void setSupportedLanguages(const QList<Utils::Id> &supportedLanguages);
void setSupportsAllLanguages(bool supportsAllLanguages);
using ToolChainConstructor = std::function<ToolChain *()>;
using ToolChainConstructor = std::function<Toolchain *()>;
void setToolchainConstructor(const ToolChainConstructor &constructor);
ToolChainConstructor toolchainConstructor() const;

4
src/plugins/projectexplorer/toolchainconfigwidget.cpp
View File

@@ -20,7 +20,7 @@ using namespace Utils;
namespace ProjectExplorer {
ToolchainConfigWidget::ToolchainConfigWidget(ToolChain *tc) :
ToolchainConfigWidget::ToolchainConfigWidget(Toolchain *tc) :
m_toolChain(tc)
{
Q_ASSERT(tc);
@@ -66,7 +66,7 @@ bool ToolchainConfigWidget::isDirty() const
return m_nameLineEdit->text() != m_toolChain->displayName() || isDirtyImpl();
}
ToolChain *ToolchainConfigWidget::toolChain() const
Toolchain *ToolchainConfigWidget::toolChain() const
{
return m_toolChain;
}

8
src/plugins/projectexplorer/toolchainconfigwidget.h
View File

@@ -15,7 +15,7 @@ QT_END_NAMESPACE
namespace ProjectExplorer {
class ToolChain;
class Toolchain;
// --------------------------------------------------------------------------
// ToolChainConfigWidget
@@ -26,9 +26,9 @@ class PROJECTEXPLORER_EXPORT ToolchainConfigWidget : public QScrollArea
Q_OBJECT
public:
explicit ToolchainConfigWidget(ToolChain *tc);
explicit ToolchainConfigWidget(Toolchain *tc);
ToolChain *toolChain() const;
Toolchain *toolChain() const;
void apply();
void discard();
@@ -53,7 +53,7 @@ protected:
QLineEdit *m_nameLineEdit;
private:
ToolChain *m_toolChain;
Toolchain *m_toolChain;
QLabel *m_errorLabel = nullptr;
};

22
src/plugins/projectexplorer/toolchainmanager.cpp
View File

@@ -106,7 +106,7 @@ void ToolChainManager::restoreToolChains()
QTC_ASSERT(!d->m_accessor, return);
d->m_accessor = std::make_unique<Internal::ToolChainSettingsAccessor>();
for (ToolChain *tc : d->m_accessor->restoreToolChains(Core::ICore::dialogParent()))
for (Toolchain *tc : d->m_accessor->restoreToolChains(Core::ICore::dialogParent()))
registerToolChain(tc);
d->m_loaded = true;
@@ -131,13 +131,13 @@ const Toolchains &ToolChainManager::toolchains()
return d->m_toolChains;
}
Toolchains ToolChainManager::toolchains(const ToolChain::Predicate &predicate)
Toolchains ToolChainManager::toolchains(const Toolchain::Predicate &predicate)
{
QTC_ASSERT(predicate, return {});
return Utils::filtered(d->m_toolChains, predicate);
}
ToolChain *ToolChainManager::toolChain(const ToolChain::Predicate &predicate)
Toolchain *ToolChainManager::toolChain(const Toolchain::Predicate &predicate)
{
QTC_CHECK(d->m_loaded);
return Utils::findOrDefault(d->m_toolChains, predicate);
@@ -147,7 +147,7 @@ Toolchains ToolChainManager::findToolChains(const Abi &abi)
{
QTC_CHECK(d->m_loaded);
Toolchains result;
for (ToolChain *tc : std::as_const(d->m_toolChains)) {
for (Toolchain *tc : std::as_const(d->m_toolChains)) {
bool isCompatible = Utils::anyOf(tc->supportedAbis(), [abi](const Abi &supportedAbi) {
return supportedAbi.isCompatibleWith(abi);
});
@@ -158,13 +158,13 @@ Toolchains ToolChainManager::findToolChains(const Abi &abi)
return result;
}
ToolChain *ToolChainManager::findToolChain(const QByteArray &id)
Toolchain *ToolChainManager::findToolChain(const QByteArray &id)
{
QTC_CHECK(d->m_loaded);
if (id.isEmpty())
return nullptr;
ToolChain *tc = Utils::findOrDefault(d->m_toolChains, Utils::equal(&ToolChain::id, id));
Toolchain *tc = Utils::findOrDefault(d->m_toolChains, Utils::equal(&Toolchain::id, id));
// Compatibility with versions 3.5 and earlier:
if (!tc) {
@@ -174,7 +174,7 @@ ToolChain *ToolChainManager::findToolChain(const QByteArray &id)
const QByteArray shortId = id.mid(pos + 1);
tc = Utils::findOrDefault(d->m_toolChains, Utils::equal(&ToolChain::id, shortId));
tc = Utils::findOrDefault(d->m_toolChains, Utils::equal(&Toolchain::id, shortId));
}
return tc;
}
@@ -184,14 +184,14 @@ bool ToolChainManager::isLoaded()
return d->m_loaded;
}
void ToolChainManager::notifyAboutUpdate(ToolChain *tc)
void ToolChainManager::notifyAboutUpdate(Toolchain *tc)
{
if (!tc || !d->m_toolChains.contains(tc))
return;
emit m_instance->toolChainUpdated(tc);
}
bool ToolChainManager::registerToolChain(ToolChain *tc)
bool ToolChainManager::registerToolChain(Toolchain *tc)
{
QTC_ASSERT(tc, return false);
QTC_ASSERT(isLanguageSupported(tc->language()),
@@ -203,7 +203,7 @@ bool ToolChainManager::registerToolChain(ToolChain *tc)
if (d->m_toolChains.contains(tc))
return true;
for (const ToolChain *current : std::as_const(d->m_toolChains)) {
for (const Toolchain *current : std::as_const(d->m_toolChains)) {
if (*tc == *current && !tc->isAutoDetected())
return false;
QTC_ASSERT(current->id() != tc->id(), return false);
@@ -214,7 +214,7 @@ bool ToolChainManager::registerToolChain(ToolChain *tc)
return true;
}
void ToolChainManager::deregisterToolChain(ToolChain *tc)
void ToolChainManager::deregisterToolChain(Toolchain *tc)
{
QTC_CHECK(d->m_loaded);
if (!tc || !d->m_toolChains.contains(tc))

22
src/plugins/projectexplorer/toolchainmanager.h
View File

@@ -40,16 +40,16 @@ public:
~ToolChainManager() override;
static const Toolchains &toolchains();
static Toolchains toolchains(const ToolChain::Predicate &predicate);
static Toolchains toolchains(const Toolchain::Predicate &predicate);
static ToolChain *toolChain(const ToolChain::Predicate &predicate);
static QList<ToolChain *> findToolChains(const Abi &abi);
static ToolChain *findToolChain(const QByteArray &id);
static Toolchain *toolChain(const Toolchain::Predicate &predicate);
static QList<Toolchain *> findToolChains(const Abi &abi);
static Toolchain *findToolChain(const QByteArray &id);
static bool isLoaded();
static bool registerToolChain(ToolChain *tc);
static void deregisterToolChain(ToolChain *tc);
static bool registerToolChain(Toolchain *tc);
static void deregisterToolChain(Toolchain *tc);
static QList<Utils::Id> allLanguages();
static bool registerLanguage(const Utils::Id &language, const QString &displayName);
@@ -68,11 +68,11 @@ public:
void saveToolChains();
signals:
void toolChainAdded(ProjectExplorer::ToolChain *);
void toolChainAdded(ProjectExplorer::Toolchain *);
// Tool chain is still valid when this call happens!
void toolChainRemoved(ProjectExplorer::ToolChain *);
void toolChainRemoved(ProjectExplorer::Toolchain *);
// Tool chain was updated.
void toolChainUpdated(ProjectExplorer::ToolChain *);
void toolChainUpdated(ProjectExplorer::Toolchain *);
// Something changed.
void toolChainsChanged();
//
@@ -84,10 +84,10 @@ private:
// Make sure the this is only called after all toolchain factories are registered!
static void restoreToolChains();
static void notifyAboutUpdate(ToolChain *);
static void notifyAboutUpdate(Toolchain *);
friend class ProjectExplorerPlugin; // for constructor
friend class ToolChain;
friend class Toolchain;
};
} // namespace ProjectExplorer

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

@@ -48,7 +48,7 @@ namespace Internal {
class ToolChainTreeItem : public TreeItem
{
public:
ToolChainTreeItem(QStackedWidget *parentWidget, ToolChain *tc, bool c) :
ToolChainTreeItem(QStackedWidget *parentWidget, Toolchain *tc, bool c) :
toolChain(tc), changed(c), m_parentWidget(parentWidget)
{}
@@ -100,7 +100,7 @@ public:
return m_widget;
}
ToolChain *toolChain;
Toolchain *toolChain;
bool changed;
private:
@@ -253,7 +253,7 @@ public:
m_widgetStack = new QStackedWidget;
m_container->setWidget(m_widgetStack);
for (ToolChain *tc : ToolChainManager::toolchains())
for (Toolchain *tc : ToolChainManager::toolchains())
insertToolChain(tc);
auto buttonLayout = new QVBoxLayout;
@@ -300,11 +300,11 @@ public:
ToolChainTreeItem *currentTreeItem();
void markForRemoval(ToolChainTreeItem *item);
ToolChainTreeItem *insertToolChain(ProjectExplorer::ToolChain *tc, bool changed = false); // Insert directly into model
void addToolChain(ProjectExplorer::ToolChain *);
void removeToolChain(ProjectExplorer::ToolChain *);
ToolChainTreeItem *insertToolChain(ProjectExplorer::Toolchain *tc, bool changed = false); // Insert directly into model
void addToolChain(ProjectExplorer::Toolchain *);
void removeToolChain(ProjectExplorer::Toolchain *);
StaticTreeItem *parentForToolChain(ToolChain *tc);
StaticTreeItem *parentForToolChain(Toolchain *tc);
QAction *createAction(const QString &name, ToolchainFactory *factory, Utils::Id language)
{
auto action = new QAction(name, nullptr);
@@ -352,7 +352,7 @@ void ToolChainOptionsWidget::markForRemoval(ToolChainTreeItem *item)
}
}
ToolChainTreeItem *ToolChainOptionsWidget::insertToolChain(ToolChain *tc, bool changed)
ToolChainTreeItem *ToolChainOptionsWidget::insertToolChain(Toolchain *tc, bool changed)
{
StaticTreeItem *parent = parentForToolChain(tc);
auto item = new ToolChainTreeItem(m_widgetStack, tc, changed);
@@ -361,7 +361,7 @@ ToolChainTreeItem *ToolChainOptionsWidget::insertToolChain(ToolChain *tc, bool c
return item;
}
void ToolChainOptionsWidget::addToolChain(ToolChain *tc)
void ToolChainOptionsWidget::addToolChain(Toolchain *tc)
{
if (Utils::eraseOne(m_toAddList, [tc](const ToolChainTreeItem *item) {
return item->toolChain == tc; })) {
@@ -373,7 +373,7 @@ void ToolChainOptionsWidget::addToolChain(ToolChain *tc)
updateState();
}
void ToolChainOptionsWidget::removeToolChain(ToolChain *tc)
void ToolChainOptionsWidget::removeToolChain(Toolchain *tc)
{
if (auto it = std::find_if(m_toRemoveList.begin(), m_toRemoveList.end(),
[tc](const ToolChainTreeItem *item) { return item->toolChain == tc; });
@@ -392,7 +392,7 @@ void ToolChainOptionsWidget::removeToolChain(ToolChain *tc)
updateState();
}
StaticTreeItem *ToolChainOptionsWidget::parentForToolChain(ToolChain *tc)
StaticTreeItem *ToolChainOptionsWidget::parentForToolChain(Toolchain *tc)
{
QPair<StaticTreeItem *, StaticTreeItem *> nodes = m_languageMap.value(tc->language());
return tc->isAutoDetected() ? nodes.first : nodes.second;
@@ -412,11 +412,11 @@ void ToolChainOptionsWidget::redetectToolchains()
knownTcs << tcItem->toolChain;
});
Toolchains toAdd;
QSet<ToolChain *> toDelete;
QSet<Toolchain *> toDelete;
ToolChainManager::resetBadToolchains();
for (ToolchainFactory *f : ToolchainFactory::allToolchainFactories()) {
const ToolchainDetector detector(knownTcs, DeviceManager::defaultDesktopDevice(), {}); // FIXME: Pass search paths
for (ToolChain * const tc : f->autoDetect(detector)) {
for (Toolchain * const tc : f->autoDetect(detector)) {
if (knownTcs.contains(tc) || toDelete.contains(tc))
continue;
const auto matchItem = [tc](const ToolChainTreeItem *item) {
@@ -434,7 +434,7 @@ void ToolChainOptionsWidget::redetectToolchains()
}
for (ToolChainTreeItem * const tcItem : std::as_const(itemsToRemove))
markForRemoval(tcItem);
for (ToolChain * const newTc : std::as_const(toAdd))
for (Toolchain * const newTc : std::as_const(toAdd))
m_toAddList.append(insertToolChain(newTc, true));
qDeleteAll(toDelete);
}
@@ -514,11 +514,11 @@ void ToolChainOptionsWidget::createToolChain(ToolchainFactory *factory, const Ut
QTC_ASSERT(factory->canCreate(), return);
QTC_ASSERT(language.isValid(), return);
ToolChain *tc = factory->create();
Toolchain *tc = factory->create();
if (!tc)
return;
tc->setDetection(ToolChain::ManualDetection);
tc->setDetection(Toolchain::ManualDetection);
tc->setLanguage(language);
auto item = insertToolChain(tc, true);
@@ -533,11 +533,11 @@ void ToolChainOptionsWidget::cloneToolChain()
if (!current)
return;
ToolChain *tc = current->toolChain->clone();
Toolchain *tc = current->toolChain->clone();
if (!tc)
return;
tc->setDetection(ToolChain::ManualDetection);
tc->setDetection(Toolchain::ManualDetection);
tc->setDisplayName(Tr::tr("Clone of %1").arg(current->toolChain->displayName()));
auto item = insertToolChain(tc, true);
@@ -551,7 +551,7 @@ void ToolChainOptionsWidget::updateState()
bool canCopy = false;
bool canDelete = false;
if (ToolChainTreeItem *item = currentTreeItem()) {
ToolChain *tc = item->toolChain;
Toolchain *tc = item->toolChain;
canCopy = tc->isValid();
canDelete = !tc->isSdkProvided();
}

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

@@ -68,14 +68,14 @@ static Toolchains autoDetectToolChains(const ToolchainDetector &detector)
}
// Remove invalid toolchains that might have sneaked in.
return Utils::filtered(result, [](const ToolChain *tc) { return tc->isValid(); });
return Utils::filtered(result, [](const Toolchain *tc) { return tc->isValid(); });
}
static Toolchains makeUniqueByEqual(const Toolchains &a)
{
Toolchains result;
for (ToolChain *tc : a) {
if (!Utils::contains(result, [tc](ToolChain *rtc) { return *tc == *rtc; }))
for (Toolchain *tc : a) {
if (!Utils::contains(result, [tc](Toolchain *rtc) { return *tc == *rtc; }))
result.append(tc);
}
return result;
@@ -88,26 +88,26 @@ static Toolchains makeUniqueByPointerEqual(const Toolchains &a)
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()));
return Utils::filtered(a, [&b](Toolchain *atc) {
return !Utils::anyOf(b, Utils::equal(&Toolchain::id, atc->id()));
});
}
static bool containsByEqual(const Toolchains &a, const ToolChain *atc)
static bool containsByEqual(const Toolchains &a, const Toolchain *atc)
{
return Utils::anyOf(a, [atc](ToolChain *btc) { return *atc == *btc; });
return Utils::anyOf(a, [atc](Toolchain *btc) { return *atc == *btc; });
}
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; });
return Utils::filtered(a, [&b](Toolchain *atc) {
return !Utils::anyOf(b, [atc](Toolchain *btc) { return *atc == *btc; });
});
}
static Toolchains subtractByPointerEqual(const Toolchains &a, const Toolchains &b)
{
return Utils::filtered(a, [&b](ToolChain *atc) { return !b.contains(atc); });
return Utils::filtered(a, [&b](Toolchain *atc) { return !b.contains(atc); });
}
static Toolchains stabilizeOrder(const Toolchains &toRegister,
@@ -121,7 +121,7 @@ static Toolchains stabilizeOrder(const Toolchains &toRegister,
for (int i = 0; i < userFileTcs.count(); ++i) {
const QByteArray userId = userFileTcs.at(i)->id();
const int handlePos = Utils::indexOf(toHandle,
[&userId](const ToolChain *htc) { return htc->id() == userId; });
[&userId](const Toolchain *htc) { return htc->id() == userId; });
if (handlePos < 0)
continue;
@@ -140,7 +140,7 @@ static ToolChainOperations mergeToolChainLists(const Toolchains &systemFileTcs,
Toolchains manualUserFileTcs;
Toolchains autodetectedUserFileTcs;
std::tie(autodetectedUserFileTcs, manualUserFileTcs)
= Utils::partition(uniqueUserFileTcs, &ToolChain::isAutoDetected);
= Utils::partition(uniqueUserFileTcs, &Toolchain::isAutoDetected);
const Toolchains autodetectedUserTcs = subtractById(autodetectedUserFileTcs, systemFileTcs);
// Calculate a set of Tcs that were detected before (and saved to userFile) and that
@@ -149,14 +149,14 @@ static ToolChainOperations mergeToolChainLists(const Toolchains &systemFileTcs,
Toolchains notRedetectedUserTcs;
std::tie(redetectedUserTcs, notRedetectedUserTcs)
= Utils::partition(autodetectedUserTcs,
[&autodetectedTcs](ToolChain *tc) { return containsByEqual(autodetectedTcs, tc); });
[&autodetectedTcs](Toolchain *tc) { return containsByEqual(autodetectedTcs, tc); });
// Remove redetected tcs from autodetectedTcs:
const Toolchains newlyAutodetectedTcs
= subtractByEqual(autodetectedTcs, redetectedUserTcs);
const Toolchains notRedetectedButValidUserTcs
= Utils::filtered(notRedetectedUserTcs, &ToolChain::isValid);
= Utils::filtered(notRedetectedUserTcs, &Toolchain::isValid);
ToolChainOperations result;
result.toDemote = notRedetectedButValidUserTcs;
@@ -188,15 +188,15 @@ Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
// read all tool chains from SDK
const Toolchains systemFileTcs = toolChains(
restoreSettings(Core::ICore::installerResourcePath(TOOLCHAIN_FILENAME), parent));
for (ToolChain * const systemTc : systemFileTcs)
systemTc->setDetection(ToolChain::AutoDetectionFromSdk);
for (Toolchain * const systemTc : systemFileTcs)
systemTc->setDetection(Toolchain::AutoDetectionFromSdk);
// read all tool chains from user file.
const Toolchains userFileTcs = toolChains(restoreSettings(parent));
// Autodetect: Pass autodetected toolchains from user file so the information can be reused:
const Toolchains autodetectedUserFileTcs
= Utils::filtered(userFileTcs, &ToolChain::isAutoDetected);
= Utils::filtered(userFileTcs, &Toolchain::isAutoDetected);
// Autodect from system paths on the desktop device.
// The restriction is intentional to keep startup and automatic validation a limited effort
@@ -207,10 +207,10 @@ Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
const ToolChainOperations ops = mergeToolChainLists(systemFileTcs, userFileTcs, autodetectedTcs);
// Process ops:
for (ToolChain *tc : ops.toDemote) {
for (Toolchain *tc : ops.toDemote) {
// FIXME: We currently only demote local toolchains, as they are not redetected.
if (tc->detectionSource().isEmpty())
tc->setDetection(ToolChain::ManualDetection);
tc->setDetection(Toolchain::ManualDetection);
}
qDeleteAll(ops.toDelete);
@@ -223,7 +223,7 @@ void ToolChainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWi
Store data;
int count = 0;
for (const ToolChain *tc : toolchains) {
for (const Toolchain *tc : toolchains) {
if (!tc || (!tc->isValid() && tc->isAutoDetected()))
continue;
Store tmp;
@@ -258,7 +258,7 @@ Toolchains ToolChainSettingsAccessor::toolChains(const Store &data) const
if (tcType.isValid()) {
for (ToolchainFactory *f : factories) {
if (f->supportedToolChainType() == tcType) {
if (ToolChain *tc = f->restore(tcMap)) {
if (Toolchain *tc = f->restore(tcMap)) {
result.append(tc);
restored = true;
break;
@@ -293,11 +293,11 @@ const char TestTokenKey[] = "TestTokenKey";
const char TestToolChainType[] = "TestToolChainType";
class TTC : public ToolChain
class TTC : public Toolchain
{
public:
TTC(const QByteArray &t = {}, bool v = true) :
ToolChain(TestToolChainType),
Toolchain(TestToolChainType),
token(t),
m_valid(v)
{
@@ -320,21 +320,21 @@ public:
FilePath makeCommand(const Environment &) const override { return "make"; }
QList<OutputLineParser *> createOutputParsers() const override { return {}; }
std::unique_ptr<ToolchainConfigWidget> createConfigurationWidget() override { return nullptr; }
bool operator ==(const ToolChain &other) const override {
if (!ToolChain::operator==(other))
bool operator ==(const Toolchain &other) const override {
if (!Toolchain::operator==(other))
return false;
return static_cast<const TTC *>(&other)->token == token;
}
void fromMap(const Store &data) final
{
ToolChain::fromMap(data);
Toolchain::fromMap(data);
token = data.value(TestTokenKey).toByteArray();
}
void toMap(Store &data) const final
{
ToolChain::toMap(data);
Toolchain::toMap(data);
data[TestTokenKey] = token;
}
@@ -350,7 +350,7 @@ QList<TTC *> TTC::m_toolChains;
} // namespace ProjectExplorer
Q_DECLARE_METATYPE(ProjectExplorer::ToolChain *)
Q_DECLARE_METATYPE(ProjectExplorer::Toolchain *)
namespace ProjectExplorer {
@@ -374,43 +374,43 @@ void ProjectExplorerPlugin::testToolChainMerging_data()
QTest::addColumn<Toolchains>("toRegister");
TTC *system1 = nullptr;
ToolChain *system1c = nullptr;
Toolchain *system1c = nullptr;
TTC *system2 = nullptr;
TTC *system3i = nullptr;
TTC *user1 = nullptr;
ToolChain *user1c = nullptr;
Toolchain *user1c = nullptr;
TTC *user3i = nullptr;
TTC *user2 = nullptr;
TTC *auto1 = nullptr;
ToolChain *auto1c = nullptr;
Toolchain *auto1c = nullptr;
TTC *auto1_2 = nullptr;
TTC *auto2 = nullptr;
TTC *auto3i = nullptr;
if (!TTC::hasToolChains()) {
system1 = new TTC("system1");
system1->setDetection(ToolChain::AutoDetection);
system1->setDetection(Toolchain::AutoDetection);
system1c = system1->clone(); Q_UNUSED(system1c)
system2 = new TTC("system2");
system2->setDetection(ToolChain::AutoDetection);
system2->setDetection(Toolchain::AutoDetection);
system3i = new TTC("system3", false);
system3i->setDetection(ToolChain::AutoDetection);
system3i->setDetection(Toolchain::AutoDetection);
user1 = new TTC("user1");
user1->setDetection(ToolChain::ManualDetection);
user1->setDetection(Toolchain::ManualDetection);
user1c = user1->clone(); Q_UNUSED(user1c)
user2 = new TTC("user2");
user2->setDetection(ToolChain::ManualDetection);
user2->setDetection(Toolchain::ManualDetection);
user3i = new TTC("user3", false);
user3i->setDetection(ToolChain::ManualDetection);
user3i->setDetection(Toolchain::ManualDetection);
auto1 = new TTC("auto1");
auto1->setDetection(ToolChain::AutoDetection);
auto1->setDetection(Toolchain::AutoDetection);
auto1c = auto1->clone();
auto1_2 = new TTC("auto1");
auto1_2->setDetection(ToolChain::AutoDetection);
auto1_2->setDetection(Toolchain::AutoDetection);
auto2 = new TTC("auto2");
auto2->setDetection(ToolChain::AutoDetection);
auto2->setDetection(Toolchain::AutoDetection);
auto3i = new TTC("auto3", false);
auto3i->setDetection(ToolChain::AutoDetection);
auto3i->setDetection(Toolchain::AutoDetection);
}
QTest::newRow("no toolchains")
@@ -468,18 +468,18 @@ void ProjectExplorerPlugin::testToolChainMerging()
Internal::ToolChainOperations ops = Internal::mergeToolChainLists(system, user, autodetect);
QSet<ToolChain *> expToRegister = Utils::toSet(toRegister);
QSet<ToolChain *> expToDemote = Utils::toSet(toDemote);
QSet<Toolchain *> expToRegister = Utils::toSet(toRegister);
QSet<Toolchain *> expToDemote = Utils::toSet(toDemote);
QSet<ToolChain *> actToRegister = Utils::toSet(ops.toRegister);
QSet<ToolChain *> actToDemote = Utils::toSet(ops.toDemote);
QSet<ToolChain *> actToDelete = Utils::toSet(ops.toDelete);
QSet<Toolchain *> actToRegister = Utils::toSet(ops.toRegister);
QSet<Toolchain *> actToDemote = Utils::toSet(ops.toDemote);
QSet<Toolchain *> actToDelete = Utils::toSet(ops.toDelete);
QCOMPARE(actToRegister.count(), ops.toRegister.count()); // no dups!
QCOMPARE(actToDemote.count(), ops.toDemote.count()); // no dups!
QCOMPARE(actToDelete.count(), ops.toDelete.count()); // no dups!
QSet<ToolChain *> tmp = actToRegister;
QSet<Toolchain *> tmp = actToRegister;
tmp.intersect(actToDemote);
QCOMPARE(tmp, actToDemote); // all toDemote are in toRegister

8
src/plugins/projectexplorer/toolchainsettingsaccessor.h
View File

@@ -9,7 +9,7 @@
namespace ProjectExplorer {
class ToolChain;
class Toolchain;
namespace Internal {
@@ -18,12 +18,12 @@ class ToolChainSettingsAccessor : public Utils::UpgradingSettingsAccessor
public:
ToolChainSettingsAccessor();
QList<ToolChain *> restoreToolChains(QWidget *parent) const;
QList<Toolchain *> restoreToolChains(QWidget *parent) const;
void saveToolChains(const QList<ToolChain *> &toolchains, QWidget *parent);
void saveToolChains(const QList<Toolchain *> &toolchains, QWidget *parent);
private:
QList<ToolChain *> toolChains(const Utils::Store &data) const;
QList<Toolchain *> toolChains(const Utils::Store &data) const;
};
} // namespace Internal

12
src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
View File

@@ -102,7 +102,7 @@ static QString targetPlatform(const ProjectExplorer::Abi &abi, const ProjectExpl
return QString();
}
static QStringList toolchainList(const ProjectExplorer::ToolChain *tc)
static QStringList toolchainList(const ProjectExplorer::Toolchain *tc)
{
const Utils::Id type = tc->typeId();
if (type == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID
@@ -174,14 +174,14 @@ static QString architecture(const ProjectExplorer::Abi &targetAbi)
return QString();
}
static bool isMultiTargetingToolchain(const ProjectExplorer::ToolChain *tc)
static bool isMultiTargetingToolchain(const ProjectExplorer::Toolchain *tc)
{
// Clang and QCC are multi-targeting compilers; others (GCC/MinGW, MSVC, ICC) are not
return tc->targetAbi().os() == ProjectExplorer::Abi::QnxOS
|| tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID;
}
static QStringList architectures(const ProjectExplorer::ToolChain *tc)
static QStringList architectures(const ProjectExplorer::Toolchain *tc)
{
// For platforms which can have builds for multiple architectures in a single configuration
// (Darwin, Android), regardless of whether the toolchain is multi-targeting or not (Clang
@@ -238,12 +238,12 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
if (!sysroot.isEmpty())
data.insert(QLatin1String(QBS_SYSROOT), sysroot);
ToolChain *tcC = ToolChainKitAspect::cToolChain(k);
ToolChain *tcCxx = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tcC = ToolChainKitAspect::cToolChain(k);
Toolchain *tcCxx = ToolChainKitAspect::cxxToolChain(k);
if (!tcC && !tcCxx)
return data;
ToolChain *mainTc = tcCxx ? tcCxx : tcC;
Toolchain *mainTc = tcCxx ? tcCxx : tcC;
Abi targetAbi = mainTc->targetAbi();

12
src/plugins/qbsprojectmanager/qbsproject.cpp
View File

@@ -827,8 +827,8 @@ static void getExpandedCompilerFlags(QStringList &cFlags, QStringList &cxxFlags,
static RawProjectPart generateProjectPart(
const QJsonObject &product,
const QJsonObject &group,
const std::shared_ptr<const ToolChain> &cToolChain,
const std::shared_ptr<const ToolChain> &cxxToolChain,
const std::shared_ptr<const Toolchain> &cToolChain,
const std::shared_ptr<const Toolchain> &cxxToolChain,
QtMajorVersion qtVersion,
QString cPch,
QString cxxPch,
@@ -952,8 +952,8 @@ static RawProjectPart generateProjectPart(
static RawProjectParts generateProjectParts(
const QJsonObject &projectData,
const std::shared_ptr<const ToolChain> &cToolChain,
const std::shared_ptr<const ToolChain> &cxxToolChain,
const std::shared_ptr<const Toolchain> &cToolChain,
const std::shared_ptr<const Toolchain> &cxxToolChain,
QtMajorVersion qtVersion
)
{
@@ -1005,9 +1005,9 @@ void QbsBuildSystem::updateCppCodeModel()
const QtSupport::CppKitInfo kitInfo(kit());
QTC_ASSERT(kitInfo.isValid(), return);
const auto cToolchain = std::shared_ptr<ToolChain>(kitInfo.cToolChain
const auto cToolchain = std::shared_ptr<Toolchain>(kitInfo.cToolChain
? kitInfo.cToolChain->clone() : nullptr);
const auto cxxToolchain = std::shared_ptr<ToolChain>(kitInfo.cxxToolChain
const auto cxxToolchain = std::shared_ptr<Toolchain>(kitInfo.cxxToolChain
? kitInfo.cxxToolChain->clone() : nullptr);
m_cppCodeModelUpdater->update({project(), kitInfo, activeParseEnvironment(), {},

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

@@ -145,8 +145,8 @@ bool QbsProjectImporter::matchKit(void *directoryData, const Kit *k) const
&& bgData->cxxCompilerPath.isEmpty()) {
return true;
}
const ToolChain * const cToolchain = ToolChainKitAspect::cToolChain(k);
const ToolChain * const cxxToolchain = ToolChainKitAspect::cxxToolChain(k);
const Toolchain * const cToolchain = ToolChainKitAspect::cToolChain(k);
const Toolchain * const cxxToolchain = ToolChainKitAspect::cxxToolChain(k);
if (!bgData->cCompilerPath.isEmpty()) {
if (!cToolchain)
return false;

2
src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp
View File

@@ -781,7 +781,7 @@ QmakeBuildConfiguration::LastKitState::LastKitState(Kit *k)
m_sysroot(SysRootKitAspect::sysRoot(k).toString()),
m_mkspec(QmakeKitAspect::mkspec(k))
{
ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
m_toolchain = tc ? tc->id() : QByteArray();
}

2
src/plugins/qmakeprojectmanager/qmakebuildconfiguration.h
View File

@@ -106,7 +106,7 @@ private:
void restrictNextBuild(const ProjectExplorer::RunConfiguration *rc) override;
void kitChanged();
void toolChainUpdated(ProjectExplorer::ToolChain *tc);
void toolChainUpdated(ProjectExplorer::Toolchain *tc);
void qtVersionsChanged(const QList<int> &, const QList<int> &, const QList<int> &changed);
void updateProblemLabel();

2
src/plugins/qmakeprojectmanager/qmakemakestep.cpp
View File

@@ -179,7 +179,7 @@ bool QmakeMakeStep::init()
void QmakeMakeStep::setupOutputFormatter(OutputFormatter *formatter)
{
formatter->addLineParser(new GnuMakeParser());
ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit());
Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit());
OutputTaskParser *xcodeBuildParser = nullptr;
if (tc && tc->targetAbi().os() == Abi::DarwinOS) {
xcodeBuildParser = new XcodebuildParser;

8
src/plugins/qmakeprojectmanager/qmakeproject.cpp
View File

@@ -237,7 +237,7 @@ QmakeBuildSystem::QmakeBuildSystem(QmakeBuildConfiguration *bc)
this, &QmakeBuildSystem::scheduleUpdateAllNowOrLater);
connect(ToolChainManager::instance(), &ToolChainManager::toolChainUpdated,
this, [this](ToolChain *tc) {
this, [this](Toolchain *tc) {
if (ToolChainKitAspect::cxxToolChain(kit()) == tc)
scheduleUpdateAllNowOrLater();
});
@@ -1308,7 +1308,7 @@ static FilePath destDirFor(const TargetInformation &ti)
FilePaths QmakeBuildSystem::allLibraryTargetFiles(const QmakeProFile *file) const
{
const ToolChain *const toolchain = ToolChainKitAspect::cxxToolChain(kit());
const Toolchain *const toolchain = ToolChainKitAspect::cxxToolChain(kit());
if (!toolchain)
return {};
@@ -1423,7 +1423,7 @@ static FilePath getFullPathOf(const QmakeProFile *pro, Variable variable,
return bc->environment().searchInPath(exe);
}
void QmakeBuildSystem::testToolChain(ToolChain *tc, const FilePath &path) const
void QmakeBuildSystem::testToolChain(Toolchain *tc, const FilePath &path) const
{
if (!tc || path.isEmpty())
return;
@@ -1474,7 +1474,7 @@ void QmakeBuildSystem::warnOnToolChainMismatch(const QmakeProFile *pro) const
FilePath QmakeBuildSystem::executableFor(const QmakeProFile *file)
{
const ToolChain *const tc = ToolChainKitAspect::cxxToolChain(kit());
const Toolchain *const tc = ToolChainKitAspect::cxxToolChain(kit());
if (!tc)
return {};

2
src/plugins/qmakeprojectmanager/qmakeproject.h
View File

@@ -115,7 +115,7 @@ public:
void startAsyncTimer(QmakeProFile::AsyncUpdateDelay delay);
void warnOnToolChainMismatch(const QmakeProFile *pro) const;
void testToolChain(ProjectExplorer::ToolChain *tc, const Utils::FilePath &path) const;
void testToolChain(ProjectExplorer::Toolchain *tc, const Utils::FilePath &path) const;
QString deviceRoot() const;

12
src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
View File

@@ -160,7 +160,7 @@ bool QmakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
QtVersion *kitVersion = QtKitAspect::qtVersion(k);
QString kitSpec = QmakeKitAspect::mkspec(k);
ToolChain *tc = ToolChainKitAspect::cxxToolChain(k);
Toolchain *tc = ToolChainKitAspect::cxxToolChain(k);
if (kitSpec.isEmpty() && kitVersion)
kitSpec = kitVersion->mkspecFor(tc);
QMakeStepConfig::OsType kitOsType = QMakeStepConfig::NoOsType;
@@ -217,17 +217,17 @@ static const Toolchains preferredToolChains(QtVersion *qtVersion, const QString
const Toolchains toolchains = ToolChainManager::toolchains();
const Abis qtAbis = qtVersion->qtAbis();
const auto matcher = [&](const ToolChain *tc) {
const auto matcher = [&](const Toolchain *tc) {
return qtAbis.contains(tc->targetAbi()) && tc->suggestedMkspecList().contains(spec);
};
ToolChain * const cxxToolchain = findOrDefault(toolchains, [matcher](const ToolChain *tc) {
Toolchain * const cxxToolchain = findOrDefault(toolchains, [matcher](const Toolchain *tc) {
return tc->language() == ProjectExplorer::Constants::CXX_LANGUAGE_ID && matcher(tc);
});
ToolChain * const cToolchain = findOrDefault(toolchains, [matcher](const ToolChain *tc) {
Toolchain * const cToolchain = findOrDefault(toolchains, [matcher](const Toolchain *tc) {
return tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID && matcher(tc);
});
Toolchains chosenToolchains;
for (ToolChain * const tc : {cxxToolchain, cToolchain}) {
for (Toolchain * const tc : {cxxToolchain, cToolchain}) {
if (tc)
chosenToolchains << tc;
};
@@ -240,7 +240,7 @@ Kit *QmakeProjectImporter::createTemporaryKit(const QtProjectImporter::QtVersion
{
Q_UNUSED(osType) // TODO use this to select the right toolchain?
return QtProjectImporter::createTemporaryKit(data, [&data, parsedSpec](Kit *k) -> void {
for (ToolChain *const tc : preferredToolChains(data.qt, parsedSpec))
for (Toolchain *const tc : preferredToolChains(data.qt, parsedSpec))
ToolChainKitAspect::setToolChain(k, tc);
if (parsedSpec != data.qt->mkspec())
QmakeKitAspect::setMkspec(k, parsedSpec, QmakeKitAspect::MkspecSource::Code);

2
src/plugins/qmakeprojectmanager/qmakestep.cpp
View File

@@ -149,7 +149,7 @@ QMakeStepConfig QMakeStep::deducedArguments() const
Kit *kit = target()->kit();
QMakeStepConfig config;
Abi targetAbi;
if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(kit)) {
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(kit)) {
targetAbi = tc->targetAbi();
if (HostOsInfo::isWindowsHost()
&& tc->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) {

14
src/plugins/qnx/qnxsettingspage.cpp
View File

@@ -99,7 +99,7 @@ public:
bool isActive() const
{
const bool hasToolChain = ToolChainManager::toolChain(Utils::equal(&ToolChain::compilerCommand,
const bool hasToolChain = ToolChainManager::toolChain(Utils::equal(&Toolchain::compilerCommand,
m_qccCompiler));
const bool hasDebugger = Utils::contains(DebuggerItemManager::debuggers(), [this](const DebuggerItem &di) {
return findTargetByDebuggerPath(di.command());
@@ -169,7 +169,7 @@ void QnxConfiguration::deactivate()
QTC_ASSERT(isActive(), return);
const Toolchains toolChainsToRemove =
ToolChainManager::toolchains(Utils::equal(&ToolChain::compilerCommand, m_qccCompiler));
ToolChainManager::toolchains(Utils::equal(&Toolchain::compilerCommand, m_qccCompiler));
QList<DebuggerItem> debuggersToRemove;
const QList<DebuggerItem> debuggerItems = DebuggerItemManager::debuggers();
@@ -187,7 +187,7 @@ void QnxConfiguration::deactivate()
}
}
for (ToolChain *tc : toolChainsToRemove)
for (Toolchain *tc : toolChainsToRemove)
ToolChainManager::deregisterToolChain(tc);
for (const DebuggerItem &debuggerItem : std::as_const(debuggersToRemove))
@@ -232,7 +232,7 @@ Toolchains QnxConfiguration::createToolChains(const QnxTarget &target)
for (const Id language : {ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID}) {
auto toolChain = new QnxToolChain;
toolChain->setDetection(ToolChain::ManualDetection);
toolChain->setDetection(Toolchain::ManualDetection);
toolChain->setLanguage(language);
toolChain->setTargetAbi(target.m_abi);
toolChain->setDisplayName(Tr::tr("QCC for %1 (%2)")
@@ -755,13 +755,13 @@ QnxSettingsPage::QnxSettingsPage(QObject *guard)
this, &QnxSettingsPage::restoreConfigurations);
}
QList<ToolChain *> autoDetectHelper(const QList<ToolChain *> &alreadyKnown)
QList<Toolchain *> autoDetectHelper(const QList<Toolchain *> &alreadyKnown)
{
QList<ToolChain *> result;
QList<Toolchain *> result;
for (const QnxConfiguration &config : std::as_const(m_configurations)) {
config.ensureContents();
for (const QnxTarget &target : std::as_const(config.m_targets)) {
result += Utils::filtered(alreadyKnown, [config, target](ToolChain *tc) {
result += Utils::filtered(alreadyKnown, [config, target](Toolchain *tc) {
return tc->typeId() == Constants::QNX_TOOLCHAIN_ID
&& tc->targetAbi() == target.m_abi
&& tc->compilerCommand() == config.m_qccCompiler;

6
src/plugins/qnx/qnxsettingspage.h
View File

@@ -5,12 +5,12 @@
#include <coreplugin/dialogs/ioptionspage.h>
namespace ProjectExplorer { class ToolChain; }
namespace ProjectExplorer { class Toolchain; }
namespace Qnx::Internal {
QList<ProjectExplorer::ToolChain *> autoDetectHelper(
const QList<ProjectExplorer::ToolChain *> &alreadyKnown);
QList<ProjectExplorer::Toolchain *> autoDetectHelper(
const QList<ProjectExplorer::Toolchain *> &alreadyKnown);
void setupQnxSettingsPage(QObject *guard);

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

@@ -152,7 +152,7 @@ GccToolChain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const
return GccToolChain::DetectedAbisResult{detectTargetAbis(sdpPath()), "unknown-qnx-gnu"};
}
bool QnxToolChain::operator ==(const ToolChain &other) const
bool QnxToolChain::operator ==(const Toolchain &other) const
{
if (!GccToolChain::operator ==(other))
return false;

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

@@ -20,7 +20,7 @@ public:
Utils::FilePathAspect sdpPath{this};
Utils::StringAspect cpuDir{this};
bool operator ==(const ToolChain &) const override;
bool operator ==(const Toolchain &) const override;
protected:
DetectedAbisResult detectSupportedAbis() const override;

8
src/plugins/qtsupport/baseqtversion.cpp
View File

@@ -542,7 +542,7 @@ Tasks QtVersion::validateKit(const Kit *k)
result << BuildSystemTask(Task::Warning, Tr::tr("Device type is not supported by Qt version."));
}
if (ToolChain *tc = ToolChainKitAspect::cxxToolChain(k)) {
if (Toolchain *tc = ToolChainKitAspect::cxxToolChain(k)) {
Abi targetAbi = tc->targetAbi();
Abis supportedAbis = tc->supportedAbis();
bool fuzzyMatch = false;
@@ -1291,7 +1291,7 @@ QString QtVersion::mkspec() const
return d->m_mkspec.toFSPathString();
}
QString QtVersion::mkspecFor(ToolChain *tc) const
QString QtVersion::mkspecFor(Toolchain *tc) const
{
QString versionSpec = mkspec();
if (!tc)
@@ -1866,10 +1866,10 @@ bool QtVersionPrivate::queryQMakeVariables(const FilePath &binary, const Environ
// This is required to make non-static qmakes work on windows where every tool chain
// tries to be incompatible with any other.
const Abis abiList = Abi::abisOfBinary(binary);
const Toolchains tcList = ToolChainManager::toolchains([&abiList](const ToolChain *t) {
const Toolchains tcList = ToolChainManager::toolchains([&abiList](const Toolchain *t) {
return abiList.contains(t->targetAbi());
});
for (ToolChain *tc : tcList) {
for (Toolchain *tc : tcList) {
Environment realEnv = env;
tc->addToEnvironment(realEnv);
output = runQmakeQuery(binary, realEnv, error);

4
src/plugins/qtsupport/baseqtversion.h
View File

@@ -28,7 +28,7 @@ class FileInProjectFinder;
namespace ProjectExplorer {
class Kit;
class ToolChain;
class Toolchain;
class Target;
} // ProjectExplorer
@@ -114,7 +114,7 @@ public:
/// @returns the name of the mkspec
QString mkspec() const;
QString mkspecFor(ProjectExplorer::ToolChain *tc) const;
QString mkspecFor(ProjectExplorer::Toolchain *tc) const;
/// @returns the full path to the default directory
/// specifally not the directory the symlink/ORIGINAL_QMAKESPEC points to
Utils::FilePath mkspecPath() const;

10
src/plugins/qtsupport/qtkitaspect.cpp
View File

@@ -230,7 +230,7 @@ void QtKitAspectFactory::fix(Kit *k)
return;
const QString spec = version->mkspec();
Toolchains possibleTcs = ToolChainManager::toolchains([version](const ToolChain *t) {
Toolchains possibleTcs = ToolChainManager::toolchains([version](const Toolchain *t) {
if (!t->isValid() || t->language() != ProjectExplorer::Constants::CXX_LANGUAGE_ID)
return false;
return Utils::anyOf(version->qtAbis(), [t](const Abi &qtAbi) {
@@ -244,7 +244,7 @@ void QtKitAspectFactory::fix(Kit *k)
// TODO: We should probably prefer the compiler with the highest version number instead,
// but this information is currently not exposed by the ToolChain class.
const FilePaths envPathVar = Environment::systemEnvironment().path();
sort(possibleTcs, [version, &envPathVar](const ToolChain *tc1, const ToolChain *tc2) {
sort(possibleTcs, [version, &envPathVar](const Toolchain *tc1, const Toolchain *tc2) {
const QVector<Abi> &qtAbis = version->qtAbis();
const bool tc1ExactMatch = qtAbis.contains(tc1->targetAbi());
const bool tc2ExactMatch = qtAbis.contains(tc2->targetAbi());
@@ -278,11 +278,11 @@ void QtKitAspectFactory::fix(Kit *k)
});
// TODO: Why is this not done during sorting?
const Toolchains goodTcs = Utils::filtered(possibleTcs, [&spec](const ToolChain *t) {
const Toolchains goodTcs = Utils::filtered(possibleTcs, [&spec](const Toolchain *t) {
return t->suggestedMkspecList().contains(spec);
});
if (ToolChain * const bestTc = goodTcs.isEmpty() ? possibleTcs.first() : goodTcs.first())
if (Toolchain * const bestTc = goodTcs.isEmpty() ? possibleTcs.first() : goodTcs.first())
ToolChainKitAspect::setAllToolChainsToMatch(k, bestTc);
}
}
@@ -405,7 +405,7 @@ void QtKitAspect::setQtVersion(Kit *k, const QtVersion *v)
void QtKitAspect::addHostBinariesToPath(const Kit *k, Environment &env)
{
if (const ToolChain *tc = ToolChainKitAspect::cxxToolChain(k))
if (const Toolchain *tc = ToolChainKitAspect::cxxToolChain(k))
env.prependOrSetPath(tc->compilerCommand().parentDir());
if (const QtVersion *qt = qtVersion(k))

12
src/plugins/qtsupport/qtoptionspage.cpp
View File

@@ -190,7 +190,7 @@ private:
QIcon icon;
};
ValidityInfo validInformation(const QtVersion *version);
QList<ProjectExplorer::ToolChain*> toolChains(const QtVersion *version);
QList<ProjectExplorer::Toolchain*> toolChains(const QtVersion *version);
QByteArray defaultToolChainId(const QtVersion *version);
bool isNameUnique(const QtVersion *version);
@@ -487,7 +487,7 @@ QtOptionsPageWidget::ValidityInfo QtOptionsPageWidget::validInformation(const Qt
const Abis qtAbis = version->qtAbis();
for (const Abi &abi : qtAbis) {
const auto abiCompatePred = [&abi] (const ToolChain *tc)
const auto abiCompatePred = [&abi] (const Toolchain *tc)
{
return Utils::contains(tc->supportedAbis(),
[&abi](const Abi &sabi) { return sabi.isCompatibleWith(abi); });
@@ -530,9 +530,9 @@ QtOptionsPageWidget::ValidityInfo QtOptionsPageWidget::validInformation(const Qt
return info;
}
QList<ToolChain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
QList<Toolchain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
{
QList<ToolChain*> toolChains;
QList<Toolchain*> toolChains;
if (!version)
return toolChains;
@@ -540,7 +540,7 @@ QList<ToolChain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
const Abis abis = version->qtAbis();
for (const Abi &a : abis) {
const Toolchains tcList = ToolChainManager::findToolChains(a);
for (ToolChain *tc : tcList) {
for (Toolchain *tc : tcList) {
if (Utils::insert(ids, tc->id()))
toolChains.append(tc);
}
@@ -551,7 +551,7 @@ QList<ToolChain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
QByteArray QtOptionsPageWidget::defaultToolChainId(const QtVersion *version)
{
QList<ToolChain*> possibleToolChains = toolChains(version);
QList<Toolchain*> possibleToolChains = toolChains(version);
if (!possibleToolChains.isEmpty())
return possibleToolChains.first()->id();
return QByteArray();

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

@@ -48,7 +48,7 @@ static void addRegisteredMinGWToEnvironment(Environment &env)
return;
}
const ToolChain *toolChain = ToolChainManager::toolChain([](const ToolChain *t){
const Toolchain *toolChain = ToolChainManager::toolChain([](const Toolchain *t){
return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID;
});
if (toolChain)
@@ -121,7 +121,7 @@ static Toolchains doAutoDetect(const ToolchainDetector &detector)
ProjectExplorer::Constants::CXX_LANGUAGE_ID}) {
auto toolChain = new WebAssemblyToolChain;
toolChain->setLanguage(languageId);
toolChain->setDetection(ToolChain::AutoDetection);
toolChain->setDetection(Toolchain::AutoDetection);
const bool cLanguage = languageId == ProjectExplorer::Constants::C_LANGUAGE_ID;
const QString script = QLatin1String(cLanguage ? "emcc" : "em++")
+ QLatin1String(sdk.osType() == OsTypeWindows ? ".bat" : "");
@@ -140,8 +140,8 @@ static Toolchains doAutoDetect(const ToolchainDetector &detector)
void WebAssemblyToolChain::registerToolChains()
{
// Remove old toolchains
for (ToolChain *tc : ToolChainManager::findToolChains(toolChainAbi())) {
if (tc->detection() != ToolChain::AutoDetection)
for (Toolchain *tc : ToolChainManager::findToolChains(toolChainAbi())) {
if (tc->detection() != Toolchain::AutoDetection)
continue;
ToolChainManager::deregisterToolChain(tc);
};