Add a matcher for members of an initializer list expression

[hwright]

Summary

Much like hasArg for various call expressions, this allows LibTooling users to match against a member of an initializer list.

This is currently being used as part of the abseil-duration-scale clang-tidy check.

[lebedev.ri]

1. Tests
2. The docs file will need to be regenerated

[hwright]

@lebedev.ri Where do the appropriate tests live? (I couldn't find an obvious subdirectory in test/)
Where are the instructions for regenerating the documentation?

[aaron.ballman]

In D56090#1341023, @hwright wrote:

@lebedev.ri Where do the appropriate tests live? (I couldn't find an obvious subdirectory in test/)

This would live in clang\unittests\ASTMatchers\ASTMatchersNarrowingTest.cpp

Where are the instructions for regenerating the documentation?

Run clang\docs\tools\dump_ast_matchers.py and it will generate the documentation for you.

You should also update Registry.cpp to list the new matcher.

include/clang/ASTMatchers/ASTMatchers.h

3527 ↗

(On Diff #179522)

I'm not certain we want the IgnoreParenImpCasts() here -- what if someone wants to match an initializer that uses one of those properties?

[hwright]

Added tests, update docs.

include/clang/ASTMatchers/ASTMatchers.h

3527 ↗

(On Diff #179522)

The hasArg implementation directly above has the same call to IgnoreParenImpCasts(). Is it also in error? (It would seem that they should both be consistent.)

[aaron.ballman]

include/clang/ASTMatchers/ASTMatchers.h

3527 ↗

(On Diff #179522)

Yeah, I noticed that as well. Doing some code archaeology, it seems that hasArg() has had that form since its inception and it was never explicitly discussed what should happen there.

@klimek -- do you have opinions here, since you wrote the original code for hasArg()? Should we be leaving the paren and implicit cast stripping up to the caller rather than doing it automatically?

[aaron.ballman]

Adding Manuel for the hasArg() questions.

[klimek]

include/clang/ASTMatchers/ASTMatchers.h

3527 ↗

(On Diff #179522)

Sigh, yea, this is one of those hard decisions: in the end, we decided that the downside of surprise of users not seeing what they expected (due to an imp cast) was less bad than basically taking away the ability to match imp casts, so we stopped putting ignoreparenimpcasts everywhere. I'm not entirely sure how to rate consistency with hasArg vs. getting us towards a more explicit world, but my gut would probably go with leaving the ignoreparenimpcasts out and see how bad people find it.

[hwright]

Removed IgnoreParenImpCasts call.

[hwright]

include/clang/ASTMatchers/ASTMatchers.h

3527 ↗

(On Diff #179522)

Removed the call to IgnoreParenImpCasts().

[aaron.ballman]

LGTM! Thanks, both!

cfe/trunk/docs/LibASTMatchersReference.html

 <tr><td colspan="4" class="doc" id="binaryOperator0"><pre>Matches binary operator expressions.
 
 Example matches a || b
   !(a || b)
 </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('blockExpr0')"><a name="blockExpr0Anchor">blockExpr</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BlockExpr.html">BlockExpr</a>&gt;...</td></tr>
-<tr><td colspan="4" class="doc" id="blockExpr0"><pre>MAtches a reference to a block.
+<tr><td colspan="4" class="doc" id="blockExpr0"><pre>Matches a reference to a block.
 
 Example: matches "^{}":
   void f() { ^{}(); }
 </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('breakStmt0')"><a name="breakStmt0Anchor">breakStmt</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1BreakStmt.html">BreakStmt</a>&gt;...</td></tr>
 <tr><td colspan="4" class="doc" id="breakStmt0"><pre>Matches break statements.

 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1ImplicitCastExpr.html">ImplicitCastExpr</a>&gt;</td><td class="name" onclick="toggle('hasImplicitDestinationType0')"><a name="hasImplicitDestinationType0Anchor">hasImplicitDestinationType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="hasImplicitDestinationType0"><pre>Matches implicit casts whose destination type matches a given
 matcher.
 
 FIXME: Unit test this matcher
 </pre></td></tr>
 
 
+<tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InitListExpr.html">InitListExpr</a>&gt;</td><td class="name" onclick="toggle('hasInit0')"><a name="hasInit0Anchor">hasInit</a></td><td>unsigned N, ast_matchers::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="hasInit0"><pre>Matches the n'th item of an initializer list expression.
+
+Example matches y.
+    (matcher = initListExpr(hasInit(0, expr())))
+  int x{y}.
+</pre></td></tr>
+
+
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InitListExpr.html">InitListExpr</a>&gt;</td><td class="name" onclick="toggle('hasSyntacticForm0')"><a name="hasSyntacticForm0Anchor">hasSyntacticForm</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="hasSyntacticForm0"><pre>Matches the syntactic form of init list expressions
 (if expression have it).
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1InjectedClassNameType.html">InjectedClassNameType</a>&gt;</td><td class="name" onclick="toggle('hasDeclaration9')"><a name="hasDeclaration9Anchor">hasDeclaration</a></td><td>const Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1Decl.html">Decl</a>&gt;  InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="hasDeclaration9"><pre>Matches a node if the declaration associated with that node

cfe/trunk/include/clang/ASTMatchers/ASTMatchers.h

AST_POLYMORPHIC_MATCHER_P2(hasArgument,
                                                            CXXConstructExpr,
                                                            ObjCMessageExpr),
                            unsigned, N, internal::Matcher<Expr>, InnerMatcher) {
   return (N < Node.getNumArgs() &&
           InnerMatcher.matches(
               *Node.getArg(N)->IgnoreParenImpCasts(), Finder, Builder));
 }
 
+/// Matches the n'th item of an initializer list expression.
+///
+/// Example matches y.
+///     (matcher = initListExpr(hasInit(0, expr())))
+/// \code
+///   int x{y}.
+/// \endcode
+AST_MATCHER_P2(InitListExpr, hasInit, unsigned, N,
+               ast_matchers::internal::Matcher<Expr>, InnerMatcher) {
+  return N < Node.getNumInits() &&
+          InnerMatcher.matches(*Node.getInit(N), Finder, Builder);
+}
+
 /// Matches declaration statements that contain a specific number of
 /// declarations.
 ///
 /// Example: Given
 /// \code
 ///   int a, b;
 ///   int c;
 ///   int d = 2, e;

cfe/trunk/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(hasElse);
   REGISTER_MATCHER(hasExternalFormalLinkage);
   REGISTER_MATCHER(hasFalseExpression);
   REGISTER_MATCHER(hasGlobalStorage);
   REGISTER_MATCHER(hasImplicitDestinationType);
   REGISTER_MATCHER(hasInClassInitializer);
   REGISTER_MATCHER(hasIncrement);
   REGISTER_MATCHER(hasIndex);
+  REGISTER_MATCHER(hasInit);
   REGISTER_MATCHER(hasInitializer);
   REGISTER_MATCHER(hasKeywordSelector);
   REGISTER_MATCHER(hasLHS);
   REGISTER_MATCHER(hasLocalQualifiers);
   REGISTER_MATCHER(hasLocalStorage);
   REGISTER_MATCHER(hasLoopInit);
   REGISTER_MATCHER(hasLoopVariable);
   REGISTER_MATCHER(hasMethod);

cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

TEST(IsAssignmentOperator, Basic) {
   EXPECT_TRUE(matches("void x() { int a; a &= 3; }", BinAsgmtOperator));
   EXPECT_TRUE(matches("struct S { S& operator=(const S&); };"
                       "void x() { S s1, s2; s1 = s2; }",
                       CXXAsgmtOperator));
   EXPECT_TRUE(
       notMatches("void x() { int a; if(a == 0) return; }", BinAsgmtOperator));
 }
 
+TEST(HasInit, Basic) {
+  EXPECT_TRUE(
+    matches("int x{0};",
+            initListExpr(hasInit(0, expr()))));
+  EXPECT_FALSE(
+    matches("int x{0};",
+            initListExpr(hasInit(1, expr()))));
+  EXPECT_FALSE(
+    matches("int x;",
+            initListExpr(hasInit(0, expr()))));
+}
+
 TEST(Matcher, isMain) {
   EXPECT_TRUE(
     matches("int main() {}", functionDecl(isMain())));
 
   EXPECT_TRUE(
     notMatches("int main2() {}", functionDecl(isMain())));
 }
 
 } // namespace ast_matchers
 } // namespace clang