[clang][NFC] Move matcher ignoringElidableConstructorCall's tests to appropriate file.

[ymandel]

Summary

ignoringElidableConstructorCall is a traversal matcher, but its tests are
grouped with narrowing-matcher tests. This revision moves them to the correct
file.

[gribozavr]

Thanks!

cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

TEST(Matcher, BindMatchedNodes) {
   StatementMatcher MethodX =
     callExpr(callee(cxxMethodDecl(hasName("x")))).bind("x");
 
   EXPECT_TRUE(matchAndVerifyResultTrue("class A { void x() { x(); } };",
                                        MethodX,
                                        llvm::make_unique<VerifyIdIsBoundTo<CXXMemberCallExpr>>("x")));
 }
 
-TEST(Matcher, IgnoresElidableConstructors) {
-  EXPECT_TRUE(
-      matches("struct H {};"
-              "template<typename T> H B(T A);"
-              "void f() {"
-              "  H D1;"
-              "  D1 = B(B(1));"
-              "}",
-              cxxOperatorCallExpr(hasArgument(
-                  1, callExpr(hasArgument(
-                         0, ignoringElidableConstructorCall(callExpr()))))),
-              LanguageMode::Cxx11OrLater));
-  EXPECT_TRUE(
-      matches("struct H {};"
-              "template<typename T> H B(T A);"
-              "void f() {"
-              "  H D1;"
-              "  D1 = B(1);"
-              "}",
-              cxxOperatorCallExpr(hasArgument(
-                  1, callExpr(hasArgument(0, ignoringElidableConstructorCall(
-                                                 integerLiteral()))))),
-              LanguageMode::Cxx11OrLater));
-  EXPECT_TRUE(matches(
-      "struct H {};"
-      "H G();"
-      "void f() {"
-      "  H D = G();"
-      "}",
-      varDecl(hasInitializer(anyOf(
-          ignoringElidableConstructorCall(callExpr()),
-          exprWithCleanups(has(ignoringElidableConstructorCall(callExpr())))))),
-      LanguageMode::Cxx11OrLater));
-}
-
-TEST(Matcher, IgnoresElidableInReturn) {
-  auto matcher = expr(ignoringElidableConstructorCall(declRefExpr()));
-  EXPECT_TRUE(matches("struct H {};"
-                      "H f() {"
-                      "  H g;"
-                      "  return g;"
-                      "}",
-                      matcher, LanguageMode::Cxx11OrLater));
-  EXPECT_TRUE(notMatches("struct H {};"
-                         "H f() {"
-                         "  return H();"
-                         "}",
-                         matcher, LanguageMode::Cxx11OrLater));
-}
-
-TEST(Matcher, IgnoreElidableConstructorDoesNotMatchConstructors) {
-  EXPECT_TRUE(matches("struct H {};"
-                      "void f() {"
-                      "  H D;"
-                      "}",
-                      varDecl(hasInitializer(
-                          ignoringElidableConstructorCall(cxxConstructExpr()))),
-                      LanguageMode::Cxx11OrLater));
-}
-
-TEST(Matcher, IgnoresElidableDoesNotPreventMatches) {
-  EXPECT_TRUE(matches("void f() {"
-                      "  int D = 10;"
-                      "}",
-                      expr(ignoringElidableConstructorCall(integerLiteral())),
-                      LanguageMode::Cxx11OrLater));
-}
-
-TEST(Matcher, IgnoresElidableInVarInit) {
-  auto matcher =
-      varDecl(hasInitializer(ignoringElidableConstructorCall(callExpr())));
-  EXPECT_TRUE(matches("struct H {};"
-                      "H G();"
-                      "void f(H D = G()) {"
-                      "  return;"
-                      "}",
-                      matcher, LanguageMode::Cxx11OrLater));
-  EXPECT_TRUE(matches("struct H {};"
-                      "H G();"
-                      "void f() {"
-                      "  H D = G();"
-                      "}",
-                      matcher, LanguageMode::Cxx11OrLater));
-}
-
 TEST(Matcher, BindTheSameNameInAlternatives) {
   StatementMatcher matcher = anyOf(
     binaryOperator(hasOperatorName("+"),
                    hasLHS(expr().bind("x")),
                    hasRHS(integerLiteral(equals(0)))),
     binaryOperator(hasOperatorName("+"),
                    hasLHS(integerLiteral(equals(0))),
                    hasRHS(expr().bind("x"))));

cfe/trunk/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

EXPECT_TRUE(notMatches("char c = 0;",
                          implicitCastExpr(hasImplicitDestinationType(
                            unless(anything())))));
   // This test creates an implicit array-to-pointer cast.
   EXPECT_TRUE(notMatches("int arr[3]; int *p = arr;",
                          implicitCastExpr(hasImplicitDestinationType(
                            unless(anything())))));
 }
 
+TEST(Matcher, IgnoresElidableConstructors) {
+  EXPECT_TRUE(
+      matches("struct H {};"
+              "template<typename T> H B(T A);"
+              "void f() {"
+              "  H D1;"
+              "  D1 = B(B(1));"
+              "}",
+              cxxOperatorCallExpr(hasArgument(
+                  1, callExpr(hasArgument(
+                         0, ignoringElidableConstructorCall(callExpr()))))),
+              LanguageMode::Cxx11OrLater));
+  EXPECT_TRUE(
+      matches("struct H {};"
+              "template<typename T> H B(T A);"
+              "void f() {"
+              "  H D1;"
+              "  D1 = B(1);"
+              "}",
+              cxxOperatorCallExpr(hasArgument(
+                  1, callExpr(hasArgument(0, ignoringElidableConstructorCall(
+                                                 integerLiteral()))))),
+              LanguageMode::Cxx11OrLater));
+  EXPECT_TRUE(matches(
+      "struct H {};"
+      "H G();"
+      "void f() {"
+      "  H D = G();"
+      "}",
+      varDecl(hasInitializer(anyOf(
+          ignoringElidableConstructorCall(callExpr()),
+          exprWithCleanups(has(ignoringElidableConstructorCall(callExpr())))))),
+      LanguageMode::Cxx11OrLater));
+}
+
+TEST(Matcher, IgnoresElidableInReturn) {
+  auto matcher = expr(ignoringElidableConstructorCall(declRefExpr()));
+  EXPECT_TRUE(matches("struct H {};"
+                      "H f() {"
+                      "  H g;"
+                      "  return g;"
+                      "}",
+                      matcher, LanguageMode::Cxx11OrLater));
+  EXPECT_TRUE(notMatches("struct H {};"
+                         "H f() {"
+                         "  return H();"
+                         "}",
+                         matcher, LanguageMode::Cxx11OrLater));
+}
+
+TEST(Matcher, IgnoreElidableConstructorDoesNotMatchConstructors) {
+  EXPECT_TRUE(matches("struct H {};"
+                      "void f() {"
+                      "  H D;"
+                      "}",
+                      varDecl(hasInitializer(
+                          ignoringElidableConstructorCall(cxxConstructExpr()))),
+                      LanguageMode::Cxx11OrLater));
+}
+
+TEST(Matcher, IgnoresElidableDoesNotPreventMatches) {
+  EXPECT_TRUE(matches("void f() {"
+                      "  int D = 10;"
+                      "}",
+                      expr(ignoringElidableConstructorCall(integerLiteral())),
+                      LanguageMode::Cxx11OrLater));
+}
+
+TEST(Matcher, IgnoresElidableInVarInit) {
+  auto matcher =
+      varDecl(hasInitializer(ignoringElidableConstructorCall(callExpr())));
+  EXPECT_TRUE(matches("struct H {};"
+                      "H G();"
+                      "void f(H D = G()) {"
+                      "  return;"
+                      "}",
+                      matcher, LanguageMode::Cxx11OrLater));
+  EXPECT_TRUE(matches("struct H {};"
+                      "H G();"
+                      "void f() {"
+                      "  H D = G();"
+                      "}",
+                      matcher, LanguageMode::Cxx11OrLater));
+}
+
 TEST(IgnoringImplicit, MatchesImplicit) {
   EXPECT_TRUE(matches("class C {}; C a = C();",
                       varDecl(has(ignoringImplicit(cxxConstructExpr())))));
 }
 
 TEST(IgnoringImplicit, MatchesNestedImplicit) {
   StringRef Code = R"(