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

All: More ToolChain->Toolchain renamings

Browse Source 
And removal of one unused function declaration.

Change-Id: I594e23401d8f247d3be081ce850005574951899d
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>
This commit is contained in:
hjk
2024-01-18 16:09:25 +01:00
parent bb88c8c9be
commit d234e71643
37 changed files with 187 additions and 188 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -278,7 +278,7 @@ private:
Macros m_macros; Macros m_macros;
}; };
// IarToolChain // IarToolchain
class IarToolchain final : public Toolchain class IarToolchain final : public Toolchain
{ {
@@ -593,10 +593,10 @@ IarToolchainConfigWidget::IarToolchainConfigWidget(IarToolchain *tc) :
void IarToolchainConfigWidget::applyImpl() void IarToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolchain()->isAutoDetected())
return; return;
const auto tc = static_cast<IarToolchain *>(toolChain()); const auto tc = static_cast<IarToolchain *>(toolchain());
const QString displayName = tc->displayName(); const QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath()); tc->setCompilerCommand(m_compilerCommand->filePath());
@@ -616,7 +616,7 @@ void IarToolchainConfigWidget::applyImpl()
bool IarToolchainConfigWidget::isDirtyImpl() const bool IarToolchainConfigWidget::isDirtyImpl() const
{ {
const auto tc = static_cast<IarToolchain *>(toolChain()); const auto tc = static_cast<IarToolchain *>(toolchain());
return m_compilerCommand->filePath() != tc->compilerCommand() return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags()) || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
|| m_abiWidget->currentAbi() != tc->targetAbi() || m_abiWidget->currentAbi() != tc->targetAbi()
@@ -633,7 +633,7 @@ void IarToolchainConfigWidget::makeReadOnlyImpl()
void IarToolchainConfigWidget::setFromToolchain() void IarToolchainConfigWidget::setFromToolchain()
{ {
const QSignalBlocker blocker(this); const QSignalBlocker blocker(this);
const auto tc = static_cast<IarToolchain *>(toolChain()); const auto tc = static_cast<IarToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags())); m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
m_abiWidget->setAbis({}, tc->targetAbi()); m_abiWidget->setAbis({}, tc->targetAbi());
@@ -648,7 +648,7 @@ void IarToolchainConfigWidget::handleCompilerCommandChange()
if (haveCompiler) { if (haveCompiler) {
const auto env = Environment::systemEnvironment(); const auto env = Environment::systemEnvironment();
const QStringList extraArgs = splitString(m_platformCodeGenFlagsLineEdit->text()); const QStringList extraArgs = splitString(m_platformCodeGenFlagsLineEdit->text());
const Id languageId = toolChain()->language(); const Id languageId = toolchain()->language();
m_macros = dumpPredefinedMacros(compilerPath, extraArgs, languageId, env); m_macros = dumpPredefinedMacros(compilerPath, extraArgs, languageId, env);
const Abi guessed = guessAbi(m_macros); const Abi guessed = guessAbi(m_macros);
m_abiWidget->setAbis({}, guessed); m_abiWidget->setAbis({}, guessed);

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

@@ -752,10 +752,10 @@ KeilToolchainConfigWidget::KeilToolchainConfigWidget(KeilToolchain *tc) :
void KeilToolchainConfigWidget::applyImpl() void KeilToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolchain()->isAutoDetected())
return; return;
const auto tc = static_cast<KeilToolchain *>(toolChain()); const auto tc = static_cast<KeilToolchain *>(toolchain());
const QString displayName = tc->displayName(); const QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath()); tc->setCompilerCommand(m_compilerCommand->filePath());
tc->m_extraCodeModelFlags.setValue(splitString(m_platformCodeGenFlagsLineEdit->text())); tc->m_extraCodeModelFlags.setValue(splitString(m_platformCodeGenFlagsLineEdit->text()));
@@ -773,7 +773,7 @@ void KeilToolchainConfigWidget::applyImpl()
bool KeilToolchainConfigWidget::isDirtyImpl() const bool KeilToolchainConfigWidget::isDirtyImpl() const
{ {
const auto tc = static_cast<KeilToolchain *>(toolChain()); const auto tc = static_cast<KeilToolchain *>(toolchain());
return m_compilerCommand->filePath() != tc->compilerCommand() return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags()) || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
|| m_abiWidget->currentAbi() != tc->targetAbi() || m_abiWidget->currentAbi() != tc->targetAbi()
@@ -790,7 +790,7 @@ void KeilToolchainConfigWidget::makeReadOnlyImpl()
void KeilToolchainConfigWidget::setFromToolchain() void KeilToolchainConfigWidget::setFromToolchain()
{ {
const QSignalBlocker blocker(this); const QSignalBlocker blocker(this);
const auto tc = static_cast<KeilToolchain *>(toolChain()); const auto tc = static_cast<KeilToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags())); m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
m_abiWidget->setAbis({}, tc->targetAbi()); m_abiWidget->setAbis({}, tc->targetAbi());

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

@@ -470,10 +470,10 @@ SdccToolchainConfigWidget::SdccToolchainConfigWidget(SdccToolchain *tc) :
void SdccToolchainConfigWidget::applyImpl() void SdccToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolchain()->isAutoDetected())
return; return;
const auto tc = static_cast<SdccToolchain *>(toolChain()); const auto tc = static_cast<SdccToolchain *>(toolchain());
const QString displayName = tc->displayName(); const QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath()); tc->setCompilerCommand(m_compilerCommand->filePath());
tc->setTargetAbi(m_abiWidget->currentAbi()); tc->setTargetAbi(m_abiWidget->currentAbi());
@@ -490,7 +490,7 @@ void SdccToolchainConfigWidget::applyImpl()
bool SdccToolchainConfigWidget::isDirtyImpl() const bool SdccToolchainConfigWidget::isDirtyImpl() const
{ {
const auto tc = static_cast<SdccToolchain *>(toolChain()); const auto tc = static_cast<SdccToolchain *>(toolchain());
return m_compilerCommand->filePath() != tc->compilerCommand() return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_abiWidget->currentAbi() != tc->targetAbi() || m_abiWidget->currentAbi() != tc->targetAbi()
; ;
@@ -505,7 +505,7 @@ void SdccToolchainConfigWidget::makeReadOnlyImpl()
void SdccToolchainConfigWidget::setFromToolchain() void SdccToolchainConfigWidget::setFromToolchain()
{ {
const QSignalBlocker blocker(this); const QSignalBlocker blocker(this);
const auto tc = static_cast<SdccToolchain *>(toolChain()); const auto tc = static_cast<SdccToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_abiWidget->setAbis({}, tc->targetAbi()); m_abiWidget->setAbis({}, tc->targetAbi());
const bool haveCompiler = m_compilerCommand->filePath().isExecutableFile(); const bool haveCompiler = m_compilerCommand->filePath().isExecutableFile();

6
src/plugins/clangcodemodel/clangutils.cpp
View File

@@ -79,9 +79,9 @@ static QStringList projectPartArguments(const ProjectPart &projectPart)
args << projectPart.compilerFilePath.toString(); args << projectPart.compilerFilePath.toString();
args << "-c"; args << "-c";
if (projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) { if (projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) {
args << "--target=" + projectPart.toolChainTargetTriple; args << "--target=" + projectPart.toolchainTargetTriple;
if (projectPart.toolChainAbi.architecture() == Abi::X86Architecture) if (projectPart.toolchainAbi.architecture() == Abi::X86Architecture)
args << QLatin1String(projectPart.toolChainAbi.wordWidth() == 64 ? "-m64" : "-m32"); args << QLatin1String(projectPart.toolchainAbi.wordWidth() == 64 ? "-m64" : "-m32");
} }
args << projectPart.compilerFlags; args << projectPart.compilerFlags;
for (const ProjectExplorer::HeaderPath &headerPath : projectPart.headerPaths) { for (const ProjectExplorer::HeaderPath &headerPath : projectPart.headerPaths) {

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

@@ -587,7 +587,7 @@ void updateConfigWithDirectoryData(CMakeConfig &config, const std::unique_ptr<Di
Toolchain *findExternalToolchain(const QString &presetArchitecture, const QString &presetToolset) Toolchain *findExternalToolchain(const QString &presetArchitecture, const QString &presetToolset)
{ {
// A compiler path example. Note that the compiler version is not the same version from MsvcToolChain // A compiler path example. Note that the compiler version is not the same version from MsvcToolchain
// ... \MSVC\14.29.30133\bin\Hostx64\x64\cl.exe // ... \MSVC\14.29.30133\bin\Hostx64\x64\cl.exe
// //
// And the CMakePresets.json // And the CMakePresets.json
@@ -996,7 +996,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
SysRootKitAspect::setSysRoot(k, data->sysroot); SysRootKitAspect::setSysRoot(k, data->sysroot);
for (const ToolchainDescription &cmtcd : data->toolchains) { for (const ToolchainDescription &cmtcd : data->toolchains) {
const ToolchainData tcd = findOrCreateToolChains(cmtcd); const ToolchainData tcd = findOrCreateToolchains(cmtcd);
QTC_ASSERT(!tcd.tcs.isEmpty(), continue); QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
if (tcd.areTemporary) { if (tcd.areTemporary) {

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

@@ -68,7 +68,7 @@ void CompilationDatabaseTests::testProject()
const CppEditor::ProjectPart &projectPart = *projectParts.first(); const CppEditor::ProjectPart &projectPart = *projectParts.first();
QVERIFY(!projectPart.headerPaths.isEmpty()); QVERIFY(!projectPart.headerPaths.isEmpty());
QVERIFY(!projectPart.projectMacros.isEmpty()); QVERIFY(!projectPart.projectMacros.isEmpty());
QVERIFY(!projectPart.toolChainMacros.isEmpty()); QVERIFY(!projectPart.toolchainMacros.isEmpty());
QVERIFY(!projectPart.files.isEmpty()); QVERIFY(!projectPart.files.isEmpty());
} }

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

@@ -80,7 +80,7 @@ void BuiltinEditorDocumentParser::updateImpl(const QPromise<void> &promise,
} }
if (const ProjectPart::ConstPtr part = baseState.projectPartInfo.projectPart) { if (const ProjectPart::ConstPtr part = baseState.projectPartInfo.projectPart) {
configFile += ProjectExplorer::Macro::toByteArray(part->toolChainMacros); configFile += ProjectExplorer::Macro::toByteArray(part->toolchainMacros);
configFile += overwrittenToolchainDefines(*part.data()); configFile += overwrittenToolchainDefines(*part.data());
configFile += ProjectExplorer::Macro::toByteArray(part->projectMacros); configFile += ProjectExplorer::Macro::toByteArray(part->projectMacros);
if (!part->projectConfigFile.isEmpty()) if (!part->projectConfigFile.isEmpty())

12
src/plugins/cppeditor/compileroptionsbuilder.cpp
View File

@@ -234,9 +234,9 @@ QStringList createLanguageOptionGcc(Language language, ProjectFile::Kind fileKin
void CompilerOptionsBuilder::addWordWidth() void CompilerOptionsBuilder::addWordWidth()
{ {
if (m_projectPart.toolChainAbi.architecture() != Abi::X86Architecture) if (m_projectPart.toolchainAbi.architecture() != Abi::X86Architecture)
return; return;
const QString argument = m_projectPart.toolChainAbi.wordWidth() == 64 const QString argument = m_projectPart.toolchainAbi.wordWidth() == 64
? QLatin1String("-m64") ? QLatin1String("-m64")
: QLatin1String("-m32"); : QLatin1String("-m32");
add(argument); add(argument);
@@ -250,7 +250,7 @@ void CompilerOptionsBuilder::addTargetTriple()
} }
const QString target = m_explicitTarget.isEmpty() || m_projectPart.targetTripleIsAuthoritative const QString target = m_explicitTarget.isEmpty() || m_projectPart.targetTripleIsAuthoritative
? m_projectPart.toolChainTargetTriple : m_explicitTarget; ? m_projectPart.toolchainTargetTriple : m_explicitTarget;
// Only "--target=" style is accepted in both g++ and cl driver modes. // Only "--target=" style is accepted in both g++ and cl driver modes.
if (!target.isEmpty()) if (!target.isEmpty())
@@ -284,7 +284,7 @@ void CompilerOptionsBuilder::addMsvcExceptions()
{ {
if (!m_clStyle) if (!m_clStyle)
return; return;
if (Utils::anyOf(m_projectPart.toolChainMacros, [](const Macro &macro) { if (Utils::anyOf(m_projectPart.toolchainMacros, [](const Macro &macro) {
return macro.key == "_CPPUNWIND"; return macro.key == "_CPPUNWIND";
})) { })) {
enableExceptions(); enableExceptions();
@@ -421,7 +421,7 @@ void CompilerOptionsBuilder::addProjectMacros()
if (m_projectPart.toolchainType == ProjectExplorer::Constants::CUSTOM_TOOLCHAIN_TYPEID if (m_projectPart.toolchainType == ProjectExplorer::Constants::CUSTOM_TOOLCHAIN_TYPEID
|| m_projectPart.toolchainType == Qnx::Constants::QNX_TOOLCHAIN_ID || m_projectPart.toolchainType == Qnx::Constants::QNX_TOOLCHAIN_ID
|| m_projectPart.toolchainType.name().contains("BareMetal") || useMacros) { || m_projectPart.toolchainType.name().contains("BareMetal") || useMacros) {
addMacros(m_projectPart.toolChainMacros); addMacros(m_projectPart.toolchainMacros);
} }
addMacros(m_projectPart.projectMacros); addMacros(m_projectPart.projectMacros);
@@ -579,7 +579,7 @@ static QByteArray msCompatibilityVersionFromDefines(const Macros &macros)
QByteArray CompilerOptionsBuilder::msvcVersion() const QByteArray CompilerOptionsBuilder::msvcVersion() const
{ {
const QByteArray version = msCompatibilityVersionFromDefines(m_projectPart.toolChainMacros); const QByteArray version = msCompatibilityVersionFromDefines(m_projectPart.toolchainMacros);
return !version.isEmpty() ? version return !version.isEmpty() ? version
: msCompatibilityVersionFromDefines(m_projectPart.projectMacros); : msCompatibilityVersionFromDefines(m_projectPart.projectMacros);
} }

1
src/plugins/cppeditor/compileroptionsbuilder.h
View File

@@ -69,7 +69,6 @@ public:
void prepend(const QString &arg); void prepend(const QString &arg);
void add(const QStringList &args, bool gccOnlyOptions = false); void add(const QStringList &args, bool gccOnlyOptions = false);
static UseToolchainMacros useToolChainMacros();
void reset(); void reset();
void evaluateCompilerFlags(); void evaluateCompilerFlags();

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

@@ -43,7 +43,7 @@ public:
tcInfo.abi = Abi(Abi::X86Architecture, Abi::DarwinOS, Abi::FreeBsdFlavor, tcInfo.abi = Abi(Abi::X86Architecture, Abi::DarwinOS, Abi::FreeBsdFlavor,
Abi::MachOFormat, 64); Abi::MachOFormat, 64);
} }
tcInfo.isMsvc2015ToolChain = isMsvc2015; tcInfo.isMsvc2015Toolchain = isMsvc2015;
tcInfo.extraCodeModelFlags = extraFlags; tcInfo.extraCodeModelFlags = extraFlags;
tcInfo.macroInspectionRunner = [this](const QStringList &) { tcInfo.macroInspectionRunner = [this](const QStringList &) {
return Toolchain::MacroInspectionReport{toolchainMacros, languageVersion}; return Toolchain::MacroInspectionReport{toolchainMacros, languageVersion};

10
src/plugins/cppeditor/cppcodemodelinspectordialog.cpp
View File

@@ -1937,9 +1937,9 @@ void CppCodeModelInspectorDialog::updateProjectPartData(const ProjectPart::Const
{QString::fromLatin1("Buildsystem Target"), buildSystemTarget}, {QString::fromLatin1("Buildsystem Target"), buildSystemTarget},
{QString::fromLatin1("Build Target Type"), CMI::Utils::toString(part->buildTargetType)}, {QString::fromLatin1("Build Target Type"), CMI::Utils::toString(part->buildTargetType)},
{QString::fromLatin1("ToolChain Type"), part->toolchainType.toString()}, {QString::fromLatin1("ToolChain Type"), part->toolchainType.toString()},
{QString::fromLatin1("ToolChain Target Triple"), part->toolChainTargetTriple}, {QString::fromLatin1("ToolChain Target Triple"), part->toolchainTargetTriple},
{QString::fromLatin1("ToolChain Word Width"), CMI::Utils::toString(part->toolChainAbi.wordWidth())}, {QString::fromLatin1("ToolChain Word Width"), CMI::Utils::toString(part->toolchainAbi.wordWidth())},
{QString::fromLatin1("ToolChain Install Dir"), part->toolChainInstallDir.toString()}, {QString::fromLatin1("ToolChain Install Dir"), part->toolchainInstallDir.toString()},
{QString::fromLatin1("Language Version"), CMI::Utils::toString(part->languageVersion)}, {QString::fromLatin1("Language Version"), CMI::Utils::toString(part->languageVersion)},
{QString::fromLatin1("Language Extensions"), CMI::Utils::toString(part->languageExtensions)}, {QString::fromLatin1("Language Extensions"), CMI::Utils::toString(part->languageExtensions)},
{QString::fromLatin1("Qt Version"), CMI::Utils::toString(part->qtVersion)} {QString::fromLatin1("Qt Version"), CMI::Utils::toString(part->qtVersion)}
@@ -1957,9 +1957,9 @@ void CppCodeModelInspectorDialog::updateProjectPartData(const ProjectPart::Const
m_projectPartTab->setTabText(ProjectPartFilesTab, m_projectPartTab->setTabText(ProjectPartFilesTab,
partTabName(ProjectPartFilesTab, part->files.size())); partTabName(ProjectPartFilesTab, part->files.size()));
int numberOfDefines = defineCount(part->toolChainMacros) + defineCount(part->projectMacros); int numberOfDefines = defineCount(part->toolchainMacros) + defineCount(part->projectMacros);
m_partToolchainDefinesEdit->setPlainText(QString::fromUtf8(ProjectExplorer::Macro::toByteArray(part->toolChainMacros))); m_partToolchainDefinesEdit->setPlainText(QString::fromUtf8(ProjectExplorer::Macro::toByteArray(part->toolchainMacros)));
m_partProjectDefinesEdit->setPlainText(QString::fromUtf8(ProjectExplorer::Macro::toByteArray(part->projectMacros))); m_partProjectDefinesEdit->setPlainText(QString::fromUtf8(ProjectExplorer::Macro::toByteArray(part->projectMacros)));
m_projectPartTab->setTabText(ProjectPartDefinesTab, m_projectPartTab->setTabText(ProjectPartDefinesTab,
partTabName(ProjectPartDefinesTab, numberOfDefines)); partTabName(ProjectPartDefinesTab, numberOfDefines));

10
src/plugins/cppeditor/cppcodemodelinspectordumper.cpp
View File

@@ -515,9 +515,9 @@ void Dumper::dumpProjectInfos(const QList<ProjectInfo::ConstPtr> &projectInfos)
m_out << i3 << "Project Name : " << projectName << "\n"; m_out << i3 << "Project Name : " << projectName << "\n";
m_out << i3 << "Project File : " << projectFilePath << "\n"; m_out << i3 << "Project File : " << projectFilePath << "\n";
m_out << i3 << "ToolChain Type : " << part->toolchainType.toString() << "\n"; m_out << i3 << "ToolChain Type : " << part->toolchainType.toString() << "\n";
m_out << i3 << "ToolChain Target Triple: " << part->toolChainTargetTriple << "\n"; m_out << i3 << "ToolChain Target Triple: " << part->toolchainTargetTriple << "\n";
m_out << i3 << "ToolChain Word Width : " << part->toolChainAbi.wordWidth() << "\n"; m_out << i3 << "ToolChain Word Width : " << part->toolchainAbi.wordWidth() << "\n";
m_out << i3 << "ToolChain Install Dir : " << part->toolChainInstallDir << "\n"; m_out << i3 << "ToolChain Install Dir : " << part->toolchainInstallDir << "\n";
m_out << i3 << "Compiler Flags : " << part->compilerFlags.join(", ") << "\n"; m_out << i3 << "Compiler Flags : " << part->compilerFlags.join(", ") << "\n";
m_out << i3 << "Selected For Building : " << part->selectedForBuilding << "\n"; m_out << i3 << "Selected For Building : " << part->selectedForBuilding << "\n";
m_out << i3 << "Build System Target : " << part->buildSystemTarget << "\n"; m_out << i3 << "Build System Target : " << part->buildSystemTarget << "\n";
@@ -537,10 +537,10 @@ void Dumper::dumpProjectInfos(const QList<ProjectInfo::ConstPtr> &projectInfos)
} }
} }
if (!part->toolChainMacros.isEmpty()) { if (!part->toolchainMacros.isEmpty()) {
m_out << i3 << "Toolchain Defines:{{{4\n"; m_out << i3 << "Toolchain Defines:{{{4\n";
const QList<QByteArray> defineLines = const QList<QByteArray> defineLines =
ProjectExplorer::Macro::toByteArray(part->toolChainMacros).split('\n'); ProjectExplorer::Macro::toByteArray(part->toolchainMacros).split('\n');
for (const QByteArray &defineLine : defineLines) for (const QByteArray &defineLine : defineLines)
m_out << i4 << defineLine << "\n"; m_out << i4 << defineLine << "\n";
} }

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

@@ -1134,7 +1134,7 @@ Macros CppModelManagerPrivate::internalDefinedMacros(SyncedProjectData &ld)
QSet<ProjectExplorer::Macro> alreadyIn; QSet<ProjectExplorer::Macro> alreadyIn;
for (const ProjectData &projectData : std::as_const(ld.m_projectData)) { for (const ProjectData &projectData : std::as_const(ld.m_projectData)) {
for (const ProjectPart::ConstPtr &part : projectData.projectInfo->projectParts()) { for (const ProjectPart::ConstPtr &part : projectData.projectInfo->projectParts()) {
addUnique(part->toolChainMacros, macros, alreadyIn); addUnique(part->toolchainMacros, macros, alreadyIn);
addUnique(part->projectMacros, macros, alreadyIn); addUnique(part->projectMacros, macros, alreadyIn);
} }
} }

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

@@ -44,10 +44,10 @@ void HeaderPathFilter::removeGccInternalIncludePaths()
return; return;
} }
if (projectPart.toolChainInstallDir.isEmpty()) if (projectPart.toolchainInstallDir.isEmpty())
return; return;
const Utils::FilePath gccInstallDir = projectPart.toolChainInstallDir; const Utils::FilePath gccInstallDir = projectPart.toolchainInstallDir;
auto isGccInternalInclude = [gccInstallDir](const HeaderPath &headerPath) { auto isGccInternalInclude = [gccInstallDir](const HeaderPath &headerPath) {
const auto filePath = Utils::FilePath::fromString(headerPath.path); const auto filePath = Utils::FilePath::fromString(headerPath.path);
return filePath == gccInstallDir.pathAppended("include") return filePath == gccInstallDir.pathAppended("include")

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

@@ -64,7 +64,7 @@ static ProjectExplorer::Macros getDefines(const QVector<ProjectPart::ConstPtr> &
{ {
ProjectExplorer::Macros defines; ProjectExplorer::Macros defines;
for (const ProjectPart::ConstPtr &part : projectParts) { for (const ProjectPart::ConstPtr &part : projectParts) {
defines.append(part->toolChainMacros); defines.append(part->toolchainMacros);
defines.append(part->projectMacros); defines.append(part->projectMacros);
} }
return defines; return defines;

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

@@ -355,9 +355,9 @@ class ProjectInfoGeneratorTestHelper
public: public:
ProjectInfoGeneratorTestHelper() ProjectInfoGeneratorTestHelper()
{ {
TestToolchain aToolChain; TestToolchain toolchain;
projectUpdateInfo.cxxToolchainInfo = {&aToolChain, {}, {}}; projectUpdateInfo.cxxToolchainInfo = {&toolchain, {}, {}};
projectUpdateInfo.cToolchainInfo = {&aToolChain, {}, {}}; projectUpdateInfo.cToolchainInfo = {&toolchain, {}, {}};
} }
ProjectInfo::ConstPtr generate() ProjectInfo::ConstPtr generate()

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

@@ -142,11 +142,11 @@ ProjectPart::ProjectPart(const Utils::FilePath &topLevelProject,
buildTargetType(rpp.buildTargetType), buildTargetType(rpp.buildTargetType),
selectedForBuilding(rpp.selectedForBuilding), selectedForBuilding(rpp.selectedForBuilding),
toolchainType(tcInfo.type), toolchainType(tcInfo.type),
isMsvc2015Toolchain(tcInfo.isMsvc2015ToolChain), isMsvc2015Toolchain(tcInfo.isMsvc2015Toolchain),
toolChainTargetTriple(tcInfo.targetTriple), toolchainTargetTriple(tcInfo.targetTriple),
targetTripleIsAuthoritative(tcInfo.targetTripleIsAuthoritative), targetTripleIsAuthoritative(tcInfo.targetTripleIsAuthoritative),
toolChainAbi(tcInfo.abi), toolchainAbi(tcInfo.abi),
toolChainInstallDir(tcInfo.installDir), toolchainInstallDir(tcInfo.installDir),
compilerFilePath(tcInfo.compilerFilePath), compilerFilePath(tcInfo.compilerFilePath),
warningFlags(flags.warningFlags), warningFlags(flags.warningFlags),
extraCodeModelFlags(tcInfo.extraCodeModelFlags), extraCodeModelFlags(tcInfo.extraCodeModelFlags),

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

@@ -76,7 +76,7 @@ public:
// Macros // Macros
const ProjectExplorer::Macros projectMacros; const ProjectExplorer::Macros projectMacros;
const ProjectExplorer::Macros &toolChainMacros = m_macroReport.macros; const ProjectExplorer::Macros &toolchainMacros = m_macroReport.macros;
// Build system // Build system
const QString buildSystemTarget; const QString buildSystemTarget;
@@ -84,13 +84,13 @@ public:
= ProjectExplorer::BuildTargetType::Unknown; = ProjectExplorer::BuildTargetType::Unknown;
const bool selectedForBuilding = true; const bool selectedForBuilding = true;
// ToolChain // Toolchain
const Utils::Id toolchainType; const Utils::Id toolchainType;
const bool isMsvc2015Toolchain = false; const bool isMsvc2015Toolchain = false;
const QString toolChainTargetTriple; const QString toolchainTargetTriple;
const bool targetTripleIsAuthoritative; const bool targetTripleIsAuthoritative;
const ProjectExplorer::Abi toolChainAbi = ProjectExplorer::Abi::hostAbi(); const ProjectExplorer::Abi toolchainAbi = ProjectExplorer::Abi::hostAbi();
const Utils::FilePath toolChainInstallDir; const Utils::FilePath toolchainInstallDir;
const Utils::FilePath compilerFilePath; const Utils::FilePath compilerFilePath;
const Utils::WarningFlags warningFlags = Utils::WarningFlags::Default; const Utils::WarningFlags warningFlags = Utils::WarningFlags::Default;

2
src/plugins/debugger/debuggerplugin.cpp
View File

@@ -2368,7 +2368,7 @@ void DebuggerUnitTests::initTestCase()
// const QList<Kit *> allKits = KitManager::kits(); // const QList<Kit *> allKits = KitManager::kits();
// if (allKits.count() != 1) // if (allKits.count() != 1)
// QSKIP("This test requires exactly one kit to be present"); // QSKIP("This test requires exactly one kit to be present");
// const ToolChain * const toolchain = ToolChainKitAspect::toolChain(allKits.first()); // const Toolchain * const toolchain = ToolchainKitAspect::toolchain(allKits.first());
// if (!toolchain) // if (!toolchain)
// QSKIP("This test requires that there is a kit with a toolchain."); // QSKIP("This test requires that there is a kit with a toolchain.");
// bool hasClangExecutable; // bool hasClangExecutable;

4
src/plugins/debugger/gdb/gdbengine.cpp
View File

@@ -1724,7 +1724,7 @@ void GdbEngine::handleThreadGroupExited(const GdbMi &result)
} }
} }
static QString msgNoGdbBinaryForToolChain(const Abi &tc) static QString msgNoGdbBinaryForToolchain(const Abi &tc)
{ {
return Tr::tr("There is no GDB binary available for binaries in format \"%1\".") return Tr::tr("There is no GDB binary available for binaries in format \"%1\".")
.arg(tc.toString()); .arg(tc.toString());
@@ -3833,7 +3833,7 @@ void GdbEngine::setupEngine()
if (rp.debugger.command.isEmpty()) { if (rp.debugger.command.isEmpty()) {
handleGdbStartFailed(); handleGdbStartFailed();
handleAdapterStartFailed( handleAdapterStartFailed(
msgNoGdbBinaryForToolChain(rp.toolChainAbi), msgNoGdbBinaryForToolchain(rp.toolChainAbi),
Constants::DEBUGGER_COMMON_SETTINGS_ID); Constants::DEBUGGER_COMMON_SETTINGS_ID);
return; return;
} }

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

@@ -46,7 +46,7 @@ public:
private: private:
QtVersions autoDetectQtVersions() const; QtVersions autoDetectQtVersions() const;
QList<Toolchain *> autoDetectToolChains(); QList<Toolchain *> autoDetectToolchains();
void autoDetectPython(); void autoDetectPython();
QList<Id> autoDetectCMake(); QList<Id> autoDetectCMake();
void autoDetectDebugger(); void autoDetectDebugger();
@@ -107,10 +107,10 @@ void KitDetectorPrivate::undoAutoDetect() const
emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Removing toolchain entries...")); emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Removing toolchain entries..."));
const Toolchains toolchains = ToolchainManager::toolchains(); const Toolchains toolchains = ToolchainManager::toolchains();
for (Toolchain *toolChain : toolchains) { for (Toolchain *toolchain : toolchains) {
if (toolChain && toolChain->detectionSource() == m_sharedId) { if (toolchain && toolchain->detectionSource() == m_sharedId) {
emit q->logOutput(ProjectExplorer::Tr::tr("Removed \"%1\"").arg(toolChain->displayName())); emit q->logOutput(ProjectExplorer::Tr::tr("Removed \"%1\"").arg(toolchain->displayName()));
ToolchainManager::deregisterToolchain(toolChain); ToolchainManager::deregisterToolchain(toolchain);
} }
}; };
@@ -164,9 +164,9 @@ void KitDetectorPrivate::listAutoDetected() const
} }
emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Toolchains:")); emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Toolchains:"));
for (Toolchain *toolChain : ToolchainManager::toolchains()) { for (Toolchain *toolchain : ToolchainManager::toolchains()) {
if (toolChain->detectionSource() == m_sharedId) if (toolchain->detectionSource() == m_sharedId)
emit q->logOutput(toolChain->displayName()); emit q->logOutput(toolchain->displayName());
} }
if (QObject *cmakeManager = ExtensionSystem::PluginManager::getObjectByName( if (QObject *cmakeManager = ExtensionSystem::PluginManager::getObjectByName(
@@ -247,29 +247,29 @@ QtVersions KitDetectorPrivate::autoDetectQtVersions() const
return qtVersions; return qtVersions;
} }
Toolchains KitDetectorPrivate::autoDetectToolChains() Toolchains KitDetectorPrivate::autoDetectToolchains()
{ {
const QList<ToolchainFactory *> factories = ToolchainFactory::allToolchainFactories(); const QList<ToolchainFactory *> factories = ToolchainFactory::allToolchainFactories();
Toolchains alreadyKnown = ToolchainManager::toolchains(); Toolchains alreadyKnown = ToolchainManager::toolchains();
Toolchains allNewToolChains; Toolchains allNewToolchains;
QApplication::processEvents(); QApplication::processEvents();
emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Searching toolchains...")); emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Searching toolchains..."));
for (ToolchainFactory *factory : factories) { for (ToolchainFactory *factory : factories) {
emit q->logOutput(ProjectExplorer::Tr::tr("Searching toolchains of type %1").arg(factory->displayName())); emit q->logOutput(ProjectExplorer::Tr::tr("Searching toolchains of type %1").arg(factory->displayName()));
const ToolchainDetector detector(alreadyKnown, m_device, m_searchPaths); const ToolchainDetector detector(alreadyKnown, m_device, m_searchPaths);
const Toolchains newToolChains = factory->autoDetect(detector); const Toolchains newToolchains = factory->autoDetect(detector);
for (Toolchain *toolChain : newToolChains) { for (Toolchain *toolchain : newToolchains) {
emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolChain->compilerCommand().toUserOutput())); emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolchain->compilerCommand().toUserOutput()));
toolChain->setDetectionSource(m_sharedId); toolchain->setDetectionSource(m_sharedId);
ToolchainManager::registerToolchain(toolChain); ToolchainManager::registerToolchain(toolchain);
alreadyKnown.append(toolChain); alreadyKnown.append(toolchain);
} }
allNewToolChains.append(newToolChains); allNewToolchains.append(newToolchains);
} }
emit q->logOutput(ProjectExplorer::Tr::tr("%1 new toolchains found.").arg(allNewToolChains.size())); emit q->logOutput(ProjectExplorer::Tr::tr("%1 new toolchains found.").arg(allNewToolchains.size()));
return allNewToolChains; return allNewToolchains;
} }
void KitDetectorPrivate::autoDetectPython() void KitDetectorPrivate::autoDetectPython()
@@ -333,7 +333,7 @@ void KitDetectorPrivate::autoDetect()
emit q->logOutput(ProjectExplorer::Tr::tr("Starting auto-detection. This will take a while...")); emit q->logOutput(ProjectExplorer::Tr::tr("Starting auto-detection. This will take a while..."));
const Toolchains toolchains = autoDetectToolChains(); const Toolchains toolchains = autoDetectToolchains();
const QtVersions qtVersions = autoDetectQtVersions(); const QtVersions qtVersions = autoDetectQtVersions();
const QList<Id> cmakeIds = autoDetectCMake(); const QList<Id> cmakeIds = autoDetectCMake();
@@ -363,8 +363,8 @@ void KitDetectorPrivate::autoDetect()
return tc->detectionSource() == m_sharedId return tc->detectionSource() == m_sharedId
&& (!qt || qt->qtAbis().contains(tc->targetAbi())); && (!qt || qt->qtAbis().contains(tc->targetAbi()));
}); });
for (Toolchain *toolChain : toolchainsToSet) for (Toolchain *toolchain : toolchainsToSet)
ToolchainKitAspect::setToolchain(k, toolChain); ToolchainKitAspect::setToolchain(k, toolchain);
if (cmakeId.isValid()) if (cmakeId.isValid())
k->setSticky(CMakeProjectManager::Constants::TOOL_ID, true); k->setSticky(CMakeProjectManager::Constants::TOOL_ID, true);

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

@@ -61,7 +61,7 @@ static Q_LOGGING_CATEGORY(kitSetupLog, "qtc.ios.kitSetup", QtWarningMsg)
static Q_LOGGING_CATEGORY(iosCommonLog, "qtc.ios.common", QtWarningMsg) static Q_LOGGING_CATEGORY(iosCommonLog, "qtc.ios.common", QtWarningMsg)
} }
using ToolChainPair = std::pair<GccToolchain *, GccToolchain *>; using ToolchainPair = std::pair<GccToolchain *, GccToolchain *>;
namespace Ios { namespace Ios {
namespace Internal { namespace Internal {
@@ -98,57 +98,57 @@ static bool isSimulatorDeviceId(const Id &id)
return id == Constants::IOS_SIMULATOR_TYPE; return id == Constants::IOS_SIMULATOR_TYPE;
} }
static QList<GccToolchain *> clangToolChains(const Toolchains &toolChains) static QList<GccToolchain *> clangToolchains(const Toolchains &toolchains)
{ {
QList<GccToolchain *> clangToolChains; QList<GccToolchain *> clangToolchains;
for (Toolchain *toolChain : toolChains) for (Toolchain *toolchain : toolchains)
if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID) if (toolchain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
clangToolChains.append(static_cast<GccToolchain *>(toolChain)); clangToolchains.append(static_cast<GccToolchain *>(toolchain));
return clangToolChains; return clangToolchains;
} }
static QList<GccToolchain *> autoDetectedIosToolChains() static QList<GccToolchain *> autoDetectedIosToolchains()
{ {
const QList<GccToolchain *> toolChains = clangToolChains(ToolchainManager::toolchains()); const QList<GccToolchain *> toolchains = clangToolchains(ToolchainManager::toolchains());
return filtered(toolChains, [](GccToolchain *toolChain) { return filtered(toolchains, [](GccToolchain *toolChain) {
return toolChain->isAutoDetected() return toolChain->isAutoDetected()
&& (toolChain->displayName().startsWith("iphone") && (toolChain->displayName().startsWith("iphone")
|| toolChain->displayName().startsWith("Apple Clang")); // TODO tool chains should be marked directly || toolChain->displayName().startsWith("Apple Clang")); // TODO tool chains should be marked directly
}); });
} }
static ToolChainPair findToolChainForPlatform(const XcodePlatform &platform, static ToolchainPair findToolchainForPlatform(const XcodePlatform &platform,
const XcodePlatform::ToolchainTarget &target, const XcodePlatform::ToolchainTarget &target,
const QList<GccToolchain *> &toolChains) const QList<GccToolchain *> &toolchains)
{ {
ToolChainPair platformToolChains; ToolchainPair platformToolchains;
auto toolchainMatch = [](GccToolchain *toolChain, const FilePath &compilerPath, const QStringList &flags) { auto toolchainMatch = [](GccToolchain *toolChain, const FilePath &compilerPath, const QStringList &flags) {
return compilerPath == toolChain->compilerCommand() return compilerPath == toolChain->compilerCommand()
&& flags == toolChain->platformCodeGenFlags() && flags == toolChain->platformCodeGenFlags()
&& flags == toolChain->platformLinkerFlags(); && flags == toolChain->platformLinkerFlags();
}; };
platformToolChains.first = findOrDefault(toolChains, std::bind(toolchainMatch, std::placeholders::_1, platformToolchains.first = findOrDefault(toolchains, std::bind(toolchainMatch, std::placeholders::_1,
platform.cCompilerPath, platform.cCompilerPath,
target.backendFlags)); target.backendFlags));
platformToolChains.second = findOrDefault(toolChains, std::bind(toolchainMatch, std::placeholders::_1, platformToolchains.second = findOrDefault(toolchains, std::bind(toolchainMatch, std::placeholders::_1,
platform.cxxCompilerPath, platform.cxxCompilerPath,
target.backendFlags)); target.backendFlags));
return platformToolChains; return platformToolchains;
} }
static QHash<XcodePlatform::ToolchainTarget, ToolChainPair> findToolChains(const QList<XcodePlatform> &platforms) static QHash<XcodePlatform::ToolchainTarget, ToolchainPair> findToolchains(const QList<XcodePlatform> &platforms)
{ {
QHash<XcodePlatform::ToolchainTarget, ToolChainPair> platformToolChainHash; QHash<XcodePlatform::ToolchainTarget, ToolchainPair> platformToolchainHash;
const QList<GccToolchain *> toolChains = autoDetectedIosToolChains(); const QList<GccToolchain *> toolchains = autoDetectedIosToolchains();
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,
toolChains); toolchains);
if (platformToolchains.first || platformToolchains.second) if (platformToolchains.first || platformToolchains.second)
platformToolChainHash.insert(target, platformToolchains); platformToolchainHash.insert(target, platformToolchains);
} }
} }
return platformToolChainHash; return platformToolchainHash;
} }
static QSet<Kit *> existingAutoDetectedIosKits() static QSet<Kit *> existingAutoDetectedIosKits()
@@ -166,16 +166,16 @@ static void printKits(const QSet<Kit *> &kits)
qCDebug(kitSetupLog) << " -" << kit->displayName(); qCDebug(kitSetupLog) << " -" << kit->displayName();
} }
static void setupKit(Kit *kit, Id pDeviceType, const ToolChainPair& toolChains, static void setupKit(Kit *kit, Id pDeviceType, const ToolchainPair& toolchains,
const QVariant &debuggerId, const FilePath &sdkPath, QtVersion *qtVersion) const QVariant &debuggerId, const FilePath &sdkPath, QtVersion *qtVersion)
{ {
DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType); DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType);
if (toolChains.first) if (toolchains.first)
ToolchainKitAspect::setToolchain(kit, toolChains.first); ToolchainKitAspect::setToolchain(kit, toolchains.first);
else else
ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID); ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
if (toolChains.second) if (toolchains.second)
ToolchainKitAspect::setToolchain(kit, toolChains.second); ToolchainKitAspect::setToolchain(kit, toolchains.second);
else else
ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID); ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
@@ -232,7 +232,7 @@ void IosConfigurations::updateAutomaticKitList()
qCDebug(kitSetupLog) << "Developer path:" << developerPath(); qCDebug(kitSetupLog) << "Developer path:" << developerPath();
// target -> tool chain // target -> tool chain
const auto targetToolChainHash = findToolChains(platforms); const auto targetToolchainHash = findToolchains(platforms);
const auto qtVersions = toSet(QtVersionManager::versions([](const QtVersion *v) { const auto qtVersions = toSet(QtVersionManager::versions([](const QtVersion *v) {
return v->isValid() && v->type() == Constants::IOSQT; return v->isValid() && v->type() == Constants::IOSQT;
@@ -256,7 +256,7 @@ void IosConfigurations::updateAutomaticKitList()
const auto target = targets.front(); const auto target = targets.front();
const ToolChainPair &platformToolchains = targetToolChainHash.value(target); const ToolchainPair &platformToolchains = targetToolchainHash.value(target);
if (!platformToolchains.first && !platformToolchains.second) { if (!platformToolchains.first && !platformToolchains.second) {
qCDebug(kitSetupLog) << " - No tool chain found"; qCDebug(kitSetupLog) << " - No tool chain found";
continue; continue;
@@ -586,13 +586,13 @@ 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) {
@@ -608,14 +608,14 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
platform.cxxCompilerPath : platform.cCompilerPath); platform.cxxCompilerPath : platform.cCompilerPath);
existingClangToolChains.append(toolChain); existingClangToolChains.append(toolChain);
} }
toolChains.append(toolChain); toolchains.append(toolChain);
}; };
createOrAdd(platformToolchains.first, ProjectExplorer::Constants::C_LANGUAGE_ID); createOrAdd(platformToolchains.first, ProjectExplorer::Constants::C_LANGUAGE_ID);
createOrAdd(platformToolchains.second, ProjectExplorer::Constants::CXX_LANGUAGE_ID); createOrAdd(platformToolchains.second, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
} }
} }
return toolChains; return toolchains;
} }
void setupIosToolchain() void setupIosToolchain()

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

@@ -120,10 +120,10 @@ bool NimToolChain::parseVersion(const FilePath &path, std::tuple<int, int, int>
// NimToolchainConfigWidget // NimToolchainConfigWidget
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();
@@ -162,35 +162,35 @@ private:
QLineEdit *m_compilerVersion; QLineEdit *m_compilerVersion;
}; };
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;
tc->setCompilerCommand(m_compilerCommand->filePath()); tc->setCompilerCommand(m_compilerCommand->filePath());
} }
void NimToolChainConfigWidget::discardImpl() void NimToolchainConfigWidget::discardImpl()
{ {
fillUI(); fillUI();
} }
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();
} }
void NimToolChainConfigWidget::makeReadOnlyImpl() void NimToolchainConfigWidget::makeReadOnlyImpl()
{ {
m_compilerCommand->setReadOnly(true); m_compilerCommand->setReadOnly(true);
} }
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());
@@ -198,7 +198,7 @@ void NimToolChainConfigWidget::fillUI()
std::unique_ptr<ToolchainConfigWidget> NimToolChain::createConfigurationWidget() std::unique_ptr<ToolchainConfigWidget> NimToolChain::createConfigurationWidget()
{ {
return std::make_unique<NimToolChainConfigWidget>(this); return std::make_unique<NimToolchainConfigWidget>(this);
} }
// NimToolchainFactory // NimToolchainFactory

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

@@ -488,10 +488,10 @@ void CustomToolChainConfigWidget::errorParserChanged(int )
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());
@@ -517,7 +517,7 @@ 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());
@@ -534,7 +534,7 @@ void CustomToolChainConfigWidget::setFromToolchain()
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()

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

@@ -1770,7 +1770,7 @@ GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
})); }));
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;
@@ -1785,10 +1785,10 @@ GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
void GccToolchainConfigWidget::applyImpl() void GccToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolchain()->isAutoDetected())
return; return;
auto tc = static_cast<GccToolchain *>(toolChain()); auto tc = static_cast<GccToolchain *>(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());
@@ -1834,7 +1834,7 @@ void GccToolchainConfigWidget::setFromToolchain()
{ {
// subwidgets are not yet connected! // subwidgets are not yet connected!
QSignalBlocker blocker(this); QSignalBlocker blocker(this);
auto tc = static_cast<GccToolchain *>(toolChain()); auto tc = static_cast<GccToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags(), m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags(),
HostOsInfo::hostOs())); HostOsInfo::hostOs()));
@@ -1852,7 +1852,7 @@ void GccToolchainConfigWidget::setFromToolchain()
bool GccToolchainConfigWidget::isDirtyImpl() const bool GccToolchainConfigWidget::isDirtyImpl() const
{ {
auto tc = static_cast<GccToolchain *>(toolChain()); auto tc = static_cast<GccToolchain *>(toolchain());
if (m_compilerCommand->filePath() != tc->compilerCommand() if (m_compilerCommand->filePath() != tc->compilerCommand()
|| m_platformCodeGenFlagsLineEdit->text() || m_platformCodeGenFlagsLineEdit->text()
@@ -2030,7 +2030,7 @@ void GccToolchainConfigWidget::updateParentToolChainComboBox()
{ {
QTC_ASSERT(m_parentToolchainCombo, return); QTC_ASSERT(m_parentToolchainCombo, return);
auto *tc = static_cast<GccToolchain *>(toolChain()); auto *tc = static_cast<GccToolchain *>(toolchain());
QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray(); QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0) if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0)
parentId = tc->m_parentToolchainId; parentId = tc->m_parentToolchainId;

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

@@ -1285,7 +1285,7 @@ protected:
void setFromMsvcToolChain() void setFromMsvcToolChain()
{ {
const auto *tc = static_cast<const MsvcToolChain *>(toolChain()); const auto *tc = static_cast<const MsvcToolChain *>(toolchain());
QTC_ASSERT(tc, return ); QTC_ASSERT(tc, return );
m_nameDisplayLabel->setText(tc->displayName()); m_nameDisplayLabel->setText(tc->displayName());
m_varsBatDisplayLabel->setText(msvcVarsToDisplay(*tc)); m_varsBatDisplayLabel->setText(msvcVarsToDisplay(*tc));
@@ -1382,7 +1382,7 @@ private:
void MsvcToolChainConfigWidget::applyImpl() void MsvcToolChainConfigWidget::applyImpl()
{ {
auto *tc = static_cast<MsvcToolChain *>(toolChain()); auto *tc = static_cast<MsvcToolChain *>(toolchain());
QTC_ASSERT(tc, return ); QTC_ASSERT(tc, return );
const QString vcVars = QDir::fromNativeSeparators(m_varsBatPathCombo->currentText()); const QString vcVars = QDir::fromNativeSeparators(m_varsBatPathCombo->currentText());
tc->setupVarsBat(m_abiWidget->currentAbi(), vcVars, vcVarsArguments()); tc->setupVarsBat(m_abiWidget->currentAbi(), vcVars, vcVarsArguments());
@@ -1396,7 +1396,7 @@ void MsvcToolChainConfigWidget::discardImpl()
bool MsvcToolChainConfigWidget::isDirtyImpl() const bool MsvcToolChainConfigWidget::isDirtyImpl() const
{ {
auto msvcToolChain = static_cast<MsvcToolChain *>(toolChain()); auto msvcToolChain = static_cast<MsvcToolChain *>(toolchain());
return msvcToolChain->varsBat() != QDir::fromNativeSeparators(m_varsBatPathCombo->currentText()) return msvcToolChain->varsBat() != QDir::fromNativeSeparators(m_varsBatPathCombo->currentText())
|| msvcToolChain->varsBatArg() != vcVarsArguments() || msvcToolChain->varsBatArg() != vcVarsArguments()
@@ -1413,7 +1413,7 @@ void MsvcToolChainConfigWidget::makeReadOnlyImpl()
void MsvcToolChainConfigWidget::setFromMsvcToolChain() void MsvcToolChainConfigWidget::setFromMsvcToolChain()
{ {
const auto *tc = static_cast<const MsvcToolChain *>(toolChain()); const auto *tc = static_cast<const MsvcToolChain *>(toolchain());
QTC_ASSERT(tc, return ); QTC_ASSERT(tc, return );
m_nameDisplayLabel->setText(tc->displayName()); m_nameDisplayLabel->setText(tc->displayName());
QString args = tc->varsBatArg(); QString args = tc->varsBatArg();
@@ -1434,7 +1434,7 @@ void MsvcToolChainConfigWidget::setFromMsvcToolChain()
void MsvcToolChainConfigWidget::updateAbis() void MsvcToolChainConfigWidget::updateAbis()
{ {
const QString normalizedVcVars = QDir::fromNativeSeparators(m_varsBatPathCombo->currentText()); const QString normalizedVcVars = QDir::fromNativeSeparators(m_varsBatPathCombo->currentText());
const auto *currentTc = static_cast<const MsvcToolChain *>(toolChain()); const auto *currentTc = static_cast<const MsvcToolChain *>(toolchain());
QTC_ASSERT(currentTc, return ); QTC_ASSERT(currentTc, return );
const MsvcToolChain::Platform platform = m_varsBatArchCombo->currentData().value<MsvcToolChain::Platform>(); const MsvcToolChain::Platform platform = m_varsBatArchCombo->currentData().value<MsvcToolChain::Platform>();
const Abi::Architecture arch = archForPlatform(platform); const Abi::Architecture arch = archForPlatform(platform);
@@ -1564,7 +1564,7 @@ private:
void ClangClToolChainConfigWidget::setFromClangClToolChain() void ClangClToolChainConfigWidget::setFromClangClToolChain()
{ {
const auto *currentTC = static_cast<const MsvcToolChain *>(toolChain()); const auto *currentTC = static_cast<const MsvcToolChain *>(toolchain());
m_nameDisplayLabel->setText(currentTC->displayName()); m_nameDisplayLabel->setText(currentTC->displayName());
m_varsBatDisplayCombo->clear(); m_varsBatDisplayCombo->clear();
m_varsBatDisplayCombo->addItem(msvcVarsToDisplay(*currentTC)); m_varsBatDisplayCombo->addItem(msvcVarsToDisplay(*currentTC));
@@ -1574,7 +1574,7 @@ void ClangClToolChainConfigWidget::setFromClangClToolChain()
m_varsBatDisplayCombo->addItem(varsToDisplay); m_varsBatDisplayCombo->addItem(varsToDisplay);
} }
const auto *clangClToolChain = static_cast<const ClangClToolChain *>(toolChain()); const auto *clangClToolChain = static_cast<const ClangClToolChain *>(toolchain());
if (clangClToolChain->isAutoDetected()) if (clangClToolChain->isAutoDetected())
m_llvmDirLabel->setText(clangClToolChain->clangPath().toUserOutput()); m_llvmDirLabel->setText(clangClToolChain->clangPath().toUserOutput());
else else
@@ -1696,7 +1696,7 @@ static Toolchains detectClangClToolChainInPath(const FilePath &clangClPath,
void ClangClToolChainConfigWidget::applyImpl() void ClangClToolChainConfigWidget::applyImpl()
{ {
Utils::FilePath clangClPath = m_compilerCommand->filePath(); Utils::FilePath clangClPath = m_compilerCommand->filePath();
auto clangClToolChain = static_cast<ClangClToolChain *>(toolChain()); auto clangClToolChain = static_cast<ClangClToolChain *>(toolchain());
clangClToolChain->setClangPath(clangClPath); clangClToolChain->setClangPath(clangClPath);
if (clangClPath.fileName() != "clang-cl.exe") { if (clangClPath.fileName() != "clang-cl.exe") {

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

@@ -386,7 +386,7 @@ static ProjectImporter::ToolchainData createToolChains(const ToolchainDescriptio
} }
ProjectImporter::ToolchainData ProjectImporter::ToolchainData
ProjectImporter::findOrCreateToolChains(const ToolchainDescription &tcd) const ProjectImporter::findOrCreateToolchains(const ToolchainDescription &tcd) const
{ {
ToolchainData result; ToolchainData result;
result.tcs = ToolchainManager::toolchains([&tcd](const Toolchain *tc) { result.tcs = ToolchainManager::toolchains([&tcd](const Toolchain *tc) {

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

@@ -87,7 +87,7 @@ protected:
// Does *any* kit feature the requested data yet? // Does *any* kit feature the requested data yet?
bool hasKitWithTemporaryData(Utils::Id id, const QVariant &data) const; bool hasKitWithTemporaryData(Utils::Id id, const QVariant &data) const;
ToolchainData findOrCreateToolChains(const ToolchainDescription &tcd) const; ToolchainData findOrCreateToolchains(const ToolchainDescription &tcd) const;
private: private:
void markKitAsTemporary(Kit *k) const; void markKitAsTemporary(Kit *k) const;

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

@@ -162,7 +162,7 @@ ToolchainInfo::ToolchainInfo(const Toolchain *toolChain,
if (toolChain) { if (toolChain) {
// Keep the following cheap/non-blocking for the ui thread... // Keep the following cheap/non-blocking for the ui thread...
type = toolChain->typeId(); type = toolChain->typeId();
isMsvc2015ToolChain = toolChain->targetAbi().osFlavor() == Abi::WindowsMsvc2015Flavor; isMsvc2015Toolchain = toolChain->targetAbi().osFlavor() == Abi::WindowsMsvc2015Flavor;
abi = toolChain->targetAbi(); abi = toolChain->targetAbi();
targetTriple = toolChain->effectiveCodeModelTargetTriple(); targetTriple = toolChain->effectiveCodeModelTargetTriple();
targetTripleIsAuthoritative = !toolChain->explicitCodeModelTargetTriple().isEmpty(); targetTripleIsAuthoritative = !toolChain->explicitCodeModelTargetTriple().isEmpty();

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

@@ -139,7 +139,7 @@ public:
public: public:
Utils::Id type; Utils::Id type;
bool isMsvc2015ToolChain = false; bool isMsvc2015Toolchain = false;
bool targetTripleIsAuthoritative = false; bool targetTripleIsAuthoritative = false;
Abi abi; Abi abi;
QString targetTriple; QString targetTriple;

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

@@ -66,7 +66,7 @@ bool ToolchainConfigWidget::isDirty() const
return m_nameLineEdit->text() != m_toolChain->displayName() || isDirtyImpl(); return m_nameLineEdit->text() != m_toolChain->displayName() || isDirtyImpl();
} }
Toolchain *ToolchainConfigWidget::toolChain() const Toolchain *ToolchainConfigWidget::toolchain() const
{ {
return m_toolChain; return m_toolChain;
} }

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

@@ -28,7 +28,7 @@ class PROJECTEXPLORER_EXPORT ToolchainConfigWidget : public QScrollArea
public: public:
explicit ToolchainConfigWidget(Toolchain *tc); explicit ToolchainConfigWidget(Toolchain *tc);
Toolchain *toolChain() const; Toolchain *toolchain() const;
void apply(); void apply();
void discard(); void discard();

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

@@ -185,9 +185,9 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void { return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void {
QList<ToolchainData> tcData; QList<ToolchainData> tcData;
if (!bgData->cxxCompilerPath.isEmpty()) if (!bgData->cxxCompilerPath.isEmpty())
tcData << findOrCreateToolChains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID}); tcData << findOrCreateToolchains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID});
if (!bgData->cCompilerPath.isEmpty()) if (!bgData->cCompilerPath.isEmpty())
tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID}); tcData << findOrCreateToolchains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID});
for (const ToolchainData &tc : std::as_const(tcData)) { for (const ToolchainData &tc : std::as_const(tcData)) {
if (!tc.tcs.isEmpty()) if (!tc.tcs.isEmpty())
ToolchainKitAspect::setToolchain(k, tc.tcs.first()); ToolchainKitAspect::setToolchain(k, tc.tcs.first());

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

@@ -231,7 +231,7 @@ Toolchains QnxConfiguration::createToolChains(const QnxTarget &target)
for (const Id language : {ProjectExplorer::Constants::C_LANGUAGE_ID, for (const Id language : {ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID}) { ProjectExplorer::Constants::CXX_LANGUAGE_ID}) {
auto toolChain = new QnxToolChain; auto toolChain = new QnxToolchain;
toolChain->setDetection(Toolchain::ManualDetection); toolChain->setDetection(Toolchain::ManualDetection);
toolChain->setLanguage(language); toolChain->setLanguage(language);
toolChain->setTargetAbi(target.m_abi); toolChain->setTargetAbi(target.m_abi);

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

@@ -22,12 +22,12 @@ using namespace Utils;
namespace Qnx::Internal { namespace Qnx::Internal {
// QnxToolChainConfigWidget // QnxToolchainConfigWidget
class QnxToolChainConfigWidget : public ToolchainConfigWidget class QnxToolchainConfigWidget : public ToolchainConfigWidget
{ {
public: public:
QnxToolChainConfigWidget(QnxToolChain *tc); QnxToolchainConfigWidget(QnxToolchain *tc);
private: private:
void applyImpl() override; void applyImpl() override;
@@ -97,17 +97,17 @@ static QStringList reinterpretOptions(const QStringList &args)
return arguments; return arguments;
} }
QnxToolChain::QnxToolChain() QnxToolchain::QnxToolchain()
: GccToolchain(Constants::QNX_TOOLCHAIN_ID) : GccToolchain(Constants::QNX_TOOLCHAIN_ID)
{ {
setOptionsReinterpreter(&reinterpretOptions); setOptionsReinterpreter(&reinterpretOptions);
setTypeDisplayName(Tr::tr("QCC")); setTypeDisplayName(Tr::tr("QCC"));
sdpPath.setSettingsKey("Qnx.QnxToolChain.NDKPath"); sdpPath.setSettingsKey("Qnx.QnxToolChain.NDKPath");
connect(&sdpPath, &BaseAspect::changed, this, &QnxToolChain::toolChainUpdated); connect(&sdpPath, &BaseAspect::changed, this, &QnxToolchain::toolChainUpdated);
cpuDir.setSettingsKey("Qnx.QnxToolChain.CpuDir"); cpuDir.setSettingsKey("Qnx.QnxToolChain.CpuDir");
connect(&cpuDir, &BaseAspect::changed, this, &QnxToolChain::toolChainUpdated); connect(&cpuDir, &BaseAspect::changed, this, &QnxToolchain::toolChainUpdated);
connect(this, &AspectContainer::fromMapFinished, this, [this] { connect(this, &AspectContainer::fromMapFinished, this, [this] {
// Make the ABIs QNX specific (if they aren't already). // Make the ABIs QNX specific (if they aren't already).
@@ -116,12 +116,12 @@ QnxToolChain::QnxToolChain()
}); });
} }
std::unique_ptr<ToolchainConfigWidget> QnxToolChain::createConfigurationWidget() std::unique_ptr<ToolchainConfigWidget> QnxToolchain::createConfigurationWidget()
{ {
return std::make_unique<QnxToolChainConfigWidget>(this); return std::make_unique<QnxToolchainConfigWidget>(this);
} }
void QnxToolChain::addToEnvironment(Environment &env) const void QnxToolchain::addToEnvironment(Environment &env) const
{ {
if (env.expandedValueForKey("QNX_HOST").isEmpty() || if (env.expandedValueForKey("QNX_HOST").isEmpty() ||
env.expandedValueForKey("QNX_TARGET").isEmpty() || env.expandedValueForKey("QNX_TARGET").isEmpty() ||
@@ -131,7 +131,7 @@ void QnxToolChain::addToEnvironment(Environment &env) const
GccToolchain::addToEnvironment(env); GccToolchain::addToEnvironment(env);
} }
QStringList QnxToolChain::suggestedMkspecList() const QStringList QnxToolchain::suggestedMkspecList() const
{ {
return { return {
"qnx-armle-v7-qcc", "qnx-armle-v7-qcc",
@@ -141,7 +141,7 @@ QStringList QnxToolChain::suggestedMkspecList() const
}; };
} }
GccToolchain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const GccToolchain::DetectedAbisResult QnxToolchain::detectSupportedAbis() const
{ {
// "unknown-qnx-gnu"is needed to get the "--target=xxx" parameter sent code model, // "unknown-qnx-gnu"is needed to get the "--target=xxx" parameter sent code model,
// which gets translated as "x86_64-qnx-gnu", which gets Clang to happily parse // which gets translated as "x86_64-qnx-gnu", which gets Clang to happily parse
@@ -152,12 +152,12 @@ GccToolchain::DetectedAbisResult QnxToolChain::detectSupportedAbis() const
return GccToolchain::DetectedAbisResult{detectTargetAbis(sdpPath()), "unknown-qnx-gnu"}; return GccToolchain::DetectedAbisResult{detectTargetAbis(sdpPath()), "unknown-qnx-gnu"};
} }
bool QnxToolChain::operator ==(const Toolchain &other) const bool QnxToolchain::operator ==(const Toolchain &other) const
{ {
if (!GccToolchain::operator ==(other)) if (!GccToolchain::operator ==(other))
return false; return false;
auto qnxTc = static_cast<const QnxToolChain *>(&other); auto qnxTc = static_cast<const QnxToolchain *>(&other);
return sdpPath() == qnxTc->sdpPath() && cpuDir() == qnxTc->cpuDir(); return sdpPath() == qnxTc->sdpPath() && cpuDir() == qnxTc->cpuDir();
} }
@@ -166,7 +166,7 @@ bool QnxToolChain::operator ==(const Toolchain &other) const
// QnxToolChainConfigWidget // QnxToolChainConfigWidget
//--------------------------------------------------------------------------------- //---------------------------------------------------------------------------------
QnxToolChainConfigWidget::QnxToolChainConfigWidget(QnxToolChain *tc) QnxToolchainConfigWidget::QnxToolchainConfigWidget(QnxToolchain *tc)
: ToolchainConfigWidget(tc) : ToolchainConfigWidget(tc)
, m_compilerCommand(new PathChooser) , m_compilerCommand(new PathChooser)
, m_sdpPath(new PathChooser) , m_sdpPath(new PathChooser)
@@ -193,16 +193,16 @@ QnxToolChainConfigWidget::QnxToolChainConfigWidget(QnxToolChain *tc)
connect(m_compilerCommand, &PathChooser::rawPathChanged, this, &ToolchainConfigWidget::dirty); connect(m_compilerCommand, &PathChooser::rawPathChanged, this, &ToolchainConfigWidget::dirty);
connect(m_sdpPath, &PathChooser::rawPathChanged, connect(m_sdpPath, &PathChooser::rawPathChanged,
this, &QnxToolChainConfigWidget::handleSdpPathChange); this, &QnxToolchainConfigWidget::handleSdpPathChange);
connect(m_abiWidget, &AbiWidget::abiChanged, this, &ToolchainConfigWidget::dirty); connect(m_abiWidget, &AbiWidget::abiChanged, this, &ToolchainConfigWidget::dirty);
} }
void QnxToolChainConfigWidget::applyImpl() void QnxToolchainConfigWidget::applyImpl()
{ {
if (toolChain()->isAutoDetected()) if (toolchain()->isAutoDetected())
return; return;
auto tc = static_cast<QnxToolChain *>(toolChain()); auto tc = static_cast<QnxToolchain *>(toolchain());
Q_ASSERT(tc); Q_ASSERT(tc);
QString displayName = tc->displayName(); QString displayName = tc->displayName();
tc->setDisplayName(displayName); // reset display name tc->setDisplayName(displayName); // reset display name
@@ -211,11 +211,11 @@ void QnxToolChainConfigWidget::applyImpl()
tc->resetToolchain(m_compilerCommand->filePath()); tc->resetToolchain(m_compilerCommand->filePath());
} }
void QnxToolChainConfigWidget::discardImpl() void QnxToolchainConfigWidget::discardImpl()
{ {
// subwidgets are not yet connected! // subwidgets are not yet connected!
QSignalBlocker blocker(this); QSignalBlocker blocker(this);
auto tc = static_cast<const QnxToolChain *>(toolChain()); auto tc = static_cast<const QnxToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand()); m_compilerCommand->setFilePath(tc->compilerCommand());
m_sdpPath->setFilePath(tc->sdpPath()); m_sdpPath->setFilePath(tc->sdpPath());
m_abiWidget->setAbis(tc->supportedAbis(), tc->targetAbi()); m_abiWidget->setAbis(tc->supportedAbis(), tc->targetAbi());
@@ -223,16 +223,16 @@ void QnxToolChainConfigWidget::discardImpl()
m_abiWidget->setEnabled(true); m_abiWidget->setEnabled(true);
} }
bool QnxToolChainConfigWidget::isDirtyImpl() const bool QnxToolchainConfigWidget::isDirtyImpl() const
{ {
auto tc = static_cast<const QnxToolChain *>(toolChain()); auto tc = static_cast<const QnxToolchain *>(toolchain());
Q_ASSERT(tc); Q_ASSERT(tc);
return m_compilerCommand->filePath() != tc->compilerCommand() return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_sdpPath->filePath() != tc->sdpPath() || m_sdpPath->filePath() != tc->sdpPath()
|| m_abiWidget->currentAbi() != tc->targetAbi(); || m_abiWidget->currentAbi() != tc->targetAbi();
} }
void QnxToolChainConfigWidget::handleSdpPathChange() void QnxToolchainConfigWidget::handleSdpPathChange()
{ {
const Abi currentAbi = m_abiWidget->currentAbi(); const Abi currentAbi = m_abiWidget->currentAbi();
const bool customAbi = m_abiWidget->isCustomAbi(); const bool customAbi = m_abiWidget->isCustomAbi();
@@ -262,7 +262,7 @@ public:
setSupportedToolchainType(Constants::QNX_TOOLCHAIN_ID); setSupportedToolchainType(Constants::QNX_TOOLCHAIN_ID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID, setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID}); ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new QnxToolChain; }); setToolchainConstructor([] { return new QnxToolchain; });
setUserCreatable(true); setUserCreatable(true);
} }

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

@@ -7,10 +7,10 @@
namespace Qnx::Internal { namespace Qnx::Internal {
class QnxToolChain : public ProjectExplorer::GccToolchain class QnxToolchain : public ProjectExplorer::GccToolchain
{ {
public: public:
QnxToolChain(); QnxToolchain();
std::unique_ptr<ProjectExplorer::ToolchainConfigWidget> createConfigurationWidget() override; std::unique_ptr<ProjectExplorer::ToolchainConfigWidget> createConfigurationWidget() override;

14
tests/auto/toolchaincache/tst_toolchaincache.cpp
View File

@@ -7,7 +7,7 @@
//////////////// the actual autotest //////////////// the actual autotest
class tst_ToolChainCache : public QObject class tst_ToolchainCache : public QObject
{ {
Q_OBJECT Q_OBJECT
@@ -20,7 +20,7 @@ private slots:
}; };
void tst_ToolChainCache::insertOne() void tst_ToolchainCache::insertOne()
{ {
const QStringList key1 = {"one"}; const QStringList key1 = {"one"};
const QString value1 = "value1"; const QString value1 = "value1";
@@ -33,7 +33,7 @@ void tst_ToolChainCache::insertOne()
QVERIFY(!cache.check({"other"})); QVERIFY(!cache.check({"other"}));
} }
void tst_ToolChainCache::insertOneOne() void tst_ToolchainCache::insertOneOne()
{ {
const QStringList key1 = {"one"}; const QStringList key1 = {"one"};
const QString value1 = "value1"; const QString value1 = "value1";
@@ -47,7 +47,7 @@ void tst_ToolChainCache::insertOneOne()
QVERIFY(!cache.check({"other"})); QVERIFY(!cache.check({"other"}));
} }
void tst_ToolChainCache::insertOneTwo() void tst_ToolchainCache::insertOneTwo()
{ {
const QStringList key1 = {"one"}; const QStringList key1 = {"one"};
const QString value1 = "value1"; const QString value1 = "value1";
@@ -65,7 +65,7 @@ void tst_ToolChainCache::insertOneTwo()
QVERIFY(!cache.check({"other"})); QVERIFY(!cache.check({"other"}));
} }
void tst_ToolChainCache::insertOneTwoThree() void tst_ToolchainCache::insertOneTwoThree()
{ {
const QStringList key1 = {"one"}; const QStringList key1 = {"one"};
const QString value1 = "value1"; const QString value1 = "value1";
@@ -87,7 +87,7 @@ void tst_ToolChainCache::insertOneTwoThree()
QVERIFY(!cache.check({"other"})); QVERIFY(!cache.check({"other"}));
} }
void tst_ToolChainCache::insertOneTwoOneThree() void tst_ToolchainCache::insertOneTwoOneThree()
{ {
const QStringList key1 = {"one"}; const QStringList key1 = {"one"};
const QString value1 = "value1"; const QString value1 = "value1";
@@ -110,5 +110,5 @@ void tst_ToolChainCache::insertOneTwoOneThree()
QVERIFY(!cache.check({"other"})); QVERIFY(!cache.check({"other"}));
} }
QTEST_GUILESS_MAIN(tst_ToolChainCache) QTEST_GUILESS_MAIN(tst_ToolchainCache)
#include "tst_toolchaincache.moc" #include "tst_toolchaincache.moc"