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) if (detector.device->type() != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
return {}; return {};
QList<GccToolchain *> existingClangToolChains = clangToolchains(detector.alreadyKnown); QList<GccToolchain *> existingClangToolchains = clangToolchains(detector.alreadyKnown);
const QList<XcodePlatform> platforms = XcodeProbe::detectPlatforms().values(); const QList<XcodePlatform> platforms = XcodeProbe::detectPlatforms().values();
Toolchains toolchains; Toolchains toolchains;
toolchains.reserve(platforms.size()); toolchains.reserve(platforms.size());
for (const XcodePlatform &platform : platforms) { for (const XcodePlatform &platform : platforms) {
for (const XcodePlatform::ToolchainTarget &target : platform.targets) { for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
ToolchainPair platformToolchains = findToolchainForPlatform(platform, target, ToolchainPair platformToolchains = findToolchainForPlatform(platform, target,
existingClangToolChains); existingClangToolchains);
auto createOrAdd = [&](GccToolchain *toolChain, Id l) { auto createOrAdd = [&](GccToolchain *toolChain, Id l) {
if (!toolChain) { if (!toolChain) {
toolChain = new GccToolchain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID, toolChain = new GccToolchain(ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID,
@@ -606,7 +606,7 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
toolChain->setPlatformLinkerFlags(target.backendFlags); toolChain->setPlatformLinkerFlags(target.backendFlags);
toolChain->resetToolchain(l == ProjectExplorer::Constants::CXX_LANGUAGE_ID ? toolChain->resetToolchain(l == ProjectExplorer::Constants::CXX_LANGUAGE_ID ?
platform.cxxCompilerPath : platform.cCompilerPath); platform.cxxCompilerPath : platform.cCompilerPath);
existingClangToolChains.append(toolChain); existingClangToolchains.append(toolChain);
} }
toolchains.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( RawProjectPart MesonProjectParser::buildRawPart(
const Target &target, const Target &target,
const Target::SourceGroup &sources, const Target::SourceGroup &sources,
const Toolchain *cxxToolChain, const Toolchain *cxxToolchain,
const Toolchain *cToolChain) const Toolchain *cToolchain)
{ {
RawProjectPart part; RawProjectPart part;
part.setDisplayName(target.name); part.setDisplayName(target.name);
@@ -266,24 +266,24 @@ RawProjectPart MesonProjectParser::buildRawPart(
part.setIncludePaths(toAbsolutePath(m_buildDir, flags.includePaths)); part.setIncludePaths(toAbsolutePath(m_buildDir, flags.includePaths));
part.setProjectFileLocation(target.definedIn); part.setProjectFileLocation(target.definedIn);
if (sources.language == "cpp") if (sources.language == "cpp")
part.setFlagsForCxx({cxxToolChain, flags.args, {}}); part.setFlagsForCxx({cxxToolchain, flags.args, {}});
else if (sources.language == "c") else if (sources.language == "c")
part.setFlagsForC({cToolChain, flags.args, {}}); part.setFlagsForC({cToolchain, flags.args, {}});
part.setQtVersion(m_qtVersion); part.setQtVersion(m_qtVersion);
return part; return part;
} }
RawProjectParts MesonProjectParser::buildProjectParts( RawProjectParts MesonProjectParser::buildProjectParts(
const Toolchain *cxxToolChain, const Toolchain *cToolChain) const Toolchain *cxxToolchain, const Toolchain *cToolchain)
{ {
RawProjectParts parts; RawProjectParts parts;
for_each_source_group(m_parserResult.targets, for_each_source_group(m_parserResult.targets,
[&parts, [&parts,
&cxxToolChain, &cxxToolchain,
&cToolChain, &cToolchain,
this](const Target &target, const Target::SourceGroup &sourceList) { this](const Target &target, const Target::SourceGroup &sourceList) {
parts.push_back( parts.push_back(
buildRawPart(target, sourceList, cxxToolChain, cToolChain)); buildRawPart(target, sourceList, cxxToolchain, cToolchain));
}); });
return parts; return parts;
} }

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

@@ -57,8 +57,8 @@ public:
QList<ProjectExplorer::BuildTargetInfo> appsTargets() const; QList<ProjectExplorer::BuildTargetInfo> appsTargets() const;
ProjectExplorer::RawProjectParts buildProjectParts( ProjectExplorer::RawProjectParts buildProjectParts(
const ProjectExplorer::Toolchain *cxxToolChain, const ProjectExplorer::Toolchain *cxxToolchain,
const ProjectExplorer::Toolchain *cToolChain); const ProjectExplorer::Toolchain *cToolchain);
void setEnvironment(const Utils::Environment &environment) { m_env = environment; } void setEnvironment(const Utils::Environment &environment) { m_env = environment; }
@@ -78,8 +78,8 @@ private:
void update(const QFuture<ParserData *> &data); void update(const QFuture<ParserData *> &data);
ProjectExplorer::RawProjectPart buildRawPart(const Target &target, ProjectExplorer::RawProjectPart buildRawPart(const Target &target,
const Target::SourceGroup &sources, const Target::SourceGroup &sources,
const ProjectExplorer::Toolchain *cxxToolChain, const ProjectExplorer::Toolchain *cxxToolchain,
const ProjectExplorer::Toolchain *cToolChain); const ProjectExplorer::Toolchain *cToolchain);
MesonOutputParser m_outputParser; MesonOutputParser m_outputParser;
Utils::Environment m_env; 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_NIMBLEPROJECT_ID[] = "Nim.NimbleProject";
const char C_NIMEDITOR_ID[] = "Nim.NimEditor"; const char C_NIMEDITOR_ID[] = "Nim.NimEditor";
// NimToolChain // NimToolchain
const char C_NIMTOOLCHAIN_TYPEID[] = "Nim.NimToolChain"; const char C_NIMTOOLCHAIN_TYPEID[] = "Nim.NimToolChain";
// NimProject // NimProject

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

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

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

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

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

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

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

@@ -223,7 +223,7 @@ public:
++row; ++row;
connect(cb, &QComboBox::currentIndexChanged, this, [this, l](int idx) { connect(cb, &QComboBox::currentIndexChanged, this, [this, l](int idx) {
currentToolChainChanged(l, idx); currentToolchainChanged(l, idx);
}); });
} }
@@ -286,7 +286,7 @@ private:
cb->setEnabled(false); cb->setEnabled(false);
} }
void currentToolChainChanged(Id language, int idx) void currentToolchainChanged(Id language, int idx)
{ {
if (m_ignoreChanges.isLocked() || idx < 0) if (m_ignoreChanges.isLocked() || idx < 0)
return; return;
@@ -370,7 +370,7 @@ static QMap<Id, QByteArray> defaultToolChainIds()
return toolChains; return toolChains;
} }
static Store defaultToolChainValue() static Store defaultToolchainValue()
{ {
const QMap<Id, QByteArray> toolChains = defaultToolChainIds(); const QMap<Id, QByteArray> toolChains = defaultToolChainIds();
Store result; Store result;
@@ -432,7 +432,7 @@ void ToolchainKitAspectFactory::setup(Kit *k)
Store value = storeFromVariant(k->value(id())); Store value = storeFromVariant(k->value(id()));
bool lockToolchains = k->isSdkProvided() && !value.isEmpty(); bool lockToolchains = k->isSdkProvided() && !value.isEmpty();
if (value.empty()) if (value.empty())
value = defaultToolChainValue(); value = defaultToolchainValue();
for (auto i = value.constBegin(); i != value.constEnd(); ++i) { for (auto i = value.constBegin(); i != value.constEnd(); ++i) {
Id l = findLanguage(stringFromKey(i.key())); 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 * 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 * 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"); 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 // 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) {
@@ -146,7 +146,7 @@ static const QList<Toolchain *> preferredToolChains(const Kit *kit)
FilePath MakeStep::defaultMakeCommand() const FilePath MakeStep::defaultMakeCommand() const
{ {
const Environment env = makeEnvironment(); const Environment env = makeEnvironment();
for (const Toolchain *tc : preferredToolChains(kit())) { for (const Toolchain *tc : preferredToolchains(kit())) {
FilePath make = tc->makeCommand(env); FilePath make = tc->makeCommand(env);
if (!make.isEmpty()) { if (!make.isEmpty()) {
IDevice::ConstPtr dev = BuildDeviceKitAspect::device(kit()); IDevice::ConstPtr dev = BuildDeviceKitAspect::device(kit());
@@ -169,7 +169,7 @@ Task MakeStep::makeCommandMissingTask()
bool MakeStep::isJobCountSupported() const bool MakeStep::isJobCountSupported() const
{ {
const QList<Toolchain *> tcs = preferredToolChains(kit()); const QList<Toolchain *> tcs = preferredToolchains(kit());
const Toolchain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst(); const Toolchain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
return tc && tc->isJobCountSupported(); return tc && tc->isJobCountSupported();
} }
@@ -236,7 +236,7 @@ Environment MakeStep::makeEnvironment() const
env.setupEnglishOutput(); env.setupEnglishOutput();
if (makeCommand().isEmpty()) { if (makeCommand().isEmpty()) {
// We also prepend "L" to the MAKEFLAGS, so that nmake / jom are less verbose // 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(); const Toolchain *tc = tcs.isEmpty() ? nullptr : tcs.constFirst();
if (tc && tc->targetAbi().os() == Abi::WindowsOS if (tc && tc->targetAbi().os() == Abi::WindowsOS
&& tc->targetAbi().osFlavor() != Abi::WindowsMSysFlavor) { && 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 #pragma once
#include "abi.h" #include "abi.h"
#include "abiwidget.h"
#include "toolchain.h" #include "toolchain.h"
#include "toolchainconfigwidget.h" #include "toolchainconfigwidget.h"
@@ -20,15 +19,15 @@ namespace ProjectExplorer::Internal {
// MsvcToolChain // MsvcToolChain
// -------------------------------------------------------------------------- // --------------------------------------------------------------------------
class MsvcToolChain : public Toolchain class MsvcToolchain : public Toolchain
{ {
public: public:
enum Type { WindowsSDK, VS }; enum Type { WindowsSDK, VS };
enum Platform { x86, amd64, x86_amd64, ia64, x86_ia64, arm, x86_arm, amd64_arm, amd64_x86, 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 }; x86_arm64, amd64_arm64, arm64, arm64_x86, arm64_amd64 };
explicit MsvcToolChain(Utils::Id typeId); explicit MsvcToolchain(Utils::Id typeId);
~MsvcToolChain() override; ~MsvcToolchain() override;
bool isValid() const override; bool isValid() const override;
@@ -127,10 +126,10 @@ protected:
QString m_varsBatArg; // Argument QString m_varsBatArg; // Argument
}; };
class PROJECTEXPLORER_EXPORT ClangClToolChain : public MsvcToolChain class PROJECTEXPLORER_EXPORT ClangClToolchain : public MsvcToolchain
{ {
public: public:
ClangClToolChain(); ClangClToolchain();
bool isValid() const override; bool isValid() const override;
QStringList suggestedMkspecList() const override; QStringList suggestedMkspecList() const override;
@@ -143,7 +142,7 @@ public:
BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner( BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner(
const Utils::Environment &env) const override; const Utils::Environment &env) const override;
const QList<MsvcToolChain *> &msvcToolchains() const; const QList<MsvcToolchain *> &msvcToolchains() const;
Utils::FilePath clangPath() const { return m_clangPath; } Utils::FilePath clangPath() const { return m_clangPath; }
void setClangPath(const Utils::FilePath &path) { m_clangPath = path; } 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); const auto toolchain = ToolchainKitAspect::cxxToolchain(kit);
QVERIFY(toolchain); QVERIFY(toolchain);
if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolChain *>(toolchain)) { if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolchain *>(toolchain)) {
while (!msvcToolchain->environmentInitialized()) { while (!msvcToolchain->environmentInitialized()) {
QSignalSpy parsingFinishedSpy(ToolchainManager::instance(), QSignalSpy parsingFinishedSpy(ToolchainManager::instance(),
&ToolchainManager::toolchainUpdated); &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) ProjectImporter::ProjectImporter(const Utils::FilePath &path) : m_projectPath(path)
{ {
useTemporaryKitAspect(ToolchainKitAspect::id(), useTemporaryKitAspect(ToolchainKitAspect::id(),
[this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolChains(k, vl); }, [this](Kit *k, const QVariantList &vl) { cleanupTemporaryToolchains(k, vl); },
[this](Kit *k, const QVariantList &vl) { persistTemporaryToolChains(k, vl); }); [this](Kit *k, const QVariantList &vl) { persistTemporaryToolchains(k, vl); });
} }
ProjectImporter::~ProjectImporter() ProjectImporter::~ProjectImporter()
@@ -316,7 +316,7 @@ static Toolchain *toolChainFromVariant(const QVariant &v)
return ToolchainManager::findToolchain(tcId); 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) { for (const QVariant &v : vl) {
Toolchain *tc = toolChainFromVariant(v); 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) { for (const QVariant &v : vl) {
Toolchain *tmpTc = toolChainFromVariant(v); Toolchain *tmpTc = toolChainFromVariant(v);

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

@@ -93,8 +93,8 @@ private:
void markKitAsTemporary(Kit *k) const; void markKitAsTemporary(Kit *k) const;
bool findTemporaryHandler(Utils::Id id) const; bool findTemporaryHandler(Utils::Id id) const;
void cleanupTemporaryToolChains(ProjectExplorer::Kit *k, const QVariantList &vl); void cleanupTemporaryToolchains(ProjectExplorer::Kit *k, const QVariantList &vl);
void persistTemporaryToolChains(ProjectExplorer::Kit *k, const QVariantList &vl); void persistTemporaryToolchains(ProjectExplorer::Kit *k, const QVariantList &vl);
const Utils::FilePath m_projectPath; const Utils::FilePath m_projectPath;
mutable bool m_isUpdating = false; 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) const Utils::FilePath &includeFileBaseDir)
{ {
// Keep the following cheap/non-blocking for the ui thread. Expensive // 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; this->commandLineFlags = commandLineFlags;
if (toolChain) { if (toolChain) {
warningFlags = toolChain->warningFlags(commandLineFlags); 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); QTC_ASSERT(!d->m_accessor, return);
d->m_accessor = std::make_unique<Internal::ToolchainSettingsAccessor>(); 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); registerToolchain(tc);
d->m_loaded = true; d->m_loaded = true;
@@ -117,7 +117,7 @@ void ToolchainManager::saveToolchains()
{ {
QTC_ASSERT(d->m_accessor, return); 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(); QtcSettings *const s = Core::ICore::settings();
s->setValueWithDefault(DETECT_X64_AS_X32_KEY, s->setValueWithDefault(DETECT_X64_AS_X32_KEY,
d->m_detectionSettings.detectX64AsX32, d->m_detectionSettings.detectX64AsX32,
@@ -254,7 +254,7 @@ bool ToolchainManager::isLanguageSupported(const Utils::Id &id)
void ToolchainManager::aboutToShutdown() void ToolchainManager::aboutToShutdown()
{ {
if (HostOsInfo::isWindowsHost()) if (HostOsInfo::isWindowsHost())
MsvcToolChain::cancelMsvcToolChainDetection(); MsvcToolchain::cancelMsvcToolChainDetection();
} }
ToolchainDetectionSettings ToolchainManager::detectionSettings() ToolchainDetectionSettings ToolchainManager::detectionSettings()

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

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

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

@@ -18,9 +18,9 @@ class ToolchainSettingsAccessor : public Utils::UpgradingSettingsAccessor
public: public:
ToolchainSettingsAccessor(); 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: private:
QList<Toolchain *> toolChains(const Utils::Store &data) const; 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"))) { if (toolchain.contains(QLatin1String("clang-cl"))) {
data.insert(QLatin1String(CPP_COMPILERNAME), mainCompilerName); data.insert(QLatin1String(CPP_COMPILERNAME), mainCompilerName);
const auto clangClToolchain = const auto clangClToolchain =
static_cast<ProjectExplorer::Internal::ClangClToolChain *>(mainTc); static_cast<ProjectExplorer::Internal::ClangClToolchain *>(mainTc);
data.insert(QLatin1String(CPP_VCVARSALLPATH), clangClToolchain->varsBat()); data.insert(QLatin1String(CPP_VCVARSALLPATH), clangClToolchain->varsBat());
} else if (toolchain.contains(QLatin1String("msvc"))) { } else if (toolchain.contains(QLatin1String("msvc"))) {
data.insert(QLatin1String(CPP_COMPILERNAME), mainCompilerName); 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( static RawProjectPart generateProjectPart(
const QJsonObject &product, const QJsonObject &product,
const QJsonObject &group, const QJsonObject &group,
const std::shared_ptr<const Toolchain> &cToolChain, const std::shared_ptr<const Toolchain> &cToolchain,
const std::shared_ptr<const Toolchain> &cxxToolChain, const std::shared_ptr<const Toolchain> &cxxToolchain,
QtMajorVersion qtVersion, QtMajorVersion qtVersion,
QString cPch, QString cPch,
QString cxxPch, QString cxxPch,
@@ -850,8 +850,8 @@ static RawProjectPart generateProjectPart(
QStringList cFlags; QStringList cFlags;
QStringList cxxFlags; QStringList cxxFlags;
getExpandedCompilerFlags(cFlags, cxxFlags, props); getExpandedCompilerFlags(cFlags, cxxFlags, props);
rpp.setFlagsForC({cToolChain.get(), cFlags, {}}); rpp.setFlagsForC({cToolchain.get(), cFlags, {}});
rpp.setFlagsForCxx({cxxToolChain.get(), cxxFlags, {}}); rpp.setFlagsForCxx({cxxToolchain.get(), cxxFlags, {}});
const QStringList defines = arrayToStringList(props.value("cpp.defines")) const QStringList defines = arrayToStringList(props.value("cpp.defines"))
+ arrayToStringList(props.value("cpp.platformDefines")); + arrayToStringList(props.value("cpp.platformDefines"));
@@ -952,8 +952,8 @@ static RawProjectPart generateProjectPart(
static RawProjectParts generateProjectParts( static RawProjectParts generateProjectParts(
const QJsonObject &projectData, const QJsonObject &projectData,
const std::shared_ptr<const Toolchain> &cToolChain, const std::shared_ptr<const Toolchain> &cToolchain,
const std::shared_ptr<const Toolchain> &cxxToolChain, const std::shared_ptr<const Toolchain> &cxxToolchain,
QtMajorVersion qtVersion QtMajorVersion qtVersion
) )
{ {
@@ -986,11 +986,11 @@ static RawProjectParts generateProjectParts(
}; };
for (const QJsonValue &g : groups) { for (const QJsonValue &g : groups) {
appendIfNotEmpty(generateProjectPart( appendIfNotEmpty(generateProjectPart(
prd, g.toObject(), cToolChain, cxxToolChain, qtVersionForPart, prd, g.toObject(), cToolchain, cxxToolchain, qtVersionForPart,
cPch, cxxPch, objcPch, objcxxPch)); cPch, cxxPch, objcPch, objcxxPch));
} }
appendIfNotEmpty(generateProjectPart( appendIfNotEmpty(generateProjectPart(
prd, {}, cToolChain, cxxToolChain, qtVersionForPart, prd, {}, cToolchain, cxxToolchain, qtVersionForPart,
cPch, cxxPch, objcPch, objcxxPch)); cPch, cxxPch, objcPch, objcxxPch));
}); });
return rpps; return rpps;

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

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

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

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

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

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

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

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

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

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