diff --git a/clang/include/clang/ASTMatchers/ASTMatchers.h b/clang/include/clang/ASTMatchers/ASTMatchers.h
index 4537c4719c90..37c7b16934bf 100644
--- a/clang/include/clang/ASTMatchers/ASTMatchers.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchers.h
@@ -1,3819 +1,3819 @@
 //===--- ASTMatchers.h - Structural query framework -------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file implements matchers to be used together with the MatchFinder to
 //  match AST nodes.
 //
 //  Matchers are created by generator functions, which can be combined in
 //  a functional in-language DSL to express queries over the C++ AST.
 //
 //  For example, to match a class with a certain name, one would call:
 //    recordDecl(hasName("MyClass"))
 //  which returns a matcher that can be used to find all AST nodes that declare
 //  a class named 'MyClass'.
 //
 //  For more complicated match expressions we're often interested in accessing
 //  multiple parts of the matched AST nodes once a match is found. In that case,
 //  use the id(...) matcher around the match expressions that match the nodes
 //  you want to access.
 //
 //  For example, when we're interested in child classes of a certain class, we
 //  would write:
 //    recordDecl(hasName("MyClass"), hasChild(id("child", recordDecl())))
 //  When the match is found via the MatchFinder, a user provided callback will
 //  be called with a BoundNodes instance that contains a mapping from the
 //  strings that we provided for the id(...) calls to the nodes that were
 //  matched.
 //  In the given example, each time our matcher finds a match we get a callback
 //  where "child" is bound to the CXXRecordDecl node of the matching child
 //  class declaration.
 //
 //  See ASTMatchersInternal.h for a more in-depth explanation of the
 //  implementation details of the matcher framework.
 //
 //  See ASTMatchFinder.h for how to use the generated matchers to run over
 //  an AST.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H
 #define LLVM_CLANG_ASTMATCHERS_ASTMATCHERS_H
 
 #include "clang/AST/DeclFriend.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "clang/ASTMatchers/ASTMatchersMacros.h"
 #include "llvm/ADT/Twine.h"
 #include "llvm/Support/Regex.h"
 #include <iterator>
 
 namespace clang {
 namespace ast_matchers {
 
 /// \brief Maps string IDs to AST nodes matched by parts of a matcher.
 ///
 /// The bound nodes are generated by calling \c bind("id") on the node matchers
 /// of the nodes we want to access later.
 ///
 /// The instances of BoundNodes are created by \c MatchFinder when the user's
 /// callbacks are executed every time a match is found.
 class BoundNodes {
 public:
   /// \brief Returns the AST node bound to \c ID.
   ///
   /// Returns NULL if there was no node bound to \c ID or if there is a node but
   /// it cannot be converted to the specified type.
   template <typename T>
   const T *getNodeAs(StringRef ID) const {
     return MyBoundNodes.getNodeAs<T>(ID);
   }
 
   /// \brief Deprecated. Please use \c getNodeAs instead.
   /// @{
   template <typename T>
   const T *getDeclAs(StringRef ID) const {
     return getNodeAs<T>(ID);
   }
   template <typename T>
   const T *getStmtAs(StringRef ID) const {
     return getNodeAs<T>(ID);
   }
   /// @}
 
   /// \brief Type of mapping from binding identifiers to bound nodes. This type
   /// is an associative container with a key type of \c std::string and a value
   /// type of \c clang::ast_type_traits::DynTypedNode
   typedef internal::BoundNodesMap::IDToNodeMap IDToNodeMap;
 
   /// \brief Retrieve mapping from binding identifiers to bound nodes.
   const IDToNodeMap &getMap() const {
     return MyBoundNodes.getMap();
   }
 
 private:
   /// \brief Create BoundNodes from a pre-filled map of bindings.
   BoundNodes(internal::BoundNodesMap &MyBoundNodes)
       : MyBoundNodes(MyBoundNodes) {}
 
   internal::BoundNodesMap MyBoundNodes;
 
   friend class internal::BoundNodesTreeBuilder;
 };
 
 /// \brief If the provided matcher matches a node, binds the node to \c ID.
 ///
 /// FIXME: Do we want to support this now that we have bind()?
 template <typename T>
 internal::Matcher<T> id(const std::string &ID,
                         const internal::BindableMatcher<T> &InnerMatcher) {
   return InnerMatcher.bind(ID);
 }
 
 /// \brief Types of matchers for the top-level classes in the AST class
 /// hierarchy.
 /// @{
 typedef internal::Matcher<Decl> DeclarationMatcher;
 typedef internal::Matcher<Stmt> StatementMatcher;
 typedef internal::Matcher<QualType> TypeMatcher;
 typedef internal::Matcher<TypeLoc> TypeLocMatcher;
 typedef internal::Matcher<NestedNameSpecifier> NestedNameSpecifierMatcher;
 typedef internal::Matcher<NestedNameSpecifierLoc> NestedNameSpecifierLocMatcher;
 /// @}
 
 /// \brief Matches any node.
 ///
 /// Useful when another matcher requires a child matcher, but there's no
 /// additional constraint. This will often be used with an explicit conversion
 /// to an \c internal::Matcher<> type such as \c TypeMatcher.
 ///
 /// Example: \c DeclarationMatcher(anything()) matches all declarations, e.g.,
 /// \code
 /// "int* p" and "void f()" in
 ///   int* p;
 ///   void f();
 /// \endcode
 ///
 /// Usable as: Any Matcher
 inline internal::TrueMatcher anything() { return internal::TrueMatcher(); }
 
 /// \brief Matches declarations.
 ///
 /// Examples matches \c X, \c C, and the friend declaration inside \c C;
 /// \code
 ///   void X();
 ///   class C {
 ///     friend X;
 ///   };
 /// \endcode
 const internal::VariadicAllOfMatcher<Decl> decl;
 
 /// \brief Matches a declaration of a linkage specification.
 ///
 /// Given
 /// \code
 ///   extern "C" {}
 /// \endcode
 /// linkageSpecDecl()
 ///   matches "extern "C" {}"
 const internal::VariadicDynCastAllOfMatcher<Decl, LinkageSpecDecl>
     linkageSpecDecl;
 
 /// \brief Matches a declaration of anything that could have a name.
 ///
 /// Example matches \c X, \c S, the anonymous union type, \c i, and \c U;
 /// \code
 ///   typedef int X;
 ///   struct S {
 ///     union {
 ///       int i;
 ///     } U;
 ///   };
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, NamedDecl> namedDecl;
 
 /// \brief Matches a declaration of a namespace.
 ///
 /// Given
 /// \code
 ///   namespace {}
 ///   namespace test {}
 /// \endcode
 /// namespaceDecl()
 ///   matches "namespace {}" and "namespace test {}"
 const internal::VariadicDynCastAllOfMatcher<Decl, NamespaceDecl> namespaceDecl;
 
 /// \brief Matches C++ class declarations.
 ///
 /// Example matches \c X, \c Z
 /// \code
 ///   class X;
 ///   template<class T> class Z {};
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   CXXRecordDecl> recordDecl;
 
 /// \brief Matches C++ class template declarations.
 ///
 /// Example matches \c Z
 /// \code
 ///   template<class T> class Z {};
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   ClassTemplateDecl> classTemplateDecl;
 
 /// \brief Matches C++ class template specializations.
 ///
 /// Given
 /// \code
 ///   template<typename T> class A {};
 ///   template<> class A<double> {};
 ///   A<int> a;
 /// \endcode
 /// classTemplateSpecializationDecl()
 ///   matches the specializations \c A<int> and \c A<double>
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   ClassTemplateSpecializationDecl> classTemplateSpecializationDecl;
 
 /// \brief Matches declarator declarations (field, variable, function
 /// and non-type template parameter declarations).
 ///
 /// Given
 /// \code
 ///   class X { int y; };
 /// \endcode
 /// declaratorDecl()
 ///   matches \c int y.
 const internal::VariadicDynCastAllOfMatcher<Decl, DeclaratorDecl>
     declaratorDecl;
 
 /// \brief Matches parameter variable declarations.
 ///
 /// Given
 /// \code
 ///   void f(int x);
 /// \endcode
 /// parmVarDecl()
 ///   matches \c int x.
 const internal::VariadicDynCastAllOfMatcher<Decl, ParmVarDecl> parmVarDecl;
 
 /// \brief Matches C++ access specifier declarations.
 ///
 /// Given
 /// \code
 ///   class C {
 ///   public:
 ///     int a;
 ///   };
 /// \endcode
 /// accessSpecDecl()
 ///   matches 'public:'
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   AccessSpecDecl> accessSpecDecl;
 
 /// \brief Matches constructor initializers.
 ///
 /// Examples matches \c i(42).
 /// \code
 ///   class C {
 ///     C() : i(42) {}
 ///     int i;
 ///   };
 /// \endcode
 const internal::VariadicAllOfMatcher<CXXCtorInitializer> ctorInitializer;
 
 /// \brief Matches template arguments.
 ///
 /// Given
 /// \code
 ///   template <typename T> struct C {};
 ///   C<int> c;
 /// \endcode
 /// templateArgument()
 ///   matches 'int' in C<int>.
 const internal::VariadicAllOfMatcher<TemplateArgument> templateArgument;
 
 /// \brief Matches public C++ declarations.
 ///
 /// Given
 /// \code
 ///   class C {
 ///   public:    int a;
 ///   protected: int b;
 ///   private:   int c;
 ///   };
 /// \endcode
 /// fieldDecl(isPublic())
 ///   matches 'int a;' 
 AST_MATCHER(Decl, isPublic) {
   return Node.getAccess() == AS_public;
 }
 
 /// \brief Matches protected C++ declarations.
 ///
 /// Given
 /// \code
 ///   class C {
 ///   public:    int a;
 ///   protected: int b;
 ///   private:   int c;
 ///   };
 /// \endcode
 /// fieldDecl(isProtected())
 ///   matches 'int b;' 
 AST_MATCHER(Decl, isProtected) {
   return Node.getAccess() == AS_protected;
 }
 
 /// \brief Matches private C++ declarations.
 ///
 /// Given
 /// \code
 ///   class C {
 ///   public:    int a;
 ///   protected: int b;
 ///   private:   int c;
 ///   };
 /// \endcode
 /// fieldDecl(isPrivate())
 ///   matches 'int c;' 
 AST_MATCHER(Decl, isPrivate) {
   return Node.getAccess() == AS_private;
 }
 
 /// \brief Matches a declaration that has been implicitly added
 /// by the compiler (eg. implicit default/copy constructors).
 AST_MATCHER(Decl, isImplicit) {
   return Node.isImplicit();
 }
 
 /// \brief Matches classTemplateSpecializations that have at least one
 /// TemplateArgument matching the given InnerMatcher.
 ///
 /// Given
 /// \code
 ///   template<typename T> class A {};
 ///   template<> class A<double> {};
 ///   A<int> a;
 /// \endcode
 /// classTemplateSpecializationDecl(hasAnyTemplateArgument(
 ///     refersToType(asString("int"))))
 ///   matches the specialization \c A<int>
 AST_POLYMORPHIC_MATCHER_P(
     hasAnyTemplateArgument,
     AST_POLYMORPHIC_SUPPORTED_TYPES_2(ClassTemplateSpecializationDecl,
                                       TemplateSpecializationType),
     internal::Matcher<TemplateArgument>, InnerMatcher) {
   ArrayRef<TemplateArgument> List =
       internal::getTemplateSpecializationArgs(Node);
   return matchesFirstInRange(InnerMatcher, List.begin(), List.end(), Finder,
                              Builder);
 }
 
 /// \brief Matches expressions that match InnerMatcher after any implicit casts
 /// are stripped off.
 ///
 /// Parentheses and explicit casts are not discarded.
 /// Given
 /// \code
 ///   int arr[5];
 ///   int a = 0;
 ///   char b = 0;
 ///   const int c = a;
 ///   int *d = arr;
 ///   long e = (long) 0l;
 /// \endcode
 /// The matchers
 /// \code
 ///    varDecl(hasInitializer(ignoringImpCasts(integerLiteral())))
 ///    varDecl(hasInitializer(ignoringImpCasts(declRefExpr())))
 /// \endcode
 /// would match the declarations for a, b, c, and d, but not e.
 /// While
 /// \code
 ///    varDecl(hasInitializer(integerLiteral()))
 ///    varDecl(hasInitializer(declRefExpr()))
 /// \endcode
 /// only match the declarations for b, c, and d.
 AST_MATCHER_P(Expr, ignoringImpCasts,
               internal::Matcher<Expr>, InnerMatcher) {
   return InnerMatcher.matches(*Node.IgnoreImpCasts(), Finder, Builder);
 }
 
 /// \brief Matches expressions that match InnerMatcher after parentheses and
 /// casts are stripped off.
 ///
 /// Implicit and non-C Style casts are also discarded.
 /// Given
 /// \code
 ///   int a = 0;
 ///   char b = (0);
 ///   void* c = reinterpret_cast<char*>(0);
 ///   char d = char(0);
 /// \endcode
 /// The matcher
 ///    varDecl(hasInitializer(ignoringParenCasts(integerLiteral())))
 /// would match the declarations for a, b, c, and d.
 /// while
 ///    varDecl(hasInitializer(integerLiteral()))
 /// only match the declaration for a.
 AST_MATCHER_P(Expr, ignoringParenCasts, internal::Matcher<Expr>, InnerMatcher) {
   return InnerMatcher.matches(*Node.IgnoreParenCasts(), Finder, Builder);
 }
 
 /// \brief Matches expressions that match InnerMatcher after implicit casts and
 /// parentheses are stripped off.
 ///
 /// Explicit casts are not discarded.
 /// Given
 /// \code
 ///   int arr[5];
 ///   int a = 0;
 ///   char b = (0);
 ///   const int c = a;
 ///   int *d = (arr);
 ///   long e = ((long) 0l);
 /// \endcode
 /// The matchers
 ///    varDecl(hasInitializer(ignoringParenImpCasts(integerLiteral())))
 ///    varDecl(hasInitializer(ignoringParenImpCasts(declRefExpr())))
 /// would match the declarations for a, b, c, and d, but not e.
 /// while
 ///    varDecl(hasInitializer(integerLiteral()))
 ///    varDecl(hasInitializer(declRefExpr()))
 /// would only match the declaration for a.
 AST_MATCHER_P(Expr, ignoringParenImpCasts,
               internal::Matcher<Expr>, InnerMatcher) {
   return InnerMatcher.matches(*Node.IgnoreParenImpCasts(), Finder, Builder);
 }
 
 /// \brief Matches classTemplateSpecializations where the n'th TemplateArgument
 /// matches the given InnerMatcher.
 ///
 /// Given
 /// \code
 ///   template<typename T, typename U> class A {};
 ///   A<bool, int> b;
 ///   A<int, bool> c;
 /// \endcode
 /// classTemplateSpecializationDecl(hasTemplateArgument(
 ///     1, refersToType(asString("int"))))
 ///   matches the specialization \c A<bool, int>
 AST_POLYMORPHIC_MATCHER_P2(
     hasTemplateArgument,
     AST_POLYMORPHIC_SUPPORTED_TYPES_2(ClassTemplateSpecializationDecl,
                                       TemplateSpecializationType),
     unsigned, N, internal::Matcher<TemplateArgument>, InnerMatcher) {
   ArrayRef<TemplateArgument> List =
       internal::getTemplateSpecializationArgs(Node);
   if (List.size() <= N)
     return false;
   return InnerMatcher.matches(List[N], Finder, Builder);
 }
 
 /// \brief Matches if the number of template arguments equals \p N.
 ///
 /// Given
 /// \code
 ///   template<typename T> struct C {};
 ///   C<int> c;
 /// \endcode
 /// classTemplateSpecializationDecl(templateArgumentCountIs(1))
 ///   matches C<int>.
 AST_POLYMORPHIC_MATCHER_P(
     templateArgumentCountIs,
     AST_POLYMORPHIC_SUPPORTED_TYPES_2(ClassTemplateSpecializationDecl,
                                       TemplateSpecializationType),
     unsigned, N) {
   return internal::getTemplateSpecializationArgs(Node).size() == N;
 }
 
 /// \brief Matches a TemplateArgument that refers to a certain type.
 ///
 /// Given
 /// \code
 ///   struct X {};
 ///   template<typename T> struct A {};
 ///   A<X> a;
 /// \endcode
 /// classTemplateSpecializationDecl(hasAnyTemplateArgument(
 ///     refersToType(class(hasName("X")))))
 ///   matches the specialization \c A<X>
 AST_MATCHER_P(TemplateArgument, refersToType,
               internal::Matcher<QualType>, InnerMatcher) {
   if (Node.getKind() != TemplateArgument::Type)
     return false;
   return InnerMatcher.matches(Node.getAsType(), Finder, Builder);
 }
 
 /// \brief Matches a canonical TemplateArgument that refers to a certain
 /// declaration.
 ///
 /// Given
 /// \code
 ///   template<typename T> struct A {};
 ///   struct B { B* next; };
 ///   A<&B::next> a;
 /// \endcode
 /// classTemplateSpecializationDecl(hasAnyTemplateArgument(
 ///     refersToDeclaration(fieldDecl(hasName("next"))))
 ///   matches the specialization \c A<&B::next> with \c fieldDecl(...) matching
 ///     \c B::next
 AST_MATCHER_P(TemplateArgument, refersToDeclaration,
               internal::Matcher<Decl>, InnerMatcher) {
   if (Node.getKind() == TemplateArgument::Declaration)
     return InnerMatcher.matches(*Node.getAsDecl(), Finder, Builder);
   return false;
 }
 
 /// \brief Matches a sugar TemplateArgument that refers to a certain expression.
 ///
 /// Given
 /// \code
 ///   template<typename T> struct A {};
 ///   struct B { B* next; };
 ///   A<&B::next> a;
 /// \endcode
 /// templateSpecializationType(hasAnyTemplateArgument(
 ///   isExpr(hasDescendant(declRefExpr(to(fieldDecl(hasName("next"))))))))
 ///   matches the specialization \c A<&B::next> with \c fieldDecl(...) matching
 ///     \c B::next
 AST_MATCHER_P(TemplateArgument, isExpr, internal::Matcher<Expr>, InnerMatcher) {
   if (Node.getKind() == TemplateArgument::Expression)
     return InnerMatcher.matches(*Node.getAsExpr(), Finder, Builder);
   return false;
 }
 
 /// \brief Matches a TemplateArgument that is an integral value.
 ///
 /// Given
 /// \code
 ///   template<int T> struct A {};
 ///   C<42> c;
 /// \endcode
 /// classTemplateSpecializationDecl(
 ///   hasAnyTemplateArgument(isIntegral()))
 ///   matches the implicit instantiation of C in C<42>
 ///   with isIntegral() matching 42.
 AST_MATCHER(TemplateArgument, isIntegral) {
   return Node.getKind() == TemplateArgument::Integral;
 }
 
 /// \brief Matches a TemplateArgument that referes to an integral type.
 ///
 /// Given
 /// \code
 ///   template<int T> struct A {};
 ///   C<42> c;
 /// \endcode
 /// classTemplateSpecializationDecl(
 ///   hasAnyTemplateArgument(refersToIntegralType(asString("int"))))
 ///   matches the implicit instantiation of C in C<42>.
 AST_MATCHER_P(TemplateArgument, refersToIntegralType,
               internal::Matcher<QualType>, InnerMatcher) {
   if (Node.getKind() != TemplateArgument::Integral)
     return false;
   return InnerMatcher.matches(Node.getIntegralType(), Finder, Builder);
 }
 
 /// \brief Matches a TemplateArgument of integral type with a given value.
 ///
 /// Note that 'Value' is a string as the template argument's value is
 /// an arbitrary precision integer. 'Value' must be euqal to the canonical
 /// representation of that integral value in base 10.
 ///
 /// Given
 /// \code
 ///   template<int T> struct A {};
 ///   C<42> c;
 /// \endcode
 /// classTemplateSpecializationDecl(
 ///   hasAnyTemplateArgument(equalsIntegralValue("42")))
 ///   matches the implicit instantiation of C in C<42>.
 AST_MATCHER_P(TemplateArgument, equalsIntegralValue,
               std::string, Value) {
   if (Node.getKind() != TemplateArgument::Integral)
     return false;
   return Node.getAsIntegral().toString(10) == Value;
 }
 
 /// \brief Matches any value declaration.
 ///
 /// Example matches A, B, C and F
 /// \code
 ///   enum X { A, B, C };
 ///   void F();
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, ValueDecl> valueDecl;
 
 /// \brief Matches C++ constructor declarations.
 ///
 /// Example matches Foo::Foo() and Foo::Foo(int)
 /// \code
 ///   class Foo {
 ///    public:
 ///     Foo();
 ///     Foo(int);
 ///     int DoSomething();
 ///   };
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   CXXConstructorDecl> constructorDecl;
 
 /// \brief Matches explicit C++ destructor declarations.
 ///
 /// Example matches Foo::~Foo()
 /// \code
 ///   class Foo {
 ///    public:
 ///     virtual ~Foo();
 ///   };
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   CXXDestructorDecl> destructorDecl;
 
 /// \brief Matches enum declarations.
 ///
 /// Example matches X
 /// \code
 ///   enum X {
 ///     A, B, C
 ///   };
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, EnumDecl> enumDecl;
 
 /// \brief Matches enum constants.
 ///
 /// Example matches A, B, C
 /// \code
 ///   enum X {
 ///     A, B, C
 ///   };
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   EnumConstantDecl> enumConstantDecl;
 
 /// \brief Matches method declarations.
 ///
 /// Example matches y
 /// \code
 ///   class X { void y(); };
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, CXXMethodDecl> methodDecl;
 
 /// \brief Matches variable declarations.
 ///
 /// Note: this does not match declarations of member variables, which are
 /// "field" declarations in Clang parlance.
 ///
 /// Example matches a
 /// \code
 ///   int a;
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, VarDecl> varDecl;
 
 /// \brief Matches field declarations.
 ///
 /// Given
 /// \code
 ///   class X { int m; };
 /// \endcode
 /// fieldDecl()
 ///   matches 'm'.
 const internal::VariadicDynCastAllOfMatcher<Decl, FieldDecl> fieldDecl;
 
 /// \brief Matches function declarations.
 ///
 /// Example matches f
 /// \code
 ///   void f();
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, FunctionDecl> functionDecl;
 
 /// \brief Matches C++ function template declarations.
 ///
 /// Example matches f
 /// \code
 ///   template<class T> void f(T t) {}
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   FunctionTemplateDecl> functionTemplateDecl;
 
 /// \brief Matches friend declarations.
 ///
 /// Given
 /// \code
 ///   class X { friend void foo(); };
 /// \endcode
 /// friendDecl()
 ///   matches 'friend void foo()'.
 const internal::VariadicDynCastAllOfMatcher<Decl, FriendDecl> friendDecl;
 
 /// \brief Matches statements.
 ///
 /// Given
 /// \code
 ///   { ++a; }
 /// \endcode
 /// stmt()
 ///   matches both the compound statement '{ ++a; }' and '++a'.
 const internal::VariadicAllOfMatcher<Stmt> stmt;
 
 /// \brief Matches declaration statements.
 ///
 /// Given
 /// \code
 ///   int a;
 /// \endcode
 /// declStmt()
 ///   matches 'int a'.
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   DeclStmt> declStmt;
 
 /// \brief Matches member expressions.
 ///
 /// Given
 /// \code
 ///   class Y {
 ///     void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; }
 ///     int a; static int b;
 ///   };
 /// \endcode
 /// memberExpr()
 ///   matches this->x, x, y.x, a, this->b
 const internal::VariadicDynCastAllOfMatcher<Stmt, MemberExpr> memberExpr;
 
 /// \brief Matches call expressions.
 ///
 /// Example matches x.y() and y()
 /// \code
 ///   X x;
 ///   x.y();
 ///   y();
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, CallExpr> callExpr;
 
 /// \brief Matches lambda expressions.
 ///
 /// Example matches [&](){return 5;}
 /// \code
 ///   [&](){return 5;}
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, LambdaExpr> lambdaExpr;
 
 /// \brief Matches member call expressions.
 ///
 /// Example matches x.y()
 /// \code
 ///   X x;
 ///   x.y();
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXMemberCallExpr> memberCallExpr;
 
 /// \brief Matches expressions that introduce cleanups to be run at the end
 /// of the sub-expression's evaluation.
 ///
 /// Example matches std::string()
 /// \code
 ///   const std::string str = std::string();
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, ExprWithCleanups>
 exprWithCleanups;
 
 /// \brief Matches init list expressions.
 ///
 /// Given
 /// \code
 ///   int a[] = { 1, 2 };
 ///   struct B { int x, y; };
 ///   B b = { 5, 6 };
 /// \endcode
 /// initListExpr()
 ///   matches "{ 1, 2 }" and "{ 5, 6 }"
 const internal::VariadicDynCastAllOfMatcher<Stmt, InitListExpr> initListExpr;
 
 /// \brief Matches substitutions of non-type template parameters.
 ///
 /// Given
 /// \code
 ///   template <int N>
 ///   struct A { static const int n = N; };
 ///   struct B : public A<42> {};
 /// \endcode
 /// substNonTypeTemplateParmExpr()
 ///   matches "N" in the right-hand side of "static const int n = N;"
 const internal::VariadicDynCastAllOfMatcher<Stmt, SubstNonTypeTemplateParmExpr>
 substNonTypeTemplateParmExpr;
 
 /// \brief Matches using declarations.
 ///
 /// Given
 /// \code
 ///   namespace X { int x; }
 ///   using X::x;
 /// \endcode
 /// usingDecl()
 ///   matches \code using X::x \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDecl> usingDecl;
 
 /// \brief Matches using namespace declarations.
 ///
 /// Given
 /// \code
 ///   namespace X { int x; }
 ///   using namespace X;
 /// \endcode
 /// usingDirectiveDecl()
 ///   matches \code using namespace X \endcode
 const internal::VariadicDynCastAllOfMatcher<Decl, UsingDirectiveDecl>
     usingDirectiveDecl;
 
 /// \brief Matches unresolved using value declarations.
 ///
 /// Given
 /// \code
 ///   template<typename X>
 ///   class C : private X {
 ///     using X::x;
 ///   };
 /// \endcode
 /// unresolvedUsingValueDecl()
 ///   matches \code using X::x \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Decl,
   UnresolvedUsingValueDecl> unresolvedUsingValueDecl;
 
 /// \brief Matches constructor call expressions (including implicit ones).
 ///
 /// Example matches string(ptr, n) and ptr within arguments of f
 ///     (matcher = constructExpr())
 /// \code
 ///   void f(const string &a, const string &b);
 ///   char *ptr;
 ///   int n;
 ///   f(string(ptr, n), ptr);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXConstructExpr> constructExpr;
 
 /// \brief Matches unresolved constructor call expressions.
 ///
 /// Example matches T(t) in return statement of f
 ///     (matcher = unresolvedConstructExpr())
 /// \code
 ///   template <typename T>
 ///   void f(const T& t) { return T(t); }
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXUnresolvedConstructExpr> unresolvedConstructExpr;
 
 /// \brief Matches implicit and explicit this expressions.
 ///
 /// Example matches the implicit this expression in "return i".
 ///     (matcher = thisExpr())
 /// \code
 /// struct foo {
 ///   int i;
 ///   int f() { return i; }
 /// };
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThisExpr> thisExpr;
 
 /// \brief Matches nodes where temporaries are created.
 ///
 /// Example matches FunctionTakesString(GetStringByValue())
 ///     (matcher = bindTemporaryExpr())
 /// \code
 ///   FunctionTakesString(GetStringByValue());
 ///   FunctionTakesStringByPointer(GetStringPointer());
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXBindTemporaryExpr> bindTemporaryExpr;
 
 /// \brief Matches nodes where temporaries are materialized.
 ///
 /// Example: Given
 /// \code
 ///   struct T {void func()};
 ///   T f();
 ///   void g(T);
 /// \endcode
 /// materializeTemporaryExpr() matches 'f()' in these statements
 /// \code
 ///   T u(f());
 ///   g(f());
 /// \endcode
 /// but does not match
 /// \code
 ///   f();
 ///   f().func();
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   MaterializeTemporaryExpr> materializeTemporaryExpr;
 
 /// \brief Matches new expressions.
 ///
 /// Given
 /// \code
 ///   new X;
 /// \endcode
 /// newExpr()
 ///   matches 'new X'.
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXNewExpr> newExpr;
 
 /// \brief Matches delete expressions.
 ///
 /// Given
 /// \code
 ///   delete X;
 /// \endcode
 /// deleteExpr()
 ///   matches 'delete X'.
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXDeleteExpr> deleteExpr;
 
 /// \brief Matches array subscript expressions.
 ///
 /// Given
 /// \code
 ///   int i = a[1];
 /// \endcode
 /// arraySubscriptExpr()
 ///   matches "a[1]"
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   ArraySubscriptExpr> arraySubscriptExpr;
 
 /// \brief Matches the value of a default argument at the call site.
 ///
 /// Example matches the CXXDefaultArgExpr placeholder inserted for the
 ///     default value of the second parameter in the call expression f(42)
 ///     (matcher = defaultArgExpr())
 /// \code
 ///   void f(int x, int y = 0);
 ///   f(42);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXDefaultArgExpr> defaultArgExpr;
 
 /// \brief Matches overloaded operator calls.
 ///
 /// Note that if an operator isn't overloaded, it won't match. Instead, use
 /// binaryOperator matcher.
 /// Currently it does not match operators such as new delete.
 /// FIXME: figure out why these do not match?
 ///
 /// Example matches both operator<<((o << b), c) and operator<<(o, b)
 ///     (matcher = operatorCallExpr())
 /// \code
 ///   ostream &operator<< (ostream &out, int i) { };
 ///   ostream &o; int b = 1, c = 1;
 ///   o << b << c;
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXOperatorCallExpr> operatorCallExpr;
 
 /// \brief Matches expressions.
 ///
 /// Example matches x()
 /// \code
 ///   void f() { x(); }
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, Expr> expr;
 
 /// \brief Matches expressions that refer to declarations.
 ///
 /// Example matches x in if (x)
 /// \code
 ///   bool x;
 ///   if (x) {}
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, DeclRefExpr> declRefExpr;
 
 /// \brief Matches if statements.
 ///
 /// Example matches 'if (x) {}'
 /// \code
 ///   if (x) {}
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, IfStmt> ifStmt;
 
 /// \brief Matches for statements.
 ///
 /// Example matches 'for (;;) {}'
 /// \code
 ///   for (;;) {}
 ///   int i[] =  {1, 2, 3}; for (auto a : i);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, ForStmt> forStmt;
 
 /// \brief Matches the increment statement of a for loop.
 ///
 /// Example:
 ///     forStmt(hasIncrement(unaryOperator(hasOperatorName("++"))))
 /// matches '++x' in
 /// \code
 ///     for (x; x < N; ++x) { }
 /// \endcode
 AST_MATCHER_P(ForStmt, hasIncrement, internal::Matcher<Stmt>,
               InnerMatcher) {
   const Stmt *const Increment = Node.getInc();
   return (Increment != nullptr &&
           InnerMatcher.matches(*Increment, Finder, Builder));
 }
 
 /// \brief Matches the initialization statement of a for loop.
 ///
 /// Example:
 ///     forStmt(hasLoopInit(declStmt()))
 /// matches 'int x = 0' in
 /// \code
 ///     for (int x = 0; x < N; ++x) { }
 /// \endcode
 AST_MATCHER_P(ForStmt, hasLoopInit, internal::Matcher<Stmt>,
               InnerMatcher) {
   const Stmt *const Init = Node.getInit();
   return (Init != nullptr && InnerMatcher.matches(*Init, Finder, Builder));
 }
 
 /// \brief Matches range-based for statements.
 ///
 /// forRangeStmt() matches 'for (auto a : i)'
 /// \code
 ///   int i[] =  {1, 2, 3}; for (auto a : i);
 ///   for(int j = 0; j < 5; ++j);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXForRangeStmt> forRangeStmt;
 
 /// \brief Matches the initialization statement of a for loop.
 ///
 /// Example:
 ///     forStmt(hasLoopVariable(anything()))
 /// matches 'int x' in
 /// \code
 ///     for (int x : a) { }
 /// \endcode
 AST_MATCHER_P(CXXForRangeStmt, hasLoopVariable, internal::Matcher<VarDecl>,
               InnerMatcher) {
   const VarDecl *const Var = Node.getLoopVariable();
   return (Var != nullptr && InnerMatcher.matches(*Var, Finder, Builder));
 }
 
 /// \brief Matches the range initialization statement of a for loop.
 ///
 /// Example:
 ///     forStmt(hasRangeInit(anything()))
 /// matches 'a' in
 /// \code
 ///     for (int x : a) { }
 /// \endcode
 AST_MATCHER_P(CXXForRangeStmt, hasRangeInit, internal::Matcher<Expr>,
               InnerMatcher) {
   const Expr *const Init = Node.getRangeInit();
   return (Init != nullptr && InnerMatcher.matches(*Init, Finder, Builder));
 }
 
 /// \brief Matches while statements.
 ///
 /// Given
 /// \code
 ///   while (true) {}
 /// \endcode
 /// whileStmt()
 ///   matches 'while (true) {}'.
 const internal::VariadicDynCastAllOfMatcher<Stmt, WhileStmt> whileStmt;
 
 /// \brief Matches do statements.
 ///
 /// Given
 /// \code
 ///   do {} while (true);
 /// \endcode
 /// doStmt()
 ///   matches 'do {} while(true)'
 const internal::VariadicDynCastAllOfMatcher<Stmt, DoStmt> doStmt;
 
 /// \brief Matches break statements.
 ///
 /// Given
 /// \code
 ///   while (true) { break; }
 /// \endcode
 /// breakStmt()
 ///   matches 'break'
 const internal::VariadicDynCastAllOfMatcher<Stmt, BreakStmt> breakStmt;
 
 /// \brief Matches continue statements.
 ///
 /// Given
 /// \code
 ///   while (true) { continue; }
 /// \endcode
 /// continueStmt()
 ///   matches 'continue'
 const internal::VariadicDynCastAllOfMatcher<Stmt, ContinueStmt> continueStmt;
 
 /// \brief Matches return statements.
 ///
 /// Given
 /// \code
 ///   return 1;
 /// \endcode
 /// returnStmt()
 ///   matches 'return 1'
 const internal::VariadicDynCastAllOfMatcher<Stmt, ReturnStmt> returnStmt;
 
 /// \brief Matches goto statements.
 ///
 /// Given
 /// \code
 ///   goto FOO;
 ///   FOO: bar();
 /// \endcode
 /// gotoStmt()
 ///   matches 'goto FOO'
 const internal::VariadicDynCastAllOfMatcher<Stmt, GotoStmt> gotoStmt;
 
 /// \brief Matches label statements.
 ///
 /// Given
 /// \code
 ///   goto FOO;
 ///   FOO: bar();
 /// \endcode
 /// labelStmt()
 ///   matches 'FOO:'
 const internal::VariadicDynCastAllOfMatcher<Stmt, LabelStmt> labelStmt;
 
 /// \brief Matches switch statements.
 ///
 /// Given
 /// \code
 ///   switch(a) { case 42: break; default: break; }
 /// \endcode
 /// switchStmt()
 ///   matches 'switch(a)'.
 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchStmt> switchStmt;
 
 /// \brief Matches case and default statements inside switch statements.
 ///
 /// Given
 /// \code
 ///   switch(a) { case 42: break; default: break; }
 /// \endcode
 /// switchCase()
 ///   matches 'case 42: break;' and 'default: break;'.
 const internal::VariadicDynCastAllOfMatcher<Stmt, SwitchCase> switchCase;
 
 /// \brief Matches case statements inside switch statements.
 ///
 /// Given
 /// \code
 ///   switch(a) { case 42: break; default: break; }
 /// \endcode
 /// caseStmt()
 ///   matches 'case 42: break;'.
 const internal::VariadicDynCastAllOfMatcher<Stmt, CaseStmt> caseStmt;
 
 /// \brief Matches default statements inside switch statements.
 ///
 /// Given
 /// \code
 ///   switch(a) { case 42: break; default: break; }
 /// \endcode
 /// defaultStmt()
 ///   matches 'default: break;'.
 const internal::VariadicDynCastAllOfMatcher<Stmt, DefaultStmt> defaultStmt;
 
 /// \brief Matches compound statements.
 ///
 /// Example matches '{}' and '{{}}'in 'for (;;) {{}}'
 /// \code
 ///   for (;;) {{}}
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, CompoundStmt> compoundStmt;
 
 /// \brief Matches catch statements.
 ///
 /// \code
 ///   try {} catch(int i) {}
 /// \endcode
 /// catchStmt()
 ///   matches 'catch(int i)'
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXCatchStmt> catchStmt;
 
 /// \brief Matches try statements.
 ///
 /// \code
 ///   try {} catch(int i) {}
 /// \endcode
 /// tryStmt()
 ///   matches 'try {}'
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXTryStmt> tryStmt;
 
 /// \brief Matches throw expressions.
 ///
 /// \code
 ///   try { throw 5; } catch(int i) {}
 /// \endcode
 /// throwExpr()
 ///   matches 'throw 5'
 const internal::VariadicDynCastAllOfMatcher<Stmt, CXXThrowExpr> throwExpr;
 
 /// \brief Matches null statements.
 ///
 /// \code
 ///   foo();;
 /// \endcode
 /// nullStmt()
 ///   matches the second ';'
 const internal::VariadicDynCastAllOfMatcher<Stmt, NullStmt> nullStmt;
 
 /// \brief Matches asm statements.
 ///
 /// \code
 ///  int i = 100;
 ///   __asm("mov al, 2");
 /// \endcode
 /// asmStmt()
 ///   matches '__asm("mov al, 2")'
 const internal::VariadicDynCastAllOfMatcher<Stmt, AsmStmt> asmStmt;
 
 /// \brief Matches bool literals.
 ///
 /// Example matches true
 /// \code
 ///   true
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXBoolLiteralExpr> boolLiteral;
 
 /// \brief Matches string literals (also matches wide string literals).
 ///
 /// Example matches "abcd", L"abcd"
 /// \code
 ///   char *s = "abcd"; wchar_t *ws = L"abcd"
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   StringLiteral> stringLiteral;
 
 /// \brief Matches character literals (also matches wchar_t).
 ///
 /// Not matching Hex-encoded chars (e.g. 0x1234, which is a IntegerLiteral),
 /// though.
 ///
 /// Example matches 'a', L'a'
 /// \code
 ///   char ch = 'a'; wchar_t chw = L'a';
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CharacterLiteral> characterLiteral;
 
 /// \brief Matches integer literals of all sizes / encodings, e.g.
 /// 1, 1L, 0x1 and 1U.
 ///
 /// Does not match character-encoded integers such as L'a'.
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   IntegerLiteral> integerLiteral;
 
 /// \brief Matches float literals of all sizes / encodings, e.g.
 /// 1.0, 1.0f, 1.0L and 1e10.
 ///
 /// Does not match implicit conversions such as
 /// \code
 ///   float a = 10;
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   FloatingLiteral> floatLiteral;
 
 /// \brief Matches user defined literal operator call.
 ///
 /// Example match: "foo"_suffix
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   UserDefinedLiteral> userDefinedLiteral;
 
 /// \brief Matches compound (i.e. non-scalar) literals
 ///
 /// Example match: {1}, (1, 2)
 /// \code
 ///   int array[4] = {1}; vector int myvec = (vector int)(1, 2);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CompoundLiteralExpr> compoundLiteralExpr;
 
 /// \brief Matches nullptr literal.
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXNullPtrLiteralExpr> nullPtrLiteralExpr;
 
 /// \brief Matches binary operator expressions.
 ///
 /// Example matches a || b
 /// \code
 ///   !(a || b)
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   BinaryOperator> binaryOperator;
 
 /// \brief Matches unary operator expressions.
 ///
 /// Example matches !a
 /// \code
 ///   !a || b
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   UnaryOperator> unaryOperator;
 
 /// \brief Matches conditional operator expressions.
 ///
 /// Example matches a ? b : c
 /// \code
 ///   (a ? b : c) + 42
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   ConditionalOperator> conditionalOperator;
 
 /// \brief Matches a reinterpret_cast expression.
 ///
 /// Either the source expression or the destination type can be matched
 /// using has(), but hasDestinationType() is more specific and can be
 /// more readable.
 ///
 /// Example matches reinterpret_cast<char*>(&p) in
 /// \code
 ///   void* p = reinterpret_cast<char*>(&p);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXReinterpretCastExpr> reinterpretCastExpr;
 
 /// \brief Matches a C++ static_cast expression.
 ///
 /// \see hasDestinationType
 /// \see reinterpretCast
 ///
 /// Example:
 ///   staticCastExpr()
 /// matches
 ///   static_cast<long>(8)
 /// in
 /// \code
 ///   long eight(static_cast<long>(8));
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXStaticCastExpr> staticCastExpr;
 
 /// \brief Matches a dynamic_cast expression.
 ///
 /// Example:
 ///   dynamicCastExpr()
 /// matches
 ///   dynamic_cast<D*>(&b);
 /// in
 /// \code
 ///   struct B { virtual ~B() {} }; struct D : B {};
 ///   B b;
 ///   D* p = dynamic_cast<D*>(&b);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXDynamicCastExpr> dynamicCastExpr;
 
 /// \brief Matches a const_cast expression.
 ///
 /// Example: Matches const_cast<int*>(&r) in
 /// \code
 ///   int n = 42;
 ///   const int &r(n);
 ///   int* p = const_cast<int*>(&r);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXConstCastExpr> constCastExpr;
 
 /// \brief Matches a C-style cast expression.
 ///
 /// Example: Matches (int*) 2.2f in
 /// \code
 ///   int i = (int) 2.2f;
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CStyleCastExpr> cStyleCastExpr;
 
 /// \brief Matches explicit cast expressions.
 ///
 /// Matches any cast expression written in user code, whether it be a
 /// C-style cast, a functional-style cast, or a keyword cast.
 ///
 /// Does not match implicit conversions.
 ///
 /// Note: the name "explicitCast" is chosen to match Clang's terminology, as
 /// Clang uses the term "cast" to apply to implicit conversions as well as to
 /// actual cast expressions.
 ///
 /// \see hasDestinationType.
 ///
 /// Example: matches all five of the casts in
 /// \code
 ///   int((int)(reinterpret_cast<int>(static_cast<int>(const_cast<int>(42)))))
 /// \endcode
 /// but does not match the implicit conversion in
 /// \code
 ///   long ell = 42;
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   ExplicitCastExpr> explicitCastExpr;
 
 /// \brief Matches the implicit cast nodes of Clang's AST.
 ///
 /// This matches many different places, including function call return value
 /// eliding, as well as any type conversions.
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   ImplicitCastExpr> implicitCastExpr;
 
 /// \brief Matches any cast nodes of Clang's AST.
 ///
 /// Example: castExpr() matches each of the following:
 /// \code
 ///   (int) 3;
 ///   const_cast<Expr *>(SubExpr);
 ///   char c = 0;
 /// \endcode
 /// but does not match
 /// \code
 ///   int i = (0);
 ///   int k = 0;
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, CastExpr> castExpr;
 
 /// \brief Matches functional cast expressions
 ///
 /// Example: Matches Foo(bar);
 /// \code
 ///   Foo f = bar;
 ///   Foo g = (Foo) bar;
 ///   Foo h = Foo(bar);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXFunctionalCastExpr> functionalCastExpr;
 
 /// \brief Matches functional cast expressions having N != 1 arguments
 ///
 /// Example: Matches Foo(bar, bar)
 /// \code
 ///   Foo h = Foo(bar, bar);
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   CXXTemporaryObjectExpr> temporaryObjectExpr;
 
 /// \brief Matches \c QualTypes in the clang AST.
 const internal::VariadicAllOfMatcher<QualType> qualType;
 
 /// \brief Matches \c Types in the clang AST.
 const internal::VariadicAllOfMatcher<Type> type;
 
 /// \brief Matches \c TypeLocs in the clang AST.
 const internal::VariadicAllOfMatcher<TypeLoc> typeLoc;
 
 /// \brief Matches if any of the given matchers matches.
 ///
 /// Unlike \c anyOf, \c eachOf will generate a match result for each
 /// matching submatcher.
 ///
 /// For example, in:
 /// \code
 ///   class A { int a; int b; };
 /// \endcode
 /// The matcher:
 /// \code
 ///   recordDecl(eachOf(has(fieldDecl(hasName("a")).bind("v")),
 ///                     has(fieldDecl(hasName("b")).bind("v"))))
 /// \endcode
 /// will generate two results binding "v", the first of which binds
 /// the field declaration of \c a, the second the field declaration of
 /// \c b.
 ///
 /// Usable as: Any Matcher
 const internal::VariadicOperatorMatcherFunc<2, UINT_MAX> eachOf = {
-  internal::EachOfVariadicOperator
+  internal::DynTypedMatcher::VO_EachOf
 };
 
 /// \brief Matches if any of the given matchers matches.
 ///
 /// Usable as: Any Matcher
 const internal::VariadicOperatorMatcherFunc<2, UINT_MAX> anyOf = {
-  internal::AnyOfVariadicOperator
+  internal::DynTypedMatcher::VO_AnyOf
 };
 
 /// \brief Matches if all given matchers match.
 ///
 /// Usable as: Any Matcher
 const internal::VariadicOperatorMatcherFunc<2, UINT_MAX> allOf = {
-  internal::AllOfVariadicOperator
+  internal::DynTypedMatcher::VO_AllOf
 };
 
 /// \brief Matches sizeof (C99), alignof (C++11) and vec_step (OpenCL)
 ///
 /// Given
 /// \code
 ///   Foo x = bar;
 ///   int y = sizeof(x) + alignof(x);
 /// \endcode
 /// unaryExprOrTypeTraitExpr()
 ///   matches \c sizeof(x) and \c alignof(x)
 const internal::VariadicDynCastAllOfMatcher<
   Stmt,
   UnaryExprOrTypeTraitExpr> unaryExprOrTypeTraitExpr;
 
 /// \brief Matches unary expressions that have a specific type of argument.
 ///
 /// Given
 /// \code
 ///   int a, c; float b; int s = sizeof(a) + sizeof(b) + alignof(c);
 /// \endcode
 /// unaryExprOrTypeTraitExpr(hasArgumentOfType(asString("int"))
 ///   matches \c sizeof(a) and \c alignof(c)
 AST_MATCHER_P(UnaryExprOrTypeTraitExpr, hasArgumentOfType,
               internal::Matcher<QualType>, InnerMatcher) {
   const QualType ArgumentType = Node.getTypeOfArgument();
   return InnerMatcher.matches(ArgumentType, Finder, Builder);
 }
 
 /// \brief Matches unary expressions of a certain kind.
 ///
 /// Given
 /// \code
 ///   int x;
 ///   int s = sizeof(x) + alignof(x)
 /// \endcode
 /// unaryExprOrTypeTraitExpr(ofKind(UETT_SizeOf))
 ///   matches \c sizeof(x)
 AST_MATCHER_P(UnaryExprOrTypeTraitExpr, ofKind, UnaryExprOrTypeTrait, Kind) {
   return Node.getKind() == Kind;
 }
 
 /// \brief Same as unaryExprOrTypeTraitExpr, but only matching
 /// alignof.
 inline internal::Matcher<Stmt> alignOfExpr(
     const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
   return stmt(unaryExprOrTypeTraitExpr(allOf(
       ofKind(UETT_AlignOf), InnerMatcher)));
 }
 
 /// \brief Same as unaryExprOrTypeTraitExpr, but only matching
 /// sizeof.
 inline internal::Matcher<Stmt> sizeOfExpr(
     const internal::Matcher<UnaryExprOrTypeTraitExpr> &InnerMatcher) {
   return stmt(unaryExprOrTypeTraitExpr(
       allOf(ofKind(UETT_SizeOf), InnerMatcher)));
 }
 
 /// \brief Matches NamedDecl nodes that have the specified name.
 ///
 /// Supports specifying enclosing namespaces or classes by prefixing the name
 /// with '<enclosing>::'.
 /// Does not match typedefs of an underlying type with the given name.
 ///
 /// Example matches X (Name == "X")
 /// \code
 ///   class X;
 /// \endcode
 ///
 /// Example matches X (Name is one of "::a::b::X", "a::b::X", "b::X", "X")
 /// \code
 ///   namespace a { namespace b { class X; } }
 /// \endcode
 inline internal::Matcher<NamedDecl> hasName(const std::string &Name) {
   return internal::Matcher<NamedDecl>(new internal::HasNameMatcher(Name));
 }
 
 /// \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.
 ///
 /// Example matches X (regexp == "::X")
 /// \code
 ///   class X;
 /// \endcode
 ///
 /// Example matches X (regexp is one of "::X", "^foo::.*X", among others)
 /// \code
 ///   namespace foo { namespace bar { class X; } }
 /// \endcode
 AST_MATCHER_P(NamedDecl, matchesName, std::string, RegExp) {
   assert(!RegExp.empty());
   std::string FullNameString = "::" + Node.getQualifiedNameAsString();
   llvm::Regex RE(RegExp);
   return RE.match(FullNameString);
 }
 
 /// \brief Matches overloaded operator names.
 ///
 /// Matches overloaded operator names specified in strings without the
 /// "operator" prefix: e.g. "<<".
 ///
 /// Given:
 /// \code
 ///   class A { int operator*(); };
 ///   const A &operator<<(const A &a, const A &b);
 ///   A a;
 ///   a << a;   // <-- This matches
 /// \endcode
 ///
 /// \c operatorCallExpr(hasOverloadedOperatorName("<<"))) matches the specified
 /// line and \c recordDecl(hasMethod(hasOverloadedOperatorName("*"))) matches
 /// the declaration of \c A.
 ///
 /// Usable as: Matcher<CXXOperatorCallExpr>, Matcher<FunctionDecl>
 inline internal::PolymorphicMatcherWithParam1<
     internal::HasOverloadedOperatorNameMatcher, StringRef,
     AST_POLYMORPHIC_SUPPORTED_TYPES_2(CXXOperatorCallExpr, FunctionDecl)>
 hasOverloadedOperatorName(StringRef Name) {
   return internal::PolymorphicMatcherWithParam1<
       internal::HasOverloadedOperatorNameMatcher, StringRef,
       AST_POLYMORPHIC_SUPPORTED_TYPES_2(CXXOperatorCallExpr, FunctionDecl)>(
       Name);
 }
 
 /// \brief Matches C++ classes that are directly or indirectly derived from
 /// a class matching \c Base.
 ///
 /// Note that a class is not considered to be derived from itself.
 ///
 /// Example matches Y, Z, C (Base == hasName("X"))
 /// \code
 ///   class X;
 ///   class Y : public X {};  // directly derived
 ///   class Z : public Y {};  // indirectly derived
 ///   typedef X A;
 ///   typedef A B;
 ///   class C : public B {};  // derived from a typedef of X
 /// \endcode
 ///
 /// In the following example, Bar matches isDerivedFrom(hasName("X")):
 /// \code
 ///   class Foo;
 ///   typedef Foo X;
 ///   class Bar : public Foo {};  // derived from a type that X is a typedef of
 /// \endcode
 AST_MATCHER_P(CXXRecordDecl, isDerivedFrom,
               internal::Matcher<NamedDecl>, Base) {
   return Finder->classIsDerivedFrom(&Node, Base, Builder);
 }
 
 /// \brief Overloaded method as shortcut for \c isDerivedFrom(hasName(...)).
 AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isDerivedFrom, StringRef, BaseName, 1) {
   assert(!BaseName.empty());
   return isDerivedFrom(hasName(BaseName)).matches(Node, Finder, Builder);
 }
 
 /// \brief Similar to \c isDerivedFrom(), but also matches classes that directly
 /// match \c Base.
 AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isSameOrDerivedFrom,
                        internal::Matcher<NamedDecl>, Base, 0) {
   return Matcher<CXXRecordDecl>(anyOf(Base, isDerivedFrom(Base)))
       .matches(Node, Finder, Builder);
 }
 
 /// \brief Overloaded method as shortcut for
 /// \c isSameOrDerivedFrom(hasName(...)).
 AST_MATCHER_P_OVERLOAD(CXXRecordDecl, isSameOrDerivedFrom, StringRef, BaseName,
                        1) {
   assert(!BaseName.empty());
   return isSameOrDerivedFrom(hasName(BaseName)).matches(Node, Finder, Builder);
 }
 
 /// \brief Matches the first method of a class or struct that satisfies \c
 /// InnerMatcher.
 ///
 /// Given:
 /// \code
 ///   class A { void func(); };
 ///   class B { void member(); };
 /// \code
 ///
 /// \c recordDecl(hasMethod(hasName("func"))) matches the declaration of \c A
 /// but not \c B.
 AST_MATCHER_P(CXXRecordDecl, hasMethod, internal::Matcher<CXXMethodDecl>,
               InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.method_begin(),
                                     Node.method_end(), Finder, Builder);
 }
 
 /// \brief Matches AST nodes that have child AST nodes that match the
 /// provided matcher.
 ///
 /// Example matches X, Y (matcher = recordDecl(has(recordDecl(hasName("X")))
 /// \code
 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
 ///   class Y { class X {}; };
 ///   class Z { class Y { class X {}; }; };  // Does not match Z.
 /// \endcode
 ///
 /// ChildT must be an AST base type.
 ///
 /// Usable as: Any Matcher
 const internal::ArgumentAdaptingMatcherFunc<internal::HasMatcher>
 LLVM_ATTRIBUTE_UNUSED has = {};
 
 /// \brief Matches AST nodes that have descendant AST nodes that match the
 /// provided matcher.
 ///
 /// Example matches X, Y, Z
 ///     (matcher = recordDecl(hasDescendant(recordDecl(hasName("X")))))
 /// \code
 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
 ///   class Y { class X {}; };
 ///   class Z { class Y { class X {}; }; };
 /// \endcode
 ///
 /// DescendantT must be an AST base type.
 ///
 /// Usable as: Any Matcher
 const internal::ArgumentAdaptingMatcherFunc<internal::HasDescendantMatcher>
 LLVM_ATTRIBUTE_UNUSED hasDescendant = {};
 
 /// \brief Matches AST nodes that have child AST nodes that match the
 /// provided matcher.
 ///
 /// Example matches X, Y (matcher = recordDecl(forEach(recordDecl(hasName("X")))
 /// \code
 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
 ///   class Y { class X {}; };
 ///   class Z { class Y { class X {}; }; };  // Does not match Z.
 /// \endcode
 ///
 /// ChildT must be an AST base type.
 ///
 /// As opposed to 'has', 'forEach' will cause a match for each result that
 /// matches instead of only on the first one.
 ///
 /// Usable as: Any Matcher
 const internal::ArgumentAdaptingMatcherFunc<internal::ForEachMatcher>
 LLVM_ATTRIBUTE_UNUSED forEach = {};
 
 /// \brief Matches AST nodes that have descendant AST nodes that match the
 /// provided matcher.
 ///
 /// Example matches X, A, B, C
 ///     (matcher = recordDecl(forEachDescendant(recordDecl(hasName("X")))))
 /// \code
 ///   class X {};  // Matches X, because X::X is a class of name X inside X.
 ///   class A { class X {}; };
 ///   class B { class C { class X {}; }; };
 /// \endcode
 ///
 /// DescendantT must be an AST base type.
 ///
 /// As opposed to 'hasDescendant', 'forEachDescendant' will cause a match for
 /// each result that matches instead of only on the first one.
 ///
 /// Note: Recursively combined ForEachDescendant can cause many matches:
 ///   recordDecl(forEachDescendant(recordDecl(forEachDescendant(recordDecl()))))
 /// will match 10 times (plus injected class name matches) on:
 /// \code
 ///   class A { class B { class C { class D { class E {}; }; }; }; };
 /// \endcode
 ///
 /// Usable as: Any Matcher
 const internal::ArgumentAdaptingMatcherFunc<internal::ForEachDescendantMatcher>
 LLVM_ATTRIBUTE_UNUSED forEachDescendant = {};
 
 /// \brief Matches if the node or any descendant matches.
 ///
 /// Generates results for each match.
 ///
 /// For example, in:
 /// \code
 ///   class A { class B {}; class C {}; };
 /// \endcode
 /// The matcher:
 /// \code
 ///   recordDecl(hasName("::A"), findAll(recordDecl(isDefinition()).bind("m")))
 /// \endcode
 /// will generate results for \c A, \c B and \c C.
 ///
 /// Usable as: Any Matcher
 template <typename T>
 internal::Matcher<T> findAll(const internal::Matcher<T> &Matcher) {
   return eachOf(Matcher, forEachDescendant(Matcher));
 }
 
 /// \brief Matches AST nodes that have a parent that matches the provided
 /// matcher.
 ///
 /// Given
 /// \code
 /// void f() { for (;;) { int x = 42; if (true) { int x = 43; } } }
 /// \endcode
 /// \c compoundStmt(hasParent(ifStmt())) matches "{ int x = 43; }".
 ///
 /// Usable as: Any Matcher
 const internal::ArgumentAdaptingMatcherFunc<
     internal::HasParentMatcher, internal::TypeList<Decl, Stmt>,
     internal::TypeList<Decl, Stmt> > LLVM_ATTRIBUTE_UNUSED hasParent = {};
 
 /// \brief Matches AST nodes that have an ancestor that matches the provided
 /// matcher.
 ///
 /// Given
 /// \code
 /// void f() { if (true) { int x = 42; } }
 /// void g() { for (;;) { int x = 43; } }
 /// \endcode
 /// \c expr(integerLiteral(hasAncestor(ifStmt()))) matches \c 42, but not 43.
 ///
 /// Usable as: Any Matcher
 const internal::ArgumentAdaptingMatcherFunc<
     internal::HasAncestorMatcher, internal::TypeList<Decl, Stmt>,
     internal::TypeList<Decl, Stmt> > LLVM_ATTRIBUTE_UNUSED hasAncestor = {};
 
 /// \brief Matches if the provided matcher does not match.
 ///
 /// Example matches Y (matcher = recordDecl(unless(hasName("X"))))
 /// \code
 ///   class X {};
 ///   class Y {};
 /// \endcode
 ///
 /// Usable as: Any Matcher
 const internal::VariadicOperatorMatcherFunc<1, 1> unless = {
-  internal::NotUnaryOperator
+  internal::DynTypedMatcher::VO_UnaryNot
 };
 
 /// \brief Matches a node if the declaration associated with that node
 /// matches the given matcher.
 ///
 /// The associated declaration is:
 /// - for type nodes, the declaration of the underlying type
 /// - for CallExpr, the declaration of the callee
 /// - for MemberExpr, the declaration of the referenced member
 /// - for CXXConstructExpr, the declaration of the constructor
 ///
 /// Also usable as Matcher<T> for any T supporting the getDecl() member
 /// function. e.g. various subtypes of clang::Type and various expressions.
 ///
 /// Usable as: Matcher<CallExpr>, Matcher<CXXConstructExpr>,
 ///   Matcher<DeclRefExpr>, Matcher<EnumType>, Matcher<InjectedClassNameType>,
 ///   Matcher<LabelStmt>, Matcher<MemberExpr>, Matcher<QualType>,
 ///   Matcher<RecordType>, Matcher<TagType>,
 ///   Matcher<TemplateSpecializationType>, Matcher<TemplateTypeParmType>,
 ///   Matcher<TypedefType>, Matcher<UnresolvedUsingType>
 inline internal::PolymorphicMatcherWithParam1<
     internal::HasDeclarationMatcher, internal::Matcher<Decl>,
     void(internal::HasDeclarationSupportedTypes)>
 hasDeclaration(const internal::Matcher<Decl> &InnerMatcher) {
   return internal::PolymorphicMatcherWithParam1<
       internal::HasDeclarationMatcher, internal::Matcher<Decl>,
       void(internal::HasDeclarationSupportedTypes)>(InnerMatcher);
 }
 
 /// \brief Matches on the implicit object argument of a member call expression.
 ///
 /// Example matches y.x() (matcher = callExpr(on(hasType(recordDecl(hasName("Y"))))))
 /// \code
 ///   class Y { public: void x(); };
 ///   void z() { Y y; y.x(); }",
 /// \endcode
 ///
 /// FIXME: Overload to allow directly matching types?
 AST_MATCHER_P(CXXMemberCallExpr, on, internal::Matcher<Expr>,
               InnerMatcher) {
   const Expr *ExprNode = Node.getImplicitObjectArgument()
                             ->IgnoreParenImpCasts();
   return (ExprNode != nullptr &&
           InnerMatcher.matches(*ExprNode, Finder, Builder));
 }
 
 /// \brief Matches if the call expression's callee expression matches.
 ///
 /// Given
 /// \code
 ///   class Y { void x() { this->x(); x(); Y y; y.x(); } };
 ///   void f() { f(); }
 /// \endcode
 /// callExpr(callee(expr()))
 ///   matches this->x(), x(), y.x(), f()
 /// with callee(...)
 ///   matching this->x, x, y.x, f respectively
 ///
 /// Note: Callee cannot take the more general internal::Matcher<Expr>
 /// because this introduces ambiguous overloads with calls to Callee taking a
 /// internal::Matcher<Decl>, as the matcher hierarchy is purely
 /// implemented in terms of implicit casts.
 AST_MATCHER_P(CallExpr, callee, internal::Matcher<Stmt>,
               InnerMatcher) {
   const Expr *ExprNode = Node.getCallee();
   return (ExprNode != nullptr &&
           InnerMatcher.matches(*ExprNode, Finder, Builder));
 }
 
 /// \brief Matches if the call expression's callee's declaration matches the
 /// given matcher.
 ///
 /// Example matches y.x() (matcher = callExpr(callee(methodDecl(hasName("x")))))
 /// \code
 ///   class Y { public: void x(); };
 ///   void z() { Y y; y.x(); }
 /// \endcode
 AST_MATCHER_P_OVERLOAD(CallExpr, callee, internal::Matcher<Decl>, InnerMatcher,
                        1) {
   return callExpr(hasDeclaration(InnerMatcher)).matches(Node, Finder, Builder);
 }
 
 /// \brief Matches if the expression's or declaration's type matches a type
 /// matcher.
 ///
 /// Example matches x (matcher = expr(hasType(recordDecl(hasName("X")))))
 ///             and z (matcher = varDecl(hasType(recordDecl(hasName("X")))))
 /// \code
 ///  class X {};
 ///  void y(X &x) { x; X z; }
 /// \endcode
 AST_POLYMORPHIC_MATCHER_P_OVERLOAD(
     hasType, AST_POLYMORPHIC_SUPPORTED_TYPES_2(Expr, ValueDecl),
     internal::Matcher<QualType>, InnerMatcher, 0) {
   return InnerMatcher.matches(Node.getType(), Finder, Builder);
 }
 
 /// \brief Overloaded to match the declaration of the expression's or value
 /// declaration's type.
 ///
 /// In case of a value declaration (for example a variable declaration),
 /// this resolves one layer of indirection. For example, in the value
 /// declaration "X x;", recordDecl(hasName("X")) matches the declaration of X,
 /// while varDecl(hasType(recordDecl(hasName("X")))) matches the declaration
 /// of x."
 ///
 /// Example matches x (matcher = expr(hasType(recordDecl(hasName("X")))))
 ///             and z (matcher = varDecl(hasType(recordDecl(hasName("X")))))
 /// \code
 ///  class X {};
 ///  void y(X &x) { x; X z; }
 /// \endcode
 ///
 /// Usable as: Matcher<Expr>, Matcher<ValueDecl>
 AST_POLYMORPHIC_MATCHER_P_OVERLOAD(
     hasType, AST_POLYMORPHIC_SUPPORTED_TYPES_2(Expr, ValueDecl),
     internal::Matcher<Decl>, InnerMatcher, 1) {
   return qualType(hasDeclaration(InnerMatcher))
       .matches(Node.getType(), Finder, Builder);
 }
 
 /// \brief Matches if the type location of the declarator decl's type matches
 /// the inner matcher.
 ///
 /// Given
 /// \code
 ///   int x;
 /// \endcode
 /// declaratorDecl(hasTypeLoc(loc(asString("int"))))
 ///   matches int x
 AST_MATCHER_P(DeclaratorDecl, hasTypeLoc, internal::Matcher<TypeLoc>, Inner) {
   if (!Node.getTypeSourceInfo())
     // This happens for example for implicit destructors.
     return false;
   return Inner.matches(Node.getTypeSourceInfo()->getTypeLoc(), Finder, Builder);
 }
 
 /// \brief Matches if the matched type is represented by the given string.
 ///
 /// Given
 /// \code
 ///   class Y { public: void x(); };
 ///   void z() { Y* y; y->x(); }
 /// \endcode
 /// callExpr(on(hasType(asString("class Y *"))))
 ///   matches y->x()
 AST_MATCHER_P(QualType, asString, std::string, Name) {
   return Name == Node.getAsString();
 }
 
 /// \brief Matches if the matched type is a pointer type and the pointee type
 /// matches the specified matcher.
 ///
 /// Example matches y->x()
 ///     (matcher = callExpr(on(hasType(pointsTo(recordDecl(hasName("Y")))))))
 /// \code
 ///   class Y { public: void x(); };
 ///   void z() { Y *y; y->x(); }
 /// \endcode
 AST_MATCHER_P(
     QualType, pointsTo, internal::Matcher<QualType>,
     InnerMatcher) {
   return (!Node.isNull() && Node->isPointerType() &&
           InnerMatcher.matches(Node->getPointeeType(), Finder, Builder));
 }
 
 /// \brief Overloaded to match the pointee type's declaration.
 AST_MATCHER_P_OVERLOAD(QualType, pointsTo, internal::Matcher<Decl>,
                        InnerMatcher, 1) {
   return pointsTo(qualType(hasDeclaration(InnerMatcher)))
       .matches(Node, Finder, Builder);
 }
 
 /// \brief Matches if the matched type is a reference type and the referenced
 /// type matches the specified matcher.
 ///
 /// Example matches X &x and const X &y
 ///     (matcher = varDecl(hasType(references(recordDecl(hasName("X"))))))
 /// \code
 ///   class X {
 ///     void a(X b) {
 ///       X &x = b;
 ///       const X &y = b;
 ///     }
 ///   };
 /// \endcode
 AST_MATCHER_P(QualType, references, internal::Matcher<QualType>,
               InnerMatcher) {
   return (!Node.isNull() && Node->isReferenceType() &&
           InnerMatcher.matches(Node->getPointeeType(), Finder, Builder));
 }
 
 /// \brief Matches QualTypes whose canonical type matches InnerMatcher.
 ///
 /// Given:
 /// \code
 ///   typedef int &int_ref;
 ///   int a;
 ///   int_ref b = a;
 /// \code
 ///
 /// \c varDecl(hasType(qualType(referenceType()))))) will not match the
 /// declaration of b but \c
 /// varDecl(hasType(qualType(hasCanonicalType(referenceType())))))) does.
 AST_MATCHER_P(QualType, hasCanonicalType, internal::Matcher<QualType>,
               InnerMatcher) {
   if (Node.isNull())
     return false;
   return InnerMatcher.matches(Node.getCanonicalType(), Finder, Builder);
 }
 
 /// \brief Overloaded to match the referenced type's declaration.
 AST_MATCHER_P_OVERLOAD(QualType, references, internal::Matcher<Decl>,
                        InnerMatcher, 1) {
   return references(qualType(hasDeclaration(InnerMatcher)))
       .matches(Node, Finder, Builder);
 }
 
 AST_MATCHER_P(CXXMemberCallExpr, onImplicitObjectArgument,
               internal::Matcher<Expr>, InnerMatcher) {
   const Expr *ExprNode = Node.getImplicitObjectArgument();
   return (ExprNode != nullptr &&
           InnerMatcher.matches(*ExprNode, Finder, Builder));
 }
 
 /// \brief Matches if the expression's type either matches the specified
 /// matcher, or is a pointer to a type that matches the InnerMatcher.
 AST_MATCHER_P_OVERLOAD(CXXMemberCallExpr, thisPointerType,
                        internal::Matcher<QualType>, InnerMatcher, 0) {
   return onImplicitObjectArgument(
       anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
       .matches(Node, Finder, Builder);
 }
 
 /// \brief Overloaded to match the type's declaration.
 AST_MATCHER_P_OVERLOAD(CXXMemberCallExpr, thisPointerType,
                        internal::Matcher<Decl>, InnerMatcher, 1) {
   return onImplicitObjectArgument(
       anyOf(hasType(InnerMatcher), hasType(pointsTo(InnerMatcher))))
       .matches(Node, Finder, Builder);
 }
 
 /// \brief Matches a DeclRefExpr that refers to a declaration that matches the
 /// specified matcher.
 ///
 /// Example matches x in if(x)
 ///     (matcher = declRefExpr(to(varDecl(hasName("x")))))
 /// \code
 ///   bool x;
 ///   if (x) {}
 /// \endcode
 AST_MATCHER_P(DeclRefExpr, to, internal::Matcher<Decl>,
               InnerMatcher) {
   const Decl *DeclNode = Node.getDecl();
   return (DeclNode != nullptr &&
           InnerMatcher.matches(*DeclNode, Finder, Builder));
 }
 
 /// \brief Matches a \c DeclRefExpr that refers to a declaration through a
 /// specific using shadow declaration.
 ///
 /// FIXME: This currently only works for functions. Fix.
 ///
 /// Given
 /// \code
 ///   namespace a { void f() {} }
 ///   using a::f;
 ///   void g() {
 ///     f();     // Matches this ..
 ///     a::f();  // .. but not this.
 ///   }
 /// \endcode
 /// declRefExpr(throughUsingDeclaration(anything()))
 ///   matches \c f()
 AST_MATCHER_P(DeclRefExpr, throughUsingDecl,
               internal::Matcher<UsingShadowDecl>, InnerMatcher) {
   const NamedDecl *FoundDecl = Node.getFoundDecl();
   if (const UsingShadowDecl *UsingDecl = dyn_cast<UsingShadowDecl>(FoundDecl))
     return InnerMatcher.matches(*UsingDecl, Finder, Builder);
   return false;
 }
 
 /// \brief Matches the Decl of a DeclStmt which has a single declaration.
 ///
 /// Given
 /// \code
 ///   int a, b;
 ///   int c;
 /// \endcode
 /// declStmt(hasSingleDecl(anything()))
 ///   matches 'int c;' but not 'int a, b;'.
 AST_MATCHER_P(DeclStmt, hasSingleDecl, internal::Matcher<Decl>, InnerMatcher) {
   if (Node.isSingleDecl()) {
     const Decl *FoundDecl = Node.getSingleDecl();
     return InnerMatcher.matches(*FoundDecl, Finder, Builder);
   }
   return false;
 }
 
 /// \brief Matches a variable declaration that has an initializer expression
 /// that matches the given matcher.
 ///
 /// Example matches x (matcher = varDecl(hasInitializer(callExpr())))
 /// \code
 ///   bool y() { return true; }
 ///   bool x = y();
 /// \endcode
 AST_MATCHER_P(
     VarDecl, hasInitializer, internal::Matcher<Expr>,
     InnerMatcher) {
   const Expr *Initializer = Node.getAnyInitializer();
   return (Initializer != nullptr &&
           InnerMatcher.matches(*Initializer, Finder, Builder));
 }
 
 /// \brief Matches a variable declaration that has function scope and is a
 /// non-static local variable.
 ///
 /// Example matches x (matcher = varDecl(hasLocalStorage())
 /// \code
 /// void f() {
 ///   int x;
 ///   static int y;
 /// }
 /// int z;
 /// \endcode
 AST_MATCHER(VarDecl, hasLocalStorage) {
   return Node.hasLocalStorage();
 }
 
 /// \brief Matches a variable declaration that does not have local storage.
 ///
 /// Example matches y and z (matcher = varDecl(hasGlobalStorage())
 /// \code
 /// void f() {
 ///   int x;
 ///   static int y;
 /// }
 /// int z;
 /// \endcode
 AST_MATCHER(VarDecl, hasGlobalStorage) {
   return Node.hasGlobalStorage();
 }
 
 /// \brief Checks that a call expression or a constructor call expression has
 /// a specific number of arguments (including absent default arguments).
 ///
 /// Example matches f(0, 0) (matcher = callExpr(argumentCountIs(2)))
 /// \code
 ///   void f(int x, int y);
 ///   f(0, 0);
 /// \endcode
 AST_POLYMORPHIC_MATCHER_P(argumentCountIs, AST_POLYMORPHIC_SUPPORTED_TYPES_2(
                                                CallExpr, CXXConstructExpr),
                           unsigned, N) {
   return Node.getNumArgs() == N;
 }
 
 /// \brief Matches the n'th argument of a call expression or a constructor
 /// call expression.
 ///
 /// Example matches y in x(y)
 ///     (matcher = callExpr(hasArgument(0, declRefExpr())))
 /// \code
 ///   void x(int) { int y; x(y); }
 /// \endcode
 AST_POLYMORPHIC_MATCHER_P2(
     hasArgument,
     AST_POLYMORPHIC_SUPPORTED_TYPES_2(CallExpr, CXXConstructExpr),
     unsigned, N, internal::Matcher<Expr>, InnerMatcher) {
   return (N < Node.getNumArgs() &&
           InnerMatcher.matches(
               *Node.getArg(N)->IgnoreParenImpCasts(), Finder, Builder));
 }
 
 /// \brief Matches declaration statements that contain a specific number of
 /// declarations.
 ///
 /// Example: Given
 /// \code
 ///   int a, b;
 ///   int c;
 ///   int d = 2, e;
 /// \endcode
 /// declCountIs(2)
 ///   matches 'int a, b;' and 'int d = 2, e;', but not 'int c;'.
 AST_MATCHER_P(DeclStmt, declCountIs, unsigned, N) {
   return std::distance(Node.decl_begin(), Node.decl_end()) == (ptrdiff_t)N;
 }
 
 /// \brief Matches the n'th declaration of a declaration statement.
 ///
 /// Note that this does not work for global declarations because the AST
 /// breaks up multiple-declaration DeclStmt's into multiple single-declaration
 /// DeclStmt's.
 /// Example: Given non-global declarations
 /// \code
 ///   int a, b = 0;
 ///   int c;
 ///   int d = 2, e;
 /// \endcode
 /// declStmt(containsDeclaration(
 ///       0, varDecl(hasInitializer(anything()))))
 ///   matches only 'int d = 2, e;', and
 /// declStmt(containsDeclaration(1, varDecl()))
 /// \code
 ///   matches 'int a, b = 0' as well as 'int d = 2, e;'
 ///   but 'int c;' is not matched.
 /// \endcode
 AST_MATCHER_P2(DeclStmt, containsDeclaration, unsigned, N,
                internal::Matcher<Decl>, InnerMatcher) {
   const unsigned NumDecls = std::distance(Node.decl_begin(), Node.decl_end());
   if (N >= NumDecls)
     return false;
   DeclStmt::const_decl_iterator Iterator = Node.decl_begin();
   std::advance(Iterator, N);
   return InnerMatcher.matches(**Iterator, Finder, Builder);
 }
 
 /// \brief Matches a constructor initializer.
 ///
 /// Given
 /// \code
 ///   struct Foo {
 ///     Foo() : foo_(1) { }
 ///     int foo_;
 ///   };
 /// \endcode
 /// recordDecl(has(constructorDecl(hasAnyConstructorInitializer(anything()))))
 ///   record matches Foo, hasAnyConstructorInitializer matches foo_(1)
 AST_MATCHER_P(CXXConstructorDecl, hasAnyConstructorInitializer,
               internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.init_begin(),
                                     Node.init_end(), Finder, Builder);
 }
 
 /// \brief Matches the field declaration of a constructor initializer.
 ///
 /// Given
 /// \code
 ///   struct Foo {
 ///     Foo() : foo_(1) { }
 ///     int foo_;
 ///   };
 /// \endcode
 /// recordDecl(has(constructorDecl(hasAnyConstructorInitializer(
 ///     forField(hasName("foo_"))))))
 ///   matches Foo
 /// with forField matching foo_
 AST_MATCHER_P(CXXCtorInitializer, forField,
               internal::Matcher<FieldDecl>, InnerMatcher) {
   const FieldDecl *NodeAsDecl = Node.getMember();
   return (NodeAsDecl != nullptr &&
       InnerMatcher.matches(*NodeAsDecl, Finder, Builder));
 }
 
 /// \brief Matches the initializer expression of a constructor initializer.
 ///
 /// Given
 /// \code
 ///   struct Foo {
 ///     Foo() : foo_(1) { }
 ///     int foo_;
 ///   };
 /// \endcode
 /// recordDecl(has(constructorDecl(hasAnyConstructorInitializer(
 ///     withInitializer(integerLiteral(equals(1)))))))
 ///   matches Foo
 /// with withInitializer matching (1)
 AST_MATCHER_P(CXXCtorInitializer, withInitializer,
               internal::Matcher<Expr>, InnerMatcher) {
   const Expr* NodeAsExpr = Node.getInit();
   return (NodeAsExpr != nullptr &&
       InnerMatcher.matches(*NodeAsExpr, Finder, Builder));
 }
 
 /// \brief Matches a constructor initializer if it is explicitly written in
 /// code (as opposed to implicitly added by the compiler).
 ///
 /// Given
 /// \code
 ///   struct Foo {
 ///     Foo() { }
 ///     Foo(int) : foo_("A") { }
 ///     string foo_;
 ///   };
 /// \endcode
 /// constructorDecl(hasAnyConstructorInitializer(isWritten()))
 ///   will match Foo(int), but not Foo()
 AST_MATCHER(CXXCtorInitializer, isWritten) {
   return Node.isWritten();
 }
 
 /// \brief Matches any argument of a call expression or a constructor call
 /// expression.
 ///
 /// Given
 /// \code
 ///   void x(int, int, int) { int y; x(1, y, 42); }
 /// \endcode
 /// callExpr(hasAnyArgument(declRefExpr()))
 ///   matches x(1, y, 42)
 /// with hasAnyArgument(...)
 ///   matching y
 ///
 /// FIXME: Currently this will ignore parentheses and implicit casts on
 /// the argument before applying the inner matcher. We'll want to remove
 /// this to allow for greater control by the user once \c ignoreImplicit()
 /// has been implemented.
 AST_POLYMORPHIC_MATCHER_P(hasAnyArgument, AST_POLYMORPHIC_SUPPORTED_TYPES_2(
                                               CallExpr, CXXConstructExpr),
                           internal::Matcher<Expr>, InnerMatcher) {
   for (const Expr *Arg : Node.arguments()) {
     BoundNodesTreeBuilder Result(*Builder);
     if (InnerMatcher.matches(*Arg->IgnoreParenImpCasts(), Finder, &Result)) {
       *Builder = std::move(Result);
       return true;
     }
   }
   return false;
 }
 
 /// \brief Matches a constructor call expression which uses list initialization.
 AST_MATCHER(CXXConstructExpr, isListInitialization) {
   return Node.isListInitialization();
 }
 
 /// \brief Matches the n'th parameter of a function declaration.
 ///
 /// Given
 /// \code
 ///   class X { void f(int x) {} };
 /// \endcode
 /// methodDecl(hasParameter(0, hasType(varDecl())))
 ///   matches f(int x) {}
 /// with hasParameter(...)
 ///   matching int x
 AST_MATCHER_P2(FunctionDecl, hasParameter,
                unsigned, N, internal::Matcher<ParmVarDecl>,
                InnerMatcher) {
   return (N < Node.getNumParams() &&
           InnerMatcher.matches(
               *Node.getParamDecl(N), Finder, Builder));
 }
 
 /// \brief Matches any parameter of a function declaration.
 ///
 /// Does not match the 'this' parameter of a method.
 ///
 /// Given
 /// \code
 ///   class X { void f(int x, int y, int z) {} };
 /// \endcode
 /// methodDecl(hasAnyParameter(hasName("y")))
 ///   matches f(int x, int y, int z) {}
 /// with hasAnyParameter(...)
 ///   matching int y
 AST_MATCHER_P(FunctionDecl, hasAnyParameter,
               internal::Matcher<ParmVarDecl>, InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.param_begin(),
                                     Node.param_end(), Finder, Builder);
 }
 
 /// \brief Matches \c FunctionDecls that have a specific parameter count.
 ///
 /// Given
 /// \code
 ///   void f(int i) {}
 ///   void g(int i, int j) {}
 /// \endcode
 /// functionDecl(parameterCountIs(2))
 ///   matches g(int i, int j) {}
 AST_MATCHER_P(FunctionDecl, parameterCountIs, unsigned, N) {
   return Node.getNumParams() == N;
 }
 
 /// \brief Matches the return type of a function declaration.
 ///
 /// Given:
 /// \code
 ///   class X { int f() { return 1; } };
 /// \endcode
 /// methodDecl(returns(asString("int")))
 ///   matches int f() { return 1; }
 AST_MATCHER_P(FunctionDecl, returns,
               internal::Matcher<QualType>, InnerMatcher) {
   return InnerMatcher.matches(Node.getReturnType(), Finder, Builder);
 }
 
 /// \brief Matches extern "C" function declarations.
 ///
 /// Given:
 /// \code
 ///   extern "C" void f() {}
 ///   extern "C" { void g() {} }
 ///   void h() {}
 /// \endcode
 /// functionDecl(isExternC())
 ///   matches the declaration of f and g, but not the declaration h
 AST_MATCHER(FunctionDecl, isExternC) {
   return Node.isExternC();
 }
 
 /// \brief Matches deleted function declarations.
 ///
 /// Given:
 /// \code
 ///   void Func();
 ///   void DeletedFunc() = delete;
 /// \endcode
 /// functionDecl(isDeleted())
 ///   matches the declaration of DeletedFunc, but not Func.
 AST_MATCHER(FunctionDecl, isDeleted) {
   return Node.isDeleted();
 }
 
 /// \brief Matches the condition expression of an if statement, for loop,
 /// or conditional operator.
 ///
 /// Example matches true (matcher = hasCondition(boolLiteral(equals(true))))
 /// \code
 ///   if (true) {}
 /// \endcode
 AST_POLYMORPHIC_MATCHER_P(
     hasCondition, AST_POLYMORPHIC_SUPPORTED_TYPES_5(
                       IfStmt, ForStmt, WhileStmt, DoStmt, ConditionalOperator),
     internal::Matcher<Expr>, InnerMatcher) {
   const Expr *const Condition = Node.getCond();
   return (Condition != nullptr &&
           InnerMatcher.matches(*Condition, Finder, Builder));
 }
 
 /// \brief Matches the then-statement of an if statement.
 ///
 /// Examples matches the if statement
 ///   (matcher = ifStmt(hasThen(boolLiteral(equals(true)))))
 /// \code
 ///   if (false) true; else false;
 /// \endcode
 AST_MATCHER_P(IfStmt, hasThen, internal::Matcher<Stmt>, InnerMatcher) {
   const Stmt *const Then = Node.getThen();
   return (Then != nullptr && InnerMatcher.matches(*Then, Finder, Builder));
 }
 
 /// \brief Matches the else-statement of an if statement.
 ///
 /// Examples matches the if statement
 ///   (matcher = ifStmt(hasElse(boolLiteral(equals(true)))))
 /// \code
 ///   if (false) false; else true;
 /// \endcode
 AST_MATCHER_P(IfStmt, hasElse, internal::Matcher<Stmt>, InnerMatcher) {
   const Stmt *const Else = Node.getElse();
   return (Else != nullptr && InnerMatcher.matches(*Else, Finder, Builder));
 }
 
 /// \brief Matches if a node equals a previously bound node.
 ///
 /// Matches a node if it equals the node previously bound to \p ID.
 ///
 /// Given
 /// \code
 ///   class X { int a; int b; };
 /// \endcode
 /// recordDecl(
 ///     has(fieldDecl(hasName("a"), hasType(type().bind("t")))),
 ///     has(fieldDecl(hasName("b"), hasType(type(equalsBoundNode("t"))))))
 ///   matches the class \c X, as \c a and \c b have the same type.
 ///
 /// Note that when multiple matches are involved via \c forEach* matchers,
 /// \c equalsBoundNodes acts as a filter.
 /// For example:
 /// compoundStmt(
 ///     forEachDescendant(varDecl().bind("d")),
 ///     forEachDescendant(declRefExpr(to(decl(equalsBoundNode("d"))))))
 /// will trigger a match for each combination of variable declaration
 /// and reference to that variable declaration within a compound statement.
 AST_POLYMORPHIC_MATCHER_P(equalsBoundNode, AST_POLYMORPHIC_SUPPORTED_TYPES_4(
                                                Stmt, Decl, Type, QualType),
                           std::string, ID) {
   // FIXME: Figure out whether it makes sense to allow this
   // on any other node types.
   // For *Loc it probably does not make sense, as those seem
   // unique. For NestedNameSepcifier it might make sense, as
   // those also have pointer identity, but I'm not sure whether
   // they're ever reused.
   internal::NotEqualsBoundNodePredicate Predicate;
   Predicate.ID = ID;
   Predicate.Node = ast_type_traits::DynTypedNode::create(Node);
   return Builder->removeBindings(Predicate);
 }
 
 /// \brief Matches the condition variable statement in an if statement.
 ///
 /// Given
 /// \code
 ///   if (A* a = GetAPointer()) {}
 /// \endcode
 /// hasConditionVariableStatement(...)
 ///   matches 'A* a = GetAPointer()'.
 AST_MATCHER_P(IfStmt, hasConditionVariableStatement,
               internal::Matcher<DeclStmt>, InnerMatcher) {
   const DeclStmt* const DeclarationStatement =
     Node.getConditionVariableDeclStmt();
   return DeclarationStatement != nullptr &&
          InnerMatcher.matches(*DeclarationStatement, Finder, Builder);
 }
 
 /// \brief Matches the index expression of an array subscript expression.
 ///
 /// Given
 /// \code
 ///   int i[5];
 ///   void f() { i[1] = 42; }
 /// \endcode
 /// arraySubscriptExpression(hasIndex(integerLiteral()))
 ///   matches \c i[1] with the \c integerLiteral() matching \c 1
 AST_MATCHER_P(ArraySubscriptExpr, hasIndex,
               internal::Matcher<Expr>, InnerMatcher) {
   if (const Expr* Expression = Node.getIdx())
     return InnerMatcher.matches(*Expression, Finder, Builder);
   return false;
 }
 
 /// \brief Matches the base expression of an array subscript expression.
 ///
 /// Given
 /// \code
 ///   int i[5];
 ///   void f() { i[1] = 42; }
 /// \endcode
 /// arraySubscriptExpression(hasBase(implicitCastExpr(
 ///     hasSourceExpression(declRefExpr()))))
 ///   matches \c i[1] with the \c declRefExpr() matching \c i
 AST_MATCHER_P(ArraySubscriptExpr, hasBase,
               internal::Matcher<Expr>, InnerMatcher) {
   if (const Expr* Expression = Node.getBase())
     return InnerMatcher.matches(*Expression, Finder, Builder);
   return false;
 }
 
 /// \brief Matches a 'for', 'while', or 'do while' statement that has
 /// a given body.
 ///
 /// Given
 /// \code
 ///   for (;;) {}
 /// \endcode
 /// hasBody(compoundStmt())
 ///   matches 'for (;;) {}'
 /// with compoundStmt()
 ///   matching '{}'
 AST_POLYMORPHIC_MATCHER_P(hasBody,
                           AST_POLYMORPHIC_SUPPORTED_TYPES_4(DoStmt, ForStmt,
                                                             WhileStmt,
                                                             CXXForRangeStmt),
                           internal::Matcher<Stmt>, InnerMatcher) {
   const Stmt *const Statement = Node.getBody();
   return (Statement != nullptr &&
           InnerMatcher.matches(*Statement, Finder, Builder));
 }
 
 /// \brief Matches compound statements where at least one substatement matches
 /// a given matcher.
 ///
 /// Given
 /// \code
 ///   { {}; 1+2; }
 /// \endcode
 /// hasAnySubstatement(compoundStmt())
 ///   matches '{ {}; 1+2; }'
 /// with compoundStmt()
 ///   matching '{}'
 AST_MATCHER_P(CompoundStmt, hasAnySubstatement,
               internal::Matcher<Stmt>, InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.body_begin(),
                                     Node.body_end(), Finder, Builder);
 }
 
 /// \brief Checks that a compound statement contains a specific number of
 /// child statements.
 ///
 /// Example: Given
 /// \code
 ///   { for (;;) {} }
 /// \endcode
 /// compoundStmt(statementCountIs(0)))
 ///   matches '{}'
 ///   but does not match the outer compound statement.
 AST_MATCHER_P(CompoundStmt, statementCountIs, unsigned, N) {
   return Node.size() == N;
 }
 
 /// \brief Matches literals that are equal to the given value.
 ///
 /// Example matches true (matcher = boolLiteral(equals(true)))
 /// \code
 ///   true
 /// \endcode
 ///
 /// Usable as: Matcher<CharacterLiteral>, Matcher<CXXBoolLiteral>,
 ///            Matcher<FloatingLiteral>, Matcher<IntegerLiteral>
 template <typename ValueT>
 internal::PolymorphicMatcherWithParam1<internal::ValueEqualsMatcher, ValueT>
 equals(const ValueT &Value) {
   return internal::PolymorphicMatcherWithParam1<
     internal::ValueEqualsMatcher,
     ValueT>(Value);
 }
 
 /// \brief Matches the operator Name of operator expressions (binary or
 /// unary).
 ///
 /// Example matches a || b (matcher = binaryOperator(hasOperatorName("||")))
 /// \code
 ///   !(a || b)
 /// \endcode
 AST_POLYMORPHIC_MATCHER_P(hasOperatorName, AST_POLYMORPHIC_SUPPORTED_TYPES_2(
                                                BinaryOperator, UnaryOperator),
                           std::string, Name) {
   return Name == Node.getOpcodeStr(Node.getOpcode());
 }
 
 /// \brief Matches the left hand side of binary operator expressions.
 ///
 /// Example matches a (matcher = binaryOperator(hasLHS()))
 /// \code
 ///   a || b
 /// \endcode
 AST_MATCHER_P(BinaryOperator, hasLHS,
               internal::Matcher<Expr>, InnerMatcher) {
   Expr *LeftHandSide = Node.getLHS();
   return (LeftHandSide != nullptr &&
           InnerMatcher.matches(*LeftHandSide, Finder, Builder));
 }
 
 /// \brief Matches the right hand side of binary operator expressions.
 ///
 /// Example matches b (matcher = binaryOperator(hasRHS()))
 /// \code
 ///   a || b
 /// \endcode
 AST_MATCHER_P(BinaryOperator, hasRHS,
               internal::Matcher<Expr>, InnerMatcher) {
   Expr *RightHandSide = Node.getRHS();
   return (RightHandSide != nullptr &&
           InnerMatcher.matches(*RightHandSide, Finder, Builder));
 }
 
 /// \brief Matches if either the left hand side or the right hand side of a
 /// binary operator matches.
 inline internal::Matcher<BinaryOperator> hasEitherOperand(
     const internal::Matcher<Expr> &InnerMatcher) {
   return anyOf(hasLHS(InnerMatcher), hasRHS(InnerMatcher));
 }
 
 /// \brief Matches if the operand of a unary operator matches.
 ///
 /// Example matches true (matcher = hasUnaryOperand(boolLiteral(equals(true))))
 /// \code
 ///   !true
 /// \endcode
 AST_MATCHER_P(UnaryOperator, hasUnaryOperand,
               internal::Matcher<Expr>, InnerMatcher) {
   const Expr * const Operand = Node.getSubExpr();
   return (Operand != nullptr &&
           InnerMatcher.matches(*Operand, Finder, Builder));
 }
 
 /// \brief Matches if the cast's source expression matches the given matcher.
 ///
 /// Example: matches "a string" (matcher =
 ///                                  hasSourceExpression(constructExpr()))
 /// \code
 /// class URL { URL(string); };
 /// URL url = "a string";
 AST_MATCHER_P(CastExpr, hasSourceExpression,
               internal::Matcher<Expr>, InnerMatcher) {
   const Expr* const SubExpression = Node.getSubExpr();
   return (SubExpression != nullptr &&
           InnerMatcher.matches(*SubExpression, Finder, Builder));
 }
 
 /// \brief Matches casts whose destination type matches a given matcher.
 ///
 /// (Note: Clang's AST refers to other conversions as "casts" too, and calls
 /// actual casts "explicit" casts.)
 AST_MATCHER_P(ExplicitCastExpr, hasDestinationType,
               internal::Matcher<QualType>, InnerMatcher) {
   const QualType NodeType = Node.getTypeAsWritten();
   return InnerMatcher.matches(NodeType, Finder, Builder);
 }
 
 /// \brief Matches implicit casts whose destination type matches a given
 /// matcher.
 ///
 /// FIXME: Unit test this matcher
 AST_MATCHER_P(ImplicitCastExpr, hasImplicitDestinationType,
               internal::Matcher<QualType>, InnerMatcher) {
   return InnerMatcher.matches(Node.getType(), Finder, Builder);
 }
 
 /// \brief Matches the true branch expression of a conditional operator.
 ///
 /// Example matches a
 /// \code
 ///   condition ? a : b
 /// \endcode
 AST_MATCHER_P(ConditionalOperator, hasTrueExpression,
               internal::Matcher<Expr>, InnerMatcher) {
   Expr *Expression = Node.getTrueExpr();
   return (Expression != nullptr &&
           InnerMatcher.matches(*Expression, Finder, Builder));
 }
 
 /// \brief Matches the false branch expression of a conditional operator.
 ///
 /// Example matches b
 /// \code
 ///   condition ? a : b
 /// \endcode
 AST_MATCHER_P(ConditionalOperator, hasFalseExpression,
               internal::Matcher<Expr>, InnerMatcher) {
   Expr *Expression = Node.getFalseExpr();
   return (Expression != nullptr &&
           InnerMatcher.matches(*Expression, Finder, Builder));
 }
 
 /// \brief Matches if a declaration has a body attached.
 ///
 /// Example matches A, va, fa
 /// \code
 ///   class A {};
 ///   class B;  // Doesn't match, as it has no body.
 ///   int va;
 ///   extern int vb;  // Doesn't match, as it doesn't define the variable.
 ///   void fa() {}
 ///   void fb();  // Doesn't match, as it has no body.
 /// \endcode
 ///
 /// Usable as: Matcher<TagDecl>, Matcher<VarDecl>, Matcher<FunctionDecl>
 AST_POLYMORPHIC_MATCHER(isDefinition, AST_POLYMORPHIC_SUPPORTED_TYPES_3(
                                           TagDecl, VarDecl, FunctionDecl)) {
   return Node.isThisDeclarationADefinition();
 }
 
 /// \brief Matches the class declaration that the given method declaration
 /// belongs to.
 ///
 /// FIXME: Generalize this for other kinds of declarations.
 /// FIXME: What other kind of declarations would we need to generalize
 /// this to?
 ///
 /// Example matches A() in the last line
 ///     (matcher = constructExpr(hasDeclaration(methodDecl(
 ///         ofClass(hasName("A"))))))
 /// \code
 ///   class A {
 ///    public:
 ///     A();
 ///   };
 ///   A a = A();
 /// \endcode
 AST_MATCHER_P(CXXMethodDecl, ofClass,
               internal::Matcher<CXXRecordDecl>, InnerMatcher) {
   const CXXRecordDecl *Parent = Node.getParent();
   return (Parent != nullptr &&
           InnerMatcher.matches(*Parent, Finder, Builder));
 }
 
 /// \brief Matches if the given method declaration is virtual.
 ///
 /// Given
 /// \code
 ///   class A {
 ///    public:
 ///     virtual void x();
 ///   };
 /// \endcode
 ///   matches A::x
 AST_MATCHER(CXXMethodDecl, isVirtual) {
   return Node.isVirtual();
 }
 
 /// \brief Matches if the given method declaration is pure.
 ///
 /// Given
 /// \code
 ///   class A {
 ///    public:
 ///     virtual void x() = 0;
 ///   };
 /// \endcode
 ///   matches A::x
 AST_MATCHER(CXXMethodDecl, isPure) {
   return Node.isPure();
 }
 
 /// \brief Matches if the given method declaration is const.
 ///
 /// Given
 /// \code
 /// struct A {
 ///   void foo() const;
 ///   void bar();
 /// };
 /// \endcode
 ///
 /// methodDecl(isConst()) matches A::foo() but not A::bar()
 AST_MATCHER(CXXMethodDecl, isConst) {
   return Node.isConst();
 }
 
 /// \brief Matches if the given method declaration overrides another method.
 ///
 /// Given
 /// \code
 ///   class A {
 ///    public:
 ///     virtual void x();
 ///   };
 ///   class B : public A {
 ///    public:
 ///     virtual void x();
 ///   };
 /// \endcode
 ///   matches B::x
 AST_MATCHER(CXXMethodDecl, isOverride) {
   return Node.size_overridden_methods() > 0;
 }
 
 /// \brief Matches member expressions that are called with '->' as opposed
 /// to '.'.
 ///
 /// Member calls on the implicit this pointer match as called with '->'.
 ///
 /// Given
 /// \code
 ///   class Y {
 ///     void x() { this->x(); x(); Y y; y.x(); a; this->b; Y::b; }
 ///     int a;
 ///     static int b;
 ///   };
 /// \endcode
 /// memberExpr(isArrow())
 ///   matches this->x, x, y.x, a, this->b
 AST_MATCHER(MemberExpr, isArrow) {
   return Node.isArrow();
 }
 
 /// \brief Matches QualType nodes that are of integer type.
 ///
 /// Given
 /// \code
 ///   void a(int);
 ///   void b(long);
 ///   void c(double);
 /// \endcode
 /// functionDecl(hasAnyParameter(hasType(isInteger())))
 /// matches "a(int)", "b(long)", but not "c(double)".
 AST_MATCHER(QualType, isInteger) {
     return Node->isIntegerType();
 }
 
 /// \brief Matches QualType nodes that are const-qualified, i.e., that
 /// include "top-level" const.
 ///
 /// Given
 /// \code
 ///   void a(int);
 ///   void b(int const);
 ///   void c(const int);
 ///   void d(const int*);
 ///   void e(int const) {};
 /// \endcode
 /// functionDecl(hasAnyParameter(hasType(isConstQualified())))
 ///   matches "void b(int const)", "void c(const int)" and
 ///   "void e(int const) {}". It does not match d as there
 ///   is no top-level const on the parameter type "const int *".
 AST_MATCHER(QualType, isConstQualified) {
   return Node.isConstQualified();
 }
 
 /// \brief Matches QualType nodes that have local CV-qualifiers attached to
 /// the node, not hidden within a typedef.
 ///
 /// Given
 /// \code
 ///   typedef const int const_int;
 ///   const_int i;
 ///   int *const j;
 ///   int *volatile k;
 ///   int m;
 /// \endcode
 /// \c varDecl(hasType(hasLocalQualifiers())) matches only \c j and \c k.
 /// \c i is const-qualified but the qualifier is not local.
 AST_MATCHER(QualType, hasLocalQualifiers) {
   return Node.hasLocalQualifiers();
 }
 
 /// \brief Matches a member expression where the member is matched by a
 /// given matcher.
 ///
 /// Given
 /// \code
 ///   struct { int first, second; } first, second;
 ///   int i(second.first);
 ///   int j(first.second);
 /// \endcode
 /// memberExpr(member(hasName("first")))
 ///   matches second.first
 ///   but not first.second (because the member name there is "second").
 AST_MATCHER_P(MemberExpr, member,
               internal::Matcher<ValueDecl>, InnerMatcher) {
   return InnerMatcher.matches(*Node.getMemberDecl(), Finder, Builder);
 }
 
 /// \brief Matches a member expression where the object expression is
 /// matched by a given matcher.
 ///
 /// Given
 /// \code
 ///   struct X { int m; };
 ///   void f(X x) { x.m; m; }
 /// \endcode
 /// memberExpr(hasObjectExpression(hasType(recordDecl(hasName("X")))))))
 ///   matches "x.m" and "m"
 /// with hasObjectExpression(...)
 ///   matching "x" and the implicit object expression of "m" which has type X*.
 AST_MATCHER_P(MemberExpr, hasObjectExpression,
               internal::Matcher<Expr>, InnerMatcher) {
   return InnerMatcher.matches(*Node.getBase(), Finder, Builder);
 }
 
 /// \brief Matches any using shadow declaration.
 ///
 /// Given
 /// \code
 ///   namespace X { void b(); }
 ///   using X::b;
 /// \endcode
 /// usingDecl(hasAnyUsingShadowDecl(hasName("b"))))
 ///   matches \code using X::b \endcode
 AST_MATCHER_P(UsingDecl, hasAnyUsingShadowDecl,
               internal::Matcher<UsingShadowDecl>, InnerMatcher) {
   return matchesFirstInPointerRange(InnerMatcher, Node.shadow_begin(),
                                     Node.shadow_end(), Finder, Builder);
 }
 
 /// \brief Matches a using shadow declaration where the target declaration is
 /// matched by the given matcher.
 ///
 /// Given
 /// \code
 ///   namespace X { int a; void b(); }
 ///   using X::a;
 ///   using X::b;
 /// \endcode
 /// usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(functionDecl())))
 ///   matches \code using X::b \endcode
 ///   but not \code using X::a \endcode
 AST_MATCHER_P(UsingShadowDecl, hasTargetDecl,
               internal::Matcher<NamedDecl>, InnerMatcher) {
   return InnerMatcher.matches(*Node.getTargetDecl(), Finder, Builder);
 }
 
 /// \brief Matches template instantiations of function, class, or static
 /// member variable template instantiations.
 ///
 /// Given
 /// \code
 ///   template <typename T> class X {}; class A {}; X<A> x;
 /// \endcode
 /// or
 /// \code
 ///   template <typename T> class X {}; class A {}; template class X<A>;
 /// \endcode
 /// recordDecl(hasName("::X"), isTemplateInstantiation())
 ///   matches the template instantiation of X<A>.
 ///
 /// But given
 /// \code
 ///   template <typename T>  class X {}; class A {};
 ///   template <> class X<A> {}; X<A> x;
 /// \endcode
 /// recordDecl(hasName("::X"), isTemplateInstantiation())
 ///   does not match, as X<A> is an explicit template specialization.
 ///
 /// Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
 AST_POLYMORPHIC_MATCHER(
     isTemplateInstantiation,
     AST_POLYMORPHIC_SUPPORTED_TYPES_3(FunctionDecl, VarDecl, CXXRecordDecl)) {
   return (Node.getTemplateSpecializationKind() == TSK_ImplicitInstantiation ||
           Node.getTemplateSpecializationKind() ==
           TSK_ExplicitInstantiationDefinition);
 }
 
 /// \brief Matches declarations that are template instantiations or are inside
 /// template instantiations.
 ///
 /// Given
 /// \code
 ///   template<typename T> void A(T t) { T i; }
 ///   A(0);
 ///   A(0U);
 /// \endcode
 /// functionDecl(isInstantiated())
 ///   matches 'A(int) {...};' and 'A(unsigned) {...}'.
 AST_MATCHER(Decl, isInstantiated) {
   auto IsInstantiation = decl(anyOf(recordDecl(isTemplateInstantiation()),
                                     functionDecl(isTemplateInstantiation())));
   auto InnerMatcher =
       decl(anyOf(IsInstantiation, hasAncestor(IsInstantiation)));
   return InnerMatcher.matches(Node, Finder, Builder);
 }
 
 /// \brief Matches statements inside of a template instantiation.
 ///
 /// Given
 /// \code
 ///   int j;
 ///   template<typename T> void A(T t) { T i; j += 42;}
 ///   A(0);
 ///   A(0U);
 /// \endcode
 /// declStmt(isInTemplateInstantiation())
 ///   matches 'int i;' and 'unsigned i'.
 /// unless(stmt(isInTemplateInstantiation()))
 ///   will NOT match j += 42; as it's shared between the template definition and
 ///   instantiation.
 AST_MATCHER(Stmt, isInTemplateInstantiation) {
   auto InnerMatcher =
       stmt(hasAncestor(decl(anyOf(recordDecl(isTemplateInstantiation()),
                                   functionDecl(isTemplateInstantiation())))));
   return InnerMatcher.matches(Node, Finder, Builder);
 }
 
 /// \brief Matches explicit template specializations of function, class, or
 /// static member variable template instantiations.
 ///
 /// Given
 /// \code
 ///   template<typename T> void A(T t) { }
 ///   template<> void A(int N) { }
 /// \endcode
 /// functionDecl(isExplicitTemplateSpecialization())
 ///   matches the specialization A<int>().
 ///
 /// Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
 AST_POLYMORPHIC_MATCHER(
     isExplicitTemplateSpecialization,
     AST_POLYMORPHIC_SUPPORTED_TYPES_3(FunctionDecl, VarDecl, CXXRecordDecl)) {
   return (Node.getTemplateSpecializationKind() == TSK_ExplicitSpecialization);
 }
 
 /// \brief Matches \c TypeLocs for which the given inner
 /// QualType-matcher matches.
 AST_MATCHER_FUNCTION_P_OVERLOAD(internal::BindableMatcher<TypeLoc>, loc,
                                 internal::Matcher<QualType>, InnerMatcher, 0) {
   return internal::BindableMatcher<TypeLoc>(
       new internal::TypeLocTypeMatcher(InnerMatcher));
 }
 
 /// \brief Matches builtin Types.
 ///
 /// Given
 /// \code
 ///   struct A {};
 ///   A a;
 ///   int b;
 ///   float c;
 ///   bool d;
 /// \endcode
 /// builtinType()
 ///   matches "int b", "float c" and "bool d"
 AST_TYPE_MATCHER(BuiltinType, builtinType);
 
 /// \brief Matches all kinds of arrays.
 ///
 /// Given
 /// \code
 ///   int a[] = { 2, 3 };
 ///   int b[4];
 ///   void f() { int c[a[0]]; }
 /// \endcode
 /// arrayType()
 ///   matches "int a[]", "int b[4]" and "int c[a[0]]";
 AST_TYPE_MATCHER(ArrayType, arrayType);
 
 /// \brief Matches C99 complex types.
 ///
 /// Given
 /// \code
 ///   _Complex float f;
 /// \endcode
 /// complexType()
 ///   matches "_Complex float f"
 AST_TYPE_MATCHER(ComplexType, complexType);
 
 /// \brief Matches arrays and C99 complex types that have a specific element
 /// type.
 ///
 /// Given
 /// \code
 ///   struct A {};
 ///   A a[7];
 ///   int b[7];
 /// \endcode
 /// arrayType(hasElementType(builtinType()))
 ///   matches "int b[7]"
 ///
 /// Usable as: Matcher<ArrayType>, Matcher<ComplexType>
 AST_TYPELOC_TRAVERSE_MATCHER(
     hasElementType, getElement,
     AST_POLYMORPHIC_SUPPORTED_TYPES_2(ArrayType, ComplexType));
 
 /// \brief Matches C arrays with a specified constant size.
 ///
 /// Given
 /// \code
 ///   void() {
 ///     int a[2];
 ///     int b[] = { 2, 3 };
 ///     int c[b[0]];
 ///   }
 /// \endcode
 /// constantArrayType()
 ///   matches "int a[2]"
 AST_TYPE_MATCHER(ConstantArrayType, constantArrayType);
 
 /// \brief Matches \c ConstantArrayType nodes that have the specified size.
 ///
 /// Given
 /// \code
 ///   int a[42];
 ///   int b[2 * 21];
 ///   int c[41], d[43];
 /// \endcode
 /// constantArrayType(hasSize(42))
 ///   matches "int a[42]" and "int b[2 * 21]"
 AST_MATCHER_P(ConstantArrayType, hasSize, unsigned, N) {
   return Node.getSize() == N;
 }
 
 /// \brief Matches C++ arrays whose size is a value-dependent expression.
 ///
 /// Given
 /// \code
 ///   template<typename T, int Size>
 ///   class array {
 ///     T data[Size];
 ///   };
 /// \endcode
 /// dependentSizedArrayType
 ///   matches "T data[Size]"
 AST_TYPE_MATCHER(DependentSizedArrayType, dependentSizedArrayType);
 
 /// \brief Matches C arrays with unspecified size.
 ///
 /// Given
 /// \code
 ///   int a[] = { 2, 3 };
 ///   int b[42];
 ///   void f(int c[]) { int d[a[0]]; };
 /// \endcode
 /// incompleteArrayType()
 ///   matches "int a[]" and "int c[]"
 AST_TYPE_MATCHER(IncompleteArrayType, incompleteArrayType);
 
 /// \brief Matches C arrays with a specified size that is not an
 /// integer-constant-expression.
 ///
 /// Given
 /// \code
 ///   void f() {
 ///     int a[] = { 2, 3 }
 ///     int b[42];
 ///     int c[a[0]];
 ///   }
 /// \endcode
 /// variableArrayType()
 ///   matches "int c[a[0]]"
 AST_TYPE_MATCHER(VariableArrayType, variableArrayType);
 
 /// \brief Matches \c VariableArrayType nodes that have a specific size
 /// expression.
 ///
 /// Given
 /// \code
 ///   void f(int b) {
 ///     int a[b];
 ///   }
 /// \endcode
 /// variableArrayType(hasSizeExpr(ignoringImpCasts(declRefExpr(to(
 ///   varDecl(hasName("b")))))))
 ///   matches "int a[b]"
 AST_MATCHER_P(VariableArrayType, hasSizeExpr,
               internal::Matcher<Expr>, InnerMatcher) {
   return InnerMatcher.matches(*Node.getSizeExpr(), Finder, Builder);
 }
 
 /// \brief Matches atomic types.
 ///
 /// Given
 /// \code
 ///   _Atomic(int) i;
 /// \endcode
 /// atomicType()
 ///   matches "_Atomic(int) i"
 AST_TYPE_MATCHER(AtomicType, atomicType);
 
 /// \brief Matches atomic types with a specific value type.
 ///
 /// Given
 /// \code
 ///   _Atomic(int) i;
 ///   _Atomic(float) f;
 /// \endcode
 /// atomicType(hasValueType(isInteger()))
 ///  matches "_Atomic(int) i"
 ///
 /// Usable as: Matcher<AtomicType>
 AST_TYPELOC_TRAVERSE_MATCHER(hasValueType, getValue,
                              AST_POLYMORPHIC_SUPPORTED_TYPES_1(AtomicType));
 
 /// \brief Matches types nodes representing C++11 auto types.
 ///
 /// Given:
 /// \code
 ///   auto n = 4;
 ///   int v[] = { 2, 3 }
 ///   for (auto i : v) { }
 /// \endcode
 /// autoType()
 ///   matches "auto n" and "auto i"
 AST_TYPE_MATCHER(AutoType, autoType);
 
 /// \brief Matches \c AutoType nodes where the deduced type is a specific type.
 ///
 /// Note: There is no \c TypeLoc for the deduced type and thus no
 /// \c getDeducedLoc() matcher.
 ///
 /// Given
 /// \code
 ///   auto a = 1;
 ///   auto b = 2.0;
 /// \endcode
 /// autoType(hasDeducedType(isInteger()))
 ///   matches "auto a"
 ///
 /// Usable as: Matcher<AutoType>
 AST_TYPE_TRAVERSE_MATCHER(hasDeducedType, getDeducedType,
                           AST_POLYMORPHIC_SUPPORTED_TYPES_1(AutoType));
 
 /// \brief Matches \c FunctionType nodes.
 ///
 /// Given
 /// \code
 ///   int (*f)(int);
 ///   void g();
 /// \endcode
 /// functionType()
 ///   matches "int (*f)(int)" and the type of "g".
 AST_TYPE_MATCHER(FunctionType, functionType);
 
 /// \brief Matches \c ParenType nodes.
 ///
 /// Given
 /// \code
 ///   int (*ptr_to_array)[4];
 ///   int *array_of_ptrs[4];
 /// \endcode
 ///
 /// \c varDecl(hasType(pointsTo(parenType()))) matches \c ptr_to_array but not
 /// \c array_of_ptrs.
 AST_TYPE_MATCHER(ParenType, parenType);
 
 /// \brief Matches \c ParenType nodes where the inner type is a specific type.
 ///
 /// Given
 /// \code
 ///   int (*ptr_to_array)[4];
 ///   int (*ptr_to_func)(int);
 /// \endcode
 ///
 /// \c varDecl(hasType(pointsTo(parenType(innerType(functionType()))))) matches
 /// \c ptr_to_func but not \c ptr_to_array.
 ///
 /// Usable as: Matcher<ParenType>
 AST_TYPE_TRAVERSE_MATCHER(innerType, getInnerType,
                           AST_POLYMORPHIC_SUPPORTED_TYPES_1(ParenType));
 
 /// \brief Matches block pointer types, i.e. types syntactically represented as
 /// "void (^)(int)".
 ///
 /// The \c pointee is always required to be a \c FunctionType.
 AST_TYPE_MATCHER(BlockPointerType, blockPointerType);
 
 /// \brief Matches member pointer types.
 /// Given
 /// \code
 ///   struct A { int i; }
 ///   A::* ptr = A::i;
 /// \endcode
 /// memberPointerType()
 ///   matches "A::* ptr"
 AST_TYPE_MATCHER(MemberPointerType, memberPointerType);
 
 /// \brief Matches pointer types.
 ///
 /// Given
 /// \code
 ///   int *a;
 ///   int &b = *a;
 ///   int c = 5;
 /// \endcode
 /// pointerType()
 ///   matches "int *a"
 AST_TYPE_MATCHER(PointerType, pointerType);
 
 /// \brief Matches both lvalue and rvalue reference types.
 ///
 /// Given
 /// \code
 ///   int *a;
 ///   int &b = *a;
 ///   int &&c = 1;
 ///   auto &d = b;
 ///   auto &&e = c;
 ///   auto &&f = 2;
 ///   int g = 5;
 /// \endcode
 ///
 /// \c referenceType() matches the types of \c b, \c c, \c d, \c e, and \c f.
 AST_TYPE_MATCHER(ReferenceType, referenceType);
 
 /// \brief Matches lvalue reference types.
 ///
 /// Given:
 /// \code
 ///   int *a;
 ///   int &b = *a;
 ///   int &&c = 1;
 ///   auto &d = b;
 ///   auto &&e = c;
 ///   auto &&f = 2;
 ///   int g = 5;
 /// \endcode
 ///
 /// \c lValueReferenceType() matches the types of \c b, \c d, and \c e. \c e is
 /// matched since the type is deduced as int& by reference collapsing rules.
 AST_TYPE_MATCHER(LValueReferenceType, lValueReferenceType);
 
 /// \brief Matches rvalue reference types.
 ///
 /// Given:
 /// \code
 ///   int *a;
 ///   int &b = *a;
 ///   int &&c = 1;
 ///   auto &d = b;
 ///   auto &&e = c;
 ///   auto &&f = 2;
 ///   int g = 5;
 /// \endcode
 ///
 /// \c rValueReferenceType() matches the types of \c c and \c f. \c e is not
 /// matched as it is deduced to int& by reference collapsing rules.
 AST_TYPE_MATCHER(RValueReferenceType, rValueReferenceType);
 
 /// \brief Narrows PointerType (and similar) matchers to those where the
 /// \c pointee matches a given matcher.
 ///
 /// Given
 /// \code
 ///   int *a;
 ///   int const *b;
 ///   float const *f;
 /// \endcode
 /// pointerType(pointee(isConstQualified(), isInteger()))
 ///   matches "int const *b"
 ///
 /// Usable as: Matcher<BlockPointerType>, Matcher<MemberPointerType>,
 ///   Matcher<PointerType>, Matcher<ReferenceType>
 AST_TYPELOC_TRAVERSE_MATCHER(
     pointee, getPointee,
     AST_POLYMORPHIC_SUPPORTED_TYPES_4(BlockPointerType, MemberPointerType,
                                       PointerType, ReferenceType));
 
 /// \brief Matches typedef types.
 ///
 /// Given
 /// \code
 ///   typedef int X;
 /// \endcode
 /// typedefType()
 ///   matches "typedef int X"
 AST_TYPE_MATCHER(TypedefType, typedefType);
 
 /// \brief Matches template specialization types.
 ///
 /// Given
 /// \code
 ///   template <typename T>
 ///   class C { };
 ///
 ///   template class C<int>;  // A
 ///   C<char> var;            // B
 /// \code
 ///
 /// \c templateSpecializationType() matches the type of the explicit
 /// instantiation in \c A and the type of the variable declaration in \c B.
 AST_TYPE_MATCHER(TemplateSpecializationType, templateSpecializationType);
 
 /// \brief Matches types nodes representing unary type transformations.
 ///
 /// Given:
 /// \code
 ///   typedef __underlying_type(T) type;
 /// \endcode
 /// unaryTransformType()
 ///   matches "__underlying_type(T)"
 AST_TYPE_MATCHER(UnaryTransformType, unaryTransformType);
 
 /// \brief Matches record types (e.g. structs, classes).
 ///
 /// Given
 /// \code
 ///   class C {};
 ///   struct S {};
 ///
 ///   C c;
 ///   S s;
 /// \code
 ///
 /// \c recordType() matches the type of the variable declarations of both \c c
 /// and \c s.
 AST_TYPE_MATCHER(RecordType, recordType);
 
 /// \brief Matches types specified with an elaborated type keyword or with a
 /// qualified name.
 ///
 /// Given
 /// \code
 ///   namespace N {
 ///     namespace M {
 ///       class D {};
 ///     }
 ///   }
 ///   class C {};
 ///
 ///   class C c;
 ///   N::M::D d;
 /// \code
 ///
 /// \c elaboratedType() matches the type of the variable declarations of both
 /// \c c and \c d.
 AST_TYPE_MATCHER(ElaboratedType, elaboratedType);
 
 /// \brief Matches ElaboratedTypes whose qualifier, a NestedNameSpecifier,
 /// matches \c InnerMatcher if the qualifier exists.
 ///
 /// Given
 /// \code
 ///   namespace N {
 ///     namespace M {
 ///       class D {};
 ///     }
 ///   }
 ///   N::M::D d;
 /// \code
 ///
 /// \c elaboratedType(hasQualifier(hasPrefix(specifiesNamespace(hasName("N"))))
 /// matches the type of the variable declaration of \c d.
 AST_MATCHER_P(ElaboratedType, hasQualifier,
               internal::Matcher<NestedNameSpecifier>, InnerMatcher) {
   if (const NestedNameSpecifier *Qualifier = Node.getQualifier())
     return InnerMatcher.matches(*Qualifier, Finder, Builder);
 
   return false;
 }
 
 /// \brief Matches ElaboratedTypes whose named type matches \c InnerMatcher.
 ///
 /// Given
 /// \code
 ///   namespace N {
 ///     namespace M {
 ///       class D {};
 ///     }
 ///   }
 ///   N::M::D d;
 /// \code
 ///
 /// \c elaboratedType(namesType(recordType(
 /// hasDeclaration(namedDecl(hasName("D")))))) matches the type of the variable
 /// declaration of \c d.
 AST_MATCHER_P(ElaboratedType, namesType, internal::Matcher<QualType>,
               InnerMatcher) {
   return InnerMatcher.matches(Node.getNamedType(), Finder, Builder);
 }
 
 /// \brief Matches declarations whose declaration context, interpreted as a
 /// Decl, matches \c InnerMatcher.
 ///
 /// Given
 /// \code
 ///   namespace N {
 ///     namespace M {
 ///       class D {};
 ///     }
 ///   }
 /// \code
 ///
 /// \c recordDecl(hasDeclContext(namedDecl(hasName("M")))) matches the
 /// declaration of \c class \c D.
 AST_MATCHER_P(Decl, hasDeclContext, internal::Matcher<Decl>, InnerMatcher) {
   const DeclContext *DC = Node.getDeclContext();
   if (!DC) return false;
   return InnerMatcher.matches(*Decl::castFromDeclContext(DC), Finder, Builder);
 }
 
 /// \brief Matches nested name specifiers.
 ///
 /// Given
 /// \code
 ///   namespace ns {
 ///     struct A { static void f(); };
 ///     void A::f() {}
 ///     void g() { A::f(); }
 ///   }
 ///   ns::A a;
 /// \endcode
 /// nestedNameSpecifier()
 ///   matches "ns::" and both "A::"
 const internal::VariadicAllOfMatcher<NestedNameSpecifier> nestedNameSpecifier;
 
 /// \brief Same as \c nestedNameSpecifier but matches \c NestedNameSpecifierLoc.
 const internal::VariadicAllOfMatcher<
   NestedNameSpecifierLoc> nestedNameSpecifierLoc;
 
 /// \brief Matches \c NestedNameSpecifierLocs for which the given inner
 /// NestedNameSpecifier-matcher matches.
 AST_MATCHER_FUNCTION_P_OVERLOAD(
     internal::BindableMatcher<NestedNameSpecifierLoc>, loc,
     internal::Matcher<NestedNameSpecifier>, InnerMatcher, 1) {
   return internal::BindableMatcher<NestedNameSpecifierLoc>(
       new internal::LocMatcher<NestedNameSpecifierLoc, NestedNameSpecifier>(
           InnerMatcher));
 }
 
 /// \brief Matches nested name specifiers that specify a type matching the
 /// given \c QualType matcher without qualifiers.
 ///
 /// Given
 /// \code
 ///   struct A { struct B { struct C {}; }; };
 ///   A::B::C c;
 /// \endcode
 /// nestedNameSpecifier(specifiesType(hasDeclaration(recordDecl(hasName("A")))))
 ///   matches "A::"
 AST_MATCHER_P(NestedNameSpecifier, specifiesType,
               internal::Matcher<QualType>, InnerMatcher) {
   if (!Node.getAsType())
     return false;
   return InnerMatcher.matches(QualType(Node.getAsType(), 0), Finder, Builder);
 }
 
 /// \brief Matches nested name specifier locs that specify a type matching the
 /// given \c TypeLoc.
 ///
 /// Given
 /// \code
 ///   struct A { struct B { struct C {}; }; };
 ///   A::B::C c;
 /// \endcode
 /// nestedNameSpecifierLoc(specifiesTypeLoc(loc(type(
 ///   hasDeclaration(recordDecl(hasName("A")))))))
 ///   matches "A::"
 AST_MATCHER_P(NestedNameSpecifierLoc, specifiesTypeLoc,
               internal::Matcher<TypeLoc>, InnerMatcher) {
   return Node && InnerMatcher.matches(Node.getTypeLoc(), Finder, Builder);
 }
 
 /// \brief Matches on the prefix of a \c NestedNameSpecifier.
 ///
 /// Given
 /// \code
 ///   struct A { struct B { struct C {}; }; };
 ///   A::B::C c;
 /// \endcode
 /// nestedNameSpecifier(hasPrefix(specifiesType(asString("struct A")))) and
 ///   matches "A::"
 AST_MATCHER_P_OVERLOAD(NestedNameSpecifier, hasPrefix,
                        internal::Matcher<NestedNameSpecifier>, InnerMatcher,
                        0) {
   NestedNameSpecifier *NextNode = Node.getPrefix();
   if (!NextNode)
     return false;
   return InnerMatcher.matches(*NextNode, Finder, Builder);
 }
 
 /// \brief Matches on the prefix of a \c NestedNameSpecifierLoc.
 ///
 /// Given
 /// \code
 ///   struct A { struct B { struct C {}; }; };
 ///   A::B::C c;
 /// \endcode
 /// nestedNameSpecifierLoc(hasPrefix(loc(specifiesType(asString("struct A")))))
 ///   matches "A::"
 AST_MATCHER_P_OVERLOAD(NestedNameSpecifierLoc, hasPrefix,
                        internal::Matcher<NestedNameSpecifierLoc>, InnerMatcher,
                        1) {
   NestedNameSpecifierLoc NextNode = Node.getPrefix();
   if (!NextNode)
     return false;
   return InnerMatcher.matches(NextNode, Finder, Builder);
 }
 
 /// \brief Matches nested name specifiers that specify a namespace matching the
 /// given namespace matcher.
 ///
 /// Given
 /// \code
 ///   namespace ns { struct A {}; }
 ///   ns::A a;
 /// \endcode
 /// nestedNameSpecifier(specifiesNamespace(hasName("ns")))
 ///   matches "ns::"
 AST_MATCHER_P(NestedNameSpecifier, specifiesNamespace,
               internal::Matcher<NamespaceDecl>, InnerMatcher) {
   if (!Node.getAsNamespace())
     return false;
   return InnerMatcher.matches(*Node.getAsNamespace(), Finder, Builder);
 }
 
 /// \brief Overloads for the \c equalsNode matcher.
 /// FIXME: Implement for other node types.
 /// @{
 
 /// \brief Matches if a node equals another node.
 ///
 /// \c Decl has pointer identity in the AST.
 AST_MATCHER_P_OVERLOAD(Decl, equalsNode, const Decl*, Other, 0) {
   return &Node == Other;
 }
 /// \brief Matches if a node equals another node.
 ///
 /// \c Stmt has pointer identity in the AST.
 ///
 AST_MATCHER_P_OVERLOAD(Stmt, equalsNode, const Stmt*, Other, 1) {
   return &Node == Other;
 }
 
 /// @}
 
 /// \brief Matches each case or default statement belonging to the given switch
 /// statement. This matcher may produce multiple matches.
 ///
 /// Given
 /// \code
 ///   switch (1) { case 1: case 2: default: switch (2) { case 3: case 4: ; } }
 /// \endcode
 /// switchStmt(forEachSwitchCase(caseStmt().bind("c"))).bind("s")
 ///   matches four times, with "c" binding each of "case 1:", "case 2:",
 /// "case 3:" and "case 4:", and "s" respectively binding "switch (1)",
 /// "switch (1)", "switch (2)" and "switch (2)".
 AST_MATCHER_P(SwitchStmt, forEachSwitchCase, internal::Matcher<SwitchCase>,
               InnerMatcher) {
   BoundNodesTreeBuilder Result;
   // FIXME: getSwitchCaseList() does not necessarily guarantee a stable
   // iteration order. We should use the more general iterating matchers once
   // they are capable of expressing this matcher (for example, it should ignore
   // case statements belonging to nested switch statements).
   bool Matched = false;
   for (const SwitchCase *SC = Node.getSwitchCaseList(); SC;
        SC = SC->getNextSwitchCase()) {
     BoundNodesTreeBuilder CaseBuilder(*Builder);
     bool CaseMatched = InnerMatcher.matches(*SC, Finder, &CaseBuilder);
     if (CaseMatched) {
       Matched = true;
       Result.addMatch(CaseBuilder);
     }
   }
   *Builder = std::move(Result);
   return Matched;
 }
 
 /// \brief Matches each constructor initializer in a constructor definition.
 ///
 /// Given
 /// \code
 ///   class A { A() : i(42), j(42) {} int i; int j; };
 /// \endcode
 /// constructorDecl(forEachConstructorInitializer(forField(decl().bind("x"))))
 ///   will trigger two matches, binding for 'i' and 'j' respectively.
 AST_MATCHER_P(CXXConstructorDecl, forEachConstructorInitializer,
               internal::Matcher<CXXCtorInitializer>, InnerMatcher) {
   BoundNodesTreeBuilder Result;
   bool Matched = false;
   for (const auto *I : Node.inits()) {
     BoundNodesTreeBuilder InitBuilder(*Builder);
     if (InnerMatcher.matches(*I, Finder, &InitBuilder)) {
       Matched = true;
       Result.addMatch(InitBuilder);
     }
   }
   *Builder = std::move(Result);
   return Matched;
 }
 
 /// \brief If the given case statement does not use the GNU case range
 /// extension, matches the constant given in the statement.
 ///
 /// Given
 /// \code
 ///   switch (1) { case 1: case 1+1: case 3 ... 4: ; }
 /// \endcode
 /// caseStmt(hasCaseConstant(integerLiteral()))
 ///   matches "case 1:"
 AST_MATCHER_P(CaseStmt, hasCaseConstant, internal::Matcher<Expr>,
               InnerMatcher) {
   if (Node.getRHS())
     return false;
 
   return InnerMatcher.matches(*Node.getLHS(), Finder, Builder);
 }
 
 /// \brief Matches declaration that has a given attribute.
 ///
 /// Given
 /// \code
 ///   __attribute__((device)) void f() { ... }
 /// \endcode
 /// decl(hasAttr(clang::attr::CUDADevice)) matches the function declaration of
 /// f.
 AST_MATCHER_P(Decl, hasAttr, attr::Kind, AttrKind) {
   for (const auto *Attr : Node.attrs()) {
     if (Attr->getKind() == AttrKind)
       return true;
   }
   return false;
 }
 
 /// \brief Matches CUDA kernel call expression.
 ///
 /// Example matches,
 /// \code
 ///   kernel<<<i,j>>>();
 /// \endcode
 const internal::VariadicDynCastAllOfMatcher<Stmt, CUDAKernelCallExpr>
     CUDAKernelCallExpr;
 
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif
diff --git a/clang/include/clang/ASTMatchers/ASTMatchersInternal.h b/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
index ba571f0d1512..1b8040cf440a 100644
--- a/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
+++ b/clang/include/clang/ASTMatchers/ASTMatchersInternal.h
@@ -1,1664 +1,1649 @@
 //===--- ASTMatchersInternal.h - Structural query framework -----*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  Implements the base layer of the matcher framework.
 //
 //  Matchers are methods that return a Matcher<T> which provides a method
 //  Matches(...) which is a predicate on an AST node. The Matches method's
 //  parameters define the context of the match, which allows matchers to recurse
 //  or store the current node as bound to a specific string, so that it can be
 //  retrieved later.
 //
 //  In general, matchers have two parts:
 //  1. A function Matcher<T> MatcherName(<arguments>) which returns a Matcher<T>
 //     based on the arguments and optionally on template type deduction based
 //     on the arguments. Matcher<T>s form an implicit reverse hierarchy
 //     to clang's AST class hierarchy, meaning that you can use a Matcher<Base>
 //     everywhere a Matcher<Derived> is required.
 //  2. An implementation of a class derived from MatcherInterface<T>.
 //
 //  The matcher functions are defined in ASTMatchers.h. To make it possible
 //  to implement both the matcher function and the implementation of the matcher
 //  interface in one place, ASTMatcherMacros.h defines macros that allow
 //  implementing a matcher in a single place.
 //
 //  This file contains the base classes needed to construct the actual matchers.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
 #define LLVM_CLANG_ASTMATCHERS_ASTMATCHERSINTERNAL_H
 
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/Stmt.h"
 #include "clang/AST/StmtCXX.h"
 #include "clang/AST/Type.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/VariadicFunction.h"
 #include <map>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace ast_matchers {
 
 class BoundNodes;
 
 namespace internal {
 
 /// \brief Internal version of BoundNodes. Holds all the bound nodes.
 class BoundNodesMap {
 public:
   /// \brief Adds \c Node to the map with key \c ID.
   ///
   /// The node's base type should be in NodeBaseType or it will be unaccessible.
   void addNode(StringRef ID, const ast_type_traits::DynTypedNode& DynNode) {
     NodeMap[ID] = DynNode;
   }
 
   /// \brief Returns the AST node bound to \c ID.
   ///
   /// Returns NULL if there was no node bound to \c ID or if there is a node but
   /// it cannot be converted to the specified type.
   template <typename T>
   const T *getNodeAs(StringRef ID) const {
     IDToNodeMap::const_iterator It = NodeMap.find(ID);
     if (It == NodeMap.end()) {
       return nullptr;
     }
     return It->second.get<T>();
   }
 
   ast_type_traits::DynTypedNode getNode(StringRef ID) const {
     IDToNodeMap::const_iterator It = NodeMap.find(ID);
     if (It == NodeMap.end()) {
       return ast_type_traits::DynTypedNode();
     }
     return It->second;
   }
 
   /// \brief Imposes an order on BoundNodesMaps.
   bool operator<(const BoundNodesMap &Other) const {
     return NodeMap < Other.NodeMap;
   }
 
   /// \brief A map from IDs to the bound nodes.
   ///
   /// Note that we're using std::map here, as for memoization:
   /// - we need a comparison operator
   /// - we need an assignment operator
   typedef std::map<std::string, ast_type_traits::DynTypedNode> IDToNodeMap;
 
   const IDToNodeMap &getMap() const {
     return NodeMap;
   }
 
   /// \brief Returns \c true if this \c BoundNodesMap can be compared, i.e. all
   /// stored nodes have memoization data.
   bool isComparable() const {
     for (const auto &IDAndNode : NodeMap) {
       if (!IDAndNode.second.getMemoizationData())
         return false;
     }
     return true;
   }
 
 private:
   IDToNodeMap NodeMap;
 };
 
 /// \brief Creates BoundNodesTree objects.
 ///
 /// The tree builder is used during the matching process to insert the bound
 /// nodes from the Id matcher.
 class BoundNodesTreeBuilder {
 public:
   /// \brief A visitor interface to visit all BoundNodes results for a
   /// BoundNodesTree.
   class Visitor {
   public:
     virtual ~Visitor() {}
 
     /// \brief Called multiple times during a single call to VisitMatches(...).
     ///
     /// 'BoundNodesView' contains the bound nodes for a single match.
     virtual void visitMatch(const BoundNodes& BoundNodesView) = 0;
   };
 
   /// \brief Add a binding from an id to a node.
   void setBinding(const std::string &Id,
                   const ast_type_traits::DynTypedNode &DynNode) {
     if (Bindings.empty())
       Bindings.push_back(BoundNodesMap());
     for (BoundNodesMap &Binding : Bindings)
       Binding.addNode(Id, DynNode);
   }
 
   /// \brief Adds a branch in the tree.
   void addMatch(const BoundNodesTreeBuilder &Bindings);
 
   /// \brief Visits all matches that this BoundNodesTree represents.
   ///
   /// The ownership of 'ResultVisitor' remains at the caller.
   void visitMatches(Visitor* ResultVisitor);
 
   template <typename ExcludePredicate>
   bool removeBindings(const ExcludePredicate &Predicate) {
     Bindings.erase(std::remove_if(Bindings.begin(), Bindings.end(), Predicate),
                    Bindings.end());
     return !Bindings.empty();
   }
 
   /// \brief Imposes an order on BoundNodesTreeBuilders.
   bool operator<(const BoundNodesTreeBuilder &Other) const {
     return Bindings < Other.Bindings;
   }
 
   /// \brief Returns \c true if this \c BoundNodesTreeBuilder can be compared,
   /// i.e. all stored node maps have memoization data.
   bool isComparable() const {
     for (const BoundNodesMap &NodesMap : Bindings) {
       if (!NodesMap.isComparable())
         return false;
     }
     return true;
   }
 
 private:
   SmallVector<BoundNodesMap, 16> Bindings;
 };
 
 class ASTMatchFinder;
 
 /// \brief Generic interface for all matchers.
 ///
 /// Used by the implementation of Matcher<T> and DynTypedMatcher.
 /// In general, implement MatcherInterface<T> or SingleNodeMatcherInterface<T>
 /// instead.
 class DynMatcherInterface : public RefCountedBaseVPTR {
 public:
   /// \brief Returns true if \p DynNode can be matched.
   ///
   /// May bind \p DynNode to an ID via \p Builder, or recurse into
   /// the AST via \p Finder.
   virtual bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
                           ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const = 0;
 };
 
 /// \brief Generic interface for matchers on an AST node of type T.
 ///
 /// Implement this if your matcher may need to inspect the children or
 /// descendants of the node or bind matched nodes to names. If you are
 /// writing a simple matcher that only inspects properties of the
 /// current node and doesn't care about its children or descendants,
 /// implement SingleNodeMatcherInterface instead.
 template <typename T>
 class MatcherInterface : public DynMatcherInterface {
 public:
   virtual ~MatcherInterface() {}
 
   /// \brief Returns true if 'Node' can be matched.
   ///
   /// May bind 'Node' to an ID via 'Builder', or recurse into
   /// the AST via 'Finder'.
   virtual bool matches(const T &Node,
                        ASTMatchFinder *Finder,
                        BoundNodesTreeBuilder *Builder) const = 0;
 
   bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
                   ASTMatchFinder *Finder,
                   BoundNodesTreeBuilder *Builder) const override {
     if (const T *Node = DynNode.get<T>()) {
       return matches(*Node, Finder, Builder);
     }
     return false;
   }
 };
 
 /// \brief Interface for matchers that only evaluate properties on a single
 /// node.
 template <typename T>
 class SingleNodeMatcherInterface : public MatcherInterface<T> {
 public:
   /// \brief Returns true if the matcher matches the provided node.
   ///
   /// A subclass must implement this instead of Matches().
   virtual bool matchesNode(const T &Node) const = 0;
 
 private:
   /// Implements MatcherInterface::Matches.
   bool matches(const T &Node,
                ASTMatchFinder * /* Finder */,
                BoundNodesTreeBuilder * /*  Builder */) const override {
     return matchesNode(Node);
   }
 };
 
 template <typename> class Matcher;
 
 /// \brief Matcher that works on a \c DynTypedNode.
 ///
 /// It is constructed from a \c Matcher<T> object and redirects most calls to
 /// underlying matcher.
 /// It checks whether the \c DynTypedNode is convertible into the type of the
 /// underlying matcher and then do the actual match on the actual node, or
 /// return false if it is not convertible.
 class DynTypedMatcher {
 public:
   /// \brief Takes ownership of the provided implementation pointer.
   template <typename T>
   DynTypedMatcher(MatcherInterface<T> *Implementation)
       : AllowBind(false),
         SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
         RestrictKind(SupportedKind), Implementation(Implementation) {}
 
   /// \brief Construct from a variadic function.
-  typedef bool (*VariadicOperatorFunction)(
-      const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder,
-      BoundNodesTreeBuilder *Builder, ArrayRef<DynTypedMatcher> InnerMatchers);
+  enum VariadicOperator {
+    /// \brief Matches nodes for which all provided matchers match.
+    VO_AllOf,
+    /// \brief Matches nodes for which at least one of the provided matchers
+    /// matches.
+    VO_AnyOf,
+    /// \brief Matches nodes for which at least one of the provided matchers
+    /// matches, but doesn't stop at the first match.
+    VO_EachOf,
+    /// \brief Matches nodes that do not match the provided matcher.
+    ///
+    /// Uses the variadic matcher interface, but fails if
+    /// InnerMatchers.size() != 1.
+    VO_UnaryNot
+  };
   static DynTypedMatcher
-  constructVariadic(VariadicOperatorFunction Func,
+  constructVariadic(VariadicOperator Op,
                     std::vector<DynTypedMatcher> InnerMatchers);
 
   /// \brief Get a "true" matcher for \p NodeKind.
   ///
   /// It only checks that the node is of the right kind.
   static DynTypedMatcher trueMatcher(ast_type_traits::ASTNodeKind NodeKind);
 
   void setAllowBind(bool AB) { AllowBind = AB; }
 
   /// \brief Return a matcher that points to the same implementation, but
   ///   restricts the node types for \p Kind.
   DynTypedMatcher dynCastTo(const ast_type_traits::ASTNodeKind Kind) const;
 
   /// \brief Returns true if the matcher matches the given \c DynNode.
   bool matches(const ast_type_traits::DynTypedNode &DynNode,
                ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const;
 
   /// \brief Bind the specified \p ID to the matcher.
   /// \return A new matcher with the \p ID bound to it if this matcher supports
   ///   binding. Otherwise, returns an empty \c Optional<>.
   llvm::Optional<DynTypedMatcher> tryBind(StringRef ID) const;
 
   /// \brief Returns a unique \p ID for the matcher.
   ///
   /// Casting a Matcher<T> to Matcher<U> creates a matcher that has the
   /// same \c Implementation pointer, but different \c RestrictKind. We need to
   /// include both in the ID to make it unique.
   ///
   /// \c MatcherIDType supports operator< and provides strict weak ordering.
   typedef std::pair<ast_type_traits::ASTNodeKind, uint64_t> MatcherIDType;
   MatcherIDType getID() const {
     /// FIXME: Document the requirements this imposes on matcher
     /// implementations (no new() implementation_ during a Matches()).
     return std::make_pair(RestrictKind,
                           reinterpret_cast<uint64_t>(Implementation.get()));
   }
 
   /// \brief Returns the type this matcher works on.
   ///
   /// \c matches() will always return false unless the node passed is of this
   /// or a derived type.
   ast_type_traits::ASTNodeKind getSupportedKind() const {
     return SupportedKind;
   }
 
   /// \brief Returns \c true if the passed \c DynTypedMatcher can be converted
   ///   to a \c Matcher<T>.
   ///
   /// This method verifies that the underlying matcher in \c Other can process
   /// nodes of types T.
   template <typename T> bool canConvertTo() const {
     return canConvertTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
   }
   bool canConvertTo(ast_type_traits::ASTNodeKind To) const;
 
   /// \brief Construct a \c Matcher<T> interface around the dynamic matcher.
   ///
   /// This method asserts that \c canConvertTo() is \c true. Callers
   /// should call \c canConvertTo() first to make sure that \c this is
   /// compatible with T.
   template <typename T> Matcher<T> convertTo() const {
     assert(canConvertTo<T>());
     return unconditionalConvertTo<T>();
   }
 
   /// \brief Same as \c convertTo(), but does not check that the underlying
   ///   matcher can handle a value of T.
   ///
   /// If it is not compatible, then this matcher will never match anything.
   template <typename T> Matcher<T> unconditionalConvertTo() const;
 
 private:
  DynTypedMatcher(ast_type_traits::ASTNodeKind SupportedKind,
                  ast_type_traits::ASTNodeKind RestrictKind,
                  IntrusiveRefCntPtr<DynMatcherInterface> Implementation)
      : AllowBind(false),
        SupportedKind(SupportedKind),
        RestrictKind(RestrictKind),
        Implementation(std::move(Implementation)) {}
 
   bool AllowBind;
   ast_type_traits::ASTNodeKind SupportedKind;
   /// \brief A potentially stricter node kind.
   ///
   /// It allows to perform implicit and dynamic cast of matchers without
   /// needing to change \c Implementation.
   ast_type_traits::ASTNodeKind RestrictKind;
   IntrusiveRefCntPtr<DynMatcherInterface> Implementation;
 };
 
 /// \brief Wrapper of a MatcherInterface<T> *that allows copying.
 ///
 /// A Matcher<Base> can be used anywhere a Matcher<Derived> is
 /// required. This establishes an is-a relationship which is reverse
 /// to the AST hierarchy. In other words, Matcher<T> is contravariant
 /// with respect to T. The relationship is built via a type conversion
 /// operator rather than a type hierarchy to be able to templatize the
 /// type hierarchy instead of spelling it out.
 template <typename T>
 class Matcher {
 public:
   /// \brief Takes ownership of the provided implementation pointer.
   explicit Matcher(MatcherInterface<T> *Implementation)
       : Implementation(Implementation) {}
 
   /// \brief Implicitly converts \c Other to a Matcher<T>.
   ///
   /// Requires \c T to be derived from \c From.
   template <typename From>
   Matcher(const Matcher<From> &Other,
           typename std::enable_if<std::is_base_of<From, T>::value &&
                                   !std::is_same<From, T>::value>::type * = 0)
       : Implementation(restrictMatcher(Other.Implementation)) {
     assert(Implementation.getSupportedKind().isSame(
         ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
   }
 
   /// \brief Implicitly converts \c Matcher<Type> to \c Matcher<QualType>.
   ///
   /// The resulting matcher is not strict, i.e. ignores qualifiers.
   template <typename TypeT>
   Matcher(const Matcher<TypeT> &Other,
           typename std::enable_if<
             std::is_same<T, QualType>::value &&
             std::is_same<TypeT, Type>::value>::type* = 0)
       : Implementation(new TypeToQualType<TypeT>(Other)) {}
 
   /// \brief Convert \c this into a \c Matcher<T> by applying dyn_cast<> to the
   /// argument.
   /// \c To must be a base class of \c T.
   template <typename To>
   Matcher<To> dynCastTo() const {
     static_assert(std::is_base_of<To, T>::value, "Invalid dynCast call.");
     return Matcher<To>(Implementation);
   }
 
   /// \brief Forwards the call to the underlying MatcherInterface<T> pointer.
   bool matches(const T &Node,
                ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const {
     return Implementation.matches(ast_type_traits::DynTypedNode::create(Node),
                                   Finder, Builder);
   }
 
   /// \brief Returns an ID that uniquely identifies the matcher.
   DynTypedMatcher::MatcherIDType getID() const {
     return Implementation.getID();
   }
 
   /// \brief Extract the dynamic matcher.
   ///
   /// The returned matcher keeps the same restrictions as \c this and remembers
   /// that it is meant to support nodes of type \c T.
   operator DynTypedMatcher() const { return Implementation; }
 
   /// \brief Allows the conversion of a \c Matcher<Type> to a \c
   /// Matcher<QualType>.
   ///
   /// Depending on the constructor argument, the matcher is either strict, i.e.
   /// does only matches in the absence of qualifiers, or not, i.e. simply
   /// ignores any qualifiers.
   template <typename TypeT>
   class TypeToQualType : public MatcherInterface<QualType> {
    public:
     TypeToQualType(const Matcher<TypeT> &InnerMatcher)
         : InnerMatcher(InnerMatcher) {}
 
     bool matches(const QualType &Node, ASTMatchFinder *Finder,
                  BoundNodesTreeBuilder *Builder) const override {
       if (Node.isNull())
         return false;
       return InnerMatcher.matches(*Node, Finder, Builder);
     }
    private:
     const Matcher<TypeT> InnerMatcher;
   };
 
 private:
   // For Matcher<T> <=> Matcher<U> conversions.
   template <typename U> friend class Matcher;
   // For DynTypedMatcher::unconditionalConvertTo<T>.
   friend class DynTypedMatcher;
 
   static DynTypedMatcher restrictMatcher(const DynTypedMatcher &Other) {
     return Other.dynCastTo(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
   }
 
   explicit Matcher(const DynTypedMatcher &Implementation)
       : Implementation(restrictMatcher(Implementation)) {
     assert(this->Implementation.getSupportedKind()
                .isSame(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
   }
 
   DynTypedMatcher Implementation;
 };  // class Matcher
 
 /// \brief A convenient helper for creating a Matcher<T> without specifying
 /// the template type argument.
 template <typename T>
 inline Matcher<T> makeMatcher(MatcherInterface<T> *Implementation) {
   return Matcher<T>(Implementation);
 }
 
 /// \brief Specialization of the conversion functions for QualType.
 ///
 /// This specialization provides the Matcher<Type>->Matcher<QualType>
 /// conversion that the static API does.
 template <>
 inline Matcher<QualType> DynTypedMatcher::convertTo<QualType>() const {
   assert(canConvertTo<QualType>());
   const ast_type_traits::ASTNodeKind SourceKind = getSupportedKind();
   if (SourceKind.isSame(
           ast_type_traits::ASTNodeKind::getFromNodeKind<Type>())) {
     // We support implicit conversion from Matcher<Type> to Matcher<QualType>
     return unconditionalConvertTo<Type>();
   }
   return unconditionalConvertTo<QualType>();
 }
 
 /// \brief Finds the first node in a range that matches the given matcher.
 template <typename MatcherT, typename IteratorT>
 bool matchesFirstInRange(const MatcherT &Matcher, IteratorT Start,
                          IteratorT End, ASTMatchFinder *Finder,
                          BoundNodesTreeBuilder *Builder) {
   for (IteratorT I = Start; I != End; ++I) {
     BoundNodesTreeBuilder Result(*Builder);
     if (Matcher.matches(*I, Finder, &Result)) {
       *Builder = std::move(Result);
       return true;
     }
   }
   return false;
 }
 
 /// \brief Finds the first node in a pointer range that matches the given
 /// matcher.
 template <typename MatcherT, typename IteratorT>
 bool matchesFirstInPointerRange(const MatcherT &Matcher, IteratorT Start,
                                 IteratorT End, ASTMatchFinder *Finder,
                                 BoundNodesTreeBuilder *Builder) {
   for (IteratorT I = Start; I != End; ++I) {
     BoundNodesTreeBuilder Result(*Builder);
     if (Matcher.matches(**I, Finder, &Result)) {
       *Builder = std::move(Result);
       return true;
     }
   }
   return false;
 }
 
 /// \brief Metafunction to determine if type T has a member called getDecl.
 template <typename T> struct has_getDecl {
   struct Default { int getDecl; };
   struct Derived : T, Default { };
 
   template<typename C, C> struct CheckT;
 
   // If T::getDecl exists, an ambiguity arises and CheckT will
   // not be instantiable. This makes f(...) the only available
   // overload.
   template<typename C>
   static char (&f(CheckT<int Default::*, &C::getDecl>*))[1];
   template<typename C> static char (&f(...))[2];
 
   static bool const value = sizeof(f<Derived>(nullptr)) == 2;
 };
 
 /// \brief Matches overloaded operators with a specific name.
 ///
 /// The type argument ArgT is not used by this matcher but is used by
 /// PolymorphicMatcherWithParam1 and should be StringRef.
 template <typename T, typename ArgT>
 class HasOverloadedOperatorNameMatcher : public SingleNodeMatcherInterface<T> {
   static_assert(std::is_same<T, CXXOperatorCallExpr>::value ||
                 std::is_base_of<FunctionDecl, T>::value,
                 "unsupported class for matcher");
   static_assert(std::is_same<ArgT, StringRef>::value,
                 "argument type must be StringRef");
 
 public:
   explicit HasOverloadedOperatorNameMatcher(const StringRef Name)
       : SingleNodeMatcherInterface<T>(), Name(Name) {}
 
   bool matchesNode(const T &Node) const override {
     return matchesSpecialized(Node);
   }
 
 private:
 
   /// \brief CXXOperatorCallExpr exist only for calls to overloaded operators
   /// so this function returns true if the call is to an operator of the given
   /// name.
   bool matchesSpecialized(const CXXOperatorCallExpr &Node) const {
     return getOperatorSpelling(Node.getOperator()) == Name;
   }
 
   /// \brief Returns true only if CXXMethodDecl represents an overloaded
   /// operator and has the given operator name.
   bool matchesSpecialized(const FunctionDecl &Node) const {
     return Node.isOverloadedOperator() &&
            getOperatorSpelling(Node.getOverloadedOperator()) == Name;
   }
 
   std::string Name;
 };
 
 /// \brief Matches named declarations with a specific name.
 ///
 /// See \c hasName() in ASTMatchers.h for details.
 class HasNameMatcher : public SingleNodeMatcherInterface<NamedDecl> {
  public:
   explicit HasNameMatcher(StringRef Name);
 
   bool matchesNode(const NamedDecl &Node) const override;
 
  private:
   /// \brief Unqualified match routine.
   ///
   /// It is much faster than the full match, but it only works for unqualified
   /// matches.
   bool matchesNodeUnqualified(const NamedDecl &Node) const;
 
   /// \brief Full match routine
   ///
   /// It generates the fully qualified name of the declaration (which is
   /// expensive) before trying to match.
   /// It is slower but simple and works on all cases.
   bool matchesNodeFull(const NamedDecl &Node) const;
 
   const bool UseUnqualifiedMatch;
   const std::string Name;
 };
 
 /// \brief Matches declarations for QualType and CallExpr.
 ///
 /// Type argument DeclMatcherT is required by PolymorphicMatcherWithParam1 but
 /// not actually used.
 template <typename T, typename DeclMatcherT>
 class HasDeclarationMatcher : public MatcherInterface<T> {
   static_assert(std::is_same<DeclMatcherT, Matcher<Decl>>::value,
                 "instantiated with wrong types");
 
 public:
   explicit HasDeclarationMatcher(const Matcher<Decl> &InnerMatcher)
       : InnerMatcher(InnerMatcher) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     return matchesSpecialized(Node, Finder, Builder);
   }
 
 private:
   /// \brief If getDecl exists as a member of U, returns whether the inner
   /// matcher matches Node.getDecl().
   template <typename U>
   bool matchesSpecialized(
       const U &Node, ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
       typename std::enable_if<has_getDecl<U>::value, int>::type = 0) const {
     return matchesDecl(Node.getDecl(), Finder, Builder);
   }
 
   /// \brief Extracts the CXXRecordDecl or EnumDecl of a QualType and returns
   /// whether the inner matcher matches on it.
   bool matchesSpecialized(const QualType &Node, ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
     /// FIXME: Add other ways to convert...
     if (Node.isNull())
       return false;
     if (const EnumType *AsEnum = dyn_cast<EnumType>(Node.getTypePtr()))
       return matchesDecl(AsEnum->getDecl(), Finder, Builder);
     return matchesDecl(Node->getAsCXXRecordDecl(), Finder, Builder);
   }
 
   /// \brief Gets the TemplateDecl from a TemplateSpecializationType
   /// and returns whether the inner matches on it.
   bool matchesSpecialized(const TemplateSpecializationType &Node,
                           ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
     return matchesDecl(Node.getTemplateName().getAsTemplateDecl(),
                        Finder, Builder);
   }
 
   /// \brief Extracts the Decl of the callee of a CallExpr and returns whether
   /// the inner matcher matches on it.
   bool matchesSpecialized(const CallExpr &Node, ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
     return matchesDecl(Node.getCalleeDecl(), Finder, Builder);
   }
 
   /// \brief Extracts the Decl of the constructor call and returns whether the
   /// inner matcher matches on it.
   bool matchesSpecialized(const CXXConstructExpr &Node,
                           ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
     return matchesDecl(Node.getConstructor(), Finder, Builder);
   }
 
   /// \brief Extracts the \c ValueDecl a \c MemberExpr refers to and returns
   /// whether the inner matcher matches on it.
   bool matchesSpecialized(const MemberExpr &Node,
                           ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
     return matchesDecl(Node.getMemberDecl(), Finder, Builder);
   }
 
   /// \brief Returns whether the inner matcher \c Node. Returns false if \c Node
   /// is \c NULL.
   bool matchesDecl(const Decl *Node,
                    ASTMatchFinder *Finder,
                    BoundNodesTreeBuilder *Builder) const {
     return Node != nullptr && InnerMatcher.matches(*Node, Finder, Builder);
   }
 
   const Matcher<Decl> InnerMatcher;
 };
 
 /// \brief IsBaseType<T>::value is true if T is a "base" type in the AST
 /// node class hierarchies.
 template <typename T>
 struct IsBaseType {
   static const bool value =
       std::is_same<T, Decl>::value ||
       std::is_same<T, Stmt>::value ||
       std::is_same<T, QualType>::value ||
       std::is_same<T, Type>::value ||
       std::is_same<T, TypeLoc>::value ||
       std::is_same<T, NestedNameSpecifier>::value ||
       std::is_same<T, NestedNameSpecifierLoc>::value ||
       std::is_same<T, CXXCtorInitializer>::value;
 };
 template <typename T>
 const bool IsBaseType<T>::value;
 
 /// \brief Interface that allows matchers to traverse the AST.
 /// FIXME: Find a better name.
 ///
 /// This provides three entry methods for each base node type in the AST:
 /// - \c matchesChildOf:
 ///   Matches a matcher on every child node of the given node. Returns true
 ///   if at least one child node could be matched.
 /// - \c matchesDescendantOf:
 ///   Matches a matcher on all descendant nodes of the given node. Returns true
 ///   if at least one descendant matched.
 /// - \c matchesAncestorOf:
 ///   Matches a matcher on all ancestors of the given node. Returns true if
 ///   at least one ancestor matched.
 ///
 /// FIXME: Currently we only allow Stmt and Decl nodes to start a traversal.
 /// In the future, we wan to implement this for all nodes for which it makes
 /// sense. In the case of matchesAncestorOf, we'll want to implement it for
 /// all nodes, as all nodes have ancestors.
 class ASTMatchFinder {
 public:
   /// \brief Defines how we descend a level in the AST when we pass
   /// through expressions.
   enum TraversalKind {
     /// Will traverse any child nodes.
     TK_AsIs,
     /// Will not traverse implicit casts and parentheses.
     TK_IgnoreImplicitCastsAndParentheses
   };
 
   /// \brief Defines how bindings are processed on recursive matches.
   enum BindKind {
     /// Stop at the first match and only bind the first match.
     BK_First,
     /// Create results for all combinations of bindings that match.
     BK_All
   };
 
   /// \brief Defines which ancestors are considered for a match.
   enum AncestorMatchMode {
     /// All ancestors.
     AMM_All,
     /// Direct parent only.
     AMM_ParentOnly
   };
 
   virtual ~ASTMatchFinder() {}
 
   /// \brief Returns true if the given class is directly or indirectly derived
   /// from a base type matching \c base.
   ///
   /// A class is considered to be also derived from itself.
   virtual bool classIsDerivedFrom(const CXXRecordDecl *Declaration,
                                   const Matcher<NamedDecl> &Base,
                                   BoundNodesTreeBuilder *Builder) = 0;
 
   template <typename T>
   bool matchesChildOf(const T &Node,
                       const DynTypedMatcher &Matcher,
                       BoundNodesTreeBuilder *Builder,
                       TraversalKind Traverse,
                       BindKind Bind) {
     static_assert(std::is_base_of<Decl, T>::value ||
                   std::is_base_of<Stmt, T>::value ||
                   std::is_base_of<NestedNameSpecifier, T>::value ||
                   std::is_base_of<NestedNameSpecifierLoc, T>::value ||
                   std::is_base_of<TypeLoc, T>::value ||
                   std::is_base_of<QualType, T>::value,
                   "unsupported type for recursive matching");
    return matchesChildOf(ast_type_traits::DynTypedNode::create(Node),
                           Matcher, Builder, Traverse, Bind);
   }
 
   template <typename T>
   bool matchesDescendantOf(const T &Node,
                            const DynTypedMatcher &Matcher,
                            BoundNodesTreeBuilder *Builder,
                            BindKind Bind) {
     static_assert(std::is_base_of<Decl, T>::value ||
                   std::is_base_of<Stmt, T>::value ||
                   std::is_base_of<NestedNameSpecifier, T>::value ||
                   std::is_base_of<NestedNameSpecifierLoc, T>::value ||
                   std::is_base_of<TypeLoc, T>::value ||
                   std::is_base_of<QualType, T>::value,
                   "unsupported type for recursive matching");
     return matchesDescendantOf(ast_type_traits::DynTypedNode::create(Node),
                                Matcher, Builder, Bind);
   }
 
   // FIXME: Implement support for BindKind.
   template <typename T>
   bool matchesAncestorOf(const T &Node,
                          const DynTypedMatcher &Matcher,
                          BoundNodesTreeBuilder *Builder,
                          AncestorMatchMode MatchMode) {
     static_assert(std::is_base_of<Decl, T>::value ||
                   std::is_base_of<Stmt, T>::value,
                   "only Decl or Stmt allowed for recursive matching");
     return matchesAncestorOf(ast_type_traits::DynTypedNode::create(Node),
                              Matcher, Builder, MatchMode);
   }
 
   virtual ASTContext &getASTContext() const = 0;
 
 protected:
   virtual bool matchesChildOf(const ast_type_traits::DynTypedNode &Node,
                               const DynTypedMatcher &Matcher,
                               BoundNodesTreeBuilder *Builder,
                               TraversalKind Traverse,
                               BindKind Bind) = 0;
 
   virtual bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node,
                                    const DynTypedMatcher &Matcher,
                                    BoundNodesTreeBuilder *Builder,
                                    BindKind Bind) = 0;
 
   virtual bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node,
                                  const DynTypedMatcher &Matcher,
                                  BoundNodesTreeBuilder *Builder,
                                  AncestorMatchMode MatchMode) = 0;
 };
 
 /// \brief A type-list implementation.
 ///
 /// A list is declared as a tree of type list nodes, where the leafs are the
 /// types.
 /// However, it is used as a "linked list" of types, by using the ::head and
 /// ::tail typedefs.
 /// Each node supports up to 4 children (instead of just 2) to reduce the
 /// nesting required by large lists.
 template <typename T1 = void, typename T2 = void, typename T3 = void,
           typename T4 = void>
 struct TypeList {
   /// \brief Implementation detail. Combined with the specializations below,
   ///   this typedef allows for flattening of nested structures.
   typedef TypeList<T1, T2, T3, T4> self;
 
   /// \brief The first type on the list.
   typedef T1 head;
 
   /// \brief A sublist with the tail. ie everything but the head.
   ///
   /// This type is used to do recursion. TypeList<>/EmptyTypeList indicates the
   /// end of the list.
   typedef typename TypeList<T2, T3, T4>::self tail;
 };
 
 /// \brief Template specialization to allow nested lists.
 ///
 /// First element is a typelist. Pop its first element.
 template <typename Sub1, typename Sub2, typename Sub3, typename Sub4,
           typename T2, typename T3, typename T4>
 struct TypeList<TypeList<Sub1, Sub2, Sub3, Sub4>, T2, T3,
                 T4> : public TypeList<Sub1,
                                       typename TypeList<Sub2, Sub3, Sub4>::self,
                                       typename TypeList<T2, T3, T4>::self> {};
 
 /// \brief Template specialization to allow nested lists.
 ///
 /// First element is an empty typelist. Skip it.
 template <typename T2, typename T3, typename T4>
 struct TypeList<TypeList<>, T2, T3, T4> : public TypeList<T2, T3, T4> {
 };
 
 /// \brief The empty type list.
 typedef TypeList<> EmptyTypeList;
 
 /// \brief Helper meta-function to determine if some type \c T is present or
 ///   a parent type in the list.
 template <typename AnyTypeList, typename T>
 struct TypeListContainsSuperOf {
   static const bool value =
       std::is_base_of<typename AnyTypeList::head, T>::value ||
       TypeListContainsSuperOf<typename AnyTypeList::tail, T>::value;
 };
 template <typename T>
 struct TypeListContainsSuperOf<EmptyTypeList, T> {
   static const bool value = false;
 };
 
 /// \brief A "type list" that contains all types.
 ///
 /// Useful for matchers like \c anything and \c unless.
 typedef TypeList<
     TypeList<Decl, Stmt, NestedNameSpecifier, NestedNameSpecifierLoc>,
     TypeList<QualType, Type, TypeLoc, CXXCtorInitializer> > AllNodeBaseTypes;
 
 /// \brief Helper meta-function to extract the argument out of a function of
 ///   type void(Arg).
 ///
 /// See AST_POLYMORPHIC_SUPPORTED_TYPES_* for details.
 template <class T> struct ExtractFunctionArgMeta;
 template <class T> struct ExtractFunctionArgMeta<void(T)> {
   typedef T type;
 };
 
 /// \brief Default type lists for ArgumentAdaptingMatcher matchers.
 typedef AllNodeBaseTypes AdaptativeDefaultFromTypes;
 typedef TypeList<TypeList<Decl, Stmt, NestedNameSpecifier>,
                  TypeList<NestedNameSpecifierLoc, TypeLoc, QualType> >
 AdaptativeDefaultToTypes;
 
 /// \brief All types that are supported by HasDeclarationMatcher above.
 typedef TypeList<TypeList<CallExpr, CXXConstructExpr, DeclRefExpr, EnumType>,
                  TypeList<InjectedClassNameType, LabelStmt, MemberExpr>,
                  TypeList<QualType, RecordType, TagType>,
                  TypeList<TemplateSpecializationType, TemplateTypeParmType,
                           TypedefType, UnresolvedUsingType> >
 HasDeclarationSupportedTypes;
 
 /// \brief Converts a \c Matcher<T> to a matcher of desired type \c To by
 /// "adapting" a \c To into a \c T.
 ///
 /// The \c ArgumentAdapterT argument specifies how the adaptation is done.
 ///
 /// For example:
 ///   \c ArgumentAdaptingMatcher<HasMatcher, T>(InnerMatcher);
 /// Given that \c InnerMatcher is of type \c Matcher<T>, this returns a matcher
 /// that is convertible into any matcher of type \c To by constructing
 /// \c HasMatcher<To, T>(InnerMatcher).
 ///
 /// If a matcher does not need knowledge about the inner type, prefer to use
 /// PolymorphicMatcherWithParam1.
 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
           typename FromTypes = AdaptativeDefaultFromTypes,
           typename ToTypes = AdaptativeDefaultToTypes>
 struct ArgumentAdaptingMatcherFunc {
   template <typename T> class Adaptor {
   public:
     explicit Adaptor(const Matcher<T> &InnerMatcher)
         : InnerMatcher(InnerMatcher) {}
 
     typedef ToTypes ReturnTypes;
 
     template <typename To> operator Matcher<To>() const {
       return Matcher<To>(new ArgumentAdapterT<To, T>(InnerMatcher));
     }
 
   private:
     const Matcher<T> InnerMatcher;
   };
 
   template <typename T>
   static Adaptor<T> create(const Matcher<T> &InnerMatcher) {
     return Adaptor<T>(InnerMatcher);
   }
 
   template <typename T>
   Adaptor<T> operator()(const Matcher<T> &InnerMatcher) const {
     return create(InnerMatcher);
   }
 };
 
 /// \brief A PolymorphicMatcherWithParamN<MatcherT, P1, ..., PN> object can be
 /// created from N parameters p1, ..., pN (of type P1, ..., PN) and
 /// used as a Matcher<T> where a MatcherT<T, P1, ..., PN>(p1, ..., pN)
 /// can be constructed.
 ///
 /// For example:
 /// - PolymorphicMatcherWithParam0<IsDefinitionMatcher>()
 ///   creates an object that can be used as a Matcher<T> for any type T
 ///   where an IsDefinitionMatcher<T>() can be constructed.
 /// - PolymorphicMatcherWithParam1<ValueEqualsMatcher, int>(42)
 ///   creates an object that can be used as a Matcher<T> for any type T
 ///   where a ValueEqualsMatcher<T, int>(42) can be constructed.
 template <template <typename T> class MatcherT,
           typename ReturnTypesF = void(AllNodeBaseTypes)>
 class PolymorphicMatcherWithParam0 {
 public:
   typedef typename ExtractFunctionArgMeta<ReturnTypesF>::type ReturnTypes;
   template <typename T>
   operator Matcher<T>() const {
     static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
                   "right polymorphic conversion");
     return Matcher<T>(new MatcherT<T>());
   }
 };
 
 template <template <typename T, typename P1> class MatcherT,
           typename P1,
           typename ReturnTypesF = void(AllNodeBaseTypes)>
 class PolymorphicMatcherWithParam1 {
 public:
   explicit PolymorphicMatcherWithParam1(const P1 &Param1)
       : Param1(Param1) {}
 
   typedef typename ExtractFunctionArgMeta<ReturnTypesF>::type ReturnTypes;
 
   template <typename T>
   operator Matcher<T>() const {
     static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
                   "right polymorphic conversion");
     return Matcher<T>(new MatcherT<T, P1>(Param1));
   }
 
 private:
   const P1 Param1;
 };
 
 template <template <typename T, typename P1, typename P2> class MatcherT,
           typename P1, typename P2,
           typename ReturnTypesF = void(AllNodeBaseTypes)>
 class PolymorphicMatcherWithParam2 {
 public:
   PolymorphicMatcherWithParam2(const P1 &Param1, const P2 &Param2)
       : Param1(Param1), Param2(Param2) {}
 
   typedef typename ExtractFunctionArgMeta<ReturnTypesF>::type ReturnTypes;
 
   template <typename T>
   operator Matcher<T>() const {
     static_assert(TypeListContainsSuperOf<ReturnTypes, T>::value,
                   "right polymorphic conversion");
     return Matcher<T>(new MatcherT<T, P1, P2>(Param1, Param2));
   }
 
 private:
   const P1 Param1;
   const P2 Param2;
 };
 
 /// \brief Matches any instance of the given NodeType.
 ///
 /// This is useful when a matcher syntactically requires a child matcher,
 /// but the context doesn't care. See for example: anything().
 class TrueMatcher {
  public:
   typedef AllNodeBaseTypes ReturnTypes;
 
   template <typename T>
   operator Matcher<T>() const {
     return DynTypedMatcher::trueMatcher(
                ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
         .template unconditionalConvertTo<T>();
   }
 };
 
 /// \brief A Matcher that allows binding the node it matches to an id.
 ///
 /// BindableMatcher provides a \a bind() method that allows binding the
 /// matched node to an id if the match was successful.
 template <typename T>
 class BindableMatcher : public Matcher<T> {
 public:
   explicit BindableMatcher(const Matcher<T> &M) : Matcher<T>(M) {}
   explicit BindableMatcher(MatcherInterface<T> *Implementation)
     : Matcher<T>(Implementation) {}
 
   /// \brief Returns a matcher that will bind the matched node on a match.
   ///
   /// The returned matcher is equivalent to this matcher, but will
   /// bind the matched node on a match.
   Matcher<T> bind(StringRef ID) const {
     return DynTypedMatcher(*this)
         .tryBind(ID)
         ->template unconditionalConvertTo<T>();
   }
 
   /// \brief Same as Matcher<T>'s conversion operator, but enables binding on
   /// the returned matcher.
   operator DynTypedMatcher() const {
     DynTypedMatcher Result = static_cast<const Matcher<T>&>(*this);
     Result.setAllowBind(true);
     return Result;
   }
 };
 
 /// \brief Matches nodes of type T that have child nodes of type ChildT for
 /// which a specified child matcher matches.
 ///
 /// ChildT must be an AST base type.
 template <typename T, typename ChildT>
 class HasMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<ChildT>::value,
                 "has only accepts base type matcher");
 
 public:
   explicit HasMatcher(const Matcher<ChildT> &ChildMatcher)
       : ChildMatcher(ChildMatcher) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     return Finder->matchesChildOf(
         Node, ChildMatcher, Builder,
         ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses,
         ASTMatchFinder::BK_First);
   }
 
  private:
   const Matcher<ChildT> ChildMatcher;
 };
 
 /// \brief Matches nodes of type T that have child nodes of type ChildT for
 /// which a specified child matcher matches. ChildT must be an AST base
 /// type.
 /// As opposed to the HasMatcher, the ForEachMatcher will produce a match
 /// for each child that matches.
 template <typename T, typename ChildT>
 class ForEachMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<ChildT>::value,
                 "for each only accepts base type matcher");
 
  public:
   explicit ForEachMatcher(const Matcher<ChildT> &ChildMatcher)
       : ChildMatcher(ChildMatcher) {}
 
   bool matches(const T& Node, ASTMatchFinder* Finder,
                BoundNodesTreeBuilder* Builder) const override {
     return Finder->matchesChildOf(
       Node, ChildMatcher, Builder,
       ASTMatchFinder::TK_IgnoreImplicitCastsAndParentheses,
       ASTMatchFinder::BK_All);
   }
 
 private:
   const Matcher<ChildT> ChildMatcher;
 };
 
 /// \brief VariadicOperatorMatcher related types.
 /// @{
 
 /// \brief "No argument" placeholder to use as template paratemers.
 struct VariadicOperatorNoArg {};
 
 /// \brief Polymorphic matcher object that uses a \c
-/// DynTypedMatcher::VariadicOperatorFunction operator.
+/// DynTypedMatcher::VariadicOperator operator.
 ///
 /// Input matchers can have any type (including other polymorphic matcher
 /// types), and the actual Matcher<T> is generated on demand with an implicit
 /// coversion operator.
 template <typename P1, typename P2 = VariadicOperatorNoArg,
           typename P3 = VariadicOperatorNoArg,
           typename P4 = VariadicOperatorNoArg,
           typename P5 = VariadicOperatorNoArg,
           typename P6 = VariadicOperatorNoArg,
           typename P7 = VariadicOperatorNoArg,
           typename P8 = VariadicOperatorNoArg,
           typename P9 = VariadicOperatorNoArg>
 class VariadicOperatorMatcher {
 public:
-  VariadicOperatorMatcher(DynTypedMatcher::VariadicOperatorFunction Func,
+  VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op,
                           const P1 &Param1,
                           const P2 &Param2 = VariadicOperatorNoArg(),
                           const P3 &Param3 = VariadicOperatorNoArg(),
                           const P4 &Param4 = VariadicOperatorNoArg(),
                           const P5 &Param5 = VariadicOperatorNoArg(),
                           const P6 &Param6 = VariadicOperatorNoArg(),
                           const P7 &Param7 = VariadicOperatorNoArg(),
                           const P8 &Param8 = VariadicOperatorNoArg(),
                           const P9 &Param9 = VariadicOperatorNoArg())
-      : Func(Func), Param1(Param1), Param2(Param2), Param3(Param3),
+      : Op(Op), Param1(Param1), Param2(Param2), Param3(Param3),
         Param4(Param4), Param5(Param5), Param6(Param6), Param7(Param7),
         Param8(Param8), Param9(Param9) {}
 
   template <typename T> operator Matcher<T>() const {
     std::vector<DynTypedMatcher> Matchers;
     addMatcher<T>(Param1, Matchers);
     addMatcher<T>(Param2, Matchers);
     addMatcher<T>(Param3, Matchers);
     addMatcher<T>(Param4, Matchers);
     addMatcher<T>(Param5, Matchers);
     addMatcher<T>(Param6, Matchers);
     addMatcher<T>(Param7, Matchers);
     addMatcher<T>(Param8, Matchers);
     addMatcher<T>(Param9, Matchers);
-    return DynTypedMatcher::constructVariadic(Func, std::move(Matchers))
+    return DynTypedMatcher::constructVariadic(Op, std::move(Matchers))
         .template unconditionalConvertTo<T>();
   }
 
 private:
   template <typename T>
   static void addMatcher(const Matcher<T> &M,
                          std::vector<DynTypedMatcher> &Matchers) {
     Matchers.push_back(M);
   }
 
   /// \brief Overload to ignore \c VariadicOperatorNoArg arguments.
   template <typename T>
   static void addMatcher(VariadicOperatorNoArg,
                          std::vector<DynTypedMatcher> &Matchers) {}
 
-  const DynTypedMatcher::VariadicOperatorFunction Func;
+  const DynTypedMatcher::VariadicOperator Op;
   const P1 Param1;
   const P2 Param2;
   const P3 Param3;
   const P4 Param4;
   const P5 Param5;
   const P6 Param6;
   const P7 Param7;
   const P8 Param8;
   const P9 Param9;
 };
 
 /// \brief Overloaded function object to generate VariadicOperatorMatcher
 ///   objects from arbitrary matchers.
 ///
 /// It supports 1-9 argument overloaded operator(). More can be added if needed.
 template <unsigned MinCount, unsigned MaxCount>
 struct VariadicOperatorMatcherFunc {
-  DynTypedMatcher::VariadicOperatorFunction Func;
+  DynTypedMatcher::VariadicOperator Op;
 
   template <unsigned Count, typename T>
   struct EnableIfValidArity
       : public std::enable_if<MinCount <= Count && Count <= MaxCount, T> {};
 
   template <typename M1>
   typename EnableIfValidArity<1, VariadicOperatorMatcher<M1> >::type
   operator()(const M1 &P1) const {
-    return VariadicOperatorMatcher<M1>(Func, P1);
+    return VariadicOperatorMatcher<M1>(Op, P1);
   }
   template <typename M1, typename M2>
   typename EnableIfValidArity<2, VariadicOperatorMatcher<M1, M2> >::type
   operator()(const M1 &P1, const M2 &P2) const {
-    return VariadicOperatorMatcher<M1, M2>(Func, P1, P2);
+    return VariadicOperatorMatcher<M1, M2>(Op, P1, P2);
   }
   template <typename M1, typename M2, typename M3>
   typename EnableIfValidArity<3, VariadicOperatorMatcher<M1, M2, M3> >::type
   operator()(const M1 &P1, const M2 &P2, const M3 &P3) const {
-    return VariadicOperatorMatcher<M1, M2, M3>(Func, P1, P2, P3);
+    return VariadicOperatorMatcher<M1, M2, M3>(Op, P1, P2, P3);
   }
   template <typename M1, typename M2, typename M3, typename M4>
   typename EnableIfValidArity<4, VariadicOperatorMatcher<M1, M2, M3, M4> >::type
   operator()(const M1 &P1, const M2 &P2, const M3 &P3, const M4 &P4) const {
-    return VariadicOperatorMatcher<M1, M2, M3, M4>(Func, P1, P2, P3, P4);
+    return VariadicOperatorMatcher<M1, M2, M3, M4>(Op, P1, P2, P3, P4);
   }
   template <typename M1, typename M2, typename M3, typename M4, typename M5>
   typename EnableIfValidArity<
       5, VariadicOperatorMatcher<M1, M2, M3, M4, M5> >::type
   operator()(const M1 &P1, const M2 &P2, const M3 &P3, const M4 &P4,
              const M5 &P5) const {
-    return VariadicOperatorMatcher<M1, M2, M3, M4, M5>(Func, P1, P2, P3, P4,
-                                                       P5);
+    return VariadicOperatorMatcher<M1, M2, M3, M4, M5>(Op, P1, P2, P3, P4, P5);
   }
   template <typename M1, typename M2, typename M3, typename M4, typename M5,
             typename M6>
   typename EnableIfValidArity<
       6, VariadicOperatorMatcher<M1, M2, M3, M4, M5, M6> >::type
   operator()(const M1 &P1, const M2 &P2, const M3 &P3, const M4 &P4,
              const M5 &P5, const M6 &P6) const {
     return VariadicOperatorMatcher<M1, M2, M3, M4, M5, M6>(
-        Func, P1, P2, P3, P4, P5, P6);
+        Op, P1, P2, P3, P4, P5, P6);
   }
   template <typename M1, typename M2, typename M3, typename M4, typename M5,
             typename M6, typename M7>
   typename EnableIfValidArity<
       7, VariadicOperatorMatcher<M1, M2, M3, M4, M5, M6, M7> >::type
   operator()(const M1 &P1, const M2 &P2, const M3 &P3, const M4 &P4,
              const M5 &P5, const M6 &P6, const M7 &P7) const {
     return VariadicOperatorMatcher<M1, M2, M3, M4, M5, M6, M7>(
-        Func, P1, P2, P3, P4, P5, P6, P7);
+        Op, P1, P2, P3, P4, P5, P6, P7);
   }
   template <typename M1, typename M2, typename M3, typename M4, typename M5,
             typename M6, typename M7, typename M8>
   typename EnableIfValidArity<
       8, VariadicOperatorMatcher<M1, M2, M3, M4, M5, M6, M7, M8> >::type
   operator()(const M1 &P1, const M2 &P2, const M3 &P3, const M4 &P4,
              const M5 &P5, const M6 &P6, const M7 &P7, const M8 &P8) const {
     return VariadicOperatorMatcher<M1, M2, M3, M4, M5, M6, M7, M8>(
-        Func, P1, P2, P3, P4, P5, P6, P7, P8);
+        Op, P1, P2, P3, P4, P5, P6, P7, P8);
   }
   template <typename M1, typename M2, typename M3, typename M4, typename M5,
             typename M6, typename M7, typename M8, typename M9>
   typename EnableIfValidArity<
       9, VariadicOperatorMatcher<M1, M2, M3, M4, M5, M6, M7, M8, M9> >::type
   operator()(const M1 &P1, const M2 &P2, const M3 &P3, const M4 &P4,
              const M5 &P5, const M6 &P6, const M7 &P7, const M8 &P8,
              const M9 &P9) const {
     return VariadicOperatorMatcher<M1, M2, M3, M4, M5, M6, M7, M8, M9>(
-        Func, P1, P2, P3, P4, P5, P6, P7, P8, P9);
+        Op, P1, P2, P3, P4, P5, P6, P7, P8, P9);
   }
 };
 
 /// @}
 
-/// \brief Matches nodes that do not match the provided matcher.
-///
-/// Uses the variadic matcher interface, but fails if InnerMatchers.size()!=1.
-bool NotUnaryOperator(const ast_type_traits::DynTypedNode DynNode,
-                      ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
-                      ArrayRef<DynTypedMatcher> InnerMatchers);
-
-/// \brief Matches nodes for which all provided matchers match.
-bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
-                           ASTMatchFinder *Finder,
-                           BoundNodesTreeBuilder *Builder,
-                           ArrayRef<DynTypedMatcher> InnerMatchers);
-
-/// \brief Matches nodes for which at least one of the provided matchers
-/// matches, but doesn't stop at the first match.
-bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
-                            ASTMatchFinder *Finder,
-                            BoundNodesTreeBuilder *Builder,
-                            ArrayRef<DynTypedMatcher> InnerMatchers);
-
-/// \brief Matches nodes for which at least one of the provided matchers
-/// matches.
-bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
-                           ASTMatchFinder *Finder,
-                           BoundNodesTreeBuilder *Builder,
-                           ArrayRef<DynTypedMatcher> InnerMatchers);
-
 template <typename T>
 inline Matcher<T> DynTypedMatcher::unconditionalConvertTo() const {
   return Matcher<T>(*this);
 }
 
 /// \brief Creates a Matcher<T> that matches if all inner matchers match.
 template<typename T>
 BindableMatcher<T> makeAllOfComposite(
     ArrayRef<const Matcher<T> *> InnerMatchers) {
   // For the size() == 0 case, we return a "true" matcher.
   if (InnerMatchers.size() == 0) {
     return BindableMatcher<T>(TrueMatcher());
   }
   // For the size() == 1 case, we simply return that one matcher.
   // No need to wrap it in a variadic operation.
   if (InnerMatchers.size() == 1) {
     return BindableMatcher<T>(*InnerMatchers[0]);
   }
 
   std::vector<DynTypedMatcher> DynMatchers;
   DynMatchers.reserve(InnerMatchers.size());
   for (const auto *InnerMatcher : InnerMatchers) {
     DynMatchers.push_back(*InnerMatcher);
   }
-  return BindableMatcher<T>(DynTypedMatcher::constructVariadic(
-                                AllOfVariadicOperator, std::move(DynMatchers))
-                                .template unconditionalConvertTo<T>());
+  return BindableMatcher<T>(
+      DynTypedMatcher::constructVariadic(DynTypedMatcher::VO_AllOf,
+                                         std::move(DynMatchers))
+          .template unconditionalConvertTo<T>());
 }
 
 /// \brief Creates a Matcher<T> that matches if
 /// T is dyn_cast'able into InnerT and all inner matchers match.
 ///
 /// Returns BindableMatcher, as matchers that use dyn_cast have
 /// the same object both to match on and to run submatchers on,
 /// so there is no ambiguity with what gets bound.
 template<typename T, typename InnerT>
 BindableMatcher<T> makeDynCastAllOfComposite(
     ArrayRef<const Matcher<InnerT> *> InnerMatchers) {
   return BindableMatcher<T>(
       makeAllOfComposite(InnerMatchers).template dynCastTo<T>());
 }
 
 /// \brief Matches nodes of type T that have at least one descendant node of
 /// type DescendantT for which the given inner matcher matches.
 ///
 /// DescendantT must be an AST base type.
 template <typename T, typename DescendantT>
 class HasDescendantMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<DescendantT>::value,
                 "has descendant only accepts base type matcher");
 
 public:
   explicit HasDescendantMatcher(const Matcher<DescendantT> &DescendantMatcher)
       : DescendantMatcher(DescendantMatcher) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     return Finder->matchesDescendantOf(
         Node, DescendantMatcher, Builder, ASTMatchFinder::BK_First);
   }
 
  private:
   const Matcher<DescendantT> DescendantMatcher;
 };
 
 /// \brief Matches nodes of type \c T that have a parent node of type \c ParentT
 /// for which the given inner matcher matches.
 ///
 /// \c ParentT must be an AST base type.
 template <typename T, typename ParentT>
 class HasParentMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<ParentT>::value,
                 "has parent only accepts base type matcher");
 
 public:
   explicit HasParentMatcher(const Matcher<ParentT> &ParentMatcher)
       : ParentMatcher(ParentMatcher) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     return Finder->matchesAncestorOf(
         Node, ParentMatcher, Builder, ASTMatchFinder::AMM_ParentOnly);
   }
 
  private:
   const Matcher<ParentT> ParentMatcher;
 };
 
 /// \brief Matches nodes of type \c T that have at least one ancestor node of
 /// type \c AncestorT for which the given inner matcher matches.
 ///
 /// \c AncestorT must be an AST base type.
 template <typename T, typename AncestorT>
 class HasAncestorMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<AncestorT>::value,
                 "has ancestor only accepts base type matcher");
 
 public:
   explicit HasAncestorMatcher(const Matcher<AncestorT> &AncestorMatcher)
       : AncestorMatcher(AncestorMatcher) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     return Finder->matchesAncestorOf(
         Node, AncestorMatcher, Builder, ASTMatchFinder::AMM_All);
   }
 
  private:
   const Matcher<AncestorT> AncestorMatcher;
 };
 
 /// \brief Matches nodes of type T that have at least one descendant node of
 /// type DescendantT for which the given inner matcher matches.
 ///
 /// DescendantT must be an AST base type.
 /// As opposed to HasDescendantMatcher, ForEachDescendantMatcher will match
 /// for each descendant node that matches instead of only for the first.
 template <typename T, typename DescendantT>
 class ForEachDescendantMatcher : public MatcherInterface<T> {
   static_assert(IsBaseType<DescendantT>::value,
                 "for each descendant only accepts base type matcher");
 
  public:
   explicit ForEachDescendantMatcher(
       const Matcher<DescendantT>& DescendantMatcher)
       : DescendantMatcher(DescendantMatcher) {}
 
   bool matches(const T& Node, ASTMatchFinder* Finder,
                BoundNodesTreeBuilder* Builder) const override {
     return Finder->matchesDescendantOf(Node, DescendantMatcher, Builder,
                                        ASTMatchFinder::BK_All);
   }
 
 private:
   const Matcher<DescendantT> DescendantMatcher;
 };
 
 /// \brief Matches on nodes that have a getValue() method if getValue() equals
 /// the value the ValueEqualsMatcher was constructed with.
 template <typename T, typename ValueT>
 class ValueEqualsMatcher : public SingleNodeMatcherInterface<T> {
   static_assert(std::is_base_of<CharacterLiteral, T>::value ||
                 std::is_base_of<CXXBoolLiteralExpr, T>::value ||
                 std::is_base_of<FloatingLiteral, T>::value ||
                 std::is_base_of<IntegerLiteral, T>::value,
                 "the node must have a getValue method");
 
 public:
   explicit ValueEqualsMatcher(const ValueT &ExpectedValue)
       : ExpectedValue(ExpectedValue) {}
 
   bool matchesNode(const T &Node) const override {
     return Node.getValue() == ExpectedValue;
   }
 
 private:
   const ValueT ExpectedValue;
 };
 
 /// \brief A VariadicDynCastAllOfMatcher<SourceT, TargetT> object is a
 /// variadic functor that takes a number of Matcher<TargetT> and returns a
 /// Matcher<SourceT> that matches TargetT nodes that are matched by all of the
 /// given matchers, if SourceT can be dynamically casted into TargetT.
 ///
 /// For example:
 ///   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:
   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> > {
 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 MatcherInterface<TLoc> {
 public:
   explicit LocMatcher(const Matcher<T> &InnerMatcher)
     : InnerMatcher(InnerMatcher) {}
 
   bool matches(const TLoc &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     if (!Node)
       return false;
     return InnerMatcher.matches(*extract(Node), Finder, Builder);
   }
 
 private:
   const NestedNameSpecifier *extract(const NestedNameSpecifierLoc &Loc) const {
     return Loc.getNestedNameSpecifier();
   }
 
   const Matcher<T> InnerMatcher;
 };
 
 /// \brief Matches \c TypeLocs based on an inner matcher matching a certain
 /// \c QualType.
 ///
 /// Used to implement the \c loc() matcher.
 class TypeLocTypeMatcher : public MatcherInterface<TypeLoc> {
 public:
   explicit TypeLocTypeMatcher(const Matcher<QualType> &InnerMatcher)
       : InnerMatcher(InnerMatcher) {}
 
   bool matches(const TypeLoc &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     if (!Node)
       return false;
     return InnerMatcher.matches(Node.getType(), Finder, Builder);
   }
 
 private:
   const Matcher<QualType> InnerMatcher;
 };
 
 /// \brief Matches nodes of type \c T for which the inner matcher matches on a
 /// another node of type \c T that can be reached using a given traverse
 /// function.
 template <typename T>
 class TypeTraverseMatcher : public MatcherInterface<T> {
 public:
   explicit TypeTraverseMatcher(const Matcher<QualType> &InnerMatcher,
                                QualType (T::*TraverseFunction)() const)
       : InnerMatcher(InnerMatcher), TraverseFunction(TraverseFunction) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     QualType NextNode = (Node.*TraverseFunction)();
     if (NextNode.isNull())
       return false;
     return InnerMatcher.matches(NextNode, Finder, Builder);
   }
 
 private:
   const Matcher<QualType> InnerMatcher;
   QualType (T::*TraverseFunction)() const;
 };
 
 /// \brief Matches nodes of type \c T in a ..Loc hierarchy, for which the inner
 /// matcher matches on a another node of type \c T that can be reached using a
 /// given traverse function.
 template <typename T>
 class TypeLocTraverseMatcher : public MatcherInterface<T> {
 public:
   explicit TypeLocTraverseMatcher(const Matcher<TypeLoc> &InnerMatcher,
                                   TypeLoc (T::*TraverseFunction)() const)
       : InnerMatcher(InnerMatcher), TraverseFunction(TraverseFunction) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     TypeLoc NextNode = (Node.*TraverseFunction)();
     if (!NextNode)
       return false;
     return InnerMatcher.matches(NextNode, Finder, Builder);
   }
 
 private:
   const Matcher<TypeLoc> InnerMatcher;
   TypeLoc (T::*TraverseFunction)() const;
 };
 
 /// \brief Converts a \c Matcher<InnerT> to a \c Matcher<OuterT>, where
 /// \c OuterT is any type that is supported by \c Getter.
 ///
 /// \code Getter<OuterT>::value() \endcode returns a
 /// \code InnerTBase (OuterT::*)() \endcode, which is used to adapt a \c OuterT
 /// object into a \c InnerT
 template <typename InnerTBase,
           template <typename OuterT> class Getter,
           template <typename OuterT> class MatcherImpl,
           typename ReturnTypesF>
 class TypeTraversePolymorphicMatcher {
 private:
   typedef TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl,
                                          ReturnTypesF> Self;
   static Self create(ArrayRef<const Matcher<InnerTBase> *> InnerMatchers);
 
 public:
   typedef typename ExtractFunctionArgMeta<ReturnTypesF>::type ReturnTypes;
 
   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> {
     Func() {}
   };
 
 private:
   const Matcher<InnerTBase> InnerMatcher;
 };
 
 // Define the create() method out of line to silence a GCC warning about
 // the struct "Func" having greater visibility than its base, which comes from
 // using the flag -fvisibility-inlines-hidden.
 template <typename InnerTBase, template <typename OuterT> class Getter,
           template <typename OuterT> class MatcherImpl, typename ReturnTypesF>
 TypeTraversePolymorphicMatcher<InnerTBase, Getter, MatcherImpl, ReturnTypesF>
 TypeTraversePolymorphicMatcher<
     InnerTBase, Getter, MatcherImpl,
     ReturnTypesF>::create(ArrayRef<const Matcher<InnerTBase> *> InnerMatchers) {
   return Self(InnerMatchers);
 }
 
 // FIXME: unify ClassTemplateSpecializationDecl and TemplateSpecializationType's
 // APIs for accessing the template argument list.
 inline ArrayRef<TemplateArgument>
 getTemplateSpecializationArgs(const ClassTemplateSpecializationDecl &D) {
   return D.getTemplateArgs().asArray();
 }
 
 inline ArrayRef<TemplateArgument>
 getTemplateSpecializationArgs(const TemplateSpecializationType &T) {
   return llvm::makeArrayRef(T.getArgs(), T.getNumArgs());
 }
 
 struct NotEqualsBoundNodePredicate {
   bool operator()(const internal::BoundNodesMap &Nodes) const {
     return Nodes.getNode(ID) != Node;
   }
   std::string ID;
   ast_type_traits::DynTypedNode Node;
 };
 
 } // end namespace internal
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif
diff --git a/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h b/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
index e4b5519dffe5..a9bd3d50115a 100644
--- a/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
+++ b/clang/include/clang/ASTMatchers/Dynamic/VariantValue.h
@@ -1,326 +1,326 @@
 //===--- VariantValue.h - Polymorphic value type -*- C++ -*-===/
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Polymorphic value type.
 ///
 /// Supports all the types required for dynamic Matcher construction.
 ///  Used by the registry to construct matchers in a generic way.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_ASTMATCHERS_DYNAMIC_VARIANTVALUE_H
 #define LLVM_CLANG_ASTMATCHERS_DYNAMIC_VARIANTVALUE_H
 
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "llvm/ADT/IntrusiveRefCntPtr.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/Twine.h"
 #include <memory>
 #include <vector>
 
 namespace clang {
 namespace ast_matchers {
 namespace dynamic {
 
 /// \brief Kind identifier.
 ///
 /// It supports all types that VariantValue can contain.
 class ArgKind {
  public:
   enum Kind {
     AK_Matcher,
     AK_Unsigned,
     AK_String
   };
   /// \brief Constructor for non-matcher types.
   ArgKind(Kind K) : K(K) { assert(K != AK_Matcher); }
 
   /// \brief Constructor for matcher types.
   ArgKind(ast_type_traits::ASTNodeKind MatcherKind)
       : K(AK_Matcher), MatcherKind(MatcherKind) {}
 
   Kind getArgKind() const { return K; }
   ast_type_traits::ASTNodeKind getMatcherKind() const {
     assert(K == AK_Matcher);
     return MatcherKind;
   }
 
   /// \brief Determines if this type can be converted to \p To.
   ///
   /// \param To the requested destination type.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   convertion.
   bool isConvertibleTo(ArgKind To, unsigned *Specificity) const;
 
   bool operator<(const ArgKind &Other) const {
     if (K == AK_Matcher && Other.K == AK_Matcher)
       return MatcherKind < Other.MatcherKind;
     return K < Other.K;
   }
 
   /// \brief String representation of the type.
   std::string asString() const;
 
 private:
   Kind K;
   ast_type_traits::ASTNodeKind MatcherKind;
 };
 
 using ast_matchers::internal::DynTypedMatcher;
 
 /// \brief A variant matcher object.
 ///
 /// The purpose of this object is to abstract simple and polymorphic matchers
 /// into a single object type.
 /// Polymorphic matchers might be implemented as a list of all the possible
 /// overloads of the matcher. \c VariantMatcher knows how to select the
 /// appropriate overload when needed.
 /// To get a real matcher object out of a \c VariantMatcher you can do:
 ///  - getSingleMatcher() which returns a matcher, only if it is not ambiguous
 ///    to decide which matcher to return. Eg. it contains only a single
 ///    matcher, or a polymorphic one with only one overload.
 ///  - hasTypedMatcher<T>()/getTypedMatcher<T>(): These calls will determine if
 ///    the underlying matcher(s) can unambiguously return a Matcher<T>.
 class VariantMatcher {
   /// \brief Methods that depend on T from hasTypedMatcher/getTypedMatcher.
   class MatcherOps {
   public:
     MatcherOps(ast_type_traits::ASTNodeKind NodeKind) : NodeKind(NodeKind) {}
 
     bool canConstructFrom(const DynTypedMatcher &Matcher,
                           bool &IsExactMatch) const;
 
     /// \brief Convert \p Matcher the destination type and return it as a new
     /// DynTypedMatcher.
     virtual DynTypedMatcher
     convertMatcher(const DynTypedMatcher &Matcher) const = 0;
 
     /// \brief Constructs a variadic typed matcher from \p InnerMatchers.
     /// Will try to convert each inner matcher to the destination type and
     /// return llvm::None if it fails to do so.
     llvm::Optional<DynTypedMatcher>
-    constructVariadicOperator(DynTypedMatcher::VariadicOperatorFunction Func,
+    constructVariadicOperator(DynTypedMatcher::VariadicOperator Op,
                               ArrayRef<VariantMatcher> InnerMatchers) const;
 
   protected:
     ~MatcherOps() {}
 
   private:
     ast_type_traits::ASTNodeKind NodeKind;
   };
 
   /// \brief Payload interface to be specialized by each matcher type.
   ///
   /// It follows a similar interface as VariantMatcher itself.
   class Payload : public RefCountedBaseVPTR {
   public:
     virtual ~Payload();
     virtual llvm::Optional<DynTypedMatcher> getSingleMatcher() const = 0;
     virtual std::string getTypeAsString() const = 0;
     virtual llvm::Optional<DynTypedMatcher>
     getTypedMatcher(const MatcherOps &Ops) const = 0;
     virtual bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
                                  unsigned *Specificity) const = 0;
   };
 
 public:
   /// \brief A null matcher.
   VariantMatcher();
 
   /// \brief Clones the provided matcher.
   static VariantMatcher SingleMatcher(const DynTypedMatcher &Matcher);
 
   /// \brief Clones the provided matchers.
   ///
   /// They should be the result of a polymorphic matcher.
   static VariantMatcher
   PolymorphicMatcher(std::vector<DynTypedMatcher> Matchers);
 
   /// \brief Creates a 'variadic' operator matcher.
   ///
   /// It will bind to the appropriate type on getTypedMatcher<T>().
   static VariantMatcher
-  VariadicOperatorMatcher(DynTypedMatcher::VariadicOperatorFunction Func,
+  VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op,
                           std::vector<VariantMatcher> Args);
 
   /// \brief Makes the matcher the "null" matcher.
   void reset();
 
   /// \brief Whether the matcher is null.
   bool isNull() const { return !Value; }
 
   /// \brief Return a single matcher, if there is no ambiguity.
   ///
   /// \returns the matcher, if there is only one matcher. An empty Optional, if
   /// the underlying matcher is a polymorphic matcher with more than one
   /// representation.
   llvm::Optional<DynTypedMatcher> getSingleMatcher() const;
 
   /// \brief Determines if the contained matcher can be converted to
   ///   \c Matcher<T>.
   ///
   /// For the Single case, it returns true if it can be converted to
   /// \c Matcher<T>.
   /// For the Polymorphic case, it returns true if one, and only one, of the
   /// overloads can be converted to \c Matcher<T>. If there are more than one
   /// that can, the result would be ambiguous and false is returned.
   template <class T>
   bool hasTypedMatcher() const {
     if (!Value) return false;
     return Value->getTypedMatcher(TypedMatcherOps<T>()).hasValue();
   }
 
   /// \brief Determines if the contained matcher can be converted to \p Kind.
   ///
   /// \param Kind the requested destination type.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   convertion.
   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
                        unsigned *Specificity) const {
     if (Value)
       return Value->isConvertibleTo(Kind, Specificity);
     return false;
   }
 
   /// \brief Return this matcher as a \c Matcher<T>.
   ///
   /// Handles the different types (Single, Polymorphic) accordingly.
   /// Asserts that \c hasTypedMatcher<T>() is true.
   template <class T>
   ast_matchers::internal::Matcher<T> getTypedMatcher() const {
     assert(hasTypedMatcher<T>() && "hasTypedMatcher<T>() == false");
     return Value->getTypedMatcher(TypedMatcherOps<T>())
         ->template convertTo<T>();
   }
 
   /// \brief String representation of the type of the value.
   ///
   /// If the underlying matcher is a polymorphic one, the string will show all
   /// the types.
   std::string getTypeAsString() const;
 
 private:
   explicit VariantMatcher(Payload *Value) : Value(Value) {}
 
   template <typename T> struct TypedMatcherOps;
 
   class SinglePayload;
   class PolymorphicPayload;
   class VariadicOpPayload;
 
   IntrusiveRefCntPtr<const Payload> Value;
 };
 
 template <typename T>
 struct VariantMatcher::TypedMatcherOps final : VariantMatcher::MatcherOps {
   TypedMatcherOps()
       : MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
   typedef ast_matchers::internal::Matcher<T> MatcherT;
 
   DynTypedMatcher
   convertMatcher(const DynTypedMatcher &Matcher) const override {
     return DynTypedMatcher(Matcher.convertTo<T>());
   }
 };
 
 /// \brief Variant value class.
 ///
 /// Basically, a tagged union with value type semantics.
 /// It is used by the registry as the return value and argument type for the
 /// matcher factory methods.
 /// It can be constructed from any of the supported types. It supports
 /// copy/assignment.
 ///
 /// Supported types:
 ///  - \c unsigned
 ///  - \c std::string
 ///  - \c VariantMatcher (\c DynTypedMatcher / \c Matcher<T>)
 class VariantValue {
 public:
   VariantValue() : Type(VT_Nothing) {}
 
   VariantValue(const VariantValue &Other);
   ~VariantValue();
   VariantValue &operator=(const VariantValue &Other);
 
   /// \brief Specific constructors for each supported type.
   VariantValue(unsigned Unsigned);
   VariantValue(const std::string &String);
   VariantValue(const VariantMatcher &Matchers);
 
   /// \brief Returns true iff this is not an empty value.
   LLVM_EXPLICIT operator bool() const { return hasValue(); }
   bool hasValue() const { return Type != VT_Nothing; }
 
   /// \brief Unsigned value functions.
   bool isUnsigned() const;
   unsigned getUnsigned() const;
   void setUnsigned(unsigned Unsigned);
 
   /// \brief String value functions.
   bool isString() const;
   const std::string &getString() const;
   void setString(const std::string &String);
 
   /// \brief Matcher value functions.
   bool isMatcher() const;
   const VariantMatcher &getMatcher() const;
   void setMatcher(const VariantMatcher &Matcher);
 
   /// \brief Determines if the contained value can be converted to \p Kind.
   ///
   /// \param Kind the requested destination type.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   convertion.
   bool isConvertibleTo(ArgKind Kind, unsigned* Specificity) const;
 
   /// \brief Determines if the contained value can be converted to any kind
   /// in \p Kinds.
   ///
   /// \param Kinds the requested destination types.
   ///
   /// \param Specificity value corresponding to the "specificity" of the
   ///   convertion. It is the maximum specificity of all the possible
   ///   conversions.
   bool isConvertibleTo(ArrayRef<ArgKind> Kinds, unsigned *Specificity) const;
 
   /// \brief String representation of the type of the value.
   std::string getTypeAsString() const;
 
 private:
   void reset();
 
   /// \brief All supported value types.
   enum ValueType {
     VT_Nothing,
     VT_Unsigned,
     VT_String,
     VT_Matcher
   };
 
   /// \brief All supported value types.
   union AllValues {
     unsigned Unsigned;
     std::string *String;
     VariantMatcher *Matcher;
   };
 
   ValueType Type;
   AllValues Value;
 };
 
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif  // LLVM_CLANG_AST_MATCHERS_DYNAMIC_VARIANT_VALUE_H
diff --git a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
index af6f0abfb9bb..c7d98b8a3a96 100644
--- a/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
+++ b/clang/lib/ASTMatchers/ASTMatchersInternal.cpp
@@ -1,270 +1,310 @@
 //===--- ASTMatchersInternal.cpp - Structural query framework -------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  Implements the base layer of the matcher framework.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/ASTMatchersInternal.h"
 #include "llvm/ADT/SmallString.h"
 #include "llvm/Support/ManagedStatic.h"
 
 namespace clang {
 namespace ast_matchers {
 namespace internal {
 
+bool NotUnaryOperator(const ast_type_traits::DynTypedNode DynNode,
+                      ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
+                      ArrayRef<DynTypedMatcher> InnerMatchers);
+
+bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
+                           ASTMatchFinder *Finder,
+                           BoundNodesTreeBuilder *Builder,
+                           ArrayRef<DynTypedMatcher> InnerMatchers);
+
+bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
+                            ASTMatchFinder *Finder,
+                            BoundNodesTreeBuilder *Builder,
+                            ArrayRef<DynTypedMatcher> InnerMatchers);
+
+bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
+                           ASTMatchFinder *Finder,
+                           BoundNodesTreeBuilder *Builder,
+                           ArrayRef<DynTypedMatcher> InnerMatchers);
+
+
 void BoundNodesTreeBuilder::visitMatches(Visitor *ResultVisitor) {
   if (Bindings.empty())
     Bindings.push_back(BoundNodesMap());
   for (BoundNodesMap &Binding : Bindings) {
     ResultVisitor->visitMatch(BoundNodes(Binding));
   }
 }
 
 namespace {
 
 class VariadicMatcher : public DynMatcherInterface {
- public:
-  VariadicMatcher(DynTypedMatcher::VariadicOperatorFunction Func,
+public:
+  typedef bool (*VariadicOperatorFunction)(
+      const ast_type_traits::DynTypedNode DynNode, ASTMatchFinder *Finder,
+      BoundNodesTreeBuilder *Builder, ArrayRef<DynTypedMatcher> InnerMatchers);
+
+  VariadicMatcher(VariadicOperatorFunction Func,
                   std::vector<DynTypedMatcher> InnerMatchers)
       : Func(Func), InnerMatchers(std::move(InnerMatchers)) {}
 
   bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
                   ASTMatchFinder *Finder,
                   BoundNodesTreeBuilder *Builder) const override {
     return Func(DynNode, Finder, Builder, InnerMatchers);
   }
 
- private:
-  DynTypedMatcher::VariadicOperatorFunction Func;
+private:
+  VariadicOperatorFunction Func;
   std::vector<DynTypedMatcher> InnerMatchers;
 };
 
 class IdDynMatcher : public DynMatcherInterface {
  public:
   IdDynMatcher(StringRef ID,
                const IntrusiveRefCntPtr<DynMatcherInterface> &InnerMatcher)
       : ID(ID), InnerMatcher(InnerMatcher) {}
 
   bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
                   ASTMatchFinder *Finder,
                   BoundNodesTreeBuilder *Builder) const override {
     bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder);
     if (Result) Builder->setBinding(ID, DynNode);
     return Result;
   }
 
  private:
   const std::string ID;
   const IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher;
 };
 
 /// \brief A matcher that always returns true.
 ///
 /// We only ever need one instance of this matcher, so we create a global one
 /// and reuse it to reduce the overhead of the matcher and increase the chance
 /// of cache hits.
 class TrueMatcherImpl : public DynMatcherInterface {
 public:
   TrueMatcherImpl() {
     Retain(); // Reference count will never become zero.
   }
   bool dynMatches(const ast_type_traits::DynTypedNode &, ASTMatchFinder *,
                   BoundNodesTreeBuilder *) const override {
     return true;
   }
 };
 static llvm::ManagedStatic<TrueMatcherImpl> TrueMatcherInstance;
 
 }  // namespace
 
 DynTypedMatcher DynTypedMatcher::constructVariadic(
-    DynTypedMatcher::VariadicOperatorFunction Func,
+    DynTypedMatcher::VariadicOperator Op,
     std::vector<DynTypedMatcher> InnerMatchers) {
   assert(InnerMatchers.size() > 0 && "Array must not be empty.");
   assert(std::all_of(InnerMatchers.begin(), InnerMatchers.end(),
                      [&InnerMatchers](const DynTypedMatcher &M) {
            return InnerMatchers[0].SupportedKind.isSame(M.SupportedKind);
          }) &&
          "SupportedKind must match!");
 
   // We must relax the restrict kind here.
   // The different operators might deal differently with a mismatch.
   // Make it the same as SupportedKind, since that is the broadest type we are
   // allowed to accept.
   auto SupportedKind = InnerMatchers[0].SupportedKind;
+  VariadicMatcher::VariadicOperatorFunction Func;
+  switch (Op) {
+  case VO_AllOf:
+    Func = AllOfVariadicOperator;
+    break;
+  case VO_AnyOf:
+    Func = AnyOfVariadicOperator;
+    break;
+  case VO_EachOf:
+    Func = EachOfVariadicOperator;
+    break;
+  case VO_UnaryNot:
+    Func = NotUnaryOperator;
+    break;
+  }
+
   return DynTypedMatcher(SupportedKind, SupportedKind,
                          new VariadicMatcher(Func, std::move(InnerMatchers)));
 }
 
 DynTypedMatcher DynTypedMatcher::trueMatcher(
     ast_type_traits::ASTNodeKind NodeKind) {
   return DynTypedMatcher(NodeKind, NodeKind, &*TrueMatcherInstance);
 }
 
 DynTypedMatcher DynTypedMatcher::dynCastTo(
     const ast_type_traits::ASTNodeKind Kind) const {
   auto Copy = *this;
   Copy.SupportedKind = Kind;
   Copy.RestrictKind =
       ast_type_traits::ASTNodeKind::getMostDerivedType(Kind, RestrictKind);
   return Copy;
 }
 
 bool DynTypedMatcher::matches(const ast_type_traits::DynTypedNode &DynNode,
                               ASTMatchFinder *Finder,
                               BoundNodesTreeBuilder *Builder) const {
   if (RestrictKind.isBaseOf(DynNode.getNodeKind()) &&
       Implementation->dynMatches(DynNode, Finder, Builder)) {
     return true;
   }
   // Delete all bindings when a matcher does not match.
   // This prevents unexpected exposure of bound nodes in unmatches
   // branches of the match tree.
   Builder->removeBindings([](const BoundNodesMap &) { return true; });
   return false;
 }
 
 llvm::Optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
   if (!AllowBind) return llvm::None;
   auto Result = *this;
   Result.Implementation = new IdDynMatcher(ID, Result.Implementation);
   return Result;
 }
 
 bool DynTypedMatcher::canConvertTo(ast_type_traits::ASTNodeKind To) const {
   const auto From = getSupportedKind();
   auto QualKind = ast_type_traits::ASTNodeKind::getFromNodeKind<QualType>();
   auto TypeKind = ast_type_traits::ASTNodeKind::getFromNodeKind<Type>();
   /// Mimic the implicit conversions of Matcher<>.
   /// - From Matcher<Type> to Matcher<QualType>
   if (From.isSame(TypeKind) && To.isSame(QualKind)) return true;
   /// - From Matcher<Base> to Matcher<Derived>
   return From.isBaseOf(To);
 }
 
 void BoundNodesTreeBuilder::addMatch(const BoundNodesTreeBuilder &Other) {
   Bindings.append(Other.Bindings.begin(), Other.Bindings.end());
 }
 
 bool NotUnaryOperator(const ast_type_traits::DynTypedNode DynNode,
                       ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
                       ArrayRef<DynTypedMatcher> InnerMatchers) {
   if (InnerMatchers.size() != 1)
     return false;
 
   // The 'unless' matcher will always discard the result:
   // If the inner matcher doesn't match, unless returns true,
   // but the inner matcher cannot have bound anything.
   // If the inner matcher matches, the result is false, and
   // any possible binding will be discarded.
   // We still need to hand in all the bound nodes up to this
   // point so the inner matcher can depend on bound nodes,
   // and we need to actively discard the bound nodes, otherwise
   // the inner matcher will reset the bound nodes if it doesn't
   // match, but this would be inversed by 'unless'.
   BoundNodesTreeBuilder Discard(*Builder);
   return !InnerMatchers[0].matches(DynNode, Finder, &Discard);
 }
 
 bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
                            ASTMatchFinder *Finder,
                            BoundNodesTreeBuilder *Builder,
                            ArrayRef<DynTypedMatcher> InnerMatchers) {
   // allOf leads to one matcher for each alternative in the first
   // matcher combined with each alternative in the second matcher.
   // Thus, we can reuse the same Builder.
   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
     if (!InnerMatcher.matches(DynNode, Finder, Builder))
       return false;
   }
   return true;
 }
 
 bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
                             ASTMatchFinder *Finder,
                             BoundNodesTreeBuilder *Builder,
                             ArrayRef<DynTypedMatcher> InnerMatchers) {
   BoundNodesTreeBuilder Result;
   bool Matched = false;
   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
     BoundNodesTreeBuilder BuilderInner(*Builder);
     if (InnerMatcher.matches(DynNode, Finder, &BuilderInner)) {
       Matched = true;
       Result.addMatch(BuilderInner);
     }
   }
   *Builder = std::move(Result);
   return Matched;
 }
 
 bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode DynNode,
                            ASTMatchFinder *Finder,
                            BoundNodesTreeBuilder *Builder,
                            ArrayRef<DynTypedMatcher> InnerMatchers) {
   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
     BoundNodesTreeBuilder Result = *Builder;
     if (InnerMatcher.matches(DynNode, Finder, &Result)) {
       *Builder = std::move(Result);
       return true;
     }
   }
   return false;
 }
 
 HasNameMatcher::HasNameMatcher(StringRef NameRef)
     : UseUnqualifiedMatch(NameRef.find("::") == NameRef.npos), Name(NameRef) {
   assert(!Name.empty());
 }
 
 bool HasNameMatcher::matchesNodeUnqualified(const NamedDecl &Node) const {
   assert(UseUnqualifiedMatch);
   if (Node.getIdentifier()) {
     // Simple name.
     return Name == Node.getName();
   }
   if (Node.getDeclName()) {
     // Name needs to be constructed.
     llvm::SmallString<128> NodeName;
     llvm::raw_svector_ostream OS(NodeName);
     Node.printName(OS);
     return Name == OS.str();
   }
   return false;
 }
 
 bool HasNameMatcher::matchesNodeFull(const NamedDecl &Node) const {
   llvm::SmallString<128> NodeName = StringRef("::");
   llvm::raw_svector_ostream OS(NodeName);
   Node.printQualifiedName(OS);
   const StringRef FullName = OS.str();
   const StringRef Pattern = Name;
 
   if (Pattern.startswith("::"))
     return FullName == Pattern;
 
   return FullName.endswith(Pattern) &&
          FullName.drop_back(Pattern.size()).endswith("::");
 }
 
 bool HasNameMatcher::matchesNode(const NamedDecl &Node) const {
   // FIXME: There is still room for improvement, but it would require copying a
   // lot of the logic from NamedDecl::printQualifiedName(). The benchmarks do
   // not show like that extra complexity is needed right now.
   if (UseUnqualifiedMatch) {
     assert(matchesNodeUnqualified(Node) == matchesNodeFull(Node));
     return matchesNodeUnqualified(Node);
   }
   return matchesNodeFull(Node);
 }
 
 } // end namespace internal
 } // end namespace ast_matchers
 } // end namespace clang
diff --git a/clang/lib/ASTMatchers/Dynamic/Marshallers.h b/clang/lib/ASTMatchers/Dynamic/Marshallers.h
index 42c880e80efc..b78bc0381990 100644
--- a/clang/lib/ASTMatchers/Dynamic/Marshallers.h
+++ b/clang/lib/ASTMatchers/Dynamic/Marshallers.h
@@ -1,711 +1,711 @@
 //===--- Marshallers.h - Generic matcher function marshallers -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Functions templates and classes to wrap matcher construct functions.
 ///
 /// A collection of template function and classes that provide a generic
 /// marshalling layer on top of matcher construct functions.
 /// These are used by the registry to export all marshaller constructors with
 /// the same generic interface.
 ///
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
 #define LLVM_CLANG_LIB_ASTMATCHERS_DYNAMIC_MARSHALLERS_H
 
 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/ASTMatchers/Dynamic/Diagnostics.h"
 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 #include <string>
 
 namespace clang {
 namespace ast_matchers {
 namespace dynamic {
 namespace internal {
 
 
 /// \brief Helper template class to just from argument type to the right is/get
 ///   functions in VariantValue.
 /// Used to verify and extract the matcher arguments below.
 template <class T> struct ArgTypeTraits;
 template <class T> struct ArgTypeTraits<const T &> : public ArgTypeTraits<T> {
 };
 
 template <> struct ArgTypeTraits<std::string> {
   static bool is(const VariantValue &Value) { return Value.isString(); }
   static const std::string &get(const VariantValue &Value) {
     return Value.getString();
   }
   static ArgKind getKind() {
     return ArgKind(ArgKind::AK_String);
   }
 };
 
 template <>
 struct ArgTypeTraits<StringRef> : public ArgTypeTraits<std::string> {
 };
 
 template <class T> struct ArgTypeTraits<ast_matchers::internal::Matcher<T> > {
   static bool is(const VariantValue &Value) {
     return Value.isMatcher() && Value.getMatcher().hasTypedMatcher<T>();
   }
   static ast_matchers::internal::Matcher<T> get(const VariantValue &Value) {
     return Value.getMatcher().getTypedMatcher<T>();
   }
   static ArgKind getKind() {
     return ArgKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
   }
 };
 
 template <> struct ArgTypeTraits<unsigned> {
   static bool is(const VariantValue &Value) { return Value.isUnsigned(); }
   static unsigned get(const VariantValue &Value) {
     return Value.getUnsigned();
   }
   static ArgKind getKind() {
     return ArgKind(ArgKind::AK_Unsigned);
   }
 };
 
 template <> struct ArgTypeTraits<attr::Kind> {
 private:
   static attr::Kind getAttrKind(llvm::StringRef AttrKind) {
     return llvm::StringSwitch<attr::Kind>(AttrKind)
 #define ATTR(X) .Case("attr::" #X, attr:: X)
 #include "clang/Basic/AttrList.inc"
         .Default(attr::Kind(-1));
   }
 public:
   static bool is(const VariantValue &Value) {
     return Value.isString() &&
         getAttrKind(Value.getString()) != attr::Kind(-1);
   }
   static attr::Kind get(const VariantValue &Value) {
     return getAttrKind(Value.getString());
   }
   static ArgKind getKind() {
     return ArgKind(ArgKind::AK_String);
   }
 };
 
 /// \brief Matcher descriptor interface.
 ///
 /// Provides a \c create() method that constructs the matcher from the provided
 /// arguments, and various other methods for type introspection.
 class MatcherDescriptor {
 public:
   virtual ~MatcherDescriptor() {}
   virtual VariantMatcher create(const SourceRange &NameRange,
                                 ArrayRef<ParserValue> Args,
                                 Diagnostics *Error) const = 0;
 
   /// Returns whether the matcher is variadic. Variadic matchers can take any
   /// number of arguments, but they must be of the same type.
   virtual bool isVariadic() const = 0;
 
   /// Returns the number of arguments accepted by the matcher if not variadic.
   virtual unsigned getNumArgs() const = 0;
 
   /// Given that the matcher is being converted to type \p ThisKind, append the
   /// set of argument types accepted for argument \p ArgNo to \p ArgKinds.
   // FIXME: We should provide the ability to constrain the output of this
   // function based on the types of other matcher arguments.
   virtual void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
                            std::vector<ArgKind> &ArgKinds) const = 0;
 
   /// Returns whether this matcher is convertible to the given type.  If it is
   /// so convertible, store in *Specificity a value corresponding to the
   /// "specificity" of the converted matcher to the given context, and in
   /// *LeastDerivedKind the least derived matcher kind which would result in the
   /// same matcher overload.  Zero specificity indicates that this conversion
   /// would produce a trivial matcher that will either always or never match.
   /// Such matchers are excluded from code completion results.
   virtual bool isConvertibleTo(
       ast_type_traits::ASTNodeKind Kind, unsigned *Specificity = nullptr,
       ast_type_traits::ASTNodeKind *LeastDerivedKind = nullptr) const = 0;
 
   /// Returns whether the matcher will, given a matcher of any type T, yield a
   /// matcher of type T.
   virtual bool isPolymorphic() const { return false; }
 };
 
 inline bool isRetKindConvertibleTo(
     ArrayRef<ast_type_traits::ASTNodeKind> RetKinds,
     ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
     ast_type_traits::ASTNodeKind *LeastDerivedKind) {
   for (const ast_type_traits::ASTNodeKind &NodeKind : RetKinds) {
     if (ArgKind(NodeKind).isConvertibleTo(Kind, Specificity)) {
       if (LeastDerivedKind)
         *LeastDerivedKind = NodeKind;
       return true;
     }
   }
   return false;
 }
 
 /// \brief Simple callback implementation. Marshaller and function are provided.
 ///
 /// This class wraps a function of arbitrary signature and a marshaller
 /// function into a MatcherDescriptor.
 /// The marshaller is in charge of taking the VariantValue arguments, checking
 /// their types, unpacking them and calling the underlying function.
 class FixedArgCountMatcherDescriptor : public MatcherDescriptor {
 public:
   typedef VariantMatcher (*MarshallerType)(void (*Func)(),
                                            StringRef MatcherName,
                                            const SourceRange &NameRange,
                                            ArrayRef<ParserValue> Args,
                                            Diagnostics *Error);
 
   /// \param Marshaller Function to unpack the arguments and call \c Func
   /// \param Func Matcher construct function. This is the function that
   ///   compile-time matcher expressions would use to create the matcher.
   /// \param RetKinds The list of matcher types to which the matcher is
   ///   convertible.
   /// \param ArgKinds The types of the arguments this matcher takes.
   FixedArgCountMatcherDescriptor(
       MarshallerType Marshaller, void (*Func)(), StringRef MatcherName,
       ArrayRef<ast_type_traits::ASTNodeKind> RetKinds,
       ArrayRef<ArgKind> ArgKinds)
       : Marshaller(Marshaller), Func(Func), MatcherName(MatcherName),
         RetKinds(RetKinds.begin(), RetKinds.end()),
         ArgKinds(ArgKinds.begin(), ArgKinds.end()) {}
 
   VariantMatcher create(const SourceRange &NameRange,
                         ArrayRef<ParserValue> Args, Diagnostics *Error) const {
     return Marshaller(Func, MatcherName, NameRange, Args, Error);
   }
 
   bool isVariadic() const { return false; }
   unsigned getNumArgs() const { return ArgKinds.size(); }
   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
                    std::vector<ArgKind> &Kinds) const {
     Kinds.push_back(ArgKinds[ArgNo]);
   }
   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
                        ast_type_traits::ASTNodeKind *LeastDerivedKind) const {
     return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
                                   LeastDerivedKind);
   }
 
 private:
   const MarshallerType Marshaller;
   void (* const Func)();
   const std::string MatcherName;
   const std::vector<ast_type_traits::ASTNodeKind> RetKinds;
   const std::vector<ArgKind> ArgKinds;
 };
 
 /// \brief Helper methods to extract and merge all possible typed matchers
 /// out of the polymorphic object.
 template <class PolyMatcher>
 static void mergePolyMatchers(const PolyMatcher &Poly,
                               std::vector<DynTypedMatcher> &Out,
                               ast_matchers::internal::EmptyTypeList) {}
 
 template <class PolyMatcher, class TypeList>
 static void mergePolyMatchers(const PolyMatcher &Poly,
                               std::vector<DynTypedMatcher> &Out, TypeList) {
   Out.push_back(ast_matchers::internal::Matcher<typename TypeList::head>(Poly));
   mergePolyMatchers(Poly, Out, typename TypeList::tail());
 }
 
 /// \brief Convert the return values of the functions into a VariantMatcher.
 ///
 /// There are 2 cases right now: The return value is a Matcher<T> or is a
 /// polymorphic matcher. For the former, we just construct the VariantMatcher.
 /// For the latter, we instantiate all the possible Matcher<T> of the poly
 /// matcher.
 static VariantMatcher outvalueToVariantMatcher(const DynTypedMatcher &Matcher) {
   return VariantMatcher::SingleMatcher(Matcher);
 }
 
 template <typename T>
 static VariantMatcher outvalueToVariantMatcher(const T &PolyMatcher,
                                                typename T::ReturnTypes * =
                                                    NULL) {
   std::vector<DynTypedMatcher> Matchers;
   mergePolyMatchers(PolyMatcher, Matchers, typename T::ReturnTypes());
   VariantMatcher Out = VariantMatcher::PolymorphicMatcher(std::move(Matchers));
   return Out;
 }
 
 template <typename T>
 inline void buildReturnTypeVectorFromTypeList(
     std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
   RetTypes.push_back(
       ast_type_traits::ASTNodeKind::getFromNodeKind<typename T::head>());
   buildReturnTypeVectorFromTypeList<typename T::tail>(RetTypes);
 }
 
 template <>
 inline void
 buildReturnTypeVectorFromTypeList<ast_matchers::internal::EmptyTypeList>(
     std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {}
 
 template <typename T>
 struct BuildReturnTypeVector {
   static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
     buildReturnTypeVectorFromTypeList<typename T::ReturnTypes>(RetTypes);
   }
 };
 
 template <typename T>
 struct BuildReturnTypeVector<ast_matchers::internal::Matcher<T> > {
   static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
     RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
   }
 };
 
 template <typename T>
 struct BuildReturnTypeVector<ast_matchers::internal::BindableMatcher<T> > {
   static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
     RetTypes.push_back(ast_type_traits::ASTNodeKind::getFromNodeKind<T>());
   }
 };
 
 /// \brief Variadic marshaller function.
 template <typename ResultT, typename ArgT,
           ResultT (*Func)(ArrayRef<const ArgT *>)>
 VariantMatcher
 variadicMatcherDescriptor(StringRef MatcherName, const SourceRange &NameRange,
                           ArrayRef<ParserValue> Args, Diagnostics *Error) {
   ArgT **InnerArgs = new ArgT *[Args.size()]();
 
   bool HasError = false;
   for (size_t i = 0, e = Args.size(); i != e; ++i) {
     typedef ArgTypeTraits<ArgT> ArgTraits;
     const ParserValue &Arg = Args[i];
     const VariantValue &Value = Arg.Value;
     if (!ArgTraits::is(Value)) {
       Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
           << (i + 1) << ArgTraits::getKind().asString() << Value.getTypeAsString();
       HasError = true;
       break;
     }
     InnerArgs[i] = new ArgT(ArgTraits::get(Value));
   }
 
   VariantMatcher Out;
   if (!HasError) {
     Out = outvalueToVariantMatcher(Func(llvm::makeArrayRef(InnerArgs,
                                                            Args.size())));
   }
 
   for (size_t i = 0, e = Args.size(); i != e; ++i) {
     delete InnerArgs[i];
   }
   delete[] InnerArgs;
   return Out;
 }
 
 /// \brief Matcher descriptor for variadic functions.
 ///
 /// This class simply wraps a VariadicFunction with the right signature to export
 /// it as a MatcherDescriptor.
 /// This allows us to have one implementation of the interface for as many free
 /// functions as we want, reducing the number of symbols and size of the
 /// object file.
 class VariadicFuncMatcherDescriptor : public MatcherDescriptor {
 public:
   typedef VariantMatcher (*RunFunc)(StringRef MatcherName,
                                     const 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)
       : Func(&variadicMatcherDescriptor<ResultT, ArgT, F>),
         MatcherName(MatcherName.str()),
         ArgsKind(ArgTypeTraits<ArgT>::getKind()) {
     BuildReturnTypeVector<ResultT>::build(RetKinds);
   }
 
   VariantMatcher create(const SourceRange &NameRange,
                         ArrayRef<ParserValue> Args, Diagnostics *Error) const {
     return Func(MatcherName, NameRange, Args, Error);
   }
 
   bool isVariadic() const { return true; }
   unsigned getNumArgs() const { return 0; }
   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
                    std::vector<ArgKind> &Kinds) const {
     Kinds.push_back(ArgsKind);
   }
   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
                        ast_type_traits::ASTNodeKind *LeastDerivedKind) const {
     return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
                                   LeastDerivedKind);
   }
 
 private:
   const RunFunc Func;
   const std::string MatcherName;
   std::vector<ast_type_traits::ASTNodeKind> RetKinds;
   const ArgKind ArgsKind;
 };
 
 /// \brief Return CK_Trivial when appropriate for VariadicDynCastAllOfMatchers.
 class DynCastAllOfMatcherDescriptor : public VariadicFuncMatcherDescriptor {
 public:
   template <typename BaseT, typename DerivedT>
   DynCastAllOfMatcherDescriptor(
       ast_matchers::internal::VariadicDynCastAllOfMatcher<BaseT, DerivedT> Func,
       StringRef MatcherName)
       : VariadicFuncMatcherDescriptor(Func, MatcherName),
         DerivedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<DerivedT>()) {
   }
 
   bool
   isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
                 ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
     // If Kind is not a base of DerivedKind, either DerivedKind is a base of
     // Kind (in which case the match will always succeed) or Kind and
     // DerivedKind are unrelated (in which case it will always fail), so set
     // Specificity to 0.
     if (VariadicFuncMatcherDescriptor::isConvertibleTo(Kind, Specificity,
                                                  LeastDerivedKind)) {
       if (Kind.isSame(DerivedKind) || !Kind.isBaseOf(DerivedKind)) {
         if (Specificity)
           *Specificity = 0;
       }
       return true;
     } else {
       return false;
     }
   }
 
 private:
   const ast_type_traits::ASTNodeKind DerivedKind;
 };
 
 /// \brief Helper macros to check the arguments on all marshaller functions.
 #define CHECK_ARG_COUNT(count)                                                 \
   if (Args.size() != count) {                                                  \
     Error->addError(NameRange, Error->ET_RegistryWrongArgCount)                \
         << count << Args.size();                                               \
     return VariantMatcher();                                                   \
   }
 
 #define CHECK_ARG_TYPE(index, type)                                            \
   if (!ArgTypeTraits<type>::is(Args[index].Value)) {                           \
     Error->addError(Args[index].Range, Error->ET_RegistryWrongArgType)         \
         << (index + 1) << ArgTypeTraits<type>::getKind().asString()            \
         << Args[index].Value.getTypeAsString();                                \
     return VariantMatcher();                                                   \
   }
 
 
 /// \brief 0-arg marshaller function.
 template <typename ReturnType>
 static VariantMatcher matcherMarshall0(void (*Func)(), StringRef MatcherName,
                                        const SourceRange &NameRange,
                                        ArrayRef<ParserValue> Args,
                                        Diagnostics *Error) {
   typedef ReturnType (*FuncType)();
   CHECK_ARG_COUNT(0);
   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)());
 }
 
 /// \brief 1-arg marshaller function.
 template <typename ReturnType, typename ArgType1>
 static VariantMatcher matcherMarshall1(void (*Func)(), StringRef MatcherName,
                                        const SourceRange &NameRange,
                                        ArrayRef<ParserValue> Args,
                                        Diagnostics *Error) {
   typedef ReturnType (*FuncType)(ArgType1);
   CHECK_ARG_COUNT(1);
   CHECK_ARG_TYPE(0, ArgType1);
   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)(
       ArgTypeTraits<ArgType1>::get(Args[0].Value)));
 }
 
 /// \brief 2-arg marshaller function.
 template <typename ReturnType, typename ArgType1, typename ArgType2>
 static VariantMatcher matcherMarshall2(void (*Func)(), StringRef MatcherName,
                                        const SourceRange &NameRange,
                                        ArrayRef<ParserValue> Args,
                                        Diagnostics *Error) {
   typedef ReturnType (*FuncType)(ArgType1, ArgType2);
   CHECK_ARG_COUNT(2);
   CHECK_ARG_TYPE(0, ArgType1);
   CHECK_ARG_TYPE(1, ArgType2);
   return outvalueToVariantMatcher(reinterpret_cast<FuncType>(Func)(
       ArgTypeTraits<ArgType1>::get(Args[0].Value),
       ArgTypeTraits<ArgType2>::get(Args[1].Value)));
 }
 
 #undef CHECK_ARG_COUNT
 #undef CHECK_ARG_TYPE
 
 /// \brief Helper class used to collect all the possible overloads of an
 ///   argument adaptative matcher function.
 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
           typename FromTypes, typename ToTypes>
 class AdaptativeOverloadCollector {
 public:
   AdaptativeOverloadCollector(StringRef Name,
                               std::vector<MatcherDescriptor *> &Out)
       : Name(Name), Out(Out) {
     collect(FromTypes());
   }
 
 private:
   typedef ast_matchers::internal::ArgumentAdaptingMatcherFunc<
       ArgumentAdapterT, FromTypes, ToTypes> AdaptativeFunc;
 
   /// \brief End case for the recursion
   static void collect(ast_matchers::internal::EmptyTypeList) {}
 
   /// \brief Recursive case. Get the overload for the head of the list, and
   ///   recurse to the tail.
   template <typename FromTypeList>
   inline void collect(FromTypeList);
 
   StringRef Name;
   std::vector<MatcherDescriptor *> &Out;
 };
 
 /// \brief MatcherDescriptor that wraps multiple "overloads" of the same
 ///   matcher.
 ///
 /// It will try every overload and generate appropriate errors for when none or
 /// more than one overloads match the arguments.
 class OverloadedMatcherDescriptor : public MatcherDescriptor {
 public:
   OverloadedMatcherDescriptor(ArrayRef<MatcherDescriptor *> Callbacks)
       : Overloads(Callbacks.begin(), Callbacks.end()) {}
 
   virtual ~OverloadedMatcherDescriptor() {}
 
   virtual VariantMatcher create(const SourceRange &NameRange,
                                 ArrayRef<ParserValue> Args,
                                 Diagnostics *Error) const {
     std::vector<VariantMatcher> Constructed;
     Diagnostics::OverloadContext Ctx(Error);
     for (const auto &O : Overloads) {
       VariantMatcher SubMatcher = O->create(NameRange, Args, Error);
       if (!SubMatcher.isNull()) {
         Constructed.push_back(SubMatcher);
       }
     }
 
     if (Constructed.empty()) return VariantMatcher(); // No overload matched.
     // We ignore the errors if any matcher succeeded.
     Ctx.revertErrors();
     if (Constructed.size() > 1) {
       // More than one constructed. It is ambiguous.
       Error->addError(NameRange, Error->ET_RegistryAmbiguousOverload);
       return VariantMatcher();
     }
     return Constructed[0];
   }
 
   bool isVariadic() const {
     bool Overload0Variadic = Overloads[0]->isVariadic();
 #ifndef NDEBUG
     for (const auto &O : Overloads) {
       assert(Overload0Variadic == O->isVariadic());
     }
 #endif
     return Overload0Variadic;
   }
 
   unsigned getNumArgs() const {
     unsigned Overload0NumArgs = Overloads[0]->getNumArgs();
 #ifndef NDEBUG
     for (const auto &O : Overloads) {
       assert(Overload0NumArgs == O->getNumArgs());
     }
 #endif
     return Overload0NumArgs;
   }
 
   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
                    std::vector<ArgKind> &Kinds) const {
     for (const auto &O : Overloads) {
       if (O->isConvertibleTo(ThisKind))
         O->getArgKinds(ThisKind, ArgNo, Kinds);
     }
   }
 
   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
                        ast_type_traits::ASTNodeKind *LeastDerivedKind) const {
     for (const auto &O : Overloads) {
       if (O->isConvertibleTo(Kind, Specificity, LeastDerivedKind))
         return true;
     }
     return false;
   }
 
 private:
   std::vector<std::unique_ptr<MatcherDescriptor>> Overloads;
 };
 
 /// \brief Variadic operator marshaller function.
 class VariadicOperatorMatcherDescriptor : public MatcherDescriptor {
 public:
-  typedef DynTypedMatcher::VariadicOperatorFunction VarFunc;
+  typedef DynTypedMatcher::VariadicOperator VarOp;
   VariadicOperatorMatcherDescriptor(unsigned MinCount, unsigned MaxCount,
-                                    VarFunc Func, StringRef MatcherName)
-      : MinCount(MinCount), MaxCount(MaxCount), Func(Func),
+                                    VarOp Op, StringRef MatcherName)
+      : MinCount(MinCount), MaxCount(MaxCount), Op(Op),
         MatcherName(MatcherName) {}
 
   virtual VariantMatcher create(const SourceRange &NameRange,
                                 ArrayRef<ParserValue> Args,
                                 Diagnostics *Error) const override {
     if (Args.size() < MinCount || MaxCount < Args.size()) {
       const std::string MaxStr =
           (MaxCount == UINT_MAX ? "" : Twine(MaxCount)).str();
       Error->addError(NameRange, Error->ET_RegistryWrongArgCount)
           << ("(" + Twine(MinCount) + ", " + MaxStr + ")") << Args.size();
       return VariantMatcher();
     }
 
     std::vector<VariantMatcher> InnerArgs;
     for (size_t i = 0, e = Args.size(); i != e; ++i) {
       const ParserValue &Arg = Args[i];
       const VariantValue &Value = Arg.Value;
       if (!Value.isMatcher()) {
         Error->addError(Arg.Range, Error->ET_RegistryWrongArgType)
             << (i + 1) << "Matcher<>" << Value.getTypeAsString();
         return VariantMatcher();
       }
       InnerArgs.push_back(Value.getMatcher());
     }
-    return VariantMatcher::VariadicOperatorMatcher(Func, std::move(InnerArgs));
+    return VariantMatcher::VariadicOperatorMatcher(Op, std::move(InnerArgs));
   }
 
   bool isVariadic() const override { return true; }
   unsigned getNumArgs() const override { return 0; }
   void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
                    std::vector<ArgKind> &Kinds) const override {
     Kinds.push_back(ThisKind);
   }
   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
                        ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
     if (Specificity)
       *Specificity = 1;
     if (LeastDerivedKind)
       *LeastDerivedKind = Kind;
     return true;
   }
   bool isPolymorphic() const override { return true; }
 
 private:
   const unsigned MinCount;
   const unsigned MaxCount;
-  const VarFunc Func;
+  const VarOp Op;
   const StringRef MatcherName;
 };
 
 /// Helper functions to select the appropriate marshaller functions.
 /// They detect the number of arguments, arguments types and return type.
 
 /// \brief 0-arg overload
 template <typename ReturnType>
 MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(),
                                      StringRef MatcherName) {
   std::vector<ast_type_traits::ASTNodeKind> RetTypes;
   BuildReturnTypeVector<ReturnType>::build(RetTypes);
   return new FixedArgCountMatcherDescriptor(
       matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
       MatcherName, RetTypes, None);
 }
 
 /// \brief 1-arg overload
 template <typename ReturnType, typename ArgType1>
 MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1),
                                      StringRef MatcherName) {
   std::vector<ast_type_traits::ASTNodeKind> RetTypes;
   BuildReturnTypeVector<ReturnType>::build(RetTypes);
   ArgKind AK = ArgTypeTraits<ArgType1>::getKind();
   return new FixedArgCountMatcherDescriptor(
       matcherMarshall1<ReturnType, ArgType1>,
       reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AK);
 }
 
 /// \brief 2-arg overload
 template <typename ReturnType, typename ArgType1, typename ArgType2>
 MatcherDescriptor *makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2),
                                      StringRef MatcherName) {
   std::vector<ast_type_traits::ASTNodeKind> RetTypes;
   BuildReturnTypeVector<ReturnType>::build(RetTypes);
   ArgKind AKs[] = { ArgTypeTraits<ArgType1>::getKind(),
                     ArgTypeTraits<ArgType2>::getKind() };
   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) {
   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>
 MatcherDescriptor *
 makeMatcherAutoMarshall(ast_matchers::internal::VariadicDynCastAllOfMatcher<
                             BaseT, DerivedT> VarFunc,
                         StringRef MatcherName) {
   return new DynCastAllOfMatcherDescriptor(VarFunc, MatcherName);
 }
 
 /// \brief Argument adaptative overload.
 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
           typename FromTypes, typename ToTypes>
 MatcherDescriptor *
 makeMatcherAutoMarshall(ast_matchers::internal::ArgumentAdaptingMatcherFunc<
                             ArgumentAdapterT, FromTypes, ToTypes>,
                         StringRef MatcherName) {
   std::vector<MatcherDescriptor *> Overloads;
   AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes, ToTypes>(MatcherName,
                                                                     Overloads);
   return new OverloadedMatcherDescriptor(Overloads);
 }
 
 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
           typename FromTypes, typename ToTypes>
 template <typename FromTypeList>
 inline void AdaptativeOverloadCollector<ArgumentAdapterT, FromTypes,
                                         ToTypes>::collect(FromTypeList) {
   Out.push_back(makeMatcherAutoMarshall(
       &AdaptativeFunc::template create<typename FromTypeList::head>, Name));
   collect(typename FromTypeList::tail());
 }
 
 /// \brief Variadic operator overload.
 template <unsigned MinCount, unsigned MaxCount>
 MatcherDescriptor *
 makeMatcherAutoMarshall(ast_matchers::internal::VariadicOperatorMatcherFunc<
                             MinCount, MaxCount> Func,
                         StringRef MatcherName) {
-  return new VariadicOperatorMatcherDescriptor(MinCount, MaxCount, Func.Func,
+  return new VariadicOperatorMatcherDescriptor(MinCount, MaxCount, Func.Op,
                                                MatcherName);
 }
 
 }  // namespace internal
 }  // namespace dynamic
 }  // namespace ast_matchers
 }  // namespace clang
 
 #endif  // LLVM_CLANG_AST_MATCHERS_DYNAMIC_MARSHALLERS_H
diff --git a/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp b/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
index 08b3b1d3f31a..a88b70701234 100644
--- a/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
+++ b/clang/lib/ASTMatchers/Dynamic/VariantValue.cpp
@@ -1,392 +1,392 @@
 //===--- VariantValue.cpp - Polymorphic value type -*- C++ -*-===/
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
 /// \brief Polymorphic value type.
 ///
 //===----------------------------------------------------------------------===//
 
 #include "clang/ASTMatchers/Dynamic/VariantValue.h"
 #include "clang/Basic/LLVM.h"
 #include "llvm/ADT/STLExtras.h"
 
 namespace clang {
 namespace ast_matchers {
 namespace dynamic {
 
 std::string ArgKind::asString() const {
   switch (getArgKind()) {
   case AK_Matcher:
     return (Twine("Matcher<") + MatcherKind.asStringRef() + ">").str();
   case AK_Unsigned:
     return "unsigned";
   case AK_String:
     return "string";
   }
   llvm_unreachable("unhandled ArgKind");
 }
 
 bool ArgKind::isConvertibleTo(ArgKind To, unsigned *Specificity) const {
   if (K != To.K)
     return false;
   if (K != AK_Matcher) {
     if (Specificity)
       *Specificity = 1;
     return true;
   }
   unsigned Distance;
   if (!MatcherKind.isBaseOf(To.MatcherKind, &Distance))
     return false;
 
   if (Specificity)
     *Specificity = 100 - Distance;
   return true;
 }
 
 bool
 VariantMatcher::MatcherOps::canConstructFrom(const DynTypedMatcher &Matcher,
                                              bool &IsExactMatch) const {
   IsExactMatch = Matcher.getSupportedKind().isSame(NodeKind);
   return Matcher.canConvertTo(NodeKind);
 }
 
 llvm::Optional<DynTypedMatcher>
 VariantMatcher::MatcherOps::constructVariadicOperator(
-    DynTypedMatcher::VariadicOperatorFunction Func,
+    DynTypedMatcher::VariadicOperator Op,
     ArrayRef<VariantMatcher> InnerMatchers) const {
   std::vector<DynTypedMatcher> DynMatchers;
   for (const auto &InnerMatcher : InnerMatchers) {
     // Abort if any of the inner matchers can't be converted to
     // Matcher<T>.
     if (!InnerMatcher.Value)
       return llvm::None;
     llvm::Optional<DynTypedMatcher> Inner =
         InnerMatcher.Value->getTypedMatcher(*this);
     if (!Inner)
       return llvm::None;
     DynMatchers.push_back(*Inner);
   }
-  return DynTypedMatcher::constructVariadic(Func, DynMatchers);
+  return DynTypedMatcher::constructVariadic(Op, DynMatchers);
 }
 
 VariantMatcher::Payload::~Payload() {}
 
 class VariantMatcher::SinglePayload : public VariantMatcher::Payload {
 public:
   SinglePayload(const DynTypedMatcher &Matcher) : Matcher(Matcher) {}
 
   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
     return Matcher;
   }
 
   std::string getTypeAsString() const override {
     return (Twine("Matcher<") + Matcher.getSupportedKind().asStringRef() + ">")
         .str();
   }
 
   llvm::Optional<DynTypedMatcher>
   getTypedMatcher(const MatcherOps &Ops) const override {
     bool Ignore;
     if (Ops.canConstructFrom(Matcher, Ignore))
       return Matcher;
     return llvm::None;
   }
 
   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
                        unsigned *Specificity) const override {
     return ArgKind(Matcher.getSupportedKind())
         .isConvertibleTo(Kind, Specificity);
   }
 
 private:
   const DynTypedMatcher Matcher;
 };
 
 class VariantMatcher::PolymorphicPayload : public VariantMatcher::Payload {
 public:
   PolymorphicPayload(std::vector<DynTypedMatcher> MatchersIn)
       : Matchers(std::move(MatchersIn)) {}
 
   ~PolymorphicPayload() override {}
 
   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
     if (Matchers.size() != 1)
       return llvm::Optional<DynTypedMatcher>();
     return Matchers[0];
   }
 
   std::string getTypeAsString() const override {
     std::string Inner;
     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
       if (i != 0)
         Inner += "|";
       Inner += Matchers[i].getSupportedKind().asStringRef();
     }
     return (Twine("Matcher<") + Inner + ">").str();
   }
 
   llvm::Optional<DynTypedMatcher>
   getTypedMatcher(const MatcherOps &Ops) const override {
     bool FoundIsExact = false;
     const DynTypedMatcher *Found = nullptr;
     int NumFound = 0;
     for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
       bool IsExactMatch;
       if (Ops.canConstructFrom(Matchers[i], IsExactMatch)) {
         if (Found) {
           if (FoundIsExact) {
             assert(!IsExactMatch && "We should not have two exact matches.");
             continue;
           }
         }
         Found = &Matchers[i];
         FoundIsExact = IsExactMatch;
         ++NumFound;
       }
     }
     // We only succeed if we found exactly one, or if we found an exact match.
     if (Found && (FoundIsExact || NumFound == 1))
       return *Found;
     return llvm::None;
   }
 
   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
                        unsigned *Specificity) const override {
     unsigned MaxSpecificity = 0;
     for (const DynTypedMatcher &Matcher : Matchers) {
       unsigned ThisSpecificity;
       if (ArgKind(Matcher.getSupportedKind())
               .isConvertibleTo(Kind, &ThisSpecificity)) {
         MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);
       }
     }
     if (Specificity)
       *Specificity = MaxSpecificity;
     return MaxSpecificity > 0;
   }
 
   const std::vector<DynTypedMatcher> Matchers;
 };
 
 class VariantMatcher::VariadicOpPayload : public VariantMatcher::Payload {
 public:
-  VariadicOpPayload(DynTypedMatcher::VariadicOperatorFunction Func,
+  VariadicOpPayload(DynTypedMatcher::VariadicOperator Op,
                     std::vector<VariantMatcher> Args)
-      : Func(Func), Args(std::move(Args)) {}
+      : Op(Op), Args(std::move(Args)) {}
 
   llvm::Optional<DynTypedMatcher> getSingleMatcher() const override {
     return llvm::Optional<DynTypedMatcher>();
   }
 
   std::string getTypeAsString() const override {
     std::string Inner;
     for (size_t i = 0, e = Args.size(); i != e; ++i) {
       if (i != 0)
         Inner += "&";
       Inner += Args[i].getTypeAsString();
     }
     return Inner;
   }
 
   llvm::Optional<DynTypedMatcher>
   getTypedMatcher(const MatcherOps &Ops) const override {
-    return Ops.constructVariadicOperator(Func, Args);
+    return Ops.constructVariadicOperator(Op, Args);
   }
 
   bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
                        unsigned *Specificity) const override {
     for (const VariantMatcher &Matcher : Args) {
       if (!Matcher.isConvertibleTo(Kind, Specificity))
         return false;
     }
     return true;
   }
 
 private:
-  const DynTypedMatcher::VariadicOperatorFunction Func;
+  const DynTypedMatcher::VariadicOperator Op;
   const std::vector<VariantMatcher> Args;
 };
 
 VariantMatcher::VariantMatcher() {}
 
 VariantMatcher VariantMatcher::SingleMatcher(const DynTypedMatcher &Matcher) {
   return VariantMatcher(new SinglePayload(Matcher));
 }
 
 VariantMatcher
 VariantMatcher::PolymorphicMatcher(std::vector<DynTypedMatcher> Matchers) {
   return VariantMatcher(new PolymorphicPayload(std::move(Matchers)));
 }
 
 VariantMatcher VariantMatcher::VariadicOperatorMatcher(
-    DynTypedMatcher::VariadicOperatorFunction Func,
+    DynTypedMatcher::VariadicOperator Op,
     std::vector<VariantMatcher> Args) {
-  return VariantMatcher(new VariadicOpPayload(Func, std::move(Args)));
+  return VariantMatcher(new VariadicOpPayload(Op, std::move(Args)));
 }
 
 llvm::Optional<DynTypedMatcher> VariantMatcher::getSingleMatcher() const {
   return Value ? Value->getSingleMatcher() : llvm::Optional<DynTypedMatcher>();
 }
 
 void VariantMatcher::reset() { Value.reset(); }
 
 std::string VariantMatcher::getTypeAsString() const {
   if (Value) return Value->getTypeAsString();
   return "<Nothing>";
 }
 
 VariantValue::VariantValue(const VariantValue &Other) : Type(VT_Nothing) {
   *this = Other;
 }
 
 VariantValue::VariantValue(unsigned Unsigned) : Type(VT_Nothing) {
   setUnsigned(Unsigned);
 }
 
 VariantValue::VariantValue(const std::string &String) : Type(VT_Nothing) {
   setString(String);
 }
 
 VariantValue::VariantValue(const VariantMatcher &Matcher) : Type(VT_Nothing) {
   setMatcher(Matcher);
 }
 
 VariantValue::~VariantValue() { reset(); }
 
 VariantValue &VariantValue::operator=(const VariantValue &Other) {
   if (this == &Other) return *this;
   reset();
   switch (Other.Type) {
   case VT_Unsigned:
     setUnsigned(Other.getUnsigned());
     break;
   case VT_String:
     setString(Other.getString());
     break;
   case VT_Matcher:
     setMatcher(Other.getMatcher());
     break;
   case VT_Nothing:
     Type = VT_Nothing;
     break;
   }
   return *this;
 }
 
 void VariantValue::reset() {
   switch (Type) {
   case VT_String:
     delete Value.String;
     break;
   case VT_Matcher:
     delete Value.Matcher;
     break;
   // Cases that do nothing.
   case VT_Unsigned:
   case VT_Nothing:
     break;
   }
   Type = VT_Nothing;
 }
 
 bool VariantValue::isUnsigned() const {
   return Type == VT_Unsigned;
 }
 
 unsigned VariantValue::getUnsigned() const {
   assert(isUnsigned());
   return Value.Unsigned;
 }
 
 void VariantValue::setUnsigned(unsigned NewValue) {
   reset();
   Type = VT_Unsigned;
   Value.Unsigned = NewValue;
 }
 
 bool VariantValue::isString() const {
   return Type == VT_String;
 }
 
 const std::string &VariantValue::getString() const {
   assert(isString());
   return *Value.String;
 }
 
 void VariantValue::setString(const std::string &NewValue) {
   reset();
   Type = VT_String;
   Value.String = new std::string(NewValue);
 }
 
 bool VariantValue::isMatcher() const {
   return Type == VT_Matcher;
 }
 
 const VariantMatcher &VariantValue::getMatcher() const {
   assert(isMatcher());
   return *Value.Matcher;
 }
 
 void VariantValue::setMatcher(const VariantMatcher &NewValue) {
   reset();
   Type = VT_Matcher;
   Value.Matcher = new VariantMatcher(NewValue);
 }
 
 bool VariantValue::isConvertibleTo(ArgKind Kind, unsigned *Specificity) const {
   switch (Kind.getArgKind()) {
   case ArgKind::AK_Unsigned:
     if (!isUnsigned())
       return false;
     *Specificity = 1;
     return true;
 
   case ArgKind::AK_String:
     if (!isString())
       return false;
     *Specificity = 1;
     return true;
 
   case ArgKind::AK_Matcher:
     if (!isMatcher())
       return false;
     return getMatcher().isConvertibleTo(Kind.getMatcherKind(), Specificity);
   }
   llvm_unreachable("Invalid Type");
 }
 
 bool VariantValue::isConvertibleTo(ArrayRef<ArgKind> Kinds,
                                    unsigned *Specificity) const {
   unsigned MaxSpecificity = 0;
   for (const ArgKind& Kind : Kinds) {
     unsigned ThisSpecificity;
     if (!isConvertibleTo(Kind, &ThisSpecificity))
       continue;
     MaxSpecificity = std::max(MaxSpecificity, ThisSpecificity);
   }
   if (Specificity && MaxSpecificity > 0) {
     *Specificity = MaxSpecificity;
   }
   return MaxSpecificity > 0;
 }
 
 std::string VariantValue::getTypeAsString() const {
   switch (Type) {
   case VT_String: return "String";
   case VT_Matcher: return getMatcher().getTypeAsString();
   case VT_Unsigned: return "Unsigned";
   case VT_Nothing: return "Nothing";
   }
   llvm_unreachable("Invalid Type");
 }
 
 } // end namespace dynamic
 } // end namespace ast_matchers
 } // end namespace clang