Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case.

Summary:
Refactor "MatcherList" into "VariantMatcher" and abstract the notion of a list of matchers for the polymorphic case.
This work is to support future changes needed for eachOf/allOf/anyOf matchers. We will add a new type on VariantMatcher.

Reviewers: klimek

CC: cfe-commits, revane

Differential Revision: http://llvm-reviews.chandlerc.com/D1365

llvm-svn: 188272

1 files changed, 30 insertions, 23 deletions

diff --git a/clang/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp b/clang/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
index 625f70bd465..168741ca4d9 100644
--- a/clang/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
+++ b/clang/unittests/ASTMatchers/Dynamic/VariantValueTest.cpp
@@ -27,7 +27,7 @@ TEST(VariantValueTest, Unsigned) {
   EXPECT_EQ(kUnsigned, Value.getUnsigned());
 
   EXPECT_FALSE(Value.isString());
-  EXPECT_FALSE(Value.isMatchers());
+  EXPECT_FALSE(Value.isMatcher());
   EXPECT_FALSE(Value.hasTypedMatcher<Decl>());
   EXPECT_FALSE(Value.hasTypedMatcher<UnaryOperator>());
 }
@@ -41,29 +41,29 @@ TEST(VariantValueTest, String) {
   EXPECT_EQ("String", Value.getTypeAsString());
 
   EXPECT_FALSE(Value.isUnsigned());
-  EXPECT_FALSE(Value.isMatchers());
+  EXPECT_FALSE(Value.isMatcher());
 }
 
 TEST(VariantValueTest, DynTypedMatcher) {
-  VariantValue Value = stmt();
+  VariantValue Value = VariantMatcher::SingleMatcher(stmt());
 
   EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
 
-  EXPECT_TRUE(Value.isMatchers());
+  EXPECT_TRUE(Value.isMatcher());
   EXPECT_FALSE(Value.hasTypedMatcher<Decl>());
   EXPECT_TRUE(Value.hasTypedMatcher<UnaryOperator>());
   EXPECT_EQ("Matcher<Stmt>", Value.getTypeAsString());
 
   // Can only convert to compatible matchers.
-  Value = recordDecl();
-  EXPECT_TRUE(Value.isMatchers());
+  Value = VariantMatcher::SingleMatcher(recordDecl());
+  EXPECT_TRUE(Value.isMatcher());
   EXPECT_TRUE(Value.hasTypedMatcher<Decl>());
   EXPECT_FALSE(Value.hasTypedMatcher<UnaryOperator>());
   EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
 
-  Value = ignoringImpCasts(expr());
-  EXPECT_TRUE(Value.isMatchers());
+  Value = VariantMatcher::SingleMatcher(ignoringImpCasts(expr()));
+  EXPECT_TRUE(Value.isMatcher());
   EXPECT_FALSE(Value.hasTypedMatcher<Decl>());
   EXPECT_FALSE(Value.hasTypedMatcher<Stmt>());
   EXPECT_TRUE(Value.hasTypedMatcher<Expr>());
@@ -77,13 +77,13 @@ TEST(VariantValueTest, Assignment) {
   EXPECT_TRUE(Value.isString());
   EXPECT_EQ("A", Value.getString());
   EXPECT_FALSE(Value.isUnsigned());
-  EXPECT_FALSE(Value.isMatchers());
+  EXPECT_FALSE(Value.isMatcher());
   EXPECT_EQ("String", Value.getTypeAsString());
 
-  Value = recordDecl();
+  Value = VariantMatcher::SingleMatcher(recordDecl());
   EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
-  EXPECT_TRUE(Value.isMatchers());
+  EXPECT_TRUE(Value.isMatcher());
   EXPECT_TRUE(Value.hasTypedMatcher<Decl>());
   EXPECT_FALSE(Value.hasTypedMatcher<UnaryOperator>());
   EXPECT_EQ("Matcher<Decl>", Value.getTypeAsString());
@@ -91,39 +91,46 @@ TEST(VariantValueTest, Assignment) {
   Value = 17;
   EXPECT_TRUE(Value.isUnsigned());
   EXPECT_EQ(17U, Value.getUnsigned());
-  EXPECT_FALSE(Value.isMatchers());
+  EXPECT_FALSE(Value.isMatcher());
   EXPECT_FALSE(Value.isString());
 
   Value = VariantValue();
   EXPECT_FALSE(Value.isUnsigned());
   EXPECT_FALSE(Value.isString());
-  EXPECT_FALSE(Value.isMatchers());
+  EXPECT_FALSE(Value.isMatcher());
   EXPECT_EQ("Nothing", Value.getTypeAsString());
 }
 
 TEST(VariantValueTest, Matcher) {
-  EXPECT_TRUE(matches("class X {};", VariantValue(recordDecl(hasName("X")))
+  EXPECT_TRUE(matches("class X {};", VariantValue(VariantMatcher::SingleMatcher(
+                                                      recordDecl(hasName("X"))))
                                          .getTypedMatcher<Decl>()));
+  EXPECT_TRUE(matches("int x;",
+                      VariantValue(VariantMatcher::SingleMatcher(varDecl()))
+                          .getTypedMatcher<Decl>()));
   EXPECT_TRUE(
-      matches("int x;", VariantValue(varDecl()).getTypedMatcher<Decl>()));
-  EXPECT_TRUE(matches("int foo() { return 1 + 1; }",
-                      VariantValue(functionDecl()).getTypedMatcher<Decl>()));
+      matches("int foo() { return 1 + 1; }",
+              VariantValue(VariantMatcher::SingleMatcher(functionDecl()))
+                  .getTypedMatcher<Decl>()));
   // Can't get the wrong matcher.
-  EXPECT_FALSE(VariantValue(varDecl()).hasTypedMatcher<Stmt>());
+  EXPECT_FALSE(VariantValue(VariantMatcher::SingleMatcher(varDecl()))
+                   .hasTypedMatcher<Stmt>());
 #if !defined(NDEBUG) && GTEST_HAS_DEATH_TEST && !defined(_MSC_VER)
   // Trying to get the wrong matcher fails an assertion in Matcher<T>.  We don't
   // do this test when building with MSVC because its debug C runtime prints the
   // assertion failure message as a wide string, which gtest doesn't understand.
-  EXPECT_DEATH(VariantValue(varDecl()).getTypedMatcher<Stmt>(),
+  EXPECT_DEATH(VariantValue(VariantMatcher::SingleMatcher(varDecl()))
+                   .getTypedMatcher<Stmt>(),
                "hasTypedMatcher");
 #endif
 
-  EXPECT_FALSE(
-      matches("int x;", VariantValue(functionDecl()).getTypedMatcher<Decl>()));
+  EXPECT_FALSE(matches(
+      "int x;", VariantValue(VariantMatcher::SingleMatcher(functionDecl()))
+                    .getTypedMatcher<Decl>()));
   EXPECT_FALSE(
       matches("int foo() { return 1 + 1; }",
-
-              VariantValue(declRefExpr()).getTypedMatcher<Stmt>()));
+              VariantValue(VariantMatcher::SingleMatcher(declRefExpr()))
+                  .getTypedMatcher<Stmt>()));
 }
 
 } // end anonymous namespace