CppTools/ProjectExplorer: Remove enum duplication

... between CppTools::ProjectPart and ProjectExplorer::ToolChain.

Change-Id: I8b448747e454adbed77547460383b8515462cc81
Reviewed-by: Tobias Hunger <tobias.hunger@qt.io>
Reviewed-by: Ivan Donchevskii <ivan.donchevskii@qt.io>

29 files changed, 206 insertions, 234 deletions

diff --git a/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp b/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp
index 706677d87e..7a185bb821 100644
--- a/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp
+++ b/src/plugins/clangcodemodel/clangeditordocumentprocessor.cpp
@@ -469,7 +469,7 @@ private:
         // Determine file kind with respect to ambiguous headers.
         CppTools::ProjectFile::Kind fileKind = CppTools::ProjectFile::classify(m_filePath);
         if (fileKind == CppTools::ProjectFile::AmbiguousHeader) {
-            fileKind = m_projectPart.languageVersion <= CppTools::ProjectPart::LatestCVersion
+            fileKind = m_projectPart.languageVersion <= ProjectExplorer::LanguageVersion::LatestC
                  ? CppTools::ProjectFile::CHeader
                  : CppTools::ProjectFile::CXXHeader;
         }
diff --git a/src/plugins/cppcheck/cppchecktool.cpp b/src/plugins/cppcheck/cppchecktool.cpp
index 5288e0f4c1..38d70be089 100644
--- a/src/plugins/cppcheck/cppchecktool.cpp
+++ b/src/plugins/cppcheck/cppchecktool.cpp
@@ -137,7 +137,7 @@ QStringList CppcheckTool::additionalArguments(const CppTools::ProjectPart &part)
     if (!m_options.guessArguments)
         return result;
 
-    using Version = CppTools::ProjectPart::LanguageVersion;
+    using Version = ProjectExplorer::LanguageVersion;
     switch (part.languageVersion) {
     case Version::C89:
         result.push_back("--std=c89 --language=c");
diff --git a/src/plugins/cpptools/compileroptionsbuilder.cpp b/src/plugins/cpptools/compileroptionsbuilder.cpp
index b05bd09d1f..9113d69747 100644
--- a/src/plugins/cpptools/compileroptionsbuilder.cpp
+++ b/src/plugins/cpptools/compileroptionsbuilder.cpp
@@ -59,7 +59,7 @@ QStringList CompilerOptionsBuilder::build(CppTools::ProjectFile::Kind fileKind,
     m_options.clear();
 
     if (fileKind == ProjectFile::CHeader || fileKind == ProjectFile::CSource) {
-        QTC_ASSERT(m_projectPart.languageVersion <= ProjectPart::LatestCVersion,
+        QTC_ASSERT(m_projectPart.languageVersion <= ProjectExplorer::LanguageVersion::LatestC,
                    return QStringList(););
     }
 
@@ -196,7 +196,7 @@ void CompilerOptionsBuilder::addExtraCodeModelFlags()
 
 void CompilerOptionsBuilder::enableExceptions()
 {
-    if (m_projectPart.languageVersion > ProjectPart::LatestCVersion)
+    if (m_projectPart.languageVersion > ProjectExplorer::LanguageVersion::LatestC)
         add(QLatin1String("-fcxx-exceptions"));
     add(QLatin1String("-fexceptions"));
 }
@@ -378,7 +378,8 @@ void CompilerOptionsBuilder::addMacros(const ProjectExplorer::Macros &macros)
 
 void CompilerOptionsBuilder::updateLanguageOption(ProjectFile::Kind fileKind)
 {
-    const bool objcExt = m_projectPart.languageExtensions & ProjectPart::ObjectiveCExtensions;
+    const bool objcExt = m_projectPart.languageExtensions
+                         & ProjectExplorer::LanguageExtension::ObjectiveC;
     const QStringList options = createLanguageOptionGcc(fileKind, objcExt);
     if (options.isEmpty())
         return;
@@ -394,48 +395,51 @@ void CompilerOptionsBuilder::updateLanguageOption(ProjectFile::Kind fileKind)
 
 void CompilerOptionsBuilder::addOptionsForLanguage(bool checkForBorlandExtensions)
 {
+    using ProjectExplorer::LanguageExtension;
+    using ProjectExplorer::LanguageVersion;
+
     QStringList opts;
-    const ProjectPart::LanguageExtensions languageExtensions = m_projectPart.languageExtensions;
-    const bool gnuExtensions = languageExtensions & ProjectPart::GnuExtensions;
+    const ProjectExplorer::LanguageExtensions languageExtensions = m_projectPart.languageExtensions;
+    const bool gnuExtensions = languageExtensions & LanguageExtension::Gnu;
 
     switch (m_projectPart.languageVersion) {
-    case ProjectPart::C89:
+    case LanguageVersion::C89:
         opts << (gnuExtensions ? QLatin1String("-std=gnu89") : QLatin1String("-std=c89"));
         break;
-    case ProjectPart::C99:
+    case LanguageVersion::C99:
         opts << (gnuExtensions ? QLatin1String("-std=gnu99") : QLatin1String("-std=c99"));
         break;
-    case ProjectPart::C11:
+    case LanguageVersion::C11:
         opts << (gnuExtensions ? QLatin1String("-std=gnu11") : QLatin1String("-std=c11"));
         break;
-    case ProjectPart::C18:
+    case LanguageVersion::C18:
         // Clang 6, 7 and current trunk do not accept "gnu18"/"c18", so use the "*17" variants.
         opts << (gnuExtensions ? QLatin1String("-std=gnu17") : QLatin1String("-std=c17"));
         break;
-    case ProjectPart::CXX11:
+    case LanguageVersion::CXX11:
         opts << (gnuExtensions ? QLatin1String("-std=gnu++11") : QLatin1String("-std=c++11"));
         break;
-    case ProjectPart::CXX98:
+    case LanguageVersion::CXX98:
         opts << (gnuExtensions ? QLatin1String("-std=gnu++98") : QLatin1String("-std=c++98"));
         break;
-    case ProjectPart::CXX03:
+    case LanguageVersion::CXX03:
         opts << (gnuExtensions ? QLatin1String("-std=gnu++03") : QLatin1String("-std=c++03"));
         break;
-    case ProjectPart::CXX14:
+    case LanguageVersion::CXX14:
         opts << (gnuExtensions ? QLatin1String("-std=gnu++14") : QLatin1String("-std=c++14"));
         break;
-    case ProjectPart::CXX17:
+    case LanguageVersion::CXX17:
         opts << (gnuExtensions ? QLatin1String("-std=gnu++17") : QLatin1String("-std=c++17"));
         break;
-    case ProjectPart::CXX2a:
+    case LanguageVersion::CXX2a:
         opts << (gnuExtensions ? QLatin1String("-std=gnu++2a") : QLatin1String("-std=c++2a"));
         break;
     }
 
-    if (languageExtensions & ProjectPart::MicrosoftExtensions)
+    if (languageExtensions & LanguageExtension::Microsoft)
         opts << QLatin1String("-fms-extensions");
 
-    if (checkForBorlandExtensions && (languageExtensions & ProjectPart::BorlandExtensions))
+    if (checkForBorlandExtensions && (languageExtensions & LanguageExtension::Borland))
         opts << QLatin1String("-fborland-extensions");
 
     m_options.append(opts);
diff --git a/src/plugins/cpptools/cppcodemodelinspectordumper.cpp b/src/plugins/cpptools/cppcodemodelinspectordumper.cpp
index 540ac99104..e359f71a05 100644
--- a/src/plugins/cpptools/cppcodemodelinspectordumper.cpp
+++ b/src/plugins/cpptools/cppcodemodelinspectordumper.cpp
@@ -103,9 +103,9 @@ QString Utils::toString(ProjectExplorer::HeaderPathType type)
     return QString();
 }
 
-QString Utils::toString(ProjectPart::LanguageVersion languageVersion)
+QString Utils::toString(ProjectExplorer::LanguageVersion languageVersion)
 {
-#define CASE_LANGUAGEVERSION(x) case ProjectPart::x: return QLatin1String(#x)
+#define CASE_LANGUAGEVERSION(x) case ProjectExplorer::LanguageVersion::x: return QLatin1String(#x)
     switch (languageVersion) {
     CASE_LANGUAGEVERSION(C89);
     CASE_LANGUAGEVERSION(C99);
@@ -123,19 +123,19 @@ QString Utils::toString(ProjectPart::LanguageVersion languageVersion)
     return QString();
 }
 
-QString Utils::toString(ProjectPart::LanguageExtensions languageExtension)
+QString Utils::toString(ProjectExplorer::LanguageExtensions languageExtension)
 {
     QString result;
 
-#define CASE_LANGUAGE_EXTENSION(ext) if (languageExtension & ProjectPart::ext) \
+#define CASE_LANGUAGE_EXTENSION(ext) if (languageExtension & ProjectExplorer::LanguageExtension::ext) \
     result += QLatin1String(#ext ", ");
 
-    CASE_LANGUAGE_EXTENSION(NoExtensions);
-    CASE_LANGUAGE_EXTENSION(GnuExtensions);
-    CASE_LANGUAGE_EXTENSION(MicrosoftExtensions);
-    CASE_LANGUAGE_EXTENSION(BorlandExtensions);
-    CASE_LANGUAGE_EXTENSION(OpenMPExtensions);
-    CASE_LANGUAGE_EXTENSION(ObjectiveCExtensions);
+    CASE_LANGUAGE_EXTENSION(None);
+    CASE_LANGUAGE_EXTENSION(Gnu);
+    CASE_LANGUAGE_EXTENSION(Microsoft);
+    CASE_LANGUAGE_EXTENSION(Borland);
+    CASE_LANGUAGE_EXTENSION(OpenMP);
+    CASE_LANGUAGE_EXTENSION(ObjectiveC);
 #undef CASE_LANGUAGE_EXTENSION
     if (result.endsWith(QLatin1String(", ")))
         result.chop(2);
diff --git a/src/plugins/cpptools/cppcodemodelinspectordumper.h b/src/plugins/cpptools/cppcodemodelinspectordumper.h
index d460acf496..b0f7a18a01 100644
--- a/src/plugins/cpptools/cppcodemodelinspectordumper.h
+++ b/src/plugins/cpptools/cppcodemodelinspectordumper.h
@@ -47,8 +47,8 @@ struct CPPTOOLS_EXPORT Utils
     static QString toString(CPlusPlus::Document::CheckMode checkMode);
     static QString toString(CPlusPlus::Document::DiagnosticMessage::Level level);
     static QString toString(ProjectExplorer::HeaderPathType type);
-    static QString toString(CppTools::ProjectPart::LanguageVersion languageVersion);
-    static QString toString(CppTools::ProjectPart::LanguageExtensions languageExtension);
+    static QString toString(ProjectExplorer::LanguageVersion languageVersion);
+    static QString toString(ProjectExplorer::LanguageExtensions languageExtension);
     static QString toString(CppTools::ProjectPart::QtVersion qtVersion);
     static QString toString(CppTools::ProjectPart::BuildTargetType buildTargetType);
     static QString toString(const QVector<CppTools::ProjectFile> &projectFiles);
diff --git a/src/plugins/cpptools/cppmodelmanager.cpp b/src/plugins/cpptools/cppmodelmanager.cpp
index 9303d66338..5db9dd601d 100644
--- a/src/plugins/cpptools/cppmodelmanager.cpp
+++ b/src/plugins/cpptools/cppmodelmanager.cpp
@@ -1170,8 +1170,9 @@ ProjectPart::Ptr CppModelManager::fallbackProjectPart()
 
     // Do not activate ObjectiveCExtensions since this will lead to the
     // "objective-c++" language option for a project-less *.cpp file.
-    part->languageExtensions = ProjectPart::AllExtensions;
-    part->languageExtensions &= ~ProjectPart::ObjectiveCExtensions;
+    part->languageExtensions = ProjectExplorer::LanguageExtension::All;
+    part->languageExtensions &= ~ProjectExplorer::LanguageExtensions(
+        ProjectExplorer::LanguageExtension::ObjectiveC);
 
     part->qtVersion = ProjectPart::Qt5;
     part->updateLanguageFeatures();
diff --git a/src/plugins/cpptools/cppprojectinfogenerator.cpp b/src/plugins/cpptools/cppprojectinfogenerator.cpp
index 8d04f2429e..0e2d8bc366 100644
--- a/src/plugins/cpptools/cppprojectinfogenerator.cpp
+++ b/src/plugins/cpptools/cppprojectinfogenerator.cpp
@@ -68,16 +68,16 @@ public:
         if (m_tcInfo.macroInspectionRunner) {
             auto macroInspectionReport = m_tcInfo.macroInspectionRunner(m_flags.commandLineFlags);
             m_projectPart.toolChainMacros = macroInspectionReport.macros;
-            m_projectPart.languageVersion = static_cast<ProjectPart::LanguageVersion>(
-                macroInspectionReport.languageVersion);
+            m_projectPart.languageVersion = macroInspectionReport.languageVersion;
         } else { // No compiler set in kit.
             if (m_language == Language::C)
-                m_projectPart.languageVersion = ProjectPart::LanguageVersion::LatestCVersion;
+                m_projectPart.languageVersion = ProjectExplorer::LanguageVersion::LatestC;
             if (m_language == Language::CXX)
-                m_projectPart.languageVersion = ProjectPart::LanguageVersion::LatestCxxVersion;
+                m_projectPart.languageVersion = ProjectExplorer::LanguageVersion::LatestCxx;
         }
 
-        mapLanguageExtensions();
+        m_projectPart.languageExtensions = m_flags.languageExtensions;
+
         addHeaderPaths();
     }
 
@@ -89,25 +89,6 @@ private:
                 : ProjectPart::WordWidth32Bit;
     }
 
-    void mapLanguageExtensions()
-    {
-        using namespace ProjectExplorer;
-
-        const ToolChain::CompilerFlags &compilerFlags = m_flags.compilerFlags;
-        ProjectPart::LanguageExtensions &languageExtensions = m_projectPart.languageExtensions;
-
-        if (compilerFlags & ToolChain::BorlandExtensions)
-            languageExtensions |= ProjectPart::BorlandExtensions;
-        if (compilerFlags & ToolChain::GnuExtensions)
-            languageExtensions |= ProjectPart::GnuExtensions;
-        if (compilerFlags & ToolChain::MicrosoftExtensions)
-            languageExtensions |= ProjectPart::MicrosoftExtensions;
-        if (compilerFlags & ToolChain::OpenMP)
-            languageExtensions |= ProjectPart::OpenMPExtensions;
-        if (compilerFlags & ToolChain::ObjectiveC)
-            languageExtensions |= ProjectPart::ObjectiveCExtensions;
-    }
-
     void addHeaderPaths()
     {
         if (!m_tcInfo.headerPathsRunner)
@@ -181,6 +162,8 @@ static ProjectPart::Ptr projectPartFromRawProjectPart(const RawProjectPart &rawP
 
 QVector<ProjectPart::Ptr> ProjectInfoGenerator::createProjectParts(const RawProjectPart &rawProjectPart)
 {
+    using ProjectExplorer::LanguageExtension;
+
     QVector<ProjectPart::Ptr> result;
     ProjectFileCategorizer cat(rawProjectPart.displayName,
                                rawProjectPart.files,
@@ -196,7 +179,7 @@ QVector<ProjectPart::Ptr> ProjectInfoGenerator::createProjectParts(const RawProj
                                         cat.cxxSources(),
                                         cat.partName("C++"),
                                         Language::CXX,
-                                        ProjectPart::NoExtensions);
+                                        LanguageExtension::None);
         }
 
         if (cat.hasObjcxxSources()) {
@@ -205,7 +188,7 @@ QVector<ProjectPart::Ptr> ProjectInfoGenerator::createProjectParts(const RawProj
                                         cat.objcxxSources(),
                                         cat.partName("Obj-C++"),
                                         Language::CXX,
-                                        ProjectPart::ObjectiveCExtensions);
+                                        LanguageExtension::ObjectiveC);
         }
 
         if (cat.hasCSources()) {
@@ -214,7 +197,7 @@ QVector<ProjectPart::Ptr> ProjectInfoGenerator::createProjectParts(const RawProj
                                         cat.cSources(),
                                         cat.partName("C"),
                                         Language::C,
-                                        ProjectPart::NoExtensions);
+                                        LanguageExtension::None);
         }
 
         if (cat.hasObjcSources()) {
@@ -223,18 +206,19 @@ QVector<ProjectPart::Ptr> ProjectInfoGenerator::createProjectParts(const RawProj
                                         cat.objcSources(),
                                         cat.partName("Obj-C"),
                                         Language::C,
-                                        ProjectPart::ObjectiveCExtensions);
+                                        LanguageExtension::ObjectiveC);
         }
     }
     return result;
 }
 
-ProjectPart::Ptr ProjectInfoGenerator::createProjectPart(const RawProjectPart &rawProjectPart,
-                                                         const ProjectPart::Ptr &templateProjectPart,
-                                                         const ProjectFiles &projectFiles,
-                                                         const QString &partName,
-                                                         Language language,
-                                                         ProjectPart::LanguageExtensions languageExtensions)
+ProjectPart::Ptr ProjectInfoGenerator::createProjectPart(
+    const RawProjectPart &rawProjectPart,
+    const ProjectPart::Ptr &templateProjectPart,
+    const ProjectFiles &projectFiles,
+    const QString &partName,
+    Language language,
+    ProjectExplorer::LanguageExtensions languageExtensions)
 {
     ProjectPart::Ptr part(templateProjectPart->copy());
     part->displayName = partName;
diff --git a/src/plugins/cpptools/cppprojectinfogenerator.h b/src/plugins/cpptools/cppprojectinfogenerator.h
index 963c9a748b..752c648fd1 100644
--- a/src/plugins/cpptools/cppprojectinfogenerator.h
+++ b/src/plugins/cpptools/cppprojectinfogenerator.h
@@ -49,7 +49,7 @@ private:
                                        const ProjectFiles &projectFiles,
                                        const QString &partName,
                                        Language language,
-                                       ProjectPart::LanguageExtensions languageExtensions);
+                                       ProjectExplorer::LanguageExtensions languageExtensions);
 
 private:
     const QFutureInterface<void> m_futureInterface;
diff --git a/src/plugins/cpptools/cppprojectpartchooser.cpp b/src/plugins/cpptools/cppprojectpartchooser.cpp
index bbf9ca3559..a7bb56beb0 100644
--- a/src/plugins/cpptools/cppprojectpartchooser.cpp
+++ b/src/plugins/cpptools/cppprojectpartchooser.cpp
@@ -116,7 +116,8 @@ private:
 
     bool isPreferredLanguage(const ProjectPart &projectPart) const
     {
-        const bool isCProjectPart = projectPart.languageVersion <= ProjectPart::LatestCVersion;
+        const bool isCProjectPart = projectPart.languageVersion
+                                    <= ProjectExplorer::LanguageVersion::LatestC;
         return (m_languagePreference == Language::C && isCProjectPart)
             || (m_languagePreference == Language::Cxx && !isCProjectPart);
     }
diff --git a/src/plugins/cpptools/cpprawprojectpart.cpp b/src/plugins/cpptools/cpprawprojectpart.cpp
index 6f60d9cf46..9675be5291 100644
--- a/src/plugins/cpptools/cpprawprojectpart.cpp
+++ b/src/plugins/cpptools/cpprawprojectpart.cpp
@@ -39,7 +39,7 @@ RawProjectPartFlags::RawProjectPartFlags(const ProjectExplorer::ToolChain *toolC
     if (toolChain) {
         this->commandLineFlags = commandLineFlags;
         warningFlags = toolChain->warningFlags(commandLineFlags);
-        compilerFlags = toolChain->compilerFlags(commandLineFlags);
+        languageExtensions = toolChain->languageExtensions(commandLineFlags);
     }
 }
 
diff --git a/src/plugins/cpptools/cpprawprojectpart.h b/src/plugins/cpptools/cpprawprojectpart.h
index 4aa17a3a47..e238fa1d81 100644
--- a/src/plugins/cpptools/cpprawprojectpart.h
+++ b/src/plugins/cpptools/cpprawprojectpart.h
@@ -28,6 +28,7 @@
 #include "cpptools_global.h"
 #include "projectpart.h"
 
+#include <projectexplorer/language.h>
 #include <projectexplorer/toolchain.h>
 
 #include <functional>
@@ -45,8 +46,7 @@ public:
     QStringList commandLineFlags;
     // The following are deduced from commandLineFlags.
     ProjectExplorer::WarningFlags warningFlags = ProjectExplorer::WarningFlags::Default;
-    ProjectExplorer::ToolChain::CompilerFlags compilerFlags
-        = ProjectExplorer::ToolChain::CompilerFlag::NoFlags;
+    ProjectExplorer::LanguageExtensions languageExtensions = ProjectExplorer::LanguageExtension::None;
 };
 
 class CPPTOOLS_EXPORT RawProjectPart
diff --git a/src/plugins/cpptools/projectpart.cpp b/src/plugins/cpptools/projectpart.cpp
index 4dc871e87e..bcfe4b3e52 100644
--- a/src/plugins/cpptools/projectpart.cpp
+++ b/src/plugins/cpptools/projectpart.cpp
@@ -35,12 +35,13 @@ namespace CppTools {
 
 void ProjectPart::updateLanguageFeatures()
 {
-    const bool hasCxx = languageVersion >= CXX98;
+    const bool hasCxx = languageVersion >= ProjectExplorer::LanguageVersion::CXX98;
     const bool hasQt = hasCxx && qtVersion != NoQt;
-    languageFeatures.cxx11Enabled = languageVersion >= CXX11;
+    languageFeatures.cxx11Enabled = languageVersion >= ProjectExplorer::LanguageVersion::CXX11;
     languageFeatures.cxxEnabled = hasCxx;
-    languageFeatures.c99Enabled = languageVersion >= C99;
-    languageFeatures.objCEnabled = languageExtensions.testFlag(ObjectiveCExtensions);
+    languageFeatures.c99Enabled = languageVersion >= ProjectExplorer::LanguageVersion::C99;
+    languageFeatures.objCEnabled = languageExtensions.testFlag(
+        ProjectExplorer::LanguageExtension::ObjectiveC);
     languageFeatures.qtEnabled = hasQt;
     languageFeatures.qtMocRunEnabled = hasQt;
     if (!hasQt) {
diff --git a/src/plugins/cpptools/projectpart.h b/src/plugins/cpptools/projectpart.h
index 8d04e71ff3..77a08128bf 100644
--- a/src/plugins/cpptools/projectpart.h
+++ b/src/plugins/cpptools/projectpart.h
@@ -30,6 +30,7 @@
 #include "cppprojectfile.h"
 
 #include <projectexplorer/headerpath.h>
+#include <projectexplorer/language.h>
 #include <projectexplorer/projectexplorer_global.h>
 #include <projectexplorer/projectmacro.h>
 
@@ -49,38 +50,6 @@ namespace CppTools {
 class CPPTOOLS_EXPORT ProjectPart
 {
 public:
-    // Keep in sync with Toolchain::LanguageVersion!
-    enum LanguageVersion {
-        C89,
-        C99,
-        C11,
-        C18,
-        LatestCVersion = C18,
-        CXX98,
-        CXX03,
-        CXX11,
-        CXX14,
-        CXX17,
-        CXX2a,
-        LatestCxxVersion = CXX2a,
-    };
-
-    enum LanguageExtension {
-        NoExtensions         = 0,
-        GnuExtensions        = 1 << 0,
-        MicrosoftExtensions  = 1 << 1,
-        BorlandExtensions    = 1 << 2,
-        OpenMPExtensions     = 1 << 3,
-        ObjectiveCExtensions = 1 << 4,
-
-        AllExtensions = GnuExtensions
-                      | MicrosoftExtensions
-                      | BorlandExtensions
-                      | OpenMPExtensions
-                      | ObjectiveCExtensions
-    };
-    Q_DECLARE_FLAGS(LanguageExtensions, LanguageExtension)
-
     enum QtVersion {
         UnknownQt = -1,
         NoQt,
@@ -129,8 +98,8 @@ public:
 
     ProjectExplorer::Macros projectMacros;
 
-    LanguageVersion languageVersion = LatestCxxVersion;
-    LanguageExtensions languageExtensions = NoExtensions;
+    ProjectExplorer::LanguageVersion languageVersion = ProjectExplorer::LanguageVersion::LatestCxx;
+    ProjectExplorer::LanguageExtensions languageExtensions = ProjectExplorer::LanguageExtension::None;
     ProjectExplorer::WarningFlags warningFlags = ProjectExplorer::WarningFlags::Default;
     QtVersion qtVersion = UnknownQt;
     CPlusPlus::LanguageFeatures languageFeatures;
diff --git a/src/plugins/nim/project/nimtoolchain.cpp b/src/plugins/nim/project/nimtoolchain.cpp
index ec1651a682..399814db32 100644
--- a/src/plugins/nim/project/nimtoolchain.cpp
+++ b/src/plugins/nim/project/nimtoolchain.cpp
@@ -87,9 +87,9 @@ Macros NimToolChain::predefinedMacros(const QStringList &) const
     return Macros();
 }
 
-ToolChain::CompilerFlags NimToolChain::compilerFlags(const QStringList &) const
+LanguageExtensions NimToolChain::languageExtensions(const QStringList &) const
 {
-    return CompilerFlag::NoFlags;
+    return LanguageExtension::None;
 }
 
 WarningFlags NimToolChain::warningFlags(const QStringList &) const
diff --git a/src/plugins/nim/project/nimtoolchain.h b/src/plugins/nim/project/nimtoolchain.h
index 4f866d5f27..ae3431a55c 100644
--- a/src/plugins/nim/project/nimtoolchain.h
+++ b/src/plugins/nim/project/nimtoolchain.h
@@ -42,7 +42,7 @@ public:
 
     MacroInspectionRunner createMacroInspectionRunner() const override;
     ProjectExplorer::Macros predefinedMacros(const QStringList &flags) const final;
-    CompilerFlags compilerFlags(const QStringList &flags) const final;
+    ProjectExplorer::LanguageExtensions languageExtensions(const QStringList &flags) const final;
     ProjectExplorer::WarningFlags warningFlags(const QStringList &flags) const final;
 
     BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override;
diff --git a/src/plugins/projectexplorer/abstractmsvctoolchain.cpp b/src/plugins/projectexplorer/abstractmsvctoolchain.cpp
index 151c4400ef..9cbed08156 100644
--- a/src/plugins/projectexplorer/abstractmsvctoolchain.cpp
+++ b/src/plugins/projectexplorer/abstractmsvctoolchain.cpp
@@ -117,11 +117,8 @@ QString AbstractMsvcToolChain::originalTargetTriple() const
 //
 // For _MSV_VER values, see https://docs.microsoft.com/en-us/cpp/preprocessor/predefined-macros?view=vs-2017.
 //
-ToolChain::LanguageVersion static languageVersionForMsvc(const Core::Id &language,
-                                                         const Macros &macros)
+LanguageVersion static languageVersionForMsvc(const Core::Id &language, const Macros &macros)
 {
-    using LanguageVersion = ToolChain::LanguageVersion;
-
     int mscVer = -1;
     QByteArray msvcLang;
     for (const ProjectExplorer::Macro &macro : macros) {
@@ -146,7 +143,7 @@ ToolChain::LanguageVersion static languageVersionForMsvc(const Core::Id &languag
         return LanguageVersion::C99;
     } else {
         QTC_CHECK(false && "Unexpected toolchain language, assuming latest C++ we support.");
-        return LanguageVersion::LatestCxxVersion;
+        return LanguageVersion::LatestCxx;
     }
 }
 
@@ -183,17 +180,17 @@ ProjectExplorer::Macros AbstractMsvcToolChain::predefinedMacros(const QStringLis
     return createMacroInspectionRunner()(cxxflags).macros;
 }
 
-ToolChain::CompilerFlags AbstractMsvcToolChain::compilerFlags(const QStringList &cxxflags) const
+LanguageExtensions AbstractMsvcToolChain::languageExtensions(const QStringList &cxxflags) const
 {
-    CompilerFlags flags(MicrosoftExtensions);
+    LanguageExtensions extensions(LanguageExtension::Microsoft);
     if (cxxflags.contains(QLatin1String("/openmp")))
-        flags |= OpenMP;
+        extensions |= LanguageExtension::OpenMP;
 
     // see http://msdn.microsoft.com/en-us/library/0k0w269d%28v=vs.71%29.aspx
     if (cxxflags.contains(QLatin1String("/Za")))
-        flags &= ~MicrosoftExtensions;
+        extensions &= ~LanguageExtensions(LanguageExtension::Microsoft);
 
-    return flags;
+    return extensions;
 }
 
 /**
diff --git a/src/plugins/projectexplorer/abstractmsvctoolchain.h b/src/plugins/projectexplorer/abstractmsvctoolchain.h
index d949073f46..bc6b297e74 100644
--- a/src/plugins/projectexplorer/abstractmsvctoolchain.h
+++ b/src/plugins/projectexplorer/abstractmsvctoolchain.h
@@ -55,7 +55,7 @@ public:
 
     MacroInspectionRunner createMacroInspectionRunner() const override;
     Macros predefinedMacros(const QStringList &cxxflags) const override;
-    CompilerFlags compilerFlags(const QStringList &cxxflags) const override;
+    LanguageExtensions languageExtensions(const QStringList &cxxflags) const override;
     WarningFlags warningFlags(const QStringList &cflags) const override;
     BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override;
     HeaderPaths builtInHeaderPaths(const QStringList &cxxflags,
diff --git a/src/plugins/projectexplorer/customtoolchain.cpp b/src/plugins/projectexplorer/customtoolchain.cpp
index 7b952e0fe2..d2c6ed8eea 100644
--- a/src/plugins/projectexplorer/customtoolchain.cpp
+++ b/src/plugins/projectexplorer/customtoolchain.cpp
@@ -140,9 +140,9 @@ Macros CustomToolChain::predefinedMacros(const QStringList &cxxflags) const
     return createMacroInspectionRunner()(cxxflags).macros;
 }
 
-ToolChain::CompilerFlags CustomToolChain::compilerFlags(const QStringList &) const
+LanguageExtensions CustomToolChain::languageExtensions(const QStringList &) const
 {
-    return NoFlags;
+    return LanguageExtension::None;
 }
 
 WarningFlags CustomToolChain::warningFlags(const QStringList &cxxflags) const
diff --git a/src/plugins/projectexplorer/customtoolchain.h b/src/plugins/projectexplorer/customtoolchain.h
index 28fd7a1828..e9d672ad33 100644
--- a/src/plugins/projectexplorer/customtoolchain.h
+++ b/src/plugins/projectexplorer/customtoolchain.h
@@ -73,7 +73,7 @@ public:
 
     MacroInspectionRunner createMacroInspectionRunner() const override;
     Macros predefinedMacros(const QStringList &cxxflags) const override;
-    CompilerFlags compilerFlags(const QStringList &cxxflags) const override;
+    LanguageExtensions languageExtensions(const QStringList &cxxflags) const override;
     WarningFlags warningFlags(const QStringList &cxxflags) const override;
     const Macros &rawPredefinedMacros() const;
     void setPredefinedMacros(const Macros &macros);
diff --git a/src/plugins/projectexplorer/gcctoolchain.cpp b/src/plugins/projectexplorer/gcctoolchain.cpp
index 2fa6de6737..b01b1473ea 100644
--- a/src/plugins/projectexplorer/gcctoolchain.cpp
+++ b/src/plugins/projectexplorer/gcctoolchain.cpp
@@ -302,9 +302,9 @@ QString GccToolChain::defaultDisplayName() const
                                                                   compilerCommand().parentDir().toUserOutput());
 }
 
-ToolChain::CompilerFlags GccToolChain::defaultCompilerFlags() const
+LanguageExtensions GccToolChain::defaultLanguageExtensions() const
 {
-    return CompilerFlags(GnuExtensions);
+    return LanguageExtension::Gnu;
 }
 
 QString GccToolChain::typeDisplayName() const
@@ -449,7 +449,7 @@ ToolChain::MacroInspectionRunner GccToolChain::createMacroInspectionRunner() con
         macroCache->insert(arguments, report);
 
         qCDebug(gccLog) << "MacroInspectionReport for code model:";
-        qCDebug(gccLog) << "Language version:" << report.languageVersion;
+        qCDebug(gccLog) << "Language version:" << static_cast<int>(report.languageVersion);
         for (const Macro &m : filteredMacros) {
             qCDebug(gccLog) << compilerCommand.toUserOutput()
                             << (lang == Constants::CXX_LANGUAGE_ID ? ": C++ [" : ": C [")
@@ -476,29 +476,29 @@ ProjectExplorer::Macros GccToolChain::predefinedMacros(const QStringList &cxxfla
 }
 
 /**
- * @brief Parses gcc flags -std=*, -fopenmp, -fms-extensions, -ansi.
+ * @brief Parses gcc flags -std=*, -fopenmp, -fms-extensions.
  * @see http://gcc.gnu.org/onlinedocs/gcc/C-Dialect-Options.html
  */
-ToolChain::CompilerFlags GccToolChain::compilerFlags(const QStringList &cxxflags) const
+LanguageExtensions GccToolChain::languageExtensions(const QStringList &cxxflags) const
 {
-    CompilerFlags flags = defaultCompilerFlags();
+    LanguageExtensions extensions = defaultLanguageExtensions();
 
     const QStringList allCxxflags = m_platformCodeGenFlags + cxxflags; // add only cxxflags is empty?
     foreach (const QString &flag, allCxxflags) {
         if (flag.startsWith("-std=")) {
             const QByteArray std = flag.mid(5).toLatin1();
             if (std.startsWith("gnu"))
-                flags |= CompilerFlags(GnuExtensions);
+                extensions |= LanguageExtension::Gnu;
             else
-                flags &= ~CompilerFlags(GnuExtensions);
+                extensions &= ~LanguageExtensions(LanguageExtension::Gnu);
         } else if (flag == "-fopenmp") {
-            flags |= OpenMP;
+            extensions |= LanguageExtension::Gnu;
         } else if (flag == "-fms-extensions") {
-            flags |= MicrosoftExtensions;
+            extensions |= LanguageExtension::Microsoft;
         }
     }
 
-    return flags;
+    return extensions;
 }
 
 WarningFlags GccToolChain::warningFlags(const QStringList &cflags) const
@@ -1234,15 +1234,15 @@ QString ClangToolChain::makeCommand(const Environment &environment) const
 }
 
 /**
- * @brief Similar to \a GccToolchain::compilerFlags, but recognizes
+ * @brief Similar to \a GccToolchain::languageExtensions, but recognizes
  * "-fborland-extensions".
  */
-ToolChain::CompilerFlags ClangToolChain::compilerFlags(const QStringList &cxxflags) const
+LanguageExtensions ClangToolChain::languageExtensions(const QStringList &cxxflags) const
 {
-    CompilerFlags flags = GccToolChain::compilerFlags(cxxflags);
+    LanguageExtensions extensions = GccToolChain::languageExtensions(cxxflags);
     if (cxxflags.contains("-fborland-extensions"))
-        flags |= BorlandExtensions;
-    return flags;
+        extensions |= LanguageExtension::Borland;
+    return extensions;
 }
 
 WarningFlags ClangToolChain::warningFlags(const QStringList &cflags) const
@@ -1283,9 +1283,9 @@ void ClangToolChain::addToEnvironment(Environment &env) const
     env.unset("PWD");
 }
 
-ToolChain::CompilerFlags ClangToolChain::defaultCompilerFlags() const
+LanguageExtensions ClangToolChain::defaultLanguageExtensions() const
 {
-    return CompilerFlags(GnuExtensions);
+    return LanguageExtension::Gnu;
 }
 
 IOutputParser *ClangToolChain::outputParser() const
@@ -1476,25 +1476,25 @@ QString LinuxIccToolChain::typeDisplayName() const
 }
 
 /**
- * Similar to \a GccToolchain::compilerFlags, but uses "-openmp" instead of
+ * Similar to \a GccToolchain::languageExtensions, but uses "-openmp" instead of
  * "-fopenmp" and "-fms-dialect[=ver]" instead of "-fms-extensions".
  * @see UNIX manual for "icc"
  */
-ToolChain::CompilerFlags LinuxIccToolChain::compilerFlags(const QStringList &cxxflags) const
+LanguageExtensions LinuxIccToolChain::languageExtensions(const QStringList &cxxflags) const
 {
     QStringList copy = cxxflags;
     copy.removeAll("-fopenmp");
     copy.removeAll("-fms-extensions");
 
-    CompilerFlags flags = GccToolChain::compilerFlags(cxxflags);
+    LanguageExtensions extensions = GccToolChain::languageExtensions(cxxflags);
     if (cxxflags.contains("-openmp"))
-        flags |= OpenMP;
+        extensions |= LanguageExtension::OpenMP;
     if (cxxflags.contains("-fms-dialect")
             || cxxflags.contains("-fms-dialect=8")
             || cxxflags.contains("-fms-dialect=9")
             || cxxflags.contains("-fms-dialect=10"))
-        flags |= MicrosoftExtensions;
-    return flags;
+        extensions |= LanguageExtension::Microsoft;
+    return extensions;
 }
 
 IOutputParser *LinuxIccToolChain::outputParser() const
diff --git a/src/plugins/projectexplorer/gcctoolchain.h b/src/plugins/projectexplorer/gcctoolchain.h
index 64e2acbe51..63c2b78a44 100644
--- a/src/plugins/projectexplorer/gcctoolchain.h
+++ b/src/plugins/projectexplorer/gcctoolchain.h
@@ -140,7 +140,7 @@ public:
 
     bool isValid() const override;
 
-    CompilerFlags compilerFlags(const QStringList &cxxflags) const override;
+    LanguageExtensions languageExtensions(const QStringList &cxxflags) const override;
     WarningFlags warningFlags(const QStringList &cflags) const override;
 
     MacroInspectionRunner createMacroInspectionRunner() const override;
@@ -200,7 +200,7 @@ protected:
     Macros macroCache(const QStringList &allCxxflags) const;
 
     virtual QString defaultDisplayName() const;
-    virtual CompilerFlags defaultCompilerFlags() const;
+    virtual LanguageExtensions defaultLanguageExtensions() const;
 
     virtual DetectedAbisResult detectSupportedAbis() const;
     virtual QString detectVersion() const;
@@ -273,7 +273,7 @@ public:
     QString typeDisplayName() const override;
     QString makeCommand(const Utils::Environment &environment) const override;
 
-    CompilerFlags compilerFlags(const QStringList &cxxflags) const override;
+    LanguageExtensions languageExtensions(const QStringList &cxxflags) const override;
     WarningFlags warningFlags(const QStringList &cflags) const override;
 
     IOutputParser *outputParser() const override;
@@ -284,7 +284,7 @@ public:
     void addToEnvironment(Utils::Environment &env) const override;
 
 protected:
-    CompilerFlags defaultCompilerFlags() const override;
+    LanguageExtensions defaultLanguageExtensions() const override;
 
 private:
     friend class Internal::ClangToolChainFactory;
@@ -321,7 +321,7 @@ class PROJECTEXPLORER_EXPORT LinuxIccToolChain : public GccToolChain
 public:
     QString typeDisplayName() const override;
 
-    CompilerFlags compilerFlags(const QStringList &cxxflags) const override;
+    LanguageExtensions languageExtensions(const QStringList &cxxflags) const override;
     IOutputParser *outputParser() const override;
 
     ToolChain *clone() const override;
diff --git a/src/plugins/projectexplorer/language.h b/src/plugins/projectexplorer/language.h
new file mode 100644
index 0000000000..5946553a6d
--- /dev/null
+++ b/src/plugins/projectexplorer/language.h
@@ -0,0 +1,65 @@
+/****************************************************************************
+**
+** Copyright (C) 2018 The Qt Company Ltd.
+** Contact: https://www.qt.io/licensing/
+**
+** This file is part of Qt Creator.
+**
+** Commercial License Usage
+** Licensees holding valid commercial Qt licenses may use this file in
+** accordance with the commercial license agreement provided with the
+** Software or, alternatively, in accordance with the terms contained in
+** a written agreement between you and The Qt Company. For licensing terms
+** and conditions see https://www.qt.io/terms-conditions. For further
+** information use the contact form at https://www.qt.io/contact-us.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3 as published by the Free Software
+** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
+** included in the packaging of this file. Please review the following
+** information to ensure the GNU General Public License requirements will
+** be met: https://www.gnu.org/licenses/gpl-3.0.html.
+**
+****************************************************************************/
+
+#pragma once
+
+#include <QFlags>
+
+namespace ProjectExplorer {
+
+enum class LanguageVersion {
+    C89,
+    C99,
+    C11,
+    C18,
+    LatestC = C18,
+    CXX98,
+    CXX03,
+    CXX11,
+    CXX14,
+    CXX17,
+    CXX2a,
+    LatestCxx = CXX2a,
+};
+
+enum class LanguageExtension {
+    None       = 0,
+
+    Gnu        = 1 << 0,
+    Microsoft  = 1 << 1,
+    Borland    = 1 << 2,
+    OpenMP     = 1 << 3,
+    ObjectiveC = 1 << 4,
+
+    All = Gnu
+        | Microsoft
+        | Borland
+        | OpenMP
+        | ObjectiveC
+};
+
+Q_DECLARE_FLAGS(LanguageExtensions, LanguageExtension)
+
+} // namespace ProjectExplorer
diff --git a/src/plugins/projectexplorer/toolchain.cpp b/src/plugins/projectexplorer/toolchain.cpp
index e11481d06f..dfff01af18 100644
--- a/src/plugins/projectexplorer/toolchain.cpp
+++ b/src/plugins/projectexplorer/toolchain.cpp
@@ -292,12 +292,12 @@ static long toLanguageVersionAsLong(QByteArray dateAsByteArray)
     return dateAsByteArray.toLong(nullptr);
 }
 
-ToolChain::LanguageVersion ToolChain::cxxLanguageVersion(const QByteArray &cplusplusMacroValue)
+LanguageVersion ToolChain::cxxLanguageVersion(const QByteArray &cplusplusMacroValue)
 {
     const long version = toLanguageVersionAsLong(cplusplusMacroValue);
 
     if (version > 201703L)
-        return LanguageVersion::LatestCxxVersion;
+        return LanguageVersion::LatestCxx;
 
     switch (version) {
     case 201703L: return LanguageVersion::CXX17;
@@ -307,11 +307,11 @@ ToolChain::LanguageVersion ToolChain::cxxLanguageVersion(const QByteArray &cplus
     case 199711L: return LanguageVersion::CXX03;
     default:
         QTC_CHECK(false && "Unexpected __cplusplus value, assuming latest C++ we support.");
-        return LanguageVersion::LatestCxxVersion;
+        return LanguageVersion::LatestCxx;
     }
 }
 
-ToolChain::LanguageVersion ToolChain::languageVersion(const Core::Id &language, const Macros &macros)
+LanguageVersion ToolChain::languageVersion(const Core::Id &language, const Macros &macros)
 {
     if (language == Constants::CXX_LANGUAGE_ID) {
         for (const ProjectExplorer::Macro &macro : macros) {
@@ -320,14 +320,14 @@ ToolChain::LanguageVersion ToolChain::languageVersion(const Core::Id &language,
         }
 
         QTC_CHECK(false && "__cplusplus is not predefined, assuming latest C++ we support.");
-        return LanguageVersion::LatestCxxVersion;
+        return LanguageVersion::LatestCxx;
     } else if (language == Constants::C_LANGUAGE_ID) {
         for (const ProjectExplorer::Macro &macro : macros) {
             if (macro.key == "__STDC_VERSION__") {
                 const long version = toLanguageVersionAsLong(macro.value);
 
                 if (version > 201710L)
-                    return LanguageVersion::LatestCVersion;
+                    return LanguageVersion::LatestC;
 
                 switch (version) {
                 case 201710L: return LanguageVersion::C18;
@@ -337,7 +337,7 @@ ToolChain::LanguageVersion ToolChain::languageVersion(const Core::Id &language,
                 default:
                     QTC_CHECK(false && "Unexpected __STDC_VERSION__ value, "
                                        "assuming latest C version we support.");
-                    return LanguageVersion::LatestCVersion;
+                    return LanguageVersion::LatestC;
                 }
             }
         }
@@ -347,7 +347,7 @@ ToolChain::LanguageVersion ToolChain::languageVersion(const Core::Id &language,
         return LanguageVersion::C89;
     } else {
         QTC_CHECK(false && "Unexpected toolchain language, assuming latest C++ we support.");
-        return LanguageVersion::LatestCxxVersion;
+        return LanguageVersion::LatestCxx;
     }
 }
 
diff --git a/src/plugins/projectexplorer/toolchain.h b/src/plugins/projectexplorer/toolchain.h
index 89bbab09b4..be13424ceb 100644
--- a/src/plugins/projectexplorer/toolchain.h
+++ b/src/plugins/projectexplorer/toolchain.h
@@ -29,6 +29,7 @@
 #include "projectexplorer_global.h"
 
 #include "headerpath.h"
+#include "language.h"
 #include "projectmacro.h"
 
 #include <coreplugin/id.h>
@@ -107,34 +108,7 @@ public:
 
     virtual bool isValid() const = 0;
 
-    enum CompilerFlag {
-        NoFlags = 0,
-        GnuExtensions = 0x8,
-        MicrosoftExtensions = 0x10,
-        BorlandExtensions = 0x20,
-        OpenMP = 0x40,
-        ObjectiveC = 0x80,
-    };
-
-    // Keep in sync with ProjectPart::LanguageVersion!
-    enum LanguageVersion {
-        C89,
-        C99,
-        C11,
-        C18,
-        LatestCVersion = C18,
-        CXX98,
-        CXX03,
-        CXX11,
-        CXX14,
-        CXX17,
-        CXX2a,
-        LatestCxxVersion = CXX2a,
-    };
-
-    Q_DECLARE_FLAGS(CompilerFlags, CompilerFlag)
-
-    virtual CompilerFlags compilerFlags(const QStringList &cxxflags) const = 0;
+    virtual LanguageExtensions languageExtensions(const QStringList &cxxflags) const = 0;
     virtual WarningFlags warningFlags(const QStringList &cflags) const = 0;
 
     class MacroInspectionReport
diff --git a/src/plugins/projectexplorer/toolchainsettingsaccessor.cpp b/src/plugins/projectexplorer/toolchainsettingsaccessor.cpp
index e0055bfe81..80d280a122 100644
--- a/src/plugins/projectexplorer/toolchainsettingsaccessor.cpp
+++ b/src/plugins/projectexplorer/toolchainsettingsaccessor.cpp
@@ -310,7 +310,7 @@ public:
     bool isValid() const override { return m_valid; }
     MacroInspectionRunner createMacroInspectionRunner() const override { return MacroInspectionRunner(); }
     Macros predefinedMacros(const QStringList &cxxflags) const override { Q_UNUSED(cxxflags); return Macros(); }
-    CompilerFlags compilerFlags(const QStringList &cxxflags) const override { Q_UNUSED(cxxflags); return NoFlags; }
+    LanguageExtensions languageExtensions(const QStringList &cxxflags) const override { Q_UNUSED(cxxflags); return LanguageExtension::None; }
     WarningFlags warningFlags(const QStringList &cflags) const override { Q_UNUSED(cflags); return WarningFlags::NoWarnings; }
     BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const override { return BuiltInHeaderPathsRunner(); }
     HeaderPaths builtInHeaderPaths(const QStringList &cxxflags, const FileName &sysRoot) const override
diff --git a/tests/unit/mockup/projectexplorer/toolchain.h b/tests/unit/mockup/projectexplorer/toolchain.h
index 3ce5ad8902..985184af85 100644
--- a/tests/unit/mockup/projectexplorer/toolchain.h
+++ b/tests/unit/mockup/projectexplorer/toolchain.h
@@ -25,8 +25,9 @@
 
 #pragma once
 
-#include <projectexplorer/headerpath.h>
 #include <projectexplorer/abi.h>
+#include <projectexplorer/headerpath.h>
+#include <projectexplorer/language.h>
 #include <projectexplorer/projectmacro.h>
 #include <coreplugin/id.h>
 
@@ -39,36 +40,11 @@ class ToolChain
 public:
     Core::Id typeId() const { return Core::Id(); }
 
-    enum CompilerFlag {
-        NoFlags = 0,
-        GnuExtensions = 0x8,
-        MicrosoftExtensions = 0x10,
-        BorlandExtensions = 0x20,
-        OpenMP = 0x40,
-        ObjectiveC = 0x80,
-    };
-    Q_DECLARE_FLAGS(CompilerFlags, CompilerFlag)
-
     Abi targetAbi() const { return Abi(); }
 
     using BuiltInHeaderPathsRunner = std::function<HeaderPaths(const QStringList &cxxflags, const QString &sysRoot)>;
     virtual BuiltInHeaderPathsRunner createBuiltInHeaderPathsRunner() const { return BuiltInHeaderPathsRunner(); }
 
-    enum LanguageVersion {
-        C89,
-        C99,
-        C11,
-        C18,
-        LatestCVersion = C18,
-        CXX98,
-        CXX03,
-        CXX11,
-        CXX14,
-        CXX17,
-        CXX2a,
-        LatestCxxVersion = CXX2a,
-    };
-
     class MacroInspectionReport
     {
     public:
diff --git a/tests/unit/unittest/compileroptionsbuilder-test.cpp b/tests/unit/unittest/compileroptionsbuilder-test.cpp
index ae81f7d0ca..37d00dd676 100644
--- a/tests/unit/unittest/compileroptionsbuilder-test.cpp
+++ b/tests/unit/unittest/compileroptionsbuilder-test.cpp
@@ -51,7 +51,7 @@ protected:
     {
         projectPart.project = project.get();
         projectPart.toolchainType = ProjectExplorer::Constants::CLANG_TOOLCHAIN_TYPEID;
-        projectPart.languageVersion = CppTools::ProjectPart::CXX17;
+        projectPart.languageVersion = ProjectExplorer::LanguageVersion::CXX17;
         projectPart.toolChainWordWidth = CppTools::ProjectPart::WordWidth64Bit;
         projectPart.toolChainTargetTriple = "x86_64-apple-darwin10";
         projectPart.extraCodeModelFlags = QStringList{"-arch", "x86_64"};
@@ -231,7 +231,7 @@ TEST_F(CompilerOptionsBuilderTest, AddTargetTriple)
 
 TEST_F(CompilerOptionsBuilderTest, EnableCExceptions)
 {
-    projectPart.languageVersion = CppTools::ProjectPart::C99;
+    projectPart.languageVersion = ProjectExplorer::LanguageVersion::C99;
 
     compilerOptionsBuilder.enableExceptions();
 
@@ -261,7 +261,7 @@ TEST_F(CompilerOptionsBuilderTest, SetLanguageVersion)
 
 TEST_F(CompilerOptionsBuilderTest, HandleLanguageExtension)
 {
-    projectPart.languageExtensions = ProjectPart::ObjectiveCExtensions;
+    projectPart.languageExtensions = ProjectExplorer::LanguageExtension::ObjectiveC;
 
     compilerOptionsBuilder.updateLanguageOption(ProjectFile::CXXSource);
 
diff --git a/tests/unit/unittest/cppprojectinfogenerator-test.cpp b/tests/unit/unittest/cppprojectinfogenerator-test.cpp
index b93ab46a73..f1e24b5aee 100644
--- a/tests/unit/unittest/cppprojectinfogenerator-test.cpp
+++ b/tests/unit/unittest/cppprojectinfogenerator-test.cpp
@@ -103,7 +103,7 @@ TEST_F(ProjectInfoGenerator, ProjectPartIndicatesObjectiveCExtensionsByDefault)
 
     ASSERT_THAT(projectInfo.projectParts().size(), Eq(1));
     const ProjectPart &projectPart = *projectInfo.projectParts().at(0);
-    ASSERT_TRUE(projectPart.languageExtensions & ProjectPart::ObjectiveCExtensions);
+    ASSERT_TRUE(projectPart.languageExtensions & ProjectExplorer::LanguageExtension::ObjectiveC);
 }
 
 TEST_F(ProjectInfoGenerator, ProjectPartHasLatestLanguageVersionByDefault)
@@ -114,13 +114,13 @@ TEST_F(ProjectInfoGenerator, ProjectPartHasLatestLanguageVersionByDefault)
 
     ASSERT_THAT(projectInfo.projectParts().size(), Eq(1));
     const ProjectPart &projectPart = *projectInfo.projectParts().at(0);
-    ASSERT_THAT(projectPart.languageVersion, Eq(ProjectPart::LatestCxxVersion));
+    ASSERT_THAT(projectPart.languageVersion, Eq(ProjectExplorer::LanguageVersion::LatestCxx));
 }
 
 TEST_F(ProjectInfoGenerator, UseMacroInspectionReportForLanguageVersion)
 {
     projectUpdateInfo.cxxToolChainInfo.macroInspectionRunner = [](const QStringList &) {
-        return ToolChain::MacroInspectionReport{Macros(), ToolChain::LanguageVersion::CXX17};
+        return ToolChain::MacroInspectionReport{Macros(), ProjectExplorer::LanguageVersion::CXX17};
     };
     rawProjectPart.files = QStringList{ "foo.cpp" };
 
@@ -128,19 +128,19 @@ TEST_F(ProjectInfoGenerator, UseMacroInspectionReportForLanguageVersion)
 
     ASSERT_THAT(projectInfo.projectParts().size(), Eq(1));
     const ProjectPart &projectPart = *projectInfo.projectParts().at(0);
-    ASSERT_THAT(projectPart.languageVersion, Eq(ProjectPart::CXX17));
+    ASSERT_THAT(projectPart.languageVersion, Eq(ProjectExplorer::LanguageVersion::CXX17));
 }
 
 TEST_F(ProjectInfoGenerator, UseCompilerFlagsForLanguageExtensions)
 {
     rawProjectPart.files = QStringList{ "foo.cpp" };
-    rawProjectPart.flagsForCxx.compilerFlags = ToolChain::CompilerFlag::MicrosoftExtensions;
+    rawProjectPart.flagsForCxx.languageExtensions = ProjectExplorer::LanguageExtension::Microsoft;
 
     const ProjectInfo projectInfo = generate();
 
     ASSERT_THAT(projectInfo.projectParts().size(), Eq(1));
     const ProjectPart &projectPart = *projectInfo.projectParts().at(0);
-    ASSERT_TRUE(projectPart.languageExtensions & ProjectPart::MicrosoftExtensions);
+    ASSERT_TRUE(projectPart.languageExtensions & ProjectExplorer::LanguageExtension::Microsoft);
 }
 
 TEST_F(ProjectInfoGenerator, ProjectFileKindsMatchProjectPartVersion)
@@ -150,10 +150,10 @@ TEST_F(ProjectInfoGenerator, ProjectFileKindsMatchProjectPartVersion)
     const ProjectInfo projectInfo = generate();
 
     ASSERT_THAT(projectInfo.projectParts(),
-                UnorderedElementsAre(IsProjectPart(ProjectPart::LatestCVersion, ProjectFile::CHeader),
-                                     IsProjectPart(ProjectPart::LatestCVersion, ProjectFile::ObjCHeader),
-                                     IsProjectPart(ProjectPart::LatestCxxVersion, ProjectFile::CXXHeader),
-                                     IsProjectPart(ProjectPart::LatestCxxVersion, ProjectFile::ObjCXXHeader)));
+                UnorderedElementsAre(IsProjectPart(ProjectExplorer::LanguageVersion::LatestC, ProjectFile::CHeader),
+                                     IsProjectPart(ProjectExplorer::LanguageVersion::LatestC, ProjectFile::ObjCHeader),
+                                     IsProjectPart(ProjectExplorer::LanguageVersion::LatestCxx, ProjectFile::CXXHeader),
+                                     IsProjectPart(ProjectExplorer::LanguageVersion::LatestCxx, ProjectFile::ObjCXXHeader)));
 }
 
 void ProjectInfoGenerator::SetUp()
diff --git a/tests/unit/unittest/cppprojectpartchooser-test.cpp b/tests/unit/unittest/cppprojectpartchooser-test.cpp
index 8020d1a35c..299a888fb7 100644
--- a/tests/unit/unittest/cppprojectpartchooser-test.cpp
+++ b/tests/unit/unittest/cppprojectpartchooser-test.cpp
@@ -342,12 +342,12 @@ QList<ProjectPart::Ptr> ProjectPartChooser::createCAndCxxProjectParts()
 
     // Create project part for C
     const ProjectPart::Ptr cprojectpart{new ProjectPart};
-    cprojectpart->languageVersion = ProjectPart::C11;
+    cprojectpart->languageVersion = ProjectExplorer::LanguageVersion::C11;
     projectParts.append(cprojectpart);
 
     // Create project part for CXX
     const ProjectPart::Ptr cxxprojectpart{new ProjectPart};
-    cxxprojectpart->languageVersion = ProjectPart::CXX98;
+    cxxprojectpart->languageVersion = ProjectExplorer::LanguageVersion::CXX98;
     projectParts.append(cxxprojectpart);
 
     return projectParts;