ProjectExplorer: Make ToolchainManager::toolchains() overloads explicit

Saves a few cycles for the plain access.

Also sprinkle a few 'const'.

Change-Id: I238dfd9352ee39caa3aa48cd04a9f1cf827b029e
Reviewed-by: <github-actions-qt-creator@cristianadam.eu>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/android/androidconfigurations.cpp

@@ -1192,7 +1192,7 @@ static bool matchToolChain(const ToolChain *atc, const ToolChain *btc)
 void AndroidConfigurations::registerNewToolChains()
 {
     const Toolchains existingAndroidToolChains
-            = ToolChainManager::toolChains(Utils::equal(&ToolChain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
+            = ToolChainManager::toolchains(Utils::equal(&ToolChain::typeId, Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
 
     const Toolchains newToolchains = AndroidToolChainFactory::autodetectToolChains(
         existingAndroidToolChains);
@@ -1205,7 +1205,7 @@ void AndroidConfigurations::registerNewToolChains()
 
 void AndroidConfigurations::removeOldToolChains()
 {
-    const auto tcs = ToolChainManager::toolChains(Utils::equal(&ToolChain::typeId,
+    const auto tcs = ToolChainManager::toolchains(Utils::equal(&ToolChain::typeId,
                                                                Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
     for (ToolChain *tc : tcs) {
         if (!tc->isValid())
@@ -1352,7 +1352,7 @@ static QVariant findOrRegisterDebugger(ToolChain *tc,
 
 void AndroidConfigurations::registerCustomToolChainsAndDebuggers()
 {
-    const Toolchains existingAndroidToolChains = ToolChainManager::toolChains(
+    const Toolchains existingAndroidToolChains = ToolChainManager::toolchains(
         Utils::equal(&ToolChain::typeId, Utils::Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
 
     const FilePaths customNdks = Utils::transform(currentConfig().getCustomNdkList(),
@@ -1406,7 +1406,7 @@ void AndroidConfigurations::updateAutomaticKitList()
     }
 
     // register new kits
-    const Toolchains toolchains = ToolChainManager::toolChains([](const ToolChain *tc) {
+    const Toolchains toolchains = ToolChainManager::toolchains([](const ToolChain *tc) {
         return tc->isAutoDetected()
             && tc->isValid()
             && tc->typeId() == Constants::ANDROID_TOOLCHAIN_TYPEID;

src/plugins/docker/dockerdevice.cpp

@@ -628,7 +628,7 @@ void KitDetectorPrivate::undoAutoDetect() const
     };
 
     emit q->logOutput('\n' + tr("Removing toolchain entries..."));
-    for (ToolChain *toolChain : ToolChainManager::toolChains()) {
+    for (ToolChain *toolChain : ToolChainManager::toolchains()) {
         QString detectionSource = toolChain->detectionSource();
         if (toolChain->detectionSource() == m_sharedId) {
             emit q->logOutput(tr("Removed \"%1\"").arg(toolChain->displayName()));
@@ -676,10 +676,9 @@ void KitDetectorPrivate::listAutoDetected() const
     };
 
     emit q->logOutput('\n' + 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());
-        }
     };
 
     if (QObject *cmakeManager = ExtensionSystem::PluginManager::getObjectByName("CMakeToolManager")) {
@@ -733,7 +732,7 @@ Toolchains KitDetectorPrivate::autoDetectToolChains()
 {
     const QList<ToolChainFactory *> factories = ToolChainFactory::allToolChainFactories();
 
-    Toolchains alreadyKnown = ToolChainManager::toolChains();
+    Toolchains alreadyKnown = ToolChainManager::toolchains();
     Toolchains allNewToolChains;
     QApplication::processEvents();
     emit q->logOutput('\n' + tr("Searching toolchains..."));

src/plugins/ios/iosconfigurations.cpp

@@ -114,10 +114,10 @@ static bool isSimulatorDeviceId(const Utils::Id &id)
     return id == Constants::IOS_SIMULATOR_TYPE;
 }
 
-static QList<ClangToolChain *> clangToolChains(const QList<ToolChain *> &toolChains)
+static QList<ClangToolChain *> clangToolChains(const Toolchains &toolChains)
 {
     QList<ClangToolChain *> clangToolChains;
-    foreach (ToolChain *toolChain, toolChains)
+    for (ToolChain *toolChain : toolChains)
         if (toolChain->typeId() == ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID)
             clangToolChains.append(static_cast<ClangToolChain *>(toolChain));
     return clangToolChains;
@@ -125,7 +125,7 @@ static QList<ClangToolChain *> clangToolChains(const QList<ToolChain *> &toolCha
 
 static QList<ClangToolChain *> autoDetectedIosToolChains()
 {
-    const QList<ClangToolChain *> toolChains = clangToolChains(ToolChainManager::toolChains());
+    const QList<ClangToolChain *> toolChains = clangToolChains(ToolChainManager::toolchains());
     return Utils::filtered(toolChains, [](ClangToolChain *toolChain) {
         return toolChain->isAutoDetected()
                && (toolChain->displayName().startsWith("iphone")

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -1362,9 +1362,9 @@ void GccToolChainConfigWidget::handlePlatformLinkerFlagsChange()
 // ClangToolChain
 // --------------------------------------------------------------------------
 
-static QList<ToolChain *> mingwToolChains()
+static const Toolchains mingwToolChains()
 {
-    return ToolChainManager::toolChains([](const ToolChain *tc) -> bool {
+    return ToolChainManager::toolchains([](const ToolChain *tc) -> bool {
         return tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID;
     });
 }

src/plugins/projectexplorer/kitinformation.cpp

@@ -270,8 +270,8 @@ private:
     {
         m_ignoreChanges = true;
         foreach (Utils::Id l, m_languageComboboxMap.keys()) {
-            const QList<ToolChain *> ltcList
+            const Toolchains ltcList
-                    = ToolChainManager::toolChains(Utils::equal(&ToolChain::language, l));
+                    = ToolChainManager::toolchains(Utils::equal(&ToolChain::language, l));
 
             QComboBox *cb = m_languageComboboxMap.value(l);
             cb->clear();
@@ -346,7 +346,7 @@ static QMap<Utils::Id, QByteArray> defaultToolChainIds()
 {
     QMap<Utils::Id, QByteArray> toolChains;
     const Abi abi = Abi::hostAbi();
-    QList<ToolChain *> tcList = ToolChainManager::toolChains(Utils::equal(&ToolChain::targetAbi, abi));
+    const Toolchains tcList = ToolChainManager::toolchains(Utils::equal(&ToolChain::targetAbi, abi));
     foreach (Utils::Id l, ToolChainManager::allLanguages()) {
         ToolChain *tc = Utils::findOrDefault(tcList, Utils::equal(&ToolChain::language, l));
         toolChains.insert(l, tc ? tc->id() : QByteArray());
@@ -498,7 +498,7 @@ void ToolChainKitAspect::setup(Kit *k)
         // ID is not found: Might be an ABI string...
         lockToolchains = false;
         const QString abi = QString::fromUtf8(id);
-        QList<ToolChain *> possibleTcs = ToolChainManager::toolChains(
+        const Toolchains possibleTcs = ToolChainManager::toolchains(
             [abi, l](const ToolChain *t) {
                 return t->targetAbi().toString() == abi && t->language() == l;
             });
@@ -655,7 +655,7 @@ void ToolChainKitAspect::setAllToolChainsToMatch(Kit *k, ToolChain *tc)
     QTC_ASSERT(tc, return);
     QTC_ASSERT(k, return);
 
-    const QList<ToolChain *> allTcList = ToolChainManager::toolChains();
+    const Toolchains allTcList = ToolChainManager::toolchains();
     QTC_ASSERT(allTcList.contains(tc), return);
 
     QVariantMap result = k->value(ToolChainKitAspect::id()).toMap();

src/plugins/projectexplorer/kitmanager.cpp

@@ -283,7 +283,7 @@ void KitManager::restoreKits()
         // TODO: This should not need to be done here. Instead, it should be a convenience
         // operation on some lower level, e.g. in the toolchain class(es).
         // Also, we shouldn't detect so many doublets in the first place.
-        for (ToolChain * const tc : ToolChainManager::toolChains()) {
+        for (ToolChain * const tc : ToolChainManager::toolchains()) {
             ToolChain *&bestTc = uniqueToolchains[tc->targetAbi()][tc->language()];
             if (!bestTc) {
                 bestTc = tc;

src/plugins/projectexplorer/projectimporter.cpp

@@ -411,7 +411,7 @@ ProjectImporter::ToolChainData
 ProjectImporter::findOrCreateToolChains(const ToolChainDescription &tcd) const
 {
     ToolChainData result;
-    result.tcs = ToolChainManager::toolChains([&tcd](const ToolChain *tc) {
+    result.tcs = ToolChainManager::toolchains([&tcd](const ToolChain *tc) {
         return tc->language() == tcd.language &&
                Utils::Environment::systemEnvironment().isSameExecutable(
                     tc->compilerCommand().toString(), tcd.compilerPath.toString());

src/plugins/projectexplorer/toolchainmanager.cpp

@@ -141,13 +141,17 @@ void ToolChainManager::saveToolChains()
                            ToolchainDetectionSettings().detectX64AsX32);
 }
 
-Toolchains ToolChainManager::toolChains(const ToolChain::Predicate &predicate)
+const Toolchains &ToolChainManager::toolchains()
 {
-    if (predicate)
-        return Utils::filtered(d->m_toolChains, predicate);
     return d->m_toolChains;
 }
 
+Toolchains ToolChainManager::toolchains(const ToolChain::Predicate &predicate)
+{
+    QTC_ASSERT(predicate, return {});
+    return Utils::filtered(d->m_toolChains, predicate);
+}
+
 ToolChain *ToolChainManager::toolChain(const ToolChain::Predicate &predicate)
 {
     return Utils::findOrDefault(d->m_toolChains, predicate);

src/plugins/projectexplorer/toolchainmanager.h

@@ -61,7 +61,9 @@ public:
     static ToolChainManager *instance();
     ~ToolChainManager() override;
 
-    static QList<ToolChain *> toolChains(const ToolChain::Predicate &predicate = ToolChain::Predicate());
+    static const Toolchains &toolchains();
+    static Toolchains toolchains(const ToolChain::Predicate &predicate);
+
     static ToolChain *toolChain(const ToolChain::Predicate &predicate);
     static QList<ToolChain *> findToolChains(const Abi &abi);
     static ToolChain *findToolChain(const QByteArray &id);

src/plugins/projectexplorer/toolchainoptionspage.cpp

@@ -249,7 +249,7 @@ public:
         m_widgetStack = new QStackedWidget;
         m_container->setWidget(m_widgetStack);
 
-        foreach (ToolChain *tc, ToolChainManager::toolChains())
+        for (ToolChain *tc : ToolChainManager::toolchains())
             insertToolChain(tc);
 
         auto buttonLayout = new QVBoxLayout;

src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp

@@ -241,11 +241,11 @@ void QmakeProjectImporter::deleteDirectoryData(void *directoryData) const
     delete static_cast<DirectoryData *>(directoryData);
 }
 
-static const QList<ToolChain *> preferredToolChains(BaseQtVersion *qtVersion, const QString &ms)
+static const Toolchains preferredToolChains(BaseQtVersion *qtVersion, const QString &ms)
 {
     const QString spec = ms.isEmpty() ? qtVersion->mkspec() : ms;
 
-    const QList<ToolChain *> toolchains = ToolChainManager::toolChains();
+    const Toolchains toolchains = ToolChainManager::toolchains();
     const Abis qtAbis = qtVersion->qtAbis();
     const auto matcher = [&](const ToolChain *tc) {
         return qtAbis.contains(tc->targetAbi()) && tc->suggestedMkspecList().contains(spec);
@@ -256,7 +256,7 @@ static const QList<ToolChain *> preferredToolChains(BaseQtVersion *qtVersion, co
     ToolChain * const cToolchain = findOrDefault(toolchains, [matcher](const ToolChain *tc) {
         return tc->language() == ProjectExplorer::Constants::C_LANGUAGE_ID && matcher(tc);
     });
-    QList<ToolChain *> chosenToolchains;
+    Toolchains chosenToolchains;
     for (ToolChain * const tc : {cxxToolchain, cToolchain}) {
         if (tc)
             chosenToolchains << tc;

src/plugins/qnx/qnxconfiguration.cpp

@@ -170,10 +170,10 @@ void QnxConfiguration::deactivate()
     if (!isActive())
         return;
 
-    QList<DebuggerItem> debuggersToRemove;
+    const Toolchains toolChainsToRemove =
-    const QList<ToolChain *> toolChainsToRemove
+        ToolChainManager::toolchains(Utils::equal(&ToolChain::compilerCommand, qccCompilerPath()));
-            = ToolChainManager::toolChains(Utils::equal(&ToolChain::compilerCommand, qccCompilerPath()));
 
+    QList<DebuggerItem> debuggersToRemove;
     foreach (DebuggerItem debuggerItem,
              DebuggerItemManager::debuggers()) {
         if (findTargetByDebuggerPath(debuggerItem.command()))
@@ -187,7 +187,7 @@ void QnxConfiguration::deactivate()
             KitManager::deregisterKit(kit);
     }
 
-    foreach (ToolChain *tc, toolChainsToRemove)
+    for (ToolChain *tc : toolChainsToRemove)
         ToolChainManager::deregisterToolChain(tc);
 
     foreach (DebuggerItem debuggerItem, debuggersToRemove)

src/plugins/qtsupport/baseqtversion.cpp

@@ -1847,9 +1847,10 @@ bool BaseQtVersionPrivate::queryQMakeVariables(const FilePath &binary, const Env
         // Try running qmake with all kinds of tool chains set up in the environment.
         // This is required to make non-static qmakes work on windows where every tool chain
         // tries to be incompatible with any other.
-        Abis abiList = Abi::abisOfBinary(binary);
+        const Abis abiList = Abi::abisOfBinary(binary);
-        const QList<ToolChain *> tcList
+        const Toolchains tcList = ToolChainManager::toolchains([&abiList](const ToolChain *t) {
-                = ToolChainManager::toolChains([&abiList](const ToolChain *t) { return abiList.contains(t->targetAbi()); });
+            return abiList.contains(t->targetAbi());
+        });
         for (ToolChain *tc : tcList) {
             Environment realEnv = env;
             tc->addToEnvironment(realEnv);

src/plugins/qtsupport/qtkitinformation.cpp

@@ -219,7 +219,7 @@ void QtKitAspect::fix(Kit *k)
         return;
 
     const QString spec = version->mkspec();
-    QList<ToolChain *> possibleTcs = ToolChainManager::toolChains([version](const ToolChain *t) {
+    Toolchains possibleTcs = ToolChainManager::toolchains([version](const ToolChain *t) {
         if (!t->isValid() || t->language() != ProjectExplorer::Constants::CXX_LANGUAGE_ID)
             return false;
         return Utils::anyOf(version->qtAbis(), [t](const Abi &qtAbi) {
@@ -243,8 +243,7 @@ void QtKitAspect::fix(Kit *k)
             return tc1->priority() > tc2->priority();
         });
 
-        const QList<ToolChain *> goodTcs = Utils::filtered(possibleTcs,
+        const Toolchains goodTcs = Utils::filtered(possibleTcs, [&spec](const ToolChain *t) {
-                                                           [&spec](const ToolChain *t) {
             return t->suggestedMkspecList().contains(spec);
         });
         // Hack to prefer a tool chain from PATH (e.g. autodetected) over other matches.