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

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

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

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

@@ -470,10 +470,10 @@ SdccToolchainConfigWidget::SdccToolchainConfigWidget(SdccToolchain *tc) :
void SdccToolchainConfigWidget::applyImpl()
{
if (toolChain()->isAutoDetected())
if (toolchain()->isAutoDetected())
return;
const auto tc = static_cast<SdccToolchain *>(toolChain());
const auto tc = static_cast<SdccToolchain *>(toolchain());
const QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath());
tc->setTargetAbi(m_abiWidget->currentAbi());
@@ -490,7 +490,7 @@ void SdccToolchainConfigWidget::applyImpl()
bool SdccToolchainConfigWidget::isDirtyImpl() const
{
const auto tc = static_cast<SdccToolchain *>(toolChain());
const auto tc = static_cast<SdccToolchain *>(toolchain());
return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_abiWidget->currentAbi() != tc->targetAbi()
;
@@ -505,7 +505,7 @@ void SdccToolchainConfigWidget::makeReadOnlyImpl()
void SdccToolchainConfigWidget::setFromToolchain()
{
const QSignalBlocker blocker(this);
const auto tc = static_cast<SdccToolchain *>(toolChain());
const auto tc = static_cast<SdccToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand());
m_abiWidget->setAbis({}, tc->targetAbi());
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 << "-c";
if (projectPart.toolchainType != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID) {
args << "--target=" + projectPart.toolChainTargetTriple;
if (projectPart.toolChainAbi.architecture() == Abi::X86Architecture)
args << QLatin1String(projectPart.toolChainAbi.wordWidth() == 64 ? "-m64" : "-m32");
args << "--target=" + projectPart.toolchainTargetTriple;
if (projectPart.toolchainAbi.architecture() == Abi::X86Architecture)
args << QLatin1String(projectPart.toolchainAbi.wordWidth() == 64 ? "-m64" : "-m32");
}
args << projectPart.compilerFlags;
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)
{
// 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
//
// And the CMakePresets.json
@@ -996,7 +996,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
SysRootKitAspect::setSysRoot(k, data->sysroot);
for (const ToolchainDescription &cmtcd : data->toolchains) {
const ToolchainData tcd = findOrCreateToolChains(cmtcd);
const ToolchainData tcd = findOrCreateToolchains(cmtcd);
QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
if (tcd.areTemporary) {

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

@@ -68,7 +68,7 @@ void CompilationDatabaseTests::testProject()
const CppEditor::ProjectPart &projectPart = *projectParts.first();
QVERIFY(!projectPart.headerPaths.isEmpty());
QVERIFY(!projectPart.projectMacros.isEmpty());
QVERIFY(!projectPart.toolChainMacros.isEmpty());
QVERIFY(!projectPart.toolchainMacros.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) {
configFile += ProjectExplorer::Macro::toByteArray(part->toolChainMacros);
configFile += ProjectExplorer::Macro::toByteArray(part->toolchainMacros);
configFile += overwrittenToolchainDefines(*part.data());
configFile += ProjectExplorer::Macro::toByteArray(part->projectMacros);
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()
{
if (m_projectPart.toolChainAbi.architecture() != Abi::X86Architecture)
if (m_projectPart.toolchainAbi.architecture() != Abi::X86Architecture)
return;
const QString argument = m_projectPart.toolChainAbi.wordWidth() == 64
const QString argument = m_projectPart.toolchainAbi.wordWidth() == 64
? QLatin1String("-m64")
: QLatin1String("-m32");
add(argument);
@@ -250,7 +250,7 @@ void CompilerOptionsBuilder::addTargetTriple()
}
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.
if (!target.isEmpty())
@@ -284,7 +284,7 @@ void CompilerOptionsBuilder::addMsvcExceptions()
{
if (!m_clStyle)
return;
if (Utils::anyOf(m_projectPart.toolChainMacros, [](const Macro &macro) {
if (Utils::anyOf(m_projectPart.toolchainMacros, [](const Macro &macro) {
return macro.key == "_CPPUNWIND";
})) {
enableExceptions();
@@ -421,7 +421,7 @@ void CompilerOptionsBuilder::addProjectMacros()
if (m_projectPart.toolchainType == ProjectExplorer::Constants::CUSTOM_TOOLCHAIN_TYPEID
|| m_projectPart.toolchainType == Qnx::Constants::QNX_TOOLCHAIN_ID
|| m_projectPart.toolchainType.name().contains("BareMetal") || useMacros) {
addMacros(m_projectPart.toolChainMacros);
addMacros(m_projectPart.toolchainMacros);
}
addMacros(m_projectPart.projectMacros);
@@ -579,7 +579,7 @@ static QByteArray msCompatibilityVersionFromDefines(const Macros &macros)
QByteArray CompilerOptionsBuilder::msvcVersion() const
{
const QByteArray version = msCompatibilityVersionFromDefines(m_projectPart.toolChainMacros);
const QByteArray version = msCompatibilityVersionFromDefines(m_projectPart.toolchainMacros);
return !version.isEmpty() ? version
: msCompatibilityVersionFromDefines(m_projectPart.projectMacros);
}

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

@@ -69,7 +69,6 @@ public:
void prepend(const QString &arg);
void add(const QStringList &args, bool gccOnlyOptions = false);
static UseToolchainMacros useToolChainMacros();
void reset();
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,
Abi::MachOFormat, 64);
}
tcInfo.isMsvc2015ToolChain = isMsvc2015;
tcInfo.isMsvc2015Toolchain = isMsvc2015;
tcInfo.extraCodeModelFlags = extraFlags;
tcInfo.macroInspectionRunner = [this](const QStringList &) {
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("Build Target Type"), CMI::Utils::toString(part->buildTargetType)},
{QString::fromLatin1("ToolChain Type"), part->toolchainType.toString()},
{QString::fromLatin1("ToolChain Target Triple"), part->toolChainTargetTriple},
{QString::fromLatin1("ToolChain Word Width"), CMI::Utils::toString(part->toolChainAbi.wordWidth())},
{QString::fromLatin1("ToolChain Install Dir"), part->toolChainInstallDir.toString()},
{QString::fromLatin1("ToolChain Target Triple"), part->toolchainTargetTriple},
{QString::fromLatin1("ToolChain Word Width"), CMI::Utils::toString(part->toolchainAbi.wordWidth())},
{QString::fromLatin1("ToolChain Install Dir"), part->toolchainInstallDir.toString()},
{QString::fromLatin1("Language Version"), CMI::Utils::toString(part->languageVersion)},
{QString::fromLatin1("Language Extensions"), CMI::Utils::toString(part->languageExtensions)},
{QString::fromLatin1("Qt Version"), CMI::Utils::toString(part->qtVersion)}
@@ -1957,9 +1957,9 @@ void CppCodeModelInspectorDialog::updateProjectPartData(const ProjectPart::Const
m_projectPartTab->setTabText(ProjectPartFilesTab,
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_projectPartTab->setTabText(ProjectPartDefinesTab,
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 File : " << projectFilePath << "\n";
m_out << i3 << "ToolChain Type : " << part->toolchainType.toString() << "\n";
m_out << i3 << "ToolChain Target Triple: " << part->toolChainTargetTriple << "\n";
m_out << i3 << "ToolChain Word Width : " << part->toolChainAbi.wordWidth() << "\n";
m_out << i3 << "ToolChain Install Dir : " << part->toolChainInstallDir << "\n";
m_out << i3 << "ToolChain Target Triple: " << part->toolchainTargetTriple << "\n";
m_out << i3 << "ToolChain Word Width : " << part->toolchainAbi.wordWidth() << "\n";
m_out << i3 << "ToolChain Install Dir : " << part->toolchainInstallDir << "\n";
m_out << i3 << "Compiler Flags : " << part->compilerFlags.join(", ") << "\n";
m_out << i3 << "Selected For Building : " << part->selectedForBuilding << "\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";
const QList<QByteArray> defineLines =
ProjectExplorer::Macro::toByteArray(part->toolChainMacros).split('\n');
ProjectExplorer::Macro::toByteArray(part->toolchainMacros).split('\n');
for (const QByteArray &defineLine : defineLines)
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;
for (const ProjectData &projectData : std::as_const(ld.m_projectData)) {
for (const ProjectPart::ConstPtr &part : projectData.projectInfo->projectParts()) {
addUnique(part->toolChainMacros, macros, alreadyIn);
addUnique(part->toolchainMacros, macros, alreadyIn);
addUnique(part->projectMacros, macros, alreadyIn);
}
}

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

@@ -44,10 +44,10 @@ void HeaderPathFilter::removeGccInternalIncludePaths()
return;
}
if (projectPart.toolChainInstallDir.isEmpty())
if (projectPart.toolchainInstallDir.isEmpty())
return;
const Utils::FilePath gccInstallDir = projectPart.toolChainInstallDir;
const Utils::FilePath gccInstallDir = projectPart.toolchainInstallDir;
auto isGccInternalInclude = [gccInstallDir](const HeaderPath &headerPath) {
const auto filePath = Utils::FilePath::fromString(headerPath.path);
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;
for (const ProjectPart::ConstPtr &part : projectParts) {
defines.append(part->toolChainMacros);
defines.append(part->toolchainMacros);
defines.append(part->projectMacros);
}
return defines;

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

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

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

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

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

@@ -76,7 +76,7 @@ public:
// Macros
const ProjectExplorer::Macros projectMacros;
const ProjectExplorer::Macros &toolChainMacros = m_macroReport.macros;
const ProjectExplorer::Macros &toolchainMacros = m_macroReport.macros;
// Build system
const QString buildSystemTarget;
@@ -84,13 +84,13 @@ public:
= ProjectExplorer::BuildTargetType::Unknown;
const bool selectedForBuilding = true;
// ToolChain
// Toolchain
const Utils::Id toolchainType;
const bool isMsvc2015Toolchain = false;
const QString toolChainTargetTriple;
const QString toolchainTargetTriple;
const bool targetTripleIsAuthoritative;
const ProjectExplorer::Abi toolChainAbi = ProjectExplorer::Abi::hostAbi();
const Utils::FilePath toolChainInstallDir;
const ProjectExplorer::Abi toolchainAbi = ProjectExplorer::Abi::hostAbi();
const Utils::FilePath toolchainInstallDir;
const Utils::FilePath compilerFilePath;
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();
// if (allKits.count() != 1)
// 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)
// QSKIP("This test requires that there is a kit with a toolchain.");
// 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\".")
.arg(tc.toString());
@@ -3833,7 +3833,7 @@ void GdbEngine::setupEngine()
if (rp.debugger.command.isEmpty()) {
handleGdbStartFailed();
handleAdapterStartFailed(
msgNoGdbBinaryForToolChain(rp.toolChainAbi),
msgNoGdbBinaryForToolchain(rp.toolChainAbi),
Constants::DEBUGGER_COMMON_SETTINGS_ID);
return;
}

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

@@ -46,7 +46,7 @@ public:
private:
QtVersions autoDetectQtVersions() const;
QList<Toolchain *> autoDetectToolChains();
QList<Toolchain *> autoDetectToolchains();
void autoDetectPython();
QList<Id> autoDetectCMake();
void autoDetectDebugger();
@@ -107,10 +107,10 @@ void KitDetectorPrivate::undoAutoDetect() const
emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Removing toolchain entries..."));
const Toolchains toolchains = ToolchainManager::toolchains();
for (Toolchain *toolChain : toolchains) {
if (toolChain && toolChain->detectionSource() == m_sharedId) {
emit q->logOutput(ProjectExplorer::Tr::tr("Removed \"%1\"").arg(toolChain->displayName()));
ToolchainManager::deregisterToolchain(toolChain);
for (Toolchain *toolchain : toolchains) {
if (toolchain && toolchain->detectionSource() == m_sharedId) {
emit q->logOutput(ProjectExplorer::Tr::tr("Removed \"%1\"").arg(toolchain->displayName()));
ToolchainManager::deregisterToolchain(toolchain);
}
};
@@ -164,9 +164,9 @@ void KitDetectorPrivate::listAutoDetected() const
}
emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Toolchains:"));
for (Toolchain *toolChain : ToolchainManager::toolchains()) {
if (toolChain->detectionSource() == m_sharedId)
emit q->logOutput(toolChain->displayName());
for (Toolchain *toolchain : ToolchainManager::toolchains()) {
if (toolchain->detectionSource() == m_sharedId)
emit q->logOutput(toolchain->displayName());
}
if (QObject *cmakeManager = ExtensionSystem::PluginManager::getObjectByName(
@@ -247,29 +247,29 @@ QtVersions KitDetectorPrivate::autoDetectQtVersions() const
return qtVersions;
}
Toolchains KitDetectorPrivate::autoDetectToolChains()
Toolchains KitDetectorPrivate::autoDetectToolchains()
{
const QList<ToolchainFactory *> factories = ToolchainFactory::allToolchainFactories();
Toolchains alreadyKnown = ToolchainManager::toolchains();
Toolchains allNewToolChains;
Toolchains allNewToolchains;
QApplication::processEvents();
emit q->logOutput('\n' + ProjectExplorer::Tr::tr("Searching toolchains..."));
for (ToolchainFactory *factory : factories) {
emit q->logOutput(ProjectExplorer::Tr::tr("Searching toolchains of type %1").arg(factory->displayName()));
const ToolchainDetector detector(alreadyKnown, m_device, m_searchPaths);
const Toolchains newToolChains = factory->autoDetect(detector);
for (Toolchain *toolChain : newToolChains) {
emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolChain->compilerCommand().toUserOutput()));
toolChain->setDetectionSource(m_sharedId);
ToolchainManager::registerToolchain(toolChain);
alreadyKnown.append(toolChain);
const Toolchains newToolchains = factory->autoDetect(detector);
for (Toolchain *toolchain : newToolchains) {
emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolchain->compilerCommand().toUserOutput()));
toolchain->setDetectionSource(m_sharedId);
ToolchainManager::registerToolchain(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()
@@ -333,7 +333,7 @@ void KitDetectorPrivate::autoDetect()
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 QList<Id> cmakeIds = autoDetectCMake();
@@ -363,8 +363,8 @@ void KitDetectorPrivate::autoDetect()
return tc->detectionSource() == m_sharedId
&& (!qt || qt->qtAbis().contains(tc->targetAbi()));
});
for (Toolchain *toolChain : toolchainsToSet)
ToolchainKitAspect::setToolchain(k, toolChain);
for (Toolchain *toolchain : toolchainsToSet)
ToolchainKitAspect::setToolchain(k, toolchain);
if (cmakeId.isValid())
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)
}
using ToolChainPair = std::pair<GccToolchain *, GccToolchain *>;
using ToolchainPair = std::pair<GccToolchain *, GccToolchain *>;
namespace Ios {
namespace Internal {
@@ -98,57 +98,57 @@ static bool isSimulatorDeviceId(const Id &id)
return id == Constants::IOS_SIMULATOR_TYPE;
}
static QList<GccToolchain *> clangToolChains(const Toolchains &toolChains)
static QList<GccToolchain *> clangToolchains(const Toolchains &toolchains)
{
QList<GccToolchain *> clangToolChains;
for (Toolchain *toolChain : toolChains)
if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
clangToolChains.append(static_cast<GccToolchain *>(toolChain));
return clangToolChains;
QList<GccToolchain *> clangToolchains;
for (Toolchain *toolchain : toolchains)
if (toolchain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
clangToolchains.append(static_cast<GccToolchain *>(toolchain));
return clangToolchains;
}
static QList<GccToolchain *> autoDetectedIosToolChains()
static QList<GccToolchain *> autoDetectedIosToolchains()
{
const QList<GccToolchain *> toolChains = clangToolChains(ToolchainManager::toolchains());
return filtered(toolChains, [](GccToolchain *toolChain) {
const QList<GccToolchain *> toolchains = clangToolchains(ToolchainManager::toolchains());
return filtered(toolchains, [](GccToolchain *toolChain) {
return toolChain->isAutoDetected()
&& (toolChain->displayName().startsWith("iphone")
|| 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 QList<GccToolchain *> &toolChains)
const QList<GccToolchain *> &toolchains)
{
ToolChainPair platformToolChains;
ToolchainPair platformToolchains;
auto toolchainMatch = [](GccToolchain *toolChain, const FilePath &compilerPath, const QStringList &flags) {
return compilerPath == toolChain->compilerCommand()
&& flags == toolChain->platformCodeGenFlags()
&& 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,
target.backendFlags));
platformToolChains.second = findOrDefault(toolChains, std::bind(toolchainMatch, std::placeholders::_1,
platformToolchains.second = findOrDefault(toolchains, std::bind(toolchainMatch, std::placeholders::_1,
platform.cxxCompilerPath,
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;
const QList<GccToolchain *> toolChains = autoDetectedIosToolChains();
QHash<XcodePlatform::ToolchainTarget, ToolchainPair> platformToolchainHash;
const QList<GccToolchain *> toolchains = autoDetectedIosToolchains();
for (const XcodePlatform &platform : platforms) {
for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
ToolChainPair platformToolchains = findToolChainForPlatform(platform, target,
toolChains);
ToolchainPair platformToolchains = findToolchainForPlatform(platform, target,
toolchains);
if (platformToolchains.first || platformToolchains.second)
platformToolChainHash.insert(target, platformToolchains);
platformToolchainHash.insert(target, platformToolchains);
}
}
return platformToolChainHash;
return platformToolchainHash;
}
static QSet<Kit *> existingAutoDetectedIosKits()
@@ -166,16 +166,16 @@ static void printKits(const QSet<Kit *> &kits)
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)
{
DeviceTypeKitAspect::setDeviceTypeId(kit, pDeviceType);
if (toolChains.first)
ToolchainKitAspect::setToolchain(kit, toolChains.first);
if (toolchains.first)
ToolchainKitAspect::setToolchain(kit, toolchains.first);
else
ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
if (toolChains.second)
ToolchainKitAspect::setToolchain(kit, toolChains.second);
if (toolchains.second)
ToolchainKitAspect::setToolchain(kit, toolchains.second);
else
ToolchainKitAspect::clearToolchain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
@@ -232,7 +232,7 @@ void IosConfigurations::updateAutomaticKitList()
qCDebug(kitSetupLog) << "Developer path:" << developerPath();
// target -> tool chain
const auto targetToolChainHash = findToolChains(platforms);
const auto targetToolchainHash = findToolchains(platforms);
const auto qtVersions = toSet(QtVersionManager::versions([](const QtVersion *v) {
return v->isValid() && v->type() == Constants::IOSQT;
@@ -256,7 +256,7 @@ void IosConfigurations::updateAutomaticKitList()
const auto target = targets.front();
const ToolChainPair &platformToolchains = targetToolChainHash.value(target);
const ToolchainPair &platformToolchains = targetToolchainHash.value(target);
if (!platformToolchains.first && !platformToolchains.second) {
qCDebug(kitSetupLog) << " - No tool chain found";
continue;
@@ -586,13 +586,13 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
if (detector.device->type() != ProjectExplorer::Constants::DESKTOP_DEVICE_TYPE)
return {};
QList<GccToolchain *> existingClangToolChains = clangToolChains(detector.alreadyKnown);
QList<GccToolchain *> existingClangToolChains = clangToolchains(detector.alreadyKnown);
const QList<XcodePlatform> platforms = XcodeProbe::detectPlatforms().values();
Toolchains toolChains;
toolChains.reserve(platforms.size());
Toolchains toolchains;
toolchains.reserve(platforms.size());
for (const XcodePlatform &platform : platforms) {
for (const XcodePlatform::ToolchainTarget &target : platform.targets) {
ToolChainPair platformToolchains = findToolChainForPlatform(platform, target,
ToolchainPair platformToolchains = findToolchainForPlatform(platform, target,
existingClangToolChains);
auto createOrAdd = [&](GccToolchain *toolChain, Id l) {
if (!toolChain) {
@@ -608,14 +608,14 @@ Toolchains IosToolchainFactory::autoDetect(const ToolchainDetector &detector) co
platform.cxxCompilerPath : platform.cCompilerPath);
existingClangToolChains.append(toolChain);
}
toolChains.append(toolChain);
toolchains.append(toolChain);
};
createOrAdd(platformToolchains.first, ProjectExplorer::Constants::C_LANGUAGE_ID);
createOrAdd(platformToolchains.second, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
}
}
return toolChains;
return toolchains;
}
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
class NimToolChainConfigWidget : public ToolchainConfigWidget
class NimToolchainConfigWidget : public ToolchainConfigWidget
{
public:
explicit NimToolChainConfigWidget(NimToolChain *tc)
explicit NimToolchainConfigWidget(NimToolChain *tc)
: ToolchainConfigWidget(tc)
, m_compilerCommand(new PathChooser)
, m_compilerVersion(new QLineEdit)
@@ -142,7 +142,7 @@ public:
// Connect
connect(m_compilerCommand, &PathChooser::validChanged, this, [this] {
const FilePath path = m_compilerCommand->rawFilePath();
auto tc = static_cast<NimToolChain *>(toolChain());
auto tc = static_cast<NimToolChain *>(toolchain());
QTC_ASSERT(tc, return);
tc->setCompilerCommand(path);
fillUI();
@@ -162,35 +162,35 @@ private:
QLineEdit *m_compilerVersion;
};
void NimToolChainConfigWidget::applyImpl()
void NimToolchainConfigWidget::applyImpl()
{
auto tc = static_cast<NimToolChain *>(toolChain());
auto tc = static_cast<NimToolChain *>(toolchain());
Q_ASSERT(tc);
if (tc->isAutoDetected())
return;
tc->setCompilerCommand(m_compilerCommand->filePath());
}
void NimToolChainConfigWidget::discardImpl()
void NimToolchainConfigWidget::discardImpl()
{
fillUI();
}
bool NimToolChainConfigWidget::isDirtyImpl() const
bool NimToolchainConfigWidget::isDirtyImpl() const
{
auto tc = static_cast<NimToolChain *>(toolChain());
auto tc = static_cast<NimToolChain *>(toolchain());
Q_ASSERT(tc);
return tc->compilerCommand() != m_compilerCommand->filePath();
}
void NimToolChainConfigWidget::makeReadOnlyImpl()
void NimToolchainConfigWidget::makeReadOnlyImpl()
{
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);
m_compilerCommand->setFilePath(tc->compilerCommand());
m_compilerVersion->setText(tc->compilerVersion());
@@ -198,7 +198,7 @@ void NimToolChainConfigWidget::fillUI()
std::unique_ptr<ToolchainConfigWidget> NimToolChain::createConfigurationWidget()
{
return std::make_unique<NimToolChainConfigWidget>(this);
return std::make_unique<NimToolchainConfigWidget>(this);
}
// NimToolchainFactory

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

@@ -488,10 +488,10 @@ void CustomToolChainConfigWidget::errorParserChanged(int )
void CustomToolChainConfigWidget::applyImpl()
{
if (toolChain()->isAutoDetected())
if (toolchain()->isAutoDetected())
return;
auto tc = static_cast<CustomToolChain *>(toolChain());
auto tc = static_cast<CustomToolChain *>(toolchain());
Q_ASSERT(tc);
QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath());
@@ -517,7 +517,7 @@ void CustomToolChainConfigWidget::setFromToolchain()
{
// subwidgets are not yet connected!
QSignalBlocker blocker(this);
auto tc = static_cast<CustomToolChain *>(toolChain());
auto tc = static_cast<CustomToolChain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand());
m_makeCommand->setFilePath(tc->makeCommand(Environment()));
m_abiWidget->setAbis(Abis(), tc->targetAbi());
@@ -534,7 +534,7 @@ void CustomToolChainConfigWidget::setFromToolchain()
bool CustomToolChainConfigWidget::isDirtyImpl() const
{
auto tc = static_cast<CustomToolChain *>(toolChain());
auto tc = static_cast<CustomToolChain *>(toolchain());
Q_ASSERT(tc);
return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_makeCommand->filePath().toString() != tc->makeCommand(Environment()).toString()

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

@@ -1770,7 +1770,7 @@ GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
}));
m_parentToolChainConnections.append(
connect(tcManager, &ToolchainManager::toolchainRemoved, this, [this](Toolchain *tc) {
if (tc->id() == toolChain()->id()) {
if (tc->id() == toolchain()->id()) {
for (QMetaObject::Connection &connection : m_parentToolChainConnections)
QObject::disconnect(connection);
return;
@@ -1785,10 +1785,10 @@ GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
void GccToolchainConfigWidget::applyImpl()
{
if (toolChain()->isAutoDetected())
if (toolchain()->isAutoDetected())
return;
auto tc = static_cast<GccToolchain *>(toolChain());
auto tc = static_cast<GccToolchain *>(toolchain());
Q_ASSERT(tc);
QString displayName = tc->displayName();
tc->setCompilerCommand(m_compilerCommand->filePath());
@@ -1834,7 +1834,7 @@ void GccToolchainConfigWidget::setFromToolchain()
{
// subwidgets are not yet connected!
QSignalBlocker blocker(this);
auto tc = static_cast<GccToolchain *>(toolChain());
auto tc = static_cast<GccToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand());
m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->platformCodeGenFlags(),
HostOsInfo::hostOs()));
@@ -1852,7 +1852,7 @@ void GccToolchainConfigWidget::setFromToolchain()
bool GccToolchainConfigWidget::isDirtyImpl() const
{
auto tc = static_cast<GccToolchain *>(toolChain());
auto tc = static_cast<GccToolchain *>(toolchain());
if (m_compilerCommand->filePath() != tc->compilerCommand()
|| m_platformCodeGenFlagsLineEdit->text()
@@ -2030,7 +2030,7 @@ void GccToolchainConfigWidget::updateParentToolChainComboBox()
{
QTC_ASSERT(m_parentToolchainCombo, return);
auto *tc = static_cast<GccToolchain *>(toolChain());
auto *tc = static_cast<GccToolchain *>(toolchain());
QByteArray parentId = m_parentToolchainCombo->currentData().toByteArray();
if (tc->isAutoDetected() || m_parentToolchainCombo->count() == 0)
parentId = tc->m_parentToolchainId;

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

@@ -1285,7 +1285,7 @@ protected:
void setFromMsvcToolChain()
{
const auto *tc = static_cast<const MsvcToolChain *>(toolChain());
const auto *tc = static_cast<const MsvcToolChain *>(toolchain());
QTC_ASSERT(tc, return );
m_nameDisplayLabel->setText(tc->displayName());
m_varsBatDisplayLabel->setText(msvcVarsToDisplay(*tc));
@@ -1382,7 +1382,7 @@ private:
void MsvcToolChainConfigWidget::applyImpl()
{
auto *tc = static_cast<MsvcToolChain *>(toolChain());
auto *tc = static_cast<MsvcToolChain *>(toolchain());
QTC_ASSERT(tc, return );
const QString vcVars = QDir::fromNativeSeparators(m_varsBatPathCombo->currentText());
tc->setupVarsBat(m_abiWidget->currentAbi(), vcVars, vcVarsArguments());
@@ -1396,7 +1396,7 @@ void MsvcToolChainConfigWidget::discardImpl()
bool MsvcToolChainConfigWidget::isDirtyImpl() const
{
auto msvcToolChain = static_cast<MsvcToolChain *>(toolChain());
auto msvcToolChain = static_cast<MsvcToolChain *>(toolchain());
return msvcToolChain->varsBat() != QDir::fromNativeSeparators(m_varsBatPathCombo->currentText())
|| msvcToolChain->varsBatArg() != vcVarsArguments()
@@ -1413,7 +1413,7 @@ void MsvcToolChainConfigWidget::makeReadOnlyImpl()
void MsvcToolChainConfigWidget::setFromMsvcToolChain()
{
const auto *tc = static_cast<const MsvcToolChain *>(toolChain());
const auto *tc = static_cast<const MsvcToolChain *>(toolchain());
QTC_ASSERT(tc, return );
m_nameDisplayLabel->setText(tc->displayName());
QString args = tc->varsBatArg();
@@ -1434,7 +1434,7 @@ void MsvcToolChainConfigWidget::setFromMsvcToolChain()
void MsvcToolChainConfigWidget::updateAbis()
{
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 );
const MsvcToolChain::Platform platform = m_varsBatArchCombo->currentData().value<MsvcToolChain::Platform>();
const Abi::Architecture arch = archForPlatform(platform);
@@ -1564,7 +1564,7 @@ private:
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_varsBatDisplayCombo->clear();
m_varsBatDisplayCombo->addItem(msvcVarsToDisplay(*currentTC));
@@ -1574,7 +1574,7 @@ void ClangClToolChainConfigWidget::setFromClangClToolChain()
m_varsBatDisplayCombo->addItem(varsToDisplay);
}
const auto *clangClToolChain = static_cast<const ClangClToolChain *>(toolChain());
const auto *clangClToolChain = static_cast<const ClangClToolChain *>(toolchain());
if (clangClToolChain->isAutoDetected())
m_llvmDirLabel->setText(clangClToolChain->clangPath().toUserOutput());
else
@@ -1696,7 +1696,7 @@ static Toolchains detectClangClToolChainInPath(const FilePath &clangClPath,
void ClangClToolChainConfigWidget::applyImpl()
{
Utils::FilePath clangClPath = m_compilerCommand->filePath();
auto clangClToolChain = static_cast<ClangClToolChain *>(toolChain());
auto clangClToolChain = static_cast<ClangClToolChain *>(toolchain());
clangClToolChain->setClangPath(clangClPath);
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::findOrCreateToolChains(const ToolchainDescription &tcd) const
ProjectImporter::findOrCreateToolchains(const ToolchainDescription &tcd) const
{
ToolchainData result;
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?
bool hasKitWithTemporaryData(Utils::Id id, const QVariant &data) const;
ToolchainData findOrCreateToolChains(const ToolchainDescription &tcd) const;
ToolchainData findOrCreateToolchains(const ToolchainDescription &tcd) const;
private:
void markKitAsTemporary(Kit *k) const;

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

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

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

@@ -139,7 +139,7 @@ public:
public:
Utils::Id type;
bool isMsvc2015ToolChain = false;
bool isMsvc2015Toolchain = false;
bool targetTripleIsAuthoritative = false;
Abi abi;
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();
}
Toolchain *ToolchainConfigWidget::toolChain() const
Toolchain *ToolchainConfigWidget::toolchain() const
{
return m_toolChain;
}

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

@@ -28,7 +28,7 @@ class PROJECTEXPLORER_EXPORT ToolchainConfigWidget : public QScrollArea
public:
explicit ToolchainConfigWidget(Toolchain *tc);
Toolchain *toolChain() const;
Toolchain *toolchain() const;
void apply();
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 {
QList<ToolchainData> tcData;
if (!bgData->cxxCompilerPath.isEmpty())
tcData << findOrCreateToolChains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID});
tcData << findOrCreateToolchains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID});
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)) {
if (!tc.tcs.isEmpty())
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,
ProjectExplorer::Constants::CXX_LANGUAGE_ID}) {
auto toolChain = new QnxToolChain;
auto toolChain = new QnxToolchain;
toolChain->setDetection(Toolchain::ManualDetection);
toolChain->setLanguage(language);
toolChain->setTargetAbi(target.m_abi);

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

@@ -22,12 +22,12 @@ using namespace Utils;
namespace Qnx::Internal {
// QnxToolChainConfigWidget
// QnxToolchainConfigWidget
class QnxToolChainConfigWidget : public ToolchainConfigWidget
class QnxToolchainConfigWidget : public ToolchainConfigWidget
{
public:
QnxToolChainConfigWidget(QnxToolChain *tc);
QnxToolchainConfigWidget(QnxToolchain *tc);
private:
void applyImpl() override;
@@ -97,17 +97,17 @@ static QStringList reinterpretOptions(const QStringList &args)
return arguments;
}
QnxToolChain::QnxToolChain()
QnxToolchain::QnxToolchain()
: GccToolchain(Constants::QNX_TOOLCHAIN_ID)
{
setOptionsReinterpreter(&reinterpretOptions);
setTypeDisplayName(Tr::tr("QCC"));
sdpPath.setSettingsKey("Qnx.QnxToolChain.NDKPath");
connect(&sdpPath, &BaseAspect::changed, this, &QnxToolChain::toolChainUpdated);
connect(&sdpPath, &BaseAspect::changed, this, &QnxToolchain::toolChainUpdated);
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] {
// 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() ||
env.expandedValueForKey("QNX_TARGET").isEmpty() ||
@@ -131,7 +131,7 @@ void QnxToolChain::addToEnvironment(Environment &env) const
GccToolchain::addToEnvironment(env);
}
QStringList QnxToolChain::suggestedMkspecList() const
QStringList QnxToolchain::suggestedMkspecList() const
{
return {
"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,
// 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"};
}
bool QnxToolChain::operator ==(const Toolchain &other) const
bool QnxToolchain::operator ==(const Toolchain &other) const
{
if (!GccToolchain::operator ==(other))
return false;
auto qnxTc = static_cast<const QnxToolChain *>(&other);
auto qnxTc = static_cast<const QnxToolchain *>(&other);
return sdpPath() == qnxTc->sdpPath() && cpuDir() == qnxTc->cpuDir();
}
@@ -166,7 +166,7 @@ bool QnxToolChain::operator ==(const Toolchain &other) const
// QnxToolChainConfigWidget
//---------------------------------------------------------------------------------
QnxToolChainConfigWidget::QnxToolChainConfigWidget(QnxToolChain *tc)
QnxToolchainConfigWidget::QnxToolchainConfigWidget(QnxToolchain *tc)
: ToolchainConfigWidget(tc)
, m_compilerCommand(new PathChooser)
, m_sdpPath(new PathChooser)
@@ -193,16 +193,16 @@ QnxToolChainConfigWidget::QnxToolChainConfigWidget(QnxToolChain *tc)
connect(m_compilerCommand, &PathChooser::rawPathChanged, this, &ToolchainConfigWidget::dirty);
connect(m_sdpPath, &PathChooser::rawPathChanged,
this, &QnxToolChainConfigWidget::handleSdpPathChange);
this, &QnxToolchainConfigWidget::handleSdpPathChange);
connect(m_abiWidget, &AbiWidget::abiChanged, this, &ToolchainConfigWidget::dirty);
}
void QnxToolChainConfigWidget::applyImpl()
void QnxToolchainConfigWidget::applyImpl()
{
if (toolChain()->isAutoDetected())
if (toolchain()->isAutoDetected())
return;
auto tc = static_cast<QnxToolChain *>(toolChain());
auto tc = static_cast<QnxToolchain *>(toolchain());
Q_ASSERT(tc);
QString displayName = tc->displayName();
tc->setDisplayName(displayName); // reset display name
@@ -211,11 +211,11 @@ void QnxToolChainConfigWidget::applyImpl()
tc->resetToolchain(m_compilerCommand->filePath());
}
void QnxToolChainConfigWidget::discardImpl()
void QnxToolchainConfigWidget::discardImpl()
{
// subwidgets are not yet connected!
QSignalBlocker blocker(this);
auto tc = static_cast<const QnxToolChain *>(toolChain());
auto tc = static_cast<const QnxToolchain *>(toolchain());
m_compilerCommand->setFilePath(tc->compilerCommand());
m_sdpPath->setFilePath(tc->sdpPath());
m_abiWidget->setAbis(tc->supportedAbis(), tc->targetAbi());
@@ -223,16 +223,16 @@ void QnxToolChainConfigWidget::discardImpl()
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);
return m_compilerCommand->filePath() != tc->compilerCommand()
|| m_sdpPath->filePath() != tc->sdpPath()
|| m_abiWidget->currentAbi() != tc->targetAbi();
}
void QnxToolChainConfigWidget::handleSdpPathChange()
void QnxToolchainConfigWidget::handleSdpPathChange()
{
const Abi currentAbi = m_abiWidget->currentAbi();
const bool customAbi = m_abiWidget->isCustomAbi();
@@ -262,7 +262,7 @@ public:
setSupportedToolchainType(Constants::QNX_TOOLCHAIN_ID);
setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID});
setToolchainConstructor([] { return new QnxToolChain; });
setToolchainConstructor([] { return new QnxToolchain; });
setUserCreatable(true);
}

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

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

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

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