ASTMatcher for ParenExpr node.

[adek05]

Summary

Simple matcher for parentheses in expressions.

Test Plan:
Unit tests. I also verified that the matcher can be used in clang-query.

[adek05]

Fix compilation error

[klimek]

include/clang/ASTMatchers/ASTMatchers.h

1051

Add '.' in the end.

1053–1054

I don't think the second half of the sentence is necessary - it is implied by saying what the example matches.

[adek05]

@klimek comments

[klimek]

LG

include/clang/ASTMatchers/ASTMatchers.h

1051

Ah, and s/parenthesis/parentheses/.

[adek05]

Would you mind committing it for me? I don't have repo access yet.

[adek05]

Fix typo

[LegalizeAdulthood]

Is the AST Matcher Reference page generated from the header and picks up this new matcher automatically or does the documentation also need an update?

[klimek]

In D16278#329491, @LegalizeAdulthood wrote:

Is the AST Matcher Reference page generated from the header and picks up this new matcher automatically or does the documentation also need an update?

Documentation also needs an update

[adek05]

Update online docs

[aaron.ballman]

I have a few small nits that don't require additional review.

include/clang/ASTMatchers/ASTMatchers.h

1052

Please use doxygen-style comments for the entire comment block.

unittests/ASTMatchers/ASTMatchersTest.cpp

3570

Please change this to EXPECT_TRUE and notMatches instead (for consistency in the rest of the file).

[adek05]

@aaron.ballman comments. If it looks good, please commit it for me :)

[aaron.ballman]

Thanks! I've commit in r258321

include/clang/ASTMatchers/ASTMatchers.h

 ///   };
 /// \endcode
 /// unresolvedUsingTypenameDecl()
 ///   matches \code using Base<T>::Foo \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   UnresolvedUsingTypenameDecl> unresolvedUsingTypenameDecl;
 
+/// \brief Matches parenthesis used in expressions.
+//
+// Example matches (foo() + 1)
+// \code
+//   int foo() { return 1; }
+//   int a = (foo() + 1);
+// \endcode
+const internal::VariadicDynCastAllOfMatcher<
+  Stmt,
+  ParenExpr> parenExpr;
+
 /// \brief Matches constructor call expressions (including implicit ones).
 ///
 /// Example matches string(ptr, n) and ptr within arguments of f
 ///     (matcher = cxxConstructExpr())
 /// \code
 ///   void f(const string &a, const string &b);
 ///   char *ptr;
 ///   int n;

lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(numSelectorArgs);
   REGISTER_MATCHER(ofClass);
   REGISTER_MATCHER(objcInterfaceDecl);
   REGISTER_MATCHER(objcMessageExpr);
   REGISTER_MATCHER(objcObjectPointerType);
   REGISTER_MATCHER(on);
   REGISTER_MATCHER(onImplicitObjectArgument);
   REGISTER_MATCHER(parameterCountIs);
+  REGISTER_MATCHER(parenExpr);
   REGISTER_MATCHER(parenType);
   REGISTER_MATCHER(parmVarDecl);
   REGISTER_MATCHER(pointee);
   REGISTER_MATCHER(pointerType);
   REGISTER_MATCHER(qualType);
   REGISTER_MATCHER(recordDecl);
   REGISTER_MATCHER(recordType);
   REGISTER_MATCHER(referenceType);

unittests/ASTMatchers/ASTMatchersTest.cpp

TEST(ExceptionHandling, SimpleCases) {
   EXPECT_TRUE(notMatches("void foo() try { throw; } catch(int) { }",
                          cxxCatchStmt(isCatchAll())));
   EXPECT_TRUE(matches("void foo() try {} catch(int X) { }",
                       varDecl(isExceptionVariable())));
   EXPECT_TRUE(notMatches("void foo() try { int X; } catch (...) { }",
                          varDecl(isExceptionVariable())));
 }
 
+TEST(ParenExpression, SimpleCases) {
+  EXPECT_TRUE(matches("int i = (3);", parenExpr()));
+  EXPECT_TRUE(matches("int i = (3 + 7);", parenExpr()));
+  EXPECT_FALSE(matches("int i = 3;", parenExpr()));
+  EXPECT_FALSE(matches("int foo() { return 1; }; int a = foo();", parenExpr()));
+}
+
 TEST(HasConditionVariableStatement, DoesNotMatchCondition) {
   EXPECT_TRUE(notMatches(
       "void x() { if(true) {} }",
       ifStmt(hasConditionVariableStatement(declStmt()))));
   EXPECT_TRUE(notMatches(
       "void x() { int x; if((x = 42)) {} }",
       ifStmt(hasConditionVariableStatement(declStmt()))));
 }

unittests/ASTMatchers/Dynamic/RegistryTest.cpp

 TEST_F(RegistryTest, HasArgs) {
   Matcher<Decl> Value = constructMatcher(
       "decl", constructMatcher("hasAttr", StringRef("attr::WarnUnused")))
       .getTypedMatcher<Decl>();
   EXPECT_TRUE(matches("struct __attribute__((warn_unused)) X {};", Value));
   EXPECT_FALSE(matches("struct X {};", Value));
 }
 
+TEST_F(RegistryTest, ParenExpr) {
+  Matcher<Stmt> Value = constructMatcher("parenExpr").getTypedMatcher<Stmt>();
+  EXPECT_TRUE(matches("int i = (1);", Value));
+  EXPECT_FALSE(matches("int i = 1;", Value));
+}
+
 } // end anonymous namespace
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang