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

ProjectExplorer: Let toolchains be (de)registered in bulk

Browse Source 
When some code adds or removes a bunch of toolchains at once, that
should be made explicit and also be reflected by the respective signal
emissions.
Fix some leaks and typos along the way.

Change-Id: I4a1f12a2378316c5faf70e85a88adc467f076caf
Reviewed-by: hjk <hjk@qt.io>
This commit is contained in:
Christian Kandeler
2024-07-18 11:10:24 +02:00
parent eb6c95b50d
commit 9d0c144892
13 changed files with 198 additions and 169 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -1248,23 +1248,17 @@ void AndroidConfigurations::registerNewToolchains()
{
const Toolchains existingAndroidToolchains
= ToolchainManager::toolchains(Utils::equal(&Toolchain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
const Toolchains newToolchains = autodetectToolchains(existingAndroidToolchains);
for (Toolchain *tc : newToolchains)
ToolchainManager::registerToolchain(tc);
ToolchainManager::registerToolchains(autodetectToolchains(existingAndroidToolchains));
registerCustomToolchainsAndDebuggers();
}
void AndroidConfigurations::removeOldToolchains()
{
const auto tcs = ToolchainManager::toolchains(Utils::equal(&Toolchain::typeId,
Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
for (Toolchain *tc : tcs) {
if (!tc->isValid())
ToolchainManager::deregisterToolchain(tc);
}
const auto tcs = Utils::filtered(
ToolchainManager::toolchains(
Utils::equal(&Toolchain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID))),
&Toolchain::isValid);
ToolchainManager::deregisterToolchains(tcs);
}
void AndroidConfigurations::removeUnusedDebuggers()
@@ -1411,8 +1405,8 @@ void AndroidConfigurations::registerCustomToolchainsAndDebuggers()
const Toolchains customToolchains
= autodetectToolchainsFromNdks(existingAndroidToolchains, customNdks, true);
ToolchainManager::registerToolchains(customToolchains);
for (Toolchain *tc : customToolchains) {
ToolchainManager::registerToolchain(tc);
const auto androidToolchain = static_cast<AndroidToolchain *>(tc);
QString abiStr;
if (androidToolchain)

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

@@ -106,13 +106,11 @@ 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) {
const Toolchains toDeregister = Utils::filtered(
ToolchainManager::toolchains(), Utils::equal(&Toolchain::detectionSource, m_sharedId));
for (Toolchain * toolchain : toDeregister)
emit q->logOutput(ProjectExplorer::Tr::tr("Removed \"%1\"").arg(toolchain->displayName()));
ToolchainManager::deregisterToolchain(toolchain);
}
};
ToolchainManager::deregisterToolchains(toDeregister);
if (auto cmakeManager = ExtensionSystem::PluginManager::getObjectByName("CMakeToolManager")) {
QString logMessage;
@@ -260,11 +258,12 @@ Toolchains KitDetectorPrivate::autoDetectToolchains()
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()));
emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"")
.arg(toolchain->compilerCommand().toUserOutput()));
toolchain->setDetectionSource(m_sharedId);
ToolchainManager::registerToolchain(toolchain);
alreadyKnown.append(toolchain);
}
ToolchainManager::registerToolchains(newToolchains);
alreadyKnown.append(newToolchains);
allNewToolchains.append(newToolchains);
}
emit q->logOutput(ProjectExplorer::Tr::tr("%1 new toolchains found.").arg(allNewToolchains.size()));

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

@@ -441,52 +441,56 @@ static Toolchain *mingwToolchain(const FilePath &path, Id language)
return toolChain;
}
// FIXME: Do not register languages separately.
static Toolchain *armGccToolchain(const FilePath &path, Id language)
{
Toolchain *toolChain = ToolchainManager::toolchain([&path, language](const Toolchain *t) {
Toolchain *toolchain = ToolchainManager::toolchain([&path, language](const Toolchain *t) {
return t->compilerCommand() == path && t->language() == language;
});
if (!toolChain) {
if (!toolchain) {
if (ToolchainFactory * const gccFactory = ToolchainFactory::factoryForType(
ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID)) {
const QList<Toolchain *> detected = gccFactory->detectForImport({path, language});
QList<Toolchain *> detected = gccFactory->detectForImport({path, language});
if (!detected.isEmpty()) {
toolChain = detected.first();
toolChain->setDetection(Toolchain::ManualDetection);
toolChain->setDisplayName("Arm GCC");
ToolchainManager::registerToolchain(toolChain);
toolchain = detected.takeFirst();
ToolchainManager::registerToolchains({toolchain});
toolchain->setDetection(Toolchain::ManualDetection);
toolchain->setDisplayName("Arm GCC");
qDeleteAll(detected);
}
}
}
return toolChain;
return toolchain;
}
static Toolchain *iarToolchain(const FilePath &path, Id language)
{
Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
Toolchain *toolchain = ToolchainManager::toolchain([language](const Toolchain *t) {
return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID
&& t->language() == language;
});
if (!toolChain) {
if (!toolchain) {
if (ToolchainFactory * const iarFactory = ToolchainFactory::factoryForType(
BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID)) {
Toolchains detected = iarFactory->autoDetect(
{{}, DeviceManager::defaultDesktopDevice(), {}});
if (detected.isEmpty())
detected = iarFactory->detectForImport({path, language});
for (auto tc : detected) {
if (tc->language() == language) {
toolChain = tc;
toolChain->setDetection(Toolchain::ManualDetection);
toolChain->setDisplayName("IAREW");
ToolchainManager::registerToolchain(toolChain);
}
Toolchains toRegister;
Toolchains toDelete;
std::tie(toRegister, toDelete)
= Utils::partition(detected, Utils::equal(&Toolchain::language, language));
for (Toolchain * const tc : toRegister) {
tc->setDetection(Toolchain::ManualDetection);
tc->setDisplayName("IAREW");
}
ToolchainManager::registerToolchains(toRegister);
qDeleteAll(toDelete);
}
}
return toolChain;
return toolchain;
}
Toolchain *McuToolchainPackage::toolChain(Id language) const

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

@@ -217,7 +217,7 @@ void verifyIarToolchain(const McuToolchainPackagePtr &iarToolchainPackage)
Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID};
Toolchain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolchain(iarId)};
iarToolchain->setLanguage(cxxLanguageId);
ToolchainManager::registerToolchain(iarToolchain);
ToolchainManager::registerToolchains({iarToolchain});
QVERIFY(iarToolchainPackage != nullptr);
QCOMPARE(iarToolchainPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE);
@@ -241,7 +241,7 @@ void verifyArmGccToolchain(const McuToolchainPackagePtr &armGccPackage, const QS
Toolchain *armToolchain{ProjectExplorer::ToolchainFactory::createToolchain(armGccId)};
armToolchain->setLanguage(cxxLanguageId);
ToolchainManager::registerToolchain(armToolchain);
ToolchainManager::registerToolchains({armToolchain});
QVERIFY(armGccPackage != nullptr);
QCOMPARE(armGccPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE);

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

@@ -1769,18 +1769,28 @@ GccToolchainConfigWidget::GccToolchainConfigWidget(GccToolchain *tc) :
updateParentToolchainComboBox();
}));
m_parentToolchainConnections.append(
connect(tcManager, &ToolchainManager::toolhainAdded, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
connect(tcManager, &ToolchainManager::toolchainsRegistered,
this, [this](const Toolchains &toolchains) {
if (Utils::contains(
toolchains,
Utils::equal(&Toolchain::typeId, Id(Constants::MINGW_TOOLCHAIN_TYPEID)))) {
updateParentToolchainComboBox();
}
}));
m_parentToolchainConnections.append(
connect(tcManager, &ToolchainManager::toolchainRemoved, this, [this](Toolchain *tc) {
connect(tcManager, &ToolchainManager::toolchainsDeregistered, this,
[this](const Toolchains &toolchains) {
bool updateParentComboBox = false;
for (Toolchain * const tc : toolchains) {
if (tc->id() == toolchain()->id()) {
for (QMetaObject::Connection &connection : m_parentToolchainConnections)
QObject::disconnect(connection);
return;
}
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
updateParentComboBox = true;
}
}
if (updateParentComboBox)
updateParentToolchainComboBox();
}));
@@ -1980,20 +1990,33 @@ void GccToolchain::syncAutodetectedWithParentToolchains()
// Subscribe only autodetected toolchains.
ToolchainManager *tcManager = ToolchainManager::instance();
m_mingwToolchainAddedConnection
= connect(tcManager, &ToolchainManager::toolhainAdded, this, [this](Toolchain *tc) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID
&& !mingwToolchainFromId(m_parentToolchainId)) {
= connect(tcManager, &ToolchainManager::toolchainsRegistered, this,
[this](const Toolchains &toolchains) {
if (mingwToolchainFromId(m_parentToolchainId))
return;
for (Toolchain * const tc : toolchains) {
if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID) {
m_parentToolchainId = tc->id();
break;
}
}
});
m_thisToolchainRemovedConnection
= connect(tcManager, &ToolchainManager::toolchainRemoved, this, [this](Toolchain *tc) {
= connect(tcManager, &ToolchainManager::toolchainsDeregistered, this,
[this](const Toolchains &toolchains) {
bool updateParentId = false;
for (Toolchain * const tc : toolchains) {
if (tc == this) {
QObject::disconnect(m_thisToolchainRemovedConnection);
QObject::disconnect(m_mingwToolchainAddedConnection);
} else if (m_parentToolchainId == tc->id()) {
updateParentId = true;
}
}
if (updateParentId) {
const Toolchains mingwTCs = mingwToolchains();
m_parentToolchainId = mingwTCs.isEmpty() ? QByteArray() : mingwTCs.front()->id();
m_parentToolchainId = mingwTCs.isEmpty() ? QByteArray()
: mingwTCs.front()->id();
}
});
}

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

@@ -343,7 +343,7 @@ private:
void onKitsLoaded() override;
void toolChainUpdated(Toolchain *tc);
void toolChainRemoved(Toolchain *tc);
void toolChainsDeregistered();
};
ToolchainKitAspectFactory::ToolchainKitAspectFactory()
@@ -695,8 +695,8 @@ void ToolchainKitAspectFactory::onKitsLoaded()
for (Kit *k : KitManager::kits())
fix(k);
connect(ToolchainManager::instance(), &ToolchainManager::toolchainRemoved,
this, &ToolchainKitAspectFactory::toolChainRemoved);
connect(ToolchainManager::instance(), &ToolchainManager::toolchainsDeregistered,
this, &ToolchainKitAspectFactory::toolChainsDeregistered);
connect(ToolchainManager::instance(), &ToolchainManager::toolchainUpdated,
this, &ToolchainKitAspectFactory::toolChainUpdated);
}
@@ -709,9 +709,8 @@ void ToolchainKitAspectFactory::toolChainUpdated(Toolchain *tc)
}
}
void ToolchainKitAspectFactory::toolChainRemoved(Toolchain *tc)
void ToolchainKitAspectFactory::toolChainsDeregistered()
{
Q_UNUSED(tc)
for (Kit *k : KitManager::kits())
fix(k);
}

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

@@ -318,23 +318,21 @@ static Toolchain *toolChainFromVariant(const QVariant &v)
void ProjectImporter::cleanupTemporaryToolchains(Kit *k, const QVariantList &vl)
{
for (const QVariant &v : vl) {
Toolchain *tc = toolChainFromVariant(v);
QTC_ASSERT(tc, continue);
ToolchainManager::deregisterToolchain(tc);
ToolchainManager::deregisterToolchains(Utils::transform(vl, toolChainFromVariant));
ToolchainKitAspect::setToolchain(k, nullptr);
}
}
void ProjectImporter::persistTemporaryToolchains(Kit *k, const QVariantList &vl)
{
Toolchains toDeregister;
for (const QVariant &v : vl) {
Toolchain *tmpTc = toolChainFromVariant(v);
QTC_ASSERT(tmpTc, continue);
Toolchain *actualTc = ToolchainKitAspect::toolchain(k, tmpTc->language());
if (tmpTc && actualTc != tmpTc)
ToolchainManager::deregisterToolchain(tmpTc);
toDeregister << tmpTc;
}
ToolchainManager::deregisterToolchains(toDeregister);
}
void ProjectImporter::useTemporaryKitAspect(Utils::Id id,
@@ -374,10 +372,7 @@ static ProjectImporter::ToolchainData createToolChains(const ToolchainDescriptio
data.tcs = factory->detectForImport(tcd);
if (data.tcs.isEmpty())
continue;
for (Toolchain *tc : std::as_const(data.tcs))
ToolchainManager::registerToolchain(tc);
ToolchainManager::registerToolchains(data.tcs);
data.areTemporary = true;
break;
}

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

@@ -787,14 +787,16 @@ void AsyncToolchainDetector::run()
[watcher,
alreadyRegistered = m_alreadyRegistered]() {
Toolchains existingTcs = ToolchainManager::toolchains();
Toolchains toRegister;
for (Toolchain *tc : watcher->result()) {
if (tc->isValid() && !alreadyRegistered(tc, existingTcs)) {
ToolchainManager::registerToolchain(tc);
toRegister << tc;
existingTcs << tc;
} else {
delete tc;
}
}
ToolchainManager::registerToolchains(toRegister);
watcher->deleteLater();
});
watcher->setFuture(Utils::asyncRun(m_func, m_detector));

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

@@ -78,8 +78,9 @@ ToolchainManager::ToolchainManager(QObject *parent) :
connect(Core::ICore::instance(), &Core::ICore::saveSettingsRequested,
this, &ToolchainManager::saveToolchains);
connect(this, &ToolchainManager::toolhainAdded, this, &ToolchainManager::toolchainsChanged);
connect(this, &ToolchainManager::toolchainRemoved, this, &ToolchainManager::toolchainsChanged);
connect(this, &ToolchainManager::toolchainsRegistered,
this, &ToolchainManager::toolchainsChanged);
connect(this, &ToolchainManager::toolchainsDeregistered, this, &ToolchainManager::toolchainsChanged);
connect(this, &ToolchainManager::toolchainUpdated, this, &ToolchainManager::toolchainsChanged);
QtcSettings * const s = Core::ICore::settings();
@@ -106,8 +107,7 @@ void ToolchainManager::restoreToolchains()
QTC_ASSERT(!d->m_accessor, return);
d->m_accessor = std::make_unique<Internal::ToolchainSettingsAccessor>();
for (Toolchain *tc : d->m_accessor->restoreToolchains(Core::ICore::dialogParent()))
registerToolchain(tc);
registerToolchains(d->m_accessor->restoreToolchains(Core::ICore::dialogParent()));
d->m_loaded = true;
emit m_instance->toolchainsLoaded();
@@ -191,37 +191,54 @@ void ToolchainManager::notifyAboutUpdate(Toolchain *tc)
emit m_instance->toolchainUpdated(tc);
}
bool ToolchainManager::registerToolchain(Toolchain *tc)
Toolchains ToolchainManager::registerToolchains(const Toolchains &toolchains)
{
QTC_ASSERT(tc, return false);
Toolchains registered;
Toolchains notRegistered;
for (Toolchain * const tc : toolchains) {
QTC_ASSERT(tc, notRegistered << tc; continue);
QTC_ASSERT(isLanguageSupported(tc->language()),
qDebug() << qPrintable("language \"" + tc->language().toString()
+ "\" unknown while registering \""
+ tc->compilerCommand().toString() + "\"");
return false);
QTC_ASSERT(d->m_accessor, return false);
if (d->m_toolChains.contains(tc))
return true;
for (const Toolchain *current : std::as_const(d->m_toolChains)) {
if (*tc == *current && !tc->isAutoDetected())
return false;
QTC_ASSERT(current->id() != tc->id(), return false);
notRegistered << tc;
continue);
QTC_ASSERT(d->m_accessor, notRegistered << tc; continue);
QTC_ASSERT(!d->m_toolChains.contains(tc), continue);
QTC_ASSERT(!Utils::contains(d->m_toolChains, Utils::equal(&Toolchain::id, tc->id())),
notRegistered << tc;
continue);
if (!tc->isAutoDetected()
&& Utils::contains(d->m_toolChains, [tc](const Toolchain *existing) {
return *tc == *existing;
})) {
notRegistered << tc;
continue;
}
d->m_toolChains << tc;
registered << tc;
}
d->m_toolChains.append(tc);
emit m_instance->toolhainAdded(tc);
return true;
if (!registered.isEmpty())
emit m_instance->toolchainsRegistered(registered);
return notRegistered;
}
void ToolchainManager::deregisterToolchain(Toolchain *tc)
void ToolchainManager::deregisterToolchains(const Toolchains &toolchains)
{
QTC_CHECK(d->m_loaded);
if (!tc || !d->m_toolChains.contains(tc))
return;
d->m_toolChains.removeOne(tc);
emit m_instance->toolchainRemoved(tc);
delete tc;
Toolchains deregistered;
for (Toolchain * const tc : toolchains) {
QTC_ASSERT(tc, continue);
const bool removed = d->m_toolChains.removeOne(tc);
QTC_ASSERT(removed, continue);
deregistered << tc;
}
if (!deregistered.isEmpty())
emit m_instance->toolchainsDeregistered(deregistered);
qDeleteAll(toolchains);
}
QList<Id> ToolchainManager::allLanguages()

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

@@ -48,8 +48,8 @@ public:
static bool isLoaded();
static bool registerToolchain(Toolchain *tc);
static void deregisterToolchain(Toolchain *tc);
static Toolchains registerToolchains(const Toolchains &toolchains);
static void deregisterToolchains(const Toolchains &toolchains);
static QList<Utils::Id> allLanguages();
static bool registerLanguage(const Utils::Id &language, const QString &displayName);
@@ -68,9 +68,9 @@ public:
void saveToolchains();
signals:
void toolhainAdded(ProjectExplorer::Toolchain *);
// Toolchain is still valid when this call happens!
void toolchainRemoved(ProjectExplorer::Toolchain *);
void toolchainsRegistered(const Toolchains &registered);
// Toolchains are still valid when this call happens!
void toolchainsDeregistered(const Toolchains &deregistered);
// Toolchain was updated.
void toolchainUpdated(ProjectExplorer::Toolchain *);
// Something changed.

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

@@ -275,10 +275,10 @@ public:
horizontalLayout->addLayout(verticalLayout);
horizontalLayout->addLayout(buttonLayout);
connect(ToolchainManager::instance(), &ToolchainManager::toolhainAdded,
this, &ToolChainOptionsWidget::addToolChain);
connect(ToolchainManager::instance(), &ToolchainManager::toolchainRemoved,
this, &ToolChainOptionsWidget::removeToolChain);
connect(ToolchainManager::instance(), &ToolchainManager::toolchainsRegistered,
this, &ToolChainOptionsWidget::handleToolchainsRegistered);
connect(ToolchainManager::instance(), &ToolchainManager::toolchainsDeregistered,
this, &ToolChainOptionsWidget::handleToolchainsDeregistered);
connect(m_toolChainView->selectionModel(), &QItemSelectionModel::currentChanged,
this, &ToolChainOptionsWidget::toolChainSelectionChanged);
@@ -301,8 +301,8 @@ public:
void markForRemoval(ToolChainTreeItem *item);
ToolChainTreeItem *insertToolChain(ProjectExplorer::Toolchain *tc, bool changed = false); // Insert directly into model
void addToolChain(ProjectExplorer::Toolchain *);
void removeToolChain(ProjectExplorer::Toolchain *);
void handleToolchainsRegistered(const Toolchains &toolchains);
void handleToolchainsDeregistered(const Toolchains &toolchains);
StaticTreeItem *parentForToolChain(Toolchain *tc);
QAction *createAction(const QString &name, ToolchainFactory *factory, Utils::Id language)
@@ -361,26 +361,31 @@ ToolChainTreeItem *ToolChainOptionsWidget::insertToolChain(Toolchain *tc, bool c
return item;
}
void ToolChainOptionsWidget::addToolChain(Toolchain *tc)
void ToolChainOptionsWidget::handleToolchainsRegistered(const Toolchains &toolchains)
{
for (Toolchain * const tc : toolchains) {
if (Utils::eraseOne(m_toAddList, [tc](const ToolChainTreeItem *item) {
return item->toolChain == tc; })) {
// do not delete here!
return;
continue;
}
insertToolChain(tc);
}
updateState();
}
void ToolChainOptionsWidget::removeToolChain(Toolchain *tc)
void ToolChainOptionsWidget::handleToolchainsDeregistered(const Toolchains &toolchains)
{
if (auto it = std::find_if(m_toRemoveList.begin(), m_toRemoveList.end(),
for (Toolchain * const tc : toolchains) {
if (auto it = std::find_if(
m_toRemoveList.begin(),
m_toRemoveList.end(),
[tc](const ToolChainTreeItem *item) { return item->toolChain == tc; });
it != m_toRemoveList.end()) {
m_toRemoveList.erase(it);
delete *it;
return;
continue;
}
StaticTreeItem *parent = parentForToolChain(tc);
@@ -388,6 +393,7 @@ void ToolChainOptionsWidget::removeToolChain(Toolchain *tc)
return static_cast<ToolChainTreeItem *>(item)->toolChain == tc;
});
m_model.destroyItem(item);
}
updateState();
}
@@ -453,9 +459,8 @@ void ToolChainOptionsWidget::toolChainSelectionChanged()
void ToolChainOptionsWidget::apply()
{
// Remove unused tool chains:
QList<ToolChainTreeItem *> nodes = m_toRemoveList;
for (const ToolChainTreeItem *n : std::as_const(nodes))
ToolchainManager::deregisterToolchain(n->toolChain);
ToolchainManager::deregisterToolchains(
Utils::transform(m_toRemoveList, &ToolChainTreeItem::toolChain));
Q_ASSERT(m_toRemoveList.isEmpty());
@@ -474,13 +479,10 @@ void ToolChainOptionsWidget::apply()
}
// Add new (and already updated) tool chains
QStringList removedTcs;
nodes = m_toAddList;
for (const ToolChainTreeItem *n : std::as_const(nodes)) {
if (!ToolchainManager::registerToolchain(n->toolChain))
removedTcs << n->toolChain->displayName();
}
//
const Toolchains notRegistered = ToolchainManager::registerToolchains(
Utils::transform(m_toAddList, &ToolChainTreeItem::toolChain));
const QStringList removedTcs = Utils::transform(notRegistered, &Toolchain::displayName);
const QList<ToolChainTreeItem *> toAddList = m_toAddList;
for (ToolChainTreeItem *n : toAddList)
markForRemoval(n);

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

@@ -187,8 +187,7 @@ void QnxConfiguration::deactivate()
}
}
for (Toolchain *tc : toolChainsToRemove)
ToolchainManager::deregisterToolchain(tc);
ToolchainManager::deregisterToolchains(toolChainsToRemove);
for (const DebuggerItem &debuggerItem : std::as_const(debuggersToRemove))
DebuggerItemManager::deregisterDebugger(debuggerItem.id());
@@ -227,26 +226,25 @@ QVariant QnxConfiguration::createDebugger(const QnxTarget &target)
Toolchains QnxConfiguration::createToolChains(const QnxTarget &target)
{
Toolchains toolChains;
Toolchains toolchains;
for (const Id language : {ProjectExplorer::Constants::C_LANGUAGE_ID,
ProjectExplorer::Constants::CXX_LANGUAGE_ID}) {
auto toolChain = new QnxToolchain;
toolChain->setDetection(Toolchain::ManualDetection);
toolChain->setLanguage(language);
toolChain->setTargetAbi(target.m_abi);
toolChain->setDisplayName(Tr::tr("QCC for %1 (%2)")
auto toolchain = new QnxToolchain;
toolchain->setDetection(Toolchain::ManualDetection);
toolchain->setLanguage(language);
toolchain->setTargetAbi(target.m_abi);
toolchain->setDisplayName(Tr::tr("QCC for %1 (%2)")
.arg(m_configName)
.arg(target.shortDescription()));
toolChain->sdpPath.setValue(m_envFile.parentDir());
toolChain->cpuDir.setValue(target.cpuDir());
toolChain->resetToolchain(m_qccCompiler);
ToolchainManager::registerToolchain(toolChain);
toolChains.append(toolChain);
toolchain->sdpPath.setValue(m_envFile.parentDir());
toolchain->cpuDir.setValue(target.cpuDir());
toolchain->resetToolchain(m_qccCompiler);
toolchains.append(toolchain);
}
return toolChains;
ToolchainManager::registerToolchains(toolchains);
return toolchains;
}
void QnxConfiguration::createKit(const QnxTarget &target)

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

@@ -146,17 +146,13 @@ static Toolchains doAutoDetect(const ToolchainDetector &detector)
void registerToolChains()
{
// Remove old toolchains
for (Toolchain *tc : ToolchainManager::findToolchains(toolChainAbi())) {
if (tc->detection() != Toolchain::AutoDetection)
continue;
ToolchainManager::deregisterToolchain(tc);
};
const Toolchains oldToolchains = Utils::filtered(
ToolchainManager::findToolchains(toolChainAbi()),
Utils::equal(&Toolchain::detection, Toolchain::AutoDetection));
ToolchainManager::deregisterToolchains(oldToolchains);
// Create new toolchains and register them
ToolchainDetector detector({}, {}, {});
const Toolchains toolchains = doAutoDetect(detector);
for (auto toolChain : toolchains)
ToolchainManager::registerToolchain(toolChain);
ToolchainManager::registerToolchains(doAutoDetect(ToolchainDetector({}, {}, {})));
// Let kits pick up the new toolchains
for (Kit *kit : KitManager::kits()) {