ProjectExplorer: Rename various items in the Toolchain class

Change-Id: I544763d3b4d521f6bbed0dc5a767c15c49055a19
Reviewed-by: Qt CI Bot <qt_ci_bot@qt-project.org>
Reviewed-by: Christian Kandeler <christian.kandeler@qt.io>

src/plugins/android/androidtoolchain.cpp

@@ -140,7 +140,7 @@ GccToolChain::DetectedAbisResult AndroidToolChain::detectSupportedAbis() const
 AndroidToolchainFactory::AndroidToolchainFactory()
 {
     setDisplayName(Tr::tr("Android Clang"));
-    setSupportedToolChainType(Constants::ANDROID_TOOLCHAIN_TYPEID);
+    setSupportedToolchainType(Constants::ANDROID_TOOLCHAIN_TYPEID);
     setSupportedLanguages({ProjectExplorer::Constants::CXX_LANGUAGE_ID});
     setToolchainConstructor([] { return new AndroidToolChain; });
 }

src/plugins/baremetal/iarewtoolchain.cpp

@@ -413,7 +413,7 @@ public:
     IarToolchainFactory()
     {
         setDisplayName(Tr::tr("IAREW"));
-        setSupportedToolChainType(Constants::IAREW_TOOLCHAIN_TYPEID);
+        setSupportedToolchainType(Constants::IAREW_TOOLCHAIN_TYPEID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
                                ProjectExplorer::Constants::CXX_LANGUAGE_ID});
         setToolchainConstructor([] { return new IarToolChain; });
@@ -421,7 +421,7 @@ public:
     }
 
     Toolchains autoDetect(const ToolchainDetector &detector) const final;
-    Toolchains detectForImport(const ToolChainDescription &tcd) const final;
+    Toolchains detectForImport(const ToolchainDescription &tcd) const final;
 
 private:
     Toolchains autoDetectToolchains(const Candidates &candidates,
@@ -507,7 +507,7 @@ Toolchains IarToolchainFactory::autoDetect(const ToolchainDetector &detector) co
     return autoDetectToolchains(candidates, detector.alreadyKnown);
 }
 
-Toolchains IarToolchainFactory::detectForImport(const ToolChainDescription &tcd) const
+Toolchains IarToolchainFactory::detectForImport(const ToolchainDescription &tcd) const
 {
     return { autoDetectToolchain({tcd.compilerPath, {}}, tcd.language) };
 }

src/plugins/baremetal/keiltoolchain.cpp

@@ -544,7 +544,7 @@ public:
     KeilToolchainFactory()
     {
         setDisplayName(Tr::tr("KEIL"));
-        setSupportedToolChainType(Constants::KEIL_TOOLCHAIN_TYPEID);
+        setSupportedToolchainType(Constants::KEIL_TOOLCHAIN_TYPEID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
                                ProjectExplorer::Constants::CXX_LANGUAGE_ID});
         setToolchainConstructor([] { return new KeilToolChain; });

src/plugins/baremetal/sdcctoolchain.cpp

@@ -306,7 +306,7 @@ public:
     SdccToolchainFactory()
     {
         setDisplayName(Tr::tr("SDCC"));
-        setSupportedToolChainType(Constants::SDCC_TOOLCHAIN_TYPEID);
+        setSupportedToolchainType(Constants::SDCC_TOOLCHAIN_TYPEID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID});
         setToolchainConstructor([] { return new SdccToolChain; });
         setUserCreatable(true);

src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp

@@ -56,7 +56,7 @@ struct DirectoryData
     QString toolset;
     FilePath sysroot;
     QtProjectImporter::QtVersionData qt;
-    QVector<ToolChainDescription> toolChains;
+    QVector<ToolchainDescription> toolChains;
 };
 
 static FilePaths scanDirectory(const FilePath &path, const QString &prefix)
@@ -464,9 +464,9 @@ static QMakeAndCMakePrefixPath qtInfoFromCMakeCache(const CMakeConfig &config,
     return {qmakeLocation, resultedPrefixPath};
 }
 
-static QVector<ToolChainDescription> extractToolChainsFromCache(const CMakeConfig &config)
+static QVector<ToolchainDescription> extractToolChainsFromCache(const CMakeConfig &config)
 {
-    QVector<ToolChainDescription> result;
+    QVector<ToolchainDescription> result;
     bool haveCCxxCompiler = false;
     for (const CMakeConfigItem &i : config) {
         if (!i.key.startsWith("CMAKE_") || !i.key.endsWith("_COMPILER"))
@@ -564,7 +564,7 @@ void updateConfigWithDirectoryData(CMakeConfig &config, const std::unique_ptr<Di
         });
 
         auto tcd = Utils::findOrDefault(data->toolChains,
-                                        [&language](const ToolChainDescription &t) {
+                                        [&language](const ToolchainDescription &t) {
                                             return t.language == language;
                                         });
 
@@ -933,7 +933,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
 
     const bool compilersMatch = [k, data] {
         const QList<Id> allLanguages = ToolchainManager::allLanguages();
-        for (const ToolChainDescription &tcd : data->toolChains) {
+        for (const ToolchainDescription &tcd : data->toolChains) {
             if (!Utils::contains(allLanguages,
                                  [&tcd](const Id &language) { return language == tcd.language; }))
                 continue;
@@ -946,7 +946,7 @@ bool CMakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
     }();
     const bool noCompilers = [k, data] {
         const QList<Id> allLanguages = ToolchainManager::allLanguages();
-        for (const ToolChainDescription &tcd : data->toolChains) {
+        for (const ToolchainDescription &tcd : data->toolChains) {
             if (!Utils::contains(allLanguages,
                                  [&tcd](const Id &language) { return language == tcd.language; }))
                 continue;
@@ -995,7 +995,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
 
         SysRootKitAspect::setSysRoot(k, data->sysroot);
 
-        for (const ToolChainDescription &cmtcd : data->toolChains) {
+        for (const ToolchainDescription &cmtcd : data->toolChains) {
             const ToolChainData tcd = findOrCreateToolChains(cmtcd);
             QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
 
@@ -1197,7 +1197,7 @@ void CMakeProjectPlugin::testCMakeProjectImporterToolChain()
         config.append(CMakeConfigItem(key.toUtf8(), value.toUtf8()));
     }
 
-    const QVector<ToolChainDescription> tcs = extractToolChainsFromCache(config);
+    const QVector<ToolchainDescription> tcs = extractToolChainsFromCache(config);
     QCOMPARE(tcs.count(), expectedLanguages.count());
     for (int i = 0; i < tcs.count(); ++i) {
         QCOMPARE(tcs.at(i).language, expectedLanguages.at(i));

src/plugins/mcusupport/mcupackage.cpp

@@ -417,7 +417,7 @@ static Toolchain *armGccToolChain(const FilePath &path, Id language)
         ToolchainFactory *gccFactory
             = Utils::findOrDefault(ToolchainFactory::allToolchainFactories(),
                                    [](ToolchainFactory *f) {
-                                       return f->supportedToolChainType()
+                                       return f->supportedToolchainType()
                                               == ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID;
                                    });
         if (gccFactory) {
@@ -444,7 +444,7 @@ static Toolchain *iarToolChain(const FilePath &path, Id language)
         ToolchainFactory *iarFactory
             = Utils::findOrDefault(ToolchainFactory::allToolchainFactories(),
                                    [](ToolchainFactory *f) {
-                                       return f->supportedToolChainType()
+                                       return f->supportedToolchainType()
                                               == BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID;
                                    });
         if (iarFactory) {

src/plugins/mcusupport/test/unittest.cpp

@@ -214,7 +214,7 @@ void verifyIarToolchain(const McuToolChainPackagePtr &iarToolchainPackage)
 {
     ProjectExplorer::ToolchainFactory toolchainFactory;
     Id iarId{BareMetal::Constants::IAREW_TOOLCHAIN_TYPEID};
-    Toolchain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolChain(iarId)};
+    Toolchain *iarToolchain{ProjectExplorer::ToolchainFactory::createToolchain(iarId)};
     iarToolchain->setLanguage(cxxLanguageId);
     ToolchainManager::registerToolchain(iarToolchain);
 
@@ -238,7 +238,7 @@ void verifyArmGccToolchain(const McuToolChainPackagePtr &armGccPackage, const QS
     ProjectExplorer::ToolchainFactory toolchainFactory;
     Id armGccId{ProjectExplorer::Constants::GCC_TOOLCHAIN_TYPEID};
 
-    Toolchain *armToolchain{ProjectExplorer::ToolchainFactory::createToolChain(armGccId)};
+    Toolchain *armToolchain{ProjectExplorer::ToolchainFactory::createToolchain(armGccId)};
     armToolchain->setLanguage(cxxLanguageId);
     ToolchainManager::registerToolchain(armToolchain);
 

src/plugins/nim/project/nimtoolchain.cpp

@@ -206,7 +206,7 @@ std::unique_ptr<ToolchainConfigWidget> NimToolChain::createConfigurationWidget()
 NimToolchainFactory::NimToolchainFactory()
 {
     setDisplayName(Tr::tr("Nim"));
-    setSupportedToolChainType(Constants::C_NIMTOOLCHAIN_TYPEID);
+    setSupportedToolchainType(Constants::C_NIMTOOLCHAIN_TYPEID);
     setSupportedLanguages({Constants::C_NIMLANGUAGE_ID});
     setToolchainConstructor([] { return new NimToolChain; });
     setUserCreatable(true);
@@ -235,7 +235,7 @@ Toolchains NimToolchainFactory::autoDetect(const ToolchainDetector &detector) co
     return result;
 }
 
-Toolchains NimToolchainFactory::detectForImport(const ToolChainDescription &tcd) const
+Toolchains NimToolchainFactory::detectForImport(const ToolchainDescription &tcd) const
 {
     Toolchains result;
     if (tcd.language == Constants::C_NIMLANGUAGE_ID) {

src/plugins/nim/project/nimtoolchain.h

@@ -40,7 +40,7 @@ public:
     NimToolchainFactory();
 
     ProjectExplorer::Toolchains autoDetect(const ProjectExplorer::ToolchainDetector &detector) const final;
-    ProjectExplorer::Toolchains detectForImport(const ProjectExplorer::ToolChainDescription &tcd) const final;
+    ProjectExplorer::Toolchains detectForImport(const ProjectExplorer::ToolchainDescription &tcd) const final;
 };
 
 } // Nim

src/plugins/projectexplorer/customtoolchain.cpp

@@ -561,7 +561,7 @@ std::unique_ptr<ToolchainConfigWidget> CustomToolChain::createConfigurationWidge
 CustomToolchainFactory::CustomToolchainFactory()
 {
     setDisplayName(Tr::tr("Custom"));
-    setSupportedToolChainType(Constants::CUSTOM_TOOLCHAIN_TYPEID);
+    setSupportedToolchainType(Constants::CUSTOM_TOOLCHAIN_TYPEID);
     setSupportsAllLanguages(true);
     setToolchainConstructor([] { return new CustomToolChain; });
     setUserCreatable(true);

src/plugins/projectexplorer/gcctoolchain.cpp

@@ -1285,22 +1285,22 @@ public:
         switch (subType) {
         case GccToolChain::RealGcc:
             setDisplayName(Tr::tr("GCC"));
-            setSupportedToolChainType(Constants::GCC_TOOLCHAIN_TYPEID);
+            setSupportedToolchainType(Constants::GCC_TOOLCHAIN_TYPEID);
             setToolchainConstructor(&constructRealGccToolchain);
             break;
         case GccToolChain::Clang:
             setDisplayName(Tr::tr("Clang"));
-            setSupportedToolChainType(Constants::CLANG_TOOLCHAIN_TYPEID);
+            setSupportedToolchainType(Constants::CLANG_TOOLCHAIN_TYPEID);
             setToolchainConstructor(&constructClangToolchain);
             break;
         case GccToolChain::MinGW:
             setDisplayName(Tr::tr("MinGW"));
-            setSupportedToolChainType(Constants::MINGW_TOOLCHAIN_TYPEID);
+            setSupportedToolchainType(Constants::MINGW_TOOLCHAIN_TYPEID);
             setToolchainConstructor(&constructMinGWToolchain);
             break;
         case GccToolChain::LinuxIcc:
             setDisplayName(Tr::tr("ICC"));
-            setSupportedToolChainType(Constants::LINUXICC_TOOLCHAIN_TYPEID);
+            setSupportedToolchainType(Constants::LINUXICC_TOOLCHAIN_TYPEID);
             setToolchainConstructor(&constructLinuxIccToolchain);
             break;
         }
@@ -1309,7 +1309,7 @@ public:
     }
 
     Toolchains autoDetect(const ToolchainDetector &detector) const final;
-    Toolchains detectForImport(const ToolChainDescription &tcd) const final;
+    Toolchains detectForImport(const ToolchainDescription &tcd) const final;
 
 private:
     static Toolchains autoDetectToolchains(const FilePaths &compilerPaths,
@@ -1317,7 +1317,7 @@ private:
                                            const Id requiredTypeId,
                                            const Toolchains &known,
                                            const GccToolChain::SubType subType);
-    static Toolchains autoDetectToolChain(const ToolChainDescription &tcd,
+    static Toolchains autoDetectToolChain(const ToolchainDescription &tcd,
                                           const GccToolChain::SubType subType);
     static Toolchains autoDetectSdkClangToolchain(const Toolchains &known);
 
@@ -1504,7 +1504,7 @@ Toolchains GccToolchainFactory::autoDetect(const ToolchainDetector &detector) co
     return result;
 }
 
-Toolchains GccToolchainFactory::detectForImport(const ToolChainDescription &tcd) const
+Toolchains GccToolchainFactory::detectForImport(const ToolchainDescription &tcd) const
 {
     Toolchains result;
 
@@ -1616,7 +1616,7 @@ Toolchains GccToolchainFactory::autoDetectToolchains(const FilePaths &compilerPa
     return result;
 }
 
-Toolchains GccToolchainFactory::autoDetectToolChain(const ToolChainDescription &tcd,
+Toolchains GccToolchainFactory::autoDetectToolChain(const ToolchainDescription &tcd,
                                                     GccToolChain::SubType subType)
 {
     Toolchains result;

src/plugins/projectexplorer/msvctoolchain.cpp

@@ -1872,7 +1872,7 @@ public:
     MsvcToolchainFactory()
     {
         setDisplayName(Tr::tr("MSVC"));
-        setSupportedToolChainType(Constants::MSVC_TOOLCHAIN_TYPEID);
+        setSupportedToolchainType(Constants::MSVC_TOOLCHAIN_TYPEID);
         setSupportedLanguages({Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID});
         setToolchainConstructor([] { return new MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID); });
     }
@@ -2244,7 +2244,7 @@ public:
     {
         setDisplayName(Tr::tr("clang-cl"));
         setSupportedLanguages({Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID});
-        setSupportedToolChainType(Constants::CLANG_CL_TOOLCHAIN_TYPEID);
+        setSupportedToolchainType(Constants::CLANG_CL_TOOLCHAIN_TYPEID);
         setToolchainConstructor([] { return new ClangClToolChain; });
     }
 

src/plugins/projectexplorer/projectimporter.cpp

@@ -366,7 +366,7 @@ bool ProjectImporter::hasKitWithTemporaryData(Utils::Id id, const QVariant &data
     });
 }
 
-static ProjectImporter::ToolChainData createToolChains(const ToolChainDescription &tcd)
+static ProjectImporter::ToolChainData createToolChains(const ToolchainDescription &tcd)
 {
     ProjectImporter::ToolChainData data;
 
@@ -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) {

src/plugins/projectexplorer/projectimporter.h

@@ -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;

src/plugins/projectexplorer/toolchain.cpp

@@ -30,20 +30,20 @@ const char CODE_MODEL_TRIPLE_KEY[] = "ExplicitCodeModelTargetTriple";
 
 QList<ToolchainFactory *> &toolchainFactories()
 {
-    static QList<ToolchainFactory *> theToolChainFactories;
+    static QList<ToolchainFactory *> theToolchainFactories;
-    return theToolChainFactories;
+    return theToolchainFactories;
 }
 
 // --------------------------------------------------------------------------
-// ToolChainPrivate
+// ToolchainPrivate
 // --------------------------------------------------------------------------
 
-class ToolChainPrivate
+class ToolchainPrivate
 {
 public:
     using Detection = Toolchain::Detection;
 
-    explicit ToolChainPrivate(Id typeId) :
+    explicit ToolchainPrivate(Id typeId) :
         m_id(QUuid::createUuid().toByteArray()),
         m_typeId(typeId),
         m_predefinedMacrosCache(new Toolchain::MacrosCache::element_type()),
@@ -107,7 +107,7 @@ QString languageId(Language l)
     return {};
 }
 
-} // namespace Deprecated::ToolChain
+} // namespace Deprecated::Toolchain
 
 using namespace Internal;
 
@@ -120,7 +120,7 @@ using namespace Internal;
 // --------------------------------------------------------------------------
 
 Toolchain::Toolchain(Id typeId) :
-    d(std::make_unique<ToolChainPrivate>(typeId))
+    d(std::make_unique<ToolchainPrivate>(typeId))
 {
 }
 
@@ -220,7 +220,7 @@ bool Toolchain::operator == (const Toolchain &tc) const
 Toolchain *Toolchain::clone() const
 {
     for (ToolchainFactory *f : std::as_const(toolchainFactories())) {
-        if (f->supportedToolChainType() == d->m_typeId) {
+        if (f->supportedToolchainType() == d->m_typeId) {
             Toolchain *tc = f->create();
             QTC_ASSERT(tc, return nullptr);
             Store data;
@@ -535,25 +535,25 @@ void Toolchain::setExplicitCodeModelTargetTriple(const QString &triple)
 }
 
 /*!
-    \class ProjectExplorer::ToolChainFactory
+    \class ProjectExplorer::ToolchainFactory
-    \brief The ToolChainFactory class creates tool chains from settings or
+    \brief The ToolchainFactory class creates tool chains from settings or
     autodetects them.
 */
 
 /*!
-    \fn QString ProjectExplorer::ToolChainFactory::displayName() const = 0
+    \fn QString ProjectExplorer::ToolchainFactory::displayName() const = 0
     Contains the name used to display the name of the tool chain that will be
     created.
 */
 
 /*!
-    \fn QStringList ProjectExplorer::ToolChain::clangParserFlags(const QStringList &cxxflags) const = 0
+    \fn QStringList ProjectExplorer::Toolchain::clangParserFlags(const QStringList &cxxflags) const = 0
     Converts tool chain specific flags to list flags that tune the libclang
     parser.
 */
 
 /*!
-    \fn bool ProjectExplorer::ToolChainFactory::canRestore(const Store &data)
+    \fn bool ProjectExplorer::ToolchainFactory::canRestore(const Store &data)
     Used by the tool chain manager to restore user-generated tool chains.
 */
 
@@ -578,7 +578,7 @@ Toolchains ToolchainFactory::autoDetect(const ToolchainDetector &detector) const
     return {};
 }
 
-Toolchains ToolchainFactory::detectForImport(const ToolChainDescription &tcd) const
+Toolchains ToolchainFactory::detectForImport(const ToolchainDescription &tcd) const
 {
     Q_UNUSED(tcd)
     return {};
@@ -633,12 +633,12 @@ void ToolchainFactory::autoDetectionToMap(Store &data, bool detected)
     data.insert(AUTODETECT_KEY, detected);
 }
 
-Toolchain *ToolchainFactory::createToolChain(Id toolChainType)
+Toolchain *ToolchainFactory::createToolchain(Id toolchainType)
 {
     for (ToolchainFactory *factory : std::as_const(toolchainFactories())) {
-        if (factory->m_supportedToolChainType == toolChainType) {
+        if (factory->m_supportedToolchainType == toolchainType) {
             if (Toolchain *tc = factory->create()) {
-                tc->d->m_typeId = toolChainType;
+                tc->d->m_typeId = toolchainType;
                 return tc;
             }
         }
@@ -651,14 +651,14 @@ QList<Id> ToolchainFactory::supportedLanguages() const
     return m_supportsAllLanguages ? ToolchainManager::allLanguages() : m_supportedLanguages;
 }
 
-Id ToolchainFactory::supportedToolChainType() const
+Id ToolchainFactory::supportedToolchainType() const
 {
-    return m_supportedToolChainType;
+    return m_supportedToolchainType;
 }
 
-void ToolchainFactory::setSupportedToolChainType(const Id &supportedToolChain)
+void ToolchainFactory::setSupportedToolchainType(const Id &supportedToolchainType)
 {
-    m_supportedToolChainType = supportedToolChain;
+    m_supportedToolchainType = supportedToolchainType;
 }
 
 void ToolchainFactory::setSupportedLanguages(const QList<Id> &supportedLanguages)
@@ -671,12 +671,12 @@ void ToolchainFactory::setSupportsAllLanguages(bool supportsAllLanguages)
     m_supportsAllLanguages = supportsAllLanguages;
 }
 
-void ToolchainFactory::setToolchainConstructor(const ToolChainConstructor &toolchainContructor)
+void ToolchainFactory::setToolchainConstructor(const ToolchainConstructor &toolchainContructor)
 {
     m_toolchainConstructor = toolchainContructor;
 }
 
-ToolchainFactory::ToolChainConstructor ToolchainFactory::toolchainConstructor() const
+ToolchainFactory::ToolchainConstructor ToolchainFactory::toolchainConstructor() const
 {
     return m_toolchainConstructor;
 }

src/plugins/projectexplorer/toolchain.h

@@ -26,7 +26,7 @@ namespace Utils { class OutputLineParser; }
 
 namespace ProjectExplorer {
 
-namespace Internal { class ToolChainPrivate; }
+namespace Internal { class ToolchainPrivate; }
 
 namespace Deprecated {
 // Deprecated in 4.3:
@@ -44,9 +44,9 @@ class GccToolChain;
 class ToolchainConfigWidget;
 class Kit;
 
-namespace Internal { class ToolChainSettingsAccessor; }
+namespace Internal { class ToolchainSettingsAccessor; }
 
-class PROJECTEXPLORER_EXPORT ToolChainDescription
+class PROJECTEXPLORER_EXPORT ToolchainDescription
 {
 public:
     Utils::FilePath compilerPath;
@@ -54,7 +54,7 @@ public:
 };
 
 // --------------------------------------------------------------------------
-// ToolChain (documentation inside)
+// Toolchain (documentation inside)
 // --------------------------------------------------------------------------
 
 class PROJECTEXPLORER_EXPORT Toolchain : public Utils::AspectContainer
@@ -194,9 +194,9 @@ private:
     Toolchain(const Toolchain &) = delete;
     Toolchain &operator=(const Toolchain &) = delete;
 
-    const std::unique_ptr<Internal::ToolChainPrivate> d;
+    const std::unique_ptr<Internal::ToolchainPrivate> d;
 
-    friend class Internal::ToolChainSettingsAccessor;
+    friend class Internal::ToolchainSettingsAccessor;
     friend class ToolchainFactory;
 };
 
@@ -253,10 +253,10 @@ public:
     static const QList<ToolchainFactory *> allToolchainFactories();
 
     QString displayName() const { return m_displayName; }
-    Utils::Id supportedToolChainType() const;
+    Utils::Id supportedToolchainType() const;
 
     virtual Toolchains autoDetect(const ToolchainDetector &detector) const;
-    virtual Toolchains detectForImport(const ToolChainDescription &tcd) const;
+    virtual Toolchains detectForImport(const ToolchainDescription &tcd) const;
 
     virtual bool canCreate() const;
     Toolchain *create() const;
@@ -267,7 +267,7 @@ public:
     static Utils::Id typeIdFromMap(const Utils::Store &data);
     static void autoDetectionToMap(Utils::Store &data, bool detected);
 
-    static Toolchain *createToolChain(Utils::Id toolChainType);
+    static Toolchain *createToolchain(Utils::Id toolchainType);
 
     QList<Utils::Id> supportedLanguages() const;
 
@@ -275,12 +275,12 @@ public:
 
 protected:
     void setDisplayName(const QString &name) { m_displayName = name; }
-    void setSupportedToolChainType(const Utils::Id &supportedToolChainType);
+    void setSupportedToolchainType(const Utils::Id &supportedToolchainType);
     void setSupportedLanguages(const QList<Utils::Id> &supportedLanguages);
     void setSupportsAllLanguages(bool supportsAllLanguages);
-    using ToolChainConstructor = std::function<Toolchain *()>;
+    using ToolchainConstructor = std::function<Toolchain *()>;
-    void setToolchainConstructor(const ToolChainConstructor &constructor);
+    void setToolchainConstructor(const ToolchainConstructor &constructor);
-    ToolChainConstructor toolchainConstructor() const;
+    ToolchainConstructor toolchainConstructor() const;
 
     class Candidate {
     public:
@@ -297,11 +297,11 @@ protected:
 
 private:
     QString m_displayName;
-    Utils::Id m_supportedToolChainType;
+    Utils::Id m_supportedToolchainType;
     QList<Utils::Id> m_supportedLanguages;
     bool m_supportsAllLanguages = false;
     bool m_userCreatable = false;
-    ToolChainConstructor m_toolchainConstructor;
+    ToolchainConstructor m_toolchainConstructor;
 };
 
 } // namespace ProjectExplorer

src/plugins/projectexplorer/toolchainmanager.cpp

@@ -38,7 +38,7 @@ class ToolchainManagerPrivate
 public:
     ~ToolchainManagerPrivate();
 
-    std::unique_ptr<ToolChainSettingsAccessor> m_accessor;
+    std::unique_ptr<ToolchainSettingsAccessor> m_accessor;
 
     Toolchains m_toolChains; // prioritized List
     BadToolchains m_badToolchains;   // to be skipped when auto-detecting
@@ -104,7 +104,7 @@ void ToolchainManager::restoreToolchains()
 {
     NANOTRACE_SCOPE("ProjectExplorer", "ToolchainManager::restoreToolChains");
     QTC_ASSERT(!d->m_accessor, return);
-    d->m_accessor = std::make_unique<Internal::ToolChainSettingsAccessor>();
+    d->m_accessor = std::make_unique<Internal::ToolchainSettingsAccessor>();
 
     for (Toolchain *tc : d->m_accessor->restoreToolChains(Core::ICore::dialogParent()))
         registerToolchain(tc);

src/plugins/projectexplorer/toolchainsettingsaccessor.cpp

@@ -173,7 +173,7 @@ static ToolChainOperations mergeToolChainLists(const Toolchains &systemFileTcs,
 // ToolChainSettingsAccessor:
 // --------------------------------------------------------------------
 
-ToolChainSettingsAccessor::ToolChainSettingsAccessor()
+ToolchainSettingsAccessor::ToolchainSettingsAccessor()
 {
     setDocType("QtCreatorToolChains");
     setApplicationDisplayName(QGuiApplication::applicationDisplayName());
@@ -182,7 +182,7 @@ ToolChainSettingsAccessor::ToolChainSettingsAccessor()
     addVersionUpgrader(std::make_unique<ToolChainSettingsUpgraderV0>());
 }
 
-Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
+Toolchains ToolchainSettingsAccessor::restoreToolChains(QWidget *parent) const
 {
     NANOTRACE_SCOPE("ProjectExplorer", "ToolChainSettingsAccessor::restoreToolChains");
     // read all tool chains from SDK
@@ -218,7 +218,7 @@ Toolchains ToolChainSettingsAccessor::restoreToolChains(QWidget *parent) const
     return ops.toRegister;
 }
 
-void ToolChainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWidget *parent)
+void ToolchainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWidget *parent)
 {
     Store data;
 
@@ -240,7 +240,7 @@ void ToolChainSettingsAccessor::saveToolChains(const Toolchains &toolchains, QWi
     saveSettings(data, parent);
 }
 
-Toolchains ToolChainSettingsAccessor::toolChains(const Store &data) const
+Toolchains ToolchainSettingsAccessor::toolChains(const Store &data) const
 {
     Toolchains result;
     const QList<ToolchainFactory *> factories = ToolchainFactory::allToolchainFactories();
@@ -257,7 +257,7 @@ Toolchains ToolChainSettingsAccessor::toolChains(const Store &data) const
         const Utils::Id tcType = ToolchainFactory::typeIdFromMap(tcMap);
         if (tcType.isValid()) {
             for (ToolchainFactory *f : factories) {
-                if (f->supportedToolChainType() == tcType) {
+                if (f->supportedToolchainType() == tcType) {
                     if (Toolchain *tc = f->restore(tcMap)) {
                         result.append(tc);
                         restored = true;
@@ -360,7 +360,7 @@ void ProjectExplorerPlugin::testToolChainMerging_data()
     {
     public:
         TestToolchainFactory() {
-            setSupportedToolChainType(TestToolChainType);
+            setSupportedToolchainType(TestToolChainType);
             setToolchainConstructor([] { return new TTC; });
         }
     };

src/plugins/projectexplorer/toolchainsettingsaccessor.h

@@ -13,10 +13,10 @@ class Toolchain;
 
 namespace Internal {
 
-class ToolChainSettingsAccessor : public Utils::UpgradingSettingsAccessor
+class ToolchainSettingsAccessor : public Utils::UpgradingSettingsAccessor
 {
 public:
-    ToolChainSettingsAccessor();
+    ToolchainSettingsAccessor();
 
     QList<Toolchain *> restoreToolChains(QWidget *parent) const;
 

src/plugins/qnx/qnxtoolchain.cpp

@@ -259,7 +259,7 @@ public:
     QnxToolchainFactory()
     {
         setDisplayName(Tr::tr("QCC"));
-        setSupportedToolChainType(Constants::QNX_TOOLCHAIN_ID);
+        setSupportedToolchainType(Constants::QNX_TOOLCHAIN_ID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
                                ProjectExplorer::Constants::CXX_LANGUAGE_ID});
         setToolchainConstructor([] { return new QnxToolChain; });

src/plugins/webassembly/webassemblytoolchain.cpp

@@ -173,7 +173,7 @@ public:
     WebAssemblyToolchainFactory()
     {
         setDisplayName(Tr::tr("Emscripten"));
-        setSupportedToolChainType(Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID);
+        setSupportedToolchainType(Constants::WEBASSEMBLY_TOOLCHAIN_TYPEID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
                                ProjectExplorer::Constants::CXX_LANGUAGE_ID});
         setToolchainConstructor([] { return new WebAssemblyToolChain; });