[clang] add parameter pack/pack expansion matchers

[upsj]

Summary

There is no (obvious to me) way to match pack expansions and parameter packs, so I added two matchers for them.

[upsj]

formatting

[aaron.ballman]

Due to how expensive it is to instantiate all the templates from ASTMatchers.h, we typically don't add new matchers unless there's a need for them in-tree or they're expected to be generally useful to a number of out-of-tree matchers. Are you planning to make use of these matchers for a clang-tidy check you're working on or something along those lines? Or are they mostly to add missing coverage?

On the technical side (feel free to ignore this until we know we're going to add the matchers to Clang if you'd like), you should add test coverage for the new matchers to clang/unittests/ASTMatchers and you should regenerate the documentation by running clang/docs/tools/dump_ast_matchers.py.

[upsj]

This is part of my long-term goal to add support for forwarding parameters and documentation for make_unique-like functions to clangd. To be fair, the details are not entirely fleshed out - for inlay hints (displaying parameter names inline), the entire function template is already available in an instantiated form, so I can work with existing matchers. For signature help (displaying which parameters are available, which one is active while typing), IIRC you only have the template instantiation pattern available, so I need to find the necessary parts of the AST myself.

My thought was to try and move towards this goal in small steps, but if this is an important build time/size consideration, I can also see whether both of them are actually necessary (I suspect isParameterPack might not be) before moving forward?

[aaron.ballman]

In D124373#3477996, @upsj wrote:

This is part of my long-term goal to add support for forwarding parameters and documentation for make_unique-like functions to clangd. To be fair, the details are not entirely fleshed out - for inlay hints (displaying parameter names inline), the entire function template is already available in an instantiated form, so I can work with existing matchers. For signature help (displaying which parameters are available, which one is active while typing), IIRC you only have the template instantiation pattern available, so I need to find the necessary parts of the AST myself.

Ah, thank you for the background information!

My thought was to try and move towards this goal in small steps, but if this is an important build time/size consideration, I can also see whether both of them are actually necessary (I suspect isParameterPack might not be) before moving forward?

We support locally defined matchers so that you can still use all the AST matching awesomeness, but without increasing the compile times for everyone for one-off matchers. e.g,., https://github.com/llvm/llvm-project/blob/c874dd53628db8170d4c5ba3878817abc385a695/clang-tools-extra/clang-tidy/readability/ConvertMemberFunctionsToStatic.cpp#L23 My recommendation is to do something similar for clangd, but once we find a second use for the matcher, we can go ahead and hoist it into ASTMatchers.h at that point. WDYT?

[upsj]

I wasn't aware of that, sounds perfect, thanks! Then I'll put this on hold until I figure out if it's really necessary.

[upsj]

I think we should be able to do this without adding new matchers globally.

clang/include/clang/ASTMatchers/ASTMatchers.h

 ///   matches 'int a;' and 'int b;' but not 'int c;'.
 AST_MATCHER_P(FieldDecl, hasInClassInitializer, internal::Matcher<Expr>,
               InnerMatcher) {
   const Expr *Initializer = Node.getInClassInitializer();
   return (Initializer != nullptr &&
           InnerMatcher.matches(*Initializer, Finder, Builder));
 }
 
+/// Determines whether a declaration is a parameter pack.
+///
+/// Given
+/// \code
+/// template <typename A, typename... Bs,
+///           int i, int... js,
+///           template <typename> class C,
+///           template <typename> class... Ds>
+/// void foo(A param, Bs... params);
+/// \endcode
+/// templateTypeParmDecl(isParameterPack())
+///   matches 'typename... Bs', but not 'typename A'.
+/// nonTypeTemplateParmDecl(isParameterPack())
+///   matches 'int... js', but not 'int i'.
+/// templateTemplateParmDecl(isParameterPack())
+///   matches 'template <typename> class... Ds', but not
+///   'template <typename> class C'
+/// varDecl(isParameterPack())
+///   matches 'Bs... params', but not 'A param'.
+AST_MATCHER(Decl, isParameterPack) { return Node.isParameterPack(); }
+
 /// Determines whether the function is "main", which is the entry point
 /// into an executable program.
 AST_MATCHER(FunctionDecl, isMain) {
   return Node.isMain();
 }
 
 /// Matches the specialized template of a specialization declaration.
 ///

 /// \endcode
 /// designatorCountIs(2)
 ///   matches '{ [2].y = 1.0, [0].x = 1.0 }',
 ///   but not '{ [2].y = 1.0, [2].x = 0.0, [0].x = 1.0 }'.
 AST_MATCHER_P(DesignatedInitExpr, designatorCountIs, unsigned, N) {
   return Node.size() == N;
 }
 
+/// Matches pack expansion expressions.
+///
+/// Given
+/// \code
+/// void bar(int, int);
+/// template <typename T, typename... Args>
+/// void foo(T arg, Args args...) {
+///     bar(arg + 1, (args + 1)...);
+/// }
+/// \endcode
+/// packExpansionExpr()
+///   matches '(args + 1)...', but not 'arg + 1'.
+extern const internal::VariadicDynCastAllOfMatcher<Stmt, PackExpansionExpr>
+    packExpansionExpr;
+
 /// Matches \c QualTypes in the clang AST.
 extern const internal::VariadicAllOfMatcher<QualType> qualType;
 
 /// Matches \c Types in the clang AST.
 extern const internal::VariadicAllOfMatcher<Type> type;
 
 /// Matches \c TypeLocs in the clang AST.
 extern const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXFunctionalCastExpr>
     cxxFunctionalCastExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTemporaryObjectExpr>
     cxxTemporaryObjectExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, PredefinedExpr>
     predefinedExpr;
 const internal::VariadicDynCastAllOfMatcher<Stmt, DesignatedInitExpr>
     designatedInitExpr;
+const internal::VariadicDynCastAllOfMatcher<Stmt, PackExpansionExpr>
+    packExpansionExpr;
 const internal::VariadicOperatorMatcherFunc<
     2, std::numeric_limits<unsigned>::max()>
     eachOf = {internal::DynTypedMatcher::VO_EachOf};
 const internal::VariadicOperatorMatcherFunc<
     2, std::numeric_limits<unsigned>::max()>
     anyOf = {internal::DynTypedMatcher::VO_AnyOf};
 const internal::VariadicOperatorMatcherFunc<
     2, std::numeric_limits<unsigned>::max()>

clang/lib/ASTMatchers/Dynamic/Registry.cpp

RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(isMain);
   REGISTER_MATCHER(isMemberInitializer);
   REGISTER_MATCHER(isMoveAssignmentOperator);
   REGISTER_MATCHER(isMoveConstructor);
   REGISTER_MATCHER(isNoReturn);
   REGISTER_MATCHER(isNoThrow);
   REGISTER_MATCHER(isNoneKind);
   REGISTER_MATCHER(isOverride);
+  REGISTER_MATCHER(isParameterPack);
   REGISTER_MATCHER(isPrivate);
   REGISTER_MATCHER(isProtected);
   REGISTER_MATCHER(isPublic);
   REGISTER_MATCHER(isPure);
   REGISTER_MATCHER(isScoped);
   REGISTER_MATCHER(isSharedKind);
   REGISTER_MATCHER(isSignedInteger);
   REGISTER_MATCHER(isStandaloneDirective);
RegistryMaps::RegistryMaps() {
   REGISTER_MATCHER(ofClass);
   REGISTER_MATCHER(ofKind);
   REGISTER_MATCHER(ompDefaultClause);
   REGISTER_MATCHER(ompExecutableDirective);
   REGISTER_MATCHER(on);
   REGISTER_MATCHER(onImplicitObjectArgument);
   REGISTER_MATCHER(opaqueValueExpr);
   REGISTER_MATCHER(optionally);
+  REGISTER_MATCHER(packExpansionExpr);
   REGISTER_MATCHER(parameterCountIs);
   REGISTER_MATCHER(parenExpr);
   REGISTER_MATCHER(parenListExpr);
   REGISTER_MATCHER(parenType);
   REGISTER_MATCHER(parmVarDecl);
   REGISTER_MATCHER(pointee);
   REGISTER_MATCHER(pointerType);
   REGISTER_MATCHER(pointerTypeLoc);