Rename APIs in unittests/AST/Language.h in preparation to share them

[gribozavr]

Summary

Declaring these helpers in the ast_matcher namespace in the clangAST
unit test seems inappropriate -- neither these helpers, nor clangAST have
anything to do with AST matchers. Therefore, I moved these helpers to
the clang namespace.

Declaring another typedef called "ArgVector" is not a good idea -- we
already have both "ArgVector", "ArgsVector", and "ArgList". I expanded
it into the underlying type.

Declaring another enum called "Language" is not a good idea because we
arleady have the "clang::Language" enum. I renamed it to
"TestLanguage".

Similarly, I renamed "getBasicRunOptionsForLanguage" to
"getCommandLineArgsForTesting" to explain the semantics better (what are
"run options"?) and not repeat types in the function name
("ForLanguage").

[sammccall]

Agree with the rationale about moving the names out of clang::ast_matchers, and the names not being safe to put into clang:: as-is.

The names are a bit unwieldy though, and I wonder if all of them are patterns we want to encourage using widely (at least if so, the names become more important).

I'd consider:

• Unittest -> Test (shorter, and unit test is two words, and llvm naming conventions notwithstanding many gtests are not unit tests)
• moving into a clang::test namespace instead of prefixing the names
• UnitTestClangArgs --> std::vector<std::string> it's harder to parse but much more widely understood

Anyway, don't want to block this, this is an important step to sharing which is worthwhile whether the names are my favourite or not :-)

clang/unittests/AST/Language.h

24

this enum doesn't seem great: why is the default CXX (presumably) 98? How do you get objc++ with 14 features?

(No need to address this now, but it's not clear this is a great API to spread more widely. Vs e.g.

struct TestLanguage {
  static TestLanguage CXX; // some arbitrary version
  static TestLanguage C;
  
  enum {
    CXX98,
    CXX11,
  } CXXVersion;

  vector<string> getCommandLineArgs();
}

[martong]

Thank you for working on this.

moving into a clang::test namespace instead of prefixing the names

+1 for this. We could go even further: clang::test::ast or clang::unittest::ast.

clang/unittests/AST/Language.h

24

Yes I agree. However, in the ASTImporter tests we didn't need to select multiple languages for one test case (yet). I think later if we need that case then we can address this.

[martong]

Just out of curiosity. In what way do you prepare to share these test? For which component are you planning to reuse this test infrastructure?

[gribozavr]

Addressed review feedback.

[gribozavr2]

In D80786#2062557, @sammccall wrote:

• Unittest -> Test (shorter, and unit test is two words, and llvm naming conventions notwithstanding many gtests are not unit tests)

Done.

• UnitTestClangArgs --> std::vector<std::string> it's harder to parse but much more widely understood

Done. I also wanted to expand the typedef, but didn't do it because I didn't want to make this change controversial.

• moving into a clang::test namespace instead of prefixing the names

Nested namespaces with names that can appear in other namespaces ("test") are a trap in C++: https://abseil.io/tips/130. This might not be a problem within the llvm-project.git code itself, but Clang is used as a library in a lot of other software.

clang/unittests/AST/Language.h

24

Oh I absolutely agree -- I think we need a way to describe a lot more than just the language standard. Feature flags (like Objective-C, delayed template parsing etc.) should compose with each other.

I'm thinking it should be somewhat similar to the LangOptions struct, but be much friendlier for unit tests, the testing library should provide a bunch of presets that imitate important platforms (for example, 32-bit Linux, 64-bit Linux, macOS, iOS, Windows with delayed template parsing etc.)

However, we have to take this one step at a time.

[gribozavr]

Changed description.

[gribozavr2]

In D80786#2062634, @martong wrote:

Just out of curiosity. In what way do you prepare to share these test? For which component are you planning to reuse this test infrastructure?

Tests in clang/unittests/Tooling/Syntax/TreeTest.cpp have similar needs. In fact, I think pretty much all Clang unittests that start by parsing a string of source code into a translation unit need such infrastructure.

[martong]

Thanks! LGTM!

clang/unittests/AST/ASTImporterFixtures.h

void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
                                StringRef Code);
 
 // Common base for the different families of ASTImporter tests that are
 // parameterized on the compiler options which may result a different AST. E.g.
 // -fms-compatibility or -fdelayed-template-parsing.
 class CompilerOptionSpecificTest : public ::testing::Test {
 protected:
   // Return the extra arguments appended to runtime options at compilation.
-  virtual ArgVector getExtraArgs() const { return ArgVector(); }
+  virtual std::vector<std::string> getExtraArgs() const { return {}; }
 
   // Returns the argument vector used for a specific language option, this set
   // can be tweaked by the test parameters.
-  ArgVector getArgVectorForLanguage(Language Lang) const {
-    ArgVector Args = getBasicRunOptionsForLanguage(Lang);
-    ArgVector ExtraArgs = getExtraArgs();
+  std::vector<std::string>
+  getCommandLineArgsForLanguage(TestLanguage Lang) const {
+    std::vector<std::string> Args = getCommandLineArgsForTesting(Lang);
+    std::vector<std::string> ExtraArgs = getExtraArgs();
     for (const auto &Arg : ExtraArgs) {
       Args.push_back(Arg);
     }
     return Args;
   }
 };
 
-const auto DefaultTestArrayForRunOptions = std::array<ArgVector, 4>{
-    {ArgVector(), ArgVector{"-fdelayed-template-parsing"},
-     ArgVector{"-fms-compatibility"},
-     ArgVector{"-fdelayed-template-parsing", "-fms-compatibility"}}};
+const auto DefaultTestArrayForRunOptions =
+    std::array<std::vector<std::string>, 4>{
+        {std::vector<std::string>(),
+         std::vector<std::string>{"-fdelayed-template-parsing"},
+         std::vector<std::string>{"-fms-compatibility"},
+         std::vector<std::string>{"-fdelayed-template-parsing",
+                                  "-fms-compatibility"}}};
 
 const auto DefaultTestValuesForRunOptions =
     ::testing::ValuesIn(DefaultTestArrayForRunOptions);
 
 // This class provides generic methods to write tests which can check internal
 // attributes of AST nodes like getPreviousDecl(), isVirtual(), etc. Also,
 // this fixture makes it possible to import from several "From" contexts.
 class ASTImporterTestBase : public CompilerOptionSpecificTest {
struct TU {
     std::string Code;
     std::string FileName;
     std::unique_ptr<ASTUnit> Unit;
     TranslationUnitDecl *TUDecl = nullptr;
     std::unique_ptr<ASTImporter> Importer;
     ImporterConstructor Creator;
     ASTImporter::ODRHandlingType ODRHandling;
 
-    TU(StringRef Code, StringRef FileName, ArgVector Args,
+    TU(StringRef Code, StringRef FileName, std::vector<std::string> Args,
        ImporterConstructor C = ImporterConstructor(),
        ASTImporter::ODRHandlingType ODRHandling =
            ASTImporter::ODRHandlingType::Conservative);
     ~TU();
 
     void
     lazyInitImporter(const std::shared_ptr<ASTImporterSharedState> &SharedState,
                      ASTUnit *ToAST);
private:
   // moving of the stored objects because that would mean breaking the
   // references in the AST. By using a vector a move could happen when the
   // vector is expanding, with the list we won't have these issues.
   std::list<TU> FromTUs;
 
   // Initialize the shared state if not initialized already.
   void lazyInitSharedState(TranslationUnitDecl *ToTU);
 
-  void lazyInitToAST(Language ToLang, StringRef ToSrcCode, StringRef FileName);
+  void lazyInitToAST(TestLanguage ToLang, StringRef ToSrcCode,
+                     StringRef FileName);
 
 protected:
   std::shared_ptr<ASTImporterSharedState> SharedStatePtr;
 
 public:
   // We may have several From context but only one To context.
   std::unique_ptr<ASTUnit> ToAST;
 
   // Returns with the TU associated with the given Decl.
   TU *findFromTU(Decl *From);
 
   // Creates an AST both for the From and To source code and imports the Decl
   // of the identifier into the To context.
   // Must not be called more than once within the same test.
   std::tuple<Decl *, Decl *>
-  getImportedDecl(StringRef FromSrcCode, Language FromLang, StringRef ToSrcCode,
-                  Language ToLang, StringRef Identifier = DeclToImportID);
+  getImportedDecl(StringRef FromSrcCode, TestLanguage FromLang,
+                  StringRef ToSrcCode, TestLanguage ToLang,
+                  StringRef Identifier = DeclToImportID);
 
   // Creates a TU decl for the given source code which can be used as a From
   // context.  May be called several times in a given test (with different file
   // name).
-  TranslationUnitDecl *getTuDecl(StringRef SrcCode, Language Lang,
+  TranslationUnitDecl *getTuDecl(StringRef SrcCode, TestLanguage Lang,
                                  StringRef FileName = "input.cc");
 
   // Creates the To context with the given source code and returns the TU decl.
-  TranslationUnitDecl *getToTuDecl(StringRef ToSrcCode, Language ToLang);
+  TranslationUnitDecl *getToTuDecl(StringRef ToSrcCode, TestLanguage ToLang);
 
   // Import the given Decl into the ToCtx.
   // May be called several times in a given test.
   // The different instances of the param From may have different ASTContext.
-  Decl *Import(Decl *From, Language ToLang);
+  Decl *Import(Decl *From, TestLanguage ToLang);
 
-  template <class DeclT> DeclT *Import(DeclT *From, Language Lang) {
+  template <class DeclT> DeclT *Import(DeclT *From, TestLanguage Lang) {
     return cast_or_null<DeclT>(Import(cast<Decl>(From), Lang));
   }
 
   // Import the given Decl into the ToCtx.
   // Same as Import but returns the result of the import which can be an error.
-  llvm::Expected<Decl *> importOrError(Decl *From, Language ToLang);
+  llvm::Expected<Decl *> importOrError(Decl *From, TestLanguage ToLang);
 
-  QualType ImportType(QualType FromType, Decl *TUDecl, Language ToLang);
+  QualType ImportType(QualType FromType, Decl *TUDecl, TestLanguage ToLang);
 
   ASTImporterTestBase()
       : ODRHandling(ASTImporter::ODRHandlingType::Conservative) {}
   ~ASTImporterTestBase();
 };
 
 class ASTImporterOptionSpecificTestBase
     : public ASTImporterTestBase,
-      public ::testing::WithParamInterface<ArgVector> {
+      public ::testing::WithParamInterface<std::vector<std::string>> {
 protected:
-  ArgVector getExtraArgs() const override { return GetParam(); }
+  std::vector<std::string> getExtraArgs() const override { return GetParam(); }
 };
 
 template <class T>
 ::testing::AssertionResult isSuccess(llvm::Expected<T> &ValOrErr) {
   if (ValOrErr)
     return ::testing::AssertionSuccess() << "Expected<> contains no error.";
   else
     return ::testing::AssertionFailure()

clang/unittests/AST/ASTImporterFixtures.cpp

 }
 
 void createVirtualFileIfNeeded(ASTUnit *ToAST, StringRef FileName,
                                StringRef Code) {
   return createVirtualFileIfNeeded(ToAST, FileName,
                                    llvm::MemoryBuffer::getMemBuffer(Code));
 }
 
-ASTImporterTestBase::TU::TU(StringRef Code, StringRef FileName, ArgVector Args,
+ASTImporterTestBase::TU::TU(StringRef Code, StringRef FileName,
+                            std::vector<std::string> Args,
                             ImporterConstructor C,
                             ASTImporter::ODRHandlingType ODRHandling)
     : Code(std::string(Code)), FileName(std::string(FileName)),
       Unit(tooling::buildASTFromCodeWithArgs(this->Code, Args, this->FileName)),
       TUDecl(Unit->getASTContext().getTranslationUnitDecl()), Creator(C),
       ODRHandling(ODRHandling) {
   Unit->enableSourceFileDiagnostics();
 

 }
 
 void ASTImporterTestBase::lazyInitSharedState(TranslationUnitDecl *ToTU) {
   assert(ToTU);
   if (!SharedStatePtr)
     SharedStatePtr = std::make_shared<ASTImporterSharedState>(*ToTU);
 }
 
-void ASTImporterTestBase::lazyInitToAST(Language ToLang, StringRef ToSrcCode,
+void ASTImporterTestBase::lazyInitToAST(TestLanguage ToLang,
+                                        StringRef ToSrcCode,
                                         StringRef FileName) {
   if (ToAST)
     return;
-  ArgVector ToArgs = getArgVectorForLanguage(ToLang);
+  std::vector<std::string> ToArgs = getCommandLineArgsForLanguage(ToLang);
   // Source code must be a valid live buffer through the tests lifetime.
   ToCode = std::string(ToSrcCode);
   // Build the AST from an empty file.
   ToAST = tooling::buildASTFromCodeWithArgs(ToCode, ToArgs, FileName);
   ToAST->enableSourceFileDiagnostics();
   lazyInitSharedState(ToAST->getASTContext().getTranslationUnitDecl());
 }
 
 ASTImporterTestBase::TU *ASTImporterTestBase::findFromTU(Decl *From) {
   // Create a virtual file in the To Ctx which corresponds to the file from
   // which we want to import the `From` Decl. Without this source locations
   // will be invalid in the ToCtx.
   auto It = llvm::find_if(FromTUs, [From](const TU &E) {
     return E.TUDecl == From->getTranslationUnitDecl();
   });
   assert(It != FromTUs.end());
   return &*It;
 }
 
-std::tuple<Decl *, Decl *>
-ASTImporterTestBase::getImportedDecl(StringRef FromSrcCode, Language FromLang,
-                                     StringRef ToSrcCode, Language ToLang,
-                                     StringRef Identifier) {
-  ArgVector FromArgs = getArgVectorForLanguage(FromLang),
-            ToArgs = getArgVectorForLanguage(ToLang);
+std::tuple<Decl *, Decl *> ASTImporterTestBase::getImportedDecl(
+    StringRef FromSrcCode, TestLanguage FromLang, StringRef ToSrcCode,
+    TestLanguage ToLang, StringRef Identifier) {
+  std::vector<std::string> FromArgs = getCommandLineArgsForLanguage(FromLang);
+  std::vector<std::string> ToArgs = getCommandLineArgsForLanguage(ToLang);
 
   FromTUs.emplace_back(FromSrcCode, InputFileName, FromArgs, Creator,
                        ODRHandling);
   TU &FromTU = FromTUs.back();
 
   assert(!ToAST);
   lazyInitToAST(ToLang, ToSrcCode, OutputFileName);
 
std::tuple<Decl *, Decl *> ASTImporterTestBase::getImportedDecl(
   Decl *Imported =
       FromTU.import(SharedStatePtr, ToAST.get(), FoundDecls.front());
 
   assert(Imported);
   return std::make_tuple(*FoundDecls.begin(), Imported);
 }
 
 TranslationUnitDecl *ASTImporterTestBase::getTuDecl(StringRef SrcCode,
-                                                    Language Lang,
+                                                    TestLanguage Lang,
                                                     StringRef FileName) {
   assert(llvm::find_if(FromTUs, [FileName](const TU &E) {
            return E.FileName == FileName;
          }) == FromTUs.end());
 
-  ArgVector Args = getArgVectorForLanguage(Lang);
+  std::vector<std::string> Args = getCommandLineArgsForLanguage(Lang);
   FromTUs.emplace_back(SrcCode, FileName, Args, Creator, ODRHandling);
   TU &Tu = FromTUs.back();
 
   return Tu.TUDecl;
 }
 
 TranslationUnitDecl *ASTImporterTestBase::getToTuDecl(StringRef ToSrcCode,
-                                                      Language ToLang) {
-  ArgVector ToArgs = getArgVectorForLanguage(ToLang);
+                                                      TestLanguage ToLang) {
+  std::vector<std::string> ToArgs = getCommandLineArgsForLanguage(ToLang);
   assert(!ToAST);
   lazyInitToAST(ToLang, ToSrcCode, OutputFileName);
   return ToAST->getASTContext().getTranslationUnitDecl();
 }
 
-Decl *ASTImporterTestBase::Import(Decl *From, Language ToLang) {
+Decl *ASTImporterTestBase::Import(Decl *From, TestLanguage ToLang) {
   lazyInitToAST(ToLang, "", OutputFileName);
   TU *FromTU = findFromTU(From);
   assert(SharedStatePtr);
   Decl *To = FromTU->import(SharedStatePtr, ToAST.get(), From);
   return To;
 }
 
 llvm::Expected<Decl *> ASTImporterTestBase::importOrError(Decl *From,
-                                                          Language ToLang) {
+                                                          TestLanguage ToLang) {
   lazyInitToAST(ToLang, "", OutputFileName);
   TU *FromTU = findFromTU(From);
   assert(SharedStatePtr);
   llvm::Expected<Decl *> To =
       FromTU->importOrError(SharedStatePtr, ToAST.get(), From);
   return To;
 }
 
 QualType ASTImporterTestBase::ImportType(QualType FromType, Decl *TUDecl,
-                                         Language ToLang) {
+                                         TestLanguage ToLang) {
   lazyInitToAST(ToLang, "", OutputFileName);
   TU *FromTU = findFromTU(TUDecl);
   assert(SharedStatePtr);
   return FromTU->import(SharedStatePtr, ToAST.get(), FromType);
 }
 
 ASTImporterTestBase::~ASTImporterTestBase() {
   if (!::testing::Test::HasFailure())

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()));
   }
-  Language getLang() { return Lang_C; }
+  TestLanguage getLang() { return Lang_C; }
 };
 
 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")); }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 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")); }
-  Language getLang() { return Lang_CXX11; }
+  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")); }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 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")); }
-  Language getLang() { return Lang_CXX11; }
+  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")); }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 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()));
   }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 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")); }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 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()));
   }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 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; }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 static const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateDecl>
     varTemplateDecl;
 
 struct VarTemplate {
   using DeclTy = VarTemplateDecl;
   static constexpr auto *Definition =
       R"(
       template <class T>
       constexpr T X = 0;
       )";
   static constexpr auto *ConflictingDefinition =
       R"(
       template <int>
       constexpr int X = 0;
       )";
   BindableMatcher<Decl> getPattern() { return varTemplateDecl(hasName("X")); }
-  Language getLang() { return Lang_CXX14; }
+  TestLanguage getLang() { return Lang_CXX14; }
 };
 
 struct ClassTemplateSpec {
   using DeclTy = ClassTemplateSpecializationDecl;
   static constexpr auto *Prototype =
       R"(
       template <class T> class X;
       template <> class X<int>;
       )";
   static constexpr auto *Definition =
       R"(
       template <class T> class X;
       template <> class X<int> {};
       )";
   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()));
   }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 // 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; }
-  Language getLang() { return Lang_CXX; }
+  TestLanguage getLang() { return Lang_CXX; }
 };
 
 static const internal::VariadicDynCastAllOfMatcher<
     Decl, VarTemplateSpecializationDecl>
     varTemplateSpecializationDecl;
 
 struct VarTemplateSpec {
   using DeclTy = VarTemplateSpecializationDecl;
   static constexpr auto *Definition =
       R"(
       template <class T> T X = 0;
       template <> int X<int> = 0;
       )";
   static constexpr auto *ConflictingDefinition =
       R"(
       template <class T> T X = 0;
       template <> float X<int> = 1.0;
       )";
   BindableMatcher<Decl> getPattern() {
     return varTemplateSpecializationDecl(hasName("X"), unless(isImplicit()));
   }
-  Language getLang() { return Lang_CXX14; }
+  TestLanguage getLang() { return Lang_CXX14; }
 };
 
 template <typename TypeParam, ASTImporter::ODRHandlingType ODRHandlingParam>
 struct ODRViolation : ASTImporterOptionSpecificTestBase {
 
   using DeclTy = typename TypeParam::DeclTy;
 
   ODRViolation() { ODRHandling = ODRHandlingParam; }
 
   static std::string getPrototype() { return TypeParam::Prototype; }
   static std::string getConflictingPrototype() {
     return TypeParam::ConflictingPrototype;
   }
   static std::string getDefinition() { return TypeParam::Definition; }
   static std::string getConflictingDefinition() {
     return TypeParam::ConflictingDefinition;
   }
   static std::string getConflictingProtoDef() {
     return TypeParam::ConflictingProtoDef;
   }
   static BindableMatcher<Decl> getPattern() { return TypeParam().getPattern(); }
-  static Language getLang() { return TypeParam().getLang(); }
+  static TestLanguage getLang() { return TypeParam().getLang(); }
 
   template <std::string (*ToTUContent)(), std::string (*FromTUContent)(),
             void (*ResultChecker)(llvm::Expected<Decl *> &, Decl *, Decl *)>
   void TypedTest_ImportAfter() {
     Decl *ToTU = getToTuDecl(ToTUContent(), getLang());
     auto *ToD = FirstDeclMatcher<DeclTy>().match(ToTU, getPattern());
 
     Decl *FromTU = getTuDecl(FromTUContent(), getLang());

clang/unittests/AST/ASTImporterTest.cpp

 namespace clang {
 namespace ast_matchers {
 
 using internal::Matcher;
 using internal::BindableMatcher;
 using llvm::StringMap;
 
 // Base class for those tests which use the family of `testImport` functions.
-class TestImportBase : public CompilerOptionSpecificTest,
-                       public ::testing::WithParamInterface<ArgVector> {
+class TestImportBase
+    : public CompilerOptionSpecificTest,
+      public ::testing::WithParamInterface<std::vector<std::string>> {
 
   template <typename NodeType>
   llvm::Expected<NodeType> importNode(ASTUnit *From, ASTUnit *To,
                                       ASTImporter &Importer, NodeType Node) {
     ASTContext &ToCtx = To->getASTContext();
 
     // Add 'From' file to virtual file system so importer can 'find' it
     // while importing SourceLocations. It is safe to add same file multiple
if (Imported) {
       (*Imported)->dump(ToNothing);
     }
 
     return Imported;
   }
 
   template <typename NodeType>
   testing::AssertionResult
-  testImport(const std::string &FromCode, const ArgVector &FromArgs,
-             const std::string &ToCode, const ArgVector &ToArgs,
+  testImport(const std::string &FromCode,
+             const std::vector<std::string> &FromArgs,
+             const std::string &ToCode, const std::vector<std::string> &ToArgs,
              MatchVerifier<NodeType> &Verifier,
              const BindableMatcher<NodeType> &SearchMatcher,
              const BindableMatcher<NodeType> &VerificationMatcher) {
     const char *const InputFileName = "input.cc";
     const char *const OutputFileName = "output.cc";
 
     std::unique_ptr<ASTUnit> FromAST = tooling::buildASTFromCodeWithArgs(
                                  FromCode, FromArgs, InputFileName),
if (!Imported) {
              << "Import failed, error: \"" << ErrorText << "\"!";
     }
 
     return Verifier.match(*Imported, WrapperMatcher);
   }
 
   template <typename NodeType>
   testing::AssertionResult
-  testImport(const std::string &FromCode, const ArgVector &FromArgs,
-             const std::string &ToCode, const ArgVector &ToArgs,
+  testImport(const std::string &FromCode,
+             const std::vector<std::string> &FromArgs,
+             const std::string &ToCode, const std::vector<std::string> &ToArgs,
              MatchVerifier<NodeType> &Verifier,
              const BindableMatcher<NodeType> &VerificationMatcher) {
     return testImport(
         FromCode, FromArgs, ToCode, ToArgs, Verifier,
         translationUnitDecl(
             has(namedDecl(hasName(DeclToImportID)).bind(DeclToImportID))),
         VerificationMatcher);
   }
 
 protected:
-  ArgVector getExtraArgs() const override { return GetParam(); }
+  std::vector<std::string> getExtraArgs() const override { return GetParam(); }
 
 public:
 
   /// Test how AST node named "declToImport" located in the translation unit
   /// of "FromCode" virtual file is imported to "ToCode" virtual file.
   /// The verification is done by running AMatcher over the imported node.
   template <typename NodeType, typename MatcherType>
-  void testImport(const std::string &FromCode, Language FromLang,
-                  const std::string &ToCode, Language ToLang,
+  void testImport(const std::string &FromCode, TestLanguage FromLang,
+                  const std::string &ToCode, TestLanguage ToLang,
                   MatchVerifier<NodeType> &Verifier,
                   const MatcherType &AMatcher) {
-    ArgVector FromArgs = getArgVectorForLanguage(FromLang),
-              ToArgs = getArgVectorForLanguage(ToLang);
+    std::vector<std::string> FromArgs = getCommandLineArgsForLanguage(FromLang);
+    std::vector<std::string> ToArgs = getCommandLineArgsForLanguage(ToLang);
     EXPECT_TRUE(
         testImport(FromCode, FromArgs, ToCode, ToArgs, Verifier, AMatcher));
   }
 
   struct ImportAction {
     StringRef FromFilename;
     StringRef ToFilename;
     // FIXME: Generalize this to support other node kinds.
ImportAction(StringRef FromFilename, StringRef ToFilename,
           ImportPredicate(namedDecl(hasName(DeclName))) {}
   };
 
   using SingleASTUnit = std::unique_ptr<ASTUnit>;
   using AllASTUnits = StringMap<SingleASTUnit>;
 
   struct CodeEntry {
     std::string CodeSample;
-    Language Lang;
+    TestLanguage Lang;
   };
 
   using CodeFiles = StringMap<CodeEntry>;
 
   /// Builds an ASTUnit for one potential compile options set.
   SingleASTUnit createASTUnit(StringRef FileName, const CodeEntry &CE) const {
-    ArgVector Args = getArgVectorForLanguage(CE.Lang);
+    std::vector<std::string> Args = getCommandLineArgsForLanguage(CE.Lang);
     auto AST = tooling::buildASTFromCodeWithArgs(CE.CodeSample, Args, FileName);
     EXPECT_TRUE(AST.get());
     return AST;
   }
 
   /// Test an arbitrary sequence of imports for a set of given in-memory files.
   /// The verification is done by running VerificationMatcher against a
   /// specified AST node inside of one of given files.
TEST_P(ASTImporterOptionSpecificTestBase,
   ASSERT_TRUE(ImportedX);
   EXPECT_TRUE(Constr1->isDefaulted());
   EXPECT_TRUE(Constr1->isExplicitlyDefaulted());
   EXPECT_TRUE(Constr2->isDeletedAsWritten());
   EXPECT_EQ(ImportedX->isAggregate(), FromX->isAggregate());
 }
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, SVEBuiltins,
-                        ::testing::Values(ArgVector{"-target",
-                                                    "aarch64-linux-gnu"}), );
+                        ::testing::Values(std::vector<std::string>{
+                            "-target", "aarch64-linux-gnu"}), );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, DeclContextTest,
-                        ::testing::Values(ArgVector()), );
+                        ::testing::Values(std::vector<std::string>()), );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, CanonicalRedeclChain,
-                        ::testing::Values(ArgVector()), );
+                        ::testing::Values(std::vector<std::string>()), );
 
 TEST_P(ASTImporterOptionSpecificTestBase, LambdasAreDifferentiated) {
   Decl *FromTU = getTuDecl(
       R"(
       void f() {
         auto L0 = [](){};
         auto L1 = [](){};
       }
auto *ToA = FirstDeclMatcher<CXXRecordDecl>().match(
       ToD->getTranslationUnitDecl(),
       cxxRecordDecl(hasName("A"), unless(isImplicit())));
   // Ensure that 'struct A' was imported (through reference from attribute of
   // 'S').
   EXPECT_TRUE(ToA);
 }
 
 template <typename T>
-auto ExtendWithOptions(const T &Values, const ArgVector &Args) {
+auto ExtendWithOptions(const T &Values, const std::vector<std::string> &Args) {
   auto Copy = Values;
-  for (ArgVector &ArgV : Copy) {
+  for (std::vector<std::string> &ArgV : Copy) {
     for (const std::string &Arg : Args) {
       ArgV.push_back(Arg);
     }
   }
   return ::testing::ValuesIn(Copy);
 }
 
 struct ImportWithExternalSource : ASTImporterOptionSpecificTestBase {
TEST_P(ImportWithExternalSource, CompleteRecordBeforeImporting) {
   EXPECT_EQ(1U, CompletedTags.size());
   EXPECT_EQ(Record, CompletedTags.front());
 }
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterLookupTableTest,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportPath,
-                        ::testing::Values(ArgVector()), );
+                        ::testing::Values(std::vector<std::string>()), );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportExpr,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportFixedPointExpr,
                         ExtendWithOptions(DefaultTestArrayForRunOptions,
-                                          ArgVector{"-ffixed-point"}), );
+                                          std::vector<std::string>{
+                                              "-ffixed-point"}), );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportType,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportDecl,
                         DefaultTestValuesForRunOptions, );
 
 INSTANTIATE_TEST_CASE_P(ParameterizedTests, ASTImporterOptionSpecificTestBase,

clang/unittests/AST/ASTImporterVisibilityTest.cpp

 const auto *StaticVT = "template <class> static int v;";
 const auto *AnonVT = "namespace { template <class> extern int v; }";
 // ClassTemplateDecl:
 const auto *ExternCT = "template <class> class X;";
 const auto *AnonCT = "namespace { template <class> class X; }";
 
 // First value in tuple: Compile options.
 // Second value in tuple: Source code to be used in the test.
-using ImportVisibilityChainParams =
-    ::testing::WithParamInterface<std::tuple<ArgVector, const char *>>;
+using ImportVisibilityChainParams = ::testing::WithParamInterface<
+    std::tuple<std::vector<std::string>, const char *>>;
 // Fixture to test the redecl chain of Decls with the same visibility. Gtest
 // makes it possible to have either value-parameterized or type-parameterized
 // fixtures. However, we cannot have both value- and type-parameterized test
 // fixtures. This is a value-parameterized test fixture in the gtest sense. We
 // intend to mimic gtest's type-parameters via the PatternFactory template
 // parameter. We manually instantiate the different tests with the each types.
 template <typename PatternFactory>
 class ImportVisibilityChain
     : public ASTImporterTestBase, public ImportVisibilityChainParams {
 protected:
   using DeclTy = typename PatternFactory::DeclTy;
-  ArgVector getExtraArgs() const override { return std::get<0>(GetParam()); }
+  std::vector<std::string> getExtraArgs() const override {
+    return std::get<0>(GetParam());
+  }
   std::string getCode() const { return std::get<1>(GetParam()); }
   BindableMatcher<Decl> getPattern() const { return PatternFactory()(); }
 
   // Type-parameterized test.
   void TypedTest_ImportChain() {
     std::string Code = getCode() + getCode();
     auto Pattern = getPattern();
 
INSTANTIATE_TEST_CASE_P(ParameterizedTests, ImportClassTemplatesVisibilityChain,
                                                              AnonCT)), );
 
 // First value in tuple: Compile options.
 // Second value in tuple: Tuple with informations for the test.
 // Code for first import (or initial code), code to import, whether the `f`
 // functions are expected to be linked in a declaration chain.
 // One value of this tuple is combined with every value of compile options.
 // The test can have a single tuple as parameter only.
-using ImportVisibilityParams = ::testing::WithParamInterface<
-    std::tuple<ArgVector, std::tuple<const char *, const char *, bool>>>;
+using ImportVisibilityParams = ::testing::WithParamInterface<std::tuple<
+    std::vector<std::string>, std::tuple<const char *, const char *, bool>>>;
 
 template <typename PatternFactory>
 class ImportVisibility
     : public ASTImporterTestBase,
       public ImportVisibilityParams {
 protected:
   using DeclTy = typename PatternFactory::DeclTy;
-  ArgVector getExtraArgs() const override { return std::get<0>(GetParam()); }
+  std::vector<std::string> getExtraArgs() const override {
+    return std::get<0>(GetParam());
+  }
   std::string getCode0() const { return std::get<0>(std::get<1>(GetParam())); }
   std::string getCode1() const { return std::get<1>(std::get<1>(GetParam())); }
   bool shouldBeLinked() const { return std::get<2>(std::get<1>(GetParam())); }
   BindableMatcher<Decl> getPattern() const { return PatternFactory()(); }
 
   void TypedTest_ImportAfter() {
     TranslationUnitDecl *ToTu = getToTuDecl(getCode0(), Lang_CXX14);
     TranslationUnitDecl *FromTu =

clang/unittests/AST/Language.h

 //===------ unittest/AST/Language.h - AST unit test support ---------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines language options for AST unittests.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_UNITTESTS_AST_LANGUAGE_H
 #define LLVM_CLANG_UNITTESTS_AST_LANGUAGE_H
 
-#include "llvm/Support/ErrorHandling.h"
 #include <vector>
 #include <string>
 
 namespace clang {
-namespace ast_matchers {
 
-typedef std::vector<std::string> ArgVector;
-
-enum Language {
-    Lang_C,
-    Lang_C89,
-    Lang_CXX,
-    Lang_CXX11,
-    Lang_CXX14,
-    Lang_CXX17,
-    Lang_CXX2a,
-    Lang_OpenCL,
-    Lang_OBJCXX
+enum TestLanguage {
 };
 
-ArgVector getBasicRunOptionsForLanguage(Language Lang);
+std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang);
 
-} // end namespace ast_matchers
 } // end namespace clang
 
 #endif

clang/unittests/AST/Language.cpp

 //===------ unittest/AST/Language.cpp - AST unit test support -------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines language options for AST unittests.
 //
 //===----------------------------------------------------------------------===//
 
 #include "Language.h"
+#include "llvm/Support/ErrorHandling.h"
 
 namespace clang {
-namespace ast_matchers {
 
-ArgVector getBasicRunOptionsForLanguage(Language Lang) {
-  ArgVector BasicArgs;
+std::vector<std::string> getCommandLineArgsForTesting(TestLanguage Lang) {
+  std::vector<std::string> Args;
   // Test with basic arguments.
   switch (Lang) {
   case Lang_C:
-    BasicArgs = {"-x", "c", "-std=c99"};
+    Args = {"-x", "c", "-std=c99"};
     break;
   case Lang_C89:
-    BasicArgs = {"-x", "c", "-std=c89"};
+    Args = {"-x", "c", "-std=c89"};
     break;
   case Lang_CXX:
-    BasicArgs = {"-std=c++98", "-frtti"};
+    Args = {"-std=c++98", "-frtti"};
     break;
   case Lang_CXX11:
-    BasicArgs = {"-std=c++11", "-frtti"};
+    Args = {"-std=c++11", "-frtti"};
     break;
   case Lang_CXX14:
-    BasicArgs = {"-std=c++14", "-frtti"};
+    Args = {"-std=c++14", "-frtti"};
     break;
   case Lang_CXX17:
-    BasicArgs = {"-std=c++17", "-frtti"};
+    Args = {"-std=c++17", "-frtti"};
     break;
   case Lang_CXX2a:
-    BasicArgs = {"-std=c++2a", "-frtti"};
+    Args = {"-std=c++2a", "-frtti"};
     break;
   case Lang_OBJCXX:
-    BasicArgs = {"-x", "objective-c++", "-frtti"};
+    Args = {"-x", "objective-c++", "-frtti"};
     break;
   case Lang_OpenCL:
     llvm_unreachable("Not implemented yet!");
   }
-  return BasicArgs;
+  return Args;
 }
 
-} // end namespace ast_matchers
 } // end namespace clang

clang/unittests/AST/MatchVerifier.h

public:
   testing::AssertionResult match(const std::string &Code,
                                  const MatcherType &AMatcher) {
     std::vector<std::string> Args;
     return match(Code, AMatcher, Args, Lang_CXX);
   }
 
   template <typename MatcherType>
   testing::AssertionResult match(const std::string &Code,
-                                 const MatcherType &AMatcher,
-                                 Language L) {
+                                 const MatcherType &AMatcher, TestLanguage L) {
     std::vector<std::string> Args;
     return match(Code, AMatcher, Args, L);
   }
 
   template <typename MatcherType>
-  testing::AssertionResult match(const std::string &Code,
-                                 const MatcherType &AMatcher,
-                                 std::vector<std::string>& Args,
-                                 Language L);
+  testing::AssertionResult
+  match(const std::string &Code, const MatcherType &AMatcher,
+        std::vector<std::string> &Args, TestLanguage L);
 
   template <typename MatcherType>
   testing::AssertionResult match(const Decl *D, const MatcherType &AMatcher);
 
 protected:
   void run(const MatchFinder::MatchResult &Result) override;
   virtual void verify(const MatchFinder::MatchResult &Result,
                       const NodeType &Node) {}

 
 private:
   bool Verified;
   std::string VerifyResult;
 };
 
 /// \brief Runs a matcher over some code, and returns the result of the
 /// verifier for the matched node.
-template <typename NodeType> template <typename MatcherType>
-testing::AssertionResult MatchVerifier<NodeType>::match(
-    const std::string &Code, const MatcherType &AMatcher,
-    std::vector<std::string>& Args, Language L) {
+template <typename NodeType>
+template <typename MatcherType>
+testing::AssertionResult
+MatchVerifier<NodeType>::match(const std::string &Code,
+                               const MatcherType &AMatcher,
+                               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:

clang/unittests/AST/StructuralEquivalenceTest.cpp

 struct StructuralEquivalenceTest : ::testing::Test {
   std::unique_ptr<ASTUnit> AST0, AST1;
   std::string Code0, Code1; // Buffers for SourceManager
 
   // Get a pair of node pointers into the synthesized AST from the given code
   // snippets. To determine the returned node, a separate matcher is specified
   // for both snippets. The first matching node is returned.
   template <typename NodeType, typename MatcherType>
-  std::tuple<NodeType *, NodeType *> makeDecls(
-      const std::string &SrcCode0, const std::string &SrcCode1, Language Lang,
-      const MatcherType &Matcher0, const MatcherType &Matcher1) {
+  std::tuple<NodeType *, NodeType *>
+  makeDecls(const std::string &SrcCode0, const std::string &SrcCode1,
+            TestLanguage Lang, const MatcherType &Matcher0,
+            const MatcherType &Matcher1) {
     this->Code0 = SrcCode0;
     this->Code1 = SrcCode1;
-    ArgVector Args = getBasicRunOptionsForLanguage(Lang);
+    std::vector<std::string> Args = getCommandLineArgsForTesting(Lang);
 
     const char *const InputFileName = "input.cc";
 
     AST0 = tooling::buildASTFromCodeWithArgs(Code0, Args, InputFileName);
     AST1 = tooling::buildASTFromCodeWithArgs(Code1, Args, InputFileName);
 
     NodeType *D0 = FirstDeclMatcher<NodeType>().match(
         AST0->getASTContext().getTranslationUnitDecl(), Matcher0);
     NodeType *D1 = FirstDeclMatcher<NodeType>().match(
         AST1->getASTContext().getTranslationUnitDecl(), Matcher1);
 
     return std::make_tuple(D0, D1);
   }
 
-  std::tuple<TranslationUnitDecl *, TranslationUnitDecl *> makeTuDecls(
-      const std::string &SrcCode0, const std::string &SrcCode1, Language Lang) {
+  std::tuple<TranslationUnitDecl *, TranslationUnitDecl *>
+  makeTuDecls(const std::string &SrcCode0, const std::string &SrcCode1,
+              TestLanguage Lang) {
     this->Code0 = SrcCode0;
     this->Code1 = SrcCode1;
-    ArgVector Args = getBasicRunOptionsForLanguage(Lang);
+    std::vector<std::string> Args = getCommandLineArgsForTesting(Lang);
 
     const char *const InputFileName = "input.cc";
 
     AST0 = tooling::buildASTFromCodeWithArgs(Code0, Args, InputFileName);
     AST1 = tooling::buildASTFromCodeWithArgs(Code1, Args, InputFileName);
 
     return std::make_tuple(AST0->getASTContext().getTranslationUnitDecl(),
                            AST1->getASTContext().getTranslationUnitDecl());
   }
 
   // Get a pair of node pointers into the synthesized AST from the given code
   // snippets. The same matcher is used for both snippets.
   template <typename NodeType, typename MatcherType>
-  std::tuple<NodeType *, NodeType *> makeDecls(
-      const std::string &SrcCode0, const std::string &SrcCode1, Language Lang,
-      const MatcherType &AMatcher) {
+  std::tuple<NodeType *, NodeType *>
+  makeDecls(const std::string &SrcCode0, const std::string &SrcCode1,
+            TestLanguage Lang, const MatcherType &AMatcher) {
     return makeDecls<NodeType, MatcherType>(
           SrcCode0, SrcCode1, Lang, AMatcher, AMatcher);
   }
 
   // Get a pair of Decl pointers to the synthesized declarations from the given
   // code snippets. We search for the first NamedDecl with given name in both
   // snippets.
-  std::tuple<NamedDecl *, NamedDecl *> makeNamedDecls(
-      const std::string &SrcCode0, const std::string &SrcCode1,
-      Language Lang, const char *const Identifier = "foo") {
+  std::tuple<NamedDecl *, NamedDecl *>
+  makeNamedDecls(const std::string &SrcCode0, const std::string &SrcCode1,
+                 TestLanguage Lang, const char *const Identifier = "foo") {
     auto Matcher = namedDecl(hasName(Identifier));
     return makeDecls<NamedDecl>(SrcCode0, SrcCode1, Lang, Matcher);
   }
 
   bool testStructuralMatch(Decl *D0, Decl *D1) {
     llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls01;
     llvm::DenseSet<std::pair<Decl *, Decl *>> NonEquivalentDecls10;
     StructuralEquivalenceContext Ctx01(