ProjectExplorer: Some more Toolchain renamings

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

src/plugins/baremetal/baremetalplugin.cpp

@@ -28,9 +28,9 @@ class BareMetalPlugin final : public ExtensionSystem::IPlugin
     {
         setupBareMetalDevice();
 
-        setupIarToolChain();
-        setupKeilToolChain();
-        setupSdccToolChain();
+        setupIarToolchain();
+        setupKeilToolchain();
+        setupSdccToolchain();
 
         setupBareMetalDeployAndRunConfigurations();
         setupBareMetalDebugSupport();

src/plugins/baremetal/iarewtoolchain.cpp

@@ -253,14 +253,14 @@ static QString buildDisplayName(Abi::Architecture arch, Utils::Id language,
     return Tr::tr("IAREW %1 (%2, %3)").arg(version, langName, archName);
 }
 
-// IarToolChainConfigWidget
+// IarToolchainConfigWidget
 
-class IarToolChain;
+class IarToolchain;
 
-class IarToolChainConfigWidget final : public ToolchainConfigWidget
+class IarToolchainConfigWidget final : public ToolchainConfigWidget
 {
 public:
-    explicit IarToolChainConfigWidget(IarToolChain *tc);
+    explicit IarToolchainConfigWidget(IarToolchain *tc);
 
 private:
     void applyImpl() final;
@@ -280,10 +280,10 @@ private:
 
 // IarToolChain
 
-class IarToolChain final : public Toolchain
+class IarToolchain final : public Toolchain
 {
 public:
-    IarToolChain() : Toolchain(Constants::IAREW_TOOLCHAIN_TYPEID)
+    IarToolchain() : Toolchain(Constants::IAREW_TOOLCHAIN_TYPEID)
     {
         setTypeDisplayName(Tr::tr("IAREW"));
         setTargetAbiKey("TargetAbi");
@@ -291,7 +291,7 @@ public:
 
         m_extraCodeModelFlags.setSettingsKey("PlatformCodeGenFlags");
         connect(&m_extraCodeModelFlags, &BaseAspect::changed,
-                this, &IarToolChain::toolChainUpdated);
+                this, &IarToolchain::toolChainUpdated);
     }
 
     MacroInspectionRunner createMacroInspectionRunner() const final;
@@ -315,10 +315,10 @@ private:
     StringListAspect m_extraCodeModelFlags{this};
 
     friend class IarToolchainFactory;
-    friend class IarToolChainConfigWidget;
+    friend class IarToolchainConfigWidget;
 };
 
-Toolchain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner IarToolchain::createMacroInspectionRunner() const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
@@ -348,18 +348,18 @@ Toolchain::MacroInspectionRunner IarToolChain::createMacroInspectionRunner() con
     };
 }
 
-Utils::LanguageExtensions IarToolChain::languageExtensions(const QStringList &) const
+Utils::LanguageExtensions IarToolchain::languageExtensions(const QStringList &) const
 {
     return LanguageExtension::None;
 }
 
-WarningFlags IarToolChain::warningFlags(const QStringList &cxxflags) const
+WarningFlags IarToolchain::warningFlags(const QStringList &cxxflags) const
 {
     Q_UNUSED(cxxflags)
     return WarningFlags::Default;
 }
 
-Toolchain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner IarToolchain::createBuiltInHeaderPathsRunner(
         const Environment &) const
 {
     Environment env = Environment::systemEnvironment();
@@ -383,23 +383,23 @@ Toolchain::BuiltInHeaderPathsRunner IarToolChain::createBuiltInHeaderPathsRunner
     };
 }
 
-void IarToolChain::addToEnvironment(Environment &env) const
+void IarToolchain::addToEnvironment(Environment &env) const
 {
     if (!compilerCommand().isEmpty())
         env.prependOrSetPath(compilerCommand().parentDir());
 }
 
-std::unique_ptr<ToolchainConfigWidget> IarToolChain::createConfigurationWidget()
+std::unique_ptr<ToolchainConfigWidget> IarToolchain::createConfigurationWidget()
 {
-    return std::make_unique<IarToolChainConfigWidget>(this);
+    return std::make_unique<IarToolchainConfigWidget>(this);
 }
 
-bool IarToolChain::operator==(const Toolchain &other) const
+bool IarToolchain::operator==(const Toolchain &other) const
 {
     if (!Toolchain::operator==(other))
         return false;
 
-    const auto customTc = static_cast<const IarToolChain *>(&other);
+    const auto customTc = static_cast<const IarToolchain *>(&other);
     return compilerCommand() == customTc->compilerCommand()
             && m_extraCodeModelFlags() == customTc->m_extraCodeModelFlags();
 }
@@ -416,7 +416,7 @@ public:
         setSupportedToolchainType(Constants::IAREW_TOOLCHAIN_TYPEID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
                                ProjectExplorer::Constants::CXX_LANGUAGE_ID});
-        setToolchainConstructor([] { return new IarToolChain; });
+        setToolchainConstructor([] { return new IarToolchain; });
         setUserCreatable(true);
     }
 
@@ -429,9 +429,9 @@ private:
     Toolchains autoDetectToolchain(const Candidate &candidate, Id languageId) const;
 };
 
-void setupIarToolChain()
+void setupIarToolchain()
 {
-    static IarToolchainFactory theIarToolChainFactory;
+    static IarToolchainFactory theIarToolchainFactory;
 }
 
 Toolchains IarToolchainFactory::autoDetect(const ToolchainDetector &detector) const
@@ -550,7 +550,7 @@ Toolchains IarToolchainFactory::autoDetectToolchain(const Candidate &candidate,
     }
     const Abi abi = guessAbi(macros);
 
-    const auto tc = new IarToolChain;
+    const auto tc = new IarToolchain;
     tc->setDetection(Toolchain::AutoDetection);
     tc->setLanguage(languageId);
     tc->setCompilerCommand(candidate.compilerPath);
@@ -563,9 +563,9 @@ Toolchains IarToolchainFactory::autoDetectToolchain(const Candidate &candidate,
     return {tc};
 }
 
-// IarToolChainConfigWidget
+// IarToolchainConfigWidget
 
-IarToolChainConfigWidget::IarToolChainConfigWidget(IarToolChain *tc) :
+IarToolchainConfigWidget::IarToolchainConfigWidget(IarToolchain *tc) :
     ToolchainConfigWidget(tc),
     m_compilerCommand(new PathChooser),
     m_abiWidget(new AbiWidget)
@@ -584,19 +584,19 @@ IarToolChainConfigWidget::IarToolChainConfigWidget(IarToolChain *tc) :
     setFromToolchain();
 
     connect(m_compilerCommand, &PathChooser::rawPathChanged,
-            this, &IarToolChainConfigWidget::handleCompilerCommandChange);
+            this, &IarToolchainConfigWidget::handleCompilerCommandChange);
     connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished,
-            this, &IarToolChainConfigWidget::handlePlatformCodeGenFlagsChange);
+            this, &IarToolchainConfigWidget::handlePlatformCodeGenFlagsChange);
     connect(m_abiWidget, &AbiWidget::abiChanged,
             this, &ToolchainConfigWidget::dirty);
 }
 
-void IarToolChainConfigWidget::applyImpl()
+void IarToolchainConfigWidget::applyImpl()
 {
     if (toolChain()->isAutoDetected())
         return;
 
-    const auto tc = static_cast<IarToolChain *>(toolChain());
+    const auto tc = static_cast<IarToolchain *>(toolChain());
     const QString displayName = tc->displayName();
     tc->setCompilerCommand(m_compilerCommand->filePath());
 
@@ -614,26 +614,26 @@ void IarToolChainConfigWidget::applyImpl()
     setFromToolchain();
 }
 
-bool IarToolChainConfigWidget::isDirtyImpl() const
+bool IarToolchainConfigWidget::isDirtyImpl() const
 {
-    const auto tc = static_cast<IarToolChain *>(toolChain());
+    const auto tc = static_cast<IarToolchain *>(toolChain());
     return m_compilerCommand->filePath() != tc->compilerCommand()
             || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
             || m_abiWidget->currentAbi() != tc->targetAbi()
             ;
 }
 
-void IarToolChainConfigWidget::makeReadOnlyImpl()
+void IarToolchainConfigWidget::makeReadOnlyImpl()
 {
     m_compilerCommand->setReadOnly(true);
     m_platformCodeGenFlagsLineEdit->setEnabled(false);
     m_abiWidget->setEnabled(false);
 }
 
-void IarToolChainConfigWidget::setFromToolchain()
+void IarToolchainConfigWidget::setFromToolchain()
 {
     const QSignalBlocker blocker(this);
-    const auto tc = static_cast<IarToolChain *>(toolChain());
+    const auto tc = static_cast<IarToolchain *>(toolChain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
     m_abiWidget->setAbis({}, tc->targetAbi());
@@ -641,7 +641,7 @@ void IarToolChainConfigWidget::setFromToolchain()
     m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected());
 }
 
-void IarToolChainConfigWidget::handleCompilerCommandChange()
+void IarToolchainConfigWidget::handleCompilerCommandChange()
 {
     const FilePath compilerPath = m_compilerCommand->filePath();
     const bool haveCompiler = compilerPath.isExecutableFile();
@@ -658,7 +658,7 @@ void IarToolChainConfigWidget::handleCompilerCommandChange()
     emit dirty();
 }
 
-void IarToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
+void IarToolchainConfigWidget::handlePlatformCodeGenFlagsChange()
 {
     const QString str1 = m_platformCodeGenFlagsLineEdit->text();
     const QString str2 = ProcessArgs::joinArgs(splitString(str1));

src/plugins/baremetal/iarewtoolchain.h

@@ -5,6 +5,6 @@
 
 namespace BareMetal::Internal {
 
-void setupIarToolChain();
+void setupIarToolchain();
 
 } // BareMetal::Internal

src/plugins/baremetal/keiltoolchain.cpp

@@ -393,20 +393,20 @@ static void addDefaultCpuArgs(const FilePath &compiler, QStringList &extraArgs)
 
 // KeilToolchain
 
-class KeilToolChain;
+class KeilToolchain;
 
-class KeilToolChainConfigWidget final : public ToolchainConfigWidget
+class KeilToolchainConfigWidget final : public ToolchainConfigWidget
 {
 public:
-    explicit KeilToolChainConfigWidget(KeilToolChain *tc);
+    explicit KeilToolchainConfigWidget(KeilToolchain *tc);
 
 private:
     void applyImpl() final;
-    void discardImpl() final { setFromToolChain(); }
+    void discardImpl() final { setFromToolchain(); }
     bool isDirtyImpl() const final;
     void makeReadOnlyImpl() final;
 
-    void setFromToolChain();
+    void setFromToolchain();
     void handleCompilerCommandChange();
     void handlePlatformCodeGenFlagsChange();
 
@@ -416,12 +416,12 @@ private:
     Macros m_macros;
 };
 
-// KeilToolChain
+// KeilToolchain
 
-class KeilToolChain final : public Toolchain
+class KeilToolchain final : public Toolchain
 {
 public:
-    KeilToolChain() :
+    KeilToolchain() :
         Toolchain(Constants::KEIL_TOOLCHAIN_TYPEID)
     {
         setTypeDisplayName(Tr::tr("KEIL"));
@@ -430,7 +430,7 @@ public:
 
         m_extraCodeModelFlags.setSettingsKey("PlatformCodeGenFlags");
         connect(&m_extraCodeModelFlags, &BaseAspect::changed,
-                this, &KeilToolChain::toolChainUpdated);
+                this, &KeilToolchain::toolChainUpdated);
     }
 
     MacroInspectionRunner createMacroInspectionRunner() const final;
@@ -455,10 +455,10 @@ private:
     StringListAspect m_extraCodeModelFlags{this};
 
     friend class KeilToolchainFactory;
-    friend class KeilToolChainConfigWidget;
+    friend class KeilToolchainConfigWidget;
 };
 
-Toolchain::MacroInspectionRunner KeilToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner KeilToolchain::createMacroInspectionRunner() const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
@@ -480,18 +480,18 @@ Toolchain::MacroInspectionRunner KeilToolChain::createMacroInspectionRunner() co
     };
 }
 
-Utils::LanguageExtensions KeilToolChain::languageExtensions(const QStringList &) const
+Utils::LanguageExtensions KeilToolchain::languageExtensions(const QStringList &) const
 {
     return LanguageExtension::None;
 }
 
-WarningFlags KeilToolChain::warningFlags(const QStringList &cxxflags) const
+WarningFlags KeilToolchain::warningFlags(const QStringList &cxxflags) const
 {
     Q_UNUSED(cxxflags)
     return WarningFlags::Default;
 }
 
-Toolchain::BuiltInHeaderPathsRunner KeilToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner KeilToolchain::createBuiltInHeaderPathsRunner(
         const Environment &) const
 {
     const FilePath compiler = compilerCommand();
@@ -509,29 +509,29 @@ Toolchain::BuiltInHeaderPathsRunner KeilToolChain::createBuiltInHeaderPathsRunne
     };
 }
 
-void KeilToolChain::addToEnvironment(Environment &env) const
+void KeilToolchain::addToEnvironment(Environment &env) const
 {
     if (!compilerCommand().isEmpty())
         env.prependOrSetPath(compilerCommand().parentDir());
 }
 
-std::unique_ptr<ToolchainConfigWidget> KeilToolChain::createConfigurationWidget()
+std::unique_ptr<ToolchainConfigWidget> KeilToolchain::createConfigurationWidget()
 {
-    return std::make_unique<KeilToolChainConfigWidget>(this);
+    return std::make_unique<KeilToolchainConfigWidget>(this);
 }
 
-bool KeilToolChain::operator ==(const Toolchain &other) const
+bool KeilToolchain::operator ==(const Toolchain &other) const
 {
     if (!Toolchain::operator ==(other))
         return false;
 
-    const auto customTc = static_cast<const KeilToolChain *>(&other);
+    const auto customTc = static_cast<const KeilToolchain *>(&other);
     return compilerCommand() == customTc->compilerCommand()
             && targetAbi() == customTc->targetAbi()
             && m_extraCodeModelFlags() == customTc->m_extraCodeModelFlags();
 }
 
-QStringList KeilToolChain::extraCodeModelFlags() const
+QStringList KeilToolchain::extraCodeModelFlags() const
 {
     return m_extraCodeModelFlags();
 }
@@ -547,7 +547,7 @@ public:
         setSupportedToolchainType(Constants::KEIL_TOOLCHAIN_TYPEID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID,
                                ProjectExplorer::Constants::CXX_LANGUAGE_ID});
-        setToolchainConstructor([] { return new KeilToolChain; });
+        setToolchainConstructor([] { return new KeilToolchain; });
         setUserCreatable(true);
     }
 
@@ -560,9 +560,9 @@ private:
             const Candidate &candidate, Utils::Id language) const;
 };
 
-void setupKeilToolChain()
+void setupKeilToolchain()
 {
-    static KeilToolchainFactory theKeilToolChainFactory;
+    static KeilToolchainFactory theKeilToolchainFactory;
 }
 
 // Parse the 'tools.ini' file to fetch a toolchain version.
@@ -709,7 +709,7 @@ Toolchains KeilToolchainFactory::autoDetectToolchain(const Candidate &candidate,
         return {};
     }
 
-    const auto tc = new KeilToolChain;
+    const auto tc = new KeilToolchain;
     tc->setDetection(Toolchain::AutoDetection);
     tc->setLanguage(language);
     tc->setCompilerCommand(candidate.compilerPath);
@@ -724,7 +724,7 @@ Toolchains KeilToolchainFactory::autoDetectToolchain(const Candidate &candidate,
 
 // KeilToolchainConfigWidget
 
-KeilToolChainConfigWidget::KeilToolChainConfigWidget(KeilToolChain *tc) :
+KeilToolchainConfigWidget::KeilToolchainConfigWidget(KeilToolchain *tc) :
     ToolchainConfigWidget(tc),
     m_compilerCommand(new PathChooser),
     m_abiWidget(new AbiWidget)
@@ -740,22 +740,22 @@ KeilToolChainConfigWidget::KeilToolChainConfigWidget(KeilToolChain *tc) :
     m_abiWidget->setEnabled(false);
 
     addErrorLabel();
-    setFromToolChain();
+    setFromToolchain();
 
     connect(m_compilerCommand, &PathChooser::rawPathChanged,
-            this, &KeilToolChainConfigWidget::handleCompilerCommandChange);
+            this, &KeilToolchainConfigWidget::handleCompilerCommandChange);
     connect(m_platformCodeGenFlagsLineEdit, &QLineEdit::editingFinished,
-            this, &KeilToolChainConfigWidget::handlePlatformCodeGenFlagsChange);
+            this, &KeilToolchainConfigWidget::handlePlatformCodeGenFlagsChange);
     connect(m_abiWidget, &AbiWidget::abiChanged,
             this, &ToolchainConfigWidget::dirty);
 }
 
-void KeilToolChainConfigWidget::applyImpl()
+void KeilToolchainConfigWidget::applyImpl()
 {
     if (toolChain()->isAutoDetected())
         return;
 
-    const auto tc = static_cast<KeilToolChain *>(toolChain());
+    const auto tc = static_cast<KeilToolchain *>(toolChain());
     const QString displayName = tc->displayName();
     tc->setCompilerCommand(m_compilerCommand->filePath());
     tc->m_extraCodeModelFlags.setValue(splitString(m_platformCodeGenFlagsLineEdit->text()));
@@ -768,29 +768,29 @@ void KeilToolChainConfigWidget::applyImpl()
     const auto languageVersion = Toolchain::languageVersion(tc->language(), m_macros);
     tc->predefinedMacrosCache()->insert({}, {m_macros, languageVersion});
 
-    setFromToolChain();
+    setFromToolchain();
 }
 
-bool KeilToolChainConfigWidget::isDirtyImpl() const
+bool KeilToolchainConfigWidget::isDirtyImpl() const
 {
-    const auto tc = static_cast<KeilToolChain *>(toolChain());
+    const auto tc = static_cast<KeilToolchain *>(toolChain());
     return m_compilerCommand->filePath() != tc->compilerCommand()
             || m_platformCodeGenFlagsLineEdit->text() != ProcessArgs::joinArgs(tc->extraCodeModelFlags())
             || m_abiWidget->currentAbi() != tc->targetAbi()
             ;
 }
 
-void KeilToolChainConfigWidget::makeReadOnlyImpl()
+void KeilToolchainConfigWidget::makeReadOnlyImpl()
 {
     m_compilerCommand->setReadOnly(true);
     m_platformCodeGenFlagsLineEdit->setEnabled(false);
     m_abiWidget->setEnabled(false);
 }
 
-void KeilToolChainConfigWidget::setFromToolChain()
+void KeilToolchainConfigWidget::setFromToolchain()
 {
     const QSignalBlocker blocker(this);
-    const auto tc = static_cast<KeilToolChain *>(toolChain());
+    const auto tc = static_cast<KeilToolchain *>(toolChain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_platformCodeGenFlagsLineEdit->setText(ProcessArgs::joinArgs(tc->extraCodeModelFlags()));
     m_abiWidget->setAbis({}, tc->targetAbi());
@@ -798,7 +798,7 @@ void KeilToolChainConfigWidget::setFromToolChain()
     m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected());
 }
 
-void KeilToolChainConfigWidget::handleCompilerCommandChange()
+void KeilToolchainConfigWidget::handleCompilerCommandChange()
 {
     const FilePath compilerPath = m_compilerCommand->filePath();
     const bool haveCompiler = compilerPath.isExecutableFile();
@@ -818,7 +818,7 @@ void KeilToolChainConfigWidget::handleCompilerCommandChange()
     emit dirty();
 }
 
-void KeilToolChainConfigWidget::handlePlatformCodeGenFlagsChange()
+void KeilToolchainConfigWidget::handlePlatformCodeGenFlagsChange()
 {
     const QString str1 = m_platformCodeGenFlagsLineEdit->text();
     const QString str2 = ProcessArgs::joinArgs(splitString(str1));

src/plugins/baremetal/keiltoolchain.h

@@ -5,6 +5,6 @@
 
 namespace BareMetal::Internal {
 
-void setupKeilToolChain();
+void setupKeilToolchain();
 
 } // BareMetal::Internal

src/plugins/baremetal/sdcctoolchain.cpp

@@ -174,14 +174,14 @@ static FilePath compilerPathFromEnvironment(const QString &compilerName)
     return systemEnvironment.searchInPath(compilerName);
 }
 
-// SdccToolChainConfigWidget
+// SdccToolchainConfigWidget
 
-class SdccToolChain;
+class SdccToolchain;
 
-class SdccToolChainConfigWidget final : public ToolchainConfigWidget
+class SdccToolchainConfigWidget final : public ToolchainConfigWidget
 {
 public:
-    explicit SdccToolChainConfigWidget(SdccToolChain *tc);
+    explicit SdccToolchainConfigWidget(SdccToolchain *tc);
 
 private:
     void applyImpl() final;
@@ -197,12 +197,12 @@ private:
     Macros m_macros;
 };
 
-// SdccToolChain
+// SdccToolchain
 
-class SdccToolChain final : public Toolchain
+class SdccToolchain final : public Toolchain
 {
 public:
-    SdccToolChain() : Toolchain(Constants::SDCC_TOOLCHAIN_TYPEID)
+    SdccToolchain() : Toolchain(Constants::SDCC_TOOLCHAIN_TYPEID)
     {
         setTypeDisplayName(Tr::tr("SDCC"));
         setTargetAbiKey("TargetAbi");
@@ -226,10 +226,10 @@ public:
 
 private:
     friend class SdccToolchainFactory;
-    friend class SdccToolChainConfigWidget;
+    friend class SdccToolchainConfigWidget;
 };
 
-Toolchain::MacroInspectionRunner SdccToolChain::createMacroInspectionRunner() const
+Toolchain::MacroInspectionRunner SdccToolchain::createMacroInspectionRunner() const
 {
     Environment env = Environment::systemEnvironment();
     addToEnvironment(env);
@@ -252,18 +252,18 @@ Toolchain::MacroInspectionRunner SdccToolChain::createMacroInspectionRunner() co
     };
 }
 
-LanguageExtensions SdccToolChain::languageExtensions(const QStringList &) const
+LanguageExtensions SdccToolchain::languageExtensions(const QStringList &) const
 {
     return LanguageExtension::None;
 }
 
-WarningFlags SdccToolChain::warningFlags(const QStringList &cxxflags) const
+WarningFlags SdccToolchain::warningFlags(const QStringList &cxxflags) const
 {
     Q_UNUSED(cxxflags)
     return WarningFlags::Default;
 }
 
-Toolchain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunner(
+Toolchain::BuiltInHeaderPathsRunner SdccToolchain::createBuiltInHeaderPathsRunner(
         const Environment &) const
 {
     Environment env = Environment::systemEnvironment();
@@ -277,23 +277,23 @@ Toolchain::BuiltInHeaderPathsRunner SdccToolChain::createBuiltInHeaderPathsRunne
     };
 }
 
-void SdccToolChain::addToEnvironment(Environment &env) const
+void SdccToolchain::addToEnvironment(Environment &env) const
 {
     if (!compilerCommand().isEmpty())
         env.prependOrSetPath(compilerCommand().parentDir());
 }
 
-std::unique_ptr<ToolchainConfigWidget> SdccToolChain::createConfigurationWidget()
+std::unique_ptr<ToolchainConfigWidget> SdccToolchain::createConfigurationWidget()
 {
-    return std::make_unique<SdccToolChainConfigWidget>(this);
+    return std::make_unique<SdccToolchainConfigWidget>(this);
 }
 
-bool SdccToolChain::operator==(const Toolchain &other) const
+bool SdccToolchain::operator==(const Toolchain &other) const
 {
     if (!Toolchain::operator==(other))
         return false;
 
-    const auto customTc = static_cast<const SdccToolChain *>(&other);
+    const auto customTc = static_cast<const SdccToolchain *>(&other);
     return compilerCommand() == customTc->compilerCommand()
             && targetAbi() == customTc->targetAbi();
 }
@@ -308,7 +308,7 @@ public:
         setDisplayName(Tr::tr("SDCC"));
         setSupportedToolchainType(Constants::SDCC_TOOLCHAIN_TYPEID);
         setSupportedLanguages({ProjectExplorer::Constants::C_LANGUAGE_ID});
-        setToolchainConstructor([] { return new SdccToolChain; });
+        setToolchainConstructor([] { return new SdccToolchain; });
         setUserCreatable(true);
     }
 
@@ -320,9 +320,9 @@ private:
     Toolchains autoDetectToolchain(const Candidate &candidate, Id language) const;
 };
 
-void setupSdccToolChain()
+void setupSdccToolchain()
 {
-    static SdccToolchainFactory theSdccToolChainFactory;
+    static SdccToolchainFactory theSdccToolchainFactory;
 }
 
 Toolchains SdccToolchainFactory::autoDetect(const ToolchainDetector &detector) const
@@ -428,7 +428,7 @@ Toolchains SdccToolchainFactory::autoDetectToolchain(const Candidate &candidate,
         if (knownAbi.architecture() != abi.architecture())
             continue;
 
-        const auto tc = new SdccToolChain;
+        const auto tc = new SdccToolchain;
         tc->setDetection(Toolchain::AutoDetection);
         tc->setLanguage(language);
         tc->setCompilerCommand(candidate.compilerPath);
@@ -445,9 +445,9 @@ Toolchains SdccToolchainFactory::autoDetectToolchain(const Candidate &candidate,
     return tcs;
 }
 
-// SdccToolChainConfigWidget
+// SdccToolchainConfigWidget
 
-SdccToolChainConfigWidget::SdccToolChainConfigWidget(SdccToolChain *tc) :
+SdccToolchainConfigWidget::SdccToolchainConfigWidget(SdccToolchain *tc) :
     ToolchainConfigWidget(tc),
     m_compilerCommand(new PathChooser),
     m_abiWidget(new AbiWidget)
@@ -463,17 +463,17 @@ SdccToolChainConfigWidget::SdccToolChainConfigWidget(SdccToolChain *tc) :
     setFromToolchain();
 
     connect(m_compilerCommand, &PathChooser::rawPathChanged,
-            this, &SdccToolChainConfigWidget::handleCompilerCommandChange);
+            this, &SdccToolchainConfigWidget::handleCompilerCommandChange);
     connect(m_abiWidget, &AbiWidget::abiChanged,
             this, &ToolchainConfigWidget::dirty);
 }
 
-void SdccToolChainConfigWidget::applyImpl()
+void SdccToolchainConfigWidget::applyImpl()
 {
     if (toolChain()->isAutoDetected())
         return;
 
-    const auto tc = static_cast<SdccToolChain *>(toolChain());
+    const auto tc = static_cast<SdccToolchain *>(toolChain());
     const QString displayName = tc->displayName();
     tc->setCompilerCommand(m_compilerCommand->filePath());
     tc->setTargetAbi(m_abiWidget->currentAbi());
@@ -488,31 +488,31 @@ void SdccToolChainConfigWidget::applyImpl()
     setFromToolchain();
 }
 
-bool SdccToolChainConfigWidget::isDirtyImpl() const
+bool SdccToolchainConfigWidget::isDirtyImpl() const
 {
-    const auto tc = static_cast<SdccToolChain *>(toolChain());
+    const auto tc = static_cast<SdccToolchain *>(toolChain());
     return m_compilerCommand->filePath() != tc->compilerCommand()
             || m_abiWidget->currentAbi() != tc->targetAbi()
             ;
 }
 
-void SdccToolChainConfigWidget::makeReadOnlyImpl()
+void SdccToolchainConfigWidget::makeReadOnlyImpl()
 {
     m_compilerCommand->setReadOnly(true);
     m_abiWidget->setEnabled(false);
 }
 
-void SdccToolChainConfigWidget::setFromToolchain()
+void SdccToolchainConfigWidget::setFromToolchain()
 {
     const QSignalBlocker blocker(this);
-    const auto tc = static_cast<SdccToolChain *>(toolChain());
+    const auto tc = static_cast<SdccToolchain *>(toolChain());
     m_compilerCommand->setFilePath(tc->compilerCommand());
     m_abiWidget->setAbis({}, tc->targetAbi());
     const bool haveCompiler = m_compilerCommand->filePath().isExecutableFile();
     m_abiWidget->setEnabled(haveCompiler && !tc->isAutoDetected());
 }
 
-void SdccToolChainConfigWidget::handleCompilerCommandChange()
+void SdccToolchainConfigWidget::handleCompilerCommandChange()
 {
     const FilePath compilerPath = m_compilerCommand->filePath();
     const bool haveCompiler = compilerPath.isExecutableFile();

src/plugins/baremetal/sdcctoolchain.h

@@ -5,6 +5,6 @@
 
 namespace BareMetal::Internal {
 
-void setupSdccToolChain();
+void setupSdccToolchain();
 
 } // BareMetal::Internal

src/plugins/cmakeprojectmanager/cmakeprojectimporter.cpp

@@ -996,7 +996,7 @@ Kit *CMakeProjectImporter::createKit(void *directoryData) const
         SysRootKitAspect::setSysRoot(k, data->sysroot);
 
         for (const ToolchainDescription &cmtcd : data->toolchains) {
-            const ToolChainData tcd = findOrCreateToolChains(cmtcd);
+            const ToolchainData tcd = findOrCreateToolChains(cmtcd);
             QTC_ASSERT(!tcd.tcs.isEmpty(), continue);
 
             if (tcd.areTemporary) {

src/plugins/cppeditor/compileroptionsbuilder_test.cpp

@@ -35,7 +35,7 @@ public:
         rpp.setQtVersion(Utils::QtMajorVersion::Qt5);
         rpp.setHeaderPaths(headerPaths);
         rpp.setConfigFileName(projectConfigFile);
-        ToolChainInfo tcInfo;
+        ToolchainInfo tcInfo;
         tcInfo.type = toolchainType;
         tcInfo.targetTriple = targetTriple;
         tcInfo.abi = Abi::fromString(targetTriple);

src/plugins/cppeditor/cppmodelmanager.cpp

@@ -1981,7 +1981,7 @@ void CppModelManager::onCoreAboutToClose()
 
 void CppModelManager::setupFallbackProjectPart()
 {
-    ToolChainInfo tcInfo;
+    ToolchainInfo tcInfo;
     RawProjectPart rpp;
     rpp.setMacros(definedMacros());
     rpp.setHeaderPaths(headerPaths());
@@ -2001,7 +2001,7 @@ void CppModelManager::setupFallbackProjectPart()
         if (sysroot.isEmpty())
             sysroot = FilePath::fromString(defaultTc->sysRoot());
         Utils::Environment env = defaultKit->buildEnvironment();
-        tcInfo = ToolChainInfo(defaultTc, sysroot, env);
+        tcInfo = ToolchainInfo(defaultTc, sysroot, env);
         const auto macroInspectionWrapper = [runner = tcInfo.macroInspectionRunner](
                 const QStringList &flags) {
             Toolchain::MacroInspectionReport report = runner(flags);

src/plugins/cppeditor/cppprojectinfogenerator.cpp

@@ -121,7 +121,7 @@ ProjectPart::ConstPtr ProjectInfoGenerator::createProjectPart(
         LanguageExtensions languageExtensions)
 {
     RawProjectPartFlags flags;
-    ToolChainInfo tcInfo;
+    ToolchainInfo tcInfo;
     if (language == Language::C) {
         flags = rawProjectPart.flagsForC;
         tcInfo = m_projectUpdateInfo.cToolchainInfo;

src/plugins/cppeditor/projectinfo_test.cpp

@@ -65,7 +65,7 @@ public:
     static QList<ProjectPart::ConstPtr> createCAndCxxProjectParts()
     {
         QList<ProjectPart::ConstPtr> projectParts;
-        ToolChainInfo tcInfo;
+        ToolchainInfo tcInfo;
 
         // Create project part for C
         tcInfo.macroInspectionRunner = [](const QStringList &) {
@@ -484,7 +484,7 @@ public:
     {
         RawProjectPart rpp;
         rpp.setHeaderPaths(headerPaths);
-        ToolChainInfo tcInfo;
+        ToolchainInfo tcInfo;
         tcInfo.type = toolchainType;
         tcInfo.targetTriple = targetTriple;
         tcInfo.installDir = toolchainInstallDir;

src/plugins/cppeditor/projectpart.cpp

@@ -69,7 +69,7 @@ static Macros getProjectMacros(const RawProjectPart &rpp)
 
 static HeaderPaths getHeaderPaths(const RawProjectPart &rpp,
                                   const RawProjectPartFlags &flags,
-                                  const ProjectExplorer::ToolChainInfo &tcInfo)
+                                  const ProjectExplorer::ToolchainInfo &tcInfo)
 {
     HeaderPaths headerPaths;
 
@@ -97,7 +97,7 @@ static HeaderPaths getHeaderPaths(const RawProjectPart &rpp,
 }
 
 static Toolchain::MacroInspectionReport getToolchainMacros(
-        const RawProjectPartFlags &flags, const ToolChainInfo &tcInfo, Utils::Language language)
+        const RawProjectPartFlags &flags, const ToolchainInfo &tcInfo, Utils::Language language)
 {
     Toolchain::MacroInspectionReport report;
     if (tcInfo.macroInspectionRunner) {
@@ -122,7 +122,7 @@ ProjectPart::ProjectPart(const Utils::FilePath &topLevelProject,
                          Utils::Language language,
                          Utils::LanguageExtensions languageExtensions,
                          const RawProjectPartFlags &flags,
-                         const ToolChainInfo &tcInfo)
+                         const ToolchainInfo &tcInfo)
     : topLevelProject(topLevelProject),
       displayName(displayName),
       projectFile(rpp.projectFile),

src/plugins/cppeditor/projectpart.h

@@ -38,7 +38,7 @@ public:
                       Utils::Language language = Utils::Language::Cxx,
                       Utils::LanguageExtensions languageExtensions = {},
                       const ProjectExplorer::RawProjectPartFlags &flags = {},
-                      const ProjectExplorer::ToolChainInfo &tcInfo = {})
+                      const ProjectExplorer::ToolchainInfo &tcInfo = {})
     {
         return ConstPtr(new ProjectPart(topLevelProject, rpp, displayName, files, language,
                                    languageExtensions, flags, tcInfo));
@@ -106,7 +106,7 @@ private:
                 Utils::Language language,
                 Utils::LanguageExtensions languageExtensions,
                 const ProjectExplorer::RawProjectPartFlags &flags,
-                const ProjectExplorer::ToolChainInfo &tcInfo);
+                const ProjectExplorer::ToolchainInfo &tcInfo);
 
     CPlusPlus::LanguageFeatures deriveLanguageFeatures() const;
 

src/plugins/projectexplorer/projectimporter.cpp

@@ -366,9 +366,9 @@ 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;
+    ProjectImporter::ToolchainData data;
 
     for (ToolchainFactory *factory : ToolchainFactory::allToolchainFactories()) {
         data.tcs = factory->detectForImport(tcd);
@@ -385,10 +385,10 @@ static ProjectImporter::ToolChainData createToolChains(const ToolchainDescriptio
     return data;
 }
 
-ProjectImporter::ToolChainData
+ProjectImporter::ToolchainData
 ProjectImporter::findOrCreateToolChains(const ToolchainDescription &tcd) const
 {
-    ToolChainData result;
+    ToolchainData result;
     result.tcs = ToolchainManager::toolchains([&tcd](const Toolchain *tc) {
         return tc->language() == tcd.language && tc->matchesCompilerCommand(tcd.compilerPath);
     });

src/plugins/projectexplorer/projectimporter.h

@@ -22,7 +22,7 @@ class PROJECTEXPLORER_EXPORT ProjectImporter : public QObject
 {
     Q_OBJECT
 public:
-    struct ToolChainData {
+    struct ToolchainData {
         QList<Toolchain *> tcs;
         bool areTemporary = false;
     };
@@ -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/rawprojectpart.cpp

@@ -155,7 +155,7 @@ bool KitInfo::isValid() const
     return kit;
 }
 
-ToolChainInfo::ToolChainInfo(const Toolchain *toolChain,
+ToolchainInfo::ToolchainInfo(const Toolchain *toolChain,
                              const Utils::FilePath &sysRootPath,
                              const Utils::Environment &env)
 {
@@ -185,8 +185,8 @@ ProjectUpdateInfo::ProjectUpdateInfo(Project *project,
                                      const RppGenerator &rppGenerator)
     : rawProjectParts(rawProjectParts)
     , rppGenerator(rppGenerator)
-    , cToolchainInfo(ToolChainInfo(kitInfo.cToolchain, kitInfo.sysRootPath, env))
-    , cxxToolchainInfo(ToolChainInfo(kitInfo.cxxToolchain, kitInfo.sysRootPath, env))
+    , cToolchainInfo(ToolchainInfo(kitInfo.cToolchain, kitInfo.sysRootPath, env))
+    , cxxToolchainInfo(ToolchainInfo(kitInfo.cxxToolchain, kitInfo.sysRootPath, env))
 {
     if (project) {
         projectName = project->displayName();

src/plugins/projectexplorer/rawprojectpart.h

@@ -127,11 +127,11 @@ public:
     Utils::FilePath sysRootPath;
 };
 
-class PROJECTEXPLORER_EXPORT ToolChainInfo
+class PROJECTEXPLORER_EXPORT ToolchainInfo
 {
 public:
-    ToolChainInfo() = default;
-    ToolChainInfo(const ProjectExplorer::Toolchain *toolChain,
+    ToolchainInfo() = default;
+    ToolchainInfo(const ProjectExplorer::Toolchain *toolChain,
                   const Utils::FilePath &sysRootPath,
                   const Utils::Environment &env);
 
@@ -171,8 +171,8 @@ public:
     RawProjectParts rawProjectParts;
     RppGenerator rppGenerator;
 
-    ToolChainInfo cToolchainInfo;
-    ToolChainInfo cxxToolchainInfo;
+    ToolchainInfo cToolchainInfo;
+    ToolchainInfo cxxToolchainInfo;
 };
 
 } // namespace ProjectExplorer

src/plugins/qbsprojectmanager/qbsprojectimporter.cpp

@@ -183,12 +183,12 @@ Kit *QbsProjectImporter::createKit(void *directoryData) const
         qtVersionData = findOrCreateQtVersion(qmakeFilePath);
     }
     return createTemporaryKit(qtVersionData,[this, bgData](Kit *k) -> void {
-        QList<ToolChainData> tcData;
+        QList<ToolchainData> tcData;
         if (!bgData->cxxCompilerPath.isEmpty())
             tcData << findOrCreateToolChains({bgData->cxxCompilerPath, PEConstants::CXX_LANGUAGE_ID});
         if (!bgData->cCompilerPath.isEmpty())
             tcData << findOrCreateToolChains({bgData->cCompilerPath, PEConstants::C_LANGUAGE_ID});
-        for (const ToolChainData &tc : std::as_const(tcData)) {
+        for (const ToolchainData &tc : std::as_const(tcData)) {
             if (!tc.tcs.isEmpty())
                 ToolchainKitAspect::setToolchain(k, tc.tcs.first());
         }