diff --git a/src/plugins/android/androidconfigurations.cpp b/src/plugins/android/androidconfigurations.cpp
index 569b07d30c9..94d23880466 100644
--- a/src/plugins/android/androidconfigurations.cpp
+++ b/src/plugins/android/androidconfigurations.cpp
@@ -499,11 +499,11 @@ FileName AndroidConfig::toolPath(const Abi &abi, const QString &ndkToolChainVers
             .arg(toolsPrefix(abi)));
 }
 
-FileName AndroidConfig::gccPath(const Abi &abi, ToolChain::Language lang,
+FileName AndroidConfig::gccPath(const Abi &abi, Core::Id lang,
                                 const QString &ndkToolChainVersion) const
 {
     const QString tool
-            = HostOsInfo::withExecutableSuffix(QString::fromLatin1(lang == ToolChain::Language::C ? "-gcc" : "-g++"));
+            = HostOsInfo::withExecutableSuffix(QString::fromLatin1(lang == Core::Id(ProjectExplorer::Constants::C_LANGUAGE_ID) ? "-gcc" : "-g++"));
     return toolPath(abi, ndkToolChainVersion).appendString(tool);
 }
 
@@ -1215,10 +1215,10 @@ static bool matchKits(const Kit *a, const Kit *b)
     if (QtSupport::QtKitInformation::qtVersion(a) != QtSupport::QtKitInformation::qtVersion(b))
         return false;
 
-    return matchToolChain(ToolChainKitInformation::toolChain(a, ToolChain::Language::Cxx),
-                          ToolChainKitInformation::toolChain(b, ToolChain::Language::Cxx))
-            && matchToolChain(ToolChainKitInformation::toolChain(a, ToolChain::Language::C),
-                              ToolChainKitInformation::toolChain(b, ToolChain::Language::C));
+    return matchToolChain(ToolChainKitInformation::toolChain(a, ProjectExplorer::Constants::CXX_LANGUAGE_ID),
+                          ToolChainKitInformation::toolChain(b, ProjectExplorer::Constants::CXX_LANGUAGE_ID))
+            && matchToolChain(ToolChainKitInformation::toolChain(a, ProjectExplorer::Constants::C_LANGUAGE_ID),
+                              ToolChainKitInformation::toolChain(b, ProjectExplorer::Constants::C_LANGUAGE_ID));
 }
 
 void AndroidConfigurations::registerNewToolChains()
@@ -1250,7 +1250,7 @@ void AndroidConfigurations::updateAutomaticKitList()
 
     // Update code for 3.0 beta, which shipped with a bug for the debugger settings
     for (Kit *k : existingKits) {
-        ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
+        ToolChain *tc = ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
         if (tc && Debugger::DebuggerKitInformation::runnable(k).executable != tc->suggestedDebugger().toString()) {
             Debugger::DebuggerItem debugger;
             debugger.setCommand(tc->suggestedDebugger());
@@ -1297,7 +1297,7 @@ void AndroidConfigurations::updateAutomaticKitList()
             return static_cast<AndroidToolChain *>(tc);
     });
     for (AndroidToolChain *tc : toolchains) {
-        if (tc->isSecondaryToolChain() || tc->language() != ToolChain::Language::Cxx)
+        if (tc->isSecondaryToolChain() || tc->language() != Core::Id(ProjectExplorer::Constants::CXX_LANGUAGE_ID))
             continue;
         const QList<AndroidToolChain *> allLanguages = Utils::filtered(toolchains,
                                                                        [tc](AndroidToolChain *otherTc) {
diff --git a/src/plugins/android/androidconfigurations.h b/src/plugins/android/androidconfigurations.h
index 9316bb3fec1..751e68d113d 100644
--- a/src/plugins/android/androidconfigurations.h
+++ b/src/plugins/android/androidconfigurations.h
@@ -126,8 +126,7 @@ public:
     Utils::FileName emulatorToolPath() const;
 
 
-    Utils::FileName gccPath(const ProjectExplorer::Abi &abi,
-                            ProjectExplorer::ToolChain::Language lang,
+    Utils::FileName gccPath(const ProjectExplorer::Abi &abi, Core::Id lang,
                             const QString &ndkToolChainVersion) const;
     Utils::FileName gdbPath(const ProjectExplorer::Abi &abi, const QString &ndkToolChainVersion) const;
 
diff --git a/src/plugins/android/androiddeployconfiguration.cpp b/src/plugins/android/androiddeployconfiguration.cpp
index af6ed218301..85d191524c8 100644
--- a/src/plugins/android/androiddeployconfiguration.cpp
+++ b/src/plugins/android/androiddeployconfiguration.cpp
@@ -31,6 +31,7 @@
 
 #include <projectexplorer/buildsteplist.h>
 #include <projectexplorer/project.h>
+#include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/target.h>
 #include <projectexplorer/toolchain.h>
 
@@ -114,7 +115,7 @@ QList<Core::Id> AndroidDeployConfigurationFactory::availableCreationIds(Target *
     if (!parent->project()->supportsKit(parent->kit()))
         return ids;
 
-    ToolChain *tc = ToolChainKitInformation::toolChain(parent->kit(), ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(parent->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     if (!tc || tc->targetAbi().osFlavor() != Abi::AndroidLinuxFlavor)
         return ids;
diff --git a/src/plugins/android/androiddeployqtstep.cpp b/src/plugins/android/androiddeployqtstep.cpp
index 5212b131925..7c77633ad09 100644
--- a/src/plugins/android/androiddeployqtstep.cpp
+++ b/src/plugins/android/androiddeployqtstep.cpp
@@ -178,7 +178,7 @@ bool AndroidDeployQtStep::init(QList<const BuildStep *> &earlierSteps)
     m_libdir = QLatin1String("lib");
     if (info.cpuAbi.contains(QLatin1String("arm64-v8a")) ||
             info.cpuAbi.contains(QLatin1String("x86_64"))) {
-        ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+        ProjectExplorer::ToolChain *tc = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
         if (tc && tc->targetAbi().wordWidth() == 64) {
             m_appProcessBinaries << QLatin1String("/system/bin/app_process64");
             m_libdir += QLatin1String("64");
diff --git a/src/plugins/android/androidgdbserverkitinformation.cpp b/src/plugins/android/androidgdbserverkitinformation.cpp
index 09cc13704d7..cb0ad4d4014 100644
--- a/src/plugins/android/androidgdbserverkitinformation.cpp
+++ b/src/plugins/android/androidgdbserverkitinformation.cpp
@@ -38,6 +38,8 @@
 #include <QVBoxLayout>
 #include <QFormLayout>
 
+#include <projectexplorer/projectexplorerconstants.h>
+
 #include <qtsupport/baseqtversion.h>
 #include <qtsupport/qtkitinformation.h>
 
@@ -82,7 +84,7 @@ Core::Id AndroidGdbServerKitInformation::id()
 bool AndroidGdbServerKitInformation::isAndroidKit(const Kit *kit)
 {
     QtSupport::BaseQtVersion *qt = QtSupport::QtKitInformation::qtVersion(kit);
-    ToolChain *tc = ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (qt && tc)
         return qt->type() == QLatin1String(Constants::ANDROIDQT)
                 && tc->typeId() == Constants::ANDROID_TOOLCHAIN_ID;
@@ -102,7 +104,7 @@ void AndroidGdbServerKitInformation::setGdbSever(Kit *kit, const FileName &gdbSe
 
 FileName AndroidGdbServerKitInformation::autoDetect(const Kit *kit)
 {
-    ToolChain *tc = ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!tc || tc->typeId() != Constants::ANDROID_TOOLCHAIN_ID)
         return FileName();
     auto atc = static_cast<AndroidToolChain *>(tc);
diff --git a/src/plugins/android/androidsettingswidget.cpp b/src/plugins/android/androidsettingswidget.cpp
index 8a7d5d302eb..67afe1dbec1 100644
--- a/src/plugins/android/androidsettingswidget.cpp
+++ b/src/plugins/android/androidsettingswidget.cpp
@@ -39,6 +39,7 @@
 #include <projectexplorer/toolchainmanager.h>
 #include <projectexplorer/kitmanager.h>
 #include <projectexplorer/kitinformation.h>
+#include <projectexplorer/projectexplorerconstants.h>
 #include <qtsupport/qtkitinformation.h>
 #include <qtsupport/qtversionmanager.h>
 
@@ -314,7 +315,7 @@ void AndroidSettingsWidget::check(AndroidSettingsWidget::Mode mode)
             // Check for a gdb with a broken python
             QStringList gdbPaths;
             foreach (const AndroidToolChainFactory::AndroidToolChainInformation &ati, compilerPaths) {
-                if (ati.language == ProjectExplorer::ToolChain::Language::C)
+                if (ati.language == Core::Id(ProjectExplorer::Constants::C_LANGUAGE_ID))
                     continue;
                 // we only check the arm gdbs, that's indicative enough
                 if (ati.abi.architecture() != ProjectExplorer::Abi::ArmArchitecture)
@@ -332,7 +333,7 @@ void AndroidSettingsWidget::check(AndroidSettingsWidget::Mode mode)
             // See if we have qt versions for those toolchains
             QSet<ProjectExplorer::Abi> toolchainsForAbi;
             foreach (const AndroidToolChainFactory::AndroidToolChainInformation &ati, compilerPaths) {
-                if (ati.language == ProjectExplorer::ToolChain::Language::Cxx)
+                if (ati.language == Core::Id(ProjectExplorer::Constants::CXX_LANGUAGE_ID))
                     toolchainsForAbi.insert(ati.abi);
             }
 
diff --git a/src/plugins/android/androidtoolchain.cpp b/src/plugins/android/androidtoolchain.cpp
index 616f27f99aa..4d4c4a0c41e 100644
--- a/src/plugins/android/androidtoolchain.cpp
+++ b/src/plugins/android/androidtoolchain.cpp
@@ -63,14 +63,14 @@ static const char ANDROID_NDK_TC_VERION[] = "Qt4ProjectManager.Android.NDK_TC_VE
 QHash<Abi, QList<int> > AndroidToolChainFactory::m_newestVersionForAbi;
 FileName AndroidToolChainFactory::m_ndkLocation;
 
-AndroidToolChain::AndroidToolChain(const Abi &abi, const QString &ndkToolChainVersion, Language l, Detection d)
+AndroidToolChain::AndroidToolChain(const Abi &abi, const QString &ndkToolChainVersion, Core::Id l, Detection d)
     : GccToolChain(Constants::ANDROID_TOOLCHAIN_ID, d),
       m_ndkToolChainVersion(ndkToolChainVersion), m_secondaryToolChain(false)
 {
     setLanguage(l);
     setTargetAbi(abi);
     setDisplayName(QString::fromLatin1("Android GCC (%1, %2-%3)")
-                   .arg(ToolChain::languageDisplayName(l),
+                   .arg(ToolChainManager::displayNameOfLanguageId(l),
                         AndroidConfig::displayName(targetAbi()),
                         ndkToolChainVersion));
 }
@@ -264,9 +264,9 @@ AndroidToolChainFactory::AndroidToolChainFactory()
     setDisplayName(tr("Android GCC"));
 }
 
-QSet<ToolChain::Language> Android::Internal::AndroidToolChainFactory::supportedLanguages() const
+QSet<Core::Id> Android::Internal::AndroidToolChainFactory::supportedLanguages() const
 {
-    return { ToolChain::Language::Cxx };
+    return { ProjectExplorer::Constants::CXX_LANGUAGE_ID };
 }
 
 QList<ToolChain *> AndroidToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
@@ -303,7 +303,8 @@ QList<AndroidToolChainFactory::AndroidToolChainInformation> AndroidToolChainFact
         int idx = versionRegExp.indexIn(fileName);
         if (idx == -1)
             continue;
-        for (const ToolChain::Language lang : { ToolChain::Language::Cxx, ToolChain::Language::C }) {
+        for (const Core::Id lang : { ProjectExplorer::Constants::CXX_LANGUAGE_ID,
+                                     ProjectExplorer::Constants::C_LANGUAGE_ID }) {
             AndroidToolChainInformation ati;
             ati.language = lang;
             ati.version = fileName.mid(idx + 1);
@@ -364,7 +365,7 @@ bool AndroidToolChainFactory::versionCompareLess(QList<AndroidToolChain *> atc,
     return versionCompareLess(a, b);
 }
 
-static AndroidToolChain *findToolChain(Utils::FileName &compilerPath, ToolChain::Language lang,
+static AndroidToolChain *findToolChain(Utils::FileName &compilerPath, Core::Id lang,
                                        const QList<ToolChain *> &alreadyKnown)
 {
     return static_cast<AndroidToolChain *>(
@@ -400,7 +401,7 @@ AndroidToolChainFactory::autodetectToolChainsForNdk(const FileName &ndkPath,
         if (abi.architecture() == Abi::UnknownArchitecture) // e.g. mipsel which is not yet supported
             continue;
         QList<AndroidToolChain *> toolChainBundle;
-        for (ToolChain::Language lang : { ToolChain::Language::Cxx, ToolChain::Language::C }) {
+        for (Core::Id lang : { ProjectExplorer::Constants::CXX_LANGUAGE_ID, ProjectExplorer::Constants::C_LANGUAGE_ID }) {
             FileName compilerPath = AndroidConfigurations::currentConfig().gccPath(abi, lang, version);
 
             AndroidToolChain *tc = findToolChain(compilerPath, lang, alreadyKnown);
diff --git a/src/plugins/android/androidtoolchain.h b/src/plugins/android/androidtoolchain.h
index fecfe070fcf..4efc29ecd0a 100644
--- a/src/plugins/android/androidtoolchain.h
+++ b/src/plugins/android/androidtoolchain.h
@@ -63,7 +63,7 @@ protected:
 
 private:
     explicit AndroidToolChain(const ProjectExplorer::Abi &abi, const QString &ndkToolChainVersion,
-                              Language l, Detection d);
+                              Core::Id l, Detection d);
     AndroidToolChain();
     AndroidToolChain(const AndroidToolChain &);
 
@@ -95,7 +95,7 @@ class AndroidToolChainFactory : public ProjectExplorer::ToolChainFactory
 
 public:
     AndroidToolChainFactory();
-    QSet<ProjectExplorer::ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     QList<ProjectExplorer::ToolChain *> autoDetect(const QList<ProjectExplorer::ToolChain *> &alreadyKnown) override;
     bool canRestore(const QVariantMap &data) override;
@@ -104,7 +104,7 @@ public:
     class AndroidToolChainInformation
     {
     public:
-        ProjectExplorer::ToolChain::Language language;
+        Core::Id language;
         Utils::FileName compilerCommand;
         ProjectExplorer::Abi abi;
         QString version;
diff --git a/src/plugins/autotest/autotestunittests.cpp b/src/plugins/autotest/autotestunittests.cpp
index fc917ffdf44..3c5e8586a4e 100644
--- a/src/plugins/autotest/autotestunittests.cpp
+++ b/src/plugins/autotest/autotestunittests.cpp
@@ -69,7 +69,7 @@ void AutoTestUnitTests::initTestCase()
     else
         QSKIP("Could not figure out which Qt version is used for default kit.");
     const ToolChain * const toolchain = ToolChainKitInformation::toolChain(allKits.first(),
-                                                                           ToolChain::Language::Cxx);
+                                                                           ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!toolchain)
         QSKIP("This test requires that there is a kit with a toolchain.");
 
diff --git a/src/plugins/autotoolsprojectmanager/makestep.cpp b/src/plugins/autotoolsprojectmanager/makestep.cpp
index c929ed248b4..f3fe8ca1749 100644
--- a/src/plugins/autotoolsprojectmanager/makestep.cpp
+++ b/src/plugins/autotoolsprojectmanager/makestep.cpp
@@ -269,7 +269,7 @@ void MakeStepConfigWidget::updateDetails()
         param.setArguments(arguments);
         m_summaryText = param.summary(displayName());
     } else {
-        m_summaryText = QLatin1String("<b>") + ProjectExplorer::ToolChainKitInformation::msgNoToolChainInTarget()  + QLatin1String("</b>");
+        m_summaryText = QLatin1String("<b>") + ToolChainKitInformation::msgNoToolChainInTarget()  + QLatin1String("</b>");
     }
 
     emit updateSummary();
diff --git a/src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp b/src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp
index e6ae1404be2..78072cc903b 100644
--- a/src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp
+++ b/src/plugins/clangstaticanalyzer/clangstaticanalyzerpreconfiguredsessiontests.cpp
@@ -175,7 +175,7 @@ static QList<Target *> validTargets(Project *project)
             return false;
         }
 
-        const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx);
+        const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
         QTC_ASSERT(toolchain, return false);
         bool hasClangExecutable;
         clangExecutableFromSettings(toolchain->typeId(), &hasClangExecutable);
diff --git a/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp b/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp
index 35e060947b1..425b97b3d01 100644
--- a/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp
+++ b/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrol.cpp
@@ -85,7 +85,7 @@ ClangStaticAnalyzerRunControl::ClangStaticAnalyzerRunControl(
     QTC_ASSERT(buildConfiguration, return);
     m_environment = buildConfiguration->environment();
 
-    ToolChain *toolChain = ToolChainKitInformation::toolChain(target->kit(), ToolChain::Language::Cxx);
+    ToolChain *toolChain = ToolChainKitInformation::toolChain(target->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     QTC_ASSERT(toolChain, return);
     m_targetTriple = toolChain->originalTargetTriple();
 }
@@ -445,7 +445,7 @@ static QDebug operator<<(QDebug debug, const AnalyzeUnits &analyzeUnits)
 static Core::Id toolchainType(ProjectExplorer::RunConfiguration *runConfiguration)
 {
     QTC_ASSERT(runConfiguration, return Core::Id());
-    return ToolChainKitInformation::toolChain(runConfiguration->target()->kit(), ToolChain::Language::Cxx)->typeId();
+    return ToolChainKitInformation::toolChain(runConfiguration->target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID)->typeId();
 }
 
 static QString executableForVersionCheck(Core::Id toolchainType, const QString &executable)
diff --git a/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrolfactory.cpp b/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrolfactory.cpp
index 5ec5b8fd980..ae395bcdcf2 100644
--- a/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrolfactory.cpp
+++ b/src/plugins/clangstaticanalyzer/clangstaticanalyzerruncontrolfactory.cpp
@@ -73,7 +73,7 @@ bool ClangStaticAnalyzerRunControlFactory::canRun(RunConfiguration *runConfigura
     QTC_ASSERT(target, return false);
     Kit *kit = target->kit();
     QTC_ASSERT(kit, return false);
-    ToolChain *toolChain = ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx);
+    ToolChain *toolChain = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     return toolChain;
 }
 
diff --git a/src/plugins/clangstaticanalyzer/clangstaticanalyzerunittests.cpp b/src/plugins/clangstaticanalyzer/clangstaticanalyzerunittests.cpp
index 35119495c94..5b2681e6c93 100644
--- a/src/plugins/clangstaticanalyzer/clangstaticanalyzerunittests.cpp
+++ b/src/plugins/clangstaticanalyzer/clangstaticanalyzerunittests.cpp
@@ -62,7 +62,7 @@ void ClangStaticAnalyzerUnitTests::initTestCase()
     if (allKits.count() != 1)
         QSKIP("This test requires exactly one kit to be present");
     const ToolChain * const toolchain = ToolChainKitInformation::toolChain(allKits.first(),
-                                                                           ToolChain::Language::Cxx);
+                                                                           Constants::CXX_LANGUAGE_ID);
     if (!toolchain)
         QSKIP("This test requires that there is a kit with a toolchain.");
     bool hasClangExecutable;
diff --git a/src/plugins/cmakeprojectmanager/builddirreader.cpp b/src/plugins/cmakeprojectmanager/builddirreader.cpp
index c9b0202849b..2d0ce4c815a 100644
--- a/src/plugins/cmakeprojectmanager/builddirreader.cpp
+++ b/src/plugins/cmakeprojectmanager/builddirreader.cpp
@@ -31,6 +31,7 @@
 #include "tealeafreader.h"
 
 #include <projectexplorer/kitinformation.h>
+#include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/target.h>
 
 using namespace ProjectExplorer;
@@ -63,10 +64,10 @@ BuildDirReader::Parameters::Parameters(const CMakeBuildConfiguration *bc)
     pathMapper = cmake->pathMapper();
     isAutorun = cmake->isAutoRun();
 
-    auto tc = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::ToolChain::Language::Cxx);
+    auto tc = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (tc)
         cxxToolChainId = tc->id();
-    tc = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::ToolChain::Language::C);
+    tc = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
     if (tc)
         cToolChainId = tc->id();
     sysRoot = ProjectExplorer::SysRootKitInformation::sysRoot(k);
diff --git a/src/plugins/cmakeprojectmanager/cmakekitinformation.cpp b/src/plugins/cmakeprojectmanager/cmakekitinformation.cpp
index a7451111a33..d22af004755 100644
--- a/src/plugins/cmakeprojectmanager/cmakekitinformation.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakekitinformation.cpp
@@ -311,7 +311,7 @@ QVariant CMakeGeneratorKitInformation::defaultValue(const Kit *k) const
 
     if (Utils::HostOsInfo::isWindowsHost()) {
         // *sigh* Windows with its zoo of incompatible stuff again...
-        ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
+        ToolChain *tc = ToolChainKitInformation::toolChain(k, Constants::CXX_LANGUAGE_ID);
         if (tc && tc->typeId() == ProjectExplorer::Constants::MINGW_TOOLCHAIN_TYPEID) {
             it = std::find_if(known.constBegin(), known.constEnd(),
                               [extraGenerator](const CMakeTool::Generator &g) {
@@ -531,8 +531,8 @@ QVariant CMakeConfigurationKitInformation::defaultValue(const Kit *k) const
 QList<Task> CMakeConfigurationKitInformation::validate(const Kit *k) const
 {
     const QtSupport::BaseQtVersion *const version = QtSupport::QtKitInformation::qtVersion(k);
-    const ToolChain *const tcC = ToolChainKitInformation::toolChain(k, ToolChain::Language::C);
-    const ToolChain *const tcCxx = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
+    const ToolChain *const tcC = ToolChainKitInformation::toolChain(k, Constants::C_LANGUAGE_ID);
+    const ToolChain *const tcCxx = ToolChainKitInformation::toolChain(k, Constants::CXX_LANGUAGE_ID);
     const CMakeConfig config = configuration(k);
 
     const bool isQt4 = version && version->qtVersion() < QtSupport::QtVersionNumber(5, 0, 0);
diff --git a/src/plugins/cmakeprojectmanager/cmakeproject.cpp b/src/plugins/cmakeprojectmanager/cmakeproject.cpp
index 0ad47668daf..9bffe400683 100644
--- a/src/plugins/cmakeprojectmanager/cmakeproject.cpp
+++ b/src/plugins/cmakeprojectmanager/cmakeproject.cpp
@@ -154,7 +154,7 @@ void CMakeProject::updateProjectData(CMakeBuildConfiguration *bc)
 
     createGeneratedCodeModelSupport();
 
-    ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!tc) {
         emit fileListChanged();
         return;
diff --git a/src/plugins/cmakeprojectmanager/tealeafreader.cpp b/src/plugins/cmakeprojectmanager/tealeafreader.cpp
index a60372631cc..ec915a6a1a7 100644
--- a/src/plugins/cmakeprojectmanager/tealeafreader.cpp
+++ b/src/plugins/cmakeprojectmanager/tealeafreader.cpp
@@ -344,8 +344,8 @@ QSet<Id> TeaLeafReader::updateCodeModel(CppTools::ProjectPartBuilder &ppBuilder)
         // CMake shuffles the include paths that it reports via the CodeBlocks generator
         // So remove the toolchain include paths, so that at least those end up in the correct
         // place.
-        auto cxxflags = getFlagsFor(cbt, targetDataCacheCxx, ToolChain::Language::Cxx);
-        auto cflags = getFlagsFor(cbt, targetDataCacheC, ToolChain::Language::C);
+        auto cxxflags = getFlagsFor(cbt, targetDataCacheCxx, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
+        auto cflags = getFlagsFor(cbt, targetDataCacheC, ProjectExplorer::Constants::C_LANGUAGE_ID);
         QSet<FileName> tcIncludes;
         QStringList includePaths;
         if (tcCxx || tcC) {
@@ -547,7 +547,7 @@ void TeaLeafReader::processCMakeError()
 
 QStringList TeaLeafReader::getFlagsFor(const CMakeBuildTarget &buildTarget,
                                        QHash<QString, QStringList> &cache,
-                                       ToolChain::Language lang)
+                                       Id lang)
 {
     // check cache:
     auto it = cache.constFind(buildTarget.title);
@@ -566,20 +566,16 @@ QStringList TeaLeafReader::getFlagsFor(const CMakeBuildTarget &buildTarget,
 
 bool TeaLeafReader::extractFlagsFromMake(const CMakeBuildTarget &buildTarget,
                                          QHash<QString, QStringList> &cache,
-                                         ToolChain::Language lang)
+                                         Id lang)
 {
     QString flagsPrefix;
-    switch (lang)
-    {
-    case ToolChain::Language::Cxx:
+
+    if (lang == ProjectExplorer::Constants::CXX_LANGUAGE_ID)
         flagsPrefix = QLatin1String("CXX_FLAGS =");
-        break;
-    case ToolChain::Language::C:
+    else if (lang == ProjectExplorer::Constants::C_LANGUAGE_ID)
         flagsPrefix = QLatin1String("C_FLAGS =");
-        break;
-    default:
+    else
         return false;
-    }
 
     QString makeCommand = buildTarget.makeCommand.toString();
     int startIndex = makeCommand.indexOf('\"');
@@ -625,24 +621,19 @@ bool TeaLeafReader::extractFlagsFromMake(const CMakeBuildTarget &buildTarget,
 
 bool TeaLeafReader::extractFlagsFromNinja(const CMakeBuildTarget &buildTarget,
                                           QHash<QString, QStringList> &cache,
-                                          ProjectExplorer::ToolChain::Language lang)
+                                          Id lang)
 {
     Q_UNUSED(buildTarget)
     if (!cache.isEmpty()) // We fill the cache in one go!
         return false;
 
     QString compilerPrefix;
-    switch (lang)
-    {
-    case ToolChain::Language::Cxx:
+    if (lang == ProjectExplorer::Constants::CXX_LANGUAGE_ID)
         compilerPrefix = QLatin1String("CXX_COMPILER");
-        break;
-    case ToolChain::Language::C:
+    else if (lang == ProjectExplorer::Constants::C_LANGUAGE_ID)
         compilerPrefix = QLatin1String("C_COMPILER");
-        break;
-    default:
+    else
         return false;
-    }
 
     // Attempt to find build.ninja file and obtain FLAGS (CXX_FLAGS/C_FLAGS) from there if no suitable flags.make were
     // found
diff --git a/src/plugins/cmakeprojectmanager/tealeafreader.h b/src/plugins/cmakeprojectmanager/tealeafreader.h
index 4baadd1652b..4eca9b0af83 100644
--- a/src/plugins/cmakeprojectmanager/tealeafreader.h
+++ b/src/plugins/cmakeprojectmanager/tealeafreader.h
@@ -70,9 +70,9 @@ private:
     void processCMakeOutput();
     void processCMakeError();
 
-    QStringList getFlagsFor(const CMakeBuildTarget &buildTarget, QHash<QString, QStringList> &cache, ProjectExplorer::ToolChain::Language lang);
-    bool extractFlagsFromMake(const CMakeBuildTarget &buildTarget, QHash<QString, QStringList> &cache, ProjectExplorer::ToolChain::Language lang);
-    bool extractFlagsFromNinja(const CMakeBuildTarget &buildTarget, QHash<QString, QStringList> &cache, ProjectExplorer::ToolChain::Language lang);
+    QStringList getFlagsFor(const CMakeBuildTarget &buildTarget, QHash<QString, QStringList> &cache, Core::Id lang);
+    bool extractFlagsFromMake(const CMakeBuildTarget &buildTarget, QHash<QString, QStringList> &cache, Core::Id lang);
+    bool extractFlagsFromNinja(const CMakeBuildTarget &buildTarget, QHash<QString, QStringList> &cache, Core::Id lang);
 
     Utils::QtcProcess *m_cmakeProcess = nullptr;
 
diff --git a/src/plugins/cpptools/cppbaseprojectpartbuilder.cpp b/src/plugins/cpptools/cppbaseprojectpartbuilder.cpp
index 23e57cb8cf9..612373c8575 100644
--- a/src/plugins/cpptools/cppbaseprojectpartbuilder.cpp
+++ b/src/plugins/cpptools/cppbaseprojectpartbuilder.cpp
@@ -296,10 +296,10 @@ ToolChainInterfacePtr BaseProjectPartBuilder::selectToolChain(
     ToolChainInterfacePtr toolChain = nullptr;
 
     if (languageVersion <= ProjectPart::LatestCVersion)
-        toolChain = m_project->toolChain(ProjectExplorer::ToolChain::Language::C, m_cFlags);
+        toolChain = m_project->toolChain(ProjectExplorer::Constants::C_LANGUAGE_ID, m_cFlags);
 
     if (!toolChain) // Use Cxx toolchain for C projects without C compiler in kit and for C++ code
-        toolChain = m_project->toolChain(ProjectExplorer::ToolChain::Language::Cxx, m_cxxFlags);
+        toolChain = m_project->toolChain(ProjectExplorer::Constants::CXX_LANGUAGE_ID, m_cxxFlags);
 
     return toolChain;
 }
diff --git a/src/plugins/cpptools/cppprojectinterface.h b/src/plugins/cpptools/cppprojectinterface.h
index 861f427882d..dd03430cb82 100644
--- a/src/plugins/cpptools/cppprojectinterface.h
+++ b/src/plugins/cpptools/cppprojectinterface.h
@@ -72,7 +72,7 @@ public:
     virtual QString displayName() const = 0;
     virtual QString projectFilePath() const = 0;
 
-    virtual ToolChainInterfacePtr toolChain(ProjectExplorer::ToolChain::Language language,
+    virtual ToolChainInterfacePtr toolChain(Core::Id language,
                                             const QStringList &commandLineFlags) const = 0;
 };
 
diff --git a/src/plugins/cpptools/projectpartbuilder.cpp b/src/plugins/cpptools/projectpartbuilder.cpp
index f9cbe3f0b3d..a2efe98b133 100644
--- a/src/plugins/cpptools/projectpartbuilder.cpp
+++ b/src/plugins/cpptools/projectpartbuilder.cpp
@@ -119,7 +119,7 @@ public:
         return m_project.projectFilePath().toString();
     }
 
-    ToolChainInterfacePtr toolChain(ProjectExplorer::ToolChain::Language language,
+    ToolChainInterfacePtr toolChain(Core::Id language,
                                     const QStringList &commandLineFlags) const override
     {
         using namespace ProjectExplorer;
diff --git a/src/plugins/genericprojectmanager/genericmakestep.cpp b/src/plugins/genericprojectmanager/genericmakestep.cpp
index 3ac7a14a635..483039c5759 100644
--- a/src/plugins/genericprojectmanager/genericmakestep.cpp
+++ b/src/plugins/genericprojectmanager/genericmakestep.cpp
@@ -95,7 +95,7 @@ bool GenericMakeStep::init(QList<const BuildStep *> &earlierSteps)
     if (!bc)
         emit addTask(Task::buildConfigurationMissingTask());
 
-    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!tc)
         emit addTask(Task::compilerMissingTask());
 
@@ -170,7 +170,7 @@ QString GenericMakeStep::makeCommand(const Utils::Environment &environment) cons
 {
     QString command = m_makeCommand;
     if (command.isEmpty()) {
-        ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+        ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
         if (tc)
             command = tc->makeCommand(environment);
         else
diff --git a/src/plugins/ios/iosbuildstep.cpp b/src/plugins/ios/iosbuildstep.cpp
index a633c108f57..e59df475daa 100644
--- a/src/plugins/ios/iosbuildstep.cpp
+++ b/src/plugins/ios/iosbuildstep.cpp
@@ -98,7 +98,7 @@ bool IosBuildStep::init(QList<const BuildStep *> &earlierSteps)
     if (!bc)
         emit addTask(Task::buildConfigurationMissingTask());
 
-    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!tc)
         emit addTask(Task::compilerMissingTask());
 
@@ -170,7 +170,7 @@ QStringList IosBuildStep::defaultArguments() const
 {
     QStringList res;
     Kit *kit = target()->kit();
-    ToolChain *tc = ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     switch (target()->activeBuildConfiguration()->buildType()) {
     case BuildConfiguration::Debug :
         res << QLatin1String("-configuration") << QLatin1String("Debug");
diff --git a/src/plugins/ios/iosconfigurations.cpp b/src/plugins/ios/iosconfigurations.cpp
index c26ef61f300..95f33e7574a 100644
--- a/src/plugins/ios/iosconfigurations.cpp
+++ b/src/plugins/ios/iosconfigurations.cpp
@@ -194,11 +194,11 @@ static void setupKit(Kit *kit, Core::Id pDeviceType, const ToolChainPair& toolCh
     if (toolChains.first)
         ToolChainKitInformation::setToolChain(kit, toolChains.first);
     else
-        ToolChainKitInformation::clearToolChain(kit, ToolChain::Language::C);
+        ToolChainKitInformation::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
     if (toolChains.second)
         ToolChainKitInformation::setToolChain(kit, toolChains.second);
     else
-        ToolChainKitInformation::clearToolChain(kit, ToolChain::Language::Cxx);
+        ToolChainKitInformation::clearToolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     QtKitInformation::setQtVersion(kit, qtVersion);
     // only replace debugger with the default one if we find an unusable one here
@@ -288,8 +288,8 @@ void IosConfigurations::updateAutomaticKitList()
                 // we do not compare the sdk (thus automatically upgrading it in place if a
                 // new Xcode is used). Change?
                 return DeviceTypeKitInformation::deviceTypeId(kit) == pDeviceType
-                        && ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx) == platformToolchains.second
-                        && ToolChainKitInformation::toolChain(kit, ToolChain::Language::C) == platformToolchains.first
+                        && ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID) == platformToolchains.second
+                        && ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID) == platformToolchains.first
                         && QtKitInformation::qtVersion(kit) == qtVersion;
             });
             QTC_ASSERT(!resultingKits.contains(kit), continue);
@@ -409,24 +409,28 @@ void IosConfigurations::setDeveloperPath(const FileName &devPath)
     }
 }
 
-static ClangToolChain *createToolChain(const Platform &platform, ToolChain::Language l)
+static ClangToolChain *createToolChain(const Platform &platform, Core::Id l)
 {
-    if (l == ToolChain::Language::None)
+    if (!l.isValid())
+        return nullptr;
+
+    if (l != Core::Id(ProjectExplorer::Constants::C_LANGUAGE_ID)
+            && l != Core::Id(ProjectExplorer::Constants::CXX_LANGUAGE_ID))
         return nullptr;
 
     ClangToolChain *toolChain = new ClangToolChain(ToolChain::AutoDetection);
     toolChain->setLanguage(l);
-    toolChain->setDisplayName(l == ToolChain::Language::Cxx ? platform.name + "++" : platform.name);
+    toolChain->setDisplayName(l == Core::Id(ProjectExplorer::Constants::CXX_LANGUAGE_ID) ? platform.name + "++" : platform.name);
     toolChain->setPlatformCodeGenFlags(platform.backendFlags);
     toolChain->setPlatformLinkerFlags(platform.backendFlags);
-    toolChain->resetToolChain(l == ToolChain::Language::Cxx ?
+    toolChain->resetToolChain(l == Core::Id(ProjectExplorer::Constants::CXX_LANGUAGE_ID) ?
                                   platform.cxxCompilerPath : platform.cCompilerPath);
     return toolChain;
 }
 
-QSet<ToolChain::Language> IosToolChainFactory::supportedLanguages() const
+QSet<Core::Id> IosToolChainFactory::supportedLanguages() const
 {
-    return { ProjectExplorer::ToolChain::Language::Cxx };
+    return { ProjectExplorer::Constants::CXX_LANGUAGE_ID };
 }
 
 QList<ToolChain *> IosToolChainFactory::autoDetect(const QList<ToolChain *> &existingToolChains)
@@ -437,7 +441,7 @@ QList<ToolChain *> IosToolChainFactory::autoDetect(const QList<ToolChain *> &exi
     toolChains.reserve(platforms.size());
     foreach (const Platform &platform, platforms) {
         ToolChainPair platformToolchains = findToolChainForPlatform(platform, existingClangToolChains);
-        auto createOrAdd = [&](ClangToolChain* toolChain, ToolChain::Language l) {
+        auto createOrAdd = [&](ClangToolChain* toolChain, Core::Id l) {
             if (!toolChain) {
                 toolChain = createToolChain(platform, l);
                 existingClangToolChains.append(toolChain);
@@ -445,8 +449,8 @@ QList<ToolChain *> IosToolChainFactory::autoDetect(const QList<ToolChain *> &exi
             toolChains.append(toolChain);
         };
 
-        createOrAdd(platformToolchains.first, ToolChain::Language::C);
-        createOrAdd(platformToolchains.second, ToolChain::Language::Cxx);
+        createOrAdd(platformToolchains.first, ProjectExplorer::Constants::C_LANGUAGE_ID);
+        createOrAdd(platformToolchains.second, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     }
     return Utils::transform(toolChains, [](ClangToolChain *tc) -> ToolChain * { return tc; });
 }
diff --git a/src/plugins/ios/iosconfigurations.h b/src/plugins/ios/iosconfigurations.h
index 58bab02654e..7ddbb7e4620 100644
--- a/src/plugins/ios/iosconfigurations.h
+++ b/src/plugins/ios/iosconfigurations.h
@@ -46,7 +46,7 @@ class IosToolChainFactory : public ProjectExplorer::ToolChainFactory
     Q_OBJECT
 
 public:
-    QSet<ProjectExplorer::ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
     QList<ProjectExplorer::ToolChain *> autoDetect(const QList<ProjectExplorer::ToolChain *> &existingToolChains) override;
 };
 
diff --git a/src/plugins/projectexplorer/abstractmsvctoolchain.cpp b/src/plugins/projectexplorer/abstractmsvctoolchain.cpp
index 6bae9bff760..76d735b7dc8 100644
--- a/src/plugins/projectexplorer/abstractmsvctoolchain.cpp
+++ b/src/plugins/projectexplorer/abstractmsvctoolchain.cpp
@@ -44,9 +44,7 @@ enum { debug = 0 };
 namespace ProjectExplorer {
 namespace Internal {
 
-AbstractMsvcToolChain::AbstractMsvcToolChain(Core::Id typeId,
-                                             const Language &l,
-                                             Detection d,
+AbstractMsvcToolChain::AbstractMsvcToolChain(Core::Id typeId, Core::Id l, Detection d,
                                              const Abi &abi,
                                              const QString& vcvarsBat) : ToolChain(typeId, d),
     m_lastEnvironment(Utils::Environment::systemEnvironment()),
diff --git a/src/plugins/projectexplorer/abstractmsvctoolchain.h b/src/plugins/projectexplorer/abstractmsvctoolchain.h
index bd06e572909..653caed65b9 100644
--- a/src/plugins/projectexplorer/abstractmsvctoolchain.h
+++ b/src/plugins/projectexplorer/abstractmsvctoolchain.h
@@ -38,7 +38,7 @@ namespace Internal {
 class PROJECTEXPLORER_EXPORT AbstractMsvcToolChain : public ToolChain
 {
 public:
-    explicit AbstractMsvcToolChain(Core::Id typeId, const Language &l, Detection d,
+    explicit AbstractMsvcToolChain(Core::Id typeId, Core::Id l, Detection d,
                                    const Abi &abi, const QString& vcvarsBat);
     explicit AbstractMsvcToolChain(Core::Id typeId, Detection d);
 
diff --git a/src/plugins/projectexplorer/customtoolchain.cpp b/src/plugins/projectexplorer/customtoolchain.cpp
index 3423ce69e8f..3e86571f8fd 100644
--- a/src/plugins/projectexplorer/customtoolchain.cpp
+++ b/src/plugins/projectexplorer/customtoolchain.cpp
@@ -85,9 +85,9 @@ CustomToolChain::CustomToolChain(Detection d) :
     m_outputParser(Gcc)
 { }
 
-CustomToolChain::CustomToolChain(Language l, Detection d) : CustomToolChain(d)
+CustomToolChain::CustomToolChain(Core::Id language, Detection d) : CustomToolChain(d)
 {
-    setLanguage(l);
+    setLanguage(language);
 }
 
 
@@ -423,9 +423,9 @@ CustomToolChainFactory::CustomToolChainFactory()
     setDisplayName(tr("Custom"));
 }
 
-QSet<ToolChain::Language> CustomToolChainFactory::supportedLanguages() const
+QSet<Core::Id> CustomToolChainFactory::supportedLanguages() const
 {
-    return ToolChain::allLanguages();
+    return ToolChainManager::allLanguages();
 }
 
 bool CustomToolChainFactory::canCreate()
@@ -433,9 +433,9 @@ bool CustomToolChainFactory::canCreate()
     return true;
 }
 
-ToolChain *CustomToolChainFactory::create(ToolChain::Language l)
+ToolChain *CustomToolChainFactory::create(Core::Id language)
 {
-    return new CustomToolChain(l, ToolChain::ManualDetection);
+    return new CustomToolChain(language, ToolChain::ManualDetection);
 }
 
 // Used by the ToolChainManager to restore user-generated tool chains
diff --git a/src/plugins/projectexplorer/customtoolchain.h b/src/plugins/projectexplorer/customtoolchain.h
index 7b46a948489..de57c637f4a 100644
--- a/src/plugins/projectexplorer/customtoolchain.h
+++ b/src/plugins/projectexplorer/customtoolchain.h
@@ -122,7 +122,7 @@ protected:
 
 private:
     explicit CustomToolChain(Detection d);
-    explicit CustomToolChain(Language l, Detection d);
+    explicit CustomToolChain(Core::Id language, Detection d);
 
     Utils::FileName m_compilerCommand;
     Utils::FileName m_makeCommand;
@@ -148,10 +148,10 @@ class CustomToolChainFactory : public ToolChainFactory
 
 public:
     CustomToolChainFactory();
-    QSet<ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     bool canCreate() override;
-    ToolChain *create(ToolChain::Language l) override;
+    ToolChain *create(Core::Id language) override;
 
     // Used by the ToolChainManager to restore user-generated tool chains
     bool canRestore(const QVariantMap &data) override;
diff --git a/src/plugins/projectexplorer/gcctoolchain.cpp b/src/plugins/projectexplorer/gcctoolchain.cpp
index 44e2ea07a7f..11bb2f916dc 100644
--- a/src/plugins/projectexplorer/gcctoolchain.cpp
+++ b/src/plugins/projectexplorer/gcctoolchain.cpp
@@ -289,7 +289,7 @@ QString GccToolChain::defaultDisplayName() const
         return typeDisplayName();
     return QCoreApplication::translate("ProjectExplorer::GccToolChain",
                                        "%1 (%2, %3 %4 in %5)").arg(typeDisplayName(),
-                                                                  ToolChain::languageDisplayName(language()),
+                                                                  ToolChainManager::displayNameOfLanguageId(language()),
                                                                   Abi::toString(m_targetAbi.architecture()),
                                                                   Abi::toString(m_targetAbi.wordWidth()),
                                                                   compilerCommand().parentDir().toUserOutput());
@@ -759,9 +759,9 @@ GccToolChainFactory::GccToolChainFactory()
     setDisplayName(tr("GCC"));
 }
 
-QSet<ToolChain::Language> GccToolChainFactory::supportedLanguages() const
+QSet<Core::Id> GccToolChainFactory::supportedLanguages() const
 {
-    return { ToolChain::Language::Cxx, ToolChain::Language::C };
+    return { Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID };
 }
 
 bool GccToolChainFactory::canCreate()
@@ -769,10 +769,10 @@ bool GccToolChainFactory::canCreate()
     return true;
 }
 
-ToolChain *GccToolChainFactory::create(ToolChain::Language l)
+ToolChain *GccToolChainFactory::create(Core::Id language)
 {
     ToolChain *tc = createToolChain(false);
-    tc->setLanguage(l);
+    tc->setLanguage(language);
     return tc;
 }
 
@@ -781,18 +781,18 @@ QList<ToolChain *> GccToolChainFactory::autoDetect(const QList<ToolChain *> &alr
     QList<ToolChain *> tcs;
     if (HostOsInfo::isMacHost()) {
         // Old mac compilers needed to support macx-gccXY mkspecs:
-        tcs.append(autoDetectToolchains("g++-4.0", Abi::hostAbi(), ToolChain::Language::Cxx,
+        tcs.append(autoDetectToolchains("g++-4.0", Abi::hostAbi(), Constants::CXX_LANGUAGE_ID,
                                         Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown));
-        tcs.append(autoDetectToolchains("g++-4.2", Abi::hostAbi(), ToolChain::Language::Cxx,
+        tcs.append(autoDetectToolchains("g++-4.2", Abi::hostAbi(), Constants::CXX_LANGUAGE_ID,
                                         Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown));
-        tcs.append(autoDetectToolchains("gcc-4.0", Abi::hostAbi(), ToolChain::Language::C,
+        tcs.append(autoDetectToolchains("gcc-4.0", Abi::hostAbi(), Constants::C_LANGUAGE_ID,
                                         Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown));
-        tcs.append(autoDetectToolchains("gcc-4.2", Abi::hostAbi(), ToolChain::Language::C,
+        tcs.append(autoDetectToolchains("gcc-4.2", Abi::hostAbi(), Constants::C_LANGUAGE_ID,
                                         Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown));
     }
-    tcs.append(autoDetectToolchains("g++", Abi::hostAbi(), ToolChain::Language::Cxx,
+    tcs.append(autoDetectToolchains("g++", Abi::hostAbi(), Constants::CXX_LANGUAGE_ID,
                                     Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown));
-    tcs.append(autoDetectToolchains("gcc", Abi::hostAbi(), ToolChain::Language::C,
+    tcs.append(autoDetectToolchains("gcc", Abi::hostAbi(), Constants::C_LANGUAGE_ID,
                                     Constants::GCC_TOOLCHAIN_TYPEID, alreadyKnown));
 
     return tcs;
@@ -821,7 +821,7 @@ GccToolChain *GccToolChainFactory::createToolChain(bool autoDetect)
 
 QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(const QString &compiler,
                                                              const Abi &requiredAbi,
-                                                             ToolChain::Language l,
+                                                             Core::Id language,
                                                              const Core::Id requiredTypeId,
                                                              const QList<ToolChain *> &alreadyKnown)
 {
@@ -864,7 +864,7 @@ QList<ToolChain *> GccToolChainFactory::autoDetectToolchains(const QString &comp
         tc->setTargetAbi(abi);
         tc->setOriginalTargetTriple(detectedAbis.originalTargetTriple);
         tc->setDisplayName(tc->defaultDisplayName()); // reset displayname
-        tc->setLanguage(l);
+        tc->setLanguage(language);
 
         result.append(tc.take());
     }
@@ -1131,17 +1131,18 @@ ClangToolChainFactory::ClangToolChainFactory()
     setDisplayName(tr("Clang"));
 }
 
-QSet<ToolChain::Language> ClangToolChainFactory::supportedLanguages() const
+QSet<Core::Id> ClangToolChainFactory::supportedLanguages() const
 {
-    return { ProjectExplorer::ToolChain::Language::Cxx, ProjectExplorer::ToolChain::Language::C };
+    return { Constants::CXX_LANGUAGE_ID,
+             Constants::C_LANGUAGE_ID };
 }
 
 QList<ToolChain *> ClangToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
 {
     QList<ToolChain *> result
-            = autoDetectToolchains("clang++", Abi::hostAbi(), ToolChain::Language::Cxx,
+            = autoDetectToolchains("clang++", Abi::hostAbi(), Constants::CXX_LANGUAGE_ID,
                                    Constants::CLANG_TOOLCHAIN_TYPEID, alreadyKnown);
-    result += autoDetectToolchains("clang", Abi::hostAbi(), ToolChain::Language::C,
+    result += autoDetectToolchains("clang", Abi::hostAbi(), Constants::C_LANGUAGE_ID,
                                    Constants::CLANG_TOOLCHAIN_TYPEID, alreadyKnown);
     return result;
 }
@@ -1214,18 +1215,19 @@ MingwToolChainFactory::MingwToolChainFactory()
     setDisplayName(tr("MinGW"));
 }
 
-QSet<ToolChain::Language> MingwToolChainFactory::supportedLanguages() const
+QSet<Core::Id> MingwToolChainFactory::supportedLanguages() const
 {
-    return { ProjectExplorer::ToolChain::Language::Cxx, ProjectExplorer::ToolChain::Language::C };
+    return { Constants::CXX_LANGUAGE_ID,
+             Constants::C_LANGUAGE_ID };
 }
 
 QList<ToolChain *> MingwToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
 {
     Abi ha = Abi::hostAbi();
     ha = Abi(ha.architecture(), Abi::WindowsOS, Abi::WindowsMSysFlavor, Abi::PEFormat, ha.wordWidth());
-    QList<ToolChain *> result = autoDetectToolchains("g++", ha, ToolChain::Language::Cxx,
+    QList<ToolChain *> result = autoDetectToolchains("g++", ha, Constants::CXX_LANGUAGE_ID,
                                                      Constants::MINGW_TOOLCHAIN_TYPEID, alreadyKnown);
-    result += autoDetectToolchains("gcc", ha, ToolChain::Language::C,
+    result += autoDetectToolchains("gcc", ha, Constants::C_LANGUAGE_ID,
                                    Constants::MINGW_TOOLCHAIN_TYPEID, alreadyKnown);
     return result;
 }
@@ -1300,14 +1302,14 @@ LinuxIccToolChainFactory::LinuxIccToolChainFactory()
     setDisplayName(tr("Linux ICC"));
 }
 
-QSet<ToolChain::Language> LinuxIccToolChainFactory::supportedLanguages() const
+QSet<Core::Id> LinuxIccToolChainFactory::supportedLanguages() const
 {
-    return { ProjectExplorer::ToolChain::Language::Cxx };
+    return { Constants::CXX_LANGUAGE_ID };
 }
 
 QList<ToolChain *> LinuxIccToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
 {
-    return autoDetectToolchains("icpc", Abi::hostAbi(), ToolChain::Language::Cxx,
+    return autoDetectToolchains("icpc", Abi::hostAbi(), Constants::CXX_LANGUAGE_ID,
                                 Constants::LINUXICC_TOOLCHAIN_TYPEID, alreadyKnown);
 }
 
diff --git a/src/plugins/projectexplorer/gcctoolchainfactories.h b/src/plugins/projectexplorer/gcctoolchainfactories.h
index 718fee0ba07..8f15a2f30ec 100644
--- a/src/plugins/projectexplorer/gcctoolchainfactories.h
+++ b/src/plugins/projectexplorer/gcctoolchainfactories.h
@@ -49,12 +49,12 @@ class GccToolChainFactory : public ToolChainFactory
 
 public:
     GccToolChainFactory();
-    QSet<ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
 
     bool canCreate() override;
-    ToolChain *create(ToolChain::Language l) override;
+    ToolChain *create(Core::Id language) override;
 
     bool canRestore(const QVariantMap &data) override;
     ToolChain *restore(const QVariantMap &data) override;
@@ -62,7 +62,7 @@ public:
 protected:
     virtual GccToolChain *createToolChain(bool autoDetect);
     QList<ToolChain *> autoDetectToolchains(const QString &compiler, const Abi &requiredAbi,
-                                            ToolChain::Language l, const Core::Id requiredTypeId,
+                                            Core::Id language, const Core::Id requiredTypeId,
                                             const QList<ToolChain *> &alreadyKnown);
 };
 
@@ -109,7 +109,7 @@ class ClangToolChainFactory : public GccToolChainFactory
 
 public:
     ClangToolChainFactory();
-    QSet<ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
 
@@ -129,7 +129,7 @@ class MingwToolChainFactory : public GccToolChainFactory
 
 public:
     MingwToolChainFactory();
-    QSet<ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
 
@@ -149,7 +149,7 @@ class LinuxIccToolChainFactory : public GccToolChainFactory
 
 public:
     LinuxIccToolChainFactory();
-    QSet<ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
 
diff --git a/src/plugins/projectexplorer/kitinformation.cpp b/src/plugins/projectexplorer/kitinformation.cpp
index 8828a682096..1f9b7b6e6ac 100644
--- a/src/plugins/projectexplorer/kitinformation.cpp
+++ b/src/plugins/projectexplorer/kitinformation.cpp
@@ -142,12 +142,12 @@ ToolChainKitInformation::ToolChainKitInformation()
 }
 
 // language id -> tool chain id
-static QMap<ToolChain::Language, QByteArray> defaultToolChainIds()
+static QMap<Core::Id, QByteArray> defaultToolChainIds()
 {
-    QMap<ToolChain::Language, QByteArray> toolChains;
+    QMap<Core::Id, QByteArray> toolChains;
     const Abi abi = Abi::hostAbi();
     QList<ToolChain *> tcList = ToolChainManager::toolChains(Utils::equal(&ToolChain::targetAbi, abi));
-    foreach (ToolChain::Language l, ToolChain::allLanguages()) {
+    foreach (Core::Id l, ToolChainManager::allLanguages()) {
         ToolChain *tc = Utils::findOrDefault(tcList, Utils::equal(&ToolChain::language, l));
         toolChains.insert(l, tc ? tc->id() : QByteArray());
     }
@@ -156,11 +156,11 @@ static QMap<ToolChain::Language, QByteArray> defaultToolChainIds()
 
 static QVariant defaultToolChainValue()
 {
-    const QMap<ToolChain::Language, QByteArray> toolChains = defaultToolChainIds();
+    const QMap<Core::Id, QByteArray> toolChains = defaultToolChainIds();
     QVariantMap result;
     auto end = toolChains.end();
     for (auto it = toolChains.begin(); it != end; ++it) {
-        result.insert(ToolChain::languageId(it.key()), it.value());
+        result.insert(it.key().toString(), it.value());
     }
     return result;
 }
@@ -195,57 +195,81 @@ QList<Task> ToolChainKitInformation::validate(const Kit *k) const
 
 void ToolChainKitInformation::upgrade(Kit *k)
 {
+    const Core::Id oldIdV1 = Constants::KITINFORMATION_ID_V1;
+    const Core::Id oldIdV2 = Constants::KITINFORMATION_ID_V2;
+
     // upgrade <=4.1 to 4.2 (keep old settings around for now)
-    const Core::Id oldId = "PE.Profile.ToolChain";
-    const QVariant oldValue = k->value(oldId);
+    {
+        const QVariant oldValue = k->value(oldIdV1);
+        const QVariant value = k->value(oldIdV2);
+        if (value.isNull() && !oldValue.isNull()) {
+            QVariantMap newValue;
+            if (oldValue.type() == QVariant::Map) {
+                // Used between 4.1 and 4.2:
+                newValue = oldValue.toMap();
+            } else {
+                // Used up to 4.1:
+                newValue.insert(Deprecated::Toolchain::languageId(Deprecated::Toolchain::Cxx), oldValue.toString());
 
-    const QVariant value = k->value(ToolChainKitInformation::id());
-    if (value.isNull() && !oldValue.isNull()) {
-        QVariantMap newValue;
-        if (oldValue.type() == QVariant::Map) {
-            // Used between 4.1 and 4.2:
-            newValue = oldValue.toMap();
-        } else {
-            // Used up to 4.1:
-            newValue.insert(ToolChain::languageId(ToolChain::Language::Cxx), oldValue.toString());
-
-            const Core::Id typeId = DeviceTypeKitInformation::deviceTypeId(k);
-            if (typeId == Constants::DESKTOP_DEVICE_TYPE) {
-                // insert default C compiler which did not exist before
-                newValue.insert(ToolChain::languageId(ToolChain::Language::C),
-                                defaultToolChainIds().value(ToolChain::Language::C));
+                const Core::Id typeId = DeviceTypeKitInformation::deviceTypeId(k);
+                if (typeId == Constants::DESKTOP_DEVICE_TYPE) {
+                    // insert default C compiler which did not exist before
+                    newValue.insert(Deprecated::Toolchain::languageId(Deprecated::Toolchain::C),
+                                    defaultToolChainIds().value(Core::Id(Constants::C_LANGUAGE_ID)));
+                }
             }
+            k->setValue(oldIdV2, newValue);
+            k->setSticky(oldIdV2, k->isSticky(oldIdV1));
+        }
+    }
+
+    // upgrade 4.2 to 4.3 (keep old settings around for now)
+    {
+        const QVariant oldValue = k->value(oldIdV2);
+        const QVariant value = k->value(ToolChainKitInformation::id());
+        if (value.isNull() && !oldValue.isNull()) {
+            QVariantMap newValue = oldValue.toMap();
+            QVariantMap::iterator it = newValue.find(Deprecated::Toolchain::languageId(Deprecated::Toolchain::C));
+            if (it != newValue.end())
+                newValue.insert(Core::Id(Constants::C_LANGUAGE_ID).toString(), it.value());
+            it = newValue.find(Deprecated::Toolchain::languageId(Deprecated::Toolchain::Cxx));
+            if (it != newValue.end())
+                newValue.insert(Core::Id(Constants::CXX_LANGUAGE_ID).toString(), it.value());
+            k->setValue(ToolChainKitInformation::id(), newValue);
+            k->setSticky(ToolChainKitInformation::id(), k->isSticky(oldIdV2));
         }
-        k->setValue(ToolChainKitInformation::id(), newValue);
-        k->setSticky(ToolChainKitInformation::id(), k->isSticky(oldId));
     }
 }
 
 void ToolChainKitInformation::fix(Kit *k)
 {
     QTC_ASSERT(ToolChainManager::isLoaded(), return);
-    foreach (ToolChain::Language l, ToolChain::allLanguages()) {
+    foreach (const Core::Id& l, ToolChainManager::allLanguages()) {
         if (!toolChain(k, l)) {
             qWarning("No tool chain set up in kit \"%s\" for \"%s\".",
                      qPrintable(k->displayName()),
-                     qPrintable(ToolChain::languageDisplayName(l)));
+                     qPrintable(ToolChainManager::displayNameOfLanguageId(l)));
             clearToolChain(k, l); // make sure to clear out no longer known tool chains
         }
     }
 }
 
+static Core::Id findLanguage(const QString &ls)
+{
+    QString lsUpper = ls.toUpper();
+    return Utils::findOrDefault(ToolChainManager::allLanguages(),
+                         [lsUpper](Core::Id l) { return lsUpper == l.toString().toUpper(); });
+}
+
 void ToolChainKitInformation::setup(Kit *k)
 {
     QTC_ASSERT(ToolChainManager::isLoaded(), return);
     const QVariantMap value = k->value(ToolChainKitInformation::id()).toMap();
 
     for (auto i = value.constBegin(); i != value.constEnd(); ++i) {
-        ToolChain::Language l
-                = Utils::findOr(ToolChain::allLanguages(), ToolChain::Language::None,
-                                [i](ToolChain::Language l) {
-                                    return ToolChain::languageId(l) == i.key();
-                                });
-        if (l == ToolChain::Language::None)
+        Core::Id l = findLanguage(i.key());
+
+        if (!l.isValid())
             continue;
 
         const QByteArray id = i.value().toByteArray();
@@ -272,52 +296,46 @@ KitConfigWidget *ToolChainKitInformation::createConfigWidget(Kit *k) const
 
 QString ToolChainKitInformation::displayNamePostfix(const Kit *k) const
 {
-    ToolChain *tc = toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
     return tc ? tc->displayName() : QString();
 }
 
 KitInformation::ItemList ToolChainKitInformation::toUserOutput(const Kit *k) const
 {
-    ToolChain *tc = toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
     return ItemList() << qMakePair(tr("Compiler"), tc ? tc->displayName() : tr("None"));
 }
 
 void ToolChainKitInformation::addToEnvironment(const Kit *k, Utils::Environment &env) const
 {
-    ToolChain *tc = toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
     if (tc)
         tc->addToEnvironment(env);
 }
 
-static ToolChain::Language findLanguage(const QString &ls)
-{
-    return Utils::findOr(ToolChain::allLanguages(), ToolChain::Language::None,
-                         [ls](ToolChain::Language l) { return ls == ToolChain::languageId(l).toUpper(); });
-}
-
 void ToolChainKitInformation::addToMacroExpander(Kit *kit, Utils::MacroExpander *expander) const
 {
     // Compatibility with Qt Creator < 4.2:
     expander->registerVariable("Compiler:Name", tr("Compiler"),
                                [this, kit]() -> QString {
-                                   const ToolChain *tc = toolChain(kit, ToolChain::Language::Cxx);
+                                   const ToolChain *tc = toolChain(kit, Constants::CXX_LANGUAGE_ID);
                                    return tc ? tc->displayName() : tr("None");
                                });
 
     expander->registerVariable("Compiler:Executable", tr("Path to the compiler executable"),
                                [this, kit]() -> QString {
-                                   const ToolChain *tc = toolChain(kit, ToolChain::Language::Cxx);
+                                   const ToolChain *tc = toolChain(kit, Constants::CXX_LANGUAGE_ID);
                                    return tc ? tc->compilerCommand().toString() : QString();
                                });
 
     expander->registerPrefix("Compiler:Name", tr("Compiler for different languages"),
                              [this, kit](const QString &ls) -> QString {
-                                 const ToolChain *tc = toolChain(kit, findLanguage(ls.toUpper()));
+                                 const ToolChain *tc = toolChain(kit, findLanguage(ls));
                                  return tc ? tc->displayName() : tr("None");
                              });
     expander->registerPrefix("Compiler:Executable", tr("Compiler executable for different languages"),
                              [this, kit](const QString &ls) -> QString {
-                                 const ToolChain *tc = toolChain(kit, findLanguage(ls.toUpper()));
+                                 const ToolChain *tc = toolChain(kit, findLanguage(ls));
                                  return tc ? tc->compilerCommand().toString() : QString();
                              });
 }
@@ -325,7 +343,7 @@ void ToolChainKitInformation::addToMacroExpander(Kit *kit, Utils::MacroExpander
 
 IOutputParser *ToolChainKitInformation::createOutputParser(const Kit *k) const
 {
-    ToolChain *tc = toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = toolChain(k, Constants::CXX_LANGUAGE_ID);
     if (tc)
         return tc->outputParser();
     return 0;
@@ -333,16 +351,16 @@ IOutputParser *ToolChainKitInformation::createOutputParser(const Kit *k) const
 
 Core::Id ToolChainKitInformation::id()
 {
-    return "PE.Profile.ToolChains";
+    return Constants::KITINFORMATION_ID_V3;
 }
 
-ToolChain *ToolChainKitInformation::toolChain(const Kit *k, ToolChain::Language l)
+ToolChain *ToolChainKitInformation::toolChain(const Kit *k, Core::Id language)
 {
     QTC_ASSERT(ToolChainManager::isLoaded(), return 0);
     if (!k)
         return 0;
     QVariantMap value = k->value(ToolChainKitInformation::id()).toMap();
-    const QByteArray id = value.value(ToolChain::languageId(l), QByteArray()).toByteArray();
+    const QByteArray id = value.value(language.toString(), QByteArray()).toByteArray();
     return ToolChainManager::findToolChain(id);
 }
 
@@ -350,9 +368,9 @@ QList<ToolChain *> ToolChainKitInformation::toolChains(const Kit *k)
 {
     const QVariantMap value = k->value(ToolChainKitInformation::id()).toMap();
     const QList<ToolChain *> tcList
-            = Utils::transform(ToolChain::allLanguages().toList(),
-                               [&value](ToolChain::Language l) -> ToolChain * {
-                                   return ToolChainManager::findToolChain(value.value(ToolChain::languageId(l)).toByteArray());
+            = Utils::transform(ToolChainManager::allLanguages().toList(),
+                               [&value](Core::Id l) -> ToolChain * {
+                                   return ToolChainManager::findToolChain(value.value(l.toString()).toByteArray());
                                });
     return Utils::filtered(tcList, [](ToolChain *tc) { return tc; });
 }
@@ -361,16 +379,17 @@ void ToolChainKitInformation::setToolChain(Kit *k, ToolChain *tc)
 {
     QTC_ASSERT(tc, return);
     QVariantMap result = k->value(ToolChainKitInformation::id()).toMap();
-    result.insert(ToolChain::languageId(tc->language()), tc->id());
+    result.insert(tc->language().toString(), tc->id());
+
     k->setValue(id(), result);
 }
 
-void ToolChainKitInformation::clearToolChain(Kit *k, ToolChain::Language l)
+void ToolChainKitInformation::clearToolChain(Kit *k, Core::Id language)
 {
-    QTC_ASSERT(l != ToolChain::Language::None, return);
+    QTC_ASSERT(language.isValid(), return);
 
     QVariantMap result = k->value(ToolChainKitInformation::id()).toMap();
-    result.insert(ToolChain::languageId(l), QByteArray());
+    result.insert(language.toString(), QByteArray());
     k->setValue(id(), result);
 }
 
@@ -382,7 +401,7 @@ Abi ToolChainKitInformation::targetAbi(const Kit *k)
     QHash<Abi, int> abiCount;
     foreach (ToolChain *tc, tcList) {
         Abi ta = tc->targetAbi();
-        if (tc->language() == ToolChain::Language::Cxx)
+        if (tc->language() == Core::Id(Constants::CXX_LANGUAGE_ID))
             cxxAbi = tc->targetAbi();
         abiCount[ta] = (abiCount.contains(ta) ? abiCount[ta] + 1 : 1);
     }
diff --git a/src/plugins/projectexplorer/kitinformation.h b/src/plugins/projectexplorer/kitinformation.h
index 34906892c4c..2238f08e1a5 100644
--- a/src/plugins/projectexplorer/kitinformation.h
+++ b/src/plugins/projectexplorer/kitinformation.h
@@ -94,10 +94,10 @@ public:
     IOutputParser *createOutputParser(const Kit *k) const override;
 
     static Core::Id id();
-    static ToolChain *toolChain(const Kit *k, ToolChain::Language l);
+    static ToolChain *toolChain(const Kit *k, Core::Id language);
     static QList<ToolChain *> toolChains(const Kit *k);
     static void setToolChain(Kit *k, ToolChain *tc);
-    static void clearToolChain(Kit *k, ToolChain::Language l);
+    static void clearToolChain(Kit *k, Core::Id language);
     static Abi targetAbi(const Kit *k);
 
     static QString msgNoToolChainInTarget();
diff --git a/src/plugins/projectexplorer/kitinformationconfigwidget.cpp b/src/plugins/projectexplorer/kitinformationconfigwidget.cpp
index 2f3445d1566..9e398a280f5 100644
--- a/src/plugins/projectexplorer/kitinformationconfigwidget.cpp
+++ b/src/plugins/projectexplorer/kitinformationconfigwidget.cpp
@@ -138,15 +138,15 @@ ToolChainInformationConfigWidget::ToolChainInformationConfigWidget(Kit *k, const
     layout->setColumnStretch(1, 2);
 
     int row = 0;
-    QList<ToolChain::Language> languageList = ToolChain::allLanguages().toList();
-    Utils::sort(languageList, [](ToolChain::Language l1, ToolChain::Language l2) {
-        return ToolChain::languageDisplayName(l1) < ToolChain::languageDisplayName(l2);
+    QList<Core::Id> languageList = ToolChainManager::allLanguages().toList();
+    Utils::sort(languageList, [](Core::Id l1, Core::Id l2) {
+        return ToolChainManager::displayNameOfLanguageId(l1) < ToolChainManager::displayNameOfLanguageId(l2);
     });
 
     QTC_ASSERT(!languageList.isEmpty(), return);
 
-    foreach (ToolChain::Language l, languageList) {
-        layout->addWidget(new QLabel(ToolChain::languageDisplayName(l) + ':'), row, 0);
+    foreach (Core::Id l, languageList) {
+        layout->addWidget(new QLabel(ToolChainManager::displayNameOfLanguageId(l) + ':'), row, 0);
         auto cb = new QComboBox;
         cb->setToolTip(toolTip());
 
@@ -188,7 +188,7 @@ void ToolChainInformationConfigWidget::refresh()
 {
     m_ignoreChanges = true;
 
-    foreach (ToolChain::Language l, m_languageComboboxMap.keys()) {
+    foreach (Core::Id l, m_languageComboboxMap.keys()) {
         const QList<ToolChain *> ltcList
                 = ToolChainManager::toolChains(Utils::equal(&ToolChain::language, l));
 
@@ -209,7 +209,7 @@ void ToolChainInformationConfigWidget::refresh()
 void ToolChainInformationConfigWidget::makeReadOnly()
 {
     m_isReadOnly = true;
-    foreach (ToolChain::Language l, m_languageComboboxMap.keys()) {
+    foreach (Core::Id l, m_languageComboboxMap.keys()) {
         m_languageComboboxMap.value(l)->setEnabled(false);
     }
 }
@@ -229,18 +229,18 @@ void ToolChainInformationConfigWidget::manageToolChains()
     ICore::showOptionsDialog(Constants::TOOLCHAIN_SETTINGS_PAGE_ID, buttonWidget());
 }
 
-void ToolChainInformationConfigWidget::currentToolChainChanged(ToolChain::Language l, int idx)
+void ToolChainInformationConfigWidget::currentToolChainChanged(Id language, int idx)
 {
     if (m_ignoreChanges || idx < 0)
         return;
 
-    const QByteArray id = m_languageComboboxMap.value(l)->itemData(idx).toByteArray();
+    const QByteArray id = m_languageComboboxMap.value(language)->itemData(idx).toByteArray();
     ToolChain *tc = ToolChainManager::findToolChain(id);
-    QTC_ASSERT(!tc || tc->language() == l, return);
+    QTC_ASSERT(!tc || tc->language() == language, return);
     if (tc)
         ToolChainKitInformation::setToolChain(m_kit, tc);
     else
-        ToolChainKitInformation::clearToolChain(m_kit, l);
+        ToolChainKitInformation::clearToolChain(m_kit, language);
 }
 
 int ToolChainInformationConfigWidget::indexOf(QComboBox *cb, const ToolChain *tc)
diff --git a/src/plugins/projectexplorer/kitinformationconfigwidget.h b/src/plugins/projectexplorer/kitinformationconfigwidget.h
index b04e5a0297b..e379480bbde 100644
--- a/src/plugins/projectexplorer/kitinformationconfigwidget.h
+++ b/src/plugins/projectexplorer/kitinformationconfigwidget.h
@@ -96,13 +96,13 @@ public:
 
 private:
     void manageToolChains();
-    void currentToolChainChanged(ToolChain::Language l, int idx);
+    void currentToolChainChanged(Core::Id language, int idx);
 
     int indexOf(QComboBox *cb, const ToolChain *tc);
 
     QWidget *m_mainWidget;
     QPushButton *m_manageButton;
-    QHash<ToolChain::Language, QComboBox *> m_languageComboboxMap;
+    QHash<Core::Id, QComboBox *> m_languageComboboxMap;
     bool m_ignoreChanges = false;
     bool m_isReadOnly = false;
 };
diff --git a/src/plugins/projectexplorer/msvctoolchain.cpp b/src/plugins/projectexplorer/msvctoolchain.cpp
index c17627f3084..3d5d3410193 100644
--- a/src/plugins/projectexplorer/msvctoolchain.cpp
+++ b/src/plugins/projectexplorer/msvctoolchain.cpp
@@ -412,13 +412,13 @@ Utils::Environment MsvcToolChain::readEnvironmentSetting(const Utils::Environmen
 // --------------------------------------------------------------------------
 
 MsvcToolChain::MsvcToolChain(const QString &name, const Abi &abi,
-                             const QString &varsBat, const QString &varsBatArg, const Language &l,
+                             const QString &varsBat, const QString &varsBatArg, Core::Id l,
                              Detection d) :
     MsvcToolChain(Constants::MSVC_TOOLCHAIN_TYPEID, name, abi, varsBat, varsBatArg, l, d)
 { }
 
 MsvcToolChain::MsvcToolChain(Core::Id typeId, const QString &name, const Abi &abi,
-                             const QString &varsBat, const QString &varsBatArg, const Language &l,
+                             const QString &varsBat, const QString &varsBatArg, Core::Id l,
                              Detection d) : AbstractMsvcToolChain(typeId, l, d, abi, varsBat),
     m_varsBatArg(varsBatArg)
 {
@@ -589,9 +589,9 @@ static const char clangClBinary[] = "clang-cl.exe";
 
 ClangClToolChain::ClangClToolChain(const QString &name, const QString &llvmDir,
                                    const Abi &abi,
-                                   const QString &varsBat, const QString &varsBatArg, const Language &l,
+                                   const QString &varsBat, const QString &varsBatArg, Core::Id language,
                                    Detection d)
-    : MsvcToolChain(Constants::CLANG_CL_TOOLCHAIN_TYPEID, name, abi, varsBat, varsBatArg, l, d)
+    : MsvcToolChain(Constants::CLANG_CL_TOOLCHAIN_TYPEID, name, abi, varsBat, varsBatArg, language, d)
     , m_llvmDir(llvmDir)
     , m_compiler(Utils::FileName::fromString(m_llvmDir + QStringLiteral("/bin/") + QLatin1String(clangClBinary)))
 { }
@@ -665,9 +665,9 @@ MsvcToolChainFactory::MsvcToolChainFactory()
     setDisplayName(tr("MSVC"));
 }
 
-QSet<ToolChain::Language> MsvcToolChainFactory::supportedLanguages() const
+QSet<Core::Id> MsvcToolChainFactory::supportedLanguages() const
 {
-    return { ToolChain::Language::C, ToolChain::Language::Cxx };
+    return { Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID };
 }
 
 QString MsvcToolChainFactory::vcVarsBatFor(const QString &basePath, MsvcToolChain::Platform platform,
@@ -692,7 +692,7 @@ static QList<ToolChain *> findOrCreateToolChain(
         ToolChain::Detection d = ToolChain::ManualDetection)
 {
     QList<ToolChain *> res;
-    for (auto language: {ToolChain::Language::C, ToolChain::Language::Cxx}) {
+    for (auto language: { Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID }) {
         ToolChain *tc = Utils::findOrDefault(
                     alreadyKnown,
                     [&varsBat, &varsBatArg, &abi, &language](ToolChain *tc) -> bool {
@@ -746,7 +746,7 @@ static void detectCppBuildTools(QList<ToolChain *> *list)
         const Entry &e = entries[i];
         const Abi abi(e.architecture, Abi::WindowsOS, Abi::WindowsMsvc2015Flavor,
                       e.format, e.wordSize);
-        for (auto language: {ToolChain::Language::C, ToolChain::Language::Cxx}) {
+        for (auto language: { Constants::C_LANGUAGE_ID, Constants::CXX_LANGUAGE_ID }) {
             list->append(new MsvcToolChain(name + QLatin1String(e.postFix), abi,
                                            vcVarsBat, QLatin1String(e.varsBatArg),
                                            language, ToolChain::AutoDetection));
@@ -794,7 +794,7 @@ static void detectClangClToolChain(QList<ToolChain *> *list)
         + Abi::toString(targetAbi.osFlavor()).toUpper();
     list->append(new ClangClToolChain(name, path, targetAbi,
                                       msvcToolChain->varsBat(), msvcToolChain->varsBatArg(),
-                                      ToolChain::Language::Cxx, ToolChain::AutoDetection));
+                                      Constants::CXX_LANGUAGE_ID, ToolChain::AutoDetection));
 }
 
 QList<ToolChain *> MsvcToolChainFactory::autoDetect(const QList<ToolChain *> &alreadyKnown)
diff --git a/src/plugins/projectexplorer/msvctoolchain.h b/src/plugins/projectexplorer/msvctoolchain.h
index 040ccf174df..f77a1637fee 100644
--- a/src/plugins/projectexplorer/msvctoolchain.h
+++ b/src/plugins/projectexplorer/msvctoolchain.h
@@ -56,7 +56,7 @@ public:
 
     explicit MsvcToolChain(const QString &name, const Abi &abi,
                            const QString &varsBat, const QString &varsBatArg,
-                           const Language &l, Detection d = ManualDetection);
+                           Core::Id l, Detection d = ManualDetection);
     MsvcToolChain();
 
     Utils::FileNameList suggestedMkspecList() const override;
@@ -77,7 +77,7 @@ public:
 protected:
     explicit MsvcToolChain(Core::Id typeId, const QString &name, const Abi &abi,
                            const QString &varsBat, const QString &varsBatArg,
-                           const Language &l, Detection d);
+                           Core::Id l, Detection d);
     explicit MsvcToolChain(Core::Id typeId);
 
     Utils::Environment readEnvironmentSetting(const Utils::Environment& env) const final;
@@ -94,7 +94,7 @@ public:
     explicit ClangClToolChain(const QString &name, const QString &llvmDir,
                               const Abi &abi,
                               const QString &varsBat, const QString &varsBatArg,
-                              const Language &l,
+                              Core::Id language,
                               Detection d = ManualDetection);
     ClangClToolChain();
 
@@ -126,7 +126,7 @@ class MsvcToolChainFactory : public ToolChainFactory
 
 public:
     MsvcToolChainFactory();
-    QSet<ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
 
diff --git a/src/plugins/projectexplorer/projectexplorer.cpp b/src/plugins/projectexplorer/projectexplorer.cpp
index cfa397ef16a..9f6b0e74eb0 100644
--- a/src/plugins/projectexplorer/projectexplorer.cpp
+++ b/src/plugins/projectexplorer/projectexplorer.cpp
@@ -446,6 +446,10 @@ bool ProjectExplorerPlugin::initialize(const QStringList &arguments, QString *er
     dd->m_kitManager = new KitManager; // register before ToolChainManager
     dd->m_toolChainManager = new ToolChainManager;
 
+    // Register languages
+    ToolChainManager::registerLanguage(Constants::C_LANGUAGE_ID, tr("C"));
+    ToolChainManager::registerLanguage(Constants::CXX_LANGUAGE_ID, tr("C++"));
+
     IWizardFactory::registerFeatureProvider(new KitFeatureProvider);
 
     // Register KitInformation:
diff --git a/src/plugins/projectexplorer/projectexplorerconstants.h b/src/plugins/projectexplorer/projectexplorerconstants.h
index e916b648e78..3adae9ef025 100644
--- a/src/plugins/projectexplorer/projectexplorerconstants.h
+++ b/src/plugins/projectexplorer/projectexplorerconstants.h
@@ -209,6 +209,10 @@ const char BUILDSTEPS_DEPLOY[] = "ProjectExplorer.BuildSteps.Deploy";
 // Deploy Configuration id:
 const char DEFAULT_DEPLOYCONFIGURATION_ID[] = "ProjectExplorer.DefaultDeployConfiguration";
 
+// Language
+const char C_LANGUAGE_ID[] = "ProjectExplorer.Language.C";
+const char CXX_LANGUAGE_ID[] = "ProjectExplorer.Language.Cxx";
+
 // ToolChain TypeIds
 const char CLANG_TOOLCHAIN_TYPEID[] = "ProjectExplorer.ToolChain.Clang";
 const char GCC_TOOLCHAIN_TYPEID[] = "ProjectExplorer.ToolChain.Gcc";
@@ -277,5 +281,10 @@ const char FILEOVERLAY_H[]=":/projectexplorer/images/fileoverlay_h.png";
 const char FILEOVERLAY_SCXML[]=":/projectexplorer/images/fileoverlay_scxml.png";
 const char FILEOVERLAY_UNKNOWN[]=":/projectexplorer/images/fileoverlay_unknown.png";
 
+// Kit Information
+const char KITINFORMATION_ID_V1[] = "PE.Profile.ToolChain";
+const char KITINFORMATION_ID_V2[] = "PE.Profile.ToolChains";
+const char KITINFORMATION_ID_V3[] = "PE.Profile.ToolChainsV3";
+
 } // namespace Constants
 } // namespace ProjectExplorer
diff --git a/src/plugins/projectexplorer/runconfiguration.cpp b/src/plugins/projectexplorer/runconfiguration.cpp
index f43daaf071f..d894a125564 100644
--- a/src/plugins/projectexplorer/runconfiguration.cpp
+++ b/src/plugins/projectexplorer/runconfiguration.cpp
@@ -276,7 +276,7 @@ Abi RunConfiguration::abi() const
     BuildConfiguration *bc = target()->activeBuildConfiguration();
     if (!bc)
         return Abi::hostAbi();
-    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), Constants::CXX_LANGUAGE_ID);
     if (!tc)
         return Abi::hostAbi();
     return tc->targetAbi();
diff --git a/src/plugins/projectexplorer/toolchain.cpp b/src/plugins/projectexplorer/toolchain.cpp
index a09586b5e00..0d72beb187a 100644
--- a/src/plugins/projectexplorer/toolchain.cpp
+++ b/src/plugins/projectexplorer/toolchain.cpp
@@ -27,6 +27,7 @@
 
 #include "abi.h"
 #include "headerpath.h"
+#include "projectexplorerconstants.h"
 #include "toolchainmanager.h"
 #include "task.h"
 
@@ -39,7 +40,8 @@
 static const char ID_KEY[] = "ProjectExplorer.ToolChain.Id";
 static const char DISPLAY_NAME_KEY[] = "ProjectExplorer.ToolChain.DisplayName";
 static const char AUTODETECT_KEY[] = "ProjectExplorer.ToolChain.Autodetect";
-static const char LANGUAGE_KEY[] = "ProjectExplorer.ToolChain.Language";
+static const char LANGUAGE_KEY_V1[] = "ProjectExplorer.ToolChain.Language"; // For QtCreator <= 4.2
+static const char LANGUAGE_KEY_V2[] = "ProjectExplorer.ToolChain.LanguageV2"; // For QtCreator > 4.2
 
 namespace ProjectExplorer {
 namespace Internal {
@@ -63,15 +65,49 @@ public:
     }
 
     QByteArray m_id;
-    QSet<ToolChain::Language> m_supportedLanguages;
+    QSet<Core::Id> m_supportedLanguages;
     mutable QString m_displayName;
     Core::Id m_typeId;
-    ToolChain::Language m_language = ToolChain::Language::None;
+    Core::Id m_language;
     Detection m_detection;
 };
 
+
+// Deprecated used from QtCreator <= 4.2
+
+Core::Id fromLanguageV1(int language)
+{
+    switch (language)
+    {
+    case Deprecated::Toolchain::C :
+        return Core::Id(Constants::C_LANGUAGE_ID);
+    case Deprecated::Toolchain::Cxx:
+        return Core::Id(Constants::CXX_LANGUAGE_ID);
+    case Deprecated::Toolchain::None:
+    default:
+        return Core::Id();
+    }
+}
+
 } // namespace Internal
 
+namespace Deprecated {
+namespace Toolchain {
+QString languageId(Language l)
+{
+    switch (l) {
+    case Language::None:
+        return QStringLiteral("None");
+    case Language::C:
+        return QStringLiteral("C");
+    case Language::Cxx:
+        return QStringLiteral("Cxx");
+    };
+    return QString();
+}
+} // namespace Toolchain
+} // namespace Deprecated
+
 /*!
     \class ProjectExplorer::ToolChain
     \brief The ToolChain class represents a tool chain.
@@ -95,12 +131,13 @@ ToolChain::ToolChain(const ToolChain &other) :
             .arg(other.displayName());
 }
 
-void ToolChain::setLanguage(const ToolChain::Language &l)
+void ToolChain::setLanguage(Core::Id language)
 {
-    QTC_ASSERT(d->m_language == Language::None, return);
-    QTC_ASSERT(l != Language::None, return);
+    QTC_ASSERT(!d->m_language.isValid(), return);
+    QTC_ASSERT(language.isValid(), return);
+    QTC_ASSERT(ToolChainManager::isLanguageSupported(language), return);
 
-    d->m_language = l;
+    d->m_language = language;
 }
 
 ToolChain::~ToolChain()
@@ -154,39 +191,7 @@ QList<Abi> ToolChain::supportedAbis() const
     return { targetAbi() };
 }
 
-const QSet<ToolChain::Language> &ToolChain::allLanguages()
-{
-    static QSet<Language> languages({ Language::C, Language::Cxx });
-    return languages;
-}
-
-QString ToolChain::languageDisplayName(Language language)
-{
-    switch (language) {
-    case Language::None:
-        return QCoreApplication::translate("ProjectExplorer::ToolChain", "None");
-    case Language::C:
-        return QCoreApplication::translate("ProjectExplorer::ToolChain", "C");
-    case Language::Cxx:
-        return QCoreApplication::translate("ProjectExplorer::ToolChain", "C++");
-    };
-    return QString();
-}
-
-QString ToolChain::languageId(ToolChain::Language l)
-{
-    switch (l) {
-    case Language::None:
-        return QStringLiteral("None");
-    case Language::C:
-        return QStringLiteral("C");
-    case Language::Cxx:
-        return QStringLiteral("Cxx");
-    };
-    return QString();
-}
-
-ToolChain::Language ToolChain::language() const
+Core::Id ToolChain::language() const
 {
     return d->m_language;
 }
@@ -220,8 +225,7 @@ QVariantMap ToolChain::toMap() const
     result.insert(QLatin1String(ID_KEY), idToSave);
     result.insert(QLatin1String(DISPLAY_NAME_KEY), displayName());
     result.insert(QLatin1String(AUTODETECT_KEY), isAutoDetected());
-    result.insert(QLatin1String(LANGUAGE_KEY), static_cast<int>(language()));
-
+    result.insert(QLatin1String(LANGUAGE_KEY_V2), language().toSetting());
     return result;
 }
 
@@ -258,12 +262,13 @@ bool ToolChain::fromMap(const QVariantMap &data)
     const bool autoDetect = data.value(QLatin1String(AUTODETECT_KEY), false).toBool();
     d->m_detection = autoDetect ? AutoDetectionFromSettings : ManualDetection;
 
-    bool ok;
-    d->m_language
-            = static_cast<Language>(data.value(QLatin1String(LANGUAGE_KEY),
-                                               static_cast<int>(Language::Cxx)).toInt(&ok));
-    if (!ok)
-        d->m_language = Language::Cxx;
+    if (data.contains(LANGUAGE_KEY_V2))
+        d->m_language = Core::Id::fromSetting(data.value(QLatin1String(LANGUAGE_KEY_V2)));
+    else if (data.contains(LANGUAGE_KEY_V1)) // Import from old settings
+        d->m_language = Internal::fromLanguageV1(data.value(QLatin1String(LANGUAGE_KEY_V1)).toInt());
+
+    if (!d->m_language.isValid())
+        d->m_language = Core::Id(Constants::CXX_LANGUAGE_ID);
 
     return true;
 }
@@ -311,7 +316,7 @@ bool ToolChainFactory::canCreate()
     return false;
 }
 
-ToolChain *ToolChainFactory::create(ToolChain::Language l)
+ToolChain *ToolChainFactory::create(Core::Id l)
 {
     Q_UNUSED(l);
     return nullptr;
diff --git a/src/plugins/projectexplorer/toolchain.h b/src/plugins/projectexplorer/toolchain.h
index 4a402f4afec..f844e940f6f 100644
--- a/src/plugins/projectexplorer/toolchain.h
+++ b/src/plugins/projectexplorer/toolchain.h
@@ -43,6 +43,17 @@ namespace ProjectExplorer {
 
 namespace Internal { class ToolChainPrivate; }
 
+namespace Deprecated {
+namespace Toolchain {
+enum Language {
+    None = 0,
+    C,
+    Cxx
+};
+QString languageId(Language l);
+} // namespace Toolchain
+} // namespace Deprecated
+
 class Abi;
 class HeaderPath;
 class IOutputParser;
@@ -114,16 +125,7 @@ public:
     virtual void addToEnvironment(Utils::Environment &env) const = 0;
     virtual QString makeCommand(const Utils::Environment &env) const = 0;
 
-    enum class Language {
-        None = 0,
-        C,
-        Cxx
-    };
-    static const QSet<Language>& allLanguages();
-    static QString languageDisplayName(Language language);
-    static QString languageId(Language l);
-
-    Language language() const;
+    Core::Id language() const;
 
     virtual Utils::FileName compilerCommand() const = 0;
     virtual IOutputParser *outputParser() const = 0;
@@ -139,7 +141,7 @@ public:
     virtual QVariantMap toMap() const;
     virtual QList<Task> validateKit(const Kit *k) const;
 
-    void setLanguage(const Language &l);
+    void setLanguage(Core::Id language);
 
 protected:
     explicit ToolChain(Core::Id typeId, Detection d);
@@ -170,7 +172,7 @@ public:
     virtual QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown);
 
     virtual bool canCreate();
-    virtual ToolChain *create(ToolChain::Language l);
+    virtual ToolChain *create(Core::Id l);
 
     virtual bool canRestore(const QVariantMap &data);
     virtual ToolChain *restore(const QVariantMap &data);
@@ -179,7 +181,7 @@ public:
     static Core::Id typeIdFromMap(const QVariantMap &data);
     static void autoDetectionToMap(QVariantMap &data, bool detected);
 
-    virtual QSet<ToolChain::Language> supportedLanguages() const = 0;
+    virtual QSet<Core::Id> supportedLanguages() const = 0;
 
 protected:
     void setDisplayName(const QString &name) { m_displayName = name; }
@@ -188,9 +190,4 @@ private:
     QString m_displayName;
 };
 
-inline uint qHash(const ProjectExplorer::ToolChain::Language &l, uint seed = 0)
-{
-    return QT_PREPEND_NAMESPACE(qHash)(static_cast<int>(l), seed);
-}
-
 } // namespace ProjectExplorer
diff --git a/src/plugins/projectexplorer/toolchainmanager.cpp b/src/plugins/projectexplorer/toolchainmanager.cpp
index ac089540938..fd8c2ea2315 100644
--- a/src/plugins/projectexplorer/toolchainmanager.cpp
+++ b/src/plugins/projectexplorer/toolchainmanager.cpp
@@ -63,16 +63,22 @@ namespace Internal {
 // ToolChainManagerPrivate
 // --------------------------------------------------------------------------
 
+struct LanguageDisplayPair
+{
+    Core::Id id;
+    QString displayName;
+};
+
 class ToolChainManagerPrivate
 {
 public:
-    ToolChainManagerPrivate() : m_writer(nullptr) {}
     ~ToolChainManagerPrivate();
 
     QMap<QString, FileName> m_abiToDebugger;
-    PersistentSettingsWriter *m_writer;
+    PersistentSettingsWriter *m_writer = nullptr;
 
     QList<ToolChain *> m_toolChains; // prioritized List
+    QVector<LanguageDisplayPair> m_languages;
 };
 
 ToolChainManagerPrivate::~ToolChainManagerPrivate()
@@ -399,7 +405,7 @@ void ToolChainManager::notifyAboutUpdate(ToolChain *tc)
 bool ToolChainManager::registerToolChain(ToolChain *tc)
 {
     QTC_ASSERT(tc, return false);
-    QTC_ASSERT(tc->language() != ToolChain::Language::None, return false);
+    QTC_ASSERT(isLanguageSupported(tc->language()), return false);
     QTC_ASSERT(d->m_writer, return false);
 
     if (d->m_toolChains.contains(tc))
@@ -424,6 +430,35 @@ void ToolChainManager::deregisterToolChain(ToolChain *tc)
     delete tc;
 }
 
+QSet<Core::Id> ToolChainManager::allLanguages()
+{
+    return Utils::transform<QSet>(d->m_languages, [](const LanguageDisplayPair &pair) {
+        return pair.id;
+    });
+}
+
+bool ToolChainManager::registerLanguage(const Core::Id &language, const QString &displayName)
+{
+    QTC_ASSERT(language.isValid(), return false);
+    QTC_ASSERT(!isLanguageSupported(language), return false);
+    QTC_ASSERT(!displayName.isEmpty(), return false);
+    d->m_languages.push_back({language, displayName});
+    return true;
+}
+
+QString ToolChainManager::displayNameOfLanguageId(const Core::Id &id)
+{
+    QTC_ASSERT(id.isValid(), return tr("None"));
+    auto entry = Utils::findOrDefault(d->m_languages, Utils::equal(&LanguageDisplayPair::id, id));
+    QTC_ASSERT(entry.id.isValid(), return tr("None"));
+    return entry.displayName;
+}
+
+bool ToolChainManager::isLanguageSupported(const Core::Id &id)
+{
+    return Utils::contains(d->m_languages, Utils::equal(&LanguageDisplayPair::id, id));
+}
+
 } // namespace ProjectExplorer
 
 #ifdef WITH_TESTS
@@ -447,7 +482,7 @@ public:
         m_valid(v)
     {
         m_toolChains.append(this);
-        setLanguage(ToolChain::Language::Cxx);
+        setLanguage(Constants::CXX_LANGUAGE_ID);
     }
 
     static QList<TTC *> toolChains();
diff --git a/src/plugins/projectexplorer/toolchainmanager.h b/src/plugins/projectexplorer/toolchainmanager.h
index 7d6588a05cf..3fdcd981266 100644
--- a/src/plugins/projectexplorer/toolchainmanager.h
+++ b/src/plugins/projectexplorer/toolchainmanager.h
@@ -29,8 +29,11 @@
 
 #include "toolchain.h"
 
+#include <coreplugin/id.h>
+
 #include <QList>
 #include <QObject>
+#include <QSet>
 #include <QString>
 
 #include <functional>
@@ -66,6 +69,11 @@ public:
     static bool registerToolChain(ToolChain *tc);
     static void deregisterToolChain(ToolChain *tc);
 
+    static QSet<Core::Id> allLanguages();
+    static bool registerLanguage(const Core::Id &language, const QString &displayName);
+    static QString displayNameOfLanguageId(const Core::Id &id);
+    static bool isLanguageSupported(const Core::Id &id);
+
     void saveToolChains();
 
 signals:
diff --git a/src/plugins/projectexplorer/toolchainoptionspage.cpp b/src/plugins/projectexplorer/toolchainoptionspage.cpp
index 42065332d23..411c95a802d 100644
--- a/src/plugins/projectexplorer/toolchainoptionspage.cpp
+++ b/src/plugins/projectexplorer/toolchainoptionspage.cpp
@@ -117,8 +117,8 @@ public:
         auto autoRoot = new StaticTreeItem(ToolChainOptionsPage::tr("Auto-detected"));
         auto manualRoot = new StaticTreeItem(ToolChainOptionsPage::tr("Manual"));
 
-        foreach (const ToolChain::Language l, ToolChain::allLanguages()) {
-            const QString dn = ToolChain::languageDisplayName(l);
+        foreach (const Core::Id &l, ToolChainManager::allLanguages()) {
+            const QString dn = ToolChainManager::displayNameOfLanguageId(l);
             auto autoNode = new StaticTreeItem(dn);
             auto manualNode = new StaticTreeItem(dn);
 
@@ -147,19 +147,19 @@ public:
         m_addButton = new QPushButton(ToolChainOptionsPage::tr("Add"), this);
         auto addMenu = new QMenu;
         foreach (ToolChainFactory *factory, m_factories) {
-            QList<ToolChain::Language> languages = factory->supportedLanguages().toList();
+            QList<Core::Id> languages = factory->supportedLanguages().toList();
             if (languages.isEmpty())
                 continue;
 
             if (languages.count() == 1) {
                 addMenu->addAction(createAction(factory->displayName(), factory, languages.at(0)));
             } else {
-                Utils::sort(languages, [](ToolChain::Language l1, ToolChain::Language l2) {
-                                return ToolChain::languageDisplayName(l1) < ToolChain::languageDisplayName(l2);
+                Utils::sort(languages, [](const Core::Id &l1, const Core::Id &l2) {
+                                return ToolChainManager::displayNameOfLanguageId(l1) < ToolChainManager::displayNameOfLanguageId(l2);
                             });
                 auto subMenu = addMenu->addMenu(factory->displayName());
-                foreach (ToolChain::Language l, languages)
-                    subMenu->addAction(createAction(ToolChain::languageDisplayName(l), factory, l));
+                foreach (const Core::Id &l, languages)
+                    subMenu->addAction(createAction(ToolChainManager::displayNameOfLanguageId(l), factory, l));
             }
         }
         m_addButton->setMenu(addMenu);
@@ -209,7 +209,7 @@ public:
 
     void toolChainSelectionChanged();
     void updateState();
-    void createToolChain(ToolChainFactory *factory, ToolChain::Language l);
+    void createToolChain(ToolChainFactory *factory, const Core::Id &language);
     void cloneToolChain();
     ToolChainTreeItem *currentTreeItem();
 
@@ -219,10 +219,10 @@ public:
     void removeToolChain(ProjectExplorer::ToolChain *);
 
     StaticTreeItem *parentForToolChain(ToolChain *tc);
-    QAction *createAction(const QString &name, ToolChainFactory *factory, ToolChain::Language l)
+    QAction *createAction(const QString &name, ToolChainFactory *factory, Core::Id language)
     {
         auto action = new QAction(name, nullptr);
-        connect(action, &QAction::triggered, [this, factory, l] { createToolChain(factory, l); });
+        connect(action, &QAction::triggered, [this, factory, language] { createToolChain(factory, language); });
         return action;
     }
 
@@ -237,7 +237,7 @@ public:
     QPushButton *m_cloneButton;
     QPushButton *m_delButton;
 
-    QHash<ToolChain::Language, QPair<StaticTreeItem *, StaticTreeItem *>> m_languageMap;
+    QHash<Core::Id, QPair<StaticTreeItem *, StaticTreeItem *>> m_languageMap;
 
     QList<ToolChainTreeItem *> m_toAddList;
     QList<ToolChainTreeItem *> m_toRemoveList;
@@ -328,7 +328,7 @@ void ToolChainOptionsWidget::apply()
     Q_ASSERT(m_toRemoveList.isEmpty());
 
     // Update tool chains:
-    foreach (ToolChain::Language l, m_languageMap.keys()) {
+    foreach (const Core::Id &l, m_languageMap.keys()) {
         StaticTreeItem *parent = m_languageMap.value(l).second;
         foreach (TreeItem *item, parent->children()) {
             auto tcItem = static_cast<ToolChainTreeItem *>(item);
@@ -371,13 +371,13 @@ void ToolChainOptionsWidget::apply()
     }
 }
 
-void ToolChainOptionsWidget::createToolChain(ToolChainFactory *factory, ToolChain::Language l)
+void ToolChainOptionsWidget::createToolChain(ToolChainFactory *factory, const Core::Id &language)
 {
     QTC_ASSERT(factory, return);
     QTC_ASSERT(factory->canCreate(), return);
-    QTC_ASSERT(l != ToolChain::Language::None, return);
+    QTC_ASSERT(language.isValid(), return);
 
-    ToolChain *tc = factory->create(l);
+    ToolChain *tc = factory->create(language);
     if (!tc)
         return;
 
diff --git a/src/plugins/projectexplorer/wincetoolchain.cpp b/src/plugins/projectexplorer/wincetoolchain.cpp
index 1a5c0bcae6f..817f07cf433 100644
--- a/src/plugins/projectexplorer/wincetoolchain.cpp
+++ b/src/plugins/projectexplorer/wincetoolchain.cpp
@@ -227,9 +227,9 @@ WinCEToolChain::WinCEToolChain(const QString &name,
                                const QString &binPath,
                                const QString &includePath,
                                const QString &libPath,
-                               const Language &l,
+                               Core::Id language,
                                Detection d) :
-    AbstractMsvcToolChain(Constants::WINCE_TOOLCHAIN_TYPEID, l, d, abi, vcvarsBat),
+    AbstractMsvcToolChain(Constants::WINCE_TOOLCHAIN_TYPEID, language, d, abi, vcvarsBat),
     m_msvcVer(msvcVer),
     m_ceVer(ceVer),
     m_binPath(binPath),
@@ -339,9 +339,9 @@ WinCEToolChainFactory::WinCEToolChainFactory()
     setDisplayName(tr("WinCE"));
 }
 
-QSet<ToolChain::Language> WinCEToolChainFactory::supportedLanguages() const
+QSet<Core::Id> WinCEToolChainFactory::supportedLanguages() const
 {
-    return { ProjectExplorer::ToolChain::Language::Cxx };
+    return { Constants::CXX_LANGUAGE_ID };
 }
 
 static ToolChain *findOrCreateToolChain(const QList<ToolChain *> &alreadyKnown,
@@ -366,7 +366,7 @@ static ToolChain *findOrCreateToolChain(const QList<ToolChain *> &alreadyKnown,
                                          });
     if (!tc)
         tc = new WinCEToolChain(name, abi, vcvarsBat, msvcVer, ceVer, binPath, includePath, libPath,
-                                ProjectExplorer::ToolChain::Language::Cxx, d);
+                                Constants::CXX_LANGUAGE_ID, d);
     return tc;
 }
 
diff --git a/src/plugins/projectexplorer/wincetoolchain.h b/src/plugins/projectexplorer/wincetoolchain.h
index b6fb6951075..49ed789407d 100644
--- a/src/plugins/projectexplorer/wincetoolchain.h
+++ b/src/plugins/projectexplorer/wincetoolchain.h
@@ -43,7 +43,7 @@ public:
                    const QString &binPath,
                    const QString &includePath,
                    const QString &libPath,
-                   const Language &l,
+                   Core::Id language,
                    Detection d = ManualDetection);
 
     Utils::FileNameList suggestedMkspecList() const override;
@@ -106,7 +106,7 @@ class WinCEToolChainFactory : public ToolChainFactory
 
 public:
     WinCEToolChainFactory();
-    QSet<ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     QList<ToolChain *> autoDetect(const QList<ToolChain *> &alreadyKnown) override;
 
diff --git a/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp b/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
index 89bb848464b..b12f649c36a 100644
--- a/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
+++ b/src/plugins/qbsprojectmanager/defaultpropertyprovider.cpp
@@ -183,9 +183,9 @@ QVariantMap DefaultPropertyProvider::autoGeneratedProperties(const ProjectExplor
         data.insert(QLatin1String(QBS_SYSROOT), sysroot);
 
     ProjectExplorer::ToolChain *tcC
-            = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::ToolChain::Language::C);
+            = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::C_LANGUAGE_ID);
     ProjectExplorer::ToolChain *tcCxx
-            = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::ToolChain::Language::Cxx);
+            = ProjectExplorer::ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!tcC && !tcCxx)
         return data;
 
diff --git a/src/plugins/qbsprojectmanager/qbsbuildconfiguration.cpp b/src/plugins/qbsprojectmanager/qbsbuildconfiguration.cpp
index dd59a117bfb..ef4ad8209c5 100644
--- a/src/plugins/qbsprojectmanager/qbsbuildconfiguration.cpp
+++ b/src/plugins/qbsprojectmanager/qbsbuildconfiguration.cpp
@@ -134,7 +134,7 @@ Internal::QbsProject *QbsBuildConfiguration::project() const
 
 IOutputParser *QbsBuildConfiguration::createOutputParser() const
 {
-    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     return tc ? tc->outputParser() : 0;
 }
 
diff --git a/src/plugins/qmakeandroidsupport/androidpackageinstallationstep.cpp b/src/plugins/qmakeandroidsupport/androidpackageinstallationstep.cpp
index 40e8b3942a4..d07d766462f 100644
--- a/src/plugins/qmakeandroidsupport/androidpackageinstallationstep.cpp
+++ b/src/plugins/qmakeandroidsupport/androidpackageinstallationstep.cpp
@@ -31,6 +31,7 @@
 #include <projectexplorer/buildsteplist.h>
 #include <projectexplorer/target.h>
 #include <projectexplorer/buildconfiguration.h>
+#include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/toolchain.h>
 #include <projectexplorer/kitinformation.h>
 #include <projectexplorer/gnumakeparser.h>
@@ -65,7 +66,7 @@ bool AndroidPackageInstallationStep::init(QList<const BuildStep *> &earlierSteps
 
     ProjectExplorer::ToolChain *tc
             = ProjectExplorer::ToolChainKitInformation::toolChain(target()->kit(),
-                                                                  ProjectExplorer::ToolChain::Language::Cxx);
+                                                                  ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     ProjectExplorer::ProcessParameters *pp = processParameters();
     pp->setMacroExpander(bc->macroExpander());
diff --git a/src/plugins/qmakeprojectmanager/makestep.cpp b/src/plugins/qmakeprojectmanager/makestep.cpp
index ec32d8f1898..1eecbfa625f 100644
--- a/src/plugins/qmakeprojectmanager/makestep.cpp
+++ b/src/plugins/qmakeprojectmanager/makestep.cpp
@@ -115,7 +115,7 @@ QString MakeStep::effectiveMakeCommand() const
         QmakeBuildConfiguration *bc = qmakeBuildConfiguration();
         if (!bc)
             bc = qobject_cast<QmakeBuildConfiguration *>(target()->activeBuildConfiguration());
-        ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+        ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
         if (bc && tc)
             makeCmd = tc->makeCommand(bc->environment());
@@ -135,7 +135,7 @@ QVariantMap MakeStep::toMap() const
 
 QStringList MakeStep::automaticallyAddedArguments() const
 {
-    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!tc || tc->targetAbi().binaryFormat() == Abi::PEFormat)
         return QStringList();
     return QStringList() << QLatin1String("-w") << QLatin1String("-r");
@@ -165,7 +165,7 @@ bool MakeStep::init(QList<const BuildStep *> &earlierSteps)
     if (!bc)
         emit addTask(Task::buildConfigurationMissingTask());
 
-    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!tc)
         emit addTask(Task::compilerMissingTask());
 
@@ -394,7 +394,7 @@ MakeStepConfigWidget::~MakeStepConfigWidget()
 void MakeStepConfigWidget::updateDetails()
 {
     ToolChain *tc
-            = ToolChainKitInformation::toolChain(m_makeStep->target()->kit(), ToolChain::Language::Cxx);
+            = ToolChainKitInformation::toolChain(m_makeStep->target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     QmakeBuildConfiguration *bc = m_makeStep->qmakeBuildConfiguration();
     if (!bc)
         bc = qobject_cast<QmakeBuildConfiguration *>(m_makeStep->target()->activeBuildConfiguration());
diff --git a/src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp b/src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp
index 02f85ee487e..5b730a4a7b3 100644
--- a/src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakebuildconfiguration.cpp
@@ -172,7 +172,7 @@ void QmakeBuildConfiguration::kitChanged()
 
 void QmakeBuildConfiguration::toolChainUpdated(ToolChain *tc)
 {
-    if (ToolChainKitInformation::toolChain(target()->kit(), ToolChain::Language::Cxx) == tc)
+    if (ToolChainKitInformation::toolChain(target()->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID) == tc)
         emitProFileEvaluateNeeded();
 }
 
@@ -757,7 +757,7 @@ QmakeBuildConfiguration::LastKitState::LastKitState(Kit *k)
       m_sysroot(SysRootKitInformation::sysRoot(k).toString()),
       m_mkspec(QmakeKitInformation::mkspec(k).toString())
 {
-    ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     m_toolchain = tc ? tc->id() : QByteArray();
 }
 
diff --git a/src/plugins/qmakeprojectmanager/qmakekitinformation.cpp b/src/plugins/qmakeprojectmanager/qmakekitinformation.cpp
index bbf3ebbfd9a..4b29b0cf481 100644
--- a/src/plugins/qmakeprojectmanager/qmakekitinformation.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakekitinformation.cpp
@@ -81,13 +81,12 @@ void QmakeKitInformation::setup(Kit *k)
     if (spec.isEmpty())
         spec = version->mkspec();
 
-
-    ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(k, Constants::CXX_LANGUAGE_ID);
 
     if (!tc || (!tc->suggestedMkspecList().empty() && !tc->suggestedMkspecList().contains(spec))) {
         const QList<ToolChain *> possibleTcs = ToolChainManager::toolChains([version, &spec](const ToolChain *t) {
             return t->isValid()
-                && t->language() == ToolChain::Language::Cxx
+                && t->language() == Core::Id(Constants::CXX_LANGUAGE_ID)
                 && version->qtAbis().contains(t->targetAbi());
         });
         ToolChain *possibleTc
@@ -149,7 +148,7 @@ FileName QmakeKitInformation::defaultMkspec(const Kit *k)
     if (!version) // No version, so no qmake
         return FileName();
 
-    return version->mkspecFor(ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx));
+    return version->mkspecFor(ToolChainKitInformation::toolChain(k, Constants::CXX_LANGUAGE_ID));
 }
 
 } // namespace QmakeProjectManager
diff --git a/src/plugins/qmakeprojectmanager/qmakeproject.cpp b/src/plugins/qmakeprojectmanager/qmakeproject.cpp
index d8241f717bb..7aff1613a4a 100644
--- a/src/plugins/qmakeprojectmanager/qmakeproject.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakeproject.cpp
@@ -1360,7 +1360,7 @@ void QmakeProject::collectLibraryData(const QmakeProFileNode *node, DeploymentDa
     if (targetPath.isEmpty())
         return;
     const Kit * const kit = activeTarget()->kit();
-    const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx);
+    const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!toolchain)
         return;
 
@@ -1497,16 +1497,16 @@ void QmakeProject::warnOnToolChainMismatch(const QmakeProFileNode *pro) const
     if (!bc)
         return;
 
-    testToolChain(ToolChainKitInformation::toolChain(t->kit(), ToolChain::Language::C),
+    testToolChain(ToolChainKitInformation::toolChain(t->kit(), ProjectExplorer::Constants::C_LANGUAGE_ID),
                   getFullPathOf(pro, QmakeCc, bc));
-    testToolChain(ToolChainKitInformation::toolChain(t->kit(), ToolChain::Language::Cxx),
+    testToolChain(ToolChainKitInformation::toolChain(t->kit(), ProjectExplorer::Constants::CXX_LANGUAGE_ID),
                   getFullPathOf(pro, QmakeCxx, bc));
 }
 
 QString QmakeProject::executableFor(const QmakeProFileNode *node)
 {
     const Kit * const kit = activeTarget()->kit();
-    const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx);
+    const ToolChain * const toolchain = ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (!toolchain)
         return QString();
 
diff --git a/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp b/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
index ac7d14d23ff..f76953d1794 100644
--- a/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakeprojectimporter.cpp
@@ -32,6 +32,7 @@
 #include "makefileparse.h"
 #include "qmakestep.h"
 
+#include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/kitmanager.h>
 #include <projectexplorer/toolchain.h>
 #include <projectexplorer/toolchainmanager.h>
@@ -160,7 +161,7 @@ QList<void *> QmakeProjectImporter::examineDirectory(const FileName &importPath)
             qCDebug(logs) << "  IOS found without osType, adjusting osType" << data->osType;
         }
 
-        if (version->type() == Constants::DESKTOPQT) {
+        if (version->type() == QtSupport::Constants::DESKTOPQT) {
             const QList<ProjectExplorer::Abi> abis = version->qtAbis();
             if (!abis.isEmpty()) {
                 ProjectExplorer::Abi abi = abis.first();
@@ -202,7 +203,7 @@ bool QmakeProjectImporter::matchKit(void *directoryData, const Kit *k) const
 
     BaseQtVersion *kitVersion = QtKitInformation::qtVersion(k);
     FileName kitSpec = QmakeKitInformation::mkspec(k);
-    ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (kitSpec.isEmpty() && kitVersion)
         kitSpec = kitVersion->mkspecFor(tc);
     QMakeStepConfig::TargetArchConfig kitTargetArch = QMakeStepConfig::NoArch;
diff --git a/src/plugins/qmakeprojectmanager/qmakestep.cpp b/src/plugins/qmakeprojectmanager/qmakestep.cpp
index e393f6d4950..937f6149995 100644
--- a/src/plugins/qmakeprojectmanager/qmakestep.cpp
+++ b/src/plugins/qmakeprojectmanager/qmakestep.cpp
@@ -162,7 +162,7 @@ QMakeStepConfig QMakeStep::deducedArguments() const
     ProjectExplorer::Kit *kit = target()->kit();
     QMakeStepConfig config;
     ProjectExplorer::ToolChain *tc
-            = ProjectExplorer::ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx);
+            = ProjectExplorer::ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     ProjectExplorer::Abi targetAbi;
     if (tc)
         targetAbi = tc->targetAbi();
diff --git a/src/plugins/qmldesigner/designercore/instances/puppetcreator.cpp b/src/plugins/qmldesigner/designercore/instances/puppetcreator.cpp
index 45bce25c663..9e2735766a7 100644
--- a/src/plugins/qmldesigner/designercore/instances/puppetcreator.cpp
+++ b/src/plugins/qmldesigner/designercore/instances/puppetcreator.cpp
@@ -35,6 +35,7 @@
 
 #include <projectexplorer/kit.h>
 #include <projectexplorer/project.h>
+#include <projectexplorer/projectexplorerconstants.h>
 #include <projectexplorer/toolchain.h>
 #include <qmakeprojectmanager/qmakeproject.h>
 #include <qmakeprojectmanager/qmakenodes.h>
@@ -463,7 +464,7 @@ QString PuppetCreator::buildCommand() const
 
     ProjectExplorer::ToolChain *toolChain
             = ProjectExplorer::ToolChainKitInformation::toolChain(m_kit,
-                                                                  ProjectExplorer::ToolChain::Language::Cxx);
+                                                                  ProjectExplorer::Constants::CXX_LANGUAGE_ID);
 
     if (toolChain)
         return toolChain->makeCommand(environment);
diff --git a/src/plugins/qnx/qnxconfiguration.cpp b/src/plugins/qnx/qnxconfiguration.cpp
index 361a756c8fe..66c455b0e6d 100644
--- a/src/plugins/qnx/qnxconfiguration.cpp
+++ b/src/plugins/qnx/qnxconfiguration.cpp
@@ -179,7 +179,7 @@ void QnxConfiguration::deactivate()
     foreach (Kit *kit, KitManager::kits()) {
         if (kit->isAutoDetected()
                 && DeviceTypeKitInformation::deviceTypeId(kit) == Constants::QNX_QNX_OS_TYPE
-                && toolChainsToRemove.contains(ToolChainKitInformation::toolChain(kit, ToolChain::Language::Cxx)))
+                && toolChainsToRemove.contains(ToolChainKitInformation::toolChain(kit, ProjectExplorer::Constants::CXX_LANGUAGE_ID)))
             KitManager::deregisterKit(kit);
     }
 
@@ -268,7 +268,7 @@ QnxToolChain *QnxConfiguration::createToolChain(const Target &target)
 {
     QnxToolChain *toolChain = new QnxToolChain(ToolChain::AutoDetection);
     toolChain->resetToolChain(qccCompilerPath());
-    toolChain->setLanguage(ToolChain::Language::Cxx);
+    toolChain->setLanguage(ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     toolChain->setTargetAbi(target.m_abi);
     toolChain->setDisplayName(
                 QCoreApplication::translate(
@@ -305,7 +305,7 @@ ProjectExplorer::Kit *QnxConfiguration::createKit(
 
     QtKitInformation::setQtVersion(kit, qnxQt);
     ToolChainKitInformation::setToolChain(kit, toolChain);
-    ToolChainKitInformation::clearToolChain(kit, ToolChain::Language::C);
+    ToolChainKitInformation::clearToolChain(kit, ProjectExplorer::Constants::C_LANGUAGE_ID);
 
     if (debugger.isValid())
         DebuggerKitInformation::setDebugger(kit, debugger);
diff --git a/src/plugins/qnx/qnxtoolchain.cpp b/src/plugins/qnx/qnxtoolchain.cpp
index f51900193f9..511bb9aaeda 100644
--- a/src/plugins/qnx/qnxtoolchain.cpp
+++ b/src/plugins/qnx/qnxtoolchain.cpp
@@ -29,6 +29,8 @@
 #include "qnxconstants.h"
 #include "qnxutils.h"
 
+#include <projectexplorer/projectexplorerconstants.h>
+
 #include <utils/pathchooser.h>
 
 #include <QFormLayout>
@@ -66,7 +68,7 @@ QnxToolChain::QnxToolChain(ToolChain::Detection d)
     : GccToolChain(Constants::QNX_TOOLCHAIN_ID, d)
 { }
 
-QnxToolChain::QnxToolChain(Language l, ToolChain::Detection d)
+QnxToolChain::QnxToolChain(Core::Id l, ToolChain::Detection d)
     : QnxToolChain(d)
 {
     setLanguage(l);
@@ -175,9 +177,9 @@ QList<ProjectExplorer::ToolChain *> QnxToolChainFactory::autoDetect(
     return tcs;
 }
 
-QSet<ToolChain::Language> QnxToolChainFactory::supportedLanguages() const
+QSet<Core::Id> QnxToolChainFactory::supportedLanguages() const
 {
-    return { ProjectExplorer::ToolChain::Language::Cxx };
+    return { ProjectExplorer::Constants::CXX_LANGUAGE_ID };
 }
 
 bool QnxToolChainFactory::canRestore(const QVariantMap &data)
@@ -200,7 +202,7 @@ bool QnxToolChainFactory::canCreate()
     return true;
 }
 
-ToolChain *QnxToolChainFactory::create(ToolChain::Language l)
+ToolChain *QnxToolChainFactory::create(Core::Id l)
 {
     return new QnxToolChain(l, ToolChain::ManualDetection);
 }
diff --git a/src/plugins/qnx/qnxtoolchain.h b/src/plugins/qnx/qnxtoolchain.h
index 7ba3d49110b..c2acccb60b1 100644
--- a/src/plugins/qnx/qnxtoolchain.h
+++ b/src/plugins/qnx/qnxtoolchain.h
@@ -35,7 +35,7 @@ class QnxToolChain : public ProjectExplorer::GccToolChain
 {
 public:
     explicit QnxToolChain(Detection d);
-    explicit QnxToolChain(Language l, Detection d);
+    explicit QnxToolChain(Core::Id l, Detection d);
 
     QString typeDisplayName() const override;
 
@@ -73,13 +73,13 @@ public:
     QList<ProjectExplorer::ToolChain *> autoDetect(
             const QList<ProjectExplorer::ToolChain *> &alreadyKnown) override;
 
-    QSet<ProjectExplorer::ToolChain::Language> supportedLanguages() const override;
+    QSet<Core::Id> supportedLanguages() const override;
 
     bool canRestore(const QVariantMap &data) override;
     ProjectExplorer::ToolChain *restore(const QVariantMap &data) override;
 
     bool canCreate() override;
-    ProjectExplorer::ToolChain *create(ProjectExplorer::ToolChain::Language l) override;
+    ProjectExplorer::ToolChain *create(Core::Id l) override;
 };
 
 //----------------------------------------------------------------------------
diff --git a/src/plugins/qtsupport/baseqtversion.cpp b/src/plugins/qtsupport/baseqtversion.cpp
index 7cb6a4f944b..8f167dc411f 100644
--- a/src/plugins/qtsupport/baseqtversion.cpp
+++ b/src/plugins/qtsupport/baseqtversion.cpp
@@ -494,7 +494,7 @@ QList<Task> BaseQtVersion::validateKit(const Kit *k)
                        FileName(), -1, ProjectExplorer::Constants::TASK_CATEGORY_BUILDSYSTEM);
     }
 
-    ToolChain *tc = ToolChainKitInformation::toolChain(k, ToolChain::Language::Cxx);
+    ToolChain *tc = ToolChainKitInformation::toolChain(k, ProjectExplorer::Constants::CXX_LANGUAGE_ID);
     if (tc) {
         Abi targetAbi = tc->targetAbi();
         bool fuzzyMatch = false;
diff --git a/tests/unit/unittest/cppbaseprojectpartbuilder-test.cpp b/tests/unit/unittest/cppbaseprojectpartbuilder-test.cpp
index 56c572d1c66..ff834c1cc32 100644
--- a/tests/unit/unittest/cppbaseprojectpartbuilder-test.cpp
+++ b/tests/unit/unittest/cppbaseprojectpartbuilder-test.cpp
@@ -92,7 +92,7 @@ private:
     QString displayName() const override { return QString(); }
     QString projectFilePath() const override { return QString(); }
 
-    ToolChainInterfacePtr toolChain(ProjectExplorer::ToolChain::Language,
+    ToolChainInterfacePtr toolChain(Core::Id,
                                     const QStringList &) const override
     { return ToolChainInterfacePtr(m_toolChain); }