ProjectExplorer: Rename ToolchainManager signals and members

Change-Id: I5195cb785f91dbaafdeeb8bb8c71939a6e3ff9e5
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/android/androidconfigurations.cpp

@@ -1153,7 +1153,7 @@ void AndroidConfigurations::registerNewToolChains()
         existingAndroidToolChains);
 
     for (Toolchain *tc : newToolchains)
-        ToolchainManager::registerToolChain(tc);
+        ToolchainManager::registerToolchain(tc);
 
     registerCustomToolChainsAndDebuggers();
 }
@@ -1164,7 +1164,7 @@ void AndroidConfigurations::removeOldToolChains()
                                                                Id(Constants::ANDROID_TOOLCHAIN_TYPEID)));
     for (Toolchain *tc : tcs) {
         if (!tc->isValid())
-            ToolchainManager::deregisterToolChain(tc);
+            ToolchainManager::deregisterToolchain(tc);
     }
 }
 
@@ -1315,7 +1315,7 @@ void AndroidConfigurations::registerCustomToolChainsAndDebuggers()
                                                                 customNdks,
                                                                 true);
     for (Toolchain *tc : customToolchains) {
-        ToolchainManager::registerToolChain(tc);
+        ToolchainManager::registerToolchain(tc);
         const auto androidToolChain = static_cast<AndroidToolChain *>(tc);
         QString abiStr;
         if (androidToolChain)

src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp

@@ -609,7 +609,7 @@ Toolchain *findExternalToolchain(const QString &presetArchitecture, const QStrin
         return tc->targetAbi().osFlavor();
     }));
 
-    return ToolchainManager::toolChain(
+    return ToolchainManager::toolchain(
         [presetArchitecture, presetToolset, msvcFlavors](const Toolchain *tc) -> bool {
             if (tc->typeId() != ProjectExplorer::Constants::MSVC_TOOLCHAIN_TYPEID)
                 return false;

src/plugins/compilationdatabaseprojectmanager/compilationdatabaseproject.cpp

@@ -77,7 +77,7 @@ Utils::Id getCompilerId(QString compilerName)
 
 Toolchain *toolchainFromCompilerId(const Utils::Id &compilerId, const Utils::Id &language)
 {
-    return ToolchainManager::toolChain([&compilerId, &language](const Toolchain *tc) {
+    return ToolchainManager::toolchain([&compilerId, &language](const Toolchain *tc) {
         if (!tc->isValid() || tc->language() != language)
             return false;
         return tc->typeId() == compilerId;
@@ -112,7 +112,7 @@ Toolchain *toolchainFromFlags(const Kit *kit, const QStringList &flags, const Ut
 
     // Try exact compiler match.
     const Utils::FilePath compiler = Utils::FilePath::fromUserInput(compilerPath(flags.front()));
-    Toolchain *toolchain = ToolchainManager::toolChain([&compiler, &language](const Toolchain *tc) {
+    Toolchain *toolchain = ToolchainManager::toolchain([&compiler, &language](const Toolchain *tc) {
         return tc->isValid() && tc->language() == language && tc->compilerCommand() == compiler;
     });
     if (toolchain)

src/plugins/compilationdatabaseprojectmanager/compilationdatabasetests.cpp

@@ -39,7 +39,7 @@ void CompilationDatabaseTests::initTestCase()
     if (allKits.empty())
         QSKIP("This test requires at least one kit to be present.");
 
-    Toolchain *toolchain = ToolchainManager::toolChain([](const Toolchain *tc) {
+    Toolchain *toolchain = ToolchainManager::toolchain([](const Toolchain *tc) {
         return tc->isValid() && tc->language() == ProjectExplorer::Constants::CXX_LANGUAGE_ID;
     });
     if (!toolchain)

src/plugins/docker/kitdetector.cpp

@@ -110,7 +110,7 @@ void KitDetectorPrivate::undoAutoDetect() const
     for (Toolchain *toolChain : toolchains) {
         if (toolChain && toolChain->detectionSource() == m_sharedId) {
             emit q->logOutput(ProjectExplorer::Tr::tr("Removed \"%1\"").arg(toolChain->displayName()));
-            ToolchainManager::deregisterToolChain(toolChain);
+            ToolchainManager::deregisterToolchain(toolChain);
         }
     };
 
@@ -262,7 +262,7 @@ Toolchains KitDetectorPrivate::autoDetectToolChains()
         for (Toolchain *toolChain : newToolChains) {
             emit q->logOutput(ProjectExplorer::Tr::tr("Found \"%1\"").arg(toolChain->compilerCommand().toUserOutput()));
             toolChain->setDetectionSource(m_sharedId);
-            ToolchainManager::registerToolChain(toolChain);
+            ToolchainManager::registerToolchain(toolChain);
             alreadyKnown.append(toolChain);
         }
         allNewToolChains.append(newToolChains);

src/plugins/mcusupport/mcupackage.cpp

@@ -366,7 +366,7 @@ bool McuToolChainPackage::isDesktopToolchain() const
 
 Toolchain *McuToolChainPackage::msvcToolChain(Id language)
 {
-    Toolchain *toolChain = ToolchainManager::toolChain([language](const Toolchain *t) {
+    Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
         const Abi abi = t->targetAbi();
         return abi.osFlavor() == Abi::WindowsMsvc2019Flavor
                && abi.architecture() == Abi::X86Architecture && abi.wordWidth() == 64
@@ -378,7 +378,7 @@ Toolchain *McuToolChainPackage::msvcToolChain(Id language)
 
 Toolchain *McuToolChainPackage::gccToolChain(Id language)
 {
-    Toolchain *toolChain = ToolchainManager::toolChain([language](const Toolchain *t) {
+    Toolchain *toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
         const Abi abi = t->targetAbi();
         return abi.os() != Abi::WindowsOS && abi.architecture() == Abi::X86Architecture
                && abi.wordWidth() == 64 && t->language() == language;
@@ -388,7 +388,7 @@ Toolchain *McuToolChainPackage::gccToolChain(Id language)
 
 static Toolchain *mingwToolChain(const FilePath &path, Id language)
 {
-    Toolchain *toolChain = ToolchainManager::toolChain([&path, language](const Toolchain *t) {
+    Toolchain *toolChain = ToolchainManager::toolchain([&path, language](const Toolchain *t) {
         // find a MinGW toolchain having the same path from registered toolchains
         const Abi abi = t->targetAbi();
         return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID
@@ -398,7 +398,7 @@ static Toolchain *mingwToolChain(const FilePath &path, Id language)
     if (!toolChain) {
         // if there's no MinGW toolchain having the same path,
         // a proper MinGW would be selected from the registered toolchains.
-        toolChain = ToolchainManager::toolChain([language](const Toolchain *t) {
+        toolChain = ToolchainManager::toolchain([language](const Toolchain *t) {
             const Abi abi = t->targetAbi();
             return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID
                    && abi.architecture() == Abi::X86Architecture && abi.wordWidth() == 64
@@ -410,7 +410,7 @@ static Toolchain *mingwToolChain(const FilePath &path, Id language)
 
 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) {
@@ -426,7 +426,7 @@ static Toolchain *armGccToolChain(const FilePath &path, Id language)
                 toolChain = detected.first();
                 toolChain->setDetection(Toolchain::ManualDetection);
                 toolChain->setDisplayName("Arm GCC");
-                ToolchainManager::registerToolChain(toolChain);
+                ToolchainManager::registerToolchain(toolChain);
             }
         }
     }
@@ -436,7 +436,7 @@ static Toolchain *armGccToolChain(const FilePath &path, Id language)
 
 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;
     });
@@ -457,7 +457,7 @@ static Toolchain *iarToolChain(const FilePath &path, Id language)
                     toolChain = tc;
                     toolChain->setDetection(Toolchain::ManualDetection);
                     toolChain->setDisplayName("IAREW");
-                    ToolchainManager::registerToolChain(toolChain);
+                    ToolchainManager::registerToolchain(toolChain);
                 }
             }
         }

src/plugins/mcusupport/mcusupportsdk.cpp

@@ -328,7 +328,7 @@ McuToolChainPackagePtr createIarToolChainPackage(const SettingsHandler::Ptr &set
     if (qtcEnvironmentVariableIsSet(envVar))
         defaultPath = FilePath::fromUserInput(qtcEnvironmentVariable(envVar));
     else {
-        const ProjectExplorer::Toolchain *tc = ProjectExplorer::ToolchainManager::toolChain(
+        const ProjectExplorer::Toolchain *tc = ProjectExplorer::ToolchainManager::toolchain(
             [](const ProjectExplorer::Toolchain *t) {
                 return t->typeId() == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID;
             });

src/plugins/mcusupport/test/unittest.cpp

@@ -216,7 +216,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::registerToolchain(iarToolchain);
 
     QVERIFY(iarToolchainPackage != nullptr);
     QCOMPARE(iarToolchainPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE);
@@ -240,7 +240,7 @@ void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QS
 
     Toolchain *armToolchain{ProjectExplorer::ToolchainFactory::createToolChain(armGccId)};
     armToolchain->setLanguage(cxxLanguageId);
-    ToolchainManager::registerToolChain(armToolchain);
+    ToolchainManager::registerToolchain(armToolchain);
 
     QVERIFY(armGccPackage != nullptr);
     QCOMPARE(armGccPackage->cmakeVariableName(), TOOLCHAIN_DIR_CMAKE_VARIABLE);

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -866,7 +866,7 @@ QStringList GccToolChain::suggestedMkspecList() const
     }
 
     if (m_subType == Clang) {
-        if (const Toolchain * const parentTc = ToolchainManager::findToolChain(m_parentToolChainId))
+        if (const Toolchain * const parentTc = ToolchainManager::findToolchain(m_parentToolChainId))
             return parentTc->suggestedMkspecList();
         const Abi abi = targetAbi();
         if (abi.os() == Abi::DarwinOS)
@@ -1759,17 +1759,17 @@ GccToolChainConfigWidget::GccToolChainConfigWidget(GccToolChain *tc) :
 
         ToolchainManager *tcManager = ToolchainManager::instance();
         m_parentToolChainConnections.append(
-            connect(tcManager, &ToolchainManager::toolChainUpdated, this, [this](Toolchain *tc) {
+            connect(tcManager, &ToolchainManager::toolchainUpdated, this, [this](Toolchain *tc) {
                 if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
                     updateParentToolChainComboBox();
             }));
         m_parentToolChainConnections.append(
-            connect(tcManager, &ToolchainManager::toolChainAdded, this, [this](Toolchain *tc) {
+            connect(tcManager, &ToolchainManager::toolhainAdded, this, [this](Toolchain *tc) {
                 if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID)
                     updateParentToolChainComboBox();
             }));
         m_parentToolChainConnections.append(
-            connect(tcManager, &ToolchainManager::toolChainRemoved, this, [this](Toolchain *tc) {
+            connect(tcManager, &ToolchainManager::toolchainRemoved, this, [this](Toolchain *tc) {
                 if (tc->id() == toolChain()->id()) {
                     for (QMetaObject::Connection &connection : m_parentToolChainConnections)
                         QObject::disconnect(connection);
@@ -1957,9 +1957,9 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
     QObject::disconnect(m_mingwToolchainAddedConnection);
 
     if (!ToolchainManager::isLoaded()) {
-        connect(ToolchainManager::instance(), &ToolchainManager::toolChainsLoaded, this,
+        connect(ToolchainManager::instance(), &ToolchainManager::toolchainsLoaded, this,
                 [id = id()] {
-            if (Toolchain * const tc = ToolchainManager::findToolChain(id)) {
+            if (Toolchain * const tc = ToolchainManager::findToolchain(id)) {
                 if (tc->typeId() == Constants::CLANG_TOOLCHAIN_TYPEID)
                     static_cast<GccToolChain *>(tc)->syncAutodetectedWithParentToolchains();
             }
@@ -1975,14 +1975,14 @@ void GccToolChain::syncAutodetectedWithParentToolchains()
     // Subscribe only autodetected toolchains.
     ToolchainManager *tcManager = ToolchainManager::instance();
     m_mingwToolchainAddedConnection
-        = connect(tcManager, &ToolchainManager::toolChainAdded, this, [this](Toolchain *tc) {
+        = connect(tcManager, &ToolchainManager::toolhainAdded, this, [this](Toolchain *tc) {
               if (tc->typeId() == Constants::MINGW_TOOLCHAIN_TYPEID
                   && !mingwToolChainFromId(m_parentToolChainId)) {
                   m_parentToolChainId = tc->id();
               }
           });
     m_thisToolchainRemovedConnection
-        = connect(tcManager, &ToolchainManager::toolChainRemoved, this, [this](Toolchain *tc) {
+        = connect(tcManager, &ToolchainManager::toolchainRemoved, this, [this](Toolchain *tc) {
               if (tc == this) {
                   QObject::disconnect(m_thisToolchainRemovedConnection);
                   QObject::disconnect(m_mingwToolchainAddedConnection);

src/plugins/projectexplorer/kitaspects.cpp

@@ -292,7 +292,7 @@ private:
             return;
 
         const QByteArray id = m_languageComboboxMap.value(language)->itemData(idx).toByteArray();
-        Toolchain *tc = ToolchainManager::findToolChain(id);
+        Toolchain *tc = ToolchainManager::findToolchain(id);
         QTC_ASSERT(!tc || tc->language() == language, return);
         if (tc)
             ToolchainKitAspect::setToolChain(m_kit, tc);
@@ -408,7 +408,7 @@ void ToolchainKitAspectFactory::fix(Kit *k)
     const QList<Id> languages = ToolchainManager::allLanguages();
     for (const Id l : languages) {
         const QByteArray tcId = ToolchainKitAspect::toolChainId(k, l);
-        if (!tcId.isEmpty() && !ToolchainManager::findToolChain(tcId)) {
+        if (!tcId.isEmpty() && !ToolchainManager::findToolchain(tcId)) {
             qWarning("Tool chain set up in kit \"%s\" for \"%s\" not found.",
                      qPrintable(k->displayName()),
                      qPrintable(ToolchainManager::displayNameOfLanguageId(l)));
@@ -443,7 +443,7 @@ void ToolchainKitAspectFactory::setup(Kit *k)
         }
 
         const QByteArray id = i.value().toByteArray();
-        Toolchain *tc = ToolchainManager::findToolChain(id);
+        Toolchain *tc = ToolchainManager::findToolchain(id);
         if (tc)
             continue;
 
@@ -557,17 +557,17 @@ QByteArray ToolchainKitAspect::toolChainId(const Kit *k, Id language)
 
 Toolchain *ToolchainKitAspect::toolChain(const Kit *k, Id language)
 {
-    return ToolchainManager::findToolChain(toolChainId(k, language));
+    return ToolchainManager::findToolchain(toolChainId(k, language));
 }
 
 Toolchain *ToolchainKitAspect::cToolChain(const Kit *k)
 {
-    return ToolchainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::C_LANGUAGE_ID));
+    return ToolchainManager::findToolchain(toolChainId(k, ProjectExplorer::Constants::C_LANGUAGE_ID));
 }
 
 Toolchain *ToolchainKitAspect::cxxToolChain(const Kit *k)
 {
-    return ToolchainManager::findToolChain(toolChainId(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID));
+    return ToolchainManager::findToolchain(toolChainId(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID));
 }
 
 
@@ -578,7 +578,7 @@ QList<Toolchain *> ToolchainKitAspect::toolChains(const Kit *k)
     const Store value = storeFromVariant(k->value(ToolchainKitAspect::id()));
     const QList<Toolchain *> tcList
             = transform<QList>(ToolchainManager::allLanguages(), [&value](Id l) {
-                return ToolchainManager::findToolChain(value.value(l.toKey()).toByteArray());
+                return ToolchainManager::findToolchain(value.value(l.toKey()).toByteArray());
             });
     return filtered(tcList, [](Toolchain *tc) { return tc; });
 }
@@ -695,9 +695,9 @@ void ToolchainKitAspectFactory::onKitsLoaded()
     for (Kit *k : KitManager::kits())
         fix(k);
 
-    connect(ToolchainManager::instance(), &ToolchainManager::toolChainRemoved,
+    connect(ToolchainManager::instance(), &ToolchainManager::toolchainRemoved,
             this, &ToolchainKitAspectFactory::toolChainRemoved);
-    connect(ToolchainManager::instance(), &ToolchainManager::toolChainUpdated,
+    connect(ToolchainManager::instance(), &ToolchainManager::toolchainUpdated,
             this, &ToolchainKitAspectFactory::toolChainUpdated);
 }
 

src/plugins/projectexplorer/project.cpp

@@ -1561,7 +1561,7 @@ void ProjectExplorerPlugin::testSourceToBinaryMapping()
     if (const auto msvcToolchain = dynamic_cast<Internal::MsvcToolChain *>(toolchain)) {
         while (!msvcToolchain->environmentInitialized()) {
             QSignalSpy parsingFinishedSpy(ToolchainManager::instance(),
-                                          &ToolchainManager::toolChainUpdated);
+                                          &ToolchainManager::toolchainUpdated);
             QVERIFY(parsingFinishedSpy.wait(10000));
         }
     }

src/plugins/projectexplorer/projectexplorer.cpp

@@ -2118,7 +2118,7 @@ bool ProjectExplorerPlugin::delayedInitialize()
 {
     NANOTRACE_SCOPE("ProjectExplorer", "ProjectExplorerPlugin::restoreKits");
     ExtraAbi::load(); // Load this before Toolchains!
-    ToolchainManager::restoreToolChains();
+    ToolchainManager::restoreToolchains();
     KitManager::restoreKits();
     return true;
 }

src/plugins/projectexplorer/projectimporter.cpp

@@ -313,7 +313,7 @@ bool ProjectImporter::findTemporaryHandler(Utils::Id id) const
 static Toolchain *toolChainFromVariant(const QVariant &v)
 {
     const QByteArray tcId = v.toByteArray();
-    return ToolchainManager::findToolChain(tcId);
+    return ToolchainManager::findToolchain(tcId);
 }
 
 void ProjectImporter::cleanupTemporaryToolChains(Kit *k, const QVariantList &vl)
@@ -321,7 +321,7 @@ 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::deregisterToolchain(tc);
         ToolchainKitAspect::setToolChain(k, nullptr);
     }
 }
@@ -333,7 +333,7 @@ void ProjectImporter::persistTemporaryToolChains(Kit *k, const QVariantList &vl)
         QTC_ASSERT(tmpTc, continue);
         Toolchain *actualTc = ToolchainKitAspect::toolChain(k, tmpTc->language());
         if (tmpTc && actualTc != tmpTc)
-            ToolchainManager::deregisterToolChain(tmpTc);
+            ToolchainManager::deregisterToolchain(tmpTc);
     }
 }
 
@@ -376,7 +376,7 @@ static ProjectImporter::ToolChainData createToolChains(const ToolChainDescriptio
             continue;
 
         for (Toolchain *tc : std::as_const(data.tcs))
-            ToolchainManager::registerToolChain(tc);
+            ToolchainManager::registerToolchain(tc);
 
         data.areTemporary = true;
         break;

src/plugins/projectexplorer/toolchainmanager.cpp

@@ -77,10 +77,10 @@ ToolchainManager::ToolchainManager(QObject *parent) :
     d = new ToolchainManagerPrivate;
 
     connect(Core::ICore::instance(), &Core::ICore::saveSettingsRequested,
-            this, &ToolchainManager::saveToolChains);
+            this, &ToolchainManager::saveToolchains);
-    connect(this, &ToolchainManager::toolChainAdded, this, &ToolchainManager::toolChainsChanged);
+    connect(this, &ToolchainManager::toolhainAdded, this, &ToolchainManager::toolchainsChanged);
-    connect(this, &ToolchainManager::toolChainRemoved, this, &ToolchainManager::toolChainsChanged);
+    connect(this, &ToolchainManager::toolchainRemoved, this, &ToolchainManager::toolchainsChanged);
-    connect(this, &ToolchainManager::toolChainUpdated, this, &ToolchainManager::toolChainsChanged);
+    connect(this, &ToolchainManager::toolchainUpdated, this, &ToolchainManager::toolchainsChanged);
 
     QtcSettings * const s = Core::ICore::settings();
     d->m_detectionSettings.detectX64AsX32
@@ -100,20 +100,20 @@ ToolchainManager *ToolchainManager::instance()
     return m_instance;
 }
 
-void ToolchainManager::restoreToolChains()
+void ToolchainManager::restoreToolchains()
 {
     NANOTRACE_SCOPE("ProjectExplorer", "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);
+        registerToolchain(tc);
 
     d->m_loaded = true;
-    emit m_instance->toolChainsLoaded();
+    emit m_instance->toolchainsLoaded();
 }
 
-void ToolchainManager::saveToolChains()
+void ToolchainManager::saveToolchains()
 {
     QTC_ASSERT(d->m_accessor, return);
 
@@ -137,13 +137,13 @@ Toolchains ToolchainManager::toolchains(const Toolchain::Predicate &predicate)
     return Utils::filtered(d->m_toolChains, predicate);
 }
 
-Toolchain *ToolchainManager::toolChain(const Toolchain::Predicate &predicate)
+Toolchain *ToolchainManager::toolchain(const Toolchain::Predicate &predicate)
 {
     QTC_CHECK(d->m_loaded);
     return Utils::findOrDefault(d->m_toolChains, predicate);
 }
 
-Toolchains ToolchainManager::findToolChains(const Abi &abi)
+Toolchains ToolchainManager::findToolchains(const Abi &abi)
 {
     QTC_CHECK(d->m_loaded);
     Toolchains result;
@@ -158,7 +158,7 @@ Toolchains ToolchainManager::findToolChains(const Abi &abi)
     return result;
 }
 
-Toolchain *ToolchainManager::findToolChain(const QByteArray &id)
+Toolchain *ToolchainManager::findToolchain(const QByteArray &id)
 {
     QTC_CHECK(d->m_loaded);
     if (id.isEmpty())
@@ -188,10 +188,10 @@ void ToolchainManager::notifyAboutUpdate(Toolchain *tc)
 {
     if (!tc || !d->m_toolChains.contains(tc))
         return;
-    emit m_instance->toolChainUpdated(tc);
+    emit m_instance->toolchainUpdated(tc);
 }
 
-bool ToolchainManager::registerToolChain(Toolchain *tc)
+bool ToolchainManager::registerToolchain(Toolchain *tc)
 {
     QTC_ASSERT(tc, return false);
     QTC_ASSERT(isLanguageSupported(tc->language()),
@@ -210,17 +210,17 @@ bool ToolchainManager::registerToolChain(Toolchain *tc)
     }
 
     d->m_toolChains.append(tc);
-    emit m_instance->toolChainAdded(tc);
+    emit m_instance->toolhainAdded(tc);
     return true;
 }
 
-void ToolchainManager::deregisterToolChain(Toolchain *tc)
+void ToolchainManager::deregisterToolchain(Toolchain *tc)
 {
     QTC_CHECK(d->m_loaded);
     if (!tc || !d->m_toolChains.contains(tc))
         return;
     d->m_toolChains.removeOne(tc);
-    emit m_instance->toolChainRemoved(tc);
+    emit m_instance->toolchainRemoved(tc);
     delete tc;
 }
 

src/plugins/projectexplorer/toolchainmanager.h

@@ -42,14 +42,14 @@ public:
     static const Toolchains &toolchains();
     static Toolchains toolchains(const Toolchain::Predicate &predicate);
 
-    static Toolchain *toolChain(const Toolchain::Predicate &predicate);
+    static Toolchain *toolchain(const Toolchain::Predicate &predicate);
-    static QList<Toolchain *> findToolChains(const Abi &abi);
+    static QList<Toolchain *> findToolchains(const Abi &abi);
-    static Toolchain *findToolChain(const QByteArray &id);
+    static Toolchain *findToolchain(const QByteArray &id);
 
     static bool isLoaded();
 
-    static bool registerToolChain(Toolchain *tc);
+    static bool registerToolchain(Toolchain *tc);
-    static void deregisterToolChain(Toolchain *tc);
+    static void deregisterToolchain(Toolchain *tc);
 
     static QList<Utils::Id> allLanguages();
     static bool registerLanguage(const Utils::Id &language, const QString &displayName);
@@ -65,24 +65,24 @@ public:
     static bool isBadToolchain(const Utils::FilePath &toolchain);
     static void addBadToolchain(const Utils::FilePath &toolchain);
 
-    void saveToolChains();
+    void saveToolchains();
 
 signals:
-    void toolChainAdded(ProjectExplorer::Toolchain *);
+    void toolhainAdded(ProjectExplorer::Toolchain *);
-    // Tool chain is still valid when this call happens!
+    // Toolchain is still valid when this call happens!
-    void toolChainRemoved(ProjectExplorer::Toolchain *);
+    void toolchainRemoved(ProjectExplorer::Toolchain *);
-    // Tool chain was updated.
+    // Toolchain was updated.
-    void toolChainUpdated(ProjectExplorer::Toolchain *);
+    void toolchainUpdated(ProjectExplorer::Toolchain *);
     // Something changed.
-    void toolChainsChanged();
+    void toolchainsChanged();
     //
-    void toolChainsLoaded();
+    void toolchainsLoaded();
 
 private:
     explicit ToolchainManager(QObject *parent = nullptr);
 
     // Make sure the this is only called after all toolchain factories are registered!
-    static void restoreToolChains();
+    static void restoreToolchains();
 
     static void notifyAboutUpdate(Toolchain *);
 

src/plugins/projectexplorer/toolchainoptionspage.cpp

@@ -275,14 +275,14 @@ public:
         horizontalLayout->addLayout(verticalLayout);
         horizontalLayout->addLayout(buttonLayout);
 
-        connect(ToolchainManager::instance(), &ToolchainManager::toolChainAdded,
+        connect(ToolchainManager::instance(), &ToolchainManager::toolhainAdded,
                 this, &ToolChainOptionsWidget::addToolChain);
-        connect(ToolchainManager::instance(), &ToolchainManager::toolChainRemoved,
+        connect(ToolchainManager::instance(), &ToolchainManager::toolchainRemoved,
                 this, &ToolChainOptionsWidget::removeToolChain);
 
         connect(m_toolChainView->selectionModel(), &QItemSelectionModel::currentChanged,
                 this, &ToolChainOptionsWidget::toolChainSelectionChanged);
-        connect(ToolchainManager::instance(), &ToolchainManager::toolChainsChanged,
+        connect(ToolchainManager::instance(), &ToolchainManager::toolchainsChanged,
                 this, &ToolChainOptionsWidget::toolChainSelectionChanged);
 
         connect(m_delButton, &QAbstractButton::clicked, this, [this] {
@@ -455,7 +455,7 @@ 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::deregisterToolchain(n->toolChain);
 
     Q_ASSERT(m_toRemoveList.isEmpty());
 
@@ -479,7 +479,7 @@ void ToolChainOptionsWidget::apply()
     QStringList removedTcs;
     nodes = m_toAddList;
     for (const ToolChainTreeItem *n : std::as_const(nodes)) {
-        if (!ToolchainManager::registerToolChain(n->toolChain))
+        if (!ToolchainManager::registerToolchain(n->toolChain))
             removedTcs << n->toolChain->displayName();
     }
     //

src/plugins/qmakeprojectmanager/qmakeproject.cpp

@@ -236,7 +236,7 @@ QmakeBuildSystem::QmakeBuildSystem(QmakeBuildConfiguration *bc)
     connect(bc, &BuildConfiguration::environmentChanged,
             this, &QmakeBuildSystem::scheduleUpdateAllNowOrLater);
 
-    connect(ToolchainManager::instance(), &ToolchainManager::toolChainUpdated,
+    connect(ToolchainManager::instance(), &ToolchainManager::toolchainUpdated,
             this, [this](Toolchain *tc) {
         if (ToolchainKitAspect::cxxToolChain(kit()) == tc)
             scheduleUpdateAllNowOrLater();

src/plugins/qnx/qnxsettingspage.cpp

@@ -99,7 +99,7 @@ public:
 
     bool isActive() const
     {
-        const bool hasToolChain = ToolchainManager::toolChain(Utils::equal(&Toolchain::compilerCommand,
+        const bool hasToolChain = ToolchainManager::toolchain(Utils::equal(&Toolchain::compilerCommand,
                                                                            m_qccCompiler));
         const bool hasDebugger = Utils::contains(DebuggerItemManager::debuggers(), [this](const DebuggerItem &di) {
             return findTargetByDebuggerPath(di.command());
@@ -188,7 +188,7 @@ void QnxConfiguration::deactivate()
     }
 
     for (Toolchain *tc : toolChainsToRemove)
-        ToolchainManager::deregisterToolChain(tc);
+        ToolchainManager::deregisterToolchain(tc);
 
     for (const DebuggerItem &debuggerItem : std::as_const(debuggersToRemove))
         DebuggerItemManager::deregisterDebugger(debuggerItem.id());
@@ -241,7 +241,7 @@ Toolchains QnxConfiguration::createToolChains(const QnxTarget &target)
         toolChain->sdpPath.setValue(m_envFile.parentDir());
         toolChain->cpuDir.setValue(target.cpuDir());
         toolChain->resetToolChain(m_qccCompiler);
-        ToolchainManager::registerToolChain(toolChain);
+        ToolchainManager::registerToolchain(toolChain);
 
         toolChains.append(toolChain);
     }

src/plugins/qtsupport/qtoptionspage.cpp

@@ -369,7 +369,7 @@ QtOptionsPageWidget::QtOptionsPageWidget()
     connect(QtVersionManager::instance(), &QtVersionManager::qtVersionsChanged,
             this, &QtOptionsPageWidget::updateQtVersions);
 
-    connect(ProjectExplorer::ToolchainManager::instance(), &ToolchainManager::toolChainsChanged,
+    connect(ProjectExplorer::ToolchainManager::instance(), &ToolchainManager::toolchainsChanged,
             this, &QtOptionsPageWidget::toolChainsUpdated);
 
     auto chooser = new VariableChooser(this);
@@ -493,7 +493,7 @@ QtOptionsPageWidget::ValidityInfo QtOptionsPageWidget::validInformation(const Qt
                                    [&abi](const Abi &sabi) { return sabi.isCompatibleWith(abi); });
         };
 
-        if (!ToolchainManager::toolChain(abiCompatePred))
+        if (!ToolchainManager::toolchain(abiCompatePred))
             missingToolChains.append(abi);
     }
 
@@ -539,7 +539,7 @@ QList<Toolchain*> QtOptionsPageWidget::toolChains(const QtVersion *version)
     QSet<QByteArray> ids;
     const Abis abis = version->qtAbis();
     for (const Abi &a : abis) {
-        const Toolchains tcList = ToolchainManager::findToolChains(a);
+        const Toolchains tcList = ToolchainManager::findToolchains(a);
         for (Toolchain *tc : tcList) {
             if (Utils::insert(ids, tc->id()))
                 toolChains.append(tc);

src/plugins/qtsupport/qtversionmanager.cpp

@@ -97,7 +97,7 @@ public:
         m_fileWatcherTimer.setInterval(2000);
         connect(&m_fileWatcherTimer, &QTimer::timeout, this, [this] { updateFromInstaller(); });
 
-        connect(ToolchainManager::instance(), &ToolchainManager::toolChainsLoaded,
+        connect(ToolchainManager::instance(), &ToolchainManager::toolchainsLoaded,
                 this, &QtVersionManagerImpl::triggerQtVersionRestore);
     }
 
@@ -144,7 +144,7 @@ void QtVersionManagerImpl::triggerQtVersionRestore()
 {
     NANOTRACE_SCOPE("QtSupport", "QtVersionManagerImpl::triggerQtVersionRestore");
     disconnect(ToolchainManager::instance(),
-               &ToolchainManager::toolChainsLoaded,
+               &ToolchainManager::toolchainsLoaded,
                this,
                &QtVersionManagerImpl::triggerQtVersionRestore);
 

src/plugins/webassembly/webassemblytoolchain.cpp

@@ -48,7 +48,7 @@ static void addRegisteredMinGWToEnvironment(Environment &env)
         return;
     }
 
-    const Toolchain *toolChain = ToolchainManager::toolChain([](const Toolchain *t){
+    const Toolchain *toolChain = ToolchainManager::toolchain([](const Toolchain *t){
         return t->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID;
     });
     if (toolChain)
@@ -140,17 +140,17 @@ static Toolchains doAutoDetect(const ToolchainDetector &detector)
 void WebAssemblyToolChain::registerToolChains()
 {
     // Remove old toolchains
-    for (Toolchain *tc : ToolchainManager::findToolChains(toolChainAbi())) {
+    for (Toolchain *tc : ToolchainManager::findToolchains(toolChainAbi())) {
          if (tc->detection() != Toolchain::AutoDetection)
              continue;
-         ToolchainManager::deregisterToolChain(tc);
+         ToolchainManager::deregisterToolchain(tc);
     };
 
     // Create new toolchains and register them
     ToolchainDetector detector({}, {}, {});
     const Toolchains toolchains = doAutoDetect(detector);
     for (auto toolChain : toolchains)
-        ToolchainManager::registerToolChain(toolChain);
+        ToolchainManager::registerToolchain(toolChain);
 
     // Let kits pick up the new toolchains
     for (Kit *kit : KitManager::kits()) {
@@ -165,7 +165,7 @@ void WebAssemblyToolChain::registerToolChains()
 
 bool WebAssemblyToolChain::areToolChainsRegistered()
 {
-    return !ToolchainManager::findToolChains(toolChainAbi()).isEmpty();
+    return !ToolchainManager::findToolchains(toolChainAbi()).isEmpty();
 }
 
 WebAssemblyToolchainFactory::WebAssemblyToolchainFactory()