[ASTMatchers] Add own version of VariadicFunction.

[sbenza]

Summary

llvm::VariadicFunction is only being used by ASTMatchers.
Having own copy here allows us to remove the other one from llvm/ADT.
Also, we can extend the API to our needs without modifying the common
implementation.

[sbenza]

Alex, this is what we discussed to make hasAnyName take a vector<StringRef> directly.

[alexfh]

LG

include/clang/ASTMatchers/ASTMatchersInternal.h

80 ↗

(On Diff #51053)

It's unfortunate that we need to create an array of the argument pointers here, but it seems there's no larger common denominator of the two ways this functions can be called.

One nit though: SmallVector will be a better container here.

[sbenza]

Minor fix

include/clang/ASTMatchers/ASTMatchersInternal.h

80 ↗

(On Diff #51053)

It's unfortunate that we need to create an array of the argument pointers here, but it seems there's no larger common denominator of the two ways this functions can be called.

Now that we control it, we can change it to be something different.
For example, instead of passing a function pointer as template parameter we could pass a class that contains overloaded operator() for both ArrayRef<T> and ArrayRef<const T*>.

On the other hand, constructing the matchers has never been the performance bottleneck of the framework.
They are usually created once and used thousands/millions of times.
Might not be worth it to optimize this too much.

One nit though: SmallVector will be a better container here.

Done.

[alexfh]

Still LG.

include/clang/ASTMatchers/ASTMatchersInternal.h

82 ↗

(On Diff #51447)

On the other hand, constructing the matchers has never been the performance bottleneck of the framework.

I was confused then. I thought, the operator() in question gets called when traversing the AST, not when constructing the matcher.

[etienneb]

Any plan for doing the same for : hasOverloadedOperatorName ?

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

 /// This matcher is only provided as a performance optimization of hasName.
 /// \code
 ///     hasAnyName(a, b, c)
 /// \endcode
 ///  is equivalent to, but faster than
 /// \code
 ///     anyOf(hasName(a), hasName(b), hasName(c))
 /// \endcode
-const llvm::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
+const internal::VariadicFunction<internal::Matcher<NamedDecl>, StringRef,
                                  internal::hasAnyNameFunc>
     hasAnyName = {};
 
 /// \brief Matches NamedDecl nodes whose fully qualified names contain
 /// a substring matched by the given RegExp.
 ///
 /// Supports specifying enclosing namespaces or classes by
 /// prefixing the name with '<enclosing>::'.  Does not match typedefs
 /// of an underlying type with the given name.

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

 #include "clang/AST/DeclObjC.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/ExprObjC.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/StmtObjC.h"
 #include "clang/AST/Type.h"
+#include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/Optional.h"
-#include "llvm/ADT/VariadicFunction.h"
+#include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/ManagedStatic.h"
 #include <map>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace ast_matchers {
 
 class BoundNodes;
 
 namespace internal {
 
+/// \brief Variadic function object.
+///
+/// Most of the functions below that use VariadicFunction could be implemented
+/// using plain C++11 variadic functions, but the function object allows us to
+/// capture it on the dynamic matcher registry.
+template <typename ResultT, typename ArgT,
+          ResultT (*Func)(ArrayRef<const ArgT *>)>
+struct VariadicFunction {
+  ResultT operator()() const { return Func({}); }
+
+  template <typename... ArgsT>
+  ResultT operator()(const ArgT &Arg1, const ArgsT &... Args) const {
+    return Execute(Arg1, static_cast<const ArgT &>(Args)...);
+  }
+
+  // We also allow calls with an already created array, in case the caller
+  // already had it.
+  ResultT operator()(ArrayRef<ArgT> Args) const {
+    SmallVector<const ArgT*, 8> InnerArgs;
+    for (const ArgT &Arg : Args)
+      InnerArgs.push_back(&Arg);
+    return Func(InnerArgs);
+  }
+
+private:
+  // Trampoline function to allow for implicit conversions to take place
+  // before we make the array.
+  template <typename... ArgsT> ResultT Execute(const ArgsT &... Args) const {
+    const ArgT *const ArgsArray[] = {&Args...};
+    return Func(ArgsArray);
+  }
+};
+
 /// \brief Unifies obtaining the underlying type of a regular node through
 /// `getType` and a TypedefNameDecl node through `getUnderlyingType`.
 template <typename NodeType>
 inline QualType getUnderlyingType(const NodeType &Node) {
   return Node.getType();
 }
 
 template <> inline QualType getUnderlyingType(const TypedefDecl &Node) {

 ///   const VariadicDynCastAllOfMatcher<
 ///       Decl, CXXRecordDecl> record;
 /// Creates a functor record(...) that creates a Matcher<Decl> given
 /// a variable number of arguments of type Matcher<CXXRecordDecl>.
 /// The returned matcher matches if the given Decl can by dynamically
 /// casted to CXXRecordDecl and all given matchers match.
 template <typename SourceT, typename TargetT>
 class VariadicDynCastAllOfMatcher
-    : public llvm::VariadicFunction<
-        BindableMatcher<SourceT>, Matcher<TargetT>,
-        makeDynCastAllOfComposite<SourceT, TargetT> > {
+    : public VariadicFunction<BindableMatcher<SourceT>, Matcher<TargetT>,
+                              makeDynCastAllOfComposite<SourceT, TargetT>> {
 public:
   VariadicDynCastAllOfMatcher() {}
 };
 
 /// \brief A \c VariadicAllOfMatcher<T> object is a variadic functor that takes
 /// a number of \c Matcher<T> and returns a \c Matcher<T> that matches \c T
 /// nodes that are matched by all of the given matchers.
 ///
 /// For example:
 ///   const VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier;
 /// Creates a functor nestedNameSpecifier(...) that creates a
 /// \c Matcher<NestedNameSpecifier> given a variable number of arguments of type
 /// \c Matcher<NestedNameSpecifier>.
 /// The returned matcher matches if all given matchers match.
 template <typename T>
-class VariadicAllOfMatcher : public llvm::VariadicFunction<
-                               BindableMatcher<T>, Matcher<T>,
-                               makeAllOfComposite<T> > {
+class VariadicAllOfMatcher
+    : public VariadicFunction<BindableMatcher<T>, Matcher<T>,
+                              makeAllOfComposite<T>> {
 public:
   VariadicAllOfMatcher() {}
 };
 
 /// \brief Matches nodes of type \c TLoc for which the inner
 /// \c Matcher<T> matches.
 template <typename TLoc, typename T>
 class LocMatcher : public WrapperMatcherInterface<TLoc> {
explicit TypeTraversePolymorphicMatcher(
       ArrayRef<const Matcher<InnerTBase> *> InnerMatchers)
       : InnerMatcher(makeAllOfComposite(InnerMatchers)) {}
 
   template <typename OuterT> operator Matcher<OuterT>() const {
     return Matcher<OuterT>(
         new MatcherImpl<OuterT>(InnerMatcher, Getter<OuterT>::value()));
   }
 
-  struct Func : public llvm::VariadicFunction<Self, Matcher<InnerTBase>,
-                                              &Self::create> {
+  struct Func
+      : public VariadicFunction<Self, Matcher<InnerTBase>, &Self::create> {
     Func() {}
   };
 
 private:
   const Matcher<InnerTBase> InnerMatcher;
 };
 
 /// \brief A simple memoizer of T(*)() functions.

cfe/trunk/lib/ASTMatchers/Dynamic/Marshallers.h

 public:
   typedef VariantMatcher (*RunFunc)(StringRef MatcherName,
                                     SourceRange NameRange,
                                     ArrayRef<ParserValue> Args,
                                     Diagnostics *Error);
 
   template <typename ResultT, typename ArgT,
             ResultT (*F)(ArrayRef<const ArgT *>)>
-  VariadicFuncMatcherDescriptor(llvm::VariadicFunction<ResultT, ArgT, F> Func,
-                          StringRef MatcherName)
+  VariadicFuncMatcherDescriptor(
+      ast_matchers::internal::VariadicFunction<ResultT, ArgT, F> Func,
       : Func(&variadicMatcherDescriptor<ResultT, ArgT, F>),
         MatcherName(MatcherName.str()),
         ArgsKind(ArgTypeTraits<ArgT>::getKind()) {
     BuildReturnTypeVector<ResultT>::build(RetKinds);
   }
 
   VariantMatcher create(SourceRange NameRange,
                         ArrayRef<ParserValue> Args,
MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2),
   return new FixedArgCountMatcherDescriptor(
       matcherMarshall2<ReturnType, ArgType1, ArgType2>,
       reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AKs);
 }
 
 /// \brief Variadic overload.
 template <typename ResultT, typename ArgT,
           ResultT (*Func)(ArrayRef<const ArgT *>)>
-MatcherDescriptor *
-makeMatcherAutoMarshall(llvm::VariadicFunction<ResultT, ArgT, Func> VarFunc,
-                        StringRef MatcherName) {
+MatcherDescriptor *makeMatcherAutoMarshall(
+    ast_matchers::internal::VariadicFunction<ResultT, ArgT, Func> VarFunc,
   return new VariadicFuncMatcherDescriptor(VarFunc, MatcherName);
 }
 
 /// \brief Overload for VariadicDynCastAllOfMatchers.
 ///
 /// Not strictly necessary, but DynCastAllOfMatcherDescriptor gives us better
 /// completion results for that type of matcher.
 template <typename BaseT, typename DerivedT>

cfe/trunk/unittests/ASTMatchers/ASTMatchersTest.cpp

TEST(Matcher, HasAnyName) {
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "a::b::C"))));
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("a::b::C", "XX"))));
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX::C", "a::b::C"))));
   EXPECT_TRUE(matches(Code, recordDecl(hasAnyName("XX", "C"))));
 
   EXPECT_TRUE(notMatches(Code, recordDecl(hasAnyName("::C", "::b::C"))));
   EXPECT_TRUE(
       matches(Code, recordDecl(hasAnyName("::C", "::b::C", "::a::b::C"))));
+
+  std::vector<StringRef> Names = {"::C", "::b::C", "::a::b::C"};
+  EXPECT_TRUE(matches(Code, recordDecl(hasAnyName(Names))));
 }
 
 TEST(Matcher, IsDefinition) {
   DeclarationMatcher DefinitionOfClassA =
       recordDecl(hasName("A"), isDefinition());
   EXPECT_TRUE(matches("class A {};", DefinitionOfClassA));
   EXPECT_TRUE(notMatches("class A;", DefinitionOfClassA));