[ASTMatchers] WIP add hisFinalExpr to StmtExpr

[njames93]

Summary

Adds a traversal matcher hasFinalExpr to match the last statement in a gnu statement expression if the last statement is an expression.

[aaron.ballman]

I don't think this is a natural fit for the functionality. A statement expression doesn't have a return value so much as it is a value expression that can contain multiple statements. To me, at least, this is a bit like saying the comma operator has a return value because you can do int i; i = 1, 2, 3; and it "returns" 3.

Can you explain a bit about why you need this matcher functionality?

[njames93]

In D76196#1923524, @aaron.ballman wrote:

I don't think this is a natural fit for the functionality. A statement expression doesn't have a return value so much as it is a value expression that can contain multiple statements. To me, at least, this is a bit like saying the comma operator has a return value because you can do int i; i = 1, 2, 3; and it "returns" 3.

Can you explain a bit about why you need this matcher functionality?

I wasn't sure where to best place this and I was well aware of the comma operator acting similarly. The idea behind it is the first N-1 statements in a StmtExpr with N aren't as relevant as the final Stmt if its an Expr Maybe hasFinalExpression(InnerMatcher<Expr>) would be a better way WDYT?

[aaron.ballman]

In D76196#1923597, @njames93 wrote:

In D76196#1923524, @aaron.ballman wrote:

I don't think this is a natural fit for the functionality. A statement expression doesn't have a return value so much as it is a value expression that can contain multiple statements. To me, at least, this is a bit like saying the comma operator has a return value because you can do int i; i = 1, 2, 3; and it "returns" 3.

Can you explain a bit about why you need this matcher functionality?

I wasn't sure where to best place this and I was well aware of the comma operator acting similarly. The idea behind it is the first N-1 statements in a StmtExpr with N aren't as relevant as the final Stmt if its an Expr Maybe hasFinalExpression(InnerMatcher<Expr>) would be a better way WDYT?

I'm still not understanding your use case, so it's a bit hard for me to tell whether this approach is good or not. Do you have a situation where you cannot match on the expression itself, you also have to know its position? I'm asking because we don't currently have support for querying positional statements (for instance, you cannot ask what the final statement in a CompoundStmt) and statement expressions are a bit strange. For instance, what would the final "expression" be in this legal-but-bizarre statement expression: ({int j = 12; j; int x;});?

[njames93]

In D76196#1924393, @aaron.ballman wrote:

I'm still not understanding your use case, so it's a bit hard for me to tell whether this approach is good or not. Do you have a situation where you cannot match on the expression itself, you also have to know its position? I'm asking because we don't currently have support for querying positional statements (for instance, you cannot ask what the final statement in a CompoundStmt) and statement expressions are a bit strange. For instance, what would the final "expression" be in this legal-but-bizarre statement expression: ({int j = 12; j; int x;});?

It would be the int x; but not matchable as its not an expression. The way StmtExpr works is it evaluates each Stmt in order and returns the result of the last Stmt, if it is an expression. otherwise it basically returns void. Possible use cases are if you want to match on say an if condition, but the condition is inside a StmtExpr. I feel like there could be a better way to get this behaviour but I'm not exactly sure what it is

[njames93]

• Rename matcher to hasFinalExpr
• Don't review it yet

clang/docs/LibASTMatchersReference.html

Given
   { {}; 1+2; }
 hasAnySubstatement(compoundStmt())
   matches '{ {}; 1+2; }'
 with compoundStmt()
   matching '{}'
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1StmtExpr.html">StmtExpr</a>&gt;</td><td class="name" onclick="toggle('hasFinalExpr0')"><a name="hasFinalExpr0Anchor">hasFinalExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Expr.html">Expr</a>&gt; InnerMatcher</td></tr>
+<tr><td colspan="4" class="doc" id="hasFinalExpr0"><pre>Matches the result value expression of a GNU statement expression.
+
+Given
+  ({int *Ptr; *Ptr;});
+hasFinalExpr(unaryOperator())
+  matches '({int *Ptr; *Ptr;})'
+with unaryOperator()
+  matching '*Ptr'
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('alignOfExpr0')"><a name="alignOfExpr0Anchor">alignOfExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1UnaryExprOrTypeTraitExpr.html">UnaryExprOrTypeTraitExpr</a>&gt;  InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="alignOfExpr0"><pre>Same as unaryExprOrTypeTraitExpr, but only matching
 alignof.
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Stmt.html">Stmt</a>&gt;</td><td class="name" onclick="toggle('forFunction0')"><a name="forFunction0Anchor">forFunction</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1FunctionDecl.html">FunctionDecl</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="forFunction0"><pre>Matches declaration of the function the statement belongs to

clang/include/clang/ASTMatchers/ASTMatchers.h

 ///   matching 'a + b'
 AST_MATCHER_P(ReturnStmt, hasReturnValue, internal::Matcher<Expr>,
               InnerMatcher) {
   if (const auto *RetValue = Node.getRetValue())
     return InnerMatcher.matches(*RetValue, Finder, Builder);
   return false;
 }
 
+/// Matches the result value expression of a GNU statement expression.
+///
+/// Given
+/// \code
+///   ({int *Ptr; *Ptr;});
+/// \endcode
+/// hasFinalExpr(unaryOperator())
+///   matches '({int *Ptr; *Ptr;})'
+/// with unaryOperator()
+///   matching '*Ptr'
+AST_MATCHER_P(StmtExpr, hasFinalExpr, internal::Matcher<Expr>, InnerMatcher) {
+  if (const CompoundStmt *CS = Node.getSubStmt()) {
+    if (const auto *E = dyn_cast_or_null<Expr>(CS->body_back()))
+      return InnerMatcher.matches(*E, Finder, Builder);
+  }
+  return false;
+}
+
 /// Matches CUDA kernel call expression.
 ///
 /// Example matches,
 /// \code
 ///   kernel<<<i,j>>>();
 /// \endcode
 extern const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
     cudaKernelCallExpr;

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

 
 TEST(StatementMatcher, HasReturnValue) {
   StatementMatcher RetVal = returnStmt(hasReturnValue(binaryOperator()));
   EXPECT_TRUE(matches("int F() { int a, b; return a + b; }", RetVal));
   EXPECT_FALSE(matches("int F() { int a; return a; }", RetVal));
   EXPECT_FALSE(matches("void F() { return; }", RetVal));
 }
 
+TEST(StatementMatcher, hasFinalExpr) {
+  StatementMatcher RetVal = stmtExpr(hasFinalExpr(binaryOperator()));
+  EXPECT_TRUE(matches("void F() { ({int a, b; a + b;}); }", RetVal));
+  EXPECT_FALSE(matches("void F() { ({int a; a;}); }", RetVal));
+  EXPECT_FALSE(matches("void F() { ({int a;}); }", RetVal));
+}
+
 TEST(StatementMatcher, ForFunction) {
   const auto CppString1 =
     "struct PosVec {"
       "  PosVec& operator=(const PosVec&) {"
       "    auto x = [] { return 1; };"
       "    return *this;"
       "  }"
       "};";