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

Rename a few more ToolChain items to Toolchain

Browse Source 
Change-Id: I78e12e6923242fcb72cdde6284185574b8792fc6
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2024-01-22 17:46:28 +01:00
parent d7c1fe129f
commit d0d0d3b83a
27 changed files with 439 additions and 439 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -586,14 +586,14 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
if (detector.device->type() != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
return {};
QList<GccToolchain *> existingClangToolChains = clangToolchains(detector.alreadyKnown);
QList<GccToolchain *> existingClangToolchains = clangToolchains(detector.alreadyKnown);
const QList<XcodePlatform> platforms = XcodeProbe::detectPlatforms().values();
Toolchains toolchains;
toolchains.reserve(platforms.size());
for (const XcodePlatform &platform : platforms) {
for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
ToolchainPair platformToolchains = findToolchainForPlatform(platform, target,
existingClangToolChains);
existingClangToolchains);
auto createOrAdd = [&](GccToolchain *toolChain, Id l) {
if (!toolChain) {
toolChain = new GccToolchain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID,
@@ -606,7 +606,7 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
toolChain->setPlatformLinkerFlags(target.backendFlags);
toolChain->resetToolchain(l == ProjectExplorer::Constants::CXX_LANGUAGE_ID ?
platform.cxxCompilerPath : platform.cCompilerPath);
existingClangToolChains.append(toolChain);
existingClangToolchains.append(toolChain);
}
toolchains.append(toolChain);
};

16
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);
@@ -266,24 +266,24 @@ RawProjectPart MesonProjectParser::buildRawPart(
part.setIncludePaths(toAbsolutePath(m_buildDir, flags.includePaths));
part.setProjectFileLocation(target.definedIn);
if (sources.language == "cpp")
part.setFlagsForCxx({cxxToolChain, flags.args, {}});
part.setFlagsForCxx({cxxToolchain, flags.args, {}});
else if (sources.language == "c")
part.setFlagsForC({cToolChain, flags.args, {}});
part.setFlagsForC({cToolchain, flags.args, {}});
part.setQtVersion(m_qtVersion);
return part;
}
RawProjectParts MesonProjectParser::buildProjectParts(
const Toolchain *cxxToolChain, const Toolchain *cToolChain)
const Toolchain *cxxToolchain, const Toolchain *cToolchain)
{
RawProjectParts parts;
for_each_source_group(m_parserResult.targets,
[&parts,
&cxxToolChain,
&cToolChain,
&cxxToolchain,
&cToolchain,
this](const Target &target, const Target::SourceGroup &sourceList) {
parts.push_back(
buildRawPart(target, sourceList, cxxToolChain, cToolChain));
buildRawPart(target, sourceList, cxxToolchain, cToolchain));
});
return parts;
}

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;

2
src/plugins/nim/nimconstants.h
View File

@@ -13,7 +13,7 @@ const char C_NIMPROJECT_ID[] = "Nim.NimProject";
const char C_NIMBLEPROJECT_ID[] = "Nim.NimbleProject";
const char C_NIMEDITOR_ID[] = "Nim.NimEditor";
// NimToolChain
// NimToolchain
const char C_NIMTOOLCHAIN_TYPEID[] = "Nim.NimToolChain";
// NimProject

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

@@ -27,11 +27,11 @@ using namespace Utils;
namespace Nim {
NimToolChain::NimToolChain()
: NimToolChain(Constants::C_NIMTOOLCHAIN_TYPEID)
NimToolchain::NimToolchain()
: NimToolchain(Constants::C_NIMTOOLCHAIN_TYPEID)
{}
NimToolChain::NimToolChain(Utils::Id typeId)
NimToolchain::NimToolchain(Utils::Id typeId)
: Toolchain(typeId)
, m_version(std::make_tuple(-1,-1,-1))
{
@@ -41,45 +41,45 @@ NimToolChain::NimToolChain(Utils::Id typeId)
setCompilerCommandKey("Nim.NimToolChain.CompilerCommand");
}
Toolchain::MacroInspectionRunner NimToolChain::createMacroInspectionRunner() const
Toolchain::MacroInspectionRunner NimToolchain::createMacroInspectionRunner() const
{
return Toolchain::MacroInspectionRunner();
}
LanguageExtensions NimToolChain::languageExtensions(const QStringList &) const
LanguageExtensions NimToolchain::languageExtensions(const QStringList &) const
{
return LanguageExtension::None;
}
WarningFlags NimToolChain::warningFlags(const QStringList &) const
WarningFlags NimToolchain::warningFlags(const QStringList &) const
{
return WarningFlags::NoWarnings;
}
Toolchain::BuiltInHeaderPathsRunner NimToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner NimToolchain::createBuiltInHeaderPathsRunner(
const Environment &) const
{
return Toolchain::BuiltInHeaderPathsRunner();
}
void NimToolChain::addToEnvironment(Environment &env) const
void NimToolchain::addToEnvironment(Environment &env) const
{
if (isValid())
env.prependOrSetPath(compilerCommand().parentDir());
}
FilePath NimToolChain::makeCommand(const Environment &env) const
FilePath NimToolchain::makeCommand(const Environment &env) const
{
const FilePath tmp = env.searchInPath("make");
return tmp.isEmpty() ? FilePath("make") : tmp;
}
QList<Utils::OutputLineParser *> NimToolChain::createOutputParsers() const
QList<Utils::OutputLineParser *> NimToolchain::createOutputParsers() const
{
return {};
}
QString NimToolChain::compilerVersion() const
QString NimToolchain::compilerVersion() const
{
return compilerCommand().isEmpty() || m_version == std::make_tuple(-1,-1,-1)
? QString()
@@ -89,7 +89,7 @@ QString NimToolChain::compilerVersion() const
std::get<2>(m_version));
}
void NimToolChain::fromMap(const Store &data)
void NimToolchain::fromMap(const Store &data)
{
Toolchain::fromMap(data);
if (hasError())
@@ -97,7 +97,7 @@ void NimToolChain::fromMap(const Store &data)
parseVersion(compilerCommand(), m_version);
}
bool NimToolChain::parseVersion(const FilePath &path, std::tuple<int, int, int> &result)
bool NimToolchain::parseVersion(const FilePath &path, std::tuple<int, int, int> &result)
{
Process process;
process.setCommand({path, {"--version"}});
@@ -123,7 +123,7 @@ bool NimToolChain::parseVersion(const FilePath &path, std::tuple<int, int, int>
class NimToolchainConfigWidget : public ToolchainConfigWidget
{
public:
explicit NimToolchainConfigWidget(NimToolChain *tc)
explicit NimToolchainConfigWidget(NimToolchain *tc)
: ToolchainConfigWidget(tc)
, m_compilerCommand(new PathChooser)
, m_compilerVersion(new QLineEdit)
@@ -142,7 +142,7 @@ public:
// Connect
connect(m_compilerCommand, &PathChooser::validChanged, this, [this] {
const FilePath path = m_compilerCommand->rawFilePath();
auto tc = static_cast<NimToolChain *>(toolchain());
auto tc = static_cast<NimToolchain *>(toolchain());
QTC_ASSERT(tc, return);
tc->setCompilerCommand(path);
fillUI();
@@ -164,7 +164,7 @@ private:
void NimToolchainConfigWidget::applyImpl()
{
auto tc = static_cast<NimToolChain *>(toolchain());
auto tc = static_cast<NimToolchain *>(toolchain());
Q_ASSERT(tc);
if (tc->isAutoDetected())
return;
@@ -178,7 +178,7 @@ void NimToolchainConfigWidget::discardImpl()
bool NimToolchainConfigWidget::isDirtyImpl() const
{
auto tc = static_cast<NimToolChain *>(toolchain());
auto tc = static_cast<NimToolchain *>(toolchain());
Q_ASSERT(tc);
return tc->compilerCommand() != m_compilerCommand->filePath();
}
@@ -190,13 +190,13 @@ void NimToolchainConfigWidget::makeReadOnlyImpl()
void NimToolchainConfigWidget::fillUI()
{
auto tc = static_cast<NimToolChain *>(toolchain());
auto tc = static_cast<NimToolchain *>(toolchain());
Q_ASSERT(tc);
m_compilerCommand->setFilePath(tc->compilerCommand());
m_compilerVersion->setText(tc->compilerVersion());
}
std::unique_ptr<ToolchainConfigWidget> NimToolChain::createConfigurationWidget()
std::unique_ptr<ToolchainConfigWidget> NimToolchain::createConfigurationWidget()
{
return std::make_unique<NimToolchainConfigWidget>(this);
}
@@ -208,7 +208,7 @@ NimToolchainFactory::NimToolchainFactory()
setDisplayName(Tr::tr("Nim"));
setSupportedToolchainType(Constants::C_NIMTOOLCHAIN_TYPEID);
setSupportedLanguages({Constants::C_NIMLANGUAGE_ID});
setToolchainConstructor([] { return new NimToolChain; });
setToolchainConstructor([] { return new NimToolchain; });
setUserCreatable(true);
}
@@ -228,7 +228,7 @@ Toolchains NimToolchainFactory::autoDetect(const ToolchainDetector &detector) co
if (!result.empty())
return result;
auto tc = new NimToolChain;
auto tc = new NimToolchain;
tc->setDetection(Toolchain::AutoDetection);
tc->setCompilerCommand(compilerPath);
result.append(tc);
@@ -239,7 +239,7 @@ Toolchains NimToolchainFactory::detectForImport(const ToolchainDescription &tcd)
{
Toolchains result;
if (tcd.language == Constants::C_NIMLANGUAGE_ID) {
auto tc = new NimToolChain;
auto tc = new NimToolchain;
tc->setDetection(Toolchain::ManualDetection); // FIXME: sure?
tc->setCompilerCommand(tcd.compilerPath);
result.append(tc);

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

@@ -8,11 +8,11 @@
namespace Nim {
class NimToolChain : public ProjectExplorer::Toolchain
class NimToolchain : public ProjectExplorer::Toolchain
{
public:
NimToolChain();
explicit NimToolChain(Utils::Id typeId);
NimToolchain();
explicit NimToolchain(Utils::Id typeId);
MacroInspectionRunner createMacroInspectionRunner() const override;
Utils::LanguageExtensions languageExtensions(const QStringList &flags) const final;

2
src/plugins/projectexplorer/abi.cpp
View File

@@ -22,7 +22,7 @@
\brief The Abi class represents the Application Binary Interface (ABI) of
a target platform.
\sa ProjectExplorer::ToolChain
\sa ProjectExplorer::Toolchain
*/
namespace ProjectExplorer {

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

@@ -42,13 +42,13 @@ const char mkspecsKeyC[] = "ProjectExplorer.CustomToolChain.Mkspecs";
const char outputParserKeyC[] = "ProjectExplorer.CustomToolChain.OutputParser";
// --------------------------------------------------------------------------
// CustomToolChain
// CustomToolchain
// --------------------------------------------------------------------------
class CustomToolChain : public Toolchain
class CustomToolchain : public Toolchain
{
public:
CustomToolChain()
CustomToolchain()
: Toolchain(Constants::CUSTOM_TOOLCHAIN_TYPEID)
, m_outputParserId(GccParser::id())
{
@@ -96,7 +96,7 @@ public:
Id outputParserId() const;
void setOutputParserId(Id parserId);
static QList<CustomToolChain::Parser> parsers();
static QList<CustomToolchain::Parser> parsers();
CustomParserSettings customParserSettings() const;
@@ -111,7 +111,7 @@ private:
Id m_outputParserId;
};
CustomParserSettings CustomToolChain::customParserSettings() const
CustomParserSettings CustomToolchain::customParserSettings() const
{
return findOrDefault(ProjectExplorerPlugin::customParsers(),
[this](const CustomParserSettings &s) {
@@ -119,12 +119,12 @@ CustomParserSettings CustomToolChain::customParserSettings() const
});
}
bool CustomToolChain::isValid() const
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();
@@ -143,23 +143,23 @@ Toolchain::MacroInspectionRunner CustomToolChain::createMacroInspectionRunner()
};
}
LanguageExtensions CustomToolChain::languageExtensions(const QStringList &) const
LanguageExtensions CustomToolchain::languageExtensions(const QStringList &) const
{
return LanguageExtension::None;
}
WarningFlags CustomToolChain::warningFlags(const QStringList &cxxflags) const
WarningFlags CustomToolchain::warningFlags(const QStringList &cxxflags) const
{
Q_UNUSED(cxxflags)
return WarningFlags::Default;
}
const Macros &CustomToolChain::rawPredefinedMacros() const
const Macros &CustomToolchain::rawPredefinedMacros() const
{
return m_predefinedMacros;
}
void CustomToolChain::setPredefinedMacros(const Macros &macros)
void CustomToolchain::setPredefinedMacros(const Macros &macros)
{
if (m_predefinedMacros == macros)
return;
@@ -167,7 +167,7 @@ void CustomToolChain::setPredefinedMacros(const Macros &macros)
toolChainUpdated();
}
Toolchain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRunner(
Toolchain::BuiltInHeaderPathsRunner CustomToolchain::createBuiltInHeaderPathsRunner(
const Environment &) const
{
const HeaderPaths builtInHeaderPaths = m_builtInHeaderPaths;
@@ -185,7 +185,7 @@ Toolchain::BuiltInHeaderPathsRunner CustomToolChain::createBuiltInHeaderPathsRun
};
}
void CustomToolChain::addToEnvironment(Environment &env) const
void CustomToolchain::addToEnvironment(Environment &env) const
{
const FilePath compiler = compilerCommand();
if (compiler.isEmpty())
@@ -197,12 +197,12 @@ void CustomToolChain::addToEnvironment(Environment &env) const
env.prependOrSetPath(makePath);
}
QStringList CustomToolChain::suggestedMkspecList() const
QStringList CustomToolchain::suggestedMkspecList() const
{
return m_mkspecs;
}
QList<OutputLineParser *> CustomToolChain::createOutputParsers() const
QList<OutputLineParser *> CustomToolchain::createOutputParsers() const
{
if (m_outputParserId == GccParser::id())
return GccParser::gccParserSuite();
@@ -215,12 +215,12 @@ QList<OutputLineParser *> CustomToolChain::createOutputParsers() const
return {new CustomParser(customParserSettings())};
}
QStringList CustomToolChain::headerPathsList() const
QStringList CustomToolchain::headerPathsList() const
{
return Utils::transform<QList>(m_builtInHeaderPaths, &HeaderPath::path);
}
void CustomToolChain::setHeaderPaths(const QStringList &list)
void CustomToolchain::setHeaderPaths(const QStringList &list)
{
HeaderPaths tmp = Utils::transform<QVector>(list, [](const QString &headerPath) {
return HeaderPath::makeBuiltIn(headerPath.trimmed());
@@ -232,7 +232,7 @@ void CustomToolChain::setHeaderPaths(const QStringList &list)
toolChainUpdated();
}
void CustomToolChain::setMakeCommand(const FilePath &path)
void CustomToolchain::setMakeCommand(const FilePath &path)
{
if (path == m_makeCommand)
return;
@@ -240,12 +240,12 @@ void CustomToolChain::setMakeCommand(const FilePath &path)
toolChainUpdated();
}
FilePath CustomToolChain::makeCommand(const Environment &) const
FilePath CustomToolchain::makeCommand(const Environment &) const
{
return m_makeCommand;
}
void CustomToolChain::setCxx11Flags(const QStringList &flags)
void CustomToolchain::setCxx11Flags(const QStringList &flags)
{
if (flags == m_cxx11Flags)
return;
@@ -253,12 +253,12 @@ void CustomToolChain::setCxx11Flags(const QStringList &flags)
toolChainUpdated();
}
const QStringList &CustomToolChain::cxx11Flags() const
const QStringList &CustomToolchain::cxx11Flags() const
{
return m_cxx11Flags;
}
void CustomToolChain::setMkspecs(const QString &specs)
void CustomToolchain::setMkspecs(const QString &specs)
{
const QStringList tmp = specs.split(',');
if (tmp == m_mkspecs)
@@ -267,12 +267,12 @@ void CustomToolChain::setMkspecs(const QString &specs)
toolChainUpdated();
}
QString CustomToolChain::mkspecs() const
QString CustomToolchain::mkspecs() const
{
return m_mkspecs.join(',');
}
void CustomToolChain::toMap(Store &data) const
void CustomToolchain::toMap(Store &data) const
{
Toolchain::toMap(data);
data.insert(makeCommandKeyC, m_makeCommand.toString());
@@ -284,7 +284,7 @@ void CustomToolChain::toMap(Store &data) const
data.insert(outputParserKeyC, m_outputParserId.toSetting());
}
void CustomToolChain::fromMap(const Store &data)
void CustomToolchain::fromMap(const Store &data)
{
Toolchain::fromMap(data);
if (hasError())
@@ -299,12 +299,12 @@ 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))
return false;
auto customTc = static_cast<const CustomToolChain *>(&other);
auto customTc = static_cast<const CustomToolchain *>(&other);
return m_makeCommand == customTc->m_makeCommand
&& compilerCommand() == customTc->compilerCommand()
&& targetAbi() == customTc->targetAbi()
@@ -312,12 +312,12 @@ bool CustomToolChain::operator ==(const Toolchain &other) const
&& m_builtInHeaderPaths == customTc->m_builtInHeaderPaths;
}
Id CustomToolChain::outputParserId() const
Id CustomToolchain::outputParserId() const
{
return m_outputParserId;
}
void CustomToolChain::setOutputParserId(Id parserId)
void CustomToolchain::setOutputParserId(Id parserId)
{
if (m_outputParserId == parserId)
return;
@@ -325,9 +325,9 @@ void CustomToolChain::setOutputParserId(Id parserId)
toolChainUpdated();
}
QList<CustomToolChain::Parser> CustomToolChain::parsers()
QList<CustomToolchain::Parser> CustomToolchain::parsers()
{
QList<CustomToolChain::Parser> result;
QList<CustomToolchain::Parser> result;
result.append({GccParser::id(), Tr::tr("GCC")});
result.append({ClangParser::id(), Tr::tr("Clang")});
result.append({LinuxIccParser::id(), Tr::tr("ICC")});
@@ -380,13 +380,13 @@ public:
};
// --------------------------------------------------------------------------
// CustomToolChainConfigWidget
// CustomToolchainConfigWidget
// --------------------------------------------------------------------------
class CustomToolChainConfigWidget final : public ToolchainConfigWidget
class CustomToolchainConfigWidget final : public ToolchainConfigWidget
{
public:
explicit CustomToolChainConfigWidget(CustomToolChain *);
explicit CustomToolchainConfigWidget(CustomToolchain *);
private:
void updateSummaries(TextEditDetailsWidget *detailsWidget);
@@ -411,7 +411,7 @@ private:
QComboBox *m_errorParserComboBox;
};
CustomToolChainConfigWidget::CustomToolChainConfigWidget(CustomToolChain *tc) :
CustomToolchainConfigWidget::CustomToolchainConfigWidget(CustomToolchain *tc) :
ToolchainConfigWidget(tc),
m_compilerCommand(new PathChooser),
m_makeCommand(new PathChooser),
@@ -426,7 +426,7 @@ CustomToolChainConfigWidget::CustomToolChainConfigWidget(CustomToolChain *tc) :
{
Q_ASSERT(tc);
const QList<CustomToolChain::Parser> parsers = CustomToolChain::parsers();
const QList<CustomToolchain::Parser> parsers = CustomToolchain::parsers();
for (const auto &parser : parsers)
m_errorParserComboBox->addItem(parser.displayName, parser.parserId.toString());
for (const CustomParserSettings &s : ProjectExplorerPlugin::customParsers())
@@ -471,27 +471,27 @@ CustomToolChainConfigWidget::CustomToolChainConfigWidget(CustomToolChain *tc) :
connect(m_cxx11Flags, &QLineEdit::textChanged, this, &ToolchainConfigWidget::dirty);
connect(m_mkspecs, &QLineEdit::textChanged, this, &ToolchainConfigWidget::dirty);
connect(m_errorParserComboBox, &QComboBox::currentIndexChanged,
this, &CustomToolChainConfigWidget::errorParserChanged);
this, &CustomToolchainConfigWidget::errorParserChanged);
errorParserChanged();
}
void CustomToolChainConfigWidget::updateSummaries(TextEditDetailsWidget *detailsWidget)
void CustomToolchainConfigWidget::updateSummaries(TextEditDetailsWidget *detailsWidget)
{
detailsWidget->updateSummaryText();
emit dirty();
}
void CustomToolChainConfigWidget::errorParserChanged(int )
void CustomToolchainConfigWidget::errorParserChanged(int )
{
emit dirty();
}
void CustomToolChainConfigWidget::applyImpl()
void CustomToolchainConfigWidget::applyImpl()
{
if (toolchain()->isAutoDetected())
return;
auto tc = static_cast<CustomToolChain *>(toolchain());
auto tc = static_cast<CustomToolchain *>(toolchain());
Q_ASSERT(tc);
QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath());
@@ -513,11 +513,11 @@ void CustomToolChainConfigWidget::applyImpl()
// macro parser did with the input.
}
void CustomToolChainConfigWidget::setFromToolchain()
void CustomToolchainConfigWidget::setFromToolchain()
{
// subwidgets are not yet connected!
QSignalBlocker blocker(this);
auto tc = static_cast<CustomToolChain *>(toolchain());
auto tc = static_cast<CustomToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand());
m_makeCommand->setFilePath(tc->makeCommand(Environment()));
m_abiWidget->setAbis(Abis(), tc->targetAbi());
@@ -532,9 +532,9 @@ void CustomToolChainConfigWidget::setFromToolchain()
m_errorParserComboBox->setCurrentIndex(index);
}
bool CustomToolChainConfigWidget::isDirtyImpl() const
bool CustomToolchainConfigWidget::isDirtyImpl() const
{
auto tc = static_cast<CustomToolChain *>(toolchain());
auto tc = static_cast<CustomToolchain *>(toolchain());
Q_ASSERT(tc);
return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_makeCommand->filePath().toString() != tc->makeCommand(Environment()).toString()
@@ -546,17 +546,17 @@ bool CustomToolChainConfigWidget::isDirtyImpl() const
|| Id::fromSetting(m_errorParserComboBox->currentData()) == tc->outputParserId();
}
void CustomToolChainConfigWidget::makeReadOnlyImpl()
void CustomToolchainConfigWidget::makeReadOnlyImpl()
{
m_mainLayout->setEnabled(false);
}
std::unique_ptr<ToolchainConfigWidget> CustomToolChain::createConfigurationWidget()
std::unique_ptr<ToolchainConfigWidget> CustomToolchain::createConfigurationWidget()
{
return std::make_unique<CustomToolChainConfigWidget>(this);
return std::make_unique<CustomToolchainConfigWidget>(this);
}
// CustomToolChainFactory
// CustomToolchainFactory
class CustomToolchainFactory final : public ToolchainFactory
{
@@ -566,7 +566,7 @@ public:
setDisplayName(Tr::tr("Custom"));
setSupportedToolchainType(Constants::CUSTOM_TOOLCHAIN_TYPEID);
setSupportsAllLanguages(true);
setToolchainConstructor([] { return new CustomToolChain; });
setToolchainConstructor([] { return new CustomToolchain; });
setUserCreatable(true);
}
};

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

@@ -121,7 +121,7 @@ private:
void setFromToolchain();
void updateParentToolChainComboBox(); // Clang
void updateParentToolchainComboBox(); // Clang
AbiWidget *m_abiWidget;
@@ -136,7 +136,7 @@ private:
ProjectExplorer::Macros m_macros;
// Clang only
QList<QMetaObject::Connection> m_parentToolChainConnections;
QList<QMetaObject::Connection> m_parentToolchainConnections;
QComboBox *m_parentToolchainCombo = nullptr;
};
@@ -153,7 +153,7 @@ const char compilerPlatformLinkerFlagsKeyC[] = "ProjectExplorer.GccToolChain.Pla
const char targetAbiKeyC[] = "ProjectExplorer.GccToolChain.TargetAbi";
const char originalTargetTripleKeyC[] = "ProjectExplorer.GccToolChain.OriginalTargetTriple";
const char supportedAbisKeyC[] = "ProjectExplorer.GccToolChain.SupportedAbis";
const char parentToolChainIdKeyC[] = "ProjectExplorer.ClangToolChain.ParentToolChainId";
const char parentToolchainIdKeyC[] = "ProjectExplorer.ClangToolChain.ParentToolChainId";
const char priorityKeyC[] = "ProjectExplorer.ClangToolChain.Priority";
const char binaryRegexp[] = "(?:^|-|\\b)(?:gcc|g\\+\\+|clang(?:\\+\\+)?)(?:-([\\d.]+))?$";
@@ -434,19 +434,19 @@ LanguageExtensions GccToolchain::defaultLanguageExtensions() const
return LanguageExtension::Gnu;
}
static const Toolchains mingwToolChains()
static const Toolchains mingwToolchains()
{
return ToolchainManager::toolchains([](const Toolchain *tc) -> bool {
return tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID;
});
}
static const GccToolchain *mingwToolChainFromId(const QByteArray &id)
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);
}
@@ -457,7 +457,7 @@ static const GccToolchain *mingwToolChainFromId(const QByteArray &id)
QString GccToolchain::originalTargetTriple() const
{
if (m_subType == Clang) {
if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolchainId))
if (const GccToolchain *parentTC = mingwToolchainFromId(m_parentToolchainId))
return parentTC->originalTargetTriple();
}
@@ -1020,7 +1020,7 @@ void GccToolchain::toMap(Store &data) const
data.insert(supportedAbisKeyC, Utils::transform<QStringList>(m_supportedAbis, &Abi::toString));
if (m_subType == Clang) {
data.insert(parentToolChainIdKeyC, m_parentToolchainId);
data.insert(parentToolchainIdKeyC, m_parentToolchainId);
data.insert(priorityKeyC, m_priority);
}
}
@@ -1044,7 +1044,7 @@ void GccToolchain::fromMap(const Store &data)
resetToolchain(compilerCommand());
if (m_subType == Clang) {
m_parentToolchainId = data.value(parentToolChainIdKeyC).toByteArray();
m_parentToolchainId = data.value(parentToolchainIdKeyC).toByteArray();
m_priority = data.value(priorityKeyC, PriorityNormal).toInt();
syncAutodetectedWithParentToolchains();
}
@@ -1316,7 +1316,7 @@ private:
const Id requiredTypeId,
const Toolchains &known,
const GccToolchain::SubType subType);
static Toolchains autoDetectToolChain(const ToolchainDescription &tcd,
static Toolchains autoDetectToolchain(const ToolchainDescription &tcd,
const GccToolchain::SubType subType);
static Toolchains autoDetectSdkClangToolchain(const Toolchains &known);
@@ -1518,7 +1518,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
if ((tcd.language == Constants::CXX_LANGUAGE_ID && fileName.startsWith("icpc")) ||
(tcd.language == Constants::C_LANGUAGE_ID && fileName.startsWith("icc"))) {
result += autoDetectToolChain(tcd, GccToolchain::LinuxIcc);
result += autoDetectToolchain(tcd, GccToolchain::LinuxIcc);
}
bool isCCompiler = tcd.language == Constants::C_LANGUAGE_ID
@@ -1530,7 +1530,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
|| (fileName == "c++" && resolvedSymlinksFileName.contains("clang")));
if (isCCompiler || isCxxCompiler)
result += autoDetectToolChain(tcd, GccToolchain::Clang);
result += autoDetectToolchain(tcd, GccToolchain::Clang);
// GCC
@@ -1545,7 +1545,7 @@ Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd)
|| (fileName == "c++" && !resolvedSymlinksFileName.contains("clang")));
if (isCCompiler || isCxxCompiler)
result += autoDetectToolChain(tcd, GccToolchain::RealGcc);
result += autoDetectToolchain(tcd, GccToolchain::RealGcc);
return result;
}
@@ -1561,7 +1561,7 @@ Toolchains GccToolchainFactory::autoDetectSdkClangToolchain(const Toolchains &kn
return {existingTc};
}
return {autoDetectToolChain({compilerPath, Constants::C_LANGUAGE_ID}, GccToolchain::Clang)};
return {autoDetectToolchain({compilerPath, Constants::C_LANGUAGE_ID}, GccToolchain::Clang)};
}
Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPaths,
@@ -1606,7 +1606,7 @@ Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPa
}
}
if (!alreadyExists) {
const Toolchains newToolchains = autoDetectToolChain({compilerPath, language}, subType);
const Toolchains newToolchains = autoDetectToolchain({compilerPath, language}, subType);
result << newToolchains;
existingCandidates << newToolchains;
}
@@ -1615,7 +1615,7 @@ Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPa
return result;
}
Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &tcd,
Toolchains GccToolchainFactory::autoDetectToolchain(const ToolchainDescription &tcd,
GccToolchain::SubType subType)
{
Toolchains result;
@@ -1757,28 +1757,28 @@ GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
m_parentToolchainCombo);
ToolchainManager *tcManager = ToolchainManager::instance();
m_parentToolChainConnections.append(
m_parentToolchainConnections.append(
connect(tcManager, &ToolchainManager::toolchainUpdated, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
updateParentToolChainComboBox();
updateParentToolchainComboBox();
}));
m_parentToolChainConnections.append(
m_parentToolchainConnections.append(
connect(tcManager, &ToolchainManager::toolhainAdded, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
updateParentToolChainComboBox();
updateParentToolchainComboBox();
}));
m_parentToolChainConnections.append(
m_parentToolchainConnections.append(
connect(tcManager, &ToolchainManager::toolchainRemoved, this, [this](Toolchain *tc) {
if (tc->id() == toolchain()->id()) {
for (QMetaObject::Connection &connection : m_parentToolChainConnections)
for (QMetaObject::Connection &connection : m_parentToolchainConnections)
QObject::disconnect(connection);
return;
}
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
updateParentToolChainComboBox();
updateParentToolchainComboBox();
}));
updateParentToolChainComboBox();
updateParentToolchainComboBox();
}
}
@@ -1817,7 +1817,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());
@@ -1846,7 +1846,7 @@ void GccToolchainConfigWidget::setFromToolchain()
}
if (m_parentToolchainCombo)
updateParentToolChainComboBox();
updateParentToolchainComboBox();
}
bool GccToolchainConfigWidget::isDirtyImpl() const
@@ -1867,7 +1867,7 @@ bool GccToolchainConfigWidget::isDirtyImpl() const
if (!m_parentToolchainCombo)
return false;
const GccToolchain *parentTC = mingwToolChainFromId(tc->m_parentToolchainId);
const GccToolchain *parentTC = mingwToolchainFromId(tc->m_parentToolchainId);
const QByteArray parentId = parentTC ? parentTC->id() : QByteArray();
return parentId != m_parentToolchainCombo->currentData();
}
@@ -1942,7 +1942,7 @@ void GccToolchainConfigWidget::handlePlatformLinkerFlagsChange()
}
// --------------------------------------------------------------------------
// ClangToolChain
// ClangToolchain
// --------------------------------------------------------------------------
void GccToolchain::syncAutodetectedWithParentToolchains()
@@ -1966,8 +1966,8 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
return;
}
if (!mingwToolChainFromId(m_parentToolchainId)) {
const Toolchains mingwTCs = mingwToolChains();
if (!mingwToolchainFromId(m_parentToolchainId)) {
const Toolchains mingwTCs = mingwToolchains();
m_parentToolchainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
}
@@ -1976,7 +1976,7 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
m_mingwToolchainAddedConnection
= connect(tcManager, &ToolchainManager::toolhainAdded, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID
&& !mingwToolChainFromId(m_parentToolchainId)) {
&& !mingwToolchainFromId(m_parentToolchainId)) {
m_parentToolchainId = tc->id();
}
});
@@ -1986,7 +1986,7 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
QObject::disconnect(m_thisToolchainRemovedConnection);
QObject::disconnect(m_mingwToolchainAddedConnection);
} else if (m_parentToolchainId == tc->id()) {
const Toolchains mingwTCs = mingwToolChains();
const Toolchains mingwTCs = mingwToolchains();
m_parentToolchainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
}
});
@@ -2017,7 +2017,7 @@ bool GccToolchain::matchesCompilerCommand(const FilePath &command) const
QString GccToolchain::sysRoot() const
{
if (m_subType == Clang) {
if (const GccToolchain *parentTC = mingwToolChainFromId(m_parentToolchainId)) {
if (const GccToolchain *parentTC = mingwToolchainFromId(m_parentToolchainId)) {
const FilePath mingwCompiler = parentTC->compilerCommand();
return mingwCompiler.parentDir().parentDir().toString();
}
@@ -2025,7 +2025,7 @@ QString GccToolchain::sysRoot() const
return {};
}
void GccToolchainConfigWidget::updateParentToolChainComboBox()
void GccToolchainConfigWidget::updateParentToolchainComboBox()
{
QTC_ASSERT(m_parentToolchainCombo, return);
@@ -2034,7 +2034,7 @@ void GccToolchainConfigWidget::updateParentToolChainComboBox()
if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0)
parentId = tc->m_parentToolchainId;
const GccToolchain *parentTC = mingwToolChainFromId(parentId);
const GccToolchain *parentTC = mingwToolchainFromId(parentId);
m_parentToolchainCombo->clear();
m_parentToolchainCombo->addItem(parentTC ? parentTC->displayName() : QString(),
@@ -2043,7 +2043,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())

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

@@ -223,7 +223,7 @@ public:
++row;
connect(cb, &QComboBox::currentIndexChanged, this, [this, l](int idx) {
currentToolChainChanged(l, idx);
currentToolchainChanged(l, idx);
});
}
@@ -286,7 +286,7 @@ private:
cb->setEnabled(false);
}
void currentToolChainChanged(Id language, int idx)
void currentToolchainChanged(Id language, int idx)
{
if (m_ignoreChanges.isLocked() || idx < 0)
return;
@@ -370,7 +370,7 @@ static QMap<Id, QByteArray> defaultToolChainIds()
return toolChains;
}
static Store defaultToolChainValue()
static Store defaultToolchainValue()
{
const QMap<Id, QByteArray> toolChains = defaultToolChainIds();
Store result;
@@ -432,7 +432,7 @@ void ToolchainKitAspectFactory::setup(Kit *k)
Store value = storeFromVariant(k->value(id()));
bool lockToolchains = k->isSdkProvided() && !value.isEmpty();
if (value.empty())
value = defaultToolChainValue();
value = defaultToolchainValue();
for (auto i = value.constBegin(); i != value.constEnd(); ++i) {
Id l = findLanguage(stringFromKey(i.key()));
@@ -594,7 +594,7 @@ void ToolchainKitAspect::setToolchain(Kit *k, Toolchain *tc)
}
/**
* @brief ToolChainKitAspect::setAllToolChainsToMatch
* @brief ToolchainKitAspect::setAllToolchainsToMatch
*
* Set up all toolchains to be similar to the one toolchain provided. Similar ideally means
* that all toolchains use the "same" compiler from the same installation, but we will

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

@@ -127,7 +127,7 @@ 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) {
@@ -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,7 +169,7 @@ Task MakeStep::makeCommandMissingTask()
bool MakeStep::isJobCountSupported() const
{
const QList<Toolchain *> tcs = preferredToolChains(kit());
const QList<Toolchain *> tcs = preferredToolchains(kit());
const Toolchain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
return tc && tc->isJobCountSupported();
}
@@ -236,7 +236,7 @@ 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 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) {

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

File diff suppressed because it is too large Load Diff

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

@@ -4,7 +4,6 @@
#pragma once
#include "abi.h"
#include "abiwidget.h"
#include "toolchain.h"
#include "toolchainconfigwidget.h"
@@ -20,15 +19,15 @@ namespace ProjectExplorer::Internal {
// MsvcToolChain
// --------------------------------------------------------------------------
class MsvcToolChain : public Toolchain
class MsvcToolchain : public Toolchain
{
public:
enum Type { WindowsSDK, VS };
enum Platform { x86, amd64, x86_amd64, ia64, x86_ia64, arm, x86_arm, amd64_arm, amd64_x86,
x86_arm64, amd64_arm64, arm64, arm64_x86, arm64_amd64 };
explicit MsvcToolChain(Utils::Id typeId);
~MsvcToolChain() override;
explicit MsvcToolchain(Utils::Id typeId);
~MsvcToolchain() override;
bool isValid() const override;
@@ -127,10 +126,10 @@ protected:
QString m_varsBatArg; // Argument
};
class PROJECTEXPLORER_EXPORT ClangClToolChain : public MsvcToolChain
class PROJECTEXPLORER_EXPORT ClangClToolchain : public MsvcToolchain
{
public:
ClangClToolChain();
ClangClToolchain();
bool isValid() const override;
QStringList suggestedMkspecList() const override;
@@ -143,7 +142,7 @@ public:
BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
const Utils::Environment &env) const override;
const QList<MsvcToolChain *> &msvcToolchains() const;
const QList<MsvcToolchain *> &msvcToolchains() const;
Utils::FilePath clangPath() const { return m_clangPath; }
void setClangPath(const Utils::FilePath &path) { m_clangPath = path; }

2
src/plugins/projectexplorer/project.cpp
View File

@@ -1617,7 +1617,7 @@ void ProjectExplorerPlugin::testSourceToBinaryMapping()
const auto toolchain = ToolchainKitAspect::cxxToolchain(kit);
QVERIFY(toolchain);
if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolChain *>(toolchain)) {
if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolchain *>(toolchain)) {
while (!msvcToolchain->environmentInitialized()) {
QSignalSpy parsingFinishedSpy(ToolchainManager::instance(),
&ToolchainManager::toolchainUpdated);

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

@@ -54,8 +54,8 @@ static bool hasOtherUsers(Utils::Id id, const QVariant &v, Kit *k)
ProjectImporter::ProjectImporter(const Utils::FilePath &path) : m_projectPath(path)
{
useTemporaryKitAspect(ToolchainKitAspect::id(),
[this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolChains(k, vl); },
[this](Kit *k, const QVariantList &vl) { persistTemporaryToolChains(k, vl); });
[this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolchains(k, vl); },
[this](Kit *k, const QVariantList &vl) { persistTemporaryToolchains(k, vl); });
}
ProjectImporter::~ProjectImporter()
@@ -316,7 +316,7 @@ static Toolchain *toolChainFromVariant(const QVariant &v)
return ToolchainManager::findToolchain(tcId);
}
void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
void ProjectImporter::cleanupTemporaryToolchains(Kit *k, const QVariantList &vl)
{
for (const QVariant &v : vl) {
Toolchain *tc = toolChainFromVariant(v);
@@ -326,7 +326,7 @@ void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
}
}
void ProjectImporter::persistTemporaryToolChains(Kit *k, const QVariantList &vl)
void ProjectImporter::persistTemporaryToolchains(Kit *k, const QVariantList &vl)
{
for (const QVariant &v : vl) {
Toolchain *tmpTc = toolChainFromVariant(v);

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

@@ -93,8 +93,8 @@ private:
void markKitAsTemporary(Kit *k) const;
bool findTemporaryHandler(Utils::Id id) const;
void cleanupTemporaryToolChains(ProjectExplorer::Kit *k, const QVariantList &vl);
void persistTemporaryToolChains(ProjectExplorer::Kit *k, const QVariantList &vl);
void cleanupTemporaryToolchains(ProjectExplorer::Kit *k, const QVariantList &vl);
void persistTemporaryToolchains(ProjectExplorer::Kit *k, const QVariantList &vl);
const Utils::FilePath m_projectPath;
mutable bool m_isUpdating = false;

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

@@ -21,7 +21,7 @@ RawProjectPartFlags::RawProjectPartFlags(const Toolchain *toolChain,
const Utils::FilePath &includeFileBaseDir)
{
// Keep the following cheap/non-blocking for the ui thread. Expensive
// operations are encapsulated in ToolChainInfo as "runners".
// operations are encapsulated in ToolchainInfo as "runners".
this->commandLineFlags = commandLineFlags;
if (toolChain) {
warningFlags = toolChain->warningFlags(commandLineFlags);

6
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;
@@ -117,7 +117,7 @@ void ToolchainManager::saveToolchains()
{
QTC_ASSERT(d->m_accessor, return);
d->m_accessor->saveToolChains(d->m_toolChains, Core::ICore::dialogParent());
d->m_accessor->saveToolchains(d->m_toolChains, Core::ICore::dialogParent());
QtcSettings *const s = Core::ICore::settings();
s->setValueWithDefault(DETECT_X64_AS_X32_KEY,
d->m_detectionSettings.detectX64AsX32,
@@ -254,7 +254,7 @@ bool ToolchainManager::isLanguageSupported(const Utils::Id &id)
void ToolchainManager::aboutToShutdown()
{
if (HostOsInfo::isWindowsHost())
MsvcToolChain::cancelMsvcToolChainDetection();
MsvcToolchain::cancelMsvcToolChainDetection();
}
ToolchainDetectionSettings ToolchainManager::detectionSettings()

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

@@ -193,7 +193,7 @@ ToolchainSettingsAccessor::ToolchainSettingsAccessor()
addVersionUpgrader(std::make_unique<ToolChainSettingsUpgraderV0>());
}
Toolchains ToolchainSettingsAccessor::restoreToolChains(QWidget *parent) const
Toolchains ToolchainSettingsAccessor::restoreToolchains(QWidget *parent) const
{
NANOTRACE_SCOPE("ProjectExplorer", "ToolChainSettingsAccessor::restoreToolChains");
// read all tool chains from SDK
@@ -229,7 +229,7 @@ Toolchains ToolchainSettingsAccessor::restoreToolChains(QWidget *parent) const
return ops.toRegister;
}
void ToolchainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWidget *parent)
void ToolchainSettingsAccessor::saveToolchains(const Toolchains &toolchains, QWidget *parent)
{
Store data;

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

@@ -18,9 +18,9 @@ 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;

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

@@ -316,7 +316,7 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
if (toolchain.contains(QLatin1String("clang-cl"))) {
data.insert(QLatin1String(CPP_COMPILERNAME), mainCompilerName);
const auto clangClToolchain =
static_cast<ProjectExplorer::Internal::ClangClToolChain *>(mainTc);
static_cast<ProjectExplorer::Internal::ClangClToolchain *>(mainTc);
data.insert(QLatin1String(CPP_VCVARSALLPATH), clangClToolchain->varsBat());
} else if (toolchain.contains(QLatin1String("msvc"))) {
data.insert(QLatin1String(CPP_COMPILERNAME), mainCompilerName);

16
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,
@@ -850,8 +850,8 @@ static RawProjectPart generateProjectPart(
QStringList cFlags;
QStringList cxxFlags;
getExpandedCompilerFlags(cFlags, cxxFlags, props);
rpp.setFlagsForC({cToolChain.get(), cFlags, {}});
rpp.setFlagsForCxx({cxxToolChain.get(), cxxFlags, {}});
rpp.setFlagsForC({cToolchain.get(), cFlags, {}});
rpp.setFlagsForCxx({cxxToolchain.get(), cxxFlags, {}});
const QStringList defines = arrayToStringList(props.value("cpp.defines"))
+ arrayToStringList(props.value("cpp.platformDefines"));
@@ -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
)
{
@@ -986,11 +986,11 @@ static RawProjectParts generateProjectParts(
};
for (const QJsonValue &g : groups) {
appendIfNotEmpty(generateProjectPart(
prd, g.toObject(), cToolChain, cxxToolChain, qtVersionForPart,
prd, g.toObject(), cToolchain, cxxToolchain, qtVersionForPart,
cPch, cxxPch, objcPch, objcxxPch));
}
appendIfNotEmpty(generateProjectPart(
prd, {}, cToolChain, cxxToolChain, qtVersionForPart,
prd, {}, cToolchain, cxxToolchain, qtVersionForPart,
cPch, cxxPch, objcPch, objcxxPch));
});
return rpps;

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

@@ -84,7 +84,7 @@ class QnxPlugin final : public ExtensionSystem::IPlugin
void initialize() final
{
setupQnxDevice();
setupQnxToolChain();
setupQnxToolchain();
setupQnxQtVersion();
setupQnxDeployment();
setupQnxRunnning();

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

@@ -277,7 +277,7 @@ public:
}
};
void setupQnxToolChain()
void setupQnxToolchain()
{
static QnxToolchainFactory theQnxToolChainFactory;
}

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

@@ -26,6 +26,6 @@ protected:
DetectedAbisResult detectSupportedAbis() const override;
};
void setupQnxToolChain();
void setupQnxToolchain();
} // Qnx::Internal

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

@@ -242,7 +242,7 @@ void QtKitAspectFactory::fix(Kit *k)
if (!possibleTcs.isEmpty()) {
// Prefer exact matches.
// TODO: We should probably prefer the compiler with the highest version number instead,
// but this information is currently not exposed by the ToolChain class.
// 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) {
const QVector<Abi> &qtAbis = version->qtAbis();

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

@@ -192,7 +192,7 @@ private:
};
ValidityInfo validInformation(const QtVersion *version);
QList<ProjectExplorer::Toolchain*> toolChains(const QtVersion *version);
QByteArray defaultToolChainId(const QtVersion *version);
QByteArray defaultToolchainId(const QtVersion *version);
bool isNameUnique(const QtVersion *version);
void updateVersionItem(QtVersionItem *item);
@@ -484,7 +484,7 @@ QtSettingsPageWidget::ValidityInfo QtSettingsPageWidget::validInformation(const
}
// Do we have tool chain issues?
Abis missingToolChains;
Abis missingToolchains;
const Abis qtAbis = version->qtAbis();
for (const Abi &abi : qtAbis) {
@@ -495,7 +495,7 @@ QtSettingsPageWidget::ValidityInfo QtSettingsPageWidget::validInformation(const
};
if (!ToolchainManager::toolchain(abiCompatePred))
missingToolChains.append(abi);
missingToolchains.append(abi);
}
bool useable = true;
@@ -503,8 +503,8 @@ QtSettingsPageWidget::ValidityInfo QtSettingsPageWidget::validInformation(const
if (!isNameUnique(version))
warnings << Tr::tr("Display Name is not unique.");
if (!missingToolChains.isEmpty()) {
if (missingToolChains.count() == qtAbis.size()) {
if (!missingToolchains.isEmpty()) {
if (missingToolchains.count() == qtAbis.size()) {
// Yes, this Qt version can't be used at all!
info.message =
Tr::tr("No compiler can produce code for this Qt version."
@@ -515,7 +515,7 @@ QtSettingsPageWidget::ValidityInfo QtSettingsPageWidget::validInformation(const
// Yes, some ABIs are unsupported
warnings << Tr::tr("Not all possible target environments can be supported due to missing compilers.");
info.toolTip = Tr::tr("The following ABIs are currently not supported: %1")
.arg(formatAbiHtmlList(missingToolChains));
.arg(formatAbiHtmlList(missingToolchains));
info.icon = m_warningVersionIcon;
}
}
@@ -550,7 +550,7 @@ QList<Toolchain*> QtSettingsPageWidget::toolChains(const QtVersion *version)
return toolChains;
}
QByteArray QtSettingsPageWidget::defaultToolChainId(const QtVersion *version)
QByteArray QtSettingsPageWidget::defaultToolchainId(const QtVersion *version)
{
QList<Toolchain*> possibleToolChains = toolChains(version);
if (!possibleToolChains.isEmpty())