Renamed Lang_C to Lang_C99, Lang_CXX to Lang_CXX03, and 2a to 20

[gribozavr]

Summary

I think we would be better off with tests explicitly specifying the
language mode. Right now Lang_C means C99, but reads as "any C version",
or as "unspecified C version".

I also changed '-std=c++98' to '-std=c++03' because they are aliases (so
there is no difference in practice), because Clang implements C++03
rules in practice, and because 03 makes a nice sortable progression
between 03, 11, 14, 17, 20.

[gribozavr]

Also rename 2a to 20.

[hlopko]

Looks good, thanks!

clang/include/clang/Testing/CommandLineArgs.h

 #define LLVM_CLANG_TESTING_COMMANDLINEARGS_H
 
 #include <string>
 #include <vector>
 
 namespace clang {
 
 enum TestLanguage {
-  Lang_C,
   Lang_C89,
-  Lang_CXX,
+  Lang_C99,
+  Lang_CXX03,
   Lang_CXX11,
   Lang_CXX14,
   Lang_CXX17,
-  Lang_CXX2a,
+  Lang_CXX20,
   Lang_OpenCL,
   Lang_OBJCXX
 };
 
 std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang);
 
 } // end namespace clang
 
 #endif

clang/lib/Testing/CommandLineArgs.cpp

 #include "llvm/Support/ErrorHandling.h"
 
 namespace clang {
 
 std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang) {
   std::vector<std::string> Args;
   // Test with basic arguments.
   switch (Lang) {
-  case Lang_C:
-    Args = {"-x", "c", "-std=c99"};
-    break;
   case Lang_C89:
     Args = {"-x", "c", "-std=c89"};
     break;
-  case Lang_CXX:
-    Args = {"-std=c++98", "-frtti"};
+  case Lang_C99:
+    Args = {"-x", "c", "-std=c99"};
+    break;
+  case Lang_CXX03:
+    Args = {"-std=c++03", "-frtti"};
     break;
   case Lang_CXX11:
     Args = {"-std=c++11", "-frtti"};
     break;
   case Lang_CXX14:
     Args = {"-std=c++14", "-frtti"};
     break;
   case Lang_CXX17:
     Args = {"-std=c++17", "-frtti"};
     break;
-  case Lang_CXX2a:
-    Args = {"-std=c++2a", "-frtti"};
+  case Lang_CXX20:
+    Args = {"-std=c++20", "-frtti"};
     break;
   case Lang_OBJCXX:
     Args = {"-x", "objective-c++", "-frtti"};
     break;
   case Lang_OpenCL:
     llvm_unreachable("Not implemented yet!");
   }
   return Args;
 }
 
 } // end namespace clang

clang/unittests/AST/ASTImporterGenericRedeclTest.cpp

void CheckPreviousDecl(Decl *Prev, Decl *Current) {
     }
 
     // The rest: Classes, Functions, etc.
     EXPECT_EQ(Current->getPreviousDecl(), Prev);
   }
 
   void
   TypedTest_PrototypeShouldBeImportedAsAPrototypeWhenThereIsNoDefinition() {
-    Decl *FromTU = getTuDecl(getPrototype(), Lang_CXX);
+    Decl *FromTU = getTuDecl(getPrototype(), Lang_CXX03);
     auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
     ASSERT_FALSE(FromD->isThisDeclarationADefinition());
 
-    Decl *ImportedD = Import(FromD, Lang_CXX);
+    Decl *ImportedD = Import(FromD, Lang_CXX03);
     Decl *ToTU = ImportedD->getTranslationUnitDecl();
 
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
     auto *ToD = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(ImportedD == ToD);
     EXPECT_FALSE(ToD->isThisDeclarationADefinition());
     if (auto *ToT = dyn_cast<TemplateDecl>(ToD)) {
       EXPECT_TRUE(ToT->getTemplatedDecl());
     }
   }
 
   void TypedTest_DefinitionShouldBeImportedAsADefinition() {
-    Decl *FromTU = getTuDecl(getDefinition(), Lang_CXX);
+    Decl *FromTU = getTuDecl(getDefinition(), Lang_CXX03);
     auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
     ASSERT_TRUE(FromD->isThisDeclarationADefinition());
 
-    Decl *ImportedD = Import(FromD, Lang_CXX);
+    Decl *ImportedD = Import(FromD, Lang_CXX03);
     Decl *ToTU = ImportedD->getTranslationUnitDecl();
 
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
     auto *ToD = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(ToD->isThisDeclarationADefinition());
     if (auto *ToT = dyn_cast<TemplateDecl>(ToD)) {
       EXPECT_TRUE(ToT->getTemplatedDecl());
     }
   }
 
   void TypedTest_ImportPrototypeAfterImportedPrototype() {
-    Decl *FromTU = getTuDecl(getPrototype() + getPrototype(), Lang_CXX);
+    Decl *FromTU = getTuDecl(getPrototype() + getPrototype(), Lang_CXX03);
     auto *From0 = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
     auto *From1 = LastDeclMatcher<DeclTy>().match(FromTU, getPattern());
     ASSERT_FALSE(From0->isThisDeclarationADefinition());
     ASSERT_FALSE(From1->isThisDeclarationADefinition());
 
-    Decl *Imported0 = Import(From0, Lang_CXX);
-    Decl *Imported1 = Import(From1, Lang_CXX);
+    Decl *Imported0 = Import(From0, Lang_CXX03);
+    Decl *Imported1 = Import(From1, Lang_CXX03);
     Decl *ToTU = Imported0->getTranslationUnitDecl();
 
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
     auto *To0 = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
     auto *To1 = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(Imported0 == To0);
     EXPECT_TRUE(Imported1 == To1);
     EXPECT_FALSE(To0->isThisDeclarationADefinition());
     EXPECT_FALSE(To1->isThisDeclarationADefinition());
 
     CheckPreviousDecl(To0, To1);
   }
 
   void TypedTest_ImportDefinitionAfterImportedPrototype() {
-    Decl *FromTU = getTuDecl(getPrototype() + getDefinition(), Lang_CXX);
+    Decl *FromTU = getTuDecl(getPrototype() + getDefinition(), Lang_CXX03);
     auto *FromProto = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
     auto *FromDef = LastDeclMatcher<DeclTy>().match(FromTU, getPattern());
     ASSERT_FALSE(FromProto->isThisDeclarationADefinition());
     ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
 
-    Decl *ImportedProto = Import(FromProto, Lang_CXX);
-    Decl *ImportedDef = Import(FromDef, Lang_CXX);
+    Decl *ImportedProto = Import(FromProto, Lang_CXX03);
+    Decl *ImportedDef = Import(FromDef, Lang_CXX03);
     Decl *ToTU = ImportedProto->getTranslationUnitDecl();
 
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
     auto *ToProto = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
     auto *ToDef = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(ImportedProto == ToProto);
     EXPECT_TRUE(ImportedDef == ToDef);
     EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
     EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
 
     CheckPreviousDecl(ToProto, ToDef);
   }
 
   void TypedTest_ImportPrototypeAfterImportedDefinition() {
-    Decl *FromTU = getTuDecl(getDefinition() + getPrototype(), Lang_CXX);
+    Decl *FromTU = getTuDecl(getDefinition() + getPrototype(), Lang_CXX03);
     auto *FromDef = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
     auto *FromProto = LastDeclMatcher<DeclTy>().match(FromTU, getPattern());
     ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
     ASSERT_FALSE(FromProto->isThisDeclarationADefinition());
 
-    Decl *ImportedDef = Import(FromDef, Lang_CXX);
-    Decl *ImportedProto = Import(FromProto, Lang_CXX);
+    Decl *ImportedDef = Import(FromDef, Lang_CXX03);
+    Decl *ImportedProto = Import(FromProto, Lang_CXX03);
     Decl *ToTU = ImportedDef->getTranslationUnitDecl();
 
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
     auto *ToDef = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
     auto *ToProto = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(ImportedDef == ToDef);
     EXPECT_TRUE(ImportedProto == ToProto);
     EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
     EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
 
     CheckPreviousDecl(ToDef, ToProto);
   }
 
   void TypedTest_ImportPrototypes() {
-    Decl *FromTU0 = getTuDecl(getPrototype(), Lang_CXX, "input0.cc");
-    Decl *FromTU1 = getTuDecl(getPrototype(), Lang_CXX, "input1.cc");
+    Decl *FromTU0 = getTuDecl(getPrototype(), Lang_CXX03, "input0.cc");
+    Decl *FromTU1 = getTuDecl(getPrototype(), Lang_CXX03, "input1.cc");
     auto *From0 = FirstDeclMatcher<DeclTy>().match(FromTU0, getPattern());
     auto *From1 = FirstDeclMatcher<DeclTy>().match(FromTU1, getPattern());
     ASSERT_FALSE(From0->isThisDeclarationADefinition());
     ASSERT_FALSE(From1->isThisDeclarationADefinition());
 
-    Decl *Imported0 = Import(From0, Lang_CXX);
-    Decl *Imported1 = Import(From1, Lang_CXX);
+    Decl *Imported0 = Import(From0, Lang_CXX03);
+    Decl *Imported1 = Import(From1, Lang_CXX03);
     Decl *ToTU = Imported0->getTranslationUnitDecl();
 
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
     auto *To0 = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
     auto *To1 = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(Imported0 == To0);
     EXPECT_TRUE(Imported1 == To1);
     EXPECT_FALSE(To0->isThisDeclarationADefinition());
     EXPECT_FALSE(To1->isThisDeclarationADefinition());
 
     CheckPreviousDecl(To0, To1);
   }
 
   void TypedTest_ImportDefinitions() {
-    Decl *FromTU0 = getTuDecl(getDefinition(), Lang_CXX, "input0.cc");
-    Decl *FromTU1 = getTuDecl(getDefinition(), Lang_CXX, "input1.cc");
+    Decl *FromTU0 = getTuDecl(getDefinition(), Lang_CXX03, "input0.cc");
+    Decl *FromTU1 = getTuDecl(getDefinition(), Lang_CXX03, "input1.cc");
     auto *From0 = FirstDeclMatcher<DeclTy>().match(FromTU0, getPattern());
     auto *From1 = FirstDeclMatcher<DeclTy>().match(FromTU1, getPattern());
     ASSERT_TRUE(From0->isThisDeclarationADefinition());
     ASSERT_TRUE(From1->isThisDeclarationADefinition());
 
-    Decl *Imported0 = Import(From0, Lang_CXX);
-    Decl *Imported1 = Import(From1, Lang_CXX);
+    Decl *Imported0 = Import(From0, Lang_CXX03);
+    Decl *Imported1 = Import(From1, Lang_CXX03);
     Decl *ToTU = Imported0->getTranslationUnitDecl();
 
     EXPECT_EQ(Imported0, Imported1);
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 1u);
     auto *To0 = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(Imported0 == To0);
     EXPECT_TRUE(To0->isThisDeclarationADefinition());
     if (auto *ToT0 = dyn_cast<TemplateDecl>(To0)) {
       EXPECT_TRUE(ToT0->getTemplatedDecl());
     }
   }
 
   void TypedTest_ImportDefinitionThenPrototype() {
-    Decl *FromTUDef = getTuDecl(getDefinition(), Lang_CXX, "input0.cc");
-    Decl *FromTUProto = getTuDecl(getPrototype(), Lang_CXX, "input1.cc");
+    Decl *FromTUDef = getTuDecl(getDefinition(), Lang_CXX03, "input0.cc");
+    Decl *FromTUProto = getTuDecl(getPrototype(), Lang_CXX03, "input1.cc");
     auto *FromDef = FirstDeclMatcher<DeclTy>().match(FromTUDef, getPattern());
     auto *FromProto =
         FirstDeclMatcher<DeclTy>().match(FromTUProto, getPattern());
     ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
     ASSERT_FALSE(FromProto->isThisDeclarationADefinition());
 
-    Decl *ImportedDef = Import(FromDef, Lang_CXX);
-    Decl *ImportedProto = Import(FromProto, Lang_CXX);
+    Decl *ImportedDef = Import(FromDef, Lang_CXX03);
+    Decl *ImportedProto = Import(FromProto, Lang_CXX03);
     Decl *ToTU = ImportedDef->getTranslationUnitDecl();
 
     EXPECT_NE(ImportedDef, ImportedProto);
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
     auto *ToDef = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
     auto *ToProto = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(ImportedDef == ToDef);
     EXPECT_TRUE(ImportedProto == ToProto);
     EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
     EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
 
     CheckPreviousDecl(ToDef, ToProto);
   }
 
   void TypedTest_ImportPrototypeThenDefinition() {
-    Decl *FromTUProto = getTuDecl(getPrototype(), Lang_CXX, "input0.cc");
-    Decl *FromTUDef = getTuDecl(getDefinition(), Lang_CXX, "input1.cc");
+    Decl *FromTUProto = getTuDecl(getPrototype(), Lang_CXX03, "input0.cc");
+    Decl *FromTUDef = getTuDecl(getDefinition(), Lang_CXX03, "input1.cc");
     auto *FromProto =
         FirstDeclMatcher<DeclTy>().match(FromTUProto, getPattern());
     auto *FromDef = FirstDeclMatcher<DeclTy>().match(FromTUDef, getPattern());
     ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
     ASSERT_FALSE(FromProto->isThisDeclarationADefinition());
 
-    Decl *ImportedProto = Import(FromProto, Lang_CXX);
-    Decl *ImportedDef = Import(FromDef, Lang_CXX);
+    Decl *ImportedProto = Import(FromProto, Lang_CXX03);
+    Decl *ImportedDef = Import(FromDef, Lang_CXX03);
     Decl *ToTU = ImportedDef->getTranslationUnitDecl();
 
     EXPECT_NE(ImportedDef, ImportedProto);
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
     auto *ToProto = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
     auto *ToDef = LastDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_TRUE(ImportedDef == ToDef);
     EXPECT_TRUE(ImportedProto == ToProto);
     EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
     EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
 
     CheckPreviousDecl(ToProto, ToDef);
   }
 
   void TypedTest_WholeRedeclChainIsImportedAtOnce() {
-    Decl *FromTU = getTuDecl(getPrototype() + getDefinition(), Lang_CXX);
+    Decl *FromTU = getTuDecl(getPrototype() + getDefinition(), Lang_CXX03);
     auto *FromD = // Definition
         LastDeclMatcher<DeclTy>().match(FromTU, getPattern());
     ASSERT_TRUE(FromD->isThisDeclarationADefinition());
 
-    Decl *ImportedD = Import(FromD, Lang_CXX);
+    Decl *ImportedD = Import(FromD, Lang_CXX03);
     Decl *ToTU = ImportedD->getTranslationUnitDecl();
 
     // The whole redecl chain is imported at once.
     EXPECT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 2u);
     EXPECT_TRUE(cast<DeclTy>(ImportedD)->isThisDeclarationADefinition());
   }
 
   void TypedTest_ImportPrototypeThenProtoAndDefinition() {
     {
-      Decl *FromTU = getTuDecl(getPrototype(), Lang_CXX, "input0.cc");
+      Decl *FromTU = getTuDecl(getPrototype(), Lang_CXX03, "input0.cc");
       auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
-      Import(FromD, Lang_CXX);
+      Import(FromD, Lang_CXX03);
     }
     {
       Decl *FromTU =
-          getTuDecl(getPrototype() + getDefinition(), Lang_CXX, "input1.cc");
+          getTuDecl(getPrototype() + getDefinition(), Lang_CXX03, "input1.cc");
       auto *FromD = FirstDeclMatcher<DeclTy>().match(FromTU, getPattern());
-      Import(FromD, Lang_CXX);
+      Import(FromD, Lang_CXX03);
     }
 
     Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
 
     ASSERT_EQ(DeclCounter<DeclTy>().match(ToTU, getPattern()), 3u);
     DeclTy *ProtoD = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
     EXPECT_FALSE(ProtoD->isThisDeclarationADefinition());
 

clang/unittests/AST/ASTImporterODRStrategiesTest.cpp

struct Function {
   using DeclTy = FunctionDecl;
   static constexpr auto *Prototype = "void X(int);";
   static constexpr auto *ConflictingPrototype = "void X(double);";
   static constexpr auto *Definition = "void X(int a) {}";
   static constexpr auto *ConflictingDefinition = "void X(double a) {}";
   BindableMatcher<Decl> getPattern() {
     return functionDecl(hasName("X"), unless(isImplicit()));
   }
-  TestLanguage getLang() { return Lang_C; }
+  TestLanguage getLang() { return Lang_C99; }
 };
 
 struct Typedef {
   using DeclTy = TypedefNameDecl;
   static constexpr auto *Definition = "typedef int X;";
   static constexpr auto *ConflictingDefinition = "typedef double X;";
   BindableMatcher<Decl> getPattern() { return typedefNameDecl(hasName("X")); }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 struct TypedefAlias {
   using DeclTy = TypedefNameDecl;
   static constexpr auto *Definition = "using X = int;";
   static constexpr auto *ConflictingDefinition = "using X = double;";
   BindableMatcher<Decl> getPattern() { return typedefNameDecl(hasName("X")); }
   TestLanguage getLang() { return Lang_CXX11; }
 };
 
 struct Enum {
   using DeclTy = EnumDecl;
   static constexpr auto *Definition = "enum X { a, b };";
   static constexpr auto *ConflictingDefinition = "enum X { a, b, c };";
   BindableMatcher<Decl> getPattern() { return enumDecl(hasName("X")); }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 struct EnumClass {
   using DeclTy = EnumDecl;
   static constexpr auto *Definition = "enum class X { a, b };";
   static constexpr auto *ConflictingDefinition = "enum class X { a, b, c };";
   BindableMatcher<Decl> getPattern() { return enumDecl(hasName("X")); }
   TestLanguage getLang() { return Lang_CXX11; }
 };
 
 struct EnumConstant {
   using DeclTy = EnumConstantDecl;
   static constexpr auto *Definition = "enum E { X = 0 };";
   static constexpr auto *ConflictingDefinition = "enum E { X = 1 };";
   BindableMatcher<Decl> getPattern() { return enumConstantDecl(hasName("X")); }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 struct Class {
   using DeclTy = CXXRecordDecl;
   static constexpr auto *Prototype = "class X;";
   static constexpr auto *Definition = "class X {};";
   static constexpr auto *ConflictingDefinition = "class X { int A; };";
   BindableMatcher<Decl> getPattern() {
     return cxxRecordDecl(hasName("X"), unless(isImplicit()));
   }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 struct Variable {
   using DeclTy = VarDecl;
   static constexpr auto *Prototype = "extern int X;";
   static constexpr auto *ConflictingPrototype = "extern float X;";
   static constexpr auto *Definition = "int X;";
   static constexpr auto *ConflictingDefinition = "float X;";
   BindableMatcher<Decl> getPattern() { return varDecl(hasName("X")); }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 struct ClassTemplate {
   using DeclTy = ClassTemplateDecl;
   static constexpr auto *Prototype = "template <class> class X;";
   static constexpr auto *ConflictingPrototype = "template <int> class X;";
   static constexpr auto *Definition = "template <class> class X {};";
   static constexpr auto *ConflictingDefinition =
       "template <class> class X { int A; };";
   static constexpr auto *ConflictingProtoDef = "template <int> class X { };";
   BindableMatcher<Decl> getPattern() {
     return classTemplateDecl(hasName("X"), unless(isImplicit()));
   }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 struct FunctionTemplate {
   using DeclTy = FunctionTemplateDecl;
   static constexpr auto *Definition0 =
       R"(
       template <class T>
       void X(T a) {};
       )";
   // This is actually not a conflicting definition, but another primary template.
   static constexpr auto *Definition1 =
       R"(
       template <class T>
       void X(T* a) {};
       )";
   BindableMatcher<Decl> getPattern() {
     return functionTemplateDecl(hasName("X"), unless(isImplicit()));
   }
   static std::string getDef0() { return Definition0; }
   static std::string getDef1() { return Definition1; }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 static const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateDecl>
     varTemplateDecl;
 
 struct VarTemplate {
   using DeclTy = VarTemplateDecl;
   static constexpr auto *Definition =
struct ClassTemplateSpec {
   static constexpr auto *ConflictingDefinition =
       R"(
       template <class T> class X;
       template <> class X<int> { int A; };
       )";
   BindableMatcher<Decl> getPattern() {
     return classTemplateSpecializationDecl(hasName("X"), unless(isImplicit()));
   }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 // Function template specializations are all "full" specializations.
 // Structural equivalency does not check the body of functions, so we cannot
 // create conflicting function template specializations.
 struct FunctionTemplateSpec {
   using DeclTy = FunctionDecl;
 
static constexpr auto *Definition1 =
       )";
 
   BindableMatcher<Decl> getPattern() {
     return functionDecl(hasName("X"), isExplicitTemplateSpecialization(),
                         unless(isImplicit()));
   }
   static std::string getDef0() { return Definition0; }
   static std::string getDef1() { return Definition1; }
-  TestLanguage getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX03; }
 };
 
 static const internal::VariadicDynCastAllOfMatcher<
     Decl, VarTemplateSpecializationDecl>
     varTemplateSpecializationDecl;
 
 struct VarTemplateSpec {
   using DeclTy = VarTemplateSpecializationDecl;

clang/unittests/AST/ASTImporterTest.cpp

 struct ImportExpr : TestImportBase {};
 struct ImportType : TestImportBase {};
 struct ImportDecl : TestImportBase {};
 struct ImportFixedPointExpr : ImportExpr {};
 
 struct CanonicalRedeclChain : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(CanonicalRedeclChain, ShouldBeConsequentWithMatchers) {
-  Decl *FromTU = getTuDecl("void f();", Lang_CXX);
+  Decl *FromTU = getTuDecl("void f();", Lang_CXX03);
   auto Pattern = functionDecl(hasName("f"));
   auto *D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
   auto Redecls = getCanonicalForwardRedeclChain(D0);
   ASSERT_EQ(Redecls.size(), 1u);
   EXPECT_EQ(D0, Redecls[0]);
 }
 
 TEST_P(CanonicalRedeclChain, ShouldBeConsequentWithMatchers2) {
-  Decl *FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX);
+  Decl *FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX03);
   auto Pattern = functionDecl(hasName("f"));
   auto *D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
   auto *D2 = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
   FunctionDecl *D1 = D2->getPreviousDecl();
 
   auto Redecls = getCanonicalForwardRedeclChain(D0);
   ASSERT_EQ(Redecls.size(), 3u);
   EXPECT_EQ(D0, Redecls[0]);
   EXPECT_EQ(D1, Redecls[1]);
   EXPECT_EQ(D2, Redecls[2]);
 }
 
 TEST_P(CanonicalRedeclChain, ShouldBeSameForAllDeclInTheChain) {
-  Decl *FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX);
+  Decl *FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX03);
   auto Pattern = functionDecl(hasName("f"));
   auto *D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
   auto *D2 = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
   FunctionDecl *D1 = D2->getPreviousDecl();
 
   auto RedeclsD0 = getCanonicalForwardRedeclChain(D0);
   auto RedeclsD1 = getCanonicalForwardRedeclChain(D1);
   auto RedeclsD2 = getCanonicalForwardRedeclChain(D2);
RedirectingImporterTest() {
     };
   }
 };
 
 // Test that an ASTImporter subclass can intercept an import call.
 TEST_P(RedirectingImporterTest, InterceptImport) {
   Decl *From, *To;
   std::tie(From, To) =
-      getImportedDecl("class shouldNotBeImported {};", Lang_CXX,
-                      "class realDecl {};", Lang_CXX, "shouldNotBeImported");
+      getImportedDecl("class shouldNotBeImported {};", Lang_CXX03,
+                      "class realDecl {};", Lang_CXX03, "shouldNotBeImported");
   auto *Imported = cast<CXXRecordDecl>(To);
   EXPECT_EQ(Imported->getQualifiedNameAsString(), "realDecl");
 
   // Make sure our importer prevented the importing of the decl.
   auto *ToTU = Imported->getTranslationUnitDecl();
   auto Pattern = functionDecl(hasName("shouldNotBeImported"));
   unsigned count =
       DeclCounterWithPredicate<CXXRecordDecl>().match(ToTU, Pattern);
   EXPECT_EQ(0U, count);
 }
 
 // Test that when we indirectly import a declaration the custom ASTImporter
 // is still intercepting the import.
 TEST_P(RedirectingImporterTest, InterceptIndirectImport) {
   Decl *From, *To;
   std::tie(From, To) =
       getImportedDecl("class shouldNotBeImported {};"
                       "class F { shouldNotBeImported f; };",
-                      Lang_CXX, "class realDecl {};", Lang_CXX, "F");
+                      Lang_CXX03, "class realDecl {};", Lang_CXX03, "F");
 
   // Make sure our ASTImporter prevented the importing of the decl.
   auto *ToTU = To->getTranslationUnitDecl();
   auto Pattern = functionDecl(hasName("shouldNotBeImported"));
   unsigned count =
       DeclCounterWithPredicate<CXXRecordDecl>().match(ToTU, Pattern);
   EXPECT_EQ(0U, count);
 }
 
 struct ImportPath : ASTImporterOptionSpecificTestBase {
   Decl *FromTU;
   FunctionDecl *D0, *D1, *D2;
   ImportPath() {
-    FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX);
+    FromTU = getTuDecl("void f(); void f(); void f();", Lang_CXX03);
     auto Pattern = functionDecl(hasName("f"));
     D0 = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
     D2 = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
     D1 = D2->getPreviousDecl();
   }
 };
 
 TEST_P(ImportPath, Push) {
TEST_P(ImportPath, CycleAfterCycle) {
   EXPECT_EQ(Res[2], D0);
 
   path.pop();
   EXPECT_FALSE(path.hasCycleAtBack());
 }
 
 TEST_P(ImportExpr, ImportStringLiteral) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport() { (void)\"foo\"; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+  testImport("void declToImport() { (void)\"foo\"; }", Lang_CXX03, "",
+             Lang_CXX03, Verifier,
              functionDecl(hasDescendant(
                  stringLiteral(hasType(asString("const char [4]"))))));
-  testImport(
-      "void declToImport() { (void)L\"foo\"; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+  testImport("void declToImport() { (void)L\"foo\"; }", Lang_CXX03, "",
+             Lang_CXX03, Verifier,
              functionDecl(hasDescendant(
                  stringLiteral(hasType(asString("const wchar_t [4]"))))));
-  testImport(
-      "void declToImport() { (void) \"foo\" \"bar\"; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+  testImport("void declToImport() { (void) \"foo\" \"bar\"; }", Lang_CXX03, "",
+             Lang_CXX03, Verifier,
              functionDecl(hasDescendant(
                  stringLiteral(hasType(asString("const char [7]"))))));
 }
 
 TEST_P(ImportExpr, ImportChooseExpr) {
   MatchVerifier<Decl> Verifier;
 
   // This case tests C code that is not condition-dependent and has a true
   // condition.
-  testImport(
-    "void declToImport() { (void)__builtin_choose_expr(1, 2, 3); }",
-    Lang_C, "", Lang_C, Verifier,
+  testImport("void declToImport() { (void)__builtin_choose_expr(1, 2, 3); }",
+             Lang_C99, "", Lang_C99, Verifier,
              functionDecl(hasDescendant(chooseExpr())));
 }
 
 TEST_P(ImportExpr, ImportGNUNullExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport() { (void)__null; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+  testImport("void declToImport() { (void)__null; }", Lang_CXX03, "",
+             Lang_CXX03, Verifier,
              functionDecl(hasDescendant(gnuNullExpr(hasType(isInteger())))));
 }
 
 TEST_P(ImportExpr, ImportCXXNullPtrLiteralExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { (void)nullptr; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(hasDescendant(cxxNullPtrLiteralExpr())));
 }
 
 
 TEST_P(ImportExpr, ImportFloatinglLiteralExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport() { (void)1.0; }",
-      Lang_C, "", Lang_C, Verifier,
+  testImport("void declToImport() { (void)1.0; }", Lang_C99, "", Lang_C99,
+             Verifier,
              functionDecl(hasDescendant(
                  floatLiteral(equals(1.0), hasType(asString("double"))))));
-  testImport(
-      "void declToImport() { (void)1.0e-5f; }",
-      Lang_C, "", Lang_C, Verifier,
+  testImport("void declToImport() { (void)1.0e-5f; }", Lang_C99, "", Lang_C99,
+             Verifier,
              functionDecl(hasDescendant(
                  floatLiteral(equals(1.0e-5f), hasType(asString("float"))))));
 }
 
 TEST_P(ImportFixedPointExpr, ImportFixedPointerLiteralExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport("void declToImport() { (void)1.0k; }", Lang_C, "", Lang_C,
+  testImport("void declToImport() { (void)1.0k; }", Lang_C99, "", Lang_C99,
              Verifier, functionDecl(hasDescendant(fixedPointLiteral())));
-  testImport("void declToImport() { (void)0.75r; }", Lang_C, "", Lang_C,
+  testImport("void declToImport() { (void)0.75r; }", Lang_C99, "", Lang_C99,
              Verifier, functionDecl(hasDescendant(fixedPointLiteral())));
 }
 
 TEST_P(ImportExpr, ImportImaginaryLiteralExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { (void)1.0i; }",
       Lang_CXX14, "", Lang_CXX14, Verifier,
       functionDecl(hasDescendant(imaginaryLiteral())));
 }
 
 TEST_P(ImportExpr, ImportCompoundLiteralExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport() {"
+  testImport("void declToImport() {"
              "  struct s { int x; long y; unsigned z; }; "
              "  (void)(struct s){ 42, 0L, 1U }; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
-          compoundLiteralExpr(
+             Lang_CXX03, "", Lang_CXX03, Verifier,
+             functionDecl(hasDescendant(compoundLiteralExpr(
                  hasType(asString("struct s")),
                  has(initListExpr(
                      hasType(asString("struct s")),
-                  has(integerLiteral(
-                      equals(42), hasType(asString("int")))),
-                  has(integerLiteral(
-                      equals(0), hasType(asString("long")))),
+                     has(integerLiteral(equals(42), hasType(asString("int")))),
+                     has(integerLiteral(equals(0), hasType(asString("long")))),
                      has(integerLiteral(
                          equals(1), hasType(asString("unsigned int"))))))))));
 }
 
 TEST_P(ImportExpr, ImportCXXThisExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "class declToImport { void f() { (void)this; } };",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      cxxRecordDecl(
-          hasMethod(
-              hasDescendant(
-                  cxxThisExpr(
-                      hasType(
-                          asString("class declToImport *")))))));
+  testImport("class declToImport { void f() { (void)this; } };", Lang_CXX03, "",
+             Lang_CXX03, Verifier,
+             cxxRecordDecl(hasMethod(hasDescendant(
+                 cxxThisExpr(hasType(asString("class declToImport *")))))));
 }
 
 TEST_P(ImportExpr, ImportAtomicExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
-      Lang_C, "", Lang_C, Verifier,
-      functionDecl(hasDescendant(
-          atomicExpr(
+  testImport("void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
+             Lang_C99, "", Lang_C99, Verifier,
+             functionDecl(hasDescendant(atomicExpr(
                  has(ignoringParenImpCasts(
                      declRefExpr(hasDeclaration(varDecl(hasName("ptr"))),
                                  hasType(asString("int *"))))),
                  has(integerLiteral(equals(1), hasType(asString("int"))))))));
 }
 
 TEST_P(ImportExpr, ImportLabelDeclAndAddrLabelExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport() { loop: goto loop; (void)&&loop; }",
-      Lang_C, "", Lang_C, Verifier,
-      functionDecl(
-          hasDescendant(
-              labelStmt(hasDeclaration(labelDecl(hasName("loop"))))),
-          hasDescendant(
-              addrLabelExpr(hasDeclaration(labelDecl(hasName("loop")))))));
+  testImport("void declToImport() { loop: goto loop; (void)&&loop; }", Lang_C99,
+             "", Lang_C99, Verifier,
+             functionDecl(hasDescendant(labelStmt(
+                              hasDeclaration(labelDecl(hasName("loop"))))),
+                          hasDescendant(addrLabelExpr(
+                              hasDeclaration(labelDecl(hasName("loop")))))));
 }
 
 AST_MATCHER_P(TemplateDecl, hasTemplateDecl,
               internal::Matcher<NamedDecl>, InnerMatcher) {
   const NamedDecl *Template = Node.getTemplatedDecl();
   return Template && InnerMatcher.matches(*Template, Finder, Builder);
 }
 
 TEST_P(ImportExpr, ImportParenListExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template<typename T> class dummy { void f() { dummy X(*this); } };"
       "typedef dummy<int> declToImport;"
       "template class dummy<int>;",
-      Lang_CXX, "", Lang_CXX, Verifier,
+      Lang_CXX03, "", Lang_CXX03, Verifier,
       typedefDecl(hasType(templateSpecializationType(
           hasDeclaration(classTemplateSpecializationDecl(hasSpecializedTemplate(
               classTemplateDecl(hasTemplateDecl(cxxRecordDecl(hasMethod(allOf(
                   hasName("f"),
                   hasBody(compoundStmt(has(declStmt(hasSingleDecl(
                       varDecl(hasInitializer(parenListExpr(has(unaryOperator(
                           hasOperatorName("*"),
                           hasUnaryOperand(cxxThisExpr())))))))))))))))))))))));
 }
 
 TEST_P(ImportExpr, ImportSwitch) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport() { int b; switch (b) { case 1: break; } }",
-      Lang_C, "", Lang_C, Verifier,
+  testImport("void declToImport() { int b; switch (b) { case 1: break; } }",
+             Lang_C99, "", Lang_C99, Verifier,
              functionDecl(hasDescendant(
                  switchStmt(has(compoundStmt(has(caseStmt())))))));
 }
 
 TEST_P(ImportExpr, ImportStmtExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { int b; int a = b ?: 1; int C = ({int X=4; X;}); }",
-      Lang_C, "", Lang_C, Verifier,
+      Lang_C99, "", Lang_C99, Verifier,
       traverse(ast_type_traits::TK_AsIs,
                functionDecl(hasDescendant(varDecl(
                    hasName("C"), hasType(asString("int")),
                    hasInitializer(stmtExpr(
                        hasAnySubstatement(declStmt(hasSingleDecl(varDecl(
                            hasName("X"), hasType(asString("int")),
                            hasInitializer(integerLiteral(equals(4))))))),
                        hasDescendant(implicitCastExpr()))))))));
 }
 
 TEST_P(ImportExpr, ImportConditionalOperator) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport() { (void)(true ? 1 : -5); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
-          conditionalOperator(
+  testImport("void declToImport() { (void)(true ? 1 : -5); }", Lang_CXX03, "",
+             Lang_CXX03, Verifier,
+             functionDecl(hasDescendant(conditionalOperator(
                  hasCondition(cxxBoolLiteral(equals(true))),
                  hasTrueExpression(integerLiteral(equals(1))),
-              hasFalseExpression(
-                  unaryOperator(hasUnaryOperand(integerLiteral(equals(5))))))
-          )));
+                 hasFalseExpression(unaryOperator(
+                     hasUnaryOperand(integerLiteral(equals(5)))))))));
 }
 
 TEST_P(ImportExpr, ImportBinaryConditionalOperator) {
   MatchVerifier<Decl> Verifier;
   testImport(
-      "void declToImport() { (void)(1 ?: -5); }", Lang_CXX, "", Lang_CXX,
+      "void declToImport() { (void)(1 ?: -5); }", Lang_CXX03, "", Lang_CXX03,
       Verifier,
       traverse(ast_type_traits::TK_AsIs,
                functionDecl(hasDescendant(binaryConditionalOperator(
                    hasCondition(implicitCastExpr(
                        hasSourceExpression(opaqueValueExpr(
                            hasSourceExpression(integerLiteral(equals(1))))),
                        hasType(booleanType()))),
                    hasTrueExpression(opaqueValueExpr(
                        hasSourceExpression(integerLiteral(equals(1))))),
                    hasFalseExpression(unaryOperator(
                        hasOperatorName("-"),
                        hasUnaryOperand(integerLiteral(equals(5))))))))));
 }
 
 TEST_P(ImportExpr, ImportDesignatedInitExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() {"
       "  struct point { double x; double y; };"
       "  struct point ptarray[10] = "
       "{ [2].y = 1.0, [2].x = 2.0, [0].x = 1.0 }; }",
-      Lang_C, "", Lang_C, Verifier,
-      functionDecl(hasDescendant(
-          initListExpr(
-              has(designatedInitExpr(
-                  designatorCountIs(2),
+      Lang_C99, "", Lang_C99, Verifier,
+      functionDecl(hasDescendant(initListExpr(
+          has(designatedInitExpr(designatorCountIs(2),
                                  hasDescendant(floatLiteral(equals(1.0))),
                                  hasDescendant(integerLiteral(equals(2))))),
-              has(designatedInitExpr(
-                  designatorCountIs(2),
+          has(designatedInitExpr(designatorCountIs(2),
                                  hasDescendant(floatLiteral(equals(2.0))),
                                  hasDescendant(integerLiteral(equals(2))))),
-              has(designatedInitExpr(
-                  designatorCountIs(2),
+          has(designatedInitExpr(designatorCountIs(2),
                                  hasDescendant(floatLiteral(equals(1.0))),
                                  hasDescendant(integerLiteral(equals(0)))))))));
 }
 
 TEST_P(ImportExpr, ImportPredefinedExpr) {
   MatchVerifier<Decl> Verifier;
   // __func__ expands as StringLiteral("declToImport")
-  testImport(
-      "void declToImport() { (void)__func__; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
-          predefinedExpr(
-              hasType(
-                  asString("const char [13]")),
-              has(stringLiteral(hasType(
-                  asString("const char [13]"))))))));
+  testImport("void declToImport() { (void)__func__; }", Lang_CXX03, "",
+             Lang_CXX03, Verifier,
+             functionDecl(hasDescendant(predefinedExpr(
+                 hasType(asString("const char [13]")),
+                 has(stringLiteral(hasType(asString("const char [13]"))))))));
 }
 
 TEST_P(ImportExpr, ImportInitListExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() {"
       "  struct point { double x; double y; };"
       "  point ptarray[10] = { [2].y = 1.0, [2].x = 2.0,"
       "                        [0].x = 1.0 }; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
-          initListExpr(
-              has(
-                  cxxConstructExpr(
-                  requiresZeroInitialization())),
-              has(
-                  initListExpr(
-                      hasType(asString("struct point")),
-                      has(floatLiteral(equals(1.0))),
-                      has(implicitValueInitExpr(
-                          hasType(asString("double")))))),
-              has(
-                  initListExpr(
-                      hasType(asString("struct point")),
+      Lang_CXX03, "", Lang_CXX03, Verifier,
+      functionDecl(hasDescendant(initListExpr(
+          has(cxxConstructExpr(requiresZeroInitialization())),
+          has(initListExpr(
+              hasType(asString("struct point")), has(floatLiteral(equals(1.0))),
+              has(implicitValueInitExpr(hasType(asString("double")))))),
+          has(initListExpr(hasType(asString("struct point")),
                            has(floatLiteral(equals(2.0))),
                            has(floatLiteral(equals(1.0)))))))));
 }
 
 
 const internal::VariadicDynCastAllOfMatcher<Expr, VAArgExpr> vaArgExpr;
 
 TEST_P(ImportExpr, ImportVAArgExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "void declToImport(__builtin_va_list list, ...) {"
+  testImport("void declToImport(__builtin_va_list list, ...) {"
              "  (void)__builtin_va_arg(list, int); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              functionDecl(hasDescendant(
                  cStyleCastExpr(hasSourceExpression(vaArgExpr())))));
 }
 
 TEST_P(ImportExpr, CXXTemporaryObjectExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "struct C {};"
       "void declToImport() { C c = C(); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+      Lang_CXX03, "", Lang_CXX03, Verifier,
       traverse(ast_type_traits::TK_AsIs,
                functionDecl(hasDescendant(exprWithCleanups(has(cxxConstructExpr(
                    has(materializeTemporaryExpr(has(implicitCastExpr(
                        has(cxxTemporaryObjectExpr()))))))))))));
 }
 
 TEST_P(ImportType, ImportAtomicType) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { typedef _Atomic(int) a_int; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(hasDescendant(typedefDecl(has(atomicType())))));
 }
 
 TEST_P(ImportDecl, ImportFunctionTemplateDecl) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "template <typename T> void declToImport() { };",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      functionTemplateDecl());
+  testImport("template <typename T> void declToImport() { };", Lang_CXX03, "",
+             Lang_CXX03, Verifier, functionTemplateDecl());
 }
 
 TEST_P(ImportExpr, ImportCXXDependentScopeMemberExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "template <typename T> struct C { T t; };"
+  testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  (void)d.t;"
              "}"
              "void instantiate() { declToImport<int>(); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              functionTemplateDecl(hasDescendant(
                  cStyleCastExpr(has(cxxDependentScopeMemberExpr())))));
-  testImport(
-      "template <typename T> struct C { T t; };"
+  testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  (void)(&d)->t;"
              "}"
              "void instantiate() { declToImport<int>(); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              functionTemplateDecl(hasDescendant(
                  cStyleCastExpr(has(cxxDependentScopeMemberExpr())))));
 }
 
 TEST_P(ImportType, ImportTypeAliasTemplate) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template <int K>"
       "struct dummy { static const int i = K; };"
       "template <int K> using dummy2 = dummy<K>;"

 }
 
 const internal::VariadicDynCastAllOfMatcher<Type,
                                             DependentTemplateSpecializationType>
     dependentTemplateSpecializationType;
 
 TEST_P(ImportType, ImportDependentTemplateSpecialization) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "template<typename T>"
+  testImport("template<typename T>"
              "struct A;"
              "template<typename T>"
              "struct declToImport {"
              "  typename A<T>::template B<T> a;"
              "};",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              classTemplateDecl(has(cxxRecordDecl(has(
                  fieldDecl(hasType(dependentTemplateSpecializationType())))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Stmt, SizeOfPackExpr>
     sizeOfPackExpr;
 
 TEST_P(ImportExpr, ImportSizeOfPackExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(

 const internal::VariadicDynCastAllOfMatcher<Stmt, TypeTraitExpr> typeTraitExpr;
 
 TEST_P(ImportExpr, ImportTypeTraitExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "void declToImport() { "
       "  (void)__builtin_types_compatible_p(int, int);"
       "}",
-      Lang_C, "", Lang_C, Verifier,
+      Lang_C99, "", Lang_C99, Verifier,
       functionDecl(hasDescendant(typeTraitExpr(hasType(asString("int"))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr> cxxTypeidExpr;
 
 TEST_P(ImportExpr, ImportCXXTypeidExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(

 
 TEST_P(ImportDecl, ImportRecordDeclInFunc) {
   MatchVerifier<Decl> Verifier;
   testImport("int declToImport() { "
              "  struct data_t {int a;int b;};"
              "  struct data_t d;"
              "  return 0;"
              "}",
-             Lang_C, "", Lang_C, Verifier,
+             Lang_C99, "", Lang_C99, Verifier,
              functionDecl(hasBody(compoundStmt(
                  has(declStmt(hasSingleDecl(varDecl(hasName("d")))))))));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportRecordTypeInFunc) {
   Decl *FromTU = getTuDecl("int declToImport() { "
                            "  struct data_t {int a;int b;};"
                            "  struct data_t d;"
                            "  return 0;"
                            "}",
-                           Lang_C, "input.c");
+                           Lang_C99, "input.c");
   auto *FromVar =
       FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("d")));
   ASSERT_TRUE(FromVar);
   auto ToType =
-      ImportType(FromVar->getType().getCanonicalType(), FromVar, Lang_C);
+      ImportType(FromVar->getType().getCanonicalType(), FromVar, Lang_C99);
   EXPECT_FALSE(ToType.isNull());
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportRecordDeclInFuncParams) {
   // This construct is not supported by ASTImporter.
   Decl *FromTU = getTuDecl(
       "int declToImport(struct data_t{int a;int b;} ***d){ return 0; }",
-      Lang_C, "input.c");
+      Lang_C99, "input.c");
   auto *From = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("declToImport")));
   ASSERT_TRUE(From);
-  auto *To = Import(From, Lang_C);
+  auto *To = Import(From, Lang_C99);
   EXPECT_EQ(To, nullptr);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportRecordDeclInFuncFromMacro) {
-  Decl *FromTU = getTuDecl(
-      "#define NONAME_SIZEOF(type) sizeof(struct{type *dummy;}) \n"
+  Decl *FromTU =
+      getTuDecl("#define NONAME_SIZEOF(type) sizeof(struct{type *dummy;}) \n"
                 "int declToImport(){ return NONAME_SIZEOF(int); }",
-      Lang_C, "input.c");
+                Lang_C99, "input.c");
   auto *From = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("declToImport")));
   ASSERT_TRUE(From);
-  auto *To = Import(From, Lang_C);
+  auto *To = Import(From, Lang_C99);
   ASSERT_TRUE(To);
   EXPECT_TRUE(MatchVerifier<FunctionDecl>().match(
       To, functionDecl(hasName("declToImport"),
                        hasDescendant(unaryExprOrTypeTraitExpr()))));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportRecordDeclInFuncParamsFromMacro) {
   // This construct is not supported by ASTImporter.
-  Decl *FromTU = getTuDecl(
-      "#define PAIR_STRUCT(type) struct data_t{type a;type b;} \n"
+  Decl *FromTU =
+      getTuDecl("#define PAIR_STRUCT(type) struct data_t{type a;type b;} \n"
                 "int declToImport(PAIR_STRUCT(int) ***d){ return 0; }",
-      Lang_C, "input.c");
+                Lang_C99, "input.c");
   auto *From = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("declToImport")));
   ASSERT_TRUE(From);
-  auto *To = Import(From, Lang_C);
+  auto *To = Import(From, Lang_C99);
   EXPECT_EQ(To, nullptr);
 }
 
 const internal::VariadicDynCastAllOfMatcher<Expr, CXXPseudoDestructorExpr>
     cxxPseudoDestructorExpr;
 
 TEST_P(ImportExpr, ImportCXXPseudoDestructorExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "typedef int T;"
       "void declToImport(int *p) {"
       "  T t;"
       "  p->T::~T();"
       "}",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      functionDecl(hasDescendant(
-          callExpr(has(cxxPseudoDestructorExpr())))));
+      Lang_CXX03, "", Lang_CXX03, Verifier,
+      functionDecl(hasDescendant(callExpr(has(cxxPseudoDestructorExpr())))));
 }
 
 TEST_P(ImportDecl, ImportUsingDecl) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "namespace foo { int bar; }"
+  testImport("namespace foo { int bar; }"
              "void declToImport() { using foo::bar; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              functionDecl(hasDescendant(usingDecl())));
 }
 
 /// \brief Matches shadow declarations introduced into a scope by a
 ///        (resolved) using declaration.
 ///
 /// Given
 /// \code
 ///   namespace n { int f; }
 ///   namespace declToImport { using n::f; }
 /// \endcode
 /// usingShadowDecl()
 ///   matches \code f \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl,
                                             UsingShadowDecl> usingShadowDecl;
 
 TEST_P(ImportDecl, ImportUsingShadowDecl) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "namespace foo { int bar; }"
+  testImport("namespace foo { int bar; }"
              "namespace declToImport { using foo::bar; }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              namespaceDecl(has(usingShadowDecl())));
 }
 
 TEST_P(ImportExpr, ImportUnresolvedLookupExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "template<typename T> int foo();"
+  testImport("template<typename T> int foo();"
              "template <typename T> void declToImport() {"
              "  (void)::foo<T>;"
              "  (void)::template foo<T>;"
              "}"
              "void instantiate() { declToImport<int>(); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              functionTemplateDecl(hasDescendant(unresolvedLookupExpr())));
 }
 
 TEST_P(ImportExpr, ImportCXXUnresolvedConstructExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "template <typename T> struct C { T t; };"
+  testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  d.t = T();"
              "}"
              "void instantiate() { declToImport<int>(); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              functionTemplateDecl(hasDescendant(
                  binaryOperator(has(cxxUnresolvedConstructExpr())))));
-  testImport(
-      "template <typename T> struct C { T t; };"
+  testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  (&d)->t = T();"
              "}"
              "void instantiate() { declToImport<int>(); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              functionTemplateDecl(hasDescendant(
                  binaryOperator(has(cxxUnresolvedConstructExpr())))));
 }
 
 /// Check that function "declToImport()" (which is the templated function
 /// for corresponding FunctionTemplateDecl) is not added into DeclContext.
 /// Same for class template declarations.
 TEST_P(ImportDecl, ImportTemplatedDeclForTemplate) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "template <typename T> void declToImport() { T a = 1; }"
+  testImport("template <typename T> void declToImport() { T a = 1; }"
              "void instantiate() { declToImport<int>(); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              functionTemplateDecl(hasAncestor(translationUnitDecl(
                  unless(has(functionDecl(hasName("declToImport"))))))));
-  testImport(
-      "template <typename T> struct declToImport { T t; };"
+  testImport("template <typename T> struct declToImport { T t; };"
              "void instantiate() { declToImport<int>(); }",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              classTemplateDecl(hasAncestor(translationUnitDecl(
                  unless(has(cxxRecordDecl(hasName("declToImport"))))))));
 }
 
 TEST_P(ImportDecl, ImportClassTemplatePartialSpecialization) {
   MatchVerifier<Decl> Verifier;
   auto Code =
       R"s(
       struct declToImport {
         template <typename T0> struct X;
         template <typename T0> struct X<T0 *> {};
       };
       )s";
-  testImport(Code, Lang_CXX, "", Lang_CXX, Verifier,
+  testImport(Code, Lang_CXX03, "", Lang_CXX03, Verifier,
              recordDecl(has(classTemplateDecl()),
                         has(classTemplateSpecializationDecl())));
 }
 
 TEST_P(ImportExpr, CXXOperatorCallExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "class declToImport {"
       "  void f() { *this = declToImport(); }"
       "};",
-      Lang_CXX, "", Lang_CXX, Verifier,
-      cxxRecordDecl(has(cxxMethodDecl(hasDescendant(
-          cxxOperatorCallExpr())))));
+      Lang_CXX03, "", Lang_CXX03, Verifier,
+      cxxRecordDecl(has(cxxMethodDecl(hasDescendant(cxxOperatorCallExpr())))));
 }
 
 TEST_P(ImportExpr, DependentSizedArrayType) {
   MatchVerifier<Decl> Verifier;
-  testImport(
-      "template<typename T, int Size> class declToImport {"
+  testImport("template<typename T, int Size> class declToImport {"
              "  T data[Size];"
              "};",
-      Lang_CXX, "", Lang_CXX, Verifier,
+             Lang_CXX03, "", Lang_CXX03, Verifier,
              classTemplateDecl(has(cxxRecordDecl(
                  has(fieldDecl(hasType(dependentSizedArrayType())))))));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportBeginLocOfDeclRefExpr) {
-  Decl *FromTU = getTuDecl(
-      "class A { public: static int X; }; void f() { (void)A::X; }", Lang_CXX);
+  Decl *FromTU =
+      getTuDecl("class A { public: static int X; }; void f() { (void)A::X; }",
+                Lang_CXX03);
   auto From = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("f")));
   ASSERT_TRUE(From);
   ASSERT_TRUE(
       cast<CStyleCastExpr>(cast<CompoundStmt>(From->getBody())->body_front())
           ->getSubExpr()
           ->getBeginLoc()
           .isValid());
-  FunctionDecl *To = Import(From, Lang_CXX);
+  FunctionDecl *To = Import(From, Lang_CXX03);
   ASSERT_TRUE(To);
   ASSERT_TRUE(
       cast<CStyleCastExpr>(cast<CompoundStmt>(To->getBody())->body_front())
           ->getSubExpr()
           ->getBeginLoc()
           .isValid());
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportOfTemplatedDeclOfClassTemplateDecl) {
-  Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX);
+  Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX03);
   auto From =
       FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, classTemplateDecl());
   ASSERT_TRUE(From);
-  auto To = cast<ClassTemplateDecl>(Import(From, Lang_CXX));
+  auto To = cast<ClassTemplateDecl>(Import(From, Lang_CXX03));
   ASSERT_TRUE(To);
   Decl *ToTemplated = To->getTemplatedDecl();
-  Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX);
+  Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX03);
   EXPECT_TRUE(ToTemplated1);
   EXPECT_EQ(ToTemplated1, ToTemplated);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportOfTemplatedDeclOfFunctionTemplateDecl) {
-  Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX);
+  Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX03);
   auto From = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU, functionTemplateDecl());
   ASSERT_TRUE(From);
-  auto To = cast<FunctionTemplateDecl>(Import(From, Lang_CXX));
+  auto To = cast<FunctionTemplateDecl>(Import(From, Lang_CXX03));
   ASSERT_TRUE(To);
   Decl *ToTemplated = To->getTemplatedDecl();
-  Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX);
+  Decl *ToTemplated1 = Import(From->getTemplatedDecl(), Lang_CXX03);
   EXPECT_TRUE(ToTemplated1);
   EXPECT_EQ(ToTemplated1, ToTemplated);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportOfTemplatedDeclShouldImportTheClassTemplateDecl) {
-  Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX);
+  Decl *FromTU = getTuDecl("template<class X> struct S{};", Lang_CXX03);
   auto FromFT =
       FirstDeclMatcher<ClassTemplateDecl>().match(FromTU, classTemplateDecl());
   ASSERT_TRUE(FromFT);
 
   auto ToTemplated =
-      cast<CXXRecordDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX));
+      cast<CXXRecordDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX03));
   EXPECT_TRUE(ToTemplated);
   auto ToTU = ToTemplated->getTranslationUnitDecl();
   auto ToFT =
       FirstDeclMatcher<ClassTemplateDecl>().match(ToTU, classTemplateDecl());
   EXPECT_TRUE(ToFT);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportOfTemplatedDeclShouldImportTheFunctionTemplateDecl) {
-  Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX);
+  Decl *FromTU = getTuDecl("template<class X> void f(){}", Lang_CXX03);
   auto FromFT = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU, functionTemplateDecl());
   ASSERT_TRUE(FromFT);
 
   auto ToTemplated =
-      cast<FunctionDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX));
+      cast<FunctionDecl>(Import(FromFT->getTemplatedDecl(), Lang_CXX03));
   EXPECT_TRUE(ToTemplated);
   auto ToTU = ToTemplated->getTranslationUnitDecl();
   auto ToFT = FirstDeclMatcher<FunctionTemplateDecl>().match(
       ToTU, functionTemplateDecl());
   EXPECT_TRUE(ToFT);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportCorrectTemplatedDecl) {
   auto Code =
         R"(
         namespace x {
           template<class X> struct S1{};
           template<class X> struct S2{};
           template<class X> struct S3{};
         }
         )";
-  Decl *FromTU = getTuDecl(Code, Lang_CXX);
+  Decl *FromTU = getTuDecl(Code, Lang_CXX03);
   auto FromNs =
       FirstDeclMatcher<NamespaceDecl>().match(FromTU, namespaceDecl());
-  auto ToNs = cast<NamespaceDecl>(Import(FromNs, Lang_CXX));
+  auto ToNs = cast<NamespaceDecl>(Import(FromNs, Lang_CXX03));
   ASSERT_TRUE(ToNs);
   auto From =
       FirstDeclMatcher<ClassTemplateDecl>().match(FromTU,
                                                   classTemplateDecl(
                                                       hasName("S2")));
   auto To =
       FirstDeclMatcher<ClassTemplateDecl>().match(ToNs,
                                                   classTemplateDecl(
                                                       hasName("S2")));
   ASSERT_TRUE(From);
   ASSERT_TRUE(To);
   auto ToTemplated = To->getTemplatedDecl();
   auto ToTemplated1 =
-      cast<CXXRecordDecl>(Import(From->getTemplatedDecl(), Lang_CXX));
+      cast<CXXRecordDecl>(Import(From->getTemplatedDecl(), Lang_CXX03));
   EXPECT_TRUE(ToTemplated1);
   ASSERT_EQ(ToTemplated1, ToTemplated);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportChooseExpr) {
   // This tests the import of isConditionTrue directly to make sure the importer
   // gets it right.
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
-    "void declToImport() { (void)__builtin_choose_expr(1, 0, 1); }",
-    Lang_C, "", Lang_C);
+      "void declToImport() { (void)__builtin_choose_expr(1, 0, 1); }", Lang_C99,
+      "", Lang_C99);
 
   auto ToResults = match(chooseExpr().bind("choose"), To->getASTContext());
   auto FromResults = match(chooseExpr().bind("choose"), From->getASTContext());
 
   const ChooseExpr *FromChooseExpr =
       selectFirst<ChooseExpr>("choose", FromResults);
   ASSERT_TRUE(FromChooseExpr);
 
std::tie(From, To) = getImportedDecl(
 
       template <> struct X<int> {
         void g() {
           X<int> x;
           declToImport(0, x);
         }
       };
       )",
-      Lang_CXX, "", Lang_CXX);
+      Lang_CXX03, "", Lang_CXX03);
 
   MatchVerifier<Decl> Verifier;
   auto Matcher = functionDecl(hasName("declToImport"),
                               parameterCountIs(2),
                               hasParameter(0, hasName("y")),
                               hasParameter(1, hasName("x")),
                               hasParameter(1, hasType(asString("X<int> &"))));
   ASSERT_TRUE(Verifier.match(From, Matcher));
   EXPECT_TRUE(Verifier.match(To, Matcher));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        TUshouldNotContainTemplatedDeclOfFunctionTemplates) {
   Decl *From, *To;
   std::tie(From, To) =
       getImportedDecl("template <typename T> void declToImport() { T a = 1; }"
                       "void instantiate() { declToImport<int>(); }",
-                      Lang_CXX, "", Lang_CXX);
+                      Lang_CXX03, "", Lang_CXX03);
 
   auto Check = [](Decl *D) -> bool {
     auto TU = D->getTranslationUnitDecl();
     for (auto Child : TU->decls()) {
       if (auto *FD = dyn_cast<FunctionDecl>(Child)) {
         if (FD->getNameAsString() == "declToImport") {
           GTEST_NONFATAL_FAILURE_(
               "TU should not contain any FunctionDecl with name declToImport");

 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        TUshouldNotContainTemplatedDeclOfClassTemplates) {
   Decl *From, *To;
   std::tie(From, To) =
       getImportedDecl("template <typename T> struct declToImport { T t; };"
                       "void instantiate() { declToImport<int>(); }",
-                      Lang_CXX, "", Lang_CXX);
+                      Lang_CXX03, "", Lang_CXX03);
 
   auto Check = [](Decl *D) -> bool {
     auto TU = D->getTranslationUnitDecl();
     for (auto Child : TU->decls()) {
       if (auto *RD = dyn_cast<CXXRecordDecl>(Child)) {
         if (RD->getNameAsString() == "declToImport") {
           GTEST_NONFATAL_FAILURE_(
               "TU should not contain any CXXRecordDecl with name declToImport");
TEST_P(ASTImporterOptionSpecificTestBase,
 
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template<class T>
       class Base {};
       class declToImport : public Base<declToImport> {};
       )",
-      Lang_CXX, "", Lang_CXX);
+      Lang_CXX03, "", Lang_CXX03);
 
   // Check that the ClassTemplateSpecializationDecl is NOT the child of the TU.
   auto Pattern =
       translationUnitDecl(unless(has(classTemplateSpecializationDecl())));
   ASSERT_TRUE(
       MatchVerifier<Decl>{}.match(From->getTranslationUnitDecl(), Pattern));
   EXPECT_TRUE(
       MatchVerifier<Decl>{}.match(To->getTranslationUnitDecl(), Pattern));
TEST_P(ASTImporterOptionSpecificTestBase,
   std::tie(From, To) = getImportedDecl(
       R"(
       namespace NS {
         template<class T>
         class X {};
         template class X<int>;
       }
       )",
-      Lang_CXX, "", Lang_CXX, "NS");
+      Lang_CXX03, "", Lang_CXX03, "NS");
 
   // Check that the ClassTemplateSpecializationDecl is NOT the child of the
   // ClassTemplateDecl.
   auto Pattern = namespaceDecl(has(classTemplateDecl(
       hasName("X"), unless(has(classTemplateSpecializationDecl())))));
   ASSERT_TRUE(MatchVerifier<Decl>{}.match(From, Pattern));
   EXPECT_TRUE(MatchVerifier<Decl>{}.match(To, Pattern));
 

 
 TEST_P(ASTImporterOptionSpecificTestBase, ShouldImportImplicitCXXRecordDecl) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       struct declToImport {
       };
       )",
-      Lang_CXX, "", Lang_CXX);
+      Lang_CXX03, "", Lang_CXX03);
 
   MatchVerifier<Decl> Verifier;
   // Match the implicit Decl.
   auto Matcher = cxxRecordDecl(has(cxxRecordDecl()));
   ASSERT_TRUE(Verifier.match(From, Matcher));
   EXPECT_TRUE(Verifier.match(To, Matcher));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ShouldImportImplicitCXXRecordDeclOfClassTemplate) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template <typename U>
       struct declToImport {
       };
       )",
-      Lang_CXX, "", Lang_CXX);
+      Lang_CXX03, "", Lang_CXX03);
 
   MatchVerifier<Decl> Verifier;
   // Match the implicit Decl.
   auto Matcher = classTemplateDecl(has(cxxRecordDecl(has(cxxRecordDecl()))));
   ASSERT_TRUE(Verifier.match(From, Matcher));
   EXPECT_TRUE(Verifier.match(To, Matcher));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ShouldImportImplicitCXXRecordDeclOfClassTemplateSpecializationDecl) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template<class T>
       class Base {};
       class declToImport : public Base<declToImport> {};
       )",
-      Lang_CXX, "", Lang_CXX);
+      Lang_CXX03, "", Lang_CXX03);
 
   auto hasImplicitClass = has(cxxRecordDecl());
   auto Pattern = translationUnitDecl(has(classTemplateDecl(
       hasName("Base"),
       has(classTemplateSpecializationDecl(hasImplicitClass)))));
   ASSERT_TRUE(
       MatchVerifier<Decl>{}.match(From->getTranslationUnitDecl(), Pattern));
   EXPECT_TRUE(
       MatchVerifier<Decl>{}.match(To->getTranslationUnitDecl(), Pattern));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, IDNSOrdinary) {
   Decl *From, *To;
   std::tie(From, To) =
-      getImportedDecl("void declToImport() {}", Lang_CXX, "", Lang_CXX);
+      getImportedDecl("void declToImport() {}", Lang_CXX03, "", Lang_CXX03);
 
   MatchVerifier<Decl> Verifier;
   auto Matcher = functionDecl();
   ASSERT_TRUE(Verifier.match(From, Matcher));
   EXPECT_TRUE(Verifier.match(To, Matcher));
   EXPECT_EQ(From->getIdentifierNamespace(), To->getIdentifierNamespace());
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, IDNSOfNonmemberOperator) {
   Decl *FromTU = getTuDecl(
       R"(
       struct X {};
       void operator<<(int, X);
       )",
-      Lang_CXX);
+      Lang_CXX03);
   Decl *From = LastDeclMatcher<Decl>{}.match(FromTU, functionDecl());
-  const Decl *To = Import(From, Lang_CXX);
+  const Decl *To = Import(From, Lang_CXX03);
   EXPECT_EQ(From->getIdentifierNamespace(), To->getIdentifierNamespace());
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ShouldImportMembersOfClassTemplateSpecializationDecl) {
   Decl *From, *To;
   std::tie(From, To) = getImportedDecl(
       R"(
       template<class T>
       class Base { int a; };
       class declToImport : Base<declToImport> {};
       )",
-      Lang_CXX, "", Lang_CXX);
+      Lang_CXX03, "", Lang_CXX03);
 
   auto Pattern = translationUnitDecl(has(classTemplateDecl(
       hasName("Base"),
       has(classTemplateSpecializationDecl(has(fieldDecl(hasName("a"))))))));
   ASSERT_TRUE(
       MatchVerifier<Decl>{}.match(From->getTranslationUnitDecl(), Pattern));
   EXPECT_TRUE(
       MatchVerifier<Decl>{}.match(To->getTranslationUnitDecl(), Pattern));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportDefinitionOfClassTemplateAfterFwdDecl) {
   {
     Decl *FromTU = getTuDecl(
         R"(
             template <typename T>
             struct B;
             )",
-        Lang_CXX, "input0.cc");
+        Lang_CXX03, "input0.cc");
     auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
         FromTU, classTemplateDecl(hasName("B")));
 
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
   }
 
   {
     Decl *FromTU = getTuDecl(
         R"(
             template <typename T>
             struct B {
               void f();
             };
             )",
-        Lang_CXX, "input1.cc");
+        Lang_CXX03, "input1.cc");
     FunctionDecl *FromD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("f")));
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
     auto *FromCTD = FirstDeclMatcher<ClassTemplateDecl>().match(
         FromTU, classTemplateDecl(hasName("B")));
-    auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX));
+    auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX03));
     EXPECT_TRUE(ToCTD->isThisDeclarationADefinition());
   }
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportDefinitionOfClassTemplateIfThereIsAnExistingFwdDeclAndDefinition) {
   Decl *ToTU = getToTuDecl(
       R"(
       template <typename T>
       struct B {
         void f();
       };
 
       template <typename T>
       struct B;
       )",
-      Lang_CXX);
+      Lang_CXX03);
   ASSERT_EQ(1u, DeclCounterWithPredicate<ClassTemplateDecl>(
                     [](const ClassTemplateDecl *T) {
                       return T->isThisDeclarationADefinition();
                     })
                     .match(ToTU, classTemplateDecl()));
 
   Decl *FromTU = getTuDecl(
       R"(
       template <typename T>
       struct B {
         void f();
       };
       )",
-      Lang_CXX, "input1.cc");
+      Lang_CXX03, "input1.cc");
   ClassTemplateDecl *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
       FromTU, classTemplateDecl(hasName("B")));
 
-  Import(FromD, Lang_CXX);
+  Import(FromD, Lang_CXX03);
 
   // We should have only one definition.
   EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateDecl>(
                     [](const ClassTemplateDecl *T) {
                       return T->isThisDeclarationADefinition();
                     })
                     .match(ToTU, classTemplateDecl()));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportDefinitionOfClassIfThereIsAnExistingFwdDeclAndDefinition) {
   Decl *ToTU = getToTuDecl(
       R"(
       struct B {
         void f();
       };
 
       struct B;
       )",
-      Lang_CXX);
+      Lang_CXX03);
   ASSERT_EQ(2u, DeclCounter<CXXRecordDecl>().match(
                     ToTU, cxxRecordDecl(unless(isImplicit()))));
 
   Decl *FromTU = getTuDecl(
       R"(
       struct B {
         void f();
       };
       )",
-      Lang_CXX, "input1.cc");
+      Lang_CXX03, "input1.cc");
   auto *FromD = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("B")));
 
-  Import(FromD, Lang_CXX);
+  Import(FromD, Lang_CXX03);
 
   EXPECT_EQ(2u, DeclCounter<CXXRecordDecl>().match(
                     ToTU, cxxRecordDecl(unless(isImplicit()))));
 }
 
 static void CompareSourceLocs(FullSourceLoc Loc1, FullSourceLoc Loc2) {
   EXPECT_EQ(Loc1.getExpansionLineNumber(), Loc2.getExpansionLineNumber());
   EXPECT_EQ(Loc1.getExpansionColumnNumber(), Loc2.getExpansionColumnNumber());
Decl *FromTU = getTuDecl(
       R"(
       #define MFOO(arg) arg = arg + 1
 
       void foo() {
         int a = 5;
         MFOO(a);
       }
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, functionDecl());
-  auto ToD = Import(FromD, Lang_CXX);
+  auto ToD = Import(FromD, Lang_CXX03);
 
   auto ToLHS = LastDeclMatcher<DeclRefExpr>().match(ToD, declRefExpr());
   auto FromLHS = LastDeclMatcher<DeclRefExpr>().match(FromTU, declRefExpr());
   auto ToRHS = LastDeclMatcher<IntegerLiteral>().match(ToD, integerLiteral());
   auto FromRHS =
       LastDeclMatcher<IntegerLiteral>().match(FromTU, integerLiteral());
 
   SourceManager &ToSM = ToAST->getASTContext().getSourceManager();
   SourceManager &FromSM = FromD->getASTContext().getSourceManager();
   CompareSourceRanges(ToD->getSourceRange(), FromD->getSourceRange(), ToSM,
                       FromSM);
   CompareSourceRanges(ToLHS->getSourceRange(), FromLHS->getSourceRange(), ToSM,
                       FromSM);
   CompareSourceRanges(ToRHS->getSourceRange(), FromRHS->getSourceRange(), ToSM,
                       FromSM);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportNestedMacro) {
   Decl *FromTU = getTuDecl(
       R"(
       #define FUNC_INT void declToImport
       #define FUNC FUNC_INT
       FUNC(int a);
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, functionDecl());
-  auto ToD = Import(FromD, Lang_CXX);
+  auto ToD = Import(FromD, Lang_CXX03);
 
   SourceManager &ToSM = ToAST->getASTContext().getSourceManager();
   SourceManager &FromSM = FromD->getASTContext().getSourceManager();
   CompareSourceRanges(ToD->getSourceRange(), FromD->getSourceRange(), ToSM,
                       FromSM);
 }
 
 TEST_P(
     ASTImporterOptionSpecificTestBase,
     ImportDefinitionOfClassTemplateSpecIfThereIsAnExistingFwdDeclAndDefinition) {
   Decl *ToTU = getToTuDecl(
       R"(
       template <typename T>
       struct B;
 
       template <>
       struct B<int> {};
 
       template <>
       struct B<int>;
       )",
-      Lang_CXX);
+      Lang_CXX03);
   // We should have only one definition.
   ASSERT_EQ(1u, DeclCounterWithPredicate<ClassTemplateSpecializationDecl>(
                     [](const ClassTemplateSpecializationDecl *T) {
                       return T->isThisDeclarationADefinition();
                     })
                     .match(ToTU, classTemplateSpecializationDecl()));
 
   Decl *FromTU = getTuDecl(
       R"(
       template <typename T>
       struct B;
 
       template <>
       struct B<int> {};
       )",
-      Lang_CXX, "input1.cc");
+      Lang_CXX03, "input1.cc");
   auto *FromD = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
       FromTU, classTemplateSpecializationDecl(hasName("B")));
 
-  Import(FromD, Lang_CXX);
+  Import(FromD, Lang_CXX03);
 
   // We should have only one definition.
   EXPECT_EQ(1u, DeclCounterWithPredicate<ClassTemplateSpecializationDecl>(
                     [](const ClassTemplateSpecializationDecl *T) {
                       return T->isThisDeclarationADefinition();
                     })
                     .match(ToTU, classTemplateSpecializationDecl()));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ObjectsWithUnnamedStructType) {
   Decl *FromTU = getTuDecl(
       R"(
       struct { int a; int b; } object0 = { 2, 3 };
       struct { int x; int y; int z; } object1;
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
 
   auto *Obj0 =
       FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("object0")));
   auto *From0 = getRecordDecl(Obj0);
   auto *Obj1 =
       FirstDeclMatcher<VarDecl>().match(FromTU, varDecl(hasName("object1")));
   auto *From1 = getRecordDecl(Obj1);
 
-  auto *To0 = Import(From0, Lang_CXX);
-  auto *To1 = Import(From1, Lang_CXX);
+  auto *To0 = Import(From0, Lang_CXX03);
+  auto *To1 = Import(From1, Lang_CXX03);
 
   EXPECT_TRUE(To0);
   EXPECT_TRUE(To1);
   EXPECT_NE(To0, To1);
   EXPECT_NE(To0->getCanonicalDecl(), To1->getCanonicalDecl());
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, AnonymousRecords) {
   auto *Code =
       R"(
       struct X {
         struct { int a; };
         struct { int b; };
       };
       )";
-  Decl *FromTU0 = getTuDecl(Code, Lang_C, "input0.c");
+  Decl *FromTU0 = getTuDecl(Code, Lang_C99, "input0.c");
 
-  Decl *FromTU1 = getTuDecl(Code, Lang_C, "input1.c");
+  Decl *FromTU1 = getTuDecl(Code, Lang_C99, "input1.c");
 
   auto *X0 =
       FirstDeclMatcher<RecordDecl>().match(FromTU0, recordDecl(hasName("X")));
   auto *X1 =
       FirstDeclMatcher<RecordDecl>().match(FromTU1, recordDecl(hasName("X")));
-  Import(X0, Lang_C);
-  Import(X1, Lang_C);
+  Import(X0, Lang_C99);
+  Import(X1, Lang_C99);
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // We expect no (ODR) warning during the import.
   EXPECT_EQ(0u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
   EXPECT_EQ(1u,
             DeclCounter<RecordDecl>().match(ToTU, recordDecl(hasName("X"))));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, AnonymousRecordsReversed) {
   Decl *FromTU0 = getTuDecl(
       R"(
       struct X {
         struct { int a; };
         struct { int b; };
       };
       )",
-      Lang_C, "input0.c");
+      Lang_C99, "input0.c");
 
   Decl *FromTU1 = getTuDecl(
       R"(
       struct X { // reversed order
         struct { int b; };
         struct { int a; };
       };
       )",
-      Lang_C, "input1.c");
+      Lang_C99, "input1.c");
 
   auto *X0 =
       FirstDeclMatcher<RecordDecl>().match(FromTU0, recordDecl(hasName("X")));
   auto *X1 =
       FirstDeclMatcher<RecordDecl>().match(FromTU1, recordDecl(hasName("X")));
-  Import(X0, Lang_C);
-  Import(X1, Lang_C);
+  Import(X0, Lang_C99);
+  Import(X1, Lang_C99);
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // We expect one (ODR) warning during the import.
   EXPECT_EQ(1u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
   EXPECT_EQ(1u,
             DeclCounter<RecordDecl>().match(ToTU, recordDecl(hasName("X"))));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportDoesUpdateUsedFlag) {
   auto Pattern = varDecl(hasName("x"));
   VarDecl *Imported1;
   {
-    Decl *FromTU = getTuDecl("extern int x;", Lang_CXX, "input0.cc");
+    Decl *FromTU = getTuDecl("extern int x;", Lang_CXX03, "input0.cc");
     auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
-    Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX));
+    Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX03));
   }
   VarDecl *Imported2;
   {
-    Decl *FromTU = getTuDecl("int x;", Lang_CXX, "input1.cc");
+    Decl *FromTU = getTuDecl("int x;", Lang_CXX03, "input1.cc");
     auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
-    Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX));
+    Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX03));
   }
   EXPECT_EQ(Imported1->getCanonicalDecl(), Imported2->getCanonicalDecl());
   EXPECT_FALSE(Imported2->isUsed(false));
   {
-    Decl *FromTU =
-        getTuDecl("extern int x; int f() { return x; }", Lang_CXX, "input2.cc");
+    Decl *FromTU = getTuDecl("extern int x; int f() { return x; }", Lang_CXX03,
+                             "input2.cc");
     auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("f")));
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
   }
   EXPECT_TRUE(Imported2->isUsed(false));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportDoesUpdateUsedFlag2) {
   auto Pattern = varDecl(hasName("x"));
   VarDecl *ExistingD;
   {
-    Decl *ToTU = getToTuDecl("int x = 1;", Lang_CXX);
+    Decl *ToTU = getToTuDecl("int x = 1;", Lang_CXX03);
     ExistingD = FirstDeclMatcher<VarDecl>().match(ToTU, Pattern);
   }
   EXPECT_FALSE(ExistingD->isUsed(false));
   {
-    Decl *FromTU = getTuDecl(
-        "int x = 1; int f() { return x; }", Lang_CXX, "input1.cc");
+    Decl *FromTU =
+        getTuDecl("int x = 1; int f() { return x; }", Lang_CXX03, "input1.cc");
     auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("f")));
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
   }
   EXPECT_TRUE(ExistingD->isUsed(false));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportDoesUpdateUsedFlag3) {
   auto Pattern = varDecl(hasName("a"));
   VarDecl *ExistingD;
   {
     Decl *ToTU = getToTuDecl(
         R"(
         struct A {
           static const int a = 1;
         };
-        )", Lang_CXX);
+        )",
+        Lang_CXX03);
     ExistingD = FirstDeclMatcher<VarDecl>().match(ToTU, Pattern);
   }
   EXPECT_FALSE(ExistingD->isUsed(false));
   {
     Decl *FromTU = getTuDecl(
         R"(
         struct A {
           static const int a = 1;
         };
         const int *f() { return &A::a; } // requires storage,
                                          // thus used flag will be set
-        )", Lang_CXX, "input1.cc");
+        )",
+        Lang_CXX03, "input1.cc");
     auto *FromFunD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("f")));
     auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
     ASSERT_TRUE(FromD->isUsed(false));
-    Import(FromFunD, Lang_CXX);
+    Import(FromFunD, Lang_CXX03);
   }
   EXPECT_TRUE(ExistingD->isUsed(false));
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ReimportWithUsedFlag) {
   auto Pattern = varDecl(hasName("x"));
 
-  Decl *FromTU = getTuDecl("int x;", Lang_CXX, "input0.cc");
+  Decl *FromTU = getTuDecl("int x;", Lang_CXX03, "input0.cc");
   auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
 
-  auto *Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX));
+  auto *Imported1 = cast<VarDecl>(Import(FromD, Lang_CXX03));
 
   ASSERT_FALSE(Imported1->isUsed(false));
 
   FromD->setIsUsed();
-  auto *Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX));
+  auto *Imported2 = cast<VarDecl>(Import(FromD, Lang_CXX03));
 
   EXPECT_EQ(Imported1, Imported2);
   EXPECT_TRUE(Imported2->isUsed(false));
 }
 
 struct ImportFunctions : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportFunctions, ImportPrototypeOfRecursiveFunction) {
-  Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX);
+  Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX03);
   auto Pattern = functionDecl(hasName("f"));
   auto *From =
       FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern); // Proto
 
-  Decl *ImportedD = Import(From, Lang_CXX);
+  Decl *ImportedD = Import(From, Lang_CXX03);
   Decl *ToTU = ImportedD->getTranslationUnitDecl();
 
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   EXPECT_TRUE(ImportedD == To0);
   EXPECT_FALSE(To0->doesThisDeclarationHaveABody());
   EXPECT_TRUE(To1->doesThisDeclarationHaveABody());
   EXPECT_EQ(To1->getPreviousDecl(), To0);
 }
 
 TEST_P(ImportFunctions, ImportDefinitionOfRecursiveFunction) {
-  Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX);
+  Decl *FromTU = getTuDecl("void f(); void f() { f(); }", Lang_CXX03);
   auto Pattern = functionDecl(hasName("f"));
   auto *From =
       LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern); // Def
 
-  Decl *ImportedD = Import(From, Lang_CXX);
+  Decl *ImportedD = Import(From, Lang_CXX03);
   Decl *ToTU = ImportedD->getTranslationUnitDecl();
 
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   auto *To1 = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   EXPECT_TRUE(ImportedD == To1);
   EXPECT_FALSE(To0->doesThisDeclarationHaveABody());
   EXPECT_TRUE(To1->doesThisDeclarationHaveABody());
   EXPECT_EQ(To1->getPreviousDecl(), To0);
 }
 
 TEST_P(ImportFunctions, OverriddenMethodsShouldBeImported) {
   auto Code =
       R"(
       struct B { virtual void f(); };
       void B::f() {}
       struct D : B { void f(); };
       )";
   auto Pattern =
       cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("D"))));
-  Decl *FromTU = getTuDecl(Code, Lang_CXX);
+  Decl *FromTU = getTuDecl(Code, Lang_CXX03);
   CXXMethodDecl *Proto =
       FirstDeclMatcher<CXXMethodDecl>().match(FromTU, Pattern);
 
   ASSERT_EQ(Proto->size_overridden_methods(), 1u);
-  CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX));
+  CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX03));
   EXPECT_EQ(To->size_overridden_methods(), 1u);
 }
 
 TEST_P(ImportFunctions, VirtualFlagShouldBePreservedWhenImportingPrototype) {
   auto Code =
       R"(
       struct B { virtual void f(); };
       void B::f() {}
       )";
   auto Pattern =
       cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("B"))));
-  Decl *FromTU = getTuDecl(Code, Lang_CXX);
+  Decl *FromTU = getTuDecl(Code, Lang_CXX03);
   CXXMethodDecl *Proto =
       FirstDeclMatcher<CXXMethodDecl>().match(FromTU, Pattern);
   CXXMethodDecl *Def = LastDeclMatcher<CXXMethodDecl>().match(FromTU, Pattern);
 
   ASSERT_TRUE(Proto->isVirtual());
   ASSERT_TRUE(Def->isVirtual());
-  CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX));
+  CXXMethodDecl *To = cast<CXXMethodDecl>(Import(Proto, Lang_CXX03));
   EXPECT_TRUE(To->isVirtual());
 }
 
 TEST_P(ImportFunctions,
        ImportDefinitionIfThereIsAnExistingDefinitionAndFwdDecl) {
   Decl *ToTU = getToTuDecl(
       R"(
       void f() {}
       void f();
       )",
-      Lang_CXX);
+      Lang_CXX03);
   ASSERT_EQ(1u,
             DeclCounterWithPredicate<FunctionDecl>([](const FunctionDecl *FD) {
               return FD->doesThisDeclarationHaveABody();
             }).match(ToTU, functionDecl()));
 
-  Decl *FromTU = getTuDecl("void f() {}", Lang_CXX, "input0.cc");
+  Decl *FromTU = getTuDecl("void f() {}", Lang_CXX03, "input0.cc");
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, functionDecl());
 
-  Import(FromD, Lang_CXX);
+  Import(FromD, Lang_CXX03);
 
   EXPECT_EQ(1u,
             DeclCounterWithPredicate<FunctionDecl>([](const FunctionDecl *FD) {
               return FD->doesThisDeclarationHaveABody();
             }).match(ToTU, functionDecl()));
 }
 
 TEST_P(ImportFunctions, ImportOverriddenMethodTwice) {
   auto Code =
       R"(
       struct B { virtual void f(); };
       struct D:B { void f(); };
       )";
   auto BFP =
       cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("B"))));
   auto DFP =
       cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("D"))));
 
-  Decl *FromTU0 = getTuDecl(Code, Lang_CXX);
+  Decl *FromTU0 = getTuDecl(Code, Lang_CXX03);
   auto *DF = FirstDeclMatcher<CXXMethodDecl>().match(FromTU0, DFP);
-  Import(DF, Lang_CXX);
+  Import(DF, Lang_CXX03);
 
-  Decl *FromTU1 = getTuDecl(Code, Lang_CXX, "input1.cc");
+  Decl *FromTU1 = getTuDecl(Code, Lang_CXX03, "input1.cc");
   auto *BF = FirstDeclMatcher<CXXMethodDecl>().match(FromTU1, BFP);
-  Import(BF, Lang_CXX);
+  Import(BF, Lang_CXX03);
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
 
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFP), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFP), 1u);
 }
 
 TEST_P(ImportFunctions, ImportOverriddenMethodTwiceDefinitionFirst) {
auto DFP =
       cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("D"))));
   auto BFDefP = cxxMethodDecl(
       hasName("f"), hasParent(cxxRecordDecl(hasName("B"))), isDefinition());
   auto DFDefP = cxxMethodDecl(
       hasName("f"), hasParent(cxxRecordDecl(hasName("D"))), isDefinition());
   auto FDefAllP = cxxMethodDecl(hasName("f"), isDefinition());
 
   {
-    Decl *FromTU = getTuDecl(CodeWithDef, Lang_CXX, "input0.cc");
+    Decl *FromTU = getTuDecl(CodeWithDef, Lang_CXX03, "input0.cc");
     auto *FromD = FirstDeclMatcher<CXXMethodDecl>().match(FromTU, DFP);
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
   }
   {
-    Decl *FromTU = getTuDecl(CodeWithoutDef, Lang_CXX, "input1.cc");
+    Decl *FromTU = getTuDecl(CodeWithoutDef, Lang_CXX03, "input1.cc");
     auto *FromB = FirstDeclMatcher<CXXMethodDecl>().match(FromTU, BFP);
-    Import(FromB, Lang_CXX);
+    Import(FromB, Lang_CXX03);
   }
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
 
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFP), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFP), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFDefP), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFDefP), 1u);
TEST_P(ImportFunctions, ImportOverriddenMethodTwiceOutOfClassDef) {
 
   auto BFP =
       cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("B"))));
   auto BFDefP = cxxMethodDecl(
       hasName("f"), hasParent(cxxRecordDecl(hasName("B"))), isDefinition());
   auto DFP = cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("D"))),
                            unless(isDefinition()));
 
-  Decl *FromTU0 = getTuDecl(Code, Lang_CXX);
+  Decl *FromTU0 = getTuDecl(Code, Lang_CXX03);
   auto *D = FirstDeclMatcher<CXXMethodDecl>().match(FromTU0, DFP);
-  Import(D, Lang_CXX);
+  Import(D, Lang_CXX03);
 
-  Decl *FromTU1 = getTuDecl(Code, Lang_CXX, "input1.cc");
+  Decl *FromTU1 = getTuDecl(Code, Lang_CXX03, "input1.cc");
   auto *B = FirstDeclMatcher<CXXMethodDecl>().match(FromTU1, BFP);
-  Import(B, Lang_CXX);
+  Import(B, Lang_CXX03);
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
 
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFP), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFDefP), 0u);
 
   auto *ToB = FirstDeclMatcher<CXXRecordDecl>().match(
       ToTU, cxxRecordDecl(hasName("B")));
auto BFDefP = cxxMethodDecl(
       hasName("f"), hasParent(cxxRecordDecl(hasName("B"))), isDefinition());
   auto DFP =
       cxxMethodDecl(hasName("f"), hasParent(cxxRecordDecl(hasName("D"))));
   auto DFDefP = cxxMethodDecl(
       hasName("f"), hasParent(cxxRecordDecl(hasName("D"))), isDefinition());
   auto FooDef = functionDecl(hasName("foo"));
 
   {
-    Decl *FromTU0 = getTuDecl(CodeTU0, Lang_CXX, "input0.cc");
+    Decl *FromTU0 = getTuDecl(CodeTU0, Lang_CXX03, "input0.cc");
     auto *D = FirstDeclMatcher<CXXMethodDecl>().match(FromTU0, DFP);
-    Import(D, Lang_CXX);
+    Import(D, Lang_CXX03);
   }
 
   {
-    Decl *FromTU1 = getTuDecl(CodeTU1, Lang_CXX, "input1.cc");
+    Decl *FromTU1 = getTuDecl(CodeTU1, Lang_CXX03, "input1.cc");
     auto *Foo = FirstDeclMatcher<FunctionDecl>().match(FromTU1, FooDef);
-    Import(Foo, Lang_CXX);
+    Import(Foo, Lang_CXX03);
   }
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
 
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFP), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFP), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, BFDefP), 0u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, DFDefP), 0u);
TEST_P(ImportFunctions,
   EXPECT_EQ(ToBFOutOfClass->getPreviousDecl(), ToBFInClass);
   EXPECT_EQ(ToDFOutOfClass->getPreviousDecl(), ToDFInClass);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportVariableChainInC) {
     std::string Code = "static int v; static int v = 0;";
     auto Pattern = varDecl(hasName("v"));
 
-    TranslationUnitDecl *FromTu = getTuDecl(Code, Lang_C, "input0.c");
+    TranslationUnitDecl *FromTu = getTuDecl(Code, Lang_C99, "input0.c");
 
     auto *From0 = FirstDeclMatcher<VarDecl>().match(FromTu, Pattern);
     auto *From1 = LastDeclMatcher<VarDecl>().match(FromTu, Pattern);
 
-    auto *To0 = Import(From0, Lang_C);
-    auto *To1 = Import(From1, Lang_C);
+    auto *To0 = Import(From0, Lang_C99);
+    auto *To1 = Import(From1, Lang_C99);
 
     EXPECT_TRUE(To0);
     ASSERT_TRUE(To1);
     EXPECT_NE(To0, To1);
     EXPECT_EQ(To1->getPreviousDecl(), To0);
 }
 
 TEST_P(ImportFunctions, ImportFromDifferentScopedAnonNamespace) {
-  TranslationUnitDecl *FromTu = getTuDecl(
-      "namespace NS0 { namespace { void f(); } }"
+  TranslationUnitDecl *FromTu =
+      getTuDecl("namespace NS0 { namespace { void f(); } }"
                 "namespace NS1 { namespace { void f(); } }",
-      Lang_CXX, "input0.cc");
+                Lang_CXX03, "input0.cc");
   auto Pattern = functionDecl(hasName("f"));
 
   auto *FromF0 = FirstDeclMatcher<FunctionDecl>().match(FromTu, Pattern);
   auto *FromF1 = LastDeclMatcher<FunctionDecl>().match(FromTu, Pattern);
 
-  auto *ToF0 = Import(FromF0, Lang_CXX);
-  auto *ToF1 = Import(FromF1, Lang_CXX);
+  auto *ToF0 = Import(FromF0, Lang_CXX03);
+  auto *ToF1 = Import(FromF1, Lang_CXX03);
 
   EXPECT_TRUE(ToF0);
   ASSERT_TRUE(ToF1);
   EXPECT_NE(ToF0, ToF1);
   EXPECT_FALSE(ToF1->getPreviousDecl());
 }
 
 TEST_P(ImportFunctions, ImportFunctionFromUnnamedNamespace) {
   {
     Decl *FromTU = getTuDecl("namespace { void f() {} } void g0() { f(); }",
-                             Lang_CXX, "input0.cc");
+                             Lang_CXX03, "input0.cc");
     auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("g0")));
 
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
   }
   {
     Decl *FromTU =
         getTuDecl("namespace { void f() { int a; } } void g1() { f(); }",
-                  Lang_CXX, "input1.cc");
+                  Lang_CXX03, "input1.cc");
     auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("g1")));
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
   }
 
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("f"))),
             2u);
 }
 
 TEST_P(ImportFunctions, ImportImplicitFunctionsInLambda) {
   Decl *FromTU = getTuDecl(
       R"(
       void foo() {
         (void)[]() { ; };
       }
       )",
       Lang_CXX11);
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("foo")));
-  auto *ToD = Import(FromD, Lang_CXX);
+  auto *ToD = Import(FromD, Lang_CXX03);
   EXPECT_TRUE(ToD);
   CXXRecordDecl *LambdaRec =
       cast<LambdaExpr>(cast<CStyleCastExpr>(
                            *cast<CompoundStmt>(ToD->getBody())->body_begin())
                            ->getSubExpr())
           ->getLambdaClass();
   EXPECT_TRUE(LambdaRec->getDestructor());
 }
 
 TEST_P(ImportFunctions,
        CallExprOfMemberFunctionTemplateWithExplicitTemplateArgs) {
   Decl *FromTU = getTuDecl(
       R"(
       struct X {
         template <typename T>
         void foo(){}
       };
       void f() {
         X x;
         x.foo<int>();
       }
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("f")));
-  auto *ToD = Import(FromD, Lang_CXX);
+  auto *ToD = Import(FromD, Lang_CXX03);
   EXPECT_TRUE(ToD);
   EXPECT_TRUE(MatchVerifier<FunctionDecl>().match(
       ToD, functionDecl(hasName("f"), hasDescendant(declRefExpr()))));
 }
 
 TEST_P(ImportFunctions,
        DependentCallExprOfMemberFunctionTemplateWithExplicitTemplateArgs) {
   Decl *FromTU = getTuDecl(
       R"(
       struct X {
         template <typename T>
         void foo(){}
       };
       template <typename T>
       void f() {
         X x;
         x.foo<T>();
       }
       void g() {
         f<int>();
       }
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("g")));
-  auto *ToD = Import(FromD, Lang_CXX);
+  auto *ToD = Import(FromD, Lang_CXX03);
   EXPECT_TRUE(ToD);
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   EXPECT_TRUE(MatchVerifier<TranslationUnitDecl>().match(
       ToTU, translationUnitDecl(hasDescendant(
                 functionDecl(hasName("f"), hasDescendant(declRefExpr()))))));
 }
 
 struct ImportFunctionTemplates : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportFunctionTemplates, ImportFunctionTemplateInRecordDeclTwice) {
   auto Code =
       R"(
       class X {
         template <class T>
         void f(T t);
       };
       )";
-  Decl *FromTU1 = getTuDecl(Code, Lang_CXX, "input1.cc");
+  Decl *FromTU1 = getTuDecl(Code, Lang_CXX03, "input1.cc");
   auto *FromD1 = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU1, functionTemplateDecl(hasName("f")));
-  auto *ToD1 = Import(FromD1, Lang_CXX);
-  Decl *FromTU2 = getTuDecl(Code, Lang_CXX, "input2.cc");
+  auto *ToD1 = Import(FromD1, Lang_CXX03);
+  Decl *FromTU2 = getTuDecl(Code, Lang_CXX03, "input2.cc");
   auto *FromD2 = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU2, functionTemplateDecl(hasName("f")));
-  auto *ToD2 = Import(FromD2, Lang_CXX);
+  auto *ToD2 = Import(FromD2, Lang_CXX03);
   EXPECT_EQ(ToD1, ToD2);
 }
 
 TEST_P(ImportFunctionTemplates,
        ImportFunctionTemplateWithDefInRecordDeclTwice) {
   auto Code =
       R"(
       class X {
         template <class T>
         void f(T t);
       };
       template <class T>
       void X::f(T t) {};
       )";
-  Decl *FromTU1 = getTuDecl(Code, Lang_CXX, "input1.cc");
+  Decl *FromTU1 = getTuDecl(Code, Lang_CXX03, "input1.cc");
   auto *FromD1 = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU1, functionTemplateDecl(hasName("f")));
-  auto *ToD1 = Import(FromD1, Lang_CXX);
-  Decl *FromTU2 = getTuDecl(Code, Lang_CXX, "input2.cc");
+  auto *ToD1 = Import(FromD1, Lang_CXX03);
+  Decl *FromTU2 = getTuDecl(Code, Lang_CXX03, "input2.cc");
   auto *FromD2 = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU2, functionTemplateDecl(hasName("f")));
-  auto *ToD2 = Import(FromD2, Lang_CXX);
+  auto *ToD2 = Import(FromD2, Lang_CXX03);
   EXPECT_EQ(ToD1, ToD2);
 }
 
 TEST_P(ImportFunctionTemplates,
        ImportFunctionWhenThereIsAFunTemplateWithSameName) {
   getToTuDecl(
       R"(
       template <typename T>
       void foo(T) {}
       void foo();
       )",
-      Lang_CXX);
-  Decl *FromTU = getTuDecl("void foo();", Lang_CXX);
+      Lang_CXX03);
+  Decl *FromTU = getTuDecl("void foo();", Lang_CXX03);
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("foo")));
-  auto *ImportedD = Import(FromD, Lang_CXX);
+  auto *ImportedD = Import(FromD, Lang_CXX03);
   EXPECT_TRUE(ImportedD);
 }
 
 TEST_P(ImportFunctionTemplates,
        ImportConstructorWhenThereIsAFunTemplateWithSameName) {
   auto Code =
       R"(
       struct Foo {
         template <typename T>
         Foo(T) {}
         Foo();
       };
       )";
-  getToTuDecl(Code, Lang_CXX);
-  Decl *FromTU = getTuDecl(Code, Lang_CXX);
+  getToTuDecl(Code, Lang_CXX03);
+  Decl *FromTU = getTuDecl(Code, Lang_CXX03);
   auto *FromD =
       LastDeclMatcher<CXXConstructorDecl>().match(FromTU, cxxConstructorDecl());
-  auto *ImportedD = Import(FromD, Lang_CXX);
+  auto *ImportedD = Import(FromD, Lang_CXX03);
   EXPECT_TRUE(ImportedD);
 }
 
 TEST_P(ImportFunctionTemplates,
        ImportOperatorWhenThereIsAFunTemplateWithSameName) {
   getToTuDecl(
       R"(
       template <typename T>
       void operator<(T,T) {}
       struct X{};
       void operator<(X, X);
       )",
-      Lang_CXX);
+      Lang_CXX03);
   Decl *FromTU = getTuDecl(
       R"(
       struct X{};
       void operator<(X, X);
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *FromD = LastDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasOverloadedOperatorName("<")));
-  auto *ImportedD = Import(FromD, Lang_CXX);
+  auto *ImportedD = Import(FromD, Lang_CXX03);
   EXPECT_TRUE(ImportedD);
 }
 
 struct ImportFriendFunctions : ImportFunctions {};
 
 TEST_P(ImportFriendFunctions, ImportFriendFunctionRedeclChainProto) {
   auto Pattern = functionDecl(hasName("f"));
 
   Decl *FromTU = getTuDecl("struct X { friend void f(); };"
                            "void f();",
-                           Lang_CXX,
-                           "input0.cc");
+                           Lang_CXX03, "input0.cc");
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
-  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   EXPECT_FALSE(ImportedD->doesThisDeclarationHaveABody());
   auto *ToFD = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   EXPECT_FALSE(ToFD->doesThisDeclarationHaveABody());
   EXPECT_EQ(ToFD->getPreviousDecl(), ImportedD);
 }
 
 TEST_P(ImportFriendFunctions,
        ImportFriendFunctionRedeclChainProto_OutOfClassProtoFirst) {
   auto Pattern = functionDecl(hasName("f"));
 
   Decl *FromTU = getTuDecl("void f();"
                            "struct X { friend void f(); };",
-                           Lang_CXX, "input0.cc");
+                           Lang_CXX03, "input0.cc");
   auto FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
-  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   EXPECT_FALSE(ImportedD->doesThisDeclarationHaveABody());
   auto *ToFD = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   EXPECT_FALSE(ToFD->doesThisDeclarationHaveABody());
   EXPECT_EQ(ToFD->getPreviousDecl(), ImportedD);
 }
 
 TEST_P(ImportFriendFunctions, ImportFriendFunctionRedeclChainDef) {
   auto Pattern = functionDecl(hasName("f"));
 
   Decl *FromTU = getTuDecl("struct X { friend void f(){} };"
                            "void f();",
-                           Lang_CXX,
-                           "input0.cc");
+                           Lang_CXX03, "input0.cc");
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
-  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   EXPECT_TRUE(ImportedD->doesThisDeclarationHaveABody());
   auto *ToFD = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   EXPECT_FALSE(ToFD->doesThisDeclarationHaveABody());
   EXPECT_EQ(ToFD->getPreviousDecl(), ImportedD);
 }
 
 TEST_P(ImportFriendFunctions,
        ImportFriendFunctionRedeclChainDef_OutOfClassDef) {
   auto Pattern = functionDecl(hasName("f"));
 
   Decl *FromTU = getTuDecl("struct X { friend void f(); };"
                            "void f(){}",
-                           Lang_CXX, "input0.cc");
+                           Lang_CXX03, "input0.cc");
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
-  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   EXPECT_FALSE(ImportedD->doesThisDeclarationHaveABody());
   auto *ToFD = LastDeclMatcher<FunctionDecl>().match(ToTU, Pattern);
   EXPECT_TRUE(ToFD->doesThisDeclarationHaveABody());
   EXPECT_EQ(ToFD->getPreviousDecl(), ImportedD);
 }
 
 TEST_P(ImportFriendFunctions, ImportFriendFunctionRedeclChainDefWithClass) {
   auto Pattern = functionDecl(hasName("f"));
 
   Decl *FromTU = getTuDecl(
       R"(
         class X;
         void f(X *x){}
         class X{
         friend void f(X *x);
         };
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
-  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   EXPECT_TRUE(ImportedD->doesThisDeclarationHaveABody());
   auto *InClassFD = cast<FunctionDecl>(FirstDeclMatcher<FriendDecl>()
                                               .match(ToTU, friendDecl())
                                               ->getFriendDecl());
   EXPECT_FALSE(InClassFD->doesThisDeclarationHaveABody());
   EXPECT_EQ(InClassFD->getPreviousDecl(), ImportedD);
TEST_P(ImportFriendFunctions,
   Decl *FromTU = getTuDecl(
       R"(
         class X;
         void f(X *x){}
         class X{
         friend void f(X *x);
         };
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
   auto *FromD = LastDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
 
-  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+  auto *ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   EXPECT_FALSE(ImportedD->doesThisDeclarationHaveABody());
   auto *OutOfClassFD = FirstDeclMatcher<FunctionDecl>().match(
       ToTU, functionDecl(unless(hasParent(friendDecl()))));
 
   EXPECT_TRUE(OutOfClassFD->doesThisDeclarationHaveABody());
   EXPECT_EQ(ImportedD->getPreviousDecl(), OutOfClassFD);
   // The parameters must refer the same type
   EXPECT_EQ((*OutOfClassFD->param_begin())->getOriginalType(),
             (*ImportedD->param_begin())->getOriginalType());
 }
 
 TEST_P(ImportFriendFunctions, ImportFriendFunctionFromMultipleTU) {
   auto Pattern = functionDecl(hasName("f"));
 
   FunctionDecl *ImportedD;
   {
     Decl *FromTU =
-        getTuDecl("struct X { friend void f(){} };", Lang_CXX, "input0.cc");
+        getTuDecl("struct X { friend void f(){} };", Lang_CXX03, "input0.cc");
     auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
-    ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+    ImportedD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   }
   FunctionDecl *ImportedD1;
   {
-    Decl *FromTU = getTuDecl("void f();", Lang_CXX, "input1.cc");
+    Decl *FromTU = getTuDecl("void f();", Lang_CXX03, "input1.cc");
     auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, Pattern);
-    ImportedD1 = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+    ImportedD1 = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   }
 
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
   EXPECT_TRUE(ImportedD->doesThisDeclarationHaveABody());
   EXPECT_FALSE(ImportedD1->doesThisDeclarationHaveABody());
   EXPECT_EQ(ImportedD1->getPreviousDecl(), ImportedD);
 }
 
 TEST_P(ImportFriendFunctions, Lookup) {
   auto FunctionPattern = functionDecl(hasName("f"));
   auto ClassPattern = cxxRecordDecl(hasName("X"));
 
   TranslationUnitDecl *FromTU =
-      getTuDecl("struct X { friend void f(); };", Lang_CXX, "input0.cc");
+      getTuDecl("struct X { friend void f(); };", Lang_CXX03, "input0.cc");
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU, FunctionPattern);
   ASSERT_TRUE(FromD->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   ASSERT_FALSE(FromD->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   {
     auto FromName = FromD->getDeclName();
     auto *Class = FirstDeclMatcher<CXXRecordDecl>().match(FromTU, ClassPattern);
     auto LookupRes = Class->noload_lookup(FromName);
     ASSERT_EQ(LookupRes.size(), 0u);
     LookupRes = FromTU->noload_lookup(FromName);
     ASSERT_EQ(LookupRes.size(), 1u);
   }
 
-  auto *ToD = cast<FunctionDecl>(Import(FromD, Lang_CXX));
+  auto *ToD = cast<FunctionDecl>(Import(FromD, Lang_CXX03));
   auto ToName = ToD->getDeclName();
 
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   auto *Class = FirstDeclMatcher<CXXRecordDecl>().match(ToTU, ClassPattern);
   auto LookupRes = Class->noload_lookup(ToName);
   EXPECT_EQ(LookupRes.size(), 0u);
   LookupRes = ToTU->noload_lookup(ToName);
   EXPECT_EQ(LookupRes.size(), 1u);
 
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, FunctionPattern), 1u);
   auto *To0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, FunctionPattern);
   EXPECT_TRUE(To0->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   EXPECT_FALSE(To0->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 }
 
 TEST_P(ImportFriendFunctions, LookupWithProtoAfter) {
   auto FunctionPattern = functionDecl(hasName("f"));
   auto ClassPattern = cxxRecordDecl(hasName("X"));
 
-  TranslationUnitDecl *FromTU = getTuDecl(
-      "struct X { friend void f(); };"
+  TranslationUnitDecl *FromTU =
+      getTuDecl("struct X { friend void f(); };"
                 // This proto decl makes f available to normal
                 // lookup, otherwise it is hidden.
                 // Normal C++ lookup (implemented in
                 // `clang::Sema::CppLookupName()` and in `LookupDirect()`)
                 // returns the found `NamedDecl` only if the set IDNS is matched
                 "void f();",
-      Lang_CXX, "input0.cc");
+                Lang_CXX03, "input0.cc");
   auto *FromFriend =
       FirstDeclMatcher<FunctionDecl>().match(FromTU, FunctionPattern);
   auto *FromNormal =
       LastDeclMatcher<FunctionDecl>().match(FromTU, FunctionPattern);
   ASSERT_TRUE(FromFriend->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   ASSERT_FALSE(FromFriend->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   ASSERT_FALSE(FromNormal->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   ASSERT_TRUE(FromNormal->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 
   auto FromName = FromFriend->getDeclName();
   auto *FromClass =
       FirstDeclMatcher<CXXRecordDecl>().match(FromTU, ClassPattern);
   auto LookupRes = FromClass->noload_lookup(FromName);
   ASSERT_EQ(LookupRes.size(), 0u);
   LookupRes = FromTU->noload_lookup(FromName);
   ASSERT_EQ(LookupRes.size(), 1u);
 
-  auto *ToFriend = cast<FunctionDecl>(Import(FromFriend, Lang_CXX));
+  auto *ToFriend = cast<FunctionDecl>(Import(FromFriend, Lang_CXX03));
   auto ToName = ToFriend->getDeclName();
 
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   auto *ToClass = FirstDeclMatcher<CXXRecordDecl>().match(ToTU, ClassPattern);
   LookupRes = ToClass->noload_lookup(ToName);
   EXPECT_EQ(LookupRes.size(), 0u);
   LookupRes = ToTU->noload_lookup(ToName);
   // Test is disabled because this result is 2.
   EXPECT_EQ(LookupRes.size(), 1u);
 
   ASSERT_EQ(DeclCounter<FunctionDecl>().match(ToTU, FunctionPattern), 2u);
   ToFriend = FirstDeclMatcher<FunctionDecl>().match(ToTU, FunctionPattern);
   auto *ToNormal = LastDeclMatcher<FunctionDecl>().match(ToTU, FunctionPattern);
   EXPECT_TRUE(ToFriend->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   EXPECT_FALSE(ToFriend->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   EXPECT_FALSE(ToNormal->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   EXPECT_TRUE(ToNormal->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 }
 
 TEST_P(ImportFriendFunctions, LookupWithProtoBefore) {
   auto FunctionPattern = functionDecl(hasName("f"));
   auto ClassPattern = cxxRecordDecl(hasName("X"));
 
-  TranslationUnitDecl *FromTU = getTuDecl(
-      "void f();"
+  TranslationUnitDecl *FromTU = getTuDecl("void f();"
                                           "struct X { friend void f(); };",
-      Lang_CXX, "input0.cc");
+                                          Lang_CXX03, "input0.cc");
   auto *FromNormal =
       FirstDeclMatcher<FunctionDecl>().match(FromTU, FunctionPattern);
   auto *FromFriend =
       LastDeclMatcher<FunctionDecl>().match(FromTU, FunctionPattern);
   ASSERT_FALSE(FromNormal->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   ASSERT_TRUE(FromNormal->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   ASSERT_TRUE(FromFriend->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   ASSERT_TRUE(FromFriend->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 
   auto FromName = FromNormal->getDeclName();
   auto *FromClass =
       FirstDeclMatcher<CXXRecordDecl>().match(FromTU, ClassPattern);
   auto LookupRes = FromClass->noload_lookup(FromName);
   ASSERT_EQ(LookupRes.size(), 0u);
   LookupRes = FromTU->noload_lookup(FromName);
   ASSERT_EQ(LookupRes.size(), 1u);
 
-  auto *ToNormal = cast<FunctionDecl>(Import(FromNormal, Lang_CXX));
+  auto *ToNormal = cast<FunctionDecl>(Import(FromNormal, Lang_CXX03));
   auto ToName = ToNormal->getDeclName();
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
 
   auto *ToClass = FirstDeclMatcher<CXXRecordDecl>().match(ToTU, ClassPattern);
   LookupRes = ToClass->noload_lookup(ToName);
   EXPECT_EQ(LookupRes.size(), 0u);
   LookupRes = ToTU->noload_lookup(ToName);
   EXPECT_EQ(LookupRes.size(), 1u);
 
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, FunctionPattern), 2u);
   ToNormal = FirstDeclMatcher<FunctionDecl>().match(ToTU, FunctionPattern);
   auto *ToFriend = LastDeclMatcher<FunctionDecl>().match(ToTU, FunctionPattern);
   EXPECT_FALSE(ToNormal->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   EXPECT_TRUE(ToNormal->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   EXPECT_TRUE(ToFriend->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   EXPECT_TRUE(ToFriend->isInIdentifierNamespace(Decl::IDNS_Ordinary));
 }
 
 TEST_P(ImportFriendFunctions, ImportFriendChangesLookup) {
   auto Pattern = functionDecl(hasName("f"));
 
   TranslationUnitDecl *FromNormalTU =
-      getTuDecl("void f();", Lang_CXX, "input0.cc");
+      getTuDecl("void f();", Lang_CXX03, "input0.cc");
   auto *FromNormalF =
       FirstDeclMatcher<FunctionDecl>().match(FromNormalTU, Pattern);
   TranslationUnitDecl *FromFriendTU =
-      getTuDecl("class X { friend void f(); };", Lang_CXX, "input1.cc");
+      getTuDecl("class X { friend void f(); };", Lang_CXX03, "input1.cc");
   auto *FromFriendF =
       FirstDeclMatcher<FunctionDecl>().match(FromFriendTU, Pattern);
   auto FromNormalName = FromNormalF->getDeclName();
   auto FromFriendName = FromFriendF->getDeclName();
 
   ASSERT_TRUE(FromNormalF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   ASSERT_FALSE(FromNormalF->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   ASSERT_FALSE(FromFriendF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   ASSERT_TRUE(FromFriendF->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   auto LookupRes = FromNormalTU->noload_lookup(FromNormalName);
   ASSERT_EQ(LookupRes.size(), 1u);
   LookupRes = FromFriendTU->noload_lookup(FromFriendName);
   ASSERT_EQ(LookupRes.size(), 1u);
 
-  auto *ToNormalF = cast<FunctionDecl>(Import(FromNormalF, Lang_CXX));
+  auto *ToNormalF = cast<FunctionDecl>(Import(FromNormalF, Lang_CXX03));
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   auto ToName = ToNormalF->getDeclName();
   EXPECT_TRUE(ToNormalF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   EXPECT_FALSE(ToNormalF->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
   LookupRes = ToTU->noload_lookup(ToName);
   EXPECT_EQ(LookupRes.size(), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 1u);
 
-  auto *ToFriendF = cast<FunctionDecl>(Import(FromFriendF, Lang_CXX));
+  auto *ToFriendF = cast<FunctionDecl>(Import(FromFriendF, Lang_CXX03));
   LookupRes = ToTU->noload_lookup(ToName);
   EXPECT_EQ(LookupRes.size(), 1u);
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, Pattern), 2u);
 
   EXPECT_TRUE(ToNormalF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   EXPECT_FALSE(ToNormalF->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
 
   EXPECT_TRUE(ToFriendF->isInIdentifierNamespace(Decl::IDNS_Ordinary));
   EXPECT_TRUE(ToFriendF->isInIdentifierNamespace(Decl::IDNS_OrdinaryFriend));
 }
 
 TEST_P(ImportFriendFunctions, ImportFriendList) {
-  TranslationUnitDecl *FromTU = getTuDecl(
-      "struct X { friend void f(); };"
+  TranslationUnitDecl *FromTU = getTuDecl("struct X { friend void f(); };"
                                           "void f();",
-      Lang_CXX, "input0.cc");
+                                          Lang_CXX03, "input0.cc");
   auto *FromFriendF = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("f")));
 
   auto *FromClass = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("X")));
   auto *FromFriend = FirstDeclMatcher<FriendDecl>().match(FromTU, friendDecl());
   auto FromFriends = FromClass->friends();
   unsigned int FrN = 0;
   for (auto Fr : FromFriends) {
     ASSERT_EQ(Fr, FromFriend);
     ++FrN;
   }
   ASSERT_EQ(FrN, 1u);
 
-  Import(FromFriendF, Lang_CXX);
+  Import(FromFriendF, Lang_CXX03);
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   auto *ToClass = FirstDeclMatcher<CXXRecordDecl>().match(
       ToTU, cxxRecordDecl(hasName("X")));
   auto *ToFriend = FirstDeclMatcher<FriendDecl>().match(ToTU, friendDecl());
   auto ToFriends = ToClass->friends();
   FrN = 0;
   for (auto Fr : ToFriends) {
     EXPECT_EQ(Fr, ToFriend);
AST_MATCHER_P(TagDecl, hasTypedefForAnonDecl, Matcher<TypedefNameDecl>,
   return false;
 }
 
 TEST_P(ImportDecl, ImportEnumSequential) {
   CodeFiles Samples{{"main.c",
                      {"void foo();"
                       "void moo();"
                       "int main() { foo(); moo(); }",
-                      Lang_C}},
+                      Lang_C99}},
 
                     {"foo.c",
                      {"typedef enum { THING_VALUE } thing_t;"
                       "void conflict(thing_t type);"
                       "void foo() { (void)THING_VALUE; }"
                       "void conflict(thing_t type) {}",
-                      Lang_C}},
+                      Lang_C99}},
 
                     {"moo.c",
                      {"typedef enum { THING_VALUE } thing_t;"
                       "void conflict(thing_t type);"
                       "void moo() { conflict(THING_VALUE); }",
-                      Lang_C}}};
+                      Lang_C99}}};
 
   auto VerificationMatcher =
       enumDecl(has(enumConstantDecl(hasName("THING_VALUE"))),
                hasTypedefForAnonDecl(hasName("thing_t")));
 
   ImportAction ImportFoo{"foo.c", "main.c", functionDecl(hasName("foo"))},
       ImportMoo{"moo.c", "main.c", functionDecl(hasName("moo"))};
 
auto Code = R"(
       struct A { void f() { } };
       )";
   testNoImportOf(cxxMethodDecl(hasName("f")), Code);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentRecord) {
   Decl *ToR1;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { };", Lang_CXX, "input0.cc");
+    Decl *FromTU = getTuDecl("struct A { };", Lang_CXX03, "input0.cc");
     auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("A")));
 
-    ToR1 = Import(FromR, Lang_CXX);
+    ToR1 = Import(FromR, Lang_CXX03);
   }
 
   Decl *ToR2;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { };", Lang_CXX, "input1.cc");
+    Decl *FromTU = getTuDecl("struct A { };", Lang_CXX03, "input1.cc");
     auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("A")));
 
-    ToR2 = Import(FromR, Lang_CXX);
+    ToR2 = Import(FromR, Lang_CXX03);
   }
 
   EXPECT_EQ(ToR1, ToR2);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentRecord) {
   Decl *ToR1;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { int x; };", Lang_CXX, "input0.cc");
+    Decl *FromTU = getTuDecl("struct A { int x; };", Lang_CXX03, "input0.cc");
     auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("A")));
-    ToR1 = Import(FromR, Lang_CXX);
+    ToR1 = Import(FromR, Lang_CXX03);
   }
   Decl *ToR2;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { unsigned x; };", Lang_CXX, "input1.cc");
+    Decl *FromTU =
+        getTuDecl("struct A { unsigned x; };", Lang_CXX03, "input1.cc");
     auto *FromR = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("A")));
-    ToR2 = Import(FromR, Lang_CXX);
+    ToR2 = Import(FromR, Lang_CXX03);
   }
   EXPECT_NE(ToR1, ToR2);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentField) {
   Decl *ToF1;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { int x; };", Lang_CXX, "input0.cc");
+    Decl *FromTU = getTuDecl("struct A { int x; };", Lang_CXX03, "input0.cc");
     auto *FromF = FirstDeclMatcher<FieldDecl>().match(
         FromTU, fieldDecl(hasName("x")));
-    ToF1 = Import(FromF, Lang_CXX);
+    ToF1 = Import(FromF, Lang_CXX03);
   }
   Decl *ToF2;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { int x; };", Lang_CXX, "input1.cc");
+    Decl *FromTU = getTuDecl("struct A { int x; };", Lang_CXX03, "input1.cc");
     auto *FromF = FirstDeclMatcher<FieldDecl>().match(
         FromTU, fieldDecl(hasName("x")));
-    ToF2 = Import(FromF, Lang_CXX);
+    ToF2 = Import(FromF, Lang_CXX03);
   }
   EXPECT_EQ(ToF1, ToF2);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentField) {
   Decl *ToF1;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { int x; };", Lang_CXX, "input0.cc");
+    Decl *FromTU = getTuDecl("struct A { int x; };", Lang_CXX03, "input0.cc");
     auto *FromF = FirstDeclMatcher<FieldDecl>().match(
         FromTU, fieldDecl(hasName("x")));
-    ToF1 = Import(FromF, Lang_CXX);
+    ToF1 = Import(FromF, Lang_CXX03);
   }
   Decl *ToF2;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { unsigned x; };", Lang_CXX, "input1.cc");
+    Decl *FromTU =
+        getTuDecl("struct A { unsigned x; };", Lang_CXX03, "input1.cc");
     auto *FromF = FirstDeclMatcher<FieldDecl>().match(
         FromTU, fieldDecl(hasName("x")));
-    ToF2 = Import(FromF, Lang_CXX);
+    ToF2 = Import(FromF, Lang_CXX03);
   }
   EXPECT_NE(ToF1, ToF2);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportOfEquivalentMethod) {
   Decl *ToM1;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { void x(); }; void A::x() { }", Lang_CXX, "input0.cc");
+    Decl *FromTU = getTuDecl("struct A { void x(); }; void A::x() { }",
+                             Lang_CXX03, "input0.cc");
     auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("x"), isDefinition()));
-    ToM1 = Import(FromM, Lang_CXX);
+    ToM1 = Import(FromM, Lang_CXX03);
   }
   Decl *ToM2;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { void x(); }; void A::x() { }", Lang_CXX, "input1.cc");
+    Decl *FromTU = getTuDecl("struct A { void x(); }; void A::x() { }",
+                             Lang_CXX03, "input1.cc");
     auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("x"), isDefinition()));
-    ToM2 = Import(FromM, Lang_CXX);
+    ToM2 = Import(FromM, Lang_CXX03);
   }
   EXPECT_EQ(ToM1, ToM2);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportOfNonEquivalentMethod) {
   Decl *ToM1;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { void x(); }; void A::x() { }",
-        Lang_CXX, "input0.cc");
+    Decl *FromTU = getTuDecl("struct A { void x(); }; void A::x() { }",
+                             Lang_CXX03, "input0.cc");
     auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("x"), isDefinition()));
-    ToM1 = Import(FromM, Lang_CXX);
+    ToM1 = Import(FromM, Lang_CXX03);
   }
   Decl *ToM2;
   {
-    Decl *FromTU = getTuDecl(
-        "struct A { void x() const; }; void A::x() const { }",
-        Lang_CXX, "input1.cc");
+    Decl *FromTU =
+        getTuDecl("struct A { void x() const; }; void A::x() const { }",
+                  Lang_CXX03, "input1.cc");
     auto *FromM = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("x"), isDefinition()));
-    ToM2 = Import(FromM, Lang_CXX);
+    ToM2 = Import(FromM, Lang_CXX03);
   }
   EXPECT_NE(ToM1, ToM2);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase,
        ImportUnnamedStructsWithRecursingField) {
   Decl *FromTU = getTuDecl(
       R"(
       struct A {
         struct {
           struct A *next;
         } entry0;
         struct {
           struct A *next;
         } entry1;
       };
       )",
-      Lang_C, "input0.cc");
+      Lang_C99, "input0.cc");
   auto *From =
       FirstDeclMatcher<RecordDecl>().match(FromTU, recordDecl(hasName("A")));
 
-  Import(From, Lang_C);
+  Import(From, Lang_C99);
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   auto *Entry0 =
       FirstDeclMatcher<FieldDecl>().match(ToTU, fieldDecl(hasName("entry0")));
   auto *Entry1 =
       FirstDeclMatcher<FieldDecl>().match(ToTU, fieldDecl(hasName("entry1")));
   auto *R0 = getRecordDecl(Entry0);
   auto *R1 = getRecordDecl(Entry1);

 
 TEST_P(ImportVariables, ImportOfOneDeclBringsInTheWholeChain) {
   Decl *FromTU = getTuDecl(
       R"(
       struct A {
         static const int a = 1 + 2;
       };
       const int A::a;
-      )", Lang_CXX, "input1.cc");
+      )",
+      Lang_CXX03, "input1.cc");
 
   auto *FromDWithInit = FirstDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a"))); // Decl with init
   auto *FromDWithDef = LastDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a"))); // Decl with definition
   ASSERT_NE(FromDWithInit, FromDWithDef);
   ASSERT_EQ(FromDWithDef->getPreviousDecl(), FromDWithInit);
 
   auto *ToD0 = cast<VarDecl>(Import(FromDWithInit, Lang_CXX11));
   auto *ToD1 = cast<VarDecl>(Import(FromDWithDef, Lang_CXX11));
   ASSERT_TRUE(ToD0);
   ASSERT_TRUE(ToD1);
   EXPECT_NE(ToD0, ToD1);
   EXPECT_EQ(ToD1->getPreviousDecl(), ToD0);
 }
 
 TEST_P(ImportVariables, InitAndDefinitionAreInDifferentTUs) {
   auto StructA =
       R"(
       struct A {
         static const int a = 1 + 2;
       };
       )";
-  Decl *ToTU = getToTuDecl(StructA, Lang_CXX);
-  Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a;", Lang_CXX,
+  Decl *ToTU = getToTuDecl(StructA, Lang_CXX03);
+  Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a;", Lang_CXX03,
                            "input1.cc");
 
   auto *FromDWithInit = FirstDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a"))); // Decl with init
   auto *FromDWithDef = LastDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a"))); // Decl with definition
   ASSERT_EQ(FromDWithInit, FromDWithDef->getPreviousDecl());
   ASSERT_TRUE(FromDWithInit->getInit());

 
 TEST_P(ImportVariables, InitAndDefinitionAreInTheFromContext) {
   auto StructA =
       R"(
       struct A {
         static const int a;
       };
       )";
-  Decl *ToTU = getToTuDecl(StructA, Lang_CXX);
+  Decl *ToTU = getToTuDecl(StructA, Lang_CXX03);
   Decl *FromTU = getTuDecl(std::string(StructA) + "const int A::a = 1 + 2;",
-                           Lang_CXX, "input1.cc");
+                           Lang_CXX03, "input1.cc");
 
   auto *FromDDeclarationOnly = FirstDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a")));
   auto *FromDWithDef = LastDeclMatcher<VarDecl>().match(
       FromTU, varDecl(hasName("a"))); // Decl with definition and with init.
   ASSERT_EQ(FromDDeclarationOnly, FromDWithDef->getPreviousDecl());
   ASSERT_FALSE(FromDDeclarationOnly->getInit());
   ASSERT_FALSE(FromDDeclarationOnly->isThisDeclarationADefinition());
   ASSERT_TRUE(FromDWithDef->isThisDeclarationADefinition());
   ASSERT_TRUE(FromDWithDef->getInit());
 
   auto *ToD = FirstDeclMatcher<VarDecl>().match(
       ToTU, varDecl(hasName("a")));
   ASSERT_FALSE(ToD->getInit());
   ASSERT_FALSE(ToD->getDefinition());
 
   auto *ImportedD = cast<VarDecl>(Import(FromDWithDef, Lang_CXX11));
   EXPECT_TRUE(ImportedD->getAnyInitializer());
   EXPECT_TRUE(ImportedD->getDefinition());
 }
 
 struct ImportClasses : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportClasses, ImportDefinitionWhenProtoIsInNestedToContext) {
-  Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_C);
-  Decl *FromTU1 = getTuDecl("struct X {};", Lang_C, "input1.cc");
+  Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_C99);
+  Decl *FromTU1 = getTuDecl("struct X {};", Lang_C99, "input1.cc");
   auto Pattern = recordDecl(hasName("X"), unless(isImplicit()));
   auto ToProto = FirstDeclMatcher<RecordDecl>().match(ToTU, Pattern);
   auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern);
 
-  Decl *ImportedDef = Import(FromDef, Lang_C);
+  Decl *ImportedDef = Import(FromDef, Lang_C99);
 
   EXPECT_NE(ImportedDef, ToProto);
   EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
   auto ToDef = LastDeclMatcher<RecordDecl>().match(ToTU, Pattern);
   EXPECT_TRUE(ImportedDef == ToDef);
   EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
   EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
   EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
 }
 
 TEST_P(ImportClasses, ImportDefinitionWhenProtoIsInNestedToContextCXX) {
-  Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_CXX);
-  Decl *FromTU1 = getTuDecl("struct X {};", Lang_CXX, "input1.cc");
+  Decl *ToTU = getToTuDecl("struct A { struct X *Xp; };", Lang_CXX03);
+  Decl *FromTU1 = getTuDecl("struct X {};", Lang_CXX03, "input1.cc");
   auto Pattern = recordDecl(hasName("X"), unless(isImplicit()));
   auto ToProto = FirstDeclMatcher<RecordDecl>().match(ToTU, Pattern);
   auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern);
 
-  Decl *ImportedDef = Import(FromDef, Lang_CXX);
+  Decl *ImportedDef = Import(FromDef, Lang_CXX03);
 
   EXPECT_NE(ImportedDef, ToProto);
   EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
   auto ToDef = LastDeclMatcher<RecordDecl>().match(ToTU, Pattern);
   EXPECT_TRUE(ImportedDef == ToDef);
   EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
   EXPECT_FALSE(ToProto->isThisDeclarationADefinition());
   EXPECT_EQ(ToDef->getPreviousDecl(), ToProto);
 }
 
 TEST_P(ImportClasses, ImportNestedPrototypeThenDefinition) {
-  Decl *FromTU0 = getTuDecl("struct A { struct X *Xp; };", Lang_C, "input0.cc");
-  Decl *FromTU1 = getTuDecl("struct X {};", Lang_C, "input1.cc");
+  Decl *FromTU0 =
+      getTuDecl("struct A { struct X *Xp; };", Lang_C99, "input0.cc");
+  Decl *FromTU1 = getTuDecl("struct X {};", Lang_C99, "input1.cc");
   auto Pattern = recordDecl(hasName("X"), unless(isImplicit()));
   auto FromProto = FirstDeclMatcher<RecordDecl>().match(FromTU0, Pattern);
   auto FromDef = FirstDeclMatcher<RecordDecl>().match(FromTU1, Pattern);
 
-  Decl *ImportedProto = Import(FromProto, Lang_C);
-  Decl *ImportedDef = Import(FromDef, Lang_C);
+  Decl *ImportedProto = Import(FromProto, Lang_C99);
+  Decl *ImportedDef = Import(FromDef, Lang_C99);
   Decl *ToTU = ImportedDef->getTranslationUnitDecl();
 
   EXPECT_NE(ImportedDef, ImportedProto);
   EXPECT_EQ(DeclCounter<RecordDecl>().match(ToTU, Pattern), 2u);
   auto ToProto = FirstDeclMatcher<RecordDecl>().match(ToTU, Pattern);
   auto ToDef = LastDeclMatcher<RecordDecl>().match(ToTU, Pattern);
   EXPECT_TRUE(ImportedDef == ToDef);
   EXPECT_TRUE(ImportedProto == ToProto);
Decl *FromTU = getTuDecl(
       R"(
       class A {
         template <int I> class F {};
         class X {
           template <int I> friend class F;
         };
       };
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
 
   auto *FromClass = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("F"), isDefinition()));
   auto *FromFriendClass = LastDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("F")));
 
   ASSERT_TRUE(FromClass);
   ASSERT_TRUE(FromFriendClass);
   ASSERT_NE(FromClass, FromFriendClass);
   ASSERT_EQ(FromFriendClass->getDefinition(), FromClass);
   ASSERT_EQ(FromFriendClass->getPreviousDecl(), FromClass);
   ASSERT_EQ(FromFriendClass->getDescribedClassTemplate()->getPreviousDecl(),
             FromClass->getDescribedClassTemplate());
 
-  auto *ToClass = cast<CXXRecordDecl>(Import(FromClass, Lang_CXX));
-  auto *ToFriendClass = cast<CXXRecordDecl>(Import(FromFriendClass, Lang_CXX));
+  auto *ToClass = cast<CXXRecordDecl>(Import(FromClass, Lang_CXX03));
+  auto *ToFriendClass =
+      cast<CXXRecordDecl>(Import(FromFriendClass, Lang_CXX03));
 
   EXPECT_TRUE(ToClass);
   EXPECT_TRUE(ToFriendClass);
   EXPECT_NE(ToClass, ToFriendClass);
   EXPECT_EQ(ToFriendClass->getDefinition(), ToClass);
   EXPECT_EQ(ToFriendClass->getPreviousDecl(), ToClass);
   EXPECT_EQ(ToFriendClass->getDescribedClassTemplate()->getPreviousDecl(),
             ToClass->getDescribedClassTemplate());
 }
 
 TEST_P(ImportFriendClasses, ImportOfRecursiveFriendClass) {
   Decl *FromTu = getTuDecl(
       R"(
       class declToImport {
         friend class declToImport;
       };
       )",
-      Lang_CXX, "input.cc");
+      Lang_CXX03, "input.cc");
 
   auto *FromD = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTu, cxxRecordDecl(hasName("declToImport")));
-  auto *ToD = Import(FromD, Lang_CXX);
+  auto *ToD = Import(FromD, Lang_CXX03);
   auto Pattern = cxxRecordDecl(has(friendDecl()));
   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromD, Pattern));
   EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToD, Pattern));
 }
 
 TEST_P(ImportFriendClasses, UndeclaredFriendClassShouldNotBeVisible) {
-  Decl *FromTu = getTuDecl("class X { friend class Y; };", Lang_CXX, "from.cc");
+  Decl *FromTu =
+      getTuDecl("class X { friend class Y; };", Lang_CXX03, "from.cc");
   auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTu, cxxRecordDecl(hasName("X")));
   auto *FromFriend = FirstDeclMatcher<FriendDecl>().match(FromTu, friendDecl());
   RecordDecl *FromRecordOfFriend =
       const_cast<RecordDecl *>(getRecordDeclOfFriend(FromFriend));
 
   ASSERT_EQ(FromRecordOfFriend->getDeclContext(), cast<DeclContext>(FromTu));
   ASSERT_EQ(FromRecordOfFriend->getLexicalDeclContext(),
             cast<DeclContext>(FromX));
   ASSERT_FALSE(
       FromRecordOfFriend->getDeclContext()->containsDecl(FromRecordOfFriend));
   ASSERT_FALSE(FromRecordOfFriend->getLexicalDeclContext()->containsDecl(
       FromRecordOfFriend));
   ASSERT_FALSE(FromRecordOfFriend->getLookupParent()
                    ->lookup(FromRecordOfFriend->getDeclName())
                    .empty());
 
-  auto *ToX = Import(FromX, Lang_CXX);
+  auto *ToX = Import(FromX, Lang_CXX03);
   ASSERT_TRUE(ToX);
 
   Decl *ToTu = ToX->getTranslationUnitDecl();
   auto *ToFriend = FirstDeclMatcher<FriendDecl>().match(ToTu, friendDecl());
   RecordDecl *ToRecordOfFriend =
       const_cast<RecordDecl *>(getRecordDeclOfFriend(ToFriend));
 
   ASSERT_EQ(ToRecordOfFriend->getDeclContext(), cast<DeclContext>(ToTu));

 
 TEST_P(ImportFriendClasses, ImportOfRecursiveFriendClassTemplate) {
   Decl *FromTu = getTuDecl(
       R"(
       template<class A> class declToImport {
         template<class A1> friend class declToImport;
       };
       )",
-      Lang_CXX, "input.cc");
+      Lang_CXX03, "input.cc");
 
   auto *FromD =
       FirstDeclMatcher<ClassTemplateDecl>().match(FromTu, classTemplateDecl());
-  auto *ToD = Import(FromD, Lang_CXX);
+  auto *ToD = Import(FromD, Lang_CXX03);
 
   auto Pattern = classTemplateDecl(
       has(cxxRecordDecl(has(friendDecl(has(classTemplateDecl()))))));
   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromD, Pattern));
   EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToD, Pattern));
 
   auto *Class =
       FirstDeclMatcher<ClassTemplateDecl>().match(ToD, classTemplateDecl());
   auto *Friend = FirstDeclMatcher<FriendDecl>().match(ToD, friendDecl());
   EXPECT_NE(Friend->getFriendDecl(), Class);
   EXPECT_EQ(Friend->getFriendDecl()->getPreviousDecl(), Class);
 }
 
 TEST_P(ImportFriendClasses, ProperPrevDeclForClassTemplateDecls) {
   auto Pattern = classTemplateSpecializationDecl(hasName("X"));
 
   ClassTemplateSpecializationDecl *Imported1;
   {
     Decl *FromTU = getTuDecl("template<class T> class X;"
                              "struct Y { friend class X<int>; };",
-                             Lang_CXX, "input0.cc");
+                             Lang_CXX03, "input0.cc");
     auto *FromD = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
         FromTU, Pattern);
 
-    Imported1 = cast<ClassTemplateSpecializationDecl>(Import(FromD, Lang_CXX));
+    Imported1 =
+        cast<ClassTemplateSpecializationDecl>(Import(FromD, Lang_CXX03));
   }
   ClassTemplateSpecializationDecl *Imported2;
   {
     Decl *FromTU = getTuDecl("template<class T> class X;"
                              "template<> class X<int>{};"
                              "struct Z { friend class X<int>; };",
-                             Lang_CXX, "input1.cc");
+                             Lang_CXX03, "input1.cc");
     auto *FromD = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
         FromTU, Pattern);
 
-    Imported2 = cast<ClassTemplateSpecializationDecl>(Import(FromD, Lang_CXX));
+    Imported2 =
+        cast<ClassTemplateSpecializationDecl>(Import(FromD, Lang_CXX03));
   }
 
   Decl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   EXPECT_EQ(DeclCounter<ClassTemplateSpecializationDecl>().match(ToTU, Pattern),
             2u);
   ASSERT_TRUE(Imported2->getPreviousDecl());
   EXPECT_EQ(Imported2->getPreviousDecl(), Imported1);
 }
 
 TEST_P(ImportFriendClasses, TypeForDeclShouldBeSetInTemplated) {
   Decl *FromTU0 = getTuDecl(
       R"(
       class X {
         class Y;
       };
       class X::Y {
         template <typename T>
         friend class F; // The decl context of F is the global namespace.
       };
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
   auto *Fwd = FirstDeclMatcher<ClassTemplateDecl>().match(
       FromTU0, classTemplateDecl(hasName("F")));
-  auto *Imported0 = cast<ClassTemplateDecl>(Import(Fwd, Lang_CXX));
+  auto *Imported0 = cast<ClassTemplateDecl>(Import(Fwd, Lang_CXX03));
   Decl *FromTU1 = getTuDecl(
       R"(
       template <typename T>
       class F {};
       )",
-      Lang_CXX, "input1.cc");
+      Lang_CXX03, "input1.cc");
   auto *Definition = FirstDeclMatcher<ClassTemplateDecl>().match(
       FromTU1, classTemplateDecl(hasName("F")));
-  auto *Imported1 = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX));
+  auto *Imported1 = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX03));
   EXPECT_EQ(Imported0->getTemplatedDecl()->getTypeForDecl(),
             Imported1->getTemplatedDecl()->getTypeForDecl());
 }
 
 TEST_P(ImportFriendClasses, DeclsFromFriendsShouldBeInRedeclChains) {
   Decl *From, *To;
   std::tie(From, To) =
-      getImportedDecl("class declToImport {};", Lang_CXX,
-                      "class Y { friend class declToImport; };", Lang_CXX);
+      getImportedDecl("class declToImport {};", Lang_CXX03,
+                      "class Y { friend class declToImport; };", Lang_CXX03);
   auto *Imported = cast<CXXRecordDecl>(To);
 
   EXPECT_TRUE(Imported->getPreviousDecl());
 }
 
 TEST_P(ImportFriendClasses,
        ImportOfClassTemplateDefinitionShouldConnectToFwdFriend) {
   Decl *ToTU = getToTuDecl(
       R"(
       class X {
         class Y;
       };
       class X::Y {
         template <typename T>
         friend class F; // The decl context of F is the global namespace.
       };
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *ToDecl = FirstDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("F")));
   Decl *FromTU = getTuDecl(
       R"(
       template <typename T>
       class F {};
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
   auto *Definition = FirstDeclMatcher<ClassTemplateDecl>().match(
       FromTU, classTemplateDecl(hasName("F")));
-  auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX));
+  auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX03));
   EXPECT_TRUE(ImportedDef->getPreviousDecl());
   EXPECT_EQ(ToDecl, ImportedDef->getPreviousDecl());
   EXPECT_EQ(ToDecl->getTemplatedDecl(),
             ImportedDef->getTemplatedDecl()->getPreviousDecl());
 }
 
 TEST_P(ImportFriendClasses,
        ImportOfClassTemplateDefinitionAndFwdFriendShouldBeLinked) {
   Decl *FromTU0 = getTuDecl(
       R"(
       class X {
         class Y;
       };
       class X::Y {
         template <typename T>
         friend class F; // The decl context of F is the global namespace.
       };
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
   auto *Fwd = FirstDeclMatcher<ClassTemplateDecl>().match(
       FromTU0, classTemplateDecl(hasName("F")));
-  auto *ImportedFwd = cast<ClassTemplateDecl>(Import(Fwd, Lang_CXX));
+  auto *ImportedFwd = cast<ClassTemplateDecl>(Import(Fwd, Lang_CXX03));
   Decl *FromTU1 = getTuDecl(
       R"(
       template <typename T>
       class F {};
       )",
-      Lang_CXX, "input1.cc");
+      Lang_CXX03, "input1.cc");
   auto *Definition = FirstDeclMatcher<ClassTemplateDecl>().match(
       FromTU1, classTemplateDecl(hasName("F")));
-  auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX));
+  auto *ImportedDef = cast<ClassTemplateDecl>(Import(Definition, Lang_CXX03));
   EXPECT_TRUE(ImportedDef->getPreviousDecl());
   EXPECT_EQ(ImportedFwd, ImportedDef->getPreviousDecl());
   EXPECT_EQ(ImportedFwd->getTemplatedDecl(),
             ImportedDef->getTemplatedDecl()->getPreviousDecl());
 }
 
 TEST_P(ImportFriendClasses, ImportOfClassDefinitionAndFwdFriendShouldBeLinked) {
   Decl *FromTU0 = getTuDecl(
       R"(
       class X {
         class Y;
       };
       class X::Y {
         friend class F; // The decl context of F is the global namespace.
       };
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
   auto *Friend = FirstDeclMatcher<FriendDecl>().match(FromTU0, friendDecl());
   QualType FT = Friend->getFriendType()->getType();
   FT = FromTU0->getASTContext().getCanonicalType(FT);
   auto *Fwd = cast<TagType>(FT)->getDecl();
-  auto *ImportedFwd = Import(Fwd, Lang_CXX);
+  auto *ImportedFwd = Import(Fwd, Lang_CXX03);
   Decl *FromTU1 = getTuDecl(
       R"(
       class F {};
       )",
-      Lang_CXX, "input1.cc");
+      Lang_CXX03, "input1.cc");
   auto *Definition = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU1, cxxRecordDecl(hasName("F")));
-  auto *ImportedDef = Import(Definition, Lang_CXX);
+  auto *ImportedDef = Import(Definition, Lang_CXX03);
   EXPECT_TRUE(ImportedDef->getPreviousDecl());
   EXPECT_EQ(ImportedFwd, ImportedDef->getPreviousDecl());
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, FriendFunInClassTemplate) {
   auto *Code = R"(
   template <class T>
   struct X {
     friend void foo(){}
   };
       )";
-  TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX);
+  TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX03);
   auto *ToFoo = FirstDeclMatcher<FunctionDecl>().match(
       ToTU, functionDecl(hasName("foo")));
 
-  TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX, "input.cc");
+  TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX03, "input.cc");
   auto *FromFoo = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("foo")));
-  auto *ImportedFoo = Import(FromFoo, Lang_CXX);
+  auto *ImportedFoo = Import(FromFoo, Lang_CXX03);
   EXPECT_EQ(ImportedFoo, ToFoo);
 }
 
 struct DeclContextTest : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(DeclContextTest, removeDeclOfClassTemplateSpecialization) {
   Decl *TU = getTuDecl(
       R"(
TEST_P(DeclContextTest, removeDeclOfClassTemplateSpecialization) {
   ASSERT_TRUE(NS->containsDecl(Spec));
 
   NS->removeDecl(Spec);
   EXPECT_FALSE(NS->containsDecl(Spec));
 }
 
 TEST_P(DeclContextTest,
        removeDeclShouldNotFailEvenIfWeHaveExternalVisibleStorage) {
-  Decl *TU = getTuDecl("extern int A; int A;", Lang_CXX);
+  Decl *TU = getTuDecl("extern int A; int A;", Lang_CXX03);
   auto *A0 = FirstDeclMatcher<VarDecl>().match(TU, varDecl(hasName("A")));
   auto *A1 = LastDeclMatcher<VarDecl>().match(TU, varDecl(hasName("A")));
 
   // Investigate the list.
   auto *DC = A0->getDeclContext();
   ASSERT_TRUE(DC->containsDecl(A0));
   ASSERT_TRUE(DC->containsDecl(A1));
 
TEST_P(ImportFunctionTemplateSpecializations,
        TUshouldNotContainFunctionTemplateImplicitInstantiation) {
 
   Decl *FromTU = getTuDecl(
       R"(
       template<class T>
       int f() { return 0; }
       void foo() { f<int>(); }
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
 
   // Check that the function template instantiation is NOT the child of the TU.
   auto Pattern = translationUnitDecl(
       unless(has(functionDecl(hasName("f"), isTemplateInstantiation()))));
   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromTU, Pattern));
 
   auto *Foo = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("foo")));
-  ASSERT_TRUE(Import(Foo, Lang_CXX));
+  ASSERT_TRUE(Import(Foo, Lang_CXX03));
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
 }
 
 TEST_P(ImportFunctionTemplateSpecializations,
        TUshouldNotContainFunctionTemplateExplicitInstantiation) {
 
   Decl *FromTU = getTuDecl(
       R"(
       template<class T>
       int f() { return 0; }
       template int f<int>();
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
 
   // Check that the function template instantiation is NOT the child of the TU.
   auto Instantiation = functionDecl(hasName("f"), isTemplateInstantiation());
   auto Pattern = translationUnitDecl(unless(has(Instantiation)));
   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromTU, Pattern));
 
-  ASSERT_TRUE(
-      Import(FirstDeclMatcher<Decl>().match(FromTU, Instantiation), Lang_CXX));
+  ASSERT_TRUE(Import(FirstDeclMatcher<Decl>().match(FromTU, Instantiation),
+                     Lang_CXX03));
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
 }
 
 TEST_P(ImportFunctionTemplateSpecializations,
        TUshouldContainFunctionTemplateSpecialization) {
 
   Decl *FromTU = getTuDecl(
       R"(
       template<class T>
       int f() { return 0; }
       template <> int f<int>() { return 4; }
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
 
   // Check that the function template specialization is the child of the TU.
   auto Specialization =
       functionDecl(hasName("f"), isExplicitTemplateSpecialization());
   auto Pattern = translationUnitDecl(has(Specialization));
   ASSERT_TRUE(MatchVerifier<Decl>{}.match(FromTU, Pattern));
 
-  ASSERT_TRUE(
-      Import(FirstDeclMatcher<Decl>().match(FromTU, Specialization), Lang_CXX));
+  ASSERT_TRUE(Import(FirstDeclMatcher<Decl>().match(FromTU, Specialization),
+                     Lang_CXX03));
 
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   EXPECT_TRUE(MatchVerifier<Decl>{}.match(ToTU, Pattern));
 }
 
 TEST_P(ImportFunctionTemplateSpecializations,
        FunctionTemplateSpecializationRedeclChain) {
 
   Decl *FromTU = getTuDecl(
       R"(
       template<class T>
       int f() { return 0; }
       template <> int f<int>() { return 4; }
       )",
-      Lang_CXX, "input0.cc");
+      Lang_CXX03, "input0.cc");
 
   auto Spec = functionDecl(hasName("f"), isExplicitTemplateSpecialization(),
                            hasParent(translationUnitDecl()));
   auto *FromSpecD = FirstDeclMatcher<Decl>().match(FromTU, Spec);
   {
     auto *TU = FromTU;
     auto *SpecD = FromSpecD;
     auto *TemplateD = FirstDeclMatcher<FunctionTemplateDecl>().match(
         TU, functionTemplateDecl());
     auto *FirstSpecD = *(TemplateD->spec_begin());
     ASSERT_EQ(SpecD, FirstSpecD);
     ASSERT_TRUE(SpecD->getPreviousDecl());
     ASSERT_FALSE(cast<FunctionDecl>(SpecD->getPreviousDecl())
                      ->doesThisDeclarationHaveABody());
   }
 
-  ASSERT_TRUE(Import(FromSpecD, Lang_CXX));
+  ASSERT_TRUE(Import(FromSpecD, Lang_CXX03));
 
   {
     auto *TU = ToAST->getASTContext().getTranslationUnitDecl();
     auto *SpecD = FirstDeclMatcher<Decl>().match(TU, Spec);
     auto *TemplateD = FirstDeclMatcher<FunctionTemplateDecl>().match(
         TU, functionTemplateDecl());
     auto *FirstSpecD = *(TemplateD->spec_begin());
     EXPECT_EQ(SpecD, FirstSpecD);

 TEST_P(ASTImporterOptionSpecificTestBase,
     ImportShouldNotReportFalseODRErrorWhenRecordIsBeingDefined) {
   {
     Decl *FromTU = getTuDecl(
         R"(
             template <typename T>
             struct B;
             )",
-        Lang_CXX, "input0.cc");
+        Lang_CXX03, "input0.cc");
     auto *FromD = FirstDeclMatcher<ClassTemplateDecl>().match(
         FromTU, classTemplateDecl(hasName("B")));
 
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
   }
 
   {
     Decl *FromTU = getTuDecl(
         R"(
             template <typename T>
             struct B {
               void f();
               B* b;
             };
             )",
-        Lang_CXX, "input1.cc");
+        Lang_CXX03, "input1.cc");
     FunctionDecl *FromD = FirstDeclMatcher<FunctionDecl>().match(
         FromTU, functionDecl(hasName("f")));
-    Import(FromD, Lang_CXX);
+    Import(FromD, Lang_CXX03);
     auto *FromCTD = FirstDeclMatcher<ClassTemplateDecl>().match(
         FromTU, classTemplateDecl(hasName("B")));
-    auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX));
+    auto *ToCTD = cast<ClassTemplateDecl>(Import(FromCTD, Lang_CXX03));
     EXPECT_TRUE(ToCTD->isThisDeclarationADefinition());
 
     // We expect no (ODR) warning during the import.
     auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
     EXPECT_EQ(0u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
   }
 }
 

 TEST_P(ASTImporterOptionSpecificTestBase, ImportTemplateParameterLists) {
   auto Code =
       R"(
       template<class T>
       int f() { return 0; }
       template <> int f<int>() { return 4; }
       )";
 
-  Decl *FromTU = getTuDecl(Code, Lang_CXX);
+  Decl *FromTU = getTuDecl(Code, Lang_CXX03);
   auto *FromD = FirstDeclMatcher<FunctionDecl>().match(FromTU,
       functionDecl(hasName("f"), isExplicitTemplateSpecialization()));
   ASSERT_EQ(FromD->getNumTemplateParameterLists(), 1u);
 
-  auto *ToD = Import(FromD, Lang_CXX);
+  auto *ToD = Import(FromD, Lang_CXX03);
   // The template parameter list should exist.
   EXPECT_EQ(ToD->getNumTemplateParameterLists(), 1u);
 }
 
 struct ASTImporterLookupTableTest : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ASTImporterLookupTableTest, OneDecl) {
-  auto *ToTU = getToTuDecl("int a;", Lang_CXX);
+  auto *ToTU = getToTuDecl("int a;", Lang_CXX03);
   auto *D = FirstDeclMatcher<VarDecl>().match(ToTU, varDecl(hasName("a")));
   ASTImporterLookupTable LT(*ToTU);
   auto Res = LT.lookup(ToTU, D->getDeclName());
   ASSERT_EQ(Res.size(), 1u);
   EXPECT_EQ(*Res.begin(), D);
 }
 
 static Decl *findInDeclListOfDC(DeclContext *DC, DeclarationName Name) {
   for (Decl *D : DC->decls()) {
     if (auto *ND = dyn_cast<NamedDecl>(D))
       if (ND->getDeclName() == Name)
         return ND;
   }
   return nullptr;
 }
 
 TEST_P(ASTImporterLookupTableTest,
     FriendWhichIsnotFoundByNormalLookupShouldBeFoundByImporterSpecificLookup) {
   auto *Code = R"(
   template <class T>
   struct X {
     friend void foo(){}
   };
       )";
-  TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX);
+  TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX03);
   auto *X = FirstDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("X")));
   auto *Foo = FirstDeclMatcher<FunctionDecl>().match(
       ToTU, functionDecl(hasName("foo")));
   DeclContext *FooDC = Foo->getDeclContext();
   DeclContext *FooLexicalDC = Foo->getLexicalDeclContext();
   ASSERT_EQ(cast<Decl>(FooLexicalDC), X->getTemplatedDecl());
   ASSERT_EQ(cast<Decl>(FooDC), ToTU);
TEST_P(ASTImporterLookupTableTest,
   auto Res = LT.lookup(FooDC, Foo->getDeclName());
   ASSERT_EQ(Res.size(), 1u);
   EXPECT_EQ(*Res.begin(), Foo);
 }
 
 TEST_P(ASTImporterLookupTableTest,
        FwdDeclStructShouldBeFoundByImporterSpecificLookup) {
   TranslationUnitDecl *ToTU =
-      getToTuDecl("struct A { struct Foo *p; };", Lang_C);
+      getToTuDecl("struct A { struct Foo *p; };", Lang_C99);
   auto *Foo =
       FirstDeclMatcher<RecordDecl>().match(ToTU, recordDecl(hasName("Foo")));
   auto *A =
       FirstDeclMatcher<RecordDecl>().match(ToTU, recordDecl(hasName("A")));
   DeclContext *FooDC = Foo->getDeclContext();
   DeclContext *FooLexicalDC = Foo->getLexicalDeclContext();
   ASSERT_EQ(cast<Decl>(FooLexicalDC), A);
   ASSERT_EQ(cast<Decl>(FooDC), ToTU);
TEST_P(ASTImporterLookupTableTest,
   ASTImporterLookupTable LT(*ToTU);
   auto Res = LT.lookup(FooDC, Foo->getDeclName());
   ASSERT_EQ(Res.size(), 1u);
   EXPECT_EQ(*Res.begin(), Foo);
 }
 
 TEST_P(ASTImporterLookupTableTest, LookupFindsNamesInDifferentDC) {
   TranslationUnitDecl *ToTU =
-      getToTuDecl("int V; struct A { int V; }; struct B { int V; };", Lang_C);
+      getToTuDecl("int V; struct A { int V; }; struct B { int V; };", Lang_C99);
   DeclarationName VName = FirstDeclMatcher<VarDecl>()
                               .match(ToTU, varDecl(hasName("V")))
                               ->getDeclName();
   auto *A =
       FirstDeclMatcher<RecordDecl>().match(ToTU, recordDecl(hasName("A")));
   auto *B =
       FirstDeclMatcher<RecordDecl>().match(ToTU, recordDecl(hasName("B")));
 

 
 TEST_P(ASTImporterLookupTableTest, LookupFindsOverloadedNames) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       void foo();
       void foo(int);
       void foo(int, int);
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *F0 = FirstDeclMatcher<FunctionDecl>().match(ToTU, functionDecl());
   auto *F2 = LastDeclMatcher<FunctionDecl>().match(ToTU, functionDecl());
   DeclarationName Name = F0->getDeclName();
   auto Res = LT.lookup(ToTU, Name);
   EXPECT_EQ(Res.size(), 3u);
   EXPECT_EQ(Res.count(F0), 1u);
   EXPECT_EQ(Res.count(F2), 1u);
 }
 
 TEST_P(ASTImporterLookupTableTest,
        DifferentOperatorsShouldHaveDifferentResultSet) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       struct X{};
       void operator+(X, X);
       void operator-(X, X);
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *FPlus = FirstDeclMatcher<FunctionDecl>().match(
       ToTU, functionDecl(hasOverloadedOperatorName("+")));
   auto *FMinus = FirstDeclMatcher<FunctionDecl>().match(
       ToTU, functionDecl(hasOverloadedOperatorName("-")));
   DeclarationName NamePlus = FPlus->getDeclName();
   auto ResPlus = LT.lookup(ToTU, NamePlus);

 }
 
 TEST_P(ASTImporterLookupTableTest, LookupDeclNamesFromDifferentTUs) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       struct X {};
       void operator+(X, X);
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *ToPlus = FirstDeclMatcher<FunctionDecl>().match(
       ToTU, functionDecl(hasOverloadedOperatorName("+")));
 
   Decl *FromTU = getTuDecl(
       R"(
       struct X {};
       void operator+(X, X);
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *FromPlus = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasOverloadedOperatorName("+")));
 
   // FromPlus have a different TU, thus its DeclarationName is different too.
   ASSERT_NE(ToPlus->getDeclName(), FromPlus->getDeclName());
 
   ASTImporterLookupTable LT(*ToTU);
   auto Res = LT.lookup(ToTU, ToPlus->getDeclName());
   ASSERT_EQ(Res.size(), 1u);
   EXPECT_EQ(*Res.begin(), ToPlus);
 
   // FromPlus have a different TU, thus its DeclarationName is different too.
   Res = LT.lookup(ToTU, FromPlus->getDeclName());
   ASSERT_EQ(Res.size(), 0u);
 }
 
 TEST_P(ASTImporterLookupTableTest,
        LookupFindsFwdFriendClassDeclWithElaboratedType) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       class Y { friend class F; };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   // In this case, the CXXRecordDecl is hidden, the FriendDecl is not a parent.
   // So we must dig up the underlying CXXRecordDecl.
   ASTImporterLookupTable LT(*ToTU);
   auto *FriendD = FirstDeclMatcher<FriendDecl>().match(ToTU, friendDecl());
   const RecordDecl *RD = getRecordDeclOfFriend(FriendD);
   auto *Y = FirstDeclMatcher<CXXRecordDecl>().match(
       ToTU, cxxRecordDecl(hasName("Y")));
TEST_P(ASTImporterLookupTableTest,
   EXPECT_EQ(Res.count(Alias), 1u);
 }
 
 TEST_P(ASTImporterLookupTableTest, LookupFindsFwdFriendClassTemplateDecl) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       class Y { template <class T> friend class F; };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *F = FirstDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("F")));
   DeclarationName Name = F->getDeclName();
   auto Res = LT.lookup(ToTU, Name);
   EXPECT_EQ(Res.size(), 2u);
   EXPECT_EQ(Res.count(F), 1u);
   EXPECT_EQ(Res.count(F->getTemplatedDecl()), 1u);
 }
 
 TEST_P(ASTImporterLookupTableTest, DependentFriendClass) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       template <typename T>
       class F;
 
       template <typename T>
       class Y {
         friend class F<T>;
       };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *F = FirstDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("F")));
   DeclarationName Name = F->getDeclName();
   auto Res = LT.lookup(ToTU, Name);
   EXPECT_EQ(Res.size(), 2u);
   EXPECT_EQ(Res.count(F), 1u);
   EXPECT_EQ(Res.count(F->getTemplatedDecl()), 1u);
 }
 
 TEST_P(ASTImporterLookupTableTest, FriendClassTemplateSpecialization) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       template <typename T>
       class F;
 
       class Y {
         friend class F<int>;
       };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *F = FirstDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("F")));
   DeclarationName Name = F->getDeclName();
   auto Res = LT.lookup(ToTU, Name);
   ASSERT_EQ(Res.size(), 3u);
   EXPECT_EQ(Res.count(F), 1u);
   EXPECT_EQ(Res.count(F->getTemplatedDecl()), 1u);
   EXPECT_EQ(Res.count(*F->spec_begin()), 1u);
 }
 
 TEST_P(ASTImporterLookupTableTest, LookupFindsFwdFriendFunctionDecl) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       class Y { friend void F(); };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *F =
       FirstDeclMatcher<FunctionDecl>().match(ToTU, functionDecl(hasName("F")));
   DeclarationName Name = F->getDeclName();
   auto Res = LT.lookup(ToTU, Name);
   EXPECT_EQ(Res.size(), 1u);
   EXPECT_EQ(*Res.begin(), F);
 }
 
 TEST_P(ASTImporterLookupTableTest,
        LookupFindsDeclsInClassTemplateSpecialization) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       template <typename T>
       struct X {
         int F;
       };
       void foo() {
         X<char> xc;
       }
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
 
   auto *Template = FirstDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("X")));
   auto *FieldInTemplate = FirstDeclMatcher<FieldDecl>().match(
       ToTU,
       fieldDecl(hasParent(cxxRecordDecl(hasParent(classTemplateDecl())))));
TEST_P(ASTImporterLookupTableTest,
   EXPECT_EQ(*Res.begin(), FieldInSpec);
 }
 
 TEST_P(ASTImporterLookupTableTest, LookupFindsFwdFriendFunctionTemplateDecl) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       class Y { template <class T> friend void F(); };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *F = FirstDeclMatcher<FunctionTemplateDecl>().match(
       ToTU, functionTemplateDecl(hasName("F")));
   DeclarationName Name = F->getDeclName();
   auto Res = LT.lookup(ToTU, Name);
   EXPECT_EQ(Res.size(), 2u);
   EXPECT_EQ(Res.count(F), 1u);
   EXPECT_EQ(Res.count(F->getTemplatedDecl()), 1u);
 }
 
 TEST_P(ASTImporterLookupTableTest, MultipleBefriendingClasses) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       struct X;
       struct A {
         friend struct X;
       };
       struct B {
         friend struct X;
       };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *X = FirstDeclMatcher<CXXRecordDecl>().match(
       ToTU, cxxRecordDecl(hasName("X")));
   auto *FriendD0 = FirstDeclMatcher<FriendDecl>().match(ToTU, friendDecl());
   auto *FriendD1 = LastDeclMatcher<FriendDecl>().match(ToTU, friendDecl());
   const RecordDecl *RD0 = getRecordDeclOfFriend(FriendD0);
   const RecordDecl *RD1 = getRecordDeclOfFriend(FriendD1);

 TEST_P(ASTImporterLookupTableTest, EnumConstantDecl) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       enum E {
         A,
         B
       };
       )",
-      Lang_C);
+      Lang_C99);
 
   ASTImporterLookupTable LT(*ToTU);
   auto *E = FirstDeclMatcher<EnumDecl>().match(ToTU, enumDecl(hasName("E")));
   auto *A = FirstDeclMatcher<EnumConstantDecl>().match(
       ToTU, enumConstantDecl(hasName("A")));
 
   DeclarationName Name = A->getDeclName();
   // Redecl context is the TU.
TEST_P(ASTImporterLookupTableTest, LookupSearchesInTheWholeRedeclChain) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       namespace N {
         int A;
       }
       namespace N {
       }
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *N1 =
       LastDeclMatcher<NamespaceDecl>().match(ToTU, namespaceDecl(hasName("N")));
   auto *A = FirstDeclMatcher<VarDecl>().match(ToTU, varDecl(hasName("A")));
   DeclarationName Name = A->getDeclName();
 
   ASTImporterLookupTable LT(*ToTU);
   auto Res = LT.lookup(N1, Name);
   ASSERT_EQ(Res.size(), 1u);
Decl *FromTU = getTuDecl(
       }
       namespace NS {
         struct X {  // <--- To be imported
           void method(int i = Y::I) {}
           int f;
         };
       }
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *FromFwd = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("X"), unless(isImplicit())));
   auto *FromDef = LastDeclMatcher<CXXRecordDecl>().match(
       FromTU,
       cxxRecordDecl(hasName("X"), isDefinition(), unless(isImplicit())));
   ASSERT_NE(FromFwd, FromDef);
   ASSERT_FALSE(FromFwd->isThisDeclarationADefinition());
   ASSERT_TRUE(FromDef->isThisDeclarationADefinition());
   ASSERT_EQ(FromFwd->getCanonicalDecl(), FromDef->getCanonicalDecl());
 
-  auto *ToDef = cast_or_null<CXXRecordDecl>(Import(FromDef, Lang_CXX));
-  auto *ToFwd = cast_or_null<CXXRecordDecl>(Import(FromFwd, Lang_CXX));
+  auto *ToDef = cast_or_null<CXXRecordDecl>(Import(FromDef, Lang_CXX03));
+  auto *ToFwd = cast_or_null<CXXRecordDecl>(Import(FromFwd, Lang_CXX03));
   EXPECT_NE(ToFwd, ToDef);
   EXPECT_FALSE(ToFwd->isThisDeclarationADefinition());
   EXPECT_TRUE(ToDef->isThisDeclarationADefinition());
   EXPECT_EQ(ToFwd->getCanonicalDecl(), ToDef->getCanonicalDecl());
   auto *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // We expect no (ODR) warning during the import.
   EXPECT_EQ(0u, ToTU->getASTContext().getDiagnostics().getNumWarnings());
 }
 
 struct ImportFriendFunctionTemplates : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(ImportFriendFunctionTemplates, LookupShouldFindPreviousFriend) {
   Decl *ToTU = getToTuDecl(
       R"(
       class X {
         template <typename T> friend void foo();
       };
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *Friend = FirstDeclMatcher<FunctionTemplateDecl>().match(
       ToTU, functionTemplateDecl(hasName("foo")));
 
   Decl *FromTU = getTuDecl(
       R"(
       template <typename T> void foo();
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *FromFoo = FirstDeclMatcher<FunctionTemplateDecl>().match(
       FromTU, functionTemplateDecl(hasName("foo")));
-  auto *Imported = Import(FromFoo, Lang_CXX);
+  auto *Imported = Import(FromFoo, Lang_CXX03);
 
   EXPECT_EQ(Imported->getPreviousDecl(), Friend);
 }
 
 struct ASTImporterWithFakeErrors : ASTImporter {
   using ASTImporter::ASTImporter;
   bool returnWithErrorInTest() override { return true; }
 };

 TEST_P(ErrorHandlingTest, ErrorHappensBeforeCreatingANewNode) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       template <typename T>
       class X {};
       template <>
       class X<int> { int a; };
       )",
-      Lang_CXX);
+      Lang_CXX03);
   TranslationUnitDecl *FromTU = getTuDecl(
       R"(
       template <typename T>
       class X {};
       template <>
       class X<int> { double b; };
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *FromSpec = FirstDeclMatcher<ClassTemplateSpecializationDecl>().match(
       FromTU, classTemplateSpecializationDecl(hasName("X")));
-  ClassTemplateSpecializationDecl *ImportedSpec = Import(FromSpec, Lang_CXX);
+  ClassTemplateSpecializationDecl *ImportedSpec = Import(FromSpec, Lang_CXX03);
   EXPECT_FALSE(ImportedSpec);
 
   // The original Decl is kept, no new decl is created.
   EXPECT_EQ(DeclCounter<ClassTemplateSpecializationDecl>().match(
                 ToTU, classTemplateSpecializationDecl(hasName("X"))),
             1u);
 
   // But an error is set to the counterpart in the "from" context.
   ASTImporter *Importer = findFromTU(FromSpec)->Importer.get();
   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromSpec);
   ASSERT_TRUE(OptErr);
   EXPECT_EQ(OptErr->Error, ImportError::NameConflict);
 }
 
 // Check a case when a new AST node is created but not linked to the AST before
 // encountering the error.
 TEST_P(ErrorHandlingTest,
        ErrorHappensAfterCreatingTheNodeButBeforeLinkingThatToTheAST) {
   TranslationUnitDecl *FromTU = getTuDecl(
-      std::string("void foo() { ") + ErroneousStmt + " }",
-      Lang_CXX);
+      std::string("void foo() { ") + ErroneousStmt + " }", Lang_CXX03);
   auto *FromFoo = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("foo")));
 
-  FunctionDecl *ImportedFoo = Import(FromFoo, Lang_CXX);
+  FunctionDecl *ImportedFoo = Import(FromFoo, Lang_CXX03);
   EXPECT_FALSE(ImportedFoo);
 
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // Created, but not linked.
   EXPECT_EQ(
       DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("foo"))),
       0u);
 
   ASTImporter *Importer = findFromTU(FromFoo)->Importer.get();
   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromFoo);
   ASSERT_TRUE(OptErr);
   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 }
 
 // Check a case when a new AST node is created and linked to the AST before
 // encountering the error. The error is set for the counterpart of the nodes in
 // the "from" context.
 TEST_P(ErrorHandlingTest, ErrorHappensAfterNodeIsCreatedAndLinked) {
-  TranslationUnitDecl *FromTU = getTuDecl(
-      std::string(R"(
+  TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
       void f();
       void f() { )") + ErroneousStmt + R"( }
       )",
-    Lang_CXX);
+                                          Lang_CXX03);
   auto *FromProto = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("f")));
   auto *FromDef =
       LastDeclMatcher<FunctionDecl>().match(FromTU, functionDecl(hasName("f")));
-  FunctionDecl *ImportedProto = Import(FromProto, Lang_CXX);
+  FunctionDecl *ImportedProto = Import(FromProto, Lang_CXX03);
   EXPECT_FALSE(ImportedProto); // Could not import.
   // However, we created two nodes in the AST. 1) the fwd decl 2) the
   // definition. The definition is not added to its DC, but the fwd decl is
   // there.
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   EXPECT_EQ(DeclCounter<FunctionDecl>().match(ToTU, functionDecl(hasName("f"))),
             1u);
   // Match the fwd decl.
   auto *ToProto =
       FirstDeclMatcher<FunctionDecl>().match(ToTU, functionDecl(hasName("f")));
   EXPECT_TRUE(ToProto);
   // An error is set to the counterpart in the "from" context both for the fwd
   // decl and the definition.
   ASTImporter *Importer = findFromTU(FromProto)->Importer.get();
   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromProto);
   ASSERT_TRUE(OptErr);
   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
   OptErr = Importer->getImportDeclErrorIfAny(FromDef);
   ASSERT_TRUE(OptErr);
   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 }
 
 // An error should be set for a class if we cannot import one member.
 TEST_P(ErrorHandlingTest, ErrorIsPropagatedFromMemberToClass) {
-  TranslationUnitDecl *FromTU = getTuDecl(
-      std::string(R"(
+  TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
       class X {
         void f() { )") + ErroneousStmt + R"( } // This member has the error
                                                // during import.
         void ok();        // The error should not prevent importing this.
       };                  // An error will be set for X too.
       )",
-      Lang_CXX);
+                                          Lang_CXX03);
   auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("X")));
-  CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX);
+  CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX03);
 
   // An error is set for X.
   EXPECT_FALSE(ImportedX);
   ASTImporter *Importer = findFromTU(FromX)->Importer.get();
   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
   ASSERT_TRUE(OptErr);
   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
 
   // An error is set for f().
   auto *FromF = FirstDeclMatcher<CXXMethodDecl>().match(
       FromTU, cxxMethodDecl(hasName("f")));
   OptErr = Importer->getImportDeclErrorIfAny(FromF);
   ASSERT_TRUE(OptErr);
   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
   // And any subsequent import should fail.
-  CXXMethodDecl *ImportedF = Import(FromF, Lang_CXX);
+  CXXMethodDecl *ImportedF = Import(FromF, Lang_CXX03);
   EXPECT_FALSE(ImportedF);
 
   // There is an error set for the other member too.
   auto *FromOK = FirstDeclMatcher<CXXMethodDecl>().match(
       FromTU, cxxMethodDecl(hasName("ok")));
   OptErr = Importer->getImportDeclErrorIfAny(FromOK);
   EXPECT_TRUE(OptErr);
   // Cannot import the other member.
-  CXXMethodDecl *ImportedOK = Import(FromOK, Lang_CXX);
+  CXXMethodDecl *ImportedOK = Import(FromOK, Lang_CXX03);
   EXPECT_FALSE(ImportedOK);
 }
 
 // Check that an error propagates to the dependent AST nodes.
 // In the below code it means that an error in X should propagate to A.
 // And even to F since the containing A is erroneous.
 // And to all AST nodes which we visit during the import process which finally
 // ends up in a failure (in the error() function).
 TEST_P(ErrorHandlingTest, ErrorPropagatesThroughImportCycles) {
-  Decl *FromTU = getTuDecl(
-      std::string(R"(
+  Decl *FromTU = getTuDecl(std::string(R"(
       namespace NS {
         class A {
           template <int I> class F {};
           class X {
             template <int I> friend class F;
-            void error() { )") + ErroneousStmt + R"( }
+            void error() { )") +
+                               ErroneousStmt + R"( }
           };
         };
 
         class B {};
       } // NS
       )",
-      Lang_CXX, "input0.cc");
+                           Lang_CXX03, "input0.cc");
 
   auto *FromFRD = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("F"), isDefinition()));
   auto *FromA = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("A"), isDefinition()));
   auto *FromB = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("B"), isDefinition()));
   auto *FromNS = FirstDeclMatcher<NamespaceDecl>().match(
       FromTU, namespaceDecl(hasName("NS")));
 
   // Start by importing the templated CXXRecordDecl of F.
   // Import fails for that.
-  EXPECT_FALSE(Import(FromFRD, Lang_CXX));
+  EXPECT_FALSE(Import(FromFRD, Lang_CXX03));
   // Import fails for A.
-  EXPECT_FALSE(Import(FromA, Lang_CXX));
+  EXPECT_FALSE(Import(FromA, Lang_CXX03));
   // But we should be able to import the independent B.
-  EXPECT_TRUE(Import(FromB, Lang_CXX));
+  EXPECT_TRUE(Import(FromB, Lang_CXX03));
   // And the namespace.
-  EXPECT_TRUE(Import(FromNS, Lang_CXX));
+  EXPECT_TRUE(Import(FromNS, Lang_CXX03));
 
   // An error is set to the templated CXXRecordDecl of F.
   ASTImporter *Importer = findFromTU(FromFRD)->Importer.get();
   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromFRD);
   EXPECT_TRUE(OptErr);
 
   // An error is set to A.
   OptErr = Importer->getImportDeclErrorIfAny(FromA);
TEST_P(ErrorHandlingTest, ErrorPropagatesThroughImportCycles) {
   // An error is set to the implicit class of X.
   OptErr =
       Importer->getImportDeclErrorIfAny(FirstDeclMatcher<CXXRecordDecl>().match(
           FromTU, cxxRecordDecl(hasName("X"), isImplicit())));
   EXPECT_TRUE(OptErr);
 }
 
 TEST_P(ErrorHandlingTest, ErrorIsNotPropagatedFromMemberToNamespace) {
-  TranslationUnitDecl *FromTU = getTuDecl(
-      std::string(R"(
+  TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
       namespace X {
         void f() { )") + ErroneousStmt + R"( } // This member has the error
                                                // during import.
         void ok();        // The error should not prevent importing this.
       };                  // An error will be set for X too.
       )",
-      Lang_CXX);
+                                          Lang_CXX03);
   auto *FromX = FirstDeclMatcher<NamespaceDecl>().match(
       FromTU, namespaceDecl(hasName("X")));
-  NamespaceDecl *ImportedX = Import(FromX, Lang_CXX);
+  NamespaceDecl *ImportedX = Import(FromX, Lang_CXX03);
 
   // There is no error set for X.
   EXPECT_TRUE(ImportedX);
   ASTImporter *Importer = findFromTU(FromX)->Importer.get();
   Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
   ASSERT_FALSE(OptErr);
 
   // An error is set for f().
   auto *FromF = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("f")));
   OptErr = Importer->getImportDeclErrorIfAny(FromF);
   ASSERT_TRUE(OptErr);
   EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
   // And any subsequent import should fail.
-  FunctionDecl *ImportedF = Import(FromF, Lang_CXX);
+  FunctionDecl *ImportedF = Import(FromF, Lang_CXX03);
   EXPECT_FALSE(ImportedF);
 
   // There is no error set for ok().
   auto *FromOK = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("ok")));
   OptErr = Importer->getImportDeclErrorIfAny(FromOK);
   EXPECT_FALSE(OptErr);
   // And we should be able to import.
-  FunctionDecl *ImportedOK = Import(FromOK, Lang_CXX);
+  FunctionDecl *ImportedOK = Import(FromOK, Lang_CXX03);
   EXPECT_TRUE(ImportedOK);
 }
 
 // An error should be set for a class if it had a previous import with an error
 // from another TU.
 TEST_P(ErrorHandlingTest,
        ImportedDeclWithErrorShouldFailTheImportOfDeclWhichMapToIt) {
   // We already have a fwd decl.
-  TranslationUnitDecl *ToTU = getToTuDecl(
-      "class X;", Lang_CXX);
+  TranslationUnitDecl *ToTU = getToTuDecl("class X;", Lang_CXX03);
   // Then we import a definition.
   {
     TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
         class X {
           void f() { )") + ErroneousStmt + R"( }
           void ok();
         };
         )",
-        Lang_CXX);
+                                            Lang_CXX03);
     auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("X")));
-    CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX);
+    CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX03);
 
     // An error is set for X ...
     EXPECT_FALSE(ImportedX);
     ASTImporter *Importer = findFromTU(FromX)->Importer.get();
     Optional<ImportError> OptErr = Importer->getImportDeclErrorIfAny(FromX);
     ASSERT_TRUE(OptErr);
     EXPECT_EQ(OptErr->Error, ImportError::UnsupportedConstruct);
   }
TEST_P(ErrorHandlingTest,
   // Try to import  X again but from another TU.
   {
     TranslationUnitDecl *FromTU = getTuDecl(std::string(R"(
         class X {
           void f() { )") + ErroneousStmt + R"( }
           void ok();
         };
         )",
-        Lang_CXX, "input1.cc");
+                                            Lang_CXX03, "input1.cc");
 
     auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
         FromTU, cxxRecordDecl(hasName("X")));
-    CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX);
+    CXXRecordDecl *ImportedX = Import(FromX, Lang_CXX03);
 
     // If we did not save the errors for the "to" context then the below checks
     // would fail, because the lookup finds the fwd Decl of the existing
     // definition in the "to" context. We can reach the existing definition via
     // the found fwd Decl. That existing definition is structurally equivalent
     // (we check only the fields) with this one we want to import, so we return
     // with the existing definition, which is erroneous (one method is missing).
 
auto Code =
         struct Base {
           template <class U1, class U2>
           friend struct Class;
         };
         template <class T1, class T2>
         struct Class { };
         )";
 
-  TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX);
-  TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX, "input.cc");
+  TranslationUnitDecl *ToTU = getToTuDecl(Code, Lang_CXX03);
+  TranslationUnitDecl *FromTU = getTuDecl(Code, Lang_CXX03, "input.cc");
 
   auto *ToClassProto = FirstDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("Class")));
   auto *ToClassDef = LastDeclMatcher<ClassTemplateDecl>().match(
       ToTU, classTemplateDecl(hasName("Class")));
   ASSERT_FALSE(ToClassProto->isThisDeclarationADefinition());
   ASSERT_TRUE(ToClassDef->isThisDeclarationADefinition());
   // Previous friend decl is not linked to it!
   ASSERT_FALSE(ToClassDef->getPreviousDecl());
   ASSERT_EQ(ToClassDef->getMostRecentDecl(), ToClassDef);
   ASSERT_EQ(ToClassProto->getMostRecentDecl(), ToClassProto);
 
   auto *FromClassProto = FirstDeclMatcher<ClassTemplateDecl>().match(
       FromTU, classTemplateDecl(hasName("Class")));
   auto *FromClassDef = LastDeclMatcher<ClassTemplateDecl>().match(
       FromTU, classTemplateDecl(hasName("Class")));
   ASSERT_FALSE(FromClassProto->isThisDeclarationADefinition());
   ASSERT_TRUE(FromClassDef->isThisDeclarationADefinition());
   ASSERT_FALSE(FromClassDef->getPreviousDecl());
   ASSERT_EQ(FromClassDef->getMostRecentDecl(), FromClassDef);
   ASSERT_EQ(FromClassProto->getMostRecentDecl(), FromClassProto);
 
-  auto *ImportedDef = Import(FromClassDef, Lang_CXX);
+  auto *ImportedDef = Import(FromClassDef, Lang_CXX03);
   // At import we should find the definition for 'Class' even if the
   // prototype (inside 'friend') for it comes first in the AST and is not
   // linked to the definition.
   EXPECT_EQ(ImportedDef, ToClassDef);
 }
 
 struct LLDBLookupTest : ASTImporterOptionSpecificTestBase {
   LLDBLookupTest() {

 
 TEST_P(LLDBLookupTest, ImporterShouldFindInTransparentContext) {
   TranslationUnitDecl *ToTU = getToTuDecl(
       R"(
       extern "C" {
         class X{};
       };
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *ToX = FirstDeclMatcher<CXXRecordDecl>().match(
       ToTU, cxxRecordDecl(hasName("X")));
 
   // Set up a stub external storage.
   ToTU->setHasExternalLexicalStorage(true);
   // Set up DeclContextBits.HasLazyExternalLexicalLookups to true.
   ToTU->setMustBuildLookupTable();
   struct TestExternalASTSource : ExternalASTSource {};
   ToTU->getASTContext().setExternalSource(new TestExternalASTSource());
 
   Decl *FromTU = getTuDecl(
       R"(
         class X;
       )",
-      Lang_CXX);
+      Lang_CXX03);
   auto *FromX = FirstDeclMatcher<CXXRecordDecl>().match(
       FromTU, cxxRecordDecl(hasName("X")));
-  auto *ImportedX = Import(FromX, Lang_CXX);
+  auto *ImportedX = Import(FromX, Lang_CXX03);
   // The lookup must find the existing class definition in the LinkageSpecDecl.
   // Then the importer renders the existing and the new decl into one chain.
   EXPECT_EQ(ImportedX->getCanonicalDecl(), ToX->getCanonicalDecl());
 }
 
 struct SVEBuiltins : ASTImporterOptionSpecificTestBase {};
 
 TEST_P(SVEBuiltins, ImportTypes) {
   static const char *const TypeNames[] = {
     "__SVInt8_t",
     "__SVInt16_t",
     "__SVInt32_t",
     "__SVInt64_t",
     "__SVUint8_t",
     "__SVUint16_t",
     "__SVUint32_t",
     "__SVUint64_t",
     "__SVFloat16_t",
     "__SVFloat32_t",
     "__SVFloat64_t",
     "__SVBool_t"
   };
 
-  TranslationUnitDecl *ToTU = getToTuDecl("", Lang_CXX);
-  TranslationUnitDecl *FromTU = getTuDecl("", Lang_CXX, "input.cc");
+  TranslationUnitDecl *ToTU = getToTuDecl("", Lang_CXX03);
+  TranslationUnitDecl *FromTU = getTuDecl("", Lang_CXX03, "input.cc");
   for (auto *TypeName : TypeNames) {
     auto *ToTypedef = FirstDeclMatcher<TypedefDecl>().match(
       ToTU, typedefDecl(hasName(TypeName)));
     QualType ToType = ToTypedef->getUnderlyingType();
 
     auto *FromTypedef = FirstDeclMatcher<TypedefDecl>().match(
       FromTU, typedefDecl(hasName(TypeName)));
     QualType FromType = FromTypedef->getUnderlyingType();
 
-    QualType ImportedType = ImportType(FromType, FromTypedef, Lang_CXX);
+    QualType ImportedType = ImportType(FromType, FromTypedef, Lang_CXX03);
     EXPECT_EQ(ImportedType, ToType);
   }
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportOfDefaultImplicitFunctions) {
   // Test that import of implicit functions works and the functions
   // are merged into one chain.
   auto GetDeclToImport = [this](StringRef File) {

 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportAssignedLambda) {
   Decl *FromTU = getTuDecl(
       R"(
       void f() {
         auto x = []{} = {}; auto x2 = x;
       }
       )",
-      Lang_CXX2a, "input0.cc");
+      Lang_CXX20, "input0.cc");
   auto FromF = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("f")));
   // We have only one lambda class.
   ASSERT_EQ(
       DeclCounter<CXXRecordDecl>().match(FromTU, cxxRecordDecl(isLambda())),
       1u);
 
-  FunctionDecl *ToF = Import(FromF, Lang_CXX2a);
+  FunctionDecl *ToF = Import(FromF, Lang_CXX20);
   EXPECT_TRUE(ToF);
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // We have only one lambda class after the import.
   EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, cxxRecordDecl(isLambda())),
             1u);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImportDefaultConstructibleLambdas) {
   Decl *FromTU = getTuDecl(
       R"(
       void f() {
         auto x = []{} = {};
         auto xb = []{} = {};
       }
       )",
-      Lang_CXX2a, "input0.cc");
+      Lang_CXX20, "input0.cc");
   auto FromF = FirstDeclMatcher<FunctionDecl>().match(
       FromTU, functionDecl(hasName("f")));
   // We have two lambda classes.
   ASSERT_EQ(
       DeclCounter<CXXRecordDecl>().match(FromTU, cxxRecordDecl(isLambda())),
       2u);
 
-  FunctionDecl *ToF = Import(FromF, Lang_CXX2a);
+  FunctionDecl *ToF = Import(FromF, Lang_CXX20);
   EXPECT_TRUE(ToF);
   TranslationUnitDecl *ToTU = ToAST->getASTContext().getTranslationUnitDecl();
   // We have two lambda classes after the import.
   EXPECT_EQ(DeclCounter<CXXRecordDecl>().match(ToTU, cxxRecordDecl(isLambda())),
             2u);
 }
 
 TEST_P(ASTImporterOptionSpecificTestBase, ImplicitlyDeclareSelf) {

 TEST_P(ImportSourceLocations, PreserveFileIDTreeStructure) {
   // Tests that the FileID tree structure (with the links being the include
   // chains) is preserved while importing other files (which need to be
   // added to this structure with fake include locations.
 
   SourceLocation Location1;
   {
     auto Pattern = varDecl(hasName("X"));
-    Decl *FromTU = getTuDecl("int X;", Lang_C, "input0.c");
+    Decl *FromTU = getTuDecl("int X;", Lang_C99, "input0.c");
     auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
 
-    Location1 = Import(FromD, Lang_C)->getLocation();
+    Location1 = Import(FromD, Lang_C99)->getLocation();
   }
   SourceLocation Location2;
   {
     auto Pattern = varDecl(hasName("Y"));
-    Decl *FromTU = getTuDecl("int Y;", Lang_C, "input1.c");
+    Decl *FromTU = getTuDecl("int Y;", Lang_C99, "input1.c");
     auto *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
 
-    Location2 = Import(FromD, Lang_C)->getLocation();
+    Location2 = Import(FromD, Lang_C99)->getLocation();
   }
 
   SourceManager &ToSM = ToAST->getSourceManager();
   FileID FileID1 = ToSM.getFileID(Location1);
   FileID FileID2 = ToSM.getFileID(Location2);
 
   // Check that the imported files look like as if they were included from the
   // start of the main file.
TEST_P(ImportSourceLocations, PreserveFileIDTreeStructure) {
   EXPECT_FALSE(ToSM.isBeforeInTranslationUnit(Location2, Location1));
 }
 
 TEST_P(ImportSourceLocations, NormalFileBuffer) {
   // Test importing normal file buffers.
 
   std::string Path = "input0.c";
   std::string Source = "int X;";
-  TranslationUnitDecl *FromTU = getTuDecl(Source, Lang_C, Path);
+  TranslationUnitDecl *FromTU = getTuDecl(Source, Lang_C99, Path);
 
   SourceLocation ImportedLoc;
   {
     // Import the VarDecl to trigger the importing of the FileID.
     auto Pattern = varDecl(hasName("X"));
     VarDecl *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
-    ImportedLoc = Import(FromD, Lang_C)->getLocation();
+    ImportedLoc = Import(FromD, Lang_C99)->getLocation();
   }
 
   // Make sure the imported buffer has the original contents.
   SourceManager &ToSM = ToAST->getSourceManager();
   FileID ImportedID = ToSM.getFileID(ImportedLoc);
   EXPECT_EQ(Source, ToSM.getBuffer(ImportedID, SourceLocation())->getBuffer());
 }
 
 TEST_P(ImportSourceLocations, OverwrittenFileBuffer) {
   // Test importing overwritten file buffers.
 
   std::string Path = "input0.c";
-  TranslationUnitDecl *FromTU = getTuDecl("int X;", Lang_C, Path);
+  TranslationUnitDecl *FromTU = getTuDecl("int X;", Lang_C99, Path);
 
   // Overwrite the file buffer for our input file with new content.
   const std::string Contents = "overwritten contents";
   SourceLocation ImportedLoc;
   {
     SourceManager &FromSM = FromTU->getASTContext().getSourceManager();
     clang::FileManager &FM = FromSM.getFileManager();
     const clang::FileEntry &FE =
         *FM.getVirtualFile(Path, static_cast<off_t>(Contents.size()), 0);
 
     llvm::SmallVector<char, 64> Buffer;
     Buffer.append(Contents.begin(), Contents.end());
     auto FileContents =
         std::make_unique<llvm::SmallVectorMemoryBuffer>(std::move(Buffer), Path);
     FromSM.overrideFileContents(&FE, std::move(FileContents));
 
     // Import the VarDecl to trigger the importing of the FileID.
     auto Pattern = varDecl(hasName("X"));
     VarDecl *FromD = FirstDeclMatcher<VarDecl>().match(FromTU, Pattern);
-    ImportedLoc = Import(FromD, Lang_C)->getLocation();
+    ImportedLoc = Import(FromD, Lang_C99)->getLocation();
   }
 
   // Make sure the imported buffer has the overwritten contents.
   SourceManager &ToSM = ToAST->getSourceManager();
   FileID ImportedID = ToSM.getFileID(ImportedLoc);
   EXPECT_EQ(Contents,
             ToSM.getBuffer(ImportedID, SourceLocation())->getBuffer());
 }
void CompleteType(TagDecl *Tag) override {
     Record->startDefinition();
     Record->completeDefinition();
     CompletedTags.push_back(Tag);
   }
 };
 
 TEST_P(ImportWithExternalSource, CompleteRecordBeforeImporting) {
   // Create an empty TU.
-  TranslationUnitDecl *FromTU = getTuDecl("", Lang_CXX, "input.cpp");
+  TranslationUnitDecl *FromTU = getTuDecl("", Lang_CXX03, "input.cpp");
 
   // Create and add the test ExternalASTSource.
   std::vector<clang::TagDecl *> CompletedTags;
   IntrusiveRefCntPtr<ExternalASTSource> source =
       new SourceWithCompletedTagList(CompletedTags);
   clang::ASTContext &Context = FromTU->getASTContext();
   Context.setExternalSource(std::move(source));
 
   // Create a dummy class by hand with external lexical storage.
   IdentifierInfo &Ident = Context.Idents.get("test_class");
   auto *Record = CXXRecordDecl::Create(
       Context, TTK_Class, FromTU, SourceLocation(), SourceLocation(), &Ident);
   Record->setHasExternalLexicalStorage();
   FromTU->addDecl(Record);
 
   // Do a minimal import of the created class.
   EXPECT_EQ(0U, CompletedTags.size());
-  Import(Record, Lang_CXX);
+  Import(Record, Lang_CXX03);
   EXPECT_EQ(0U, CompletedTags.size());
 
   // Import the definition of the created class.
   llvm::Error Err = findFromTU(Record)->Importer->ImportDefinition(Record);
   EXPECT_FALSE((bool)Err);
   consumeError(std::move(Err));
 
   // Make sure the class was completed once.

clang/unittests/AST/MatchVerifier.h

 /// \brief Base class for verifying some property of nodes found by a matcher.
 template <typename NodeType>
 class MatchVerifier : public MatchFinder::MatchCallback {
 public:
   template <typename MatcherType>
   testing::AssertionResult match(const std::string &Code,
                                  const MatcherType &AMatcher) {
     std::vector<std::string> Args;
-    return match(Code, AMatcher, Args, Lang_CXX);
+    return match(Code, AMatcher, Args, Lang_CXX03);
   }
 
   template <typename MatcherType>
   testing::AssertionResult match(const std::string &Code,
                                  const MatcherType &AMatcher, TestLanguage L) {
     std::vector<std::string> Args;
     return match(Code, AMatcher, Args, L);
   }
MatchVerifier<NodeType>::match(const std::string &Code,
                                std::vector<std::string> &Args, TestLanguage L) {
   MatchFinder Finder;
   Finder.addMatcher(AMatcher.bind(""), this);
   std::unique_ptr<tooling::FrontendActionFactory> Factory(
       tooling::newFrontendActionFactory(&Finder));
 
   StringRef FileName;
   switch (L) {
-  case Lang_C:
-    Args.push_back("-std=c99");
-    FileName = "input.c";
-    break;
   case Lang_C89:
     Args.push_back("-std=c89");
     FileName = "input.c";
     break;
-  case Lang_CXX:
-    Args.push_back("-std=c++98");
+  case Lang_C99:
+    Args.push_back("-std=c99");
+    FileName = "input.c";
+    break;
+  case Lang_CXX03:
+    Args.push_back("-std=c++03");
     FileName = "input.cc";
     break;
   case Lang_CXX11:
     Args.push_back("-std=c++11");
     FileName = "input.cc";
     break;
   case Lang_CXX14:
     Args.push_back("-std=c++14");
     FileName = "input.cc";
     break;
   case Lang_CXX17:
     Args.push_back("-std=c++17");
     FileName = "input.cc";
     break;
-  case Lang_CXX2a:
-    Args.push_back("-std=c++2a");
+  case Lang_CXX20:
+    Args.push_back("-std=c++20");
     FileName = "input.cc";
     break;
   case Lang_OpenCL:
     FileName = "input.cl";
     break;
   case Lang_OBJCXX:
     FileName = "input.mm";
     break;

clang/unittests/AST/SourceLocationTest.cpp

TEST(LabelStmt, Range) {
   RangeVerifier<LabelStmt> Verifier;
   Verifier.expectRange(1, 12, 1, 15);
   EXPECT_TRUE(Verifier.match("void f() { l: return; }", labelStmt()));
 }
 
 TEST(ParmVarDecl, KNRLocation) {
   LocationVerifier<ParmVarDecl> Verifier;
   Verifier.expectLocation(1, 8);
-  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
+  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C99));
 }
 
 TEST(ParmVarDecl, KNRRange) {
   RangeVerifier<ParmVarDecl> Verifier;
   Verifier.expectRange(1, 8, 1, 8);
-  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C));
+  EXPECT_TRUE(Verifier.match("void f(i) {}", varDecl(), Lang_C99));
 }
 
 TEST(CXXNewExpr, ArrayRange) {
   RangeVerifier<CXXNewExpr> Verifier;
   Verifier.expectRange(1, 12, 1, 22);
   EXPECT_TRUE(Verifier.match("void f() { new int[10]; }", cxxNewExpr()));
 }
 
TEST(FunctionDecl, ExceptionSpecifications) {
   Verifier.expectRange(1, 10, 1, 34);
   EXPECT_TRUE(Verifier.match("void f() throw(void(void) throw());\n",
                              loc(functionType())));
 
   Verifier.expectRange(1, 10, 1, 19);
   std::vector<std::string> Args;
   Args.push_back("-fms-extensions");
   EXPECT_TRUE(Verifier.match("void f() throw(...);\n", loc(functionType()),
-                             Args, Lang_CXX));
+                             Args, Lang_CXX03));
 
   Verifier.expectRange(1, 10, 1, 10);
   EXPECT_TRUE(
       Verifier.match("void f() noexcept;\n", loc(functionType()), Lang_CXX11));
 
   Verifier.expectRange(1, 10, 1, 24);
   EXPECT_TRUE(Verifier.match("void f() noexcept(false);\n", loc(functionType()),
                              Lang_CXX11));

clang/unittests/AST/StructuralEquivalenceTest.cpp

struct StructuralEquivalenceTest : ::testing::Test {
   }
 
   bool testStructuralMatch(std::tuple<Decl *, Decl *> t) {
     return testStructuralMatch(get<0>(t), get<1>(t));
   }
 };
 
 TEST_F(StructuralEquivalenceTest, Int) {
-  auto Decls = makeNamedDecls("int foo;", "int foo;", Lang_CXX);
+  auto Decls = makeNamedDecls("int foo;", "int foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(Decls));
 }
 
 TEST_F(StructuralEquivalenceTest, IntVsSignedInt) {
-  auto Decls = makeNamedDecls("int foo;", "signed int foo;", Lang_CXX);
+  auto Decls = makeNamedDecls("int foo;", "signed int foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(Decls));
 }
 
 TEST_F(StructuralEquivalenceTest, Char) {
-  auto Decls = makeNamedDecls("char foo;", "char foo;", Lang_CXX);
+  auto Decls = makeNamedDecls("char foo;", "char foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(Decls));
 }
 
 // This test is disabled for now.
 // FIXME Whether this is equivalent is dependendant on the target.
 TEST_F(StructuralEquivalenceTest, DISABLED_CharVsSignedChar) {
-  auto Decls = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX);
+  auto Decls = makeNamedDecls("char foo;", "signed char foo;", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(Decls));
 }
 
 TEST_F(StructuralEquivalenceTest, ForwardRecordDecl) {
-  auto Decls = makeNamedDecls("struct foo;", "struct foo;", Lang_CXX);
+  auto Decls = makeNamedDecls("struct foo;", "struct foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(Decls));
 }
 
 TEST_F(StructuralEquivalenceTest, IntVsSignedIntInStruct) {
   auto Decls = makeNamedDecls("struct foo { int x; };",
-                              "struct foo { signed int x; };", Lang_CXX);
+                              "struct foo { signed int x; };", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(Decls));
 }
 
 TEST_F(StructuralEquivalenceTest, CharVsSignedCharInStruct) {
   auto Decls = makeNamedDecls("struct foo { char x; };",
-                              "struct foo { signed char x; };", Lang_CXX);
+                              "struct foo { signed char x; };", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(Decls));
 }
 
 TEST_F(StructuralEquivalenceTest, IntVsSignedIntTemplateSpec) {
   auto Decls = makeDecls<ClassTemplateSpecializationDecl>(
       R"(template <class T> struct foo; template<> struct foo<int>{};)",
       R"(template <class T> struct foo; template<> struct foo<signed int>{};)",
-      Lang_CXX,
-      classTemplateSpecializationDecl());
+      Lang_CXX03, classTemplateSpecializationDecl());
   auto Spec0 = get<0>(Decls);
   auto Spec1 = get<1>(Decls);
   EXPECT_TRUE(testStructuralMatch(Spec0, Spec1));
 }
 
 TEST_F(StructuralEquivalenceTest, CharVsSignedCharTemplateSpec) {
   auto Decls = makeDecls<ClassTemplateSpecializationDecl>(
       R"(template <class T> struct foo; template<> struct foo<char>{};)",
       R"(template <class T> struct foo; template<> struct foo<signed char>{};)",
-      Lang_CXX,
-      classTemplateSpecializationDecl());
+      Lang_CXX03, classTemplateSpecializationDecl());
   auto Spec0 = get<0>(Decls);
   auto Spec1 = get<1>(Decls);
   EXPECT_FALSE(testStructuralMatch(Spec0, Spec1));
 }
 
 TEST_F(StructuralEquivalenceTest, CharVsSignedCharTemplateSpecWithInheritance) {
   auto Decls = makeDecls<ClassTemplateSpecializationDecl>(
       R"(
       struct true_type{};
       template <class T> struct foo;
       template<> struct foo<char> : true_type {};
       )",
       R"(
       struct true_type{};
       template <class T> struct foo;
       template<> struct foo<signed char> : true_type {};
       )",
-      Lang_CXX,
-      classTemplateSpecializationDecl());
+      Lang_CXX03, classTemplateSpecializationDecl());
   EXPECT_FALSE(testStructuralMatch(Decls));
 }
 
 // This test is disabled for now.
 // FIXME Enable it, once the check is implemented.
 TEST_F(StructuralEquivalenceTest, DISABLED_WrongOrderInNamespace) {
   auto Code =
       R"(
       namespace NS {
       template <class T> class Base {
           int a;
       };
       class Derived : Base<Derived> {
       };
       }
       void foo(NS::Derived &);
       )";
-  auto Decls = makeNamedDecls(Code, Code, Lang_CXX);
+  auto Decls = makeNamedDecls(Code, Code, Lang_CXX03);
 
   NamespaceDecl *NS =
       LastDeclMatcher<NamespaceDecl>().match(get<1>(Decls), namespaceDecl());
   ClassTemplateDecl *TD = LastDeclMatcher<ClassTemplateDecl>().match(
       get<1>(Decls), classTemplateDecl(hasName("Base")));
 
   // Reorder the decls, move the TD to the last place in the DC.
   NS->removeDecl(TD);
   NS->addDeclInternal(TD);
 
   EXPECT_FALSE(testStructuralMatch(Decls));
 }
 
 TEST_F(StructuralEquivalenceTest, WrongOrderOfFieldsInClass) {
   auto Code = "class X { int a; int b; };";
-  auto Decls = makeNamedDecls(Code, Code, Lang_CXX, "X");
+  auto Decls = makeNamedDecls(Code, Code, Lang_CXX03, "X");
 
   CXXRecordDecl *RD = FirstDeclMatcher<CXXRecordDecl>().match(
       get<1>(Decls), cxxRecordDecl(hasName("X")));
   FieldDecl *FD =
       FirstDeclMatcher<FieldDecl>().match(get<1>(Decls), fieldDecl(hasName("a")));
 
   // Reorder the FieldDecls
   RD->removeDecl(FD);
   RD->addDeclInternal(FD);
 
   EXPECT_FALSE(testStructuralMatch(Decls));
 }
 
 struct StructuralEquivalenceFunctionTest : StructuralEquivalenceTest {
 };
 
 TEST_F(StructuralEquivalenceFunctionTest, TemplateVsNonTemplate) {
-  auto t = makeNamedDecls(
-      "void foo();",
-      "template<class T> void foo();",
-      Lang_CXX);
+  auto t = makeNamedDecls("void foo();", "template<class T> void foo();",
+                          Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, DifferentOperators) {
   auto t = makeDecls<FunctionDecl>(
-      "struct X{}; bool operator<(X, X);",
-      "struct X{}; bool operator==(X, X);", Lang_CXX,
-      functionDecl(hasOverloadedOperatorName("<")),
+      "struct X{}; bool operator<(X, X);", "struct X{}; bool operator==(X, X);",
+      Lang_CXX03, functionDecl(hasOverloadedOperatorName("<")),
       functionDecl(hasOverloadedOperatorName("==")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, SameOperators) {
   auto t = makeDecls<FunctionDecl>(
-      "struct X{}; bool operator<(X, X);",
-      "struct X{}; bool operator<(X, X);", Lang_CXX,
-      functionDecl(hasOverloadedOperatorName("<")),
+      "struct X{}; bool operator<(X, X);", "struct X{}; bool operator<(X, X);",
+      Lang_CXX03, functionDecl(hasOverloadedOperatorName("<")),
       functionDecl(hasOverloadedOperatorName("<")));
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, CtorVsDtor) {
-  auto t = makeDecls<FunctionDecl>(
-      "struct X{ X(); };",
-      "struct X{ ~X(); };", Lang_CXX,
-      cxxConstructorDecl(),
+  auto t = makeDecls<FunctionDecl>("struct X{ X(); };", "struct X{ ~X(); };",
+                                   Lang_CXX03, cxxConstructorDecl(),
                                    cxxDestructorDecl());
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ParamConstWithRef) {
-  auto t = makeNamedDecls("void foo(int&);",
-                          "void foo(const int&);", Lang_CXX);
+  auto t =
+      makeNamedDecls("void foo(int&);", "void foo(const int&);", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ParamConstSimple) {
-  auto t = makeNamedDecls("void foo(int);",
-                          "void foo(const int);", Lang_CXX);
+  auto t = makeNamedDecls("void foo(int);", "void foo(const int);", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(t));
   // consider this OK
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, Throw) {
-  auto t = makeNamedDecls("void foo();",
-                          "void foo() throw();", Lang_CXX);
+  auto t = makeNamedDecls("void foo();", "void foo() throw();", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, Noexcept) {
   auto t = makeNamedDecls("void foo();",
                           "void foo() noexcept;", Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }

 
 TEST_F(StructuralEquivalenceFunctionTest, NoexceptVsNoexceptTrue) {
   auto t = makeNamedDecls("void foo() noexcept;",
                           "void foo() noexcept(true);", Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ReturnType) {
-  auto t = makeNamedDecls("char foo();",
-                          "int foo();", Lang_CXX);
+  auto t = makeNamedDecls("char foo();", "int foo();", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ReturnConst) {
-  auto t = makeNamedDecls("char foo();",
-                          "const char foo();", Lang_CXX);
+  auto t = makeNamedDecls("char foo();", "const char foo();", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ReturnRef) {
   auto t = makeNamedDecls("char &foo();",
                           "char &&foo();", Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ParamCount) {
-  auto t = makeNamedDecls("void foo(int);",
-                          "void foo(int, int);", Lang_CXX);
+  auto t = makeNamedDecls("void foo(int);", "void foo(int, int);", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ParamType) {
-  auto t = makeNamedDecls("void foo(int);",
-                          "void foo(char);", Lang_CXX);
+  auto t = makeNamedDecls("void foo(int);", "void foo(char);", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ParamName) {
-  auto t = makeNamedDecls("void foo(int a);",
-                          "void foo(int b);", Lang_CXX);
+  auto t = makeNamedDecls("void foo(int a);", "void foo(int b);", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, Variadic) {
-  auto t = makeNamedDecls("void foo(int x...);",
-                          "void foo(int x);", Lang_CXX);
+  auto t =
+      makeNamedDecls("void foo(int x...);", "void foo(int x);", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, ParamPtr) {
-  auto t = makeNamedDecls("void foo(int *);",
-                          "void foo(int);", Lang_CXX);
+  auto t = makeNamedDecls("void foo(int *);", "void foo(int);", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, NameInParen) {
-  auto t = makeNamedDecls(
-      "void ((foo))();",
-      "void foo();",
-      Lang_CXX);
+  auto t = makeNamedDecls("void ((foo))();", "void foo();", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, NameInParenWithExceptionSpec) {
   auto t = makeNamedDecls(
       "void (foo)() throw(int);",
       "void (foo)() noexcept;",
       Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, NameInParenWithConst) {
   auto t = makeNamedDecls(
       "struct A { void (foo)() const; };",
       "struct A { void (foo)(); };",
       Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, FunctionsWithDifferentNoreturnAttr) {
-  auto t = makeNamedDecls(
-      "__attribute__((noreturn)) void foo();",
-      "                          void foo();",
-      Lang_C);
+  auto t = makeNamedDecls("__attribute__((noreturn)) void foo();",
+                          "                          void foo();", Lang_C99);
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest,
     FunctionsWithDifferentCallingConventions) {
   // These attributes may not be available on certain platforms.
   if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getArch() !=
       llvm::Triple::x86_64)
     return;
-  auto t = makeNamedDecls(
-      "__attribute__((preserve_all)) void foo();",
-      "__attribute__((ms_abi))   void foo();",
-      Lang_C);
+  auto t = makeNamedDecls("__attribute__((preserve_all)) void foo();",
+                          "__attribute__((ms_abi))   void foo();", Lang_C99);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceFunctionTest, FunctionsWithDifferentSavedRegsAttr) {
   if (llvm::Triple(llvm::sys::getDefaultTargetTriple()).getArch() !=
       llvm::Triple::x86_64)
     return;
   auto t = makeNamedDecls(
       "__attribute__((no_caller_saved_registers)) void foo();",
-      "                                           void foo();",
-      Lang_C);
+      "                                           void foo();", Lang_C99);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 struct StructuralEquivalenceCXXMethodTest : StructuralEquivalenceTest {
 };
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Virtual) {
-  auto t = makeDecls<CXXMethodDecl>(
-      "struct X { void foo(); };",
-      "struct X { virtual void foo(); };", Lang_CXX,
-      cxxMethodDecl(hasName("foo")));
+  auto t = makeDecls<CXXMethodDecl>("struct X { void foo(); };",
+                                    "struct X { virtual void foo(); };",
+                                    Lang_CXX03, cxxMethodDecl(hasName("foo")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Pure) {
   auto t = makeNamedDecls("struct X { virtual void foo(); };",
-                          "struct X { virtual void foo() = 0; };", Lang_CXX);
+                          "struct X { virtual void foo() = 0; };", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, DISABLED_Final) {
   // The final-ness is not checked yet.
-  auto t = makeNamedDecls("struct X { virtual void foo(); };",
-                          "struct X { virtual void foo() final; };", Lang_CXX);
+  auto t =
+      makeNamedDecls("struct X { virtual void foo(); };",
+                     "struct X { virtual void foo() final; };", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Const) {
   auto t = makeNamedDecls("struct X { void foo(); };",
-                          "struct X { void foo() const; };", Lang_CXX);
+                          "struct X { void foo() const; };", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Static) {
   auto t = makeNamedDecls("struct X { void foo(); };",
-                          "struct X { static void foo(); };", Lang_CXX);
+                          "struct X { static void foo(); };", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Ref1) {
   auto t = makeNamedDecls("struct X { void foo(); };",
                           "struct X { void foo() &&; };", Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Ref2) {
   auto t = makeNamedDecls("struct X { void foo() &; };",
                           "struct X { void foo() &&; };", Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, AccessSpecifier) {
-  auto t = makeDecls<CXXMethodDecl>(
-      "struct X { public: void foo(); };",
-      "struct X { private: void foo(); };", Lang_CXX,
-      cxxMethodDecl(hasName("foo")));
+  auto t = makeDecls<CXXMethodDecl>("struct X { public: void foo(); };",
+                                    "struct X { private: void foo(); };",
+                                    Lang_CXX03, cxxMethodDecl(hasName("foo")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Delete) {
   auto t = makeNamedDecls("struct X { void foo(); };",
                           "struct X { void foo() = delete; };", Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Constructor) {
-  auto t = makeDecls<FunctionDecl>(
-      "void foo();", "struct foo { foo(); };", Lang_CXX,
-      functionDecl(hasName("foo")), cxxConstructorDecl(hasName("foo")));
+  auto t = makeDecls<FunctionDecl>("void foo();", "struct foo { foo(); };",
+                                   Lang_CXX03, functionDecl(hasName("foo")),
+                                   cxxConstructorDecl(hasName("foo")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, ConstructorParam) {
   auto t = makeDecls<CXXConstructorDecl>("struct X { X(); };",
-                                         "struct X { X(int); };", Lang_CXX,
+                                         "struct X { X(int); };", Lang_CXX03,
                                          cxxConstructorDecl(hasName("X")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, ConstructorExplicit) {
   auto t = makeDecls<CXXConstructorDecl>("struct X { X(int); };",
                                          "struct X { explicit X(int); };",
                                          Lang_CXX11,
TEST_F(StructuralEquivalenceCXXMethodTest, Conversion) {
   auto t = makeDecls<CXXConversionDecl>("struct X { operator bool(); };",
                                         "struct X { operator char(); };",
                                          Lang_CXX11,
                                          cxxConversionDecl());
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, Operator) {
-  auto t = makeDecls<FunctionDecl>(
-      "struct X { int operator +(int); };",
-      "struct X { int operator -(int); };", Lang_CXX,
+  auto t =
+      makeDecls<FunctionDecl>("struct X { int operator +(int); };",
+                              "struct X { int operator -(int); };", Lang_CXX03,
                               functionDecl(hasOverloadedOperatorName("+")),
                               functionDecl(hasOverloadedOperatorName("-")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, OutOfClass1) {
   auto t = makeDecls<FunctionDecl>(
       "struct X { virtual void f(); }; void X::f() { }",
-      "struct X { virtual void f() { }; };",
-      Lang_CXX,
+      "struct X { virtual void f() { }; };", Lang_CXX03,
       functionDecl(allOf(hasName("f"), isDefinition())));
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceCXXMethodTest, OutOfClass2) {
   auto t = makeDecls<FunctionDecl>(
       "struct X { virtual void f(); }; void X::f() { }",
-      "struct X { void f(); }; void X::f() { }",
-      Lang_CXX,
+      "struct X { void f(); }; void X::f() { }", Lang_CXX03,
       functionDecl(allOf(hasName("f"), isDefinition())));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 struct StructuralEquivalenceRecordTest : StructuralEquivalenceTest {
   // FIXME Use a common getRecordDecl with ASTImporterTest.cpp!
   RecordDecl *getRecordDecl(FieldDecl *FD) {
     auto *ET = cast<ElaboratedType>(FD->getType().getTypePtr());
     return cast<RecordType>(ET->getNamedType().getTypePtr())->getDecl();
   };
 };
 
 TEST_F(StructuralEquivalenceRecordTest, Name) {
-  auto t = makeDecls<CXXRecordDecl>(
-      "struct A{ };",
-      "struct B{ };",
-      Lang_CXX,
+  auto t = makeDecls<CXXRecordDecl>("struct A{ };", "struct B{ };", Lang_CXX03,
                                     cxxRecordDecl(hasName("A")),
                                     cxxRecordDecl(hasName("B")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceRecordTest, Fields) {
-  auto t = makeNamedDecls(
-      "struct foo{ int x; };",
-      "struct foo{ char x; };",
-      Lang_CXX);
+  auto t = makeNamedDecls("struct foo{ int x; };", "struct foo{ char x; };",
+                          Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceRecordTest, DISABLED_Methods) {
   // Currently, methods of a class are not checked at class equivalence.
-  auto t = makeNamedDecls(
-      "struct foo{ int x(); };",
-      "struct foo{ char x(); };",
-      Lang_CXX);
+  auto t = makeNamedDecls("struct foo{ int x(); };", "struct foo{ char x(); };",
+                          Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceRecordTest, Bases) {
-  auto t = makeNamedDecls(
-      "struct A{ }; struct foo: A { };",
-      "struct B{ }; struct foo: B { };",
-      Lang_CXX);
+  auto t = makeNamedDecls("struct A{ }; struct foo: A { };",
+                          "struct B{ }; struct foo: B { };", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceRecordTest, InheritanceVirtual) {
-  auto t = makeNamedDecls(
-      "struct A{ }; struct foo: A { };",
-      "struct A{ }; struct foo: virtual A { };",
-      Lang_CXX);
+  auto t =
+      makeNamedDecls("struct A{ }; struct foo: A { };",
+                     "struct A{ }; struct foo: virtual A { };", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceRecordTest, DISABLED_InheritanceType) {
   // Access specifier in inheritance is not checked yet.
-  auto t = makeNamedDecls(
-      "struct A{ }; struct foo: public A { };",
-      "struct A{ }; struct foo: private A { };",
-      Lang_CXX);
+  auto t =
+      makeNamedDecls("struct A{ }; struct foo: public A { };",
+                     "struct A{ }; struct foo: private A { };", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceRecordTest, Match) {
   auto Code = R"(
       struct A{ };
       struct B{ };
       struct foo: A, virtual B {
         void x();
         int a;
       };
       )";
-  auto t = makeNamedDecls(Code, Code, Lang_CXX);
+  auto t = makeNamedDecls(Code, Code, Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceRecordTest, UnnamedRecordsShouldBeInequivalent) {
   auto t = makeTuDecls(
       R"(
       struct A {
         struct {
           struct A *next;
         } entry0;
         struct {
           struct A *next;
         } entry1;
       };
       )",
-      "", Lang_C);
+      "", Lang_C99);
   auto *TU = get<0>(t);
   auto *Entry0 =
       FirstDeclMatcher<FieldDecl>().match(TU, fieldDecl(hasName("entry0")));
   auto *Entry1 =
       FirstDeclMatcher<FieldDecl>().match(TU, fieldDecl(hasName("entry1")));
   auto *R0 = getRecordDecl(Entry0);
   auto *R1 = getRecordDecl(Entry1);
 
auto t = makeTuDecls(
         struct {
           int a;
         };
         struct {
           int b;
         };
       };
       )",
-      "", Lang_C);
+      "", Lang_C99);
   auto *TU = get<0>(t);
   auto *A = FirstDeclMatcher<IndirectFieldDecl>().match(
       TU, indirectFieldDecl(hasName("a")));
   auto *FA = cast<FieldDecl>(A->chain().front());
   RecordDecl *RA = cast<RecordType>(FA->getType().getTypePtr())->getDecl();
   auto *B = FirstDeclMatcher<IndirectFieldDecl>().match(
       TU, indirectFieldDecl(hasName("b")));
   auto *FB = cast<FieldDecl>(B->chain().front());
auto t = makeTuDecls(
       };
       )",
       R"(
       struct X { // The order is reversed.
         struct { int b; };
         struct { int a; };
       };
       )",
-      Lang_C);
+      Lang_C99);
 
   auto *TU = get<0>(t);
   auto *A = FirstDeclMatcher<IndirectFieldDecl>().match(
       TU, indirectFieldDecl(hasName("a")));
   auto *FA = cast<FieldDecl>(A->chain().front());
   RecordDecl *RA = cast<RecordType>(FA->getType().getTypePtr())->getDecl();
 
   auto *TU1 = get<1>(t);
auto Code =
         struct {
           struct A *next;
         } entry0;
         struct {
           struct A *next;
         } entry1;
       };
       )";
-  auto t = makeTuDecls(Code, Code, Lang_C);
+  auto t = makeTuDecls(Code, Code, Lang_C99);
 
   auto *FromTU = get<0>(t);
   auto *Entry1 =
       FirstDeclMatcher<FieldDecl>().match(FromTU, fieldDecl(hasName("entry1")));
 
   auto *ToTU = get<1>(t);
   auto *Entry0 =
       FirstDeclMatcher<FieldDecl>().match(ToTU, fieldDecl(hasName("entry0")));
   auto *A =
       FirstDeclMatcher<RecordDecl>().match(ToTU, recordDecl(hasName("A")));
   A->startDefinition(); // Set isBeingDefined, getDefinition() will return a
                         // nullptr. This may be the case during ASTImport.
 
   auto *R0 = getRecordDecl(Entry0);
   auto *R1 = getRecordDecl(Entry1);
 
   ASSERT_NE(R0, R1);
   EXPECT_TRUE(testStructuralMatch(R0, R0));
   EXPECT_TRUE(testStructuralMatch(R1, R1));
   EXPECT_FALSE(testStructuralMatch(R0, R1));
 }
 
 TEST_F(StructuralEquivalenceRecordTest, TemplateVsNonTemplate) {
-  auto t = makeDecls<CXXRecordDecl>(
-      "struct A { };",
+  auto t = makeDecls<CXXRecordDecl>("struct A { };",
                                     "template<class T> struct A { };",
-      Lang_CXX,
-      cxxRecordDecl(hasName("A")));
+                                    Lang_CXX03, cxxRecordDecl(hasName("A")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceRecordTest,
     FwdDeclRecordShouldBeEqualWithFwdDeclRecord) {
   auto t = makeNamedDecls("class foo;", "class foo;", Lang_CXX11);
   EXPECT_TRUE(testStructuralMatch(t));
 }
auto t = makeDecls<LambdaExpr>(
       lambdaExpr(),
       lambdaExpr());
   CXXRecordDecl *L0 = get<0>(t)->getLambdaClass();
   CXXRecordDecl *L1 = get<1>(t)->getLambdaClass();
   EXPECT_TRUE(testStructuralMatch(L0, L1));
 }
 
 TEST_F(StructuralEquivalenceTest, CompareSameDeclWithMultiple) {
-  auto t = makeNamedDecls(
-      "struct A{ }; struct B{ }; void foo(A a, A b);",
+  auto t = makeNamedDecls("struct A{ }; struct B{ }; void foo(A a, A b);",
                           "struct A{ }; struct B{ }; void foo(A a, B b);",
-      Lang_CXX);
+                          Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceTest, ExplicitBoolDifferent) {
   auto Decls = makeNamedDecls("struct foo {explicit(false) foo(int);};",
-                              "struct foo {explicit(true) foo(int);};", Lang_CXX2a);
+                              "struct foo {explicit(true) foo(int);};", Lang_CXX20);
   CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
       get<0>(Decls), cxxConstructorDecl(hasName("foo")));
   CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
       get<1>(Decls), cxxConstructorDecl(hasName("foo")));
   EXPECT_FALSE(testStructuralMatch(First, Second));
 }
 
 TEST_F(StructuralEquivalenceTest, ExplicitBoolSame) {
   auto Decls = makeNamedDecls("struct foo {explicit(true) foo(int);};",
-                              "struct foo {explicit(true) foo(int);};", Lang_CXX2a);
+                              "struct foo {explicit(true) foo(int);};", Lang_CXX20);
   CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
       get<0>(Decls), cxxConstructorDecl(hasName("foo")));
   CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
       get<1>(Decls), cxxConstructorDecl(hasName("foo")));
   EXPECT_TRUE(testStructuralMatch(First, Second));
 }
 
 struct StructuralEquivalenceEnumTest : StructuralEquivalenceTest {};
auto t = makeNamedDecls("enum class foo { B };", "enum class foo { A };",
                           Lang_CXX11);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 struct StructuralEquivalenceTemplateTest : StructuralEquivalenceTest {};
 
 TEST_F(StructuralEquivalenceTemplateTest, ExactlySameTemplates) {
   auto t = makeNamedDecls("template <class T> struct foo;",
-                          "template <class T> struct foo;", Lang_CXX);
+                          "template <class T> struct foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceTemplateTest, DifferentTemplateArgName) {
   auto t = makeNamedDecls("template <class T> struct foo;",
-                          "template <class U> struct foo;", Lang_CXX);
+                          "template <class U> struct foo;", Lang_CXX03);
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceTemplateTest, DifferentTemplateArgKind) {
   auto t = makeNamedDecls("template <class T> struct foo;",
-                          "template <int T> struct foo;", Lang_CXX);
+                          "template <int T> struct foo;", Lang_CXX03);
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceTemplateTest, ExplicitBoolSame) {
-  auto Decls = makeNamedDecls("template <bool b> struct foo {explicit(b) foo(int);};",
-                              "template <bool b> struct foo {explicit(b) foo(int);};", Lang_CXX2a);
+  auto Decls = makeNamedDecls(
+      "template <bool b> struct foo {explicit(b) foo(int);};",
+      "template <bool b> struct foo {explicit(b) foo(int);};", Lang_CXX20);
   CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
       get<0>(Decls), cxxConstructorDecl(hasName("foo<b>")));
   CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
       get<1>(Decls), cxxConstructorDecl(hasName("foo<b>")));
   EXPECT_TRUE(testStructuralMatch(First, Second));
 }
 
 TEST_F(StructuralEquivalenceTemplateTest, ExplicitBoolDifference) {
-  auto Decls = makeNamedDecls("template <bool b> struct foo {explicit(b) foo(int);};",
-                              "template <bool b> struct foo {explicit(!b) foo(int);};", Lang_CXX2a);
+  auto Decls = makeNamedDecls(
+      "template <bool b> struct foo {explicit(b) foo(int);};",
+      "template <bool b> struct foo {explicit(!b) foo(int);};", Lang_CXX20);
   CXXConstructorDecl *First = FirstDeclMatcher<CXXConstructorDecl>().match(
       get<0>(Decls), cxxConstructorDecl(hasName("foo<b>")));
   CXXConstructorDecl *Second = FirstDeclMatcher<CXXConstructorDecl>().match(
       get<1>(Decls), cxxConstructorDecl(hasName("foo<b>")));
   EXPECT_FALSE(testStructuralMatch(First, Second));
 }
 
 TEST_F(StructuralEquivalenceTemplateTest,
void f() {
     // Make specialization with substituted template template param.
     Primary <P1> A;
   };
 };
 
 // Instantiate with substitution Arg into P1.
 template class Templ <Arg>;
       )",
-      Lang_CXX, classTemplateSpecializationDecl(hasName("Primary")));
+      Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceTemplateTest,
        TemplateVsSubstTemplateTemplateParmInArgNotEq) {
   auto t = makeDecls<ClassTemplateSpecializationDecl>(
       R"(
 template <typename P1> class Arg { };
void f() {
     // Make specialization with substituted template template param.
     Primary <P1> A;
   };
 };
 
 // Instantiate with substitution Arg into P1.
 template class Templ <Arg>;
       )",
-      Lang_CXX, classTemplateSpecializationDecl(hasName("Primary")));
+      Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 struct StructuralEquivalenceDependentTemplateArgsTest
     : StructuralEquivalenceTemplateTest {};
 
 TEST_F(StructuralEquivalenceDependentTemplateArgsTest,
        SameStructsInDependentArgs) {
auto t = makeDecls<FunctionTemplateDecl>(Code + R"(
       )",
                                            Code + R"(
       struct S
       {
         template <typename T, typename enable_if<S2<T>::value>::type>
         void f();
       };
       )",
-                                           Lang_CXX,
+                                           Lang_CXX03,
                                            functionTemplateDecl(hasName("f")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(StructuralEquivalenceDependentTemplateArgsTest,
        DifferentValueInDependentScopeDeclRefExpr) {
   std::string Code =
       R"(
auto t = makeDecls<FunctionTemplateDecl>(Code + R"(
       )",
                                            Code + R"(
       struct S
       {
         template <typename T, typename enable_if<S1<T>::value2>::type>
         void f();
       };
       )",
-                                           Lang_CXX,
+                                           Lang_CXX03,
                                            functionTemplateDecl(hasName("f")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(
     StructuralEquivalenceTemplateTest,
     ClassTemplSpecWithQualifiedAndNonQualifiedTypeArgsShouldBeEqual) {
   auto t = makeDecls<ClassTemplateSpecializationDecl>(
auto t = makeDecls<ClassTemplateSpecializationDecl>(
       template <class T> struct Primary {};
       namespace N {
         struct Arg;
       }
       using namespace N;
       // Explicit instantiation with UNqualified name.
       template struct Primary<Arg>;
       )",
-      Lang_CXX,
-      classTemplateSpecializationDecl(hasName("Primary")));
+      Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(
     StructuralEquivalenceTemplateTest,
     ClassTemplSpecWithInequivalentQualifiedAndNonQualifiedTypeArgs) {
   auto t = makeDecls<ClassTemplateSpecializationDecl>(
       R"(
auto t = makeDecls<ClassTemplateSpecializationDecl>(
       namespace N {
         // This struct is not equivalent with the other in the prev TU.
         struct Arg { double b; }; // -- Field mismatch.
       }
       using namespace N;
       // Explicit instantiation with UNqualified name.
       template struct Primary<Arg>;
       )",
-      Lang_CXX,
-      classTemplateSpecializationDecl(hasName("Primary")));
+      Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(
     StructuralEquivalenceTemplateTest,
     ClassTemplSpecWithQualifiedAndNonQualifiedTemplArgsShouldBeEqual) {
   auto t = makeDecls<ClassTemplateSpecializationDecl>(
       R"(
       template <template <class> class T> struct Primary {};
       namespace N {
         template <class T> struct Arg;
       }
       // Explicit instantiation with qualified name.
       template struct Primary<N::Arg>;
       )",
       R"(
       template <template <class> class T> struct Primary {};
       namespace N {
         template <class T> struct Arg;
       }
       using namespace N;
       // Explicit instantiation with UNqualified name.
       template struct Primary<Arg>;
       )",
-      Lang_CXX,
-      classTemplateSpecializationDecl(hasName("Primary")));
+      Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
   EXPECT_TRUE(testStructuralMatch(t));
 }
 
 TEST_F(
     StructuralEquivalenceTemplateTest,
     ClassTemplSpecWithInequivalentQualifiedAndNonQualifiedTemplArgs) {
   auto t = makeDecls<ClassTemplateSpecializationDecl>(
       R"(
auto t = makeDecls<ClassTemplateSpecializationDecl>(
       namespace N {
         // This template is not equivalent with the other in the prev TU.
         template <class T> struct Arg { double b; }; // -- Field mismatch.
       }
       using namespace N;
       // Explicit instantiation with UNqualified name.
       template struct Primary<Arg>;
       )",
-      Lang_CXX,
-      classTemplateSpecializationDecl(hasName("Primary")));
+      Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 
 TEST_F(
     StructuralEquivalenceTemplateTest,
     ClassTemplSpecWithInequivalentShadowedTemplArg) {
   auto t = makeDecls<ClassTemplateSpecializationDecl>(
       R"(
       template <template <class> class T> struct Primary {};
       template <class T> struct Arg { int a; };
       // Explicit instantiation with ::Arg
       template struct Primary<Arg>;
       )",
       R"(
       template <template <class> class T> struct Primary {};
       template <class T> struct Arg { int a; };
       namespace N {
         // This template is not equivalent with the other in the global scope.
         template <class T> struct Arg { double b; }; // -- Field mismatch.
         // Explicit instantiation with N::Arg which shadows ::Arg
         template struct Primary<Arg>;
       }
       )",
-      Lang_CXX,
-      classTemplateSpecializationDecl(hasName("Primary")));
+      Lang_CXX03, classTemplateSpecializationDecl(hasName("Primary")));
   EXPECT_FALSE(testStructuralMatch(t));
 }
 struct StructuralEquivalenceCacheTest : public StructuralEquivalenceTest {
   llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls;
 
   template <typename NodeType, typename MatcherType>
   std::pair<NodeType *, NodeType *>
   findDeclPair(std::tuple<TranslationUnitDecl *, TranslationUnitDecl *> TU,
auto TU = makeTuDecls(
       class B {};
       void x(A, A);
       )",
       R"(
       class A {};
       class B {};
       void x(A, B);
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   StructuralEquivalenceContext Ctx(
       get<0>(TU)->getASTContext(), get<1>(TU)->getASTContext(),
       NonEquivalentDecls, StructuralEquivalenceKind::Default, false, false);
 
   auto X = findDeclPair<FunctionDecl>(TU, functionDecl(hasName("x")));
   EXPECT_FALSE(Ctx.IsEquivalent(X.first, X.second));
 
auto TU = makeTuDecls(
       class B { int i; };
       void x(A *);
       void y(B *);
       class C {
         friend void x(A *);
         friend void y(B *);
       };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   StructuralEquivalenceContext Ctx(
       get<0>(TU)->getASTContext(), get<1>(TU)->getASTContext(),
       NonEquivalentDecls, StructuralEquivalenceKind::Default, false, false);
 
   auto C = findDeclPair<CXXRecordDecl>(
       TU, cxxRecordDecl(hasName("C"), unless(isImplicit())));
   EXPECT_FALSE(Ctx.IsEquivalent(C.first, C.second));
auto TU = makeTuDecls(
       R"(
       class C;
       class A { C *c; };
       void x(A *);
       class C {
         friend void x(A *);
       };
       )",
-      Lang_CXX);
+      Lang_CXX03);
 
   StructuralEquivalenceContext Ctx(
       get<0>(TU)->getASTContext(), get<1>(TU)->getASTContext(),
       NonEquivalentDecls, StructuralEquivalenceKind::Default, false, false);
 
   auto C = findDeclPair<CXXRecordDecl>(
       TU, cxxRecordDecl(hasName("C"), unless(isImplicit())));
   EXPECT_TRUE(Ctx.IsEquivalent(C.first, C.second));

clang/unittests/Tooling/Syntax/TreeTest.cpp

return llvm::makeArrayRef(T->firstLeaf()->token(),
                             T->lastLeaf()->token() + 1);
 }
 
 struct TestClangConfig {
   TestLanguage Language;
   std::string Target;
 
   bool isCXX() const {
-    return Language == Lang_CXX || Language == Lang_CXX11 ||
+    return Language == Lang_CXX03 || Language == Lang_CXX11 ||
            Language == Lang_CXX14 || Language == Lang_CXX17 ||
-           Language == Lang_CXX2a;
+           Language == Lang_CXX20;
   }
 
   bool isCXX11OrLater() const {
     return Language == Lang_CXX11 || Language == Lang_CXX14 ||
-           Language == Lang_CXX17 || Language == Lang_CXX2a;
+           Language == Lang_CXX17 || Language == Lang_CXX20;
   }
 
   bool hasDelayedTemplateParsing() const {
     return Target == "x86_64-pc-win32-msvc";
   }
 
   std::vector<std::string> getCommandLineArgs() const {
     std::vector<std::string> Result = getCommandLineArgsForTesting(Language);
struct TestClangConfig {
   friend std::ostream &operator<<(std::ostream &OS,
                                   const TestClangConfig &ClangConfig) {
     return OS << ClangConfig.toString();
   }
 
   static std::vector<TestClangConfig> &allConfigs() {
     static std::vector<TestClangConfig> all_configs = []() {
       std::vector<TestClangConfig> all_configs;
-      for (TestLanguage lang : {Lang_C, Lang_C89, Lang_CXX, Lang_CXX11,
-                                Lang_CXX14, Lang_CXX17, Lang_CXX2a}) {
+      for (TestLanguage lang : {Lang_C89, Lang_C99, Lang_CXX03, Lang_CXX11,
+                                Lang_CXX14, Lang_CXX17, Lang_CXX20}) {
         TestClangConfig config;
         config.Language = lang;
         config.Target = "x86_64-pc-linux-gnu";
         all_configs.push_back(config);
 
         // Windows target is interesting to test because it enables
         // `-fdelayed-template-parsing`.
         config.Target = "x86_64-pc-win32-msvc";