[ASTImporter] Eliminated some unittest warnings.

[balazske]

Summary

When running the ASTTests test, warnings produced by the compiler can be
distracting when looking for test errors. A part of the warnings is removed
by setting extra compiler options.

[a.sidorin]

Hello Balázs!

Thank you for addressing this problem, it is really cool. However, it will be much better if we don't suppress warnings but fix them. Could you modify the tests instead?

[balazske]

Original idea was to not modify the test code to keep it as simple as possible. If you like it better I will change the test code.

[balazske]

[ASTImporter] Fixed test code in ASTImporter tests.

Test code is fixed instead of turn off the warnings.
For this to work change of match expressions was needed.

[a_sidorin]

Hello Balázs,

The patch is mostly LG now, thank you!

unittests/AST/ASTImporterTest.cpp

495

Redundant space after cast.

541

Commented code should be removed.

802

Sometimes we turn to usehasDescendant(), sometimes we add a cast matcher. Can we make it consistent?

[balazske]

[ASTImporter] Fixed test code in ASTImporter tests.

Reformatted some test code, changed to use isDescendant.

[balazske]

Some of the source code was reformatted for more consistency. At least a part of the code is now better formatted.

[a.sidorin]

Thank you!

When committing, please change the commit message (the current review description is out-of-date) and mention the reformatting done.

[balazske]

Rebase to newest master.

unittests/AST/ASTImporterTest.cpp

for (size_t CompileOpt = 0; CompileOpt < NumCompileOpts; ++CompileOpt) {
     MatchVerifier<Decl> Verifier;
     EXPECT_TRUE(Verifier.match(ToVerify,
                                BindableMatcher<Decl>(VerificationMatcher)));
   }
 }
 
 TEST(ImportExpr, ImportStringLiteral) {
   MatchVerifier<Decl> Verifier;
-  testImport("void declToImport() { \"foo\"; }",
+  testImport("void declToImport() { (void)\"foo\"; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     stringLiteral(
-                       hasType(
-                         asString("const char [4]"))))))));
-  testImport("void declToImport() { L\"foo\"; }",
+               hasDescendant(
+                     asString("const char [4]"))))));
+  testImport("void declToImport() { (void)L\"foo\"; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     stringLiteral(
-                       hasType(
-                        asString("const wchar_t [4]"))))))));
-  testImport("void declToImport() { \"foo\" \"bar\"; }",
+               hasDescendant(
+                     asString("const wchar_t [4]"))))));
+  testImport("void declToImport() { (void) \"foo\" \"bar\"; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     stringLiteral(
-                       hasType(
-                         asString("const char [7]"))))))));
+               hasDescendant(
+                     asString("const char [7]"))))));
 }
 
 TEST(ImportExpr, ImportGNUNullExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport("void declToImport() { __null; }",
+  testImport("void declToImport() { (void)__null; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     gnuNullExpr(
-                       hasType(isInteger())))))));
+               hasDescendant(
+                   hasType(isInteger())))));
 }
 
 TEST(ImportExpr, ImportCXXNullPtrLiteralExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport("void declToImport() { nullptr; }",
+  testImport("void declToImport() { (void)nullptr; }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     cxxNullPtrLiteralExpr())))));
+               hasDescendant(
+                 cxxNullPtrLiteralExpr())));
 }
 
 
 TEST(ImportExpr, ImportFloatinglLiteralExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport("void declToImport() { 1.0; }",
+  testImport("void declToImport() { (void)1.0; }",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     floatLiteral(
-                       equals(1.0),
-                       hasType(asString("double"))))))));
-  testImport("void declToImport() { 1.0e-5f; }",
+               hasDescendant(
+                   hasType(asString("double"))))));
+  testImport("void declToImport() { (void)1.0e-5f; }",
               Lang_C, "", Lang_C, Verifier,
               functionDecl(
-                hasBody(
-                  compoundStmt(
-                    has(
-                      floatLiteral(
-                        equals(1.0e-5f),
-                        hasType(asString("float"))))))));
+                hasDescendant(
+                    hasType(asString("float"))))));
 }
 
 TEST(ImportExpr, ImportCompoundLiteralExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() {"
              "  struct s { int x; long y; unsigned z; }; "
-             "  (struct s){ 42, 0L, 1U }; }",
+             "  (void) (struct s){ 42, 0L, 1U }; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     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(1),
-                               hasType(asString("unsigned int"))))
-                         ))))))));
+               hasDescendant(
+                     ))))));
 }
 
 TEST(ImportExpr, ImportCXXThisExpr) {
   MatchVerifier<Decl> Verifier;
-  testImport("class declToImport { void f() { this; } };",
+  testImport("class declToImport { void f() { (void)this; } };",
              Lang_CXX, "", Lang_CXX, Verifier,
              cxxRecordDecl(
                hasMethod(
-                 hasBody(
-                   compoundStmt(
-                     has(
-                       cxxThisExpr(
-                         hasType(
-                           asString("class declToImport *")))))))));
+                 hasDescendant(
+                       asString("class declToImport *")))))));
 }
 
 TEST(ImportExpr, ImportAtomicExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { int *ptr; __atomic_load_n(ptr, 1); }",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(hasBody(compoundStmt(has(atomicExpr(
                  has(ignoringParenImpCasts(
                      declRefExpr(hasDeclaration(varDecl(hasName("ptr"))),
                                  hasType(asString("int *"))))),
                  has(integerLiteral(equals(1), hasType(asString("int"))))))))));
 }
 
 TEST(ImportExpr, ImportLabelDeclAndAddrLabelExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
-      "void declToImport() { loop: goto loop; &&loop; }", Lang_C, "", Lang_C,
-      Verifier,
-      functionDecl(hasBody(compoundStmt(
+      "void declToImport() { loop: goto loop; (void)&&loop; }",
+      Lang_C, "", Lang_C, Verifier,
+      /*functionDecl(hasBody(compoundStmt(
           has(labelStmt(hasDeclaration(labelDecl(hasName("loop"))))),
-          has(addrLabelExpr(hasDeclaration(labelDecl(hasName("loop")))))))));
+          has(addrLabelExpr(hasDeclaration(labelDecl(hasName("loop")))))))));*/
+      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);
 }
 
functionDecl(
                       hasDescendant(
                         implicitCastExpr()
                         )))))))))));
 }
 
 TEST(ImportExpr, ImportConditionalOperator) {
   MatchVerifier<Decl> Verifier;
   testImport(
-    "void declToImport() { true ? 1 : -5; }",
+    "void declToImport() { (void) (true ? 1 : -5); }",
     Lang_CXX, "", Lang_CXX, Verifier,
     functionDecl(
-      hasBody(
-        compoundStmt(
-          has(
-            conditionalOperator(
-              hasCondition(cxxBoolLiteral(equals(true))),
-              hasTrueExpression(integerLiteral(equals(1))),
-              hasFalseExpression(
-                unaryOperator(hasUnaryOperand(integerLiteral(equals(5))))
-                )))))));
+      hasDescendant(
+            unaryOperator(hasUnaryOperand(integerLiteral(equals(5)))))))));
 }
 
 TEST(ImportExpr, ImportBinaryConditionalOperator) {
   MatchVerifier<Decl> Verifier;
   testImport(
-    "void declToImport() { 1 ?: -5; }", Lang_CXX, "", Lang_CXX, Verifier,
+    "void declToImport() { (void) (1 ?: -5); }",
+    Lang_CXX, "", Lang_CXX, Verifier,
     functionDecl(
-      hasBody(
-        compoundStmt(
-          has(
-            binaryConditionalOperator(
-              hasCondition(
-                implicitCastExpr(
-                  hasSourceExpression(
-                    opaqueValueExpr(
-                      hasSourceExpression(integerLiteral(equals(1))))),
-                  hasType(booleanType()))),
-              hasTrueExpression(
-                opaqueValueExpr(hasSourceExpression(
-                                  integerLiteral(equals(1))))),
-              hasFalseExpression(
-                unaryOperator(hasOperatorName("-"),
-                              hasUnaryOperand(integerLiteral(equals(5)))))
-                ))))));
+      hasDescendant(
+            ))));
 }
 
 TEST(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 }; }",
testImport("void declToImport() {"
                                              equals(0)))))
                                    ))))))))))));
 }
 
 
 TEST(ImportExpr, ImportPredefinedExpr) {
   MatchVerifier<Decl> Verifier;
   // __func__ expands as StringLiteral("declToImport")
-  testImport("void declToImport() { __func__; }",
+  testImport("void declToImport() { (void)__func__; }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     predefinedExpr(
-                       hasType(
-                         asString("const char [13]")),
-                       has(
-                         stringLiteral(
-                           hasType(
-                             asString("const char [13]"))))))))));
+               hasDescendant(
+                         asString("const char [13]"))))))));
 }
 
 TEST(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,"

 const internal::VariadicDynCastAllOfMatcher<Expr, CXXDependentScopeMemberExpr>
     cxxDependentScopeMemberExpr;
 
 TEST(ImportExpr, ImportCXXDependentScopeMemberExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
-             "  d.t;"
+             "  (void)d.t;"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
-             functionTemplateDecl(has(functionDecl(
-                 has(compoundStmt(has(cxxDependentScopeMemberExpr())))))));
+             functionTemplateDecl(has(functionDecl(has(compoundStmt(has(
+                 cStyleCastExpr(has(
+                     cxxDependentScopeMemberExpr())))))))));
   testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
-             "  (&d)->t;"
+             "  (void)(&d)->t;"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
-             functionTemplateDecl(has(functionDecl(
-                 has(compoundStmt(has(cxxDependentScopeMemberExpr())))))));
+             functionTemplateDecl(has(functionDecl(has(compoundStmt(has(
+                 cStyleCastExpr(has(
+                     cxxDependentScopeMemberExpr())))))))));
 }
 
 TEST(ImportType, ImportTypeAliasTemplate) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template <int K>"
       "struct dummy { static const int i = K; };"
       "template <int K> using dummy2 = dummy<K>;"
       "int declToImport() { return dummy2<3>::i; }",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(
           hasBody(compoundStmt(
               has(returnStmt(has(implicitCastExpr(has(declRefExpr()))))))),
           unless(hasAncestor(translationUnitDecl(has(typeAliasDecl()))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Decl, VarTemplateSpecializationDecl>
     varTemplateSpecializationDecl;
 
 TEST(ImportDecl, ImportVarTemplate) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "template <typename T>"
       "T pi = T(3.1415926535897932385L);"
-      "void declToImport() { pi<int>; }",
-      Lang_CXX11, "", Lang_CXX11, Verifier,
+      "void declToImport() { (void) pi<int>; }",
+      Lang_CXX14, "", Lang_CXX14, Verifier,
       functionDecl(
-          hasBody(has(declRefExpr(to(varTemplateSpecializationDecl())))),
+          hasDescendant(declRefExpr(to(varTemplateSpecializationDecl()))),
           unless(hasAncestor(translationUnitDecl(has(varDecl(
               hasName("pi"), unless(varTemplateSpecializationDecl()))))))));
 }
 
 TEST(ImportType, ImportPackExpansion) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename... Args>"
              "struct dummy {"

 ///   __builtin_types_compatible_p(int, int)
 /// \endcode
 //  will generate TypeTraitExpr <...> 'int'
 const internal::VariadicDynCastAllOfMatcher<Stmt, TypeTraitExpr> typeTraitExpr;
 
 TEST(ImportExpr, ImportTypeTraitExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("void declToImport() { "
-             "  __builtin_types_compatible_p(int, int);"
+             "  (void)__builtin_types_compatible_p(int, int);"
              "}",
              Lang_C, "", Lang_C, Verifier,
              functionDecl(
-               hasBody(
-                 compoundStmt(
-                   has(
-                     typeTraitExpr(hasType(asString("int"))))))));
+               hasDescendant(
+                 typeTraitExpr(hasType(asString("int"))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTypeidExpr> cxxTypeidExpr;
 
 TEST(ImportExpr, ImportCXXTypeidExpr) {
   MatchVerifier<Decl> Verifier;
   testImport(
       "namespace std { class type_info {}; }"
       "void declToImport() {"
       "  int x;"
       "  auto a = typeid(int); auto b = typeid(x);"
       "}",
       Lang_CXX11, "", Lang_CXX11, Verifier,
       functionDecl(
           hasDescendant(varDecl(
               hasName("a"), hasInitializer(hasDescendant(cxxTypeidExpr())))),
           hasDescendant(varDecl(
               hasName("b"), hasInitializer(hasDescendant(cxxTypeidExpr()))))));
 }
 
 TEST(ImportExpr, ImportTypeTraitExprValDep) {
   MatchVerifier<Decl> Verifier;
   testImport("template<typename T> struct declToImport {"
-             "  void m() { __is_pod(T); }"
+             "  void m() { (void)__is_pod(T); }"
              "};"
              "void f() { declToImport<int>().m(); }",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              classTemplateDecl(
                has(
                  cxxRecordDecl(
                    has(
                      functionDecl(
-                       hasBody(
-                         compoundStmt(
-                           has(
-                             typeTraitExpr(
-                               hasType(booleanType())
-                               ))))))))));
+                       hasDescendant(
+                           ))))))));
 }
 
 const internal::VariadicDynCastAllOfMatcher<Expr, CXXPseudoDestructorExpr>
     cxxPseudoDestructorExpr;
 
 TEST(ImportExpr, ImportCXXPseudoDestructorExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("typedef int T;"
testImport("namespace foo { int bar; }"
              Lang_CXX, "", Lang_CXX, Verifier,
              namespaceDecl(has(usingShadowDecl())));
 }
 
 TEST(ImportExpr, ImportUnresolvedLookupExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template<typename T> int foo();"
              "template <typename T> void declToImport() {"
-             "  ::foo<T>;"
-             "  ::template foo<T>;"
+             "  (void) ::foo<T>;"
+             "  (void) ::template foo<T>;"
              "}"
              "void instantiate() { declToImport<int>(); }",
              Lang_CXX, "", Lang_CXX, Verifier,
              functionTemplateDecl(has(functionDecl(
-                 has(compoundStmt(has(unresolvedLookupExpr())))))));
+                 hasDescendant(unresolvedLookupExpr())))));
 }
 
 TEST(ImportExpr, ImportCXXUnresolvedConstructExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> struct C { T t; };"
              "template <typename T> void declToImport() {"
              "  C<T> d;"
              "  d.t = T();"
const internal::VariadicDynCastAllOfMatcher<Expr, DependentScopeDeclRefExpr>
     dependentScopeDeclRefExpr;
 
 TEST(ImportExpr, DependentScopeDeclRefExpr) {
   MatchVerifier<Decl> Verifier;
   testImport("template <typename T> struct S { static T foo; };"
              "template <typename T> void declToImport() {"
              "  (void) S<T>::foo;"
              "}"
-             "void instantiate() { declToImport<int>(); }",
+             "void instantiate() { declToImport<int>(); }"
+             "template <typename T> T S<T>::foo;",
              Lang_CXX11, "", Lang_CXX11, Verifier,
              functionTemplateDecl(has(functionDecl(has(compoundStmt(
                  has(cStyleCastExpr(has(dependentScopeDeclRefExpr())))))))));
 
   testImport("template <typename T> struct S {"
              "template<typename S> static void foo(){};"
              "};"
              "template <typename T> void declToImport() {"