Remove clang::ast_type_traits namespace in favor of clang

[rnk]

Summary

DynTypedNode and ASTNodeKind are implemented as part of the clang AST
library, which uses the main clang namespace. There doesn't seem to be a
need for this extra level of namespacing.

I left behind aliases in the ast_type_traits namespace for out of tree
clients of these APIs. To provide aliases for the enumerators, I used
this pattern:

namespace ast_type_traits {
constexpr TraversalKind TK_AsIs = ::clang::TK_AsIs;
}

I think the typedefs will be useful for migration, but we might be able
to drop these enumerator aliases. Reviewers, let me know what you think.

[aaron.ballman]

LGTM!

clang/docs/LibASTMatchersReference.html

The matcher:
   cxxRecordDecl(hasName("::A"),
                 findAll(cxxRecordDecl(isDefinition()).bind("m")))
 will generate results for A, B and C.
 
 Usable as: Any Matcher
 </pre></td></tr>
 
 
-<tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('traverse1')"><a name="traverse1Anchor">traverse</a></td><td>ast_type_traits::TraversalKind TK, const BindableMatcher&lt;T&gt;  InnerMatcher</td></tr>
+<tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('traverse1')"><a name="traverse1Anchor">traverse</a></td><td>TraversalKind TK, const BindableMatcher&lt;T&gt;  InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="traverse1"><pre></pre></td></tr>
 
 
-<tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('traverse0')"><a name="traverse0Anchor">traverse</a></td><td>ast_type_traits::TraversalKind TK, const Matcher&lt;T&gt;  InnerMatcher</td></tr>
+<tr><td>Matcher&lt;T&gt;</td><td class="name" onclick="toggle('traverse0')"><a name="traverse0Anchor">traverse</a></td><td>TraversalKind TK, const Matcher&lt;T&gt;  InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="traverse0"><pre>Causes all nested matchers to be matched with the specified traversal kind.
 
 Given
   void foo()
   {
       int i = 3.0;
   }
 The matcher
-  traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
+  traverse(TK_IgnoreImplicitCastsAndParentheses,
     varDecl(hasInitializer(floatLiteral().bind("init")))
   )
 matches the variable declaration with "init" bound to the "3.0".
 </pre></td></tr>
 
 
 <tr><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1TypedefNameDecl.html">TypedefNameDecl</a>&gt;</td><td class="name" onclick="toggle('hasType2')"><a name="hasType2Anchor">hasType</a></td><td>Matcher&lt;<a href="https://clang.llvm.org/doxygen/classclang_1_1QualType.html">QualType</a>&gt; InnerMatcher</td></tr>
 <tr><td colspan="4" class="doc" id="hasType2"><pre>Matches if the expression's or declaration's type matches a type

clang/include/clang/AST/ASTContext.h

 class CharUnits;
 class ConceptDecl;
 class CXXABI;
 class CXXConstructorDecl;
 class CXXMethodDecl;
 class CXXRecordDecl;
 class DiagnosticsEngine;
 class ParentMapContext;
+class DynTypedNode;
 class DynTypedNodeList;
 class Expr;
 class FixedPointSemantics;
 class GlobalDecl;
 class MangleContext;
 class MangleNumberingContext;
 class MaterializeTemporaryExpr;
 class MemberSpecializationInfo;

 class TemplateTemplateParmDecl;
 class TemplateTypeParmDecl;
 class UnresolvedSetIterator;
 class UsingShadowDecl;
 class VarTemplateDecl;
 class VTableContextBase;
 struct BlockVarCopyInit;
 
-namespace ast_type_traits {
-class DynTypedNode;
-}
 
 namespace Builtin {
 
 class Context;
 
 } // namespace Builtin
 
 enum BuiltinTemplateKind : int;

clang/include/clang/AST/ASTNodeTraverser.h

: public ConstDeclVisitor<Derived>,
       public TypeVisitor<Derived>,
       public ConstAttrVisitor<Derived>,
       public ConstTemplateArgumentVisitor<Derived> {
 
   /// Indicates whether we should trigger deserialization of nodes that had
   /// not already been loaded.
   bool Deserialize = false;
 
-  ast_type_traits::TraversalKind Traversal =
-      ast_type_traits::TraversalKind::TK_AsIs;
+  TraversalKind Traversal = TraversalKind::TK_AsIs;
 
   NodeDelegateType &getNodeDelegate() {
     return getDerived().doGetNodeDelegate();
   }
   Derived &getDerived() { return *static_cast<Derived *>(this); }
 
 public:
   void setDeserialize(bool D) { Deserialize = D; }
   bool getDeserialize() const { return Deserialize; }
 
-  void SetTraversalKind(ast_type_traits::TraversalKind TK) { Traversal = TK; }
+  void SetTraversalKind(TraversalKind TK) { Traversal = TK; }
 
   void Visit(const Decl *D) {
     getNodeDelegate().AddChild([=] {
       getNodeDelegate().Visit(D);
       if (!D)
         return;
 
       ConstDeclVisitor<Derived>::Visit(D);
public:
   }
 
   void Visit(const Stmt *Node, StringRef Label = {}) {
     getNodeDelegate().AddChild(Label, [=] {
       const Stmt *S = Node;
 
       if (auto *E = dyn_cast_or_null<Expr>(S)) {
         switch (Traversal) {
-        case ast_type_traits::TK_AsIs:
+        case TK_AsIs:
           break;
-        case ast_type_traits::TK_IgnoreImplicitCastsAndParentheses:
+        case TK_IgnoreImplicitCastsAndParentheses:
           S = E->IgnoreParenImpCasts();
           break;
-        case ast_type_traits::TK_IgnoreUnlessSpelledInSource:
+        case TK_IgnoreUnlessSpelledInSource:
           S = E->IgnoreUnlessSpelledInSource();
           break;
         }
       }
 
       getNodeDelegate().Visit(S);
 
       if (!S) {
         return;
       }
 
       ConstStmtVisitor<Derived>::Visit(S);
 
       // Some statements have custom mechanisms for dumping their children.
       if (isa<DeclStmt>(S) || isa<GenericSelectionExpr>(S))
         return;
 
-      if (isa<LambdaExpr>(S) &&
-          Traversal == ast_type_traits::TK_IgnoreUnlessSpelledInSource)
+      if (isa<LambdaExpr>(S) && Traversal == TK_IgnoreUnlessSpelledInSource)
         return;
 
       for (const Stmt *SubStmt : S->children())
         Visit(SubStmt);
     });
   }
 
   void Visit(QualType T) {
getNodeDelegate().AddChild([=] {
                                                                           FC);
       for (comments::Comment::child_iterator I = C->child_begin(),
                                              E = C->child_end();
            I != E; ++I)
         Visit(*I, FC);
     });
   }
 
-  void Visit(const ast_type_traits::DynTypedNode &N) {
+  void Visit(const DynTypedNode &N) {
     // FIXME: Improve this with a switch or a visitor pattern.
     if (const auto *D = N.get<Decl>())
       Visit(D);
     else if (const auto *S = N.get<Stmt>())
       Visit(S);
     else if (const auto *QT = N.get<QualType>())
       Visit(*QT);
     else if (const auto *T = N.get<Type>())
void VisitGenericSelectionExpr(const GenericSelectionExpr *E) {
     Visit(E->getControllingExpr()->getType()); // FIXME: remove
 
     for (const auto Assoc : E->associations()) {
       Visit(Assoc);
     }
   }
 
   void VisitLambdaExpr(const LambdaExpr *Node) {
-    if (Traversal == ast_type_traits::TK_IgnoreUnlessSpelledInSource) {
+    if (Traversal == TK_IgnoreUnlessSpelledInSource) {
       for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
         const auto *C = Node->capture_begin() + I;
         if (!C->isExplicit())
           continue;
         if (Node->isInitCapture(C))
           Visit(C->getCapturedVar());
         else
           Visit(Node->capture_init_begin()[I]);

clang/include/clang/AST/ASTTypeTraits.h

 class raw_ostream;
 
 }
 
 namespace clang {
 
 struct PrintingPolicy;
 
-namespace ast_type_traits {
-
 /// Defines how we descend a level in the AST when we pass
 /// through expressions.
 enum TraversalKind {
   /// Will traverse all child nodes.
   TK_AsIs,
 
   /// Will not traverse implicit casts and parentheses.
   /// Corresponds to Expr::IgnoreParenImpCasts()

 // AST node that is not supported, but prevents misuse - a user cannot create
 // a DynTypedNode from arbitrary types.
 template <typename T, typename EnablerT> struct DynTypedNode::BaseConverter {
   static const T *get(ASTNodeKind NodeKind, const char Storage[]) {
     return NULL;
   }
 };
 
-} // end namespace ast_type_traits
+// Previously these types were defined in the clang::ast_type_traits namespace.
+// Provide typedefs so that legacy code can be fixed asynchronously.
+namespace ast_type_traits {
+using DynTypedNode = ::clang::DynTypedNode;
+using ASTNodeKind = ::clang::ASTNodeKind;
+using TraversalKind = ::clang::TraversalKind;
+
+constexpr TraversalKind TK_AsIs = ::clang::TK_AsIs;
+constexpr TraversalKind TK_IgnoreImplicitCastsAndParentheses =
+    ::clang::TK_IgnoreImplicitCastsAndParentheses;
+constexpr TraversalKind TK_IgnoreUnlessSpelledInSource =
+    ::clang::TK_IgnoreUnlessSpelledInSource;
+} // namespace ast_type_traits
+
 } // end namespace clang
 
 namespace llvm {
 
 template <>
-struct DenseMapInfo<clang::ast_type_traits::ASTNodeKind>
-    : clang::ast_type_traits::ASTNodeKind::DenseMapInfo {};
+struct DenseMapInfo<clang::ASTNodeKind> : clang::ASTNodeKind::DenseMapInfo {};
 
 template <>
-struct DenseMapInfo<clang::ast_type_traits::DynTypedNode>
-    : clang::ast_type_traits::DynTypedNode::DenseMapInfo {};
+struct DenseMapInfo<clang::DynTypedNode> : clang::DynTypedNode::DenseMapInfo {};
 
 }  // end namespace llvm
 
 #endif

clang/include/clang/AST/ParentMapContext.h

public:
   /// Additionally, we will want to add an interface to already give a hint
   /// where to search for the parents, for example when looking at a statement
   /// inside a certain function.
   ///
   /// 'NodeT' can be one of Decl, Stmt, Type, TypeLoc,
   /// NestedNameSpecifier or NestedNameSpecifierLoc.
   template <typename NodeT> DynTypedNodeList getParents(const NodeT &Node);
 
-  DynTypedNodeList getParents(const ast_type_traits::DynTypedNode &Node);
+  DynTypedNodeList getParents(const DynTypedNode &Node);
 
   /// Clear parent maps.
   void clear();
 
-  ast_type_traits::TraversalKind getTraversalKind() const { return Traversal; }
-  void setTraversalKind(ast_type_traits::TraversalKind TK) { Traversal = TK; }
+  TraversalKind getTraversalKind() const { return Traversal; }
+  void setTraversalKind(TraversalKind TK) { Traversal = TK; }
 
   const Expr *traverseIgnored(const Expr *E) const;
   Expr *traverseIgnored(Expr *E) const;
-  ast_type_traits::DynTypedNode
-  traverseIgnored(const ast_type_traits::DynTypedNode &N) const;
+  DynTypedNode traverseIgnored(const DynTypedNode &N) const;
 
 private:
   ASTContext &ASTCtx;
   class ParentMap;
-  ast_type_traits::TraversalKind Traversal = ast_type_traits::TK_AsIs;
+  TraversalKind Traversal = TK_AsIs;
   std::unique_ptr<ParentMap> Parents;
 };
 
 class TraversalKindScope {
   ParentMapContext &Ctx;
-  ast_type_traits::TraversalKind TK = ast_type_traits::TK_AsIs;
+  TraversalKind TK = TK_AsIs;
 
 public:
-  TraversalKindScope(ASTContext &ASTCtx,
-                     llvm::Optional<ast_type_traits::TraversalKind> ScopeTK)
+  TraversalKindScope(ASTContext &ASTCtx, llvm::Optional<TraversalKind> ScopeTK)
       : Ctx(ASTCtx.getParentMapContext()) {
     TK = Ctx.getTraversalKind();
     if (ScopeTK)
       Ctx.setTraversalKind(*ScopeTK);
   }
 
   ~TraversalKindScope() { Ctx.setTraversalKind(TK); }
 };
 
 /// Container for either a single DynTypedNode or for an ArrayRef to
 /// DynTypedNode. For use with ParentMap.
 class DynTypedNodeList {
-  using DynTypedNode = ast_type_traits::DynTypedNode;
+  using DynTypedNode = DynTypedNode;
 
-  llvm::AlignedCharArrayUnion<ast_type_traits::DynTypedNode,
-                              ArrayRef<DynTypedNode>> Storage;
+  llvm::AlignedCharArrayUnion<DynTypedNode, ArrayRef<DynTypedNode>> Storage;
   bool IsSingleNode;
 
 public:
   DynTypedNodeList(const DynTypedNode &N) : IsSingleNode(true) {
     new (Storage.buffer) DynTypedNode(N);
   }
 
   DynTypedNodeList(ArrayRef<DynTypedNode> A) : IsSingleNode(false) {
     new (Storage.buffer) ArrayRef<DynTypedNode>(A);
   }
 
-  const ast_type_traits::DynTypedNode *begin() const {
+  const DynTypedNode *begin() const {
     if (!IsSingleNode)
       return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
           ->begin();
     return reinterpret_cast<const DynTypedNode *>(Storage.buffer);
   }
 
-  const ast_type_traits::DynTypedNode *end() const {
+  const DynTypedNode *end() const {
     if (!IsSingleNode)
       return reinterpret_cast<const ArrayRef<DynTypedNode> *>(Storage.buffer)
           ->end();
     return reinterpret_cast<const DynTypedNode *>(Storage.buffer) + 1;
   }
 
   size_t size() const { return end() - begin(); }
   bool empty() const { return begin() == end(); }
 
   const DynTypedNode &operator[](size_t N) const {
     assert(N < size() && "Out of bounds!");
     return *(begin() + N);
   }
 };
 
 template <typename NodeT>
 inline DynTypedNodeList ParentMapContext::getParents(const NodeT &Node) {
-  return getParents(ast_type_traits::DynTypedNode::create(Node));
+  return getParents(DynTypedNode::create(Node));
 }
 
 template <typename NodeT>
 inline DynTypedNodeList ASTContext::getParents(const NodeT &Node) {
   return getParentMapContext().getParents(Node);
 }
 
 template <>
-inline DynTypedNodeList
-ASTContext::getParents(const ast_type_traits::DynTypedNode &Node) {
+inline DynTypedNodeList ASTContext::getParents(const DynTypedNode &Node) {
   return getParentMapContext().getParents(Node);
 }
 
 } // namespace clang
 
 #endif

clang/include/clang/ASTMatchers/ASTMatchFinder.h

public:
 
   /// Calls the registered callbacks on all matches on the given \p Node.
   ///
   /// Note that there can be multiple matches on a single node, for
   /// example when using decl(forEachDescendant(stmt())).
   ///
   /// @{
   template <typename T> void match(const T &Node, ASTContext &Context) {
-    match(clang::ast_type_traits::DynTypedNode::create(Node), Context);
+    match(clang::DynTypedNode::create(Node), Context);
   }
-  void match(const clang::ast_type_traits::DynTypedNode &Node,
-             ASTContext &Context);
+  void match(const clang::DynTypedNode &Node, ASTContext &Context);
   /// @}
 
   /// Finds all matches in the given AST.
   void matchAST(ASTContext &Context);
 
   /// Registers a callback to notify the end of parsing.
   ///
   /// The provided closure is called after parsing is done, before the AST is

 ///
 /// \see selectFirst
 /// @{
 template <typename MatcherT, typename NodeT>
 SmallVector<BoundNodes, 1>
 match(MatcherT Matcher, const NodeT &Node, ASTContext &Context);
 
 template <typename MatcherT>
-SmallVector<BoundNodes, 1>
-match(MatcherT Matcher, const ast_type_traits::DynTypedNode &Node,
+SmallVector<BoundNodes, 1> match(MatcherT Matcher, const DynTypedNode &Node,
                                  ASTContext &Context);
 /// @}
 
 /// Returns the results of matching \p Matcher on the translation unit of
 /// \p Context and collects the \c BoundNodes of all callback invocations.
 template <typename MatcherT>
 SmallVector<BoundNodes, 1> match(MatcherT Matcher, ASTContext &Context);
 
 /// Returns the first result of type \c NodeT bound to \p BoundTo.
public:
   void run(const MatchFinder::MatchResult &Result) override {
     Nodes.push_back(Result.Nodes);
   }
   SmallVector<BoundNodes, 1> Nodes;
 };
 }
 
 template <typename MatcherT>
-SmallVector<BoundNodes, 1>
-match(MatcherT Matcher, const ast_type_traits::DynTypedNode &Node,
+SmallVector<BoundNodes, 1> match(MatcherT Matcher, const DynTypedNode &Node,
                                  ASTContext &Context) {
   internal::CollectMatchesCallback Callback;
   MatchFinder Finder;
   Finder.addMatcher(Matcher, &Callback);
   Finder.match(Node, Context);
   return std::move(Callback.Nodes);
 }
 
 template <typename MatcherT, typename NodeT>
 SmallVector<BoundNodes, 1>
 match(MatcherT Matcher, const NodeT &Node, ASTContext &Context) {
-  return match(Matcher, ast_type_traits::DynTypedNode::create(Node), Context);
+  return match(Matcher, DynTypedNode::create(Node), Context);
 }
 
 template <typename MatcherT>
 SmallVector<BoundNodes, 1>
 match(MatcherT Matcher, ASTContext &Context) {
   internal::CollectMatchesCallback Callback;
   MatchFinder Finder;
   Finder.addMatcher(Matcher, &Callback);
   Finder.matchAST(Context);
   return std::move(Callback.Nodes);
 }
 
 inline SmallVector<BoundNodes, 1>
-matchDynamic(internal::DynTypedMatcher Matcher,
-             const ast_type_traits::DynTypedNode &Node, ASTContext &Context) {
+matchDynamic(internal::DynTypedMatcher Matcher, const DynTypedNode &Node,
+             ASTContext &Context) {
   internal::CollectMatchesCallback Callback;
   MatchFinder Finder;
   Finder.addDynamicMatcher(Matcher, &Callback);
   Finder.match(Node, Context);
   return std::move(Callback.Nodes);
 }
 
 template <typename NodeT>
 SmallVector<BoundNodes, 1> matchDynamic(internal::DynTypedMatcher Matcher,
                                         const NodeT &Node,
                                         ASTContext &Context) {
-  return matchDynamic(Matcher, ast_type_traits::DynTypedNode::create(Node),
-                      Context);
+  return matchDynamic(Matcher, DynTypedNode::create(Node), Context);
 }
 
 inline SmallVector<BoundNodes, 1>
 matchDynamic(internal::DynTypedMatcher Matcher, ASTContext &Context) {
   internal::CollectMatchesCallback Callback;
   MatchFinder Finder;
   Finder.addDynamicMatcher(Matcher, &Callback);
   Finder.matchAST(Context);
   return std::move(Callback.Nodes);
 }
 
 } // end namespace ast_matchers
 } // end namespace clang
 
 #endif

clang/include/clang/ASTMatchers/ASTMatchers.h

public:
   /// it cannot be converted to the specified type.
   template <typename T>
   const T *getNodeAs(StringRef ID) const {
     return MyBoundNodes.getNodeAs<T>(ID);
   }
 
   /// 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
+  /// type of \c clang::DynTypedNode
   using IDToNodeMap = internal::BoundNodesMap::IDToNodeMap;
 
   /// Retrieve mapping from binding identifiers to bound nodes.
   const IDToNodeMap &getMap() const {
     return MyBoundNodes.getMap();
   }
 
 private:

 /// \code
 ///   void foo()
 ///   {
 ///       int i = 3.0;
 ///   }
 /// \endcode
 /// The matcher
 /// \code
-///   traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
+///   traverse(TK_IgnoreImplicitCastsAndParentheses,
 ///     varDecl(hasInitializer(floatLiteral().bind("init")))
 ///   )
 /// \endcode
 /// matches the variable declaration with "init" bound to the "3.0".
 template <typename T>
-internal::Matcher<T> traverse(ast_type_traits::TraversalKind TK,
+internal::Matcher<T> traverse(TraversalKind TK,
                               const internal::Matcher<T> &InnerMatcher) {
   return internal::DynTypedMatcher::constructRestrictedWrapper(
              new internal::TraversalMatcher<T>(TK, InnerMatcher),
              InnerMatcher.getID().first)
       .template unconditionalConvertTo<T>();
 }
 
 template <typename T>
 internal::BindableMatcher<T>
-traverse(ast_type_traits::TraversalKind TK,
-         const internal::BindableMatcher<T> &InnerMatcher) {
+traverse(TraversalKind TK, const internal::BindableMatcher<T> &InnerMatcher) {
   return internal::BindableMatcher<T>(
       internal::DynTypedMatcher::constructRestrictedWrapper(
           new internal::TraversalMatcher<T>(TK, InnerMatcher),
           InnerMatcher.getID().first)
           .template unconditionalConvertTo<T>());
 }
 
 template <typename... T>
 internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>
-traverse(ast_type_traits::TraversalKind TK,
+traverse(TraversalKind TK,
          const internal::VariadicOperatorMatcher<T...> &InnerMatcher) {
   return internal::TraversalWrapper<internal::VariadicOperatorMatcher<T...>>(
       TK, InnerMatcher);
 }
 
 template <template <typename ToArg, typename FromArg> class ArgumentAdapterT,
           typename T, typename ToTypes>
 internal::TraversalWrapper<
     internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>>
-traverse(ast_type_traits::TraversalKind TK,
-         const internal::ArgumentAdaptingMatcherFuncAdaptor<
+traverse(TraversalKind TK, const internal::ArgumentAdaptingMatcherFuncAdaptor<
                                ArgumentAdapterT, T, ToTypes> &InnerMatcher) {
   return internal::TraversalWrapper<
       internal::ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T,
                                                    ToTypes>>(TK, InnerMatcher);
 }
 
 template <template <typename T, typename P1> class MatcherT, typename P1,
           typename ReturnTypesF>
 internal::TraversalWrapper<
     internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>>
-traverse(
-    ast_type_traits::TraversalKind TK,
-    const internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>
-        &InnerMatcher) {
+traverse(TraversalKind TK, const internal::PolymorphicMatcherWithParam1<
+                               MatcherT, P1, ReturnTypesF> &InnerMatcher) {
   return internal::TraversalWrapper<
       internal::PolymorphicMatcherWithParam1<MatcherT, P1, ReturnTypesF>>(
       TK, InnerMatcher);
 }
 
 template <template <typename T, typename P1, typename P2> class MatcherT,
           typename P1, typename P2, typename ReturnTypesF>
 internal::TraversalWrapper<
     internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>>
-traverse(
-    ast_type_traits::TraversalKind TK,
-    const internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>
-        &InnerMatcher) {
+traverse(TraversalKind TK, const internal::PolymorphicMatcherWithParam2<
+                               MatcherT, P1, P2, ReturnTypesF> &InnerMatcher) {
   return internal::TraversalWrapper<
       internal::PolymorphicMatcherWithParam2<MatcherT, P1, P2, ReturnTypesF>>(
       TK, InnerMatcher);
 }
 
 /// Matches expressions that match InnerMatcher after any implicit AST
 /// nodes are stripped off.
 ///
AST_POLYMORPHIC_MATCHER_P(equalsBoundNode,
   // 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);
+  Predicate.Node = DynTypedNode::create(Node);
   return Builder->removeBindings(Predicate);
 }
 
 /// Matches the condition variable statement in an if statement.
 ///
 /// Given
 /// \code
 ///   if (A* a = GetAPointer()) {}

 /// \endcode
 /// returnStmt(forFunction(hasName("operator=")))
 ///   matches 'return *this'
 ///   but does not match 'return v > 0'
 AST_MATCHER_P(Stmt, forFunction, internal::Matcher<FunctionDecl>,
               InnerMatcher) {
   const auto &Parents = Finder->getASTContext().getParents(Node);
 
-  llvm::SmallVector<ast_type_traits::DynTypedNode, 8> Stack(Parents.begin(),
-                                                            Parents.end());
+  llvm::SmallVector<DynTypedNode, 8> Stack(Parents.begin(), Parents.end());
   while(!Stack.empty()) {
     const auto &CurNode = Stack.back();
     Stack.pop_back();
     if(const auto *FuncDeclNode = CurNode.get<FunctionDecl>()) {
       if(InnerMatcher.matches(*FuncDeclNode, Finder, Builder)) {
         return true;
       }
     } else if(const auto *LambdaExprNode = CurNode.get<LambdaExpr>()) {

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

 }
 
 /// Internal version of BoundNodes. Holds all the bound nodes.
 class BoundNodesMap {
 public:
   /// 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) {
+  void addNode(StringRef ID, const DynTypedNode &DynNode) {
     NodeMap[std::string(ID)] = DynNode;
   }
 
   /// 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 {
+  DynTypedNode getNode(StringRef ID) const {
     IDToNodeMap::const_iterator It = NodeMap.find(ID);
     if (It == NodeMap.end()) {
-      return ast_type_traits::DynTypedNode();
+      return DynTypedNode();
     }
     return It->second;
   }
 
   /// Imposes an order on BoundNodesMaps.
   bool operator<(const BoundNodesMap &Other) const {
     return NodeMap < Other.NodeMap;
   }
 
   /// 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
-  using IDToNodeMap =
-      std::map<std::string, ast_type_traits::DynTypedNode, std::less<>>;
+  using IDToNodeMap = std::map<std::string, DynTypedNode, std::less<>>;
 
   const IDToNodeMap &getMap() const {
     return NodeMap;
   }
 
   /// Returns \c true if this \c BoundNodesMap can be compared, i.e. all
   /// stored nodes have memoization data.
   bool isComparable() const {
public:
 
     /// 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;
   };
 
   /// Add a binding from an id to a node.
-  void setBinding(StringRef Id, const ast_type_traits::DynTypedNode &DynNode) {
+  void setBinding(StringRef Id, const DynTypedNode &DynNode) {
     if (Bindings.empty())
       Bindings.emplace_back();
     for (BoundNodesMap &Binding : Bindings)
       Binding.addNode(Id, DynNode);
   }
 
   /// Adds a branch in the tree.
   void addMatch(const BoundNodesTreeBuilder &Bindings);
class DynMatcherInterface
     : public llvm::ThreadSafeRefCountedBase<DynMatcherInterface> {
 public:
   virtual ~DynMatcherInterface() = default;
 
   /// 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,
+  virtual bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const = 0;
 
-  virtual llvm::Optional<ast_type_traits::TraversalKind> TraversalKind() const {
+  virtual llvm::Optional<TraversalKind> TraversalKind() const {
     return llvm::None;
   }
 };
 
 /// 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:
   /// 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,
+  bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
                   BoundNodesTreeBuilder *Builder) const override {
     return matches(DynNode.getUnchecked<T>(), Finder, Builder);
   }
 };
 
 /// Interface for matchers that only evaluate properties on a single
 /// node.
 template <typename T>

 /// 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:
   /// Takes ownership of the provided implementation pointer.
   template <typename T>
   DynTypedMatcher(MatcherInterface<T> *Implementation)
-      : SupportedKind(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()),
+      : SupportedKind(ASTNodeKind::getFromNodeKind<T>()),
         RestrictKind(SupportedKind), Implementation(Implementation) {}
 
   /// Construct from a variadic function.
   enum VariadicOperator {
     /// Matches nodes for which all provided matchers match.
     VO_AllOf,
 
     /// Matches nodes for which at least one of the provided matchers
enum VariadicOperator {
     /// 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(VariadicOperator Op,
-                    ast_type_traits::ASTNodeKind SupportedKind,
+  constructVariadic(VariadicOperator Op, ASTNodeKind SupportedKind,
                     std::vector<DynTypedMatcher> InnerMatchers);
 
   static DynTypedMatcher
   constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher,
-                             ast_type_traits::ASTNodeKind RestrictKind);
+                             ASTNodeKind RestrictKind);
 
   /// 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);
+  static DynTypedMatcher trueMatcher(ASTNodeKind NodeKind);
 
   void setAllowBind(bool AB) { AllowBind = AB; }
 
   /// Check whether this matcher could ever match a node of kind \p Kind.
   /// \return \c false if this matcher will never match such a node. Otherwise,
   /// return \c true.
-  bool canMatchNodesOfKind(ast_type_traits::ASTNodeKind Kind) const;
+  bool canMatchNodesOfKind(ASTNodeKind Kind) const;
 
   /// 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;
+  DynTypedMatcher dynCastTo(const ASTNodeKind Kind) const;
 
   /// Returns true if the matcher matches the given \c DynNode.
-  bool matches(const ast_type_traits::DynTypedNode &DynNode,
-               ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder) const;
+  bool matches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
+               BoundNodesTreeBuilder *Builder) const;
 
   /// Same as matches(), but skips the kind check.
   ///
   /// It is faster, but the caller must ensure the node is valid for the
   /// kind of this matcher.
-  bool matchesNoKindCheck(const ast_type_traits::DynTypedNode &DynNode,
-                          ASTMatchFinder *Finder,
+  bool matchesNoKindCheck(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const;
 
   /// 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;
 
   /// 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.
-  using MatcherIDType = std::pair<ast_type_traits::ASTNodeKind, uint64_t>;
+  using MatcherIDType = std::pair<ASTNodeKind, uint64_t>;
   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()));
   }
 
   /// 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;
-  }
+  ASTNodeKind getSupportedKind() const { return SupportedKind; }
 
   /// 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>());
+    return canConvertTo(ASTNodeKind::getFromNodeKind<T>());
   }
-  bool canConvertTo(ast_type_traits::ASTNodeKind To) const;
+  bool canConvertTo(ASTNodeKind To) const;
 
   /// 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>();
   }
 
   /// 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,
+  DynTypedMatcher(ASTNodeKind SupportedKind, ASTNodeKind RestrictKind,
                   IntrusiveRefCntPtr<DynMatcherInterface> Implementation)
       : SupportedKind(SupportedKind), RestrictKind(RestrictKind),
         Implementation(std::move(Implementation)) {}
 
   bool AllowBind = false;
-  ast_type_traits::ASTNodeKind SupportedKind;
+  ASTNodeKind SupportedKind;
 
   /// 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;
+  ASTNodeKind RestrictKind;
   IntrusiveRefCntPtr<DynMatcherInterface> Implementation;
 };
 
 /// Wrapper base class for a wrapping matcher.
 ///
 /// This is just a container for a DynTypedMatcher that can be used as a base
 /// class for another matcher.
 template <typename T>
public:
   ///
   /// Requires \c T to be derived from \c From.
   template <typename From>
   Matcher(const Matcher<From> &Other,
           std::enable_if_t<std::is_base_of<From, T>::value &&
                            !std::is_same<From, T>::value> * = nullptr)
       : Implementation(restrictMatcher(Other.Implementation)) {
     assert(Implementation.getSupportedKind().isSame(
-        ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
+        ASTNodeKind::getFromNodeKind<T>()));
   }
 
   /// 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,
           std::enable_if_t<std::is_same<T, QualType>::value &&
                            std::is_same<TypeT, Type>::value> * = nullptr)
       : Implementation(new TypeToQualType<TypeT>(Other)) {}
 
   /// 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);
   }
 
   /// 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);
+    return Implementation.matches(DynTypedNode::create(Node), Finder, Builder);
   }
 
   /// Returns an ID that uniquely identifies the matcher.
   DynTypedMatcher::MatcherIDType getID() const {
     return Implementation.getID();
   }
 
   /// Extract the dynamic matcher.
public:
   public:
     TypeToQualType(const Matcher<TypeT> &InnerMatcher)
         : TypeToQualType::WrapperMatcherInterface(InnerMatcher) {}
 
     bool matches(const QualType &Node, ASTMatchFinder *Finder,
                  BoundNodesTreeBuilder *Builder) const override {
       if (Node.isNull())
         return false;
-      return this->InnerMatcher.matches(
-          ast_type_traits::DynTypedNode::create(*Node), Finder, Builder);
+      return this->InnerMatcher.matches(DynTypedNode::create(*Node), Finder,
+                                        Builder);
     }
   };
 
 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>());
+    return Other.dynCastTo(ASTNodeKind::getFromNodeKind<T>());
   }
 
   explicit Matcher(const DynTypedMatcher &Implementation)
       : Implementation(restrictMatcher(Implementation)) {
-    assert(this->Implementation.getSupportedKind()
-               .isSame(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()));
+    assert(this->Implementation.getSupportedKind().isSame(
+        ASTNodeKind::getFromNodeKind<T>()));
   }
 
   DynTypedMatcher Implementation;
 };  // class Matcher
 
 /// 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);
 }
 
 /// 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>())) {
+  const ASTNodeKind SourceKind = getSupportedKind();
+  if (SourceKind.isSame(ASTNodeKind::getFromNodeKind<Type>())) {
     // We support implicit conversion from Matcher<Type> to Matcher<QualType>
     return unconditionalConvertTo<Type>();
   }
   return unconditionalConvertTo<QualType>();
 }
 
 /// Finds the first node in a range that matches the given matcher.
 template <typename MatcherT, typename IteratorT>
bool matchesSpecialized(const LabelStmt &Node, ASTMatchFinder *Finder,
                           BoundNodesTreeBuilder *Builder) const {
     return matchesDecl(Node.getDecl(), Finder, Builder);
   }
 
   /// 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 &&
-           this->InnerMatcher.matches(
-               ast_type_traits::DynTypedNode::create(*Node), Finder, Builder);
+    return Node != nullptr && this->InnerMatcher.matches(
+                                  DynTypedNode::create(*Node), Finder, Builder);
   }
 };
 
 /// 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 =
public:
   /// A class is not considered to be derived from itself.
   virtual bool objcClassIsDerivedFrom(const ObjCInterfaceDecl *Declaration,
                                       const Matcher<NamedDecl> &Base,
                                       BoundNodesTreeBuilder *Builder,
                                       bool Directly) = 0;
 
   template <typename T>
   bool matchesChildOf(const T &Node, const DynTypedMatcher &Matcher,
-                      BoundNodesTreeBuilder *Builder,
-                      ast_type_traits::TraversalKind Traverse, BindKind Bind) {
+                      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),
-                          getASTContext(), Matcher, Builder, Traverse, Bind);
+    return matchesChildOf(DynTypedNode::create(Node), getASTContext(), 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),
-                               getASTContext(), Matcher, Builder, Bind);
+    return matchesDescendantOf(DynTypedNode::create(Node), getASTContext(),
+                               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<NestedNameSpecifierLoc, T>::value ||
                       std::is_base_of<Stmt, T>::value ||
                       std::is_base_of<TypeLoc, T>::value,
                   "type not allowed for recursive matching");
-    return matchesAncestorOf(ast_type_traits::DynTypedNode::create(Node),
-                             getASTContext(), Matcher, Builder, MatchMode);
+    return matchesAncestorOf(DynTypedNode::create(Node), getASTContext(),
+                             Matcher, Builder, MatchMode);
   }
 
   virtual ASTContext &getASTContext() const = 0;
 
 protected:
-  virtual bool matchesChildOf(const ast_type_traits::DynTypedNode &Node,
-                              ASTContext &Ctx, const DynTypedMatcher &Matcher,
+  virtual bool matchesChildOf(const DynTypedNode &Node, ASTContext &Ctx,
+                              const DynTypedMatcher &Matcher,
                               BoundNodesTreeBuilder *Builder,
-                              ast_type_traits::TraversalKind Traverse,
-                              BindKind Bind) = 0;
+                              TraversalKind Traverse, BindKind Bind) = 0;
 
-  virtual bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node,
-                                   ASTContext &Ctx,
+  virtual bool matchesDescendantOf(const DynTypedNode &Node, ASTContext &Ctx,
                                    const DynTypedMatcher &Matcher,
                                    BoundNodesTreeBuilder *Builder,
                                    BindKind Bind) = 0;
 
-  virtual bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node,
-                                 ASTContext &Ctx,
+  virtual bool matchesAncestorOf(const DynTypedNode &Node, ASTContext &Ctx,
                                  const DynTypedMatcher &Matcher,
                                  BoundNodesTreeBuilder *Builder,
                                  AncestorMatchMode MatchMode) = 0;
 };
 
 /// A type-list implementation.
 ///
 /// A "linked list" of types, accessible by using the ::head and ::tail
struct ArgumentAdaptingMatcherFunc {
   ArgumentAdaptingMatcherFuncAdaptor<ArgumentAdapterT, T, ToTypes>
   operator()(const Matcher<T> &InnerMatcher) const {
     return create(InnerMatcher);
   }
 };
 
 template <typename T>
 class TraversalMatcher : public WrapperMatcherInterface<T> {
-  ast_type_traits::TraversalKind Traversal;
+  TraversalKind Traversal;
 
 public:
-  explicit TraversalMatcher(ast_type_traits::TraversalKind TK,
-                            const Matcher<T> &ChildMatcher)
+  explicit TraversalMatcher(TraversalKind TK, const Matcher<T> &ChildMatcher)
       : TraversalMatcher::WrapperMatcherInterface(ChildMatcher), Traversal(TK) {
   }
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
-    return this->InnerMatcher.matches(
-        ast_type_traits::DynTypedNode::create(Node), Finder, Builder);
+    return this->InnerMatcher.matches(DynTypedNode::create(Node), Finder,
+                                      Builder);
   }
 
-  llvm::Optional<ast_type_traits::TraversalKind>
-  TraversalKind() const override {
+  llvm::Optional<TraversalKind> TraversalKind() const override {
     return Traversal;
   }
 };
 
 template <typename MatcherType> class TraversalWrapper {
 public:
-  TraversalWrapper(ast_type_traits::TraversalKind TK,
-                   const MatcherType &InnerMatcher)
+  TraversalWrapper(TraversalKind TK, const MatcherType &InnerMatcher)
       : TK(TK), InnerMatcher(InnerMatcher) {}
 
   template <typename T> operator Matcher<T>() const {
     return internal::DynTypedMatcher::constructRestrictedWrapper(
                new internal::TraversalMatcher<T>(TK, InnerMatcher),
-               ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
+               ASTNodeKind::getFromNodeKind<T>())
         .template unconditionalConvertTo<T>();
   }
 
 private:
-  ast_type_traits::TraversalKind TK;
+  TraversalKind TK;
   MatcherType InnerMatcher;
 };
 
 /// 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.
 ///

 /// This is useful when a matcher syntactically requires a child matcher,
 /// but the context doesn't care. See for example: anything().
 class TrueMatcher {
 public:
   using ReturnTypes = AllNodeBaseTypes;
 
   template <typename T>
   operator Matcher<T>() const {
-    return DynTypedMatcher::trueMatcher(
-               ast_type_traits::ASTNodeKind::getFromNodeKind<T>())
+    return DynTypedMatcher::trueMatcher(ASTNodeKind::getFromNodeKind<T>())
         .template unconditionalConvertTo<T>();
   }
 };
 
 /// 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.

 class HasMatcher : public WrapperMatcherInterface<T> {
 public:
   explicit HasMatcher(const Matcher<ChildT> &ChildMatcher)
       : HasMatcher::WrapperMatcherInterface(ChildMatcher) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     return Finder->matchesChildOf(Node, this->InnerMatcher, Builder,
-                                  ast_type_traits::TraversalKind::TK_AsIs,
+                                  TraversalKind::TK_AsIs,
                                   ASTMatchFinder::BK_First);
   }
 };
 
 /// 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 WrapperMatcherInterface<T> {
   static_assert(IsBaseType<ChildT>::value,
                 "for each only accepts base type matcher");
 
  public:
    explicit ForEachMatcher(const Matcher<ChildT> &ChildMatcher)
        : ForEachMatcher::WrapperMatcherInterface(ChildMatcher) {}
 
   bool matches(const T& Node, ASTMatchFinder* Finder,
                BoundNodesTreeBuilder* Builder) const override {
     return Finder->matchesChildOf(
         Node, this->InnerMatcher, Builder,
-        ast_type_traits::TraversalKind::TK_IgnoreImplicitCastsAndParentheses,
+        TraversalKind::TK_IgnoreImplicitCastsAndParentheses,
         ASTMatchFinder::BK_All);
   }
 };
 
 /// VariadicOperatorMatcher related types.
 /// @{
 
 /// Polymorphic matcher object that uses a \c
 /// 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
 /// conversion operator.
 template <typename... Ps> class VariadicOperatorMatcher {
 public:
   VariadicOperatorMatcher(DynTypedMatcher::VariadicOperator Op, Ps &&... Params)
       : Op(Op), Params(std::forward<Ps>(Params)...) {}
 
   template <typename T> operator Matcher<T>() const {
     return DynTypedMatcher::constructVariadic(
-               Op, ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
+               Op, ASTNodeKind::getFromNodeKind<T>(),
                getMatchers<T>(std::index_sequence_for<Ps...>()))
         .template unconditionalConvertTo<T>();
   }
 
 private:
   // Helper method to unpack the tuple into a vector.
   template <typename T, std::size_t... Is>
   std::vector<DynTypedMatcher> getMatchers(std::index_sequence<Is...>) const {
if (InnerMatchers.size() == 1) {
     return BindableMatcher<T>(*InnerMatchers[0]);
   }
 
   using PI = llvm::pointee_iterator<const Matcher<T> *const *>;
 
   std::vector<DynTypedMatcher> DynMatchers(PI(InnerMatchers.begin()),
                                            PI(InnerMatchers.end()));
   return BindableMatcher<T>(
-      DynTypedMatcher::constructVariadic(
-          DynTypedMatcher::VO_AllOf,
-          ast_type_traits::ASTNodeKind::getFromNodeKind<T>(),
+      DynTypedMatcher::constructVariadic(DynTypedMatcher::VO_AllOf,
+                                         ASTNodeKind::getFromNodeKind<T>(),
                                          std::move(DynMatchers))
           .template unconditionalConvertTo<T>());
 }
 
 /// 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,
public:
   bool matches(const TLoc &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     if (!Node)
       return false;
     return this->InnerMatcher.matches(extract(Node), Finder, Builder);
   }
 
 private:
-  static ast_type_traits::DynTypedNode
-  extract(const NestedNameSpecifierLoc &Loc) {
-    return ast_type_traits::DynTypedNode::create(*Loc.getNestedNameSpecifier());
+  static DynTypedNode extract(const NestedNameSpecifierLoc &Loc) {
+    return DynTypedNode::create(*Loc.getNestedNameSpecifier());
   }
 };
 
 /// Matches \c TypeLocs based on an inner matcher matching a certain
 /// \c QualType.
 ///
 /// Used to implement the \c loc() matcher.
 class TypeLocTypeMatcher : public WrapperMatcherInterface<TypeLoc> {
 public:
   explicit TypeLocTypeMatcher(const Matcher<QualType> &InnerMatcher)
       : TypeLocTypeMatcher::WrapperMatcherInterface(InnerMatcher) {}
 
   bool matches(const TypeLoc &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     if (!Node)
       return false;
-    return this->InnerMatcher.matches(
-        ast_type_traits::DynTypedNode::create(Node.getType()), Finder, Builder);
+    return this->InnerMatcher.matches(DynTypedNode::create(Node.getType()),
+                                      Finder, Builder);
   }
 };
 
 /// 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 WrapperMatcherInterface<T> {
 public:
   explicit TypeTraverseMatcher(const Matcher<QualType> &InnerMatcher,
                                QualType (T::*TraverseFunction)() const)
       : TypeTraverseMatcher::WrapperMatcherInterface(InnerMatcher),
         TraverseFunction(TraverseFunction) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     QualType NextNode = (Node.*TraverseFunction)();
     if (NextNode.isNull())
       return false;
-    return this->InnerMatcher.matches(
-        ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder);
+    return this->InnerMatcher.matches(DynTypedNode::create(NextNode), Finder,
+                                      Builder);
   }
 
 private:
   QualType (T::*TraverseFunction)() const;
 };
 
 /// 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 WrapperMatcherInterface<T> {
 public:
   explicit TypeLocTraverseMatcher(const Matcher<TypeLoc> &InnerMatcher,
                                   TypeLoc (T::*TraverseFunction)() const)
       : TypeLocTraverseMatcher::WrapperMatcherInterface(InnerMatcher),
         TraverseFunction(TraverseFunction) {}
 
   bool matches(const T &Node, ASTMatchFinder *Finder,
                BoundNodesTreeBuilder *Builder) const override {
     TypeLoc NextNode = (Node.*TraverseFunction)();
     if (!NextNode)
       return false;
-    return this->InnerMatcher.matches(
-        ast_type_traits::DynTypedNode::create(NextNode), Finder, Builder);
+    return this->InnerMatcher.matches(DynTypedNode::create(NextNode), Finder,
+                                      Builder);
   }
 
 private:
   TypeLoc (T::*TraverseFunction)() const;
 };
 
 /// Converts a \c Matcher<InnerT> to a \c Matcher<OuterT>, where
 /// \c OuterT is any type that is supported by \c Getter.

 }
 
 struct NotEqualsBoundNodePredicate {
   bool operator()(const internal::BoundNodesMap &Nodes) const {
     return Nodes.getNode(ID) != Node;
   }
 
   std::string ID;
-  ast_type_traits::DynTypedNode Node;
+  DynTypedNode Node;
 };
 
 template <typename Ty>
 struct GetBodyMatcher {
   static const Stmt *get(const Ty &Node) {
     return Node.getBody();
   }
 };

clang/include/clang/ASTMatchers/Dynamic/VariantValue.h

enum Kind {
     AK_Double,
     AK_Unsigned,
     AK_String
   };
   /// Constructor for non-matcher types.
   ArgKind(Kind K) : K(K) { assert(K != AK_Matcher); }
 
   /// Constructor for matcher types.
-  ArgKind(ast_type_traits::ASTNodeKind MatcherKind)
-      : K(AK_Matcher), MatcherKind(MatcherKind) {}
+  ArgKind(ASTNodeKind MatcherKind) : K(AK_Matcher), MatcherKind(MatcherKind) {}
 
   Kind getArgKind() const { return K; }
-  ast_type_traits::ASTNodeKind getMatcherKind() const {
+  ASTNodeKind getMatcherKind() const {
     assert(K == AK_Matcher);
     return MatcherKind;
   }
 
   /// 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
   ///   conversion.
   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;
   }
 
   /// String representation of the type.
   std::string asString() const;
 
 private:
   Kind K;
-  ast_type_traits::ASTNodeKind MatcherKind;
+  ASTNodeKind MatcherKind;
 };
 
 using ast_matchers::internal::DynTypedMatcher;
 
 /// 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 {
   /// Methods that depend on T from hasTypedMatcher/getTypedMatcher.
   class MatcherOps {
   public:
-    MatcherOps(ast_type_traits::ASTNodeKind NodeKind) : NodeKind(NodeKind) {}
+    MatcherOps(ASTNodeKind NodeKind) : NodeKind(NodeKind) {}
 
     bool canConstructFrom(const DynTypedMatcher &Matcher,
                           bool &IsExactMatch) const;
 
     /// Convert \p Matcher the destination type and return it as a new
     /// DynTypedMatcher.
     virtual DynTypedMatcher
     convertMatcher(const DynTypedMatcher &Matcher) const = 0;
 
     /// 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::VariadicOperator Op,
                               ArrayRef<VariantMatcher> InnerMatchers) const;
 
   protected:
     ~MatcherOps() = default;
 
   private:
-    ast_type_traits::ASTNodeKind NodeKind;
+    ASTNodeKind NodeKind;
   };
 
   /// Payload interface to be specialized by each matcher type.
   ///
   /// It follows a similar interface as VariantMatcher itself.
   class Payload {
   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,
+    virtual bool isConvertibleTo(ASTNodeKind Kind,
                                  unsigned *Specificity) const = 0;
   };
 
 public:
   /// A null matcher.
   VariantMatcher();
 
   /// Clones the provided matcher.
public:
   }
 
   /// 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
   ///   conversion.
-  bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
-                       unsigned *Specificity) const {
+  bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const {
     if (Value)
       return Value->isConvertibleTo(Kind, Specificity);
     return false;
   }
 
   /// Return this matcher as a \c Matcher<T>.
   ///
   /// Handles the different types (Single, Polymorphic) accordingly.
private:
   class PolymorphicPayload;
   class VariadicOpPayload;
 
   std::shared_ptr<const Payload> Value;
 };
 
 template <typename T>
 struct VariantMatcher::TypedMatcherOps final : VariantMatcher::MatcherOps {
-  TypedMatcherOps()
-      : MatcherOps(ast_type_traits::ASTNodeKind::getFromNodeKind<T>()) {}
+  TypedMatcherOps() : MatcherOps(ASTNodeKind::getFromNodeKind<T>()) {}
   typedef ast_matchers::internal::Matcher<T> MatcherT;
 
   DynTypedMatcher
   convertMatcher(const DynTypedMatcher &Matcher) const override {
     return DynTypedMatcher(Matcher.convertTo<T>());
   }
 };
 

clang/include/clang/Tooling/ASTDiff/ASTDiff.h

enum ChangeKind {
   Move,      // (Src, Dst, Pos): move Src to be a child of Dst at offset Pos.
   UpdateMove // Same as Move plus Update.
 };
 
 /// Represents a Clang AST node, alongside some additional information.
 struct Node {
   NodeId Parent, LeftMostDescendant, RightMostDescendant;
   int Depth, Height, Shift = 0;
-  ast_type_traits::DynTypedNode ASTNode;
+  DynTypedNode ASTNode;
   SmallVector<NodeId, 4> Children;
   ChangeKind Change = None;
 
-  ast_type_traits::ASTNodeKind getType() const;
+  ASTNodeKind getType() const;
   StringRef getTypeLabel() const;
   bool isLeaf() const { return Children.empty(); }
   llvm::Optional<StringRef> getIdentifier() const;
   llvm::Optional<std::string> getQualifiedIdentifier() const;
 };
 
 class ASTDiff {
 public:

clang/include/clang/Tooling/ASTDiff/ASTDiffInternal.h

 #ifndef LLVM_CLANG_TOOLING_ASTDIFF_ASTDIFFINTERNAL_H
 #define LLVM_CLANG_TOOLING_ASTDIFF_ASTDIFFINTERNAL_H
 
 #include "clang/AST/ASTTypeTraits.h"
 
 namespace clang {
 namespace diff {
 
-using DynTypedNode = ast_type_traits::DynTypedNode;
+using DynTypedNode = DynTypedNode;
 
 class SyntaxTree;
 class SyntaxTreeImpl;
 struct ComparisonOptions;
 
 /// Within a tree, this identifies a node by its preorder offset.
 struct NodeId {
 private:

clang/include/clang/Tooling/Refactoring/ASTSelection.h

 /// Represents a selected AST node.
 ///
 /// AST selection is represented using a tree of \c SelectedASTNode. The tree
 /// follows the top-down shape of the actual AST. Each selected node has
 /// a selection kind. The kind might be none as the node itself might not
 /// actually be selected, e.g. a statement in macro whose child is in a macro
 /// argument.
 struct SelectedASTNode {
-  ast_type_traits::DynTypedNode Node;
+  DynTypedNode Node;
   SourceSelectionKind SelectionKind;
   std::vector<SelectedASTNode> Children;
 
-  SelectedASTNode(const ast_type_traits::DynTypedNode &Node,
-                  SourceSelectionKind SelectionKind)
+  SelectedASTNode(const DynTypedNode &Node, SourceSelectionKind SelectionKind)
       : Node(Node), SelectionKind(SelectionKind) {}
   SelectedASTNode(SelectedASTNode &&) = default;
   SelectedASTNode &operator=(SelectedASTNode &&) = default;
 
   void dump(llvm::raw_ostream &OS = llvm::errs()) const;
 
   using ReferenceType = std::reference_wrapper<const SelectedASTNode>;
 };

clang/lib/AST/ASTTypeTraits.cpp

 //===----------------------------------------------------------------------===//
 
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/NestedNameSpecifier.h"
 #include "clang/AST/OpenMPClause.h"
 
-namespace clang {
-namespace ast_type_traits {
+using namespace clang;
 
 const ASTNodeKind::KindInfo ASTNodeKind::AllKindInfo[] = {
   { NKI_None, "<None>" },
   { NKI_None, "TemplateArgument" },
   { NKI_None, "TemplateName" },
   { NKI_None, "NestedNameSpecifierLoc" },
   { NKI_None, "QualType" },
   { NKI_None, "TypeLoc" },
SourceRange DynTypedNode::getSourceRange() const {
   if (const Decl *D = get<Decl>())
     return D->getSourceRange();
   if (const Stmt *S = get<Stmt>())
     return S->getSourceRange();
   if (const auto *C = get<OMPClause>())
     return SourceRange(C->getBeginLoc(), C->getEndLoc());
   return SourceRange();
 }
-
-} // end namespace ast_type_traits
-} // end namespace clang

clang/lib/AST/ParentMapContext.cpp

const Expr *ParentMapContext::traverseIgnored(const Expr *E) const {
   return traverseIgnored(const_cast<Expr *>(E));
 }
 
 Expr *ParentMapContext::traverseIgnored(Expr *E) const {
   if (!E)
     return nullptr;
 
   switch (Traversal) {
-  case ast_type_traits::TK_AsIs:
+  case TK_AsIs:
     return E;
-  case ast_type_traits::TK_IgnoreImplicitCastsAndParentheses:
+  case TK_IgnoreImplicitCastsAndParentheses:
     return E->IgnoreParenImpCasts();
-  case ast_type_traits::TK_IgnoreUnlessSpelledInSource:
+  case TK_IgnoreUnlessSpelledInSource:
     return E->IgnoreUnlessSpelledInSource();
   }
   llvm_unreachable("Invalid Traversal type!");
 }
 
-ast_type_traits::DynTypedNode
-ParentMapContext::traverseIgnored(const ast_type_traits::DynTypedNode &N) const {
+DynTypedNode ParentMapContext::traverseIgnored(const DynTypedNode &N) const {
   if (const auto *E = N.get<Expr>()) {
-    return ast_type_traits::DynTypedNode::create(*traverseIgnored(E));
+    return DynTypedNode::create(*traverseIgnored(E));
   }
   return N;
 }
 
 class ParentMapContext::ParentMap {
   /// Contains parents of a node.
-  using ParentVector = llvm::SmallVector<ast_type_traits::DynTypedNode, 2>;
+  using ParentVector = llvm::SmallVector<DynTypedNode, 2>;
 
   /// Maps from a node to its parents. This is used for nodes that have
   /// pointer identity only, which are more common and we can save space by
   /// only storing a unique pointer to them.
-  using ParentMapPointers = llvm::DenseMap<
-      const void *,
+  using ParentMapPointers =
+      llvm::DenseMap<const void *,
                      llvm::PointerUnion<const Decl *, const Stmt *,
-                         ast_type_traits::DynTypedNode *, ParentVector *>>;
+                                        DynTypedNode *, ParentVector *>>;
 
   /// Parent map for nodes without pointer identity. We store a full
   /// DynTypedNode for all keys.
-  using ParentMapOtherNodes = llvm::DenseMap<
-      ast_type_traits::DynTypedNode,
+  using ParentMapOtherNodes =
+      llvm::DenseMap<DynTypedNode,
                      llvm::PointerUnion<const Decl *, const Stmt *,
-                         ast_type_traits::DynTypedNode *, ParentVector *>>;
+                                        DynTypedNode *, ParentVector *>>;
 
   ParentMapPointers PointerParents;
   ParentMapOtherNodes OtherParents;
   class ASTVisitor;
 
-  static ast_type_traits::DynTypedNode
+  static DynTypedNode
   getSingleDynTypedNodeFromParentMap(ParentMapPointers::mapped_type U) {
     if (const auto *D = U.dyn_cast<const Decl *>())
-      return ast_type_traits::DynTypedNode::create(*D);
+      return DynTypedNode::create(*D);
     if (const auto *S = U.dyn_cast<const Stmt *>())
-      return ast_type_traits::DynTypedNode::create(*S);
-    return *U.get<ast_type_traits::DynTypedNode *>();
+      return DynTypedNode::create(*S);
+    return *U.get<DynTypedNode *>();
   }
 
   template <typename NodeTy, typename MapTy>
   static DynTypedNodeList getDynNodeFromMap(const NodeTy &Node,
                                                         const MapTy &Map) {
     auto I = Map.find(Node);
     if (I == Map.end()) {
-      return llvm::ArrayRef<ast_type_traits::DynTypedNode>();
+      return llvm::ArrayRef<DynTypedNode>();
     }
     if (const auto *V = I->second.template dyn_cast<ParentVector *>()) {
       return llvm::makeArrayRef(*V);
     }
     return getSingleDynTypedNodeFromParentMap(I->second);
   }
 
 public:
   ParentMap(ASTContext &Ctx);
   ~ParentMap() {
     for (const auto &Entry : PointerParents) {
-      if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
-        delete Entry.second.get<ast_type_traits::DynTypedNode *>();
+      if (Entry.second.is<DynTypedNode *>()) {
+        delete Entry.second.get<DynTypedNode *>();
       } else if (Entry.second.is<ParentVector *>()) {
         delete Entry.second.get<ParentVector *>();
       }
     }
     for (const auto &Entry : OtherParents) {
-      if (Entry.second.is<ast_type_traits::DynTypedNode *>()) {
-        delete Entry.second.get<ast_type_traits::DynTypedNode *>();
+      if (Entry.second.is<DynTypedNode *>()) {
+        delete Entry.second.get<DynTypedNode *>();
       } else if (Entry.second.is<ParentVector *>()) {
         delete Entry.second.get<ParentVector *>();
       }
     }
   }
 
-  DynTypedNodeList getParents(ast_type_traits::TraversalKind TK,
-                              const ast_type_traits::DynTypedNode &Node) {
+  DynTypedNodeList getParents(TraversalKind TK, const DynTypedNode &Node) {
     if (Node.getNodeKind().hasPointerIdentity()) {
       auto ParentList =
           getDynNodeFromMap(Node.getMemoizationData(), PointerParents);
-      if (ParentList.size() == 1 &&
-          TK == ast_type_traits::TK_IgnoreUnlessSpelledInSource) {
+      if (ParentList.size() == 1 && TK == TK_IgnoreUnlessSpelledInSource) {
         const auto *E = ParentList[0].get<Expr>();
         const auto *Child = Node.get<Expr>();
         if (E && Child)
           return AscendIgnoreUnlessSpelledInSource(E, Child);
       }
       return ParentList;
     }
     return getDynNodeFromMap(Node, OtherParents);
while (ShouldSkip(E, Child)) {
       const auto *S = It->second.dyn_cast<const Stmt *>();
       if (!S) {
         if (auto *Vec = It->second.dyn_cast<ParentVector *>())
           return llvm::makeArrayRef(*Vec);
         return getSingleDynTypedNodeFromParentMap(It->second);
       }
       const auto *P = dyn_cast<Expr>(S);
       if (!P)
-        return ast_type_traits::DynTypedNode::create(*S);
+        return DynTypedNode::create(*S);
       Child = E;
       E = P;
     }
-    return ast_type_traits::DynTypedNode::create(*E);
+    return DynTypedNode::create(*E);
   }
 };
 
 /// Template specializations to abstract away from pointers and TypeLocs.
 /// @{
-template <typename T>
-static ast_type_traits::DynTypedNode createDynTypedNode(const T &Node) {
-  return ast_type_traits::DynTypedNode::create(*Node);
+template <typename T> static DynTypedNode createDynTypedNode(const T &Node) {
+  return DynTypedNode::create(*Node);
 }
-template <>
-ast_type_traits::DynTypedNode createDynTypedNode(const TypeLoc &Node) {
-  return ast_type_traits::DynTypedNode::create(Node);
+template <> DynTypedNode createDynTypedNode(const TypeLoc &Node) {
+  return DynTypedNode::create(Node);
 }
 template <>
-ast_type_traits::DynTypedNode
-createDynTypedNode(const NestedNameSpecifierLoc &Node) {
-  return ast_type_traits::DynTypedNode::create(Node);
+DynTypedNode createDynTypedNode(const NestedNameSpecifierLoc &Node) {
+  return DynTypedNode::create(Node);
 }
 /// @}
 
 /// A \c RecursiveASTVisitor that builds a map from nodes to their
 /// parents as defined by the \c RecursiveASTVisitor.
 ///
 /// Note that the relationship described here is purely in terms of AST
 /// traversal - there are other relationships (for example declaration context)
if (ParentStack.size() > 0) {
       // do not have pointer identity.
       auto &NodeOrVector = (*Parents)[MapNode];
       if (NodeOrVector.isNull()) {
         if (const auto *D = ParentStack.back().get<Decl>())
           NodeOrVector = D;
         else if (const auto *S = ParentStack.back().get<Stmt>())
           NodeOrVector = S;
         else
-          NodeOrVector = new ast_type_traits::DynTypedNode(ParentStack.back());
+          NodeOrVector = new DynTypedNode(ParentStack.back());
       } else {
         if (!NodeOrVector.template is<ParentVector *>()) {
           auto *Vector = new ParentVector(
               1, getSingleDynTypedNodeFromParentMap(NodeOrVector));
-          delete NodeOrVector
-              .template dyn_cast<ast_type_traits::DynTypedNode *>();
+          delete NodeOrVector.template dyn_cast<DynTypedNode *>();
           NodeOrVector = Vector;
         }
 
         auto *Vector = NodeOrVector.template get<ParentVector *>();
         // Skip duplicates for types that have memoization data.
         // We must check that the type has memoization data before calling
         // std::find() because DynTypedNode::operator== can't compare all
         // types.
private:
   bool TraverseStmt(Stmt *StmtNode) {
     return TraverseNode(StmtNode, StmtNode,
                         [&] { return VisitorBase::TraverseStmt(StmtNode); },
                         &Map.PointerParents);
   }
 
   bool TraverseTypeLoc(TypeLoc TypeLocNode) {
     return TraverseNode(
-        TypeLocNode, ast_type_traits::DynTypedNode::create(TypeLocNode),
+        TypeLocNode, DynTypedNode::create(TypeLocNode),
         [&] { return VisitorBase::TraverseTypeLoc(TypeLocNode); },
         &Map.OtherParents);
   }
 
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNSLocNode) {
     return TraverseNode(
-        NNSLocNode, ast_type_traits::DynTypedNode::create(NNSLocNode),
+        NNSLocNode, DynTypedNode::create(NNSLocNode),
         [&] { return VisitorBase::TraverseNestedNameSpecifierLoc(NNSLocNode); },
         &Map.OtherParents);
   }
 
   ParentMap &Map;
-  llvm::SmallVector<ast_type_traits::DynTypedNode, 16> ParentStack;
+  llvm::SmallVector<DynTypedNode, 16> ParentStack;
 };
 
 ParentMapContext::ParentMap::ParentMap(ASTContext &Ctx) {
   ASTVisitor(*this).TraverseAST(Ctx);
 }
 
-DynTypedNodeList
-ParentMapContext::getParents(const ast_type_traits::DynTypedNode &Node) {
+DynTypedNodeList ParentMapContext::getParents(const DynTypedNode &Node) {
   if (!Parents)
     // We build the parent map for the traversal scope (usually whole TU), as
     // hasAncestor can escape any subtree.
     Parents = std::make_unique<ParentMap>(ASTCtx);
   return Parents->getParents(getTraversalKind(), Node);
 }

clang/lib/ASTMatchers/ASTMatchFinder.cpp

 // We currently only memoize on nodes whose pointers identify the
 // nodes (\c Stmt and \c Decl, but not \c QualType or \c TypeLoc).
 // For \c QualType and \c TypeLoc it is possible to implement
 // generation of keys for each type.
 // FIXME: Benchmark whether memoization of non-pointer typed nodes
 // provides enough benefit for the additional amount of code.
 struct MatchKey {
   DynTypedMatcher::MatcherIDType MatcherID;
-  ast_type_traits::DynTypedNode Node;
+  DynTypedNode Node;
   BoundNodesTreeBuilder BoundNodes;
-  ast_type_traits::TraversalKind Traversal = ast_type_traits::TK_AsIs;
+  TraversalKind Traversal = TK_AsIs;
 
   bool operator<(const MatchKey &Other) const {
     return std::tie(Traversal, MatcherID, Node, BoundNodes) <
            std::tie(Other.Traversal, Other.MatcherID, Other.Node,
                     Other.BoundNodes);
   }
 };
 
public:
   typedef RecursiveASTVisitor<MatchChildASTVisitor> VisitorBase;
 
   // Creates an AST visitor that matches 'matcher' on all children or
   // descendants of a traversed node. max_depth is the maximum depth
   // to traverse: use 1 for matching the children and INT_MAX for
   // matching the descendants.
   MatchChildASTVisitor(const DynTypedMatcher *Matcher, ASTMatchFinder *Finder,
                        BoundNodesTreeBuilder *Builder, int MaxDepth,
-                       ast_type_traits::TraversalKind Traversal,
-                       ASTMatchFinder::BindKind Bind)
+                       TraversalKind Traversal, ASTMatchFinder::BindKind Bind)
       : Matcher(Matcher), Finder(Finder), Builder(Builder), CurrentDepth(0),
         MaxDepth(MaxDepth), Traversal(Traversal), Bind(Bind), Matches(false) {}
 
   // Returns true if a match is found in the subtree rooted at the
   // given AST node. This is done via a set of mutually recursive
   // functions. Here's how the recursion is done (the  *wildcard can
   // actually be Decl, Stmt, or Type):
   //
   //   - Traverse(node) calls BaseTraverse(node) when it needs
   //     to visit the descendants of node.
   //   - BaseTraverse(node) then calls (via VisitorBase::Traverse*(node))
   //     Traverse*(c) for each child c of 'node'.
   //   - Traverse*(c) in turn calls Traverse(c), completing the
   //     recursion.
-  bool findMatch(const ast_type_traits::DynTypedNode &DynNode) {
+  bool findMatch(const DynTypedNode &DynNode) {
     reset();
     if (const Decl *D = DynNode.get<Decl>())
       traverse(*D);
     else if (const Stmt *S = DynNode.get<Stmt>())
       traverse(*S);
     else if (const NestedNameSpecifier *NNS =
              DynNode.get<NestedNameSpecifier>())
       traverse(*NNS);
public:
   }
 
   Stmt *getStmtToTraverse(Stmt *StmtNode) {
     Stmt *StmtToTraverse = StmtNode;
     if (auto *ExprNode = dyn_cast_or_null<Expr>(StmtNode)) {
       auto *LambdaNode = dyn_cast_or_null<LambdaExpr>(StmtNode);
       if (LambdaNode &&
           Finder->getASTContext().getParentMapContext().getTraversalKind() ==
-              ast_type_traits::TK_IgnoreUnlessSpelledInSource)
+              TK_IgnoreUnlessSpelledInSource)
         StmtToTraverse = LambdaNode;
       else
         StmtToTraverse =
             Finder->getASTContext().getParentMapContext().traverseIgnored(
                 ExprNode);
     }
-    if (Traversal ==
-        ast_type_traits::TraversalKind::TK_IgnoreImplicitCastsAndParentheses) {
+    if (Traversal == TraversalKind::TK_IgnoreImplicitCastsAndParentheses) {
       if (Expr *ExprNode = dyn_cast_or_null<Expr>(StmtNode))
         StmtToTraverse = ExprNode->IgnoreParenImpCasts();
     }
     return StmtToTraverse;
   }
 
   bool TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue = nullptr) {
     // If we need to keep track of the depth, we can't perform data recursion.
public:
   bool TraverseConstructorInitializer(CXXCtorInitializer *CtorInit) {
     if (!CtorInit)
       return true;
     ScopedIncrement ScopedDepth(&CurrentDepth);
     return traverse(*CtorInit);
   }
   bool TraverseLambdaExpr(LambdaExpr *Node) {
     if (Finder->getASTContext().getParentMapContext().getTraversalKind() !=
-        ast_type_traits::TK_IgnoreUnlessSpelledInSource)
+        TK_IgnoreUnlessSpelledInSource)
       return VisitorBase::TraverseLambdaExpr(Node);
     if (!Node)
       return true;
     ScopedIncrement ScopedDepth(&CurrentDepth);
 
     for (unsigned I = 0, N = Node->capture_size(); I != N; ++I) {
       const auto *C = Node->capture_begin() + I;
       if (!C->isExplicit())
private:
   // returns, i.e. if no match is found or 'Bind' is 'BK_All'.
   template <typename T>
   bool match(const T &Node) {
     if (CurrentDepth == 0 || CurrentDepth > MaxDepth) {
       return true;
     }
     if (Bind != ASTMatchFinder::BK_All) {
       BoundNodesTreeBuilder RecursiveBuilder(*Builder);
-      if (Matcher->matches(ast_type_traits::DynTypedNode::create(Node), Finder,
+      if (Matcher->matches(DynTypedNode::create(Node), Finder,
                            &RecursiveBuilder)) {
         Matches = true;
         ResultBindings.addMatch(RecursiveBuilder);
         return false; // Abort as soon as a match is found.
       }
     } else {
       BoundNodesTreeBuilder RecursiveBuilder(*Builder);
-      if (Matcher->matches(ast_type_traits::DynTypedNode::create(Node), Finder,
+      if (Matcher->matches(DynTypedNode::create(Node), Finder,
                            &RecursiveBuilder)) {
         // After the first match the matcher succeeds.
         Matches = true;
         ResultBindings.addMatch(RecursiveBuilder);
       }
     }
     return true;
   }
private:
   }
 
   const DynTypedMatcher *const Matcher;
   ASTMatchFinder *const Finder;
   BoundNodesTreeBuilder *const Builder;
   BoundNodesTreeBuilder ResultBindings;
   int CurrentDepth;
   const int MaxDepth;
-  const ast_type_traits::TraversalKind Traversal;
+  const TraversalKind Traversal;
   const ASTMatchFinder::BindKind Bind;
   bool Matches;
 };
 
 // Controls the outermost traversal of the AST and allows to match multiple
 // matchers.
 class MatchASTVisitor : public RecursiveASTVisitor<MatchASTVisitor>,
                         public ASTMatchFinder {
public:
   bool TraverseStmt(Stmt *StmtNode, DataRecursionQueue *Queue = nullptr);
   bool TraverseType(QualType TypeNode);
   bool TraverseTypeLoc(TypeLoc TypeNode);
   bool TraverseNestedNameSpecifier(NestedNameSpecifier *NNS);
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS);
   bool TraverseConstructorInitializer(CXXCtorInitializer *CtorInit);
 
   // Matches children or descendants of 'Node' with 'BaseMatcher'.
-  bool memoizedMatchesRecursively(const ast_type_traits::DynTypedNode &Node,
-                                  ASTContext &Ctx,
+  bool memoizedMatchesRecursively(const DynTypedNode &Node, ASTContext &Ctx,
                                   const DynTypedMatcher &Matcher,
                                   BoundNodesTreeBuilder *Builder, int MaxDepth,
-                                  ast_type_traits::TraversalKind Traversal,
-                                  BindKind Bind) {
+                                  TraversalKind Traversal, BindKind Bind) {
     // For AST-nodes that don't have an identity, we can't memoize.
     if (!Node.getMemoizationData() || !Builder->isComparable())
       return matchesRecursively(Node, Matcher, Builder, MaxDepth, Traversal,
                                 Bind);
 
     MatchKey Key;
     Key.MatcherID = Matcher.getID();
     Key.Node = Node;
bool memoizedMatchesRecursively(const DynTypedNode &Node, ASTContext &Ctx,
     MemoizedMatchResult &CachedResult = ResultCache[Key];
     CachedResult = std::move(Result);
 
     *Builder = CachedResult.Nodes;
     return CachedResult.ResultOfMatch;
   }
 
   // Matches children or descendants of 'Node' with 'BaseMatcher'.
-  bool matchesRecursively(const ast_type_traits::DynTypedNode &Node,
+  bool matchesRecursively(const DynTypedNode &Node,
                           const DynTypedMatcher &Matcher,
                           BoundNodesTreeBuilder *Builder, int MaxDepth,
-                          ast_type_traits::TraversalKind Traversal,
-                          BindKind Bind) {
+                          TraversalKind Traversal, BindKind Bind) {
     MatchChildASTVisitor Visitor(
       &Matcher, this, Builder, MaxDepth, Traversal, Bind);
     return Visitor.findMatch(Node);
   }
 
   bool classIsDerivedFrom(const CXXRecordDecl *Declaration,
                           const Matcher<NamedDecl> &Base,
                           BoundNodesTreeBuilder *Builder,
                           bool Directly) override;
 
   bool objcClassIsDerivedFrom(const ObjCInterfaceDecl *Declaration,
                               const Matcher<NamedDecl> &Base,
                               BoundNodesTreeBuilder *Builder,
                               bool Directly) override;
 
   // Implements ASTMatchFinder::matchesChildOf.
-  bool matchesChildOf(const ast_type_traits::DynTypedNode &Node,
-                      ASTContext &Ctx, const DynTypedMatcher &Matcher,
-                      BoundNodesTreeBuilder *Builder,
-                      ast_type_traits::TraversalKind Traversal,
+  bool matchesChildOf(const DynTypedNode &Node, ASTContext &Ctx,
+                      const DynTypedMatcher &Matcher,
+                      BoundNodesTreeBuilder *Builder, TraversalKind Traversal,
                       BindKind Bind) override {
     if (ResultCache.size() > MaxMemoizationEntries)
       ResultCache.clear();
     return memoizedMatchesRecursively(Node, Ctx, Matcher, Builder, 1, Traversal,
                                       Bind);
   }
   // Implements ASTMatchFinder::matchesDescendantOf.
-  bool matchesDescendantOf(const ast_type_traits::DynTypedNode &Node,
-                           ASTContext &Ctx, const DynTypedMatcher &Matcher,
+  bool matchesDescendantOf(const DynTypedNode &Node, ASTContext &Ctx,
+                           const DynTypedMatcher &Matcher,
                            BoundNodesTreeBuilder *Builder,
                            BindKind Bind) override {
     if (ResultCache.size() > MaxMemoizationEntries)
       ResultCache.clear();
     return memoizedMatchesRecursively(Node, Ctx, Matcher, Builder, INT_MAX,
-                                      ast_type_traits::TraversalKind::TK_AsIs,
-                                      Bind);
+                                      TraversalKind::TK_AsIs, Bind);
   }
   // Implements ASTMatchFinder::matchesAncestorOf.
-  bool matchesAncestorOf(const ast_type_traits::DynTypedNode &Node,
-                         ASTContext &Ctx, const DynTypedMatcher &Matcher,
+  bool matchesAncestorOf(const DynTypedNode &Node, ASTContext &Ctx,
+                         const DynTypedMatcher &Matcher,
                          BoundNodesTreeBuilder *Builder,
                          AncestorMatchMode MatchMode) override {
     // Reset the cache outside of the recursive call to make sure we
     // don't invalidate any iterators.
     if (ResultCache.size() > MaxMemoizationEntries)
       ResultCache.clear();
     return memoizedMatchesAncestorOfRecursively(Node, Ctx, Matcher, Builder,
                                                 MatchMode);
   }
 
   // Matches all registered matchers on the given node and calls the
   // result callback for every node that matches.
-  void match(const ast_type_traits::DynTypedNode &Node) {
+  void match(const DynTypedNode &Node) {
     // FIXME: Improve this with a switch or a visitor pattern.
     if (auto *N = Node.get<Decl>()) {
       match(*N);
     } else if (auto *N = Node.get<Stmt>()) {
       match(*N);
     } else if (auto *N = Node.get<Type>()) {
       match(*N);
     } else if (auto *N = Node.get<QualType>()) {
for (const auto &MP : Matchers) {
       BoundNodesTreeBuilder Builder;
       if (MP.first.matches(Node, this, &Builder)) {
         MatchVisitor Visitor(ActiveASTContext, MP.second);
         Builder.visitMatches(&Visitor);
       }
     }
   }
 
-  void matchWithFilter(const ast_type_traits::DynTypedNode &DynNode) {
+  void matchWithFilter(const DynTypedNode &DynNode) {
     auto Kind = DynNode.getNodeKind();
     auto it = MatcherFiltersMap.find(Kind);
     const auto &Filter =
         it != MatcherFiltersMap.end() ? it->second : getFilterForKind(Kind);
 
     if (Filter.empty())
       return;
 
     const bool EnableCheckProfiling = Options.CheckProfiling.hasValue();
     TimeBucketRegion Timer;
     auto &Matchers = this->Matchers->DeclOrStmt;
     for (unsigned short I : Filter) {
       auto &MP = Matchers[I];
       if (EnableCheckProfiling)
         Timer.setBucket(&TimeByBucket[MP.second->getID()]);
       BoundNodesTreeBuilder Builder;
       if (MP.first.matches(DynNode, this, &Builder)) {
         MatchVisitor Visitor(ActiveASTContext, MP.second);
         Builder.visitMatches(&Visitor);
       }
     }
   }
 
-  const std::vector<unsigned short> &
-  getFilterForKind(ast_type_traits::ASTNodeKind Kind) {
+  const std::vector<unsigned short> &getFilterForKind(ASTNodeKind Kind) {
     auto &Filter = MatcherFiltersMap[Kind];
     auto &Matchers = this->Matchers->DeclOrStmt;
     assert((Matchers.size() < USHRT_MAX) && "Too many matchers.");
     for (unsigned I = 0, E = Matchers.size(); I != E; ++I) {
       if (Matchers[I].first.canMatchNodesOfKind(Kind)) {
         Filter.push_back(I);
       }
     }
     return Filter;
   }
 
   /// @{
   /// Overloads to pair the different node types to their matchers.
   void matchDispatch(const Decl *Node) {
-    return matchWithFilter(ast_type_traits::DynTypedNode::create(*Node));
+    return matchWithFilter(DynTypedNode::create(*Node));
   }
   void matchDispatch(const Stmt *Node) {
-    return matchWithFilter(ast_type_traits::DynTypedNode::create(*Node));
+    return matchWithFilter(DynTypedNode::create(*Node));
   }
 
   void matchDispatch(const Type *Node) {
     matchWithoutFilter(QualType(Node, 0), Matchers->Type);
   }
   void matchDispatch(const TypeLoc *Node) {
     matchWithoutFilter(*Node, Matchers->TypeLoc);
   }
private:
   // To allow memoization in the very common case of having deeply nested
   // expressions inside a template function, we first walk up the AST, memoizing
   // the result of the match along the way, as long as there is only a single
   // parent.
   //
   // Once there are multiple parents, the breadth first search order does not
   // allow simple memoization on the ancestors. Thus, we only memoize as long
   // as there is a single parent.
-  bool memoizedMatchesAncestorOfRecursively(
-      const ast_type_traits::DynTypedNode &Node, ASTContext &Ctx,
-      const DynTypedMatcher &Matcher, BoundNodesTreeBuilder *Builder,
+  bool memoizedMatchesAncestorOfRecursively(const DynTypedNode &Node,
+                                            ASTContext &Ctx,
+                                            const DynTypedMatcher &Matcher,
+                                            BoundNodesTreeBuilder *Builder,
                                             AncestorMatchMode MatchMode) {
     // For AST-nodes that don't have an identity, we can't memoize.
     if (!Builder->isComparable())
       return matchesAncestorOfRecursively(Node, Ctx, Matcher, Builder,
                                           MatchMode);
 
     MatchKey Key;
     Key.MatcherID = Matcher.getID();
     Key.Node = Node;
bool memoizedMatchesAncestorOfRecursively(const DynTypedNode &Node,
 
     MemoizedMatchResult &CachedResult = ResultCache[Key];
     CachedResult = std::move(Result);
 
     *Builder = CachedResult.Nodes;
     return CachedResult.ResultOfMatch;
   }
 
-  bool matchesAncestorOfRecursively(const ast_type_traits::DynTypedNode &Node,
-                                    ASTContext &Ctx,
+  bool matchesAncestorOfRecursively(const DynTypedNode &Node, ASTContext &Ctx,
                                     const DynTypedMatcher &Matcher,
                                     BoundNodesTreeBuilder *Builder,
                                     AncestorMatchMode MatchMode) {
     const auto &Parents = ActiveASTContext->getParents(Node);
     if (Parents.empty()) {
       // Nodes may have no parents if:
       //  a) the node is the TranslationUnitDecl
       //  b) we have a limited traversal scope that excludes the parent edges
#ifndef NDEBUG
         Node.dump(llvm::errs(), ActiveASTContext->getSourceManager());
         llvm_unreachable("Parent map should be complete!");
       }
 #endif
       return false;
     }
     if (Parents.size() == 1) {
       // Only one parent - do recursive memoization.
-      const ast_type_traits::DynTypedNode Parent = Parents[0];
+      const DynTypedNode Parent = Parents[0];
       BoundNodesTreeBuilder BuilderCopy = *Builder;
       if (Matcher.matches(Parent, this, &BuilderCopy)) {
         *Builder = std::move(BuilderCopy);
         return true;
       }
       if (MatchMode != ASTMatchFinder::AMM_ParentOnly) {
         return memoizedMatchesAncestorOfRecursively(Parent, Ctx, Matcher,
                                                     Builder, MatchMode);
         // Once we get back from the recursive call, the result will be the
         // same as the parent's result.
       }
     } else {
       // Multiple parents - BFS over the rest of the nodes.
       llvm::DenseSet<const void *> Visited;
-      std::deque<ast_type_traits::DynTypedNode> Queue(Parents.begin(),
-                                                      Parents.end());
+      std::deque<DynTypedNode> Queue(Parents.begin(), Parents.end());
       while (!Queue.empty()) {
         BoundNodesTreeBuilder BuilderCopy = *Builder;
         if (Matcher.matches(Queue.front(), this, &BuilderCopy)) {
           *Builder = std::move(BuilderCopy);
           return true;
         }
         if (MatchMode != ASTMatchFinder::AMM_ParentOnly) {
           for (const auto &Parent :
#endif
   const MatchFinder::MatchersByType *Matchers;
 
   /// Filtered list of matcher indices for each matcher kind.
   ///
   /// \c Decl and \c Stmt toplevel matchers usually apply to a specific node
   /// kind (and derived kinds) so it is a waste to try every matcher on every
   /// node.
   /// We precalculate a list of matchers that pass the toplevel restrict check.
-  llvm::DenseMap<ast_type_traits::ASTNodeKind, std::vector<unsigned short>>
-      MatcherFiltersMap;
+  llvm::DenseMap<ASTNodeKind, std::vector<unsigned short>> MatcherFiltersMap;
 
   const MatchFinder::MatchFinderOptions &Options;
   ASTContext *ActiveASTContext;
 
   // Maps a canonical type to its TypedefDecls.
   llvm::DenseMap<const Type*, std::set<const TypedefNameDecl*> > TypeAliases;
 
   // Maps an Objective-C interface to its ObjCCompatibleAliasDecls.
bool MatchFinder::addDynamicMatcher(const internal::DynTypedMatcher &NodeMatch,
   }
   return false;
 }
 
 std::unique_ptr<ASTConsumer> MatchFinder::newASTConsumer() {
   return std::make_unique<internal::MatchASTConsumer>(this, ParsingDone);
 }
 
-void MatchFinder::match(const clang::ast_type_traits::DynTypedNode &Node,
-                        ASTContext &Context) {
+void MatchFinder::match(const clang::DynTypedNode &Node, ASTContext &Context) {
   internal::MatchASTVisitor Visitor(&Matchers, Options);
   Visitor.set_active_ast_context(&Context);
   Visitor.match(Node);
 }
 
 void MatchFinder::matchAST(ASTContext &Context) {
   internal::MatchASTVisitor Visitor(&Matchers, Options);
   Visitor.set_active_ast_context(&Context);

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

AST_MATCHER_P(ObjCMessageExpr, hasAnySelectorMatcher, std::vector<std::string>,
   for (const std::string &S : Matches)
     if (S == SelString)
       return true;
   return false;
 }
 
 namespace internal {
 
-bool NotUnaryOperator(const ast_type_traits::DynTypedNode &DynNode,
-                      ASTMatchFinder *Finder, BoundNodesTreeBuilder *Builder,
+bool NotUnaryOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
+                      BoundNodesTreeBuilder *Builder,
                       ArrayRef<DynTypedMatcher> InnerMatchers);
 
-bool AllOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
-                           ASTMatchFinder *Finder,
+bool AllOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
                            BoundNodesTreeBuilder *Builder,
                            ArrayRef<DynTypedMatcher> InnerMatchers);
 
-bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
-                            ASTMatchFinder *Finder,
+bool EachOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
                             BoundNodesTreeBuilder *Builder,
                             ArrayRef<DynTypedMatcher> InnerMatchers);
 
-bool AnyOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
-                           ASTMatchFinder *Finder,
+bool AnyOfVariadicOperator(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
                            BoundNodesTreeBuilder *Builder,
                            ArrayRef<DynTypedMatcher> InnerMatchers);
 
-bool OptionallyVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
+bool OptionallyVariadicOperator(const 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 {
 
 using VariadicOperatorFunction = bool (*)(
-    const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder,
+    const DynTypedNode &DynNode, ASTMatchFinder *Finder,
     BoundNodesTreeBuilder *Builder, ArrayRef<DynTypedMatcher> InnerMatchers);
 
 template <VariadicOperatorFunction Func>
 class VariadicMatcher : public DynMatcherInterface {
 public:
   VariadicMatcher(std::vector<DynTypedMatcher> InnerMatchers)
       : InnerMatchers(std::move(InnerMatchers)) {}
 
-  bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
-                  ASTMatchFinder *Finder,
+  bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
                   BoundNodesTreeBuilder *Builder) const override {
     return Func(DynNode, Finder, Builder, InnerMatchers);
   }
 
 private:
   std::vector<DynTypedMatcher> InnerMatchers;
 };
 
 class IdDynMatcher : public DynMatcherInterface {
 public:
   IdDynMatcher(StringRef ID,
                IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher)
       : ID(ID), InnerMatcher(std::move(InnerMatcher)) {}
 
-  bool dynMatches(const ast_type_traits::DynTypedNode &DynNode,
-                  ASTMatchFinder *Finder,
+  bool dynMatches(const DynTypedNode &DynNode, ASTMatchFinder *Finder,
                   BoundNodesTreeBuilder *Builder) const override {
     bool Result = InnerMatcher->dynMatches(DynNode, Finder, Builder);
     if (Result) Builder->setBinding(ID, DynNode);
     return Result;
   }
 
-  llvm::Optional<ast_type_traits::TraversalKind>
-  TraversalKind() const override {
+  llvm::Optional<clang::TraversalKind> TraversalKind() const override {
     return InnerMatcher->TraversalKind();
   }
 
 private:
   const std::string ID;
   const IntrusiveRefCntPtr<DynMatcherInterface> InnerMatcher;
 };
 
 /// 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 *,
+  bool dynMatches(const DynTypedNode &, ASTMatchFinder *,
                   BoundNodesTreeBuilder *) const override {
     return true;
   }
 };
 
 } // namespace
 
 static llvm::ManagedStatic<TrueMatcherImpl> TrueMatcherInstance;
 
-DynTypedMatcher DynTypedMatcher::constructVariadic(
-    DynTypedMatcher::VariadicOperator Op,
-    ast_type_traits::ASTNodeKind SupportedKind,
+DynTypedMatcher
+DynTypedMatcher::constructVariadic(DynTypedMatcher::VariadicOperator Op,
+                                   ASTNodeKind SupportedKind,
                                    std::vector<DynTypedMatcher> InnerMatchers) {
   assert(!InnerMatchers.empty() && "Array must not be empty.");
   assert(llvm::all_of(InnerMatchers,
                       [SupportedKind](const DynTypedMatcher &M) {
                         return M.canConvertTo(SupportedKind);
                       }) &&
          "InnerMatchers must be convertible to SupportedKind!");
 
   // 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 RestrictKind = SupportedKind;
 
   switch (Op) {
   case VO_AllOf:
     // In the case of allOf() we must pass all the checks, so making
     // RestrictKind the most restrictive can save us time. This way we reject
     // invalid types earlier and we can elide the kind checks inside the
     // matcher.
     for (auto &IM : InnerMatchers) {
-      RestrictKind = ast_type_traits::ASTNodeKind::getMostDerivedType(
-          RestrictKind, IM.RestrictKind);
+      RestrictKind =
+          ASTNodeKind::getMostDerivedType(RestrictKind, IM.RestrictKind);
     }
     return DynTypedMatcher(
         SupportedKind, RestrictKind,
         new VariadicMatcher<AllOfVariadicOperator>(std::move(InnerMatchers)));
 
   case VO_AnyOf:
     return DynTypedMatcher(
         SupportedKind, RestrictKind,
case VO_UnaryNot:
     // vector.
     return DynTypedMatcher(
         SupportedKind, RestrictKind,
         new VariadicMatcher<NotUnaryOperator>(std::move(InnerMatchers)));
   }
   llvm_unreachable("Invalid Op value.");
 }
 
-DynTypedMatcher DynTypedMatcher::constructRestrictedWrapper(
-    const DynTypedMatcher &InnerMatcher,
-    ast_type_traits::ASTNodeKind RestrictKind) {
+DynTypedMatcher
+DynTypedMatcher::constructRestrictedWrapper(const DynTypedMatcher &InnerMatcher,
+                                            ASTNodeKind RestrictKind) {
   DynTypedMatcher Copy = InnerMatcher;
   Copy.RestrictKind = RestrictKind;
   return Copy;
 }
 
-DynTypedMatcher DynTypedMatcher::trueMatcher(
-    ast_type_traits::ASTNodeKind NodeKind) {
+DynTypedMatcher DynTypedMatcher::trueMatcher(ASTNodeKind NodeKind) {
   return DynTypedMatcher(NodeKind, NodeKind, &*TrueMatcherInstance);
 }
 
-bool DynTypedMatcher::canMatchNodesOfKind(
-    ast_type_traits::ASTNodeKind Kind) const {
+bool DynTypedMatcher::canMatchNodesOfKind(ASTNodeKind Kind) const {
   return RestrictKind.isBaseOf(Kind);
 }
 
-DynTypedMatcher DynTypedMatcher::dynCastTo(
-    const ast_type_traits::ASTNodeKind Kind) const {
+DynTypedMatcher DynTypedMatcher::dynCastTo(const ASTNodeKind Kind) const {
   auto Copy = *this;
   Copy.SupportedKind = Kind;
-  Copy.RestrictKind =
-      ast_type_traits::ASTNodeKind::getMostDerivedType(Kind, RestrictKind);
+  Copy.RestrictKind = ASTNodeKind::getMostDerivedType(Kind, RestrictKind);
   return Copy;
 }
 
-bool DynTypedMatcher::matches(const ast_type_traits::DynTypedNode &DynNode,
+bool DynTypedMatcher::matches(const DynTypedNode &DynNode,
                               ASTMatchFinder *Finder,
                               BoundNodesTreeBuilder *Builder) const {
   TraversalKindScope RAII(Finder->getASTContext(),
                           Implementation->TraversalKind());
 
   auto N =
       Finder->getASTContext().getParentMapContext().traverseIgnored(DynNode);
 
   if (RestrictKind.isBaseOf(N.getNodeKind()) &&
       Implementation->dynMatches(N, 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;
 }
 
-bool DynTypedMatcher::matchesNoKindCheck(
-    const ast_type_traits::DynTypedNode &DynNode, ASTMatchFinder *Finder,
+bool DynTypedMatcher::matchesNoKindCheck(const DynTypedNode &DynNode,
+                                         ASTMatchFinder *Finder,
                                          BoundNodesTreeBuilder *Builder) const {
   TraversalKindScope raii(Finder->getASTContext(),
                           Implementation->TraversalKind());
 
   auto N =
       Finder->getASTContext().getParentMapContext().traverseIgnored(DynNode);
 
   assert(RestrictKind.isBaseOf(N.getNodeKind()));
   if (Implementation->dynMatches(N, Finder, Builder)) {

 llvm::Optional<DynTypedMatcher> DynTypedMatcher::tryBind(StringRef ID) const {
   if (!AllowBind) return llvm::None;
   auto Result = *this;
   Result.Implementation =
       new IdDynMatcher(ID, std::move(Result.Implementation));
   return std::move(Result);
 }
 
-bool DynTypedMatcher::canConvertTo(ast_type_traits::ASTNodeKind To) const {
+bool DynTypedMatcher::canConvertTo(ASTNodeKind To) const {
   const auto From = getSupportedKind();
-  auto QualKind = ast_type_traits::ASTNodeKind::getFromNodeKind<QualType>();
-  auto TypeKind = ast_type_traits::ASTNodeKind::getFromNodeKind<Type>();
+  auto QualKind = ASTNodeKind::getFromNodeKind<QualType>();
+  auto TypeKind = 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,
+bool NotUnaryOperator(const 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,
+bool AllOfVariadicOperator(const 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.matchesNoKindCheck(DynNode, Finder, Builder))
       return false;
   }
   return true;
 }
 
-bool EachOfVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
-                            ASTMatchFinder *Finder,
+bool EachOfVariadicOperator(const 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,
+bool AnyOfVariadicOperator(const 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;
 }
 
-bool OptionallyVariadicOperator(const ast_type_traits::DynTypedNode &DynNode,
+bool OptionallyVariadicOperator(const DynTypedNode &DynNode,
                                 ASTMatchFinder *Finder,
                                 BoundNodesTreeBuilder *Builder,
                                 ArrayRef<DynTypedMatcher> InnerMatchers) {
   BoundNodesTreeBuilder Result;
   for (const DynTypedMatcher &InnerMatcher : InnerMatchers) {
     BoundNodesTreeBuilder BuilderInner(*Builder);
     if (InnerMatcher.matches(DynNode, Finder, &BuilderInner))
       Result.addMatch(BuilderInner);

clang/lib/ASTMatchers/Dynamic/Marshallers.h

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>());
+    return ArgKind(ASTNodeKind::getFromNodeKind<T>());
   }
 };
 
 template <> struct ArgTypeTraits<bool> {
   static bool is(const VariantValue &Value) { return Value.isBoolean(); }
 
   static bool get(const VariantValue &Value) {
     return Value.getBoolean();
public:
 
   /// 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,
+  virtual void getArgKinds(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;
+  virtual bool
+  isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity = nullptr,
+                  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) {
+inline bool isRetKindConvertibleTo(ArrayRef<ASTNodeKind> RetKinds,
+                                   ASTNodeKind Kind, unsigned *Specificity,
+                                   ASTNodeKind *LeastDerivedKind) {
+  for (const ASTNodeKind &NodeKind : RetKinds) {
     if (ArgKind(NodeKind).isConvertibleTo(Kind, Specificity)) {
       if (LeastDerivedKind)
         *LeastDerivedKind = NodeKind;
       return true;
     }
   }
   return false;
 }
using MarshallerType = VariantMatcher (*)(void (*Func)(),
                                             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,
+  FixedArgCountMatcherDescriptor(MarshallerType Marshaller, void (*Func)(),
+                                 StringRef MatcherName,
+                                 ArrayRef<ASTNodeKind> RetKinds,
                                  ArrayRef<ArgKind> ArgKinds)
       : Marshaller(Marshaller), Func(Func), MatcherName(MatcherName),
         RetKinds(RetKinds.begin(), RetKinds.end()),
         ArgKinds(ArgKinds.begin(), ArgKinds.end()) {}
 
   VariantMatcher create(SourceRange NameRange,
                         ArrayRef<ParserValue> Args,
                         Diagnostics *Error) const override {
     return Marshaller(Func, MatcherName, NameRange, Args, Error);
   }
 
   bool isVariadic() const override { return false; }
   unsigned getNumArgs() const override { return ArgKinds.size(); }
 
-  void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
+  void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
                    std::vector<ArgKind> &Kinds) const override {
     Kinds.push_back(ArgKinds[ArgNo]);
   }
 
-  bool isConvertibleTo(
-      ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
-      ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
+  bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
+                       ASTNodeKind *LeastDerivedKind) const override {
     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<ASTNodeKind> RetKinds;
   const std::vector<ArgKind> ArgKinds;
 };
 
 /// 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,
static VariantMatcher outvalueToVariantMatcher(const T &PolyMatcher,
                                                    nullptr) {
   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>());
+inline void
+buildReturnTypeVectorFromTypeList(std::vector<ASTNodeKind> &RetTypes) {
+  RetTypes.push_back(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) {}
+    std::vector<ASTNodeKind> &RetTypes) {}
 
 template <typename T>
 struct BuildReturnTypeVector {
-  static void build(std::vector<ast_type_traits::ASTNodeKind> &RetTypes) {
+  static void build(std::vector<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>());
+  static void build(std::vector<ASTNodeKind> &RetTypes) {
+    RetTypes.push_back(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>());
+  static void build(std::vector<ASTNodeKind> &RetTypes) {
+    RetTypes.push_back(ASTNodeKind::getFromNodeKind<T>());
   }
 };
 
 /// Variadic marshaller function.
 template <typename ResultT, typename ArgT,
           ResultT (*Func)(ArrayRef<const ArgT *>)>
 VariantMatcher
 variadicMatcherDescriptor(StringRef MatcherName, SourceRange NameRange,
VariantMatcher create(SourceRange NameRange,
                         ArrayRef<ParserValue> Args,
                         Diagnostics *Error) const override {
     return Func(MatcherName, NameRange, Args, Error);
   }
 
   bool isVariadic() const override { return true; }
   unsigned getNumArgs() const override { return 0; }
 
-  void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
+  void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
                    std::vector<ArgKind> &Kinds) const override {
     Kinds.push_back(ArgsKind);
   }
 
-  bool isConvertibleTo(
-      ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
-      ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
+  bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
+                       ASTNodeKind *LeastDerivedKind) const override {
     return isRetKindConvertibleTo(RetKinds, Kind, Specificity,
                                   LeastDerivedKind);
   }
 
 private:
   const RunFunc Func;
   const std::string MatcherName;
-  std::vector<ast_type_traits::ASTNodeKind> RetKinds;
+  std::vector<ASTNodeKind> RetKinds;
   const ArgKind ArgsKind;
 };
 
 /// 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>()) {
-  }
+        DerivedKind(ASTNodeKind::getFromNodeKind<DerivedT>()) {}
 
-  bool
-  isConvertibleTo(ast_type_traits::ASTNodeKind Kind, unsigned *Specificity,
-                ast_type_traits::ASTNodeKind *LeastDerivedKind) const override {
+  bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
+                       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;
+  const ASTNodeKind DerivedKind;
 };
 
 /// 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();                                                   \

 #ifndef NDEBUG
     for (const auto &O : Overloads) {
       assert(Overload0NumArgs == O->getNumArgs());
     }
 #endif
     return Overload0NumArgs;
   }
 
-  void getArgKinds(ast_type_traits::ASTNodeKind ThisKind, unsigned ArgNo,
+  void getArgKinds(ASTNodeKind ThisKind, unsigned ArgNo,
                    std::vector<ArgKind> &Kinds) const override {
     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 override {
+  bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
+                       ASTNodeKind *LeastDerivedKind) const override {
     for (const auto &O : Overloads) {
       if (O->isConvertibleTo(Kind, Specificity, LeastDerivedKind))
         return true;
     }
     return false;
   }
 
 private:
for (size_t i = 0, e = Args.size(); i != e; ++i) {
       InnerArgs.push_back(Value.getMatcher());
     }
     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,
+  void getArgKinds(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 {
+  bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity,
+                       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 VarOp Op;
   const StringRef MatcherName;
 };
 
 /// Helper functions to select the appropriate marshaller functions.
 /// They detect the number of arguments, arguments types and return type.
 
 /// 0-arg overload
 template <typename ReturnType>
 std::unique_ptr<MatcherDescriptor>
 makeMatcherAutoMarshall(ReturnType (*Func)(), StringRef MatcherName) {
-  std::vector<ast_type_traits::ASTNodeKind> RetTypes;
+  std::vector<ASTNodeKind> RetTypes;
   BuildReturnTypeVector<ReturnType>::build(RetTypes);
   return std::make_unique<FixedArgCountMatcherDescriptor>(
       matcherMarshall0<ReturnType>, reinterpret_cast<void (*)()>(Func),
       MatcherName, RetTypes, None);
 }
 
 /// 1-arg overload
 template <typename ReturnType, typename ArgType1>
 std::unique_ptr<MatcherDescriptor>
 makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1), StringRef MatcherName) {
-  std::vector<ast_type_traits::ASTNodeKind> RetTypes;
+  std::vector<ASTNodeKind> RetTypes;
   BuildReturnTypeVector<ReturnType>::build(RetTypes);
   ArgKind AK = ArgTypeTraits<ArgType1>::getKind();
   return std::make_unique<FixedArgCountMatcherDescriptor>(
       matcherMarshall1<ReturnType, ArgType1>,
       reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AK);
 }
 
 /// 2-arg overload
 template <typename ReturnType, typename ArgType1, typename ArgType2>
 std::unique_ptr<MatcherDescriptor>
 makeMatcherAutoMarshall(ReturnType (*Func)(ArgType1, ArgType2),
                         StringRef MatcherName) {
-  std::vector<ast_type_traits::ASTNodeKind> RetTypes;
+  std::vector<ASTNodeKind> RetTypes;
   BuildReturnTypeVector<ReturnType>::build(RetTypes);
   ArgKind AKs[] = { ArgTypeTraits<ArgType1>::getKind(),
                     ArgTypeTraits<ArgType2>::getKind() };
   return std::make_unique<FixedArgCountMatcherDescriptor>(
       matcherMarshall2<ReturnType, ArgType1, ArgType2>,
       reinterpret_cast<void (*)()>(Func), MatcherName, RetTypes, AKs);
 }
 

clang/lib/ASTMatchers/Dynamic/VariantValue.cpp

public:
   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 {
+  bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const override {
     return ArgKind(Matcher.getSupportedKind())
         .isConvertibleTo(Kind, Specificity);
   }
 
 private:
   const DynTypedMatcher Matcher;
 };
 
for (size_t i = 0, e = Matchers.size(); i != e; ++i) {
       }
     }
     // 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 {
+  bool isConvertibleTo(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);
       }
     }
std::string getTypeAsString() const override {
     return Inner;
   }
 
   llvm::Optional<DynTypedMatcher>
   getTypedMatcher(const MatcherOps &Ops) const override {
     return Ops.constructVariadicOperator(Op, Args);
   }
 
-  bool isConvertibleTo(ast_type_traits::ASTNodeKind Kind,
-                       unsigned *Specificity) const override {
+  bool isConvertibleTo(ASTNodeKind Kind, unsigned *Specificity) const override {
     for (const VariantMatcher &Matcher : Args) {
       if (!Matcher.isConvertibleTo(Kind, Specificity))
         return false;
     }
     return true;
   }
 
 private:

clang/lib/Tooling/ASTDiff/ASTDiff.cpp

for (SNodeId D1 = LMD1 + 1; D1 <= Id1; ++D1) {
                         ForestDist[D1][D2 - 1] + InsertionCost,
                         ForestDist[DLMD1][DLMD2] + TreeDist[D1][D2]});
         }
       }
     }
   }
 };
 
-ast_type_traits::ASTNodeKind Node::getType() const {
-  return ASTNode.getNodeKind();
-}
+ASTNodeKind Node::getType() const { return ASTNode.getNodeKind(); }
 
 StringRef Node::getTypeLabel() const { return getType().asStringRef(); }
 
 llvm::Optional<std::string> Node::getQualifiedIdentifier() const {
   if (auto *ND = ASTNode.get<NamedDecl>()) {
     if (ND->getDeclName().isIdentifier())
       return ND->getQualifiedNameAsString();
   }

clang/lib/Tooling/Refactoring/ASTSelection.cpp

 //===--- ASTSelection.cpp - Clang refactoring library ---------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Tooling/Refactoring/ASTSelection.h"
 #include "clang/AST/LexicallyOrderedRecursiveASTVisitor.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/Support/SaveAndRestore.h"
 
 using namespace clang;
 using namespace tooling;
-using ast_type_traits::DynTypedNode;
 
 namespace {
 
 CharSourceRange getLexicalDeclRange(Decl *D, const SourceManager &SM,
                                     const LangOptions &LangOpts) {
   if (!isa<ObjCImplDecl>(D))
     return CharSourceRange::getTokenRange(D->getSourceRange());
   // Objective-C implementation declarations end at the '@' instead of the 'end'

clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

if (const auto *TemplateSpecType =
 
         auto StartLoc = StartLocationForType(TargetLoc);
         auto EndLoc = EndLocationForType(TargetLoc);
         if (IsValidEditLoc(Context.getSourceManager(), StartLoc)) {
           RenameInfo Info = {
               StartLoc,
               EndLoc,
               TemplateSpecType->getTemplateName().getAsTemplateDecl(),
-              getClosestAncestorDecl(
-                  ast_type_traits::DynTypedNode::create(TargetLoc)),
+              getClosestAncestorDecl(DynTypedNode::create(TargetLoc)),
               GetNestedNameForType(TargetLoc),
               /*IgnorePrefixQualifers=*/false};
           RenameInfos.push_back(Info);
         }
       }
     }
     return true;
   }
private:
 
   // Get the closest ancester which is a declaration of a given AST node.
   template <typename ASTNodeType>
   const Decl *getClosestAncestorDecl(const ASTNodeType &Node) {
     auto Parents = Context.getParents(Node);
     // FIXME: figure out how to handle it when there are multiple parents.
     if (Parents.size() != 1)
       return nullptr;
-    if (ast_type_traits::ASTNodeKind::getFromNodeKind<Decl>().isBaseOf(
-            Parents[0].getNodeKind()))
+    if (ASTNodeKind::getFromNodeKind<Decl>().isBaseOf(Parents[0].getNodeKind()))
       return Parents[0].template get<Decl>();
     return getClosestAncestorDecl(Parents[0]);
   }
 
   // Get the parent typeLoc of a given typeLoc. If there is no such parent,
   // return nullptr.
   const TypeLoc *getParentTypeLoc(TypeLoc Loc) const {
     auto Parents = Context.getParents(Loc);

clang/lib/Tooling/Transformer/RangeSelector.cpp

 #include <string>
 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace transformer;
 
 using ast_matchers::MatchFinder;
-using ast_type_traits::ASTNodeKind;
-using ast_type_traits::DynTypedNode;
 using llvm::Error;
 using llvm::StringError;
 
 using MatchResult = MatchFinder::MatchResult;
 
 static Error invalidArgumentError(Twine Message) {
   return llvm::make_error<StringError>(llvm::errc::invalid_argument, Message);
 }

clang/lib/Tooling/Transformer/RewriteRule.cpp

 #include <utility>
 #include <vector>
 
 using namespace clang;
 using namespace transformer;
 
 using ast_matchers::MatchFinder;
 using ast_matchers::internal::DynTypedMatcher;
-using ast_type_traits::ASTNodeKind;
 
 using MatchResult = MatchFinder::MatchResult;
 
 Expected<SmallVector<transformer::detail::Transformation, 1>>
 transformer::detail::translateEdits(const MatchResult &Result,
                                 llvm::ArrayRef<ASTEdit> Edits) {
   SmallVector<transformer::detail::Transformation, 1> Transformations;
   for (const auto &Edit : Edits) {

clang/lib/Tooling/Transformer/Stencil.cpp

 #include <atomic>
 #include <memory>
 #include <string>
 
 using namespace clang;
 using namespace transformer;
 
 using ast_matchers::MatchFinder;
-using ast_type_traits::DynTypedNode;
 using llvm::errc;
 using llvm::Error;
 using llvm::Expected;
 using llvm::StringError;
 
 static llvm::Expected<DynTypedNode>
 getNode(const ast_matchers::BoundNodes &Nodes, StringRef Id) {
   auto &NodesMap = Nodes.getMap();

clang/unittests/AST/ASTContextParentMapTest.cpp

TEST(GetParents, RespectsTraversalScope) {
   auto AST =
       tooling::buildASTFromCode("struct foo { int bar; };", "foo.cpp",
                                 std::make_shared<PCHContainerOperations>());
   auto &Ctx = AST->getASTContext();
   auto &TU = *Ctx.getTranslationUnitDecl();
   auto &Foo = *TU.lookup(&Ctx.Idents.get("foo")).front();
   auto &Bar = *cast<DeclContext>(Foo).lookup(&Ctx.Idents.get("bar")).front();
 
-  using ast_type_traits::DynTypedNode;
   // Initially, scope is the whole TU.
   EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
   EXPECT_THAT(Ctx.getParents(Foo), ElementsAre(DynTypedNode::create(TU)));
 
   // Restrict the scope, now some parents are gone.
   Ctx.setTraversalScope({&Foo});
   EXPECT_THAT(Ctx.getParents(Bar), ElementsAre(DynTypedNode::create(Foo)));
   EXPECT_THAT(Ctx.getParents(Foo), ElementsAre());

clang/unittests/AST/ASTTraverserTest.cpp

template <typename... NodeType> std::string dumpASTString(NodeType &&... N) {
   OS << "\n";
 
   Dumper.Visit(std::forward<NodeType &&>(N)...);
 
   return OS.str();
 }
 
 template <typename... NodeType>
-std::string dumpASTString(ast_type_traits::TraversalKind TK, NodeType &&... N) {
+std::string dumpASTString(TraversalKind TK, NodeType &&... N) {
   std::string Buffer;
   llvm::raw_string_ostream OS(Buffer);
 
   TestASTDumper Dumper(OS);
   Dumper.SetTraversalKind(TK);
 
   OS << "\n";
 
   Dumper.Visit(std::forward<NodeType &&>(N)...);
 
   return OS.str();
 }
 
 const FunctionDecl *getFunctionNode(clang::ASTUnit *AST,
                                     const std::string &Name) {
   auto Result = ast_matchers::match(functionDecl(hasName(Name)).bind("fn"),
                                     AST->getASTContext());
   EXPECT_EQ(Result.size(), 1u);
   return Result[0].getNodeAs<FunctionDecl>("fn");
 }
 
 template <typename T> struct Verifier {
   static void withDynNode(T Node, const std::string &DumpString) {
-    EXPECT_EQ(dumpASTString(ast_type_traits::DynTypedNode::create(Node)),
-              DumpString);
+    EXPECT_EQ(dumpASTString(DynTypedNode::create(Node)), DumpString);
   }
 };
 
 template <typename T> struct Verifier<T *> {
   static void withDynNode(T *Node, const std::string &DumpString) {
-    EXPECT_EQ(dumpASTString(ast_type_traits::DynTypedNode::create(*Node)),
-              DumpString);
+    EXPECT_EQ(dumpASTString(DynTypedNode::create(*Node)), DumpString);
   }
 };
 
 template <typename T>
 void verifyWithDynNode(T Node, const std::string &DumpString) {
   EXPECT_EQ(dumpASTString(Node), DumpString);
 
   Verifier<T>::withDynNode(Node, DumpString);
)cpp");
 
   auto BN = ast_matchers::match(
       cxxConstructorDecl(hasName("MyStruct"),
                          hasParameter(0, parmVarDecl(hasType(isInteger()))))
           .bind("ctor"),
       AST->getASTContext());
   EXPECT_EQ(BN.size(), 1u);
 
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+  EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
                           BN[0].getNodeAs<Decl>("ctor")),
             R"cpp(
 CXXConstructorDecl 'MyStruct'
 |-ParmVarDecl 'i'
 `-CompoundStmt
   `-CXXTemporaryObjectExpr
 )cpp");
 
-  EXPECT_EQ(
-      dumpASTString(ast_type_traits::TK_AsIs, BN[0].getNodeAs<Decl>("ctor")),
+  EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("ctor")),
             R"cpp(
 CXXConstructorDecl 'MyStruct'
 |-ParmVarDecl 'i'
 `-CompoundStmt
   `-ExprWithCleanups
     `-CXXBindTemporaryExpr
       `-CXXTemporaryObjectExpr
 )cpp");
 }
void foo()
     someFun();
 }
 )cpp");
 
   auto BN = ast_matchers::match(functionDecl(hasName("foo")).bind("fn"),
                                 AST->getASTContext());
   EXPECT_EQ(BN.size(), 1u);
 
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+  EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
                           BN[0].getNodeAs<Decl>("fn")),
             R"cpp(
 FunctionDecl 'foo'
 `-CompoundStmt
   `-CallExpr
     `-DeclRefExpr 'someFun'
 )cpp");
 
-  EXPECT_EQ(
-      dumpASTString(ast_type_traits::TK_AsIs, BN[0].getNodeAs<Decl>("fn")),
+  EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("fn")),
             R"cpp(
 FunctionDecl 'foo'
 `-CompoundStmt
   `-ExprWithCleanups
     `-CXXBindTemporaryExpr
       `-CallExpr
         `-ImplicitCastExpr
           `-DeclRefExpr 'someFun'
 )cpp");
`-ReturnStmt
     `-ExprWithCleanups
       `-CXXConstructExpr
         `-MaterializeTemporaryExpr
           `-ImplicitCastExpr
             `-CXXConstructExpr
               `-IntegerLiteral
 )cpp";
 
-    EXPECT_EQ(dumpASTString(ast_type_traits::TK_AsIs, FN), Expected);
+    EXPECT_EQ(dumpASTString(TK_AsIs, FN), Expected);
 
     Expected = R"cpp(
 FunctionDecl 'func1'
 `-CompoundStmt
   `-ReturnStmt
     `-IntegerLiteral
 )cpp";
-    EXPECT_EQ(
-        dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, FN),
-        Expected);
+    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, FN), Expected);
   }
 
   llvm::StringRef Expected = R"cpp(
 FunctionDecl 'func2'
 `-CompoundStmt
   `-ReturnStmt
     `-CXXTemporaryObjectExpr
       `-IntegerLiteral
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func2")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func2")),
 
   Expected = R"cpp(
 FunctionDecl 'func3'
 `-CompoundStmt
   `-ReturnStmt
     `-CXXFunctionalCastExpr
       `-IntegerLiteral
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func3")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func3")),
 
   Expected = R"cpp(
 FunctionDecl 'func4'
 `-CompoundStmt
   `-ReturnStmt
     `-CXXTemporaryObjectExpr
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func4")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func4")),
 
   Expected = R"cpp(
 FunctionDecl 'func5'
 `-CompoundStmt
   `-ReturnStmt
     `-CXXTemporaryObjectExpr
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func5")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func5")),
 
   Expected = R"cpp(
 FunctionDecl 'func6'
 `-CompoundStmt
   `-ReturnStmt
     `-CXXTemporaryObjectExpr
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func6")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func6")),
 
   Expected = R"cpp(
 FunctionDecl 'func7'
 `-CompoundStmt
   `-ReturnStmt
     `-CXXTemporaryObjectExpr
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func7")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func7")),
 
   Expected = R"cpp(
 FunctionDecl 'func8'
 `-CompoundStmt
   `-ReturnStmt
     `-CXXFunctionalCastExpr
       `-InitListExpr
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func8")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func8")),
 
   Expected = R"cpp(
 FunctionDecl 'func9'
 `-CompoundStmt
   `-ReturnStmt
     `-CXXFunctionalCastExpr
       `-InitListExpr
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func9")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func9")),
 
   Expected = R"cpp(
 FunctionDecl 'func10'
 `-CompoundStmt
   |-DeclStmt
   | `-VarDecl 'a'
   |   `-CXXConstructExpr
   `-ReturnStmt
     `-DeclRefExpr 'a'
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func10")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func10")),
 
   Expected = R"cpp(
 FunctionDecl 'func11'
 `-CompoundStmt
   |-DeclStmt
   | `-VarDecl 'b'
   |   `-CXXConstructExpr
   `-ReturnStmt
     `-DeclRefExpr 'b'
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func11")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func11")),
 
   Expected = R"cpp(
 FunctionDecl 'func12'
 `-CompoundStmt
   |-DeclStmt
   | `-VarDecl 'c'
   |   `-CXXConstructExpr
   `-ReturnStmt
     `-DeclRefExpr 'c'
 )cpp";
-  EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                          getFunctionNode("func12")),
-            Expected);
+  EXPECT_EQ(
+      dumpASTString(TK_IgnoreUnlessSpelledInSource, getFunctionNode("func12")),
 }
 
 TEST(Traverse, LambdaUnlessSpelledInSource) {
 
   auto AST =
       buildASTFromCodeWithArgs(R"cpp(
 
 void captures() {

 | `-DeclRefExpr 'd'
 |-VarDecl 'e'
 | `-DeclRefExpr 'f'
 |-ParmVarDecl 'g'
 |-ParmVarDecl 'h'
 | `-IntegerLiteral
 `-CompoundStmt
 )cpp";
-    EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L),
-              Expected);
+    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
 
     Expected = R"cpp(
 LambdaExpr
 |-CXXRecordDecl ''
 | |-CXXMethodDecl 'operator()'
 | | |-ParmVarDecl 'g'
 | | |-ParmVarDecl 'h'
 | | | `-IntegerLiteral
 | | `-CompoundStmt
 | |-FieldDecl ''
 | |-FieldDecl ''
 | |-FieldDecl ''
 | |-FieldDecl ''
 | `-CXXDestructorDecl '~'
 |-ImplicitCastExpr
 | `-DeclRefExpr 'a'
 |-DeclRefExpr 'b'
 |-ImplicitCastExpr
 | `-DeclRefExpr 'd'
 |-DeclRefExpr 'f'
 `-CompoundStmt
 )cpp";
-    EXPECT_EQ(dumpASTString(ast_type_traits::TK_AsIs, L), Expected);
+    EXPECT_EQ(dumpASTString(TK_AsIs, L), Expected);
   }
 
   {
     auto L = getLambdaNode("templated");
 
     llvm::StringRef Expected = R"cpp(
 LambdaExpr
 |-DeclRefExpr 'a'
 |-TemplateTypeParmDecl 'T'
 |-ParmVarDecl 't'
 `-CompoundStmt
 )cpp";
-    EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L),
-              Expected);
+    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
   }
 
   {
     auto L = getLambdaNode("capture_this");
 
     llvm::StringRef Expected = R"cpp(
 LambdaExpr
 |-CXXThisExpr
 `-CompoundStmt
 )cpp";
-    EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L),
-              Expected);
+    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
   }
 
   {
     auto L = getLambdaNode("capture_this_copy");
 
     llvm::StringRef Expected = R"cpp(
 LambdaExpr
 |-VarDecl 'self'
 | `-UnaryOperator
 |   `-CXXThisExpr
 `-CompoundStmt
 )cpp";
-    EXPECT_EQ(dumpASTString(ast_type_traits::TK_IgnoreUnlessSpelledInSource, L),
-              Expected);
+    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
   }
 }
 
 } // namespace clang

clang/unittests/AST/MatchVerifier.h

void MatchVerifier<NodeType>::run(const MatchFinder::MatchResult &Result) {
   } else {
     // Callback has been called, default to success.
     setSuccess();
     verify(Result, *Node);
   }
 }
 
 template <>
-inline void MatchVerifier<ast_type_traits::DynTypedNode>::run(
-    const MatchFinder::MatchResult &Result) {
+inline void
+MatchVerifier<DynTypedNode>::run(const MatchFinder::MatchResult &Result) {
   BoundNodes::IDToNodeMap M = Result.Nodes.getMap();
   BoundNodes::IDToNodeMap::const_iterator I = M.find("");
   if (I == M.end()) {
     setFailure("Node was not bound");
   } else {
     // Callback has been called, default to success.
     setSuccess();
     verify(Result, I->second);
virtual SourceRange getRange(const NodeType &Node) {
     return Node.getSourceRange();
   }
 
 private:
   unsigned ExpectBeginLine, ExpectBeginColumn, ExpectEndLine, ExpectEndColumn;
 };
 
 /// \brief Verify whether a node's dump contains a given substring.
-class DumpVerifier : public MatchVerifier<ast_type_traits::DynTypedNode> {
+class DumpVerifier : public MatchVerifier<DynTypedNode> {
 public:
   void expectSubstring(const std::string &Str) {
     ExpectSubstring = Str;
   }
 
 protected:
   void verify(const MatchFinder::MatchResult &Result,
-              const ast_type_traits::DynTypedNode &Node) override {
+              const DynTypedNode &Node) override {
     std::string DumpStr;
     llvm::raw_string_ostream Dump(DumpStr);
     Node.dump(Dump, *Result.SourceManager);
 
     if (Dump.str().find(ExpectSubstring) == std::string::npos) {
       std::string MsgStr;
       llvm::raw_string_ostream Msg(MsgStr);
       Msg << "Expected dump substring <" << ExpectSubstring << ">, found <"
           << Dump.str() << '>';
       this->setFailure(Msg.str());
     }
   }
 
 private:
   std::string ExpectSubstring;
 };
 
 /// \brief Verify whether a node's pretty print matches a given string.
-class PrintVerifier : public MatchVerifier<ast_type_traits::DynTypedNode> {
+class PrintVerifier : public MatchVerifier<DynTypedNode> {
 public:
   void expectString(const std::string &Str) {
     ExpectString = Str;
   }
 
 protected:
   void verify(const MatchFinder::MatchResult &Result,
-              const ast_type_traits::DynTypedNode &Node) override {
+              const DynTypedNode &Node) override {
     std::string PrintStr;
     llvm::raw_string_ostream Print(PrintStr);
     Node.print(Print, Result.Context->getPrintingPolicy());
 
     if (Print.str() != ExpectString) {
       std::string MsgStr;
       llvm::raw_string_ostream Msg(MsgStr);
       Msg << "Expected pretty print <" << ExpectString << ">, found <"

clang/unittests/ASTMatchers/ASTMatchersInternalTest.cpp

ASSERT_DEBUG_DEATH({
       DeclarationMatcher HasEmptyName = recordDecl(matchesName(""));
       EXPECT_TRUE(notMatches("class X {};", HasEmptyName));
     }, "");
 }
 #endif
 
 TEST(ConstructVariadic, MismatchedTypes_Regression) {
   EXPECT_TRUE(
-      matches("const int a = 0;",
-              internal::DynTypedMatcher::constructVariadic(
+      matches("const int a = 0;", internal::DynTypedMatcher::constructVariadic(
                                       internal::DynTypedMatcher::VO_AnyOf,
-                  ast_type_traits::ASTNodeKind::getFromNodeKind<QualType>(),
+                                      ASTNodeKind::getFromNodeKind<QualType>(),
                                       {isConstQualified(), arrayType()})
                                       .convertTo<QualType>()));
 }
 
 // For testing AST_MATCHER_P().
 AST_MATCHER_P(Decl, just, internal::Matcher<Decl>, AMatcher) {
   // Make sure all special variables are used: node, match_finder,
   // bound_nodes_builder, and the parameter named 'AMatcher'.
   return AMatcher.matches(Node, Finder, Builder);
 }
EXPECT_TRUE(matchAndVerifyResultFalse("class A { class C {}; };",
       HasClassB, std::make_unique<VerifyIdIsBoundTo<Decl>>("b")));
 }
 
 AST_POLYMORPHIC_MATCHER_P(polymorphicHas,
                           AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt),
                           internal::Matcher<Decl>, AMatcher) {
   return Finder->matchesChildOf(
       Node, AMatcher, Builder,
-      ast_type_traits::TraversalKind::TK_IgnoreImplicitCastsAndParentheses,
+      TraversalKind::TK_IgnoreImplicitCastsAndParentheses,
       ASTMatchFinder::BK_First);
 }
 
 TEST(AstPolymorphicMatcherPMacro, Works) {
   DeclarationMatcher HasClassB =
       polymorphicHas(recordDecl(hasName("B")).bind("b"));
 
   EXPECT_TRUE(matchAndVerifyResultTrue("class A { class B {}; };",

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

 void foo()
 {
   int i = 3.0;
 }
 )cpp";
 
   auto Matcher = varDecl(hasInitializer(floatLiteral()));
 
-  EXPECT_TRUE(
-      notMatches(VarDeclCode, traverse(ast_type_traits::TK_AsIs, Matcher)));
-  EXPECT_TRUE(
-      matches(VarDeclCode,
-              traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
-                       Matcher)));
+  EXPECT_TRUE(notMatches(VarDeclCode, traverse(TK_AsIs, Matcher)));
+  EXPECT_TRUE(matches(VarDeclCode,
+                      traverse(TK_IgnoreImplicitCastsAndParentheses, Matcher)));
 
   auto ParentMatcher = floatLiteral(hasParent(varDecl(hasName("i"))));
 
-  EXPECT_TRUE(notMatches(VarDeclCode,
-                         traverse(ast_type_traits::TK_AsIs, ParentMatcher)));
+  EXPECT_TRUE(notMatches(VarDeclCode, traverse(TK_AsIs, ParentMatcher)));
   EXPECT_TRUE(matches(VarDeclCode,
-                      traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                               ParentMatcher)));
+                      traverse(TK_IgnoreUnlessSpelledInSource, ParentMatcher)));
 
-  EXPECT_TRUE(
-      matches(VarDeclCode, decl(traverse(ast_type_traits::TK_AsIs,
-                                         anyOf(cxxRecordDecl(), varDecl())))));
+  EXPECT_TRUE(matches(
+      VarDeclCode, decl(traverse(TK_AsIs, anyOf(cxxRecordDecl(), varDecl())))));
 
-  EXPECT_TRUE(matches(VarDeclCode,
-                      floatLiteral(traverse(ast_type_traits::TK_AsIs,
-                                            hasParent(implicitCastExpr())))));
+  EXPECT_TRUE(
+      matches(VarDeclCode,
+              floatLiteral(traverse(TK_AsIs, hasParent(implicitCastExpr())))));
 
-  EXPECT_TRUE(matches(
-      VarDeclCode,
-      floatLiteral(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+  EXPECT_TRUE(
+      matches(VarDeclCode, floatLiteral(traverse(TK_IgnoreUnlessSpelledInSource,
                                                  hasParent(varDecl())))));
 
   EXPECT_TRUE(
-      matches(VarDeclCode,
-              varDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      matches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                             unless(parmVarDecl())))));
 
-  EXPECT_TRUE(notMatches(
-      VarDeclCode,
-      varDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+  EXPECT_TRUE(
+      notMatches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                                has(implicitCastExpr())))));
 
-  EXPECT_TRUE(matches(VarDeclCode, varDecl(traverse(ast_type_traits::TK_AsIs,
-                                                    has(implicitCastExpr())))));
+  EXPECT_TRUE(matches(VarDeclCode,
+                      varDecl(traverse(TK_AsIs, has(implicitCastExpr())))));
 
   EXPECT_TRUE(matches(
-      VarDeclCode,
-      traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-        // The has() below strips away the ImplicitCastExpr before the
-        // traverse(AsIs) gets to process it.
-        varDecl(has(traverse(ast_type_traits::TK_AsIs, floatLiteral()))))));
+      VarDeclCode, traverse(TK_IgnoreUnlessSpelledInSource,
+                            // The has() below strips away the ImplicitCastExpr
+                            // before the traverse(AsIs) gets to process it.
+                            varDecl(has(traverse(TK_AsIs, floatLiteral()))))));
+
+  EXPECT_TRUE(
+      matches(VarDeclCode, functionDecl(traverse(TK_AsIs, hasName("foo")))));
 
   EXPECT_TRUE(matches(
       VarDeclCode,
-      functionDecl(traverse(ast_type_traits::TK_AsIs, hasName("foo")))));
+      functionDecl(traverse(TK_IgnoreUnlessSpelledInSource, hasName("foo")))));
 
   EXPECT_TRUE(matches(
-      VarDeclCode,
-      functionDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                            hasName("foo")))));
+      VarDeclCode, functionDecl(traverse(TK_AsIs, hasAnyName("foo", "bar")))));
 
   EXPECT_TRUE(
-      matches(VarDeclCode, functionDecl(traverse(ast_type_traits::TK_AsIs,
-                                                 hasAnyName("foo", "bar")))));
-
-  EXPECT_TRUE(matches(
-      VarDeclCode,
-      functionDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      matches(VarDeclCode, functionDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                                  hasAnyName("foo", "bar")))));
 
   const char *Code = R"cpp(
 void foo(int a)
 {
   int i = 3.0 + a;
 }
 void bar()
 {
   foo(7.0);
 }
 )cpp";
   EXPECT_TRUE(
-      matches(Code,
-              callExpr(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      matches(Code, callExpr(traverse(TK_IgnoreUnlessSpelledInSource,
                                       hasArgument(0, floatLiteral())))));
 
   EXPECT_TRUE(
-      matches(Code,
-              callExpr(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      matches(Code, callExpr(traverse(TK_IgnoreUnlessSpelledInSource,
                                       hasAnyArgument(floatLiteral())))));
 
   EXPECT_TRUE(
-      matches(VarDeclCode,
-              varDecl(traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      matches(VarDeclCode, varDecl(traverse(TK_IgnoreUnlessSpelledInSource,
                                             hasType(builtinType())))));
 
-  EXPECT_TRUE(matches(
-      VarDeclCode,
-      functionDecl(hasName("foo"), traverse(ast_type_traits::TK_AsIs,
-                                            hasDescendant(floatLiteral())))));
+  EXPECT_TRUE(
+      matches(VarDeclCode,
+              functionDecl(hasName("foo"),
+                           traverse(TK_AsIs, hasDescendant(floatLiteral())))));
 
-  EXPECT_TRUE(notMatches(Code, traverse(ast_type_traits::TK_AsIs,
-                                        floatLiteral(hasParent(callExpr(callee(
-                                            functionDecl(hasName("foo")))))))));
-  EXPECT_TRUE(
-      matches(Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                             floatLiteral(hasParent(callExpr(
-                                 callee(functionDecl(hasName("foo")))))))));
+  EXPECT_TRUE(notMatches(
+      Code, traverse(TK_AsIs, floatLiteral(hasParent(callExpr(
+                                  callee(functionDecl(hasName("foo")))))))));
+  EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
 
   Code = R"cpp(
 void foo()
 {
   int i = (3);
 }
 )cpp";
-  EXPECT_TRUE(
-      matches(Code,
-              traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
-                       varDecl(hasInitializer(integerLiteral(equals(3)))))));
+  EXPECT_TRUE(matches(
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
   EXPECT_TRUE(matches(
       Code,
-      traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      traverse(TK_IgnoreUnlessSpelledInSource,
                integerLiteral(equals(3), hasParent(varDecl(hasName("i")))))));
 
   Code = R"cpp(
 const char *SomeString{"str"};
 )cpp";
-  EXPECT_TRUE(matches(Code, traverse(ast_type_traits::TK_AsIs,
-                                     stringLiteral(hasParent(implicitCastExpr(
+  EXPECT_TRUE(
+      matches(Code, traverse(TK_AsIs, stringLiteral(hasParent(implicitCastExpr(
                                           hasParent(initListExpr())))))));
   EXPECT_TRUE(
-      matches(Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                              stringLiteral(hasParent(initListExpr())))));
 }
 
 template <typename MatcherT>
 bool matcherTemplateWithBinding(StringRef Code, const MatcherT &M) {
   return matchAndVerifyResultTrue(
       std::string(Code), M.bind("matchedStmt"),
       std::make_unique<VerifyIdIsBoundTo<ReturnStmt>>("matchedStmt", 1));
 }
 
 TEST(Traversal, traverseWithBinding) {
   // Some existing matcher code expects to take a matcher as a
   // template arg and bind to it.  Verify that that works.
 
   llvm::StringRef Code = R"cpp(
 int foo()
 {
   return 42.0;
 }
 )cpp";
   EXPECT_TRUE(matcherTemplateWithBinding(
-      Code,
-      traverse(ast_type_traits::TK_AsIs,
+      Code, traverse(TK_AsIs,
                      returnStmt(has(implicitCastExpr(has(floatLiteral())))))));
 }
 
 TEST(Traversal, traverseMatcherNesting) {
 
   const char *Code = R"cpp(
 float bar(int i)
 {
   return i;
 }
 
 void foo()
 {
   bar(bar(3.0));
 }
 )cpp";
 
-  EXPECT_TRUE(matches(
-      Code,
-      traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
+  EXPECT_TRUE(
+      matches(Code, traverse(TK_IgnoreImplicitCastsAndParentheses,
                              callExpr(has(callExpr(traverse(
-                   ast_type_traits::TK_AsIs,
-                   callExpr(has(implicitCastExpr(has(floatLiteral())))))))))));
+                                 TK_AsIs, callExpr(has(implicitCastExpr(
+                                              has(floatLiteral())))))))))));
 }
 
 TEST(Traversal, traverseMatcherThroughImplicit) {
   const char *Code = R"cpp(
 struct S {
   S(int x);
 };
 
 void constructImplicit() {
   int a = 8;
   S s(a);
 }
   )cpp";
 
-  auto Matcher = traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
-                          implicitCastExpr());
+  auto Matcher =
+      traverse(TK_IgnoreImplicitCastsAndParentheses, implicitCastExpr());
 
   // Verfiy that it does not segfault
   EXPECT_FALSE(matches(Code, Matcher));
 }
 
 TEST(Traversal, traverseMatcherThroughMemoization) {
 
   const char *Code = R"cpp(
 void foo()
 {
   int i = 3.0;
 }
   )cpp";
 
   auto Matcher = varDecl(hasInitializer(floatLiteral()));
 
   // Matchers such as hasDescendant memoize their result regarding AST
   // nodes. In the matcher below, the first use of hasDescendant(Matcher)
   // fails, and the use of it inside the traverse() matcher should pass
   // causing the overall matcher to be a true match.
   // This test verifies that the first false result is not re-used, which
   // would cause the overall matcher to be incorrectly false.
 
   EXPECT_TRUE(matches(
-      Code, functionDecl(anyOf(
-                hasDescendant(Matcher),
-                traverse(ast_type_traits::TK_IgnoreImplicitCastsAndParentheses,
+      Code,
+      functionDecl(anyOf(hasDescendant(Matcher),
+                         traverse(TK_IgnoreImplicitCastsAndParentheses,
                                   functionDecl(hasDescendant(Matcher)))))));
 }
 
 TEST(Traversal, traverseUnlessSpelledInSource) {
 
   const char *Code = R"cpp(
 
 struct A
 {

 void func14() {
   [] <typename TemplateType> (TemplateType t, TemplateType u) { int e = t + u; };
   float i = 42.0;
 }
 
 )cpp";
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func1"))),
                                 hasReturnValue(integerLiteral(equals(42)))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      integerLiteral(equals(42),
                                     hasParent(returnStmt(forFunction(
                                         functionDecl(hasName("func1")))))))));
 
   EXPECT_TRUE(matches(
       Code,
-      traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      traverse(TK_IgnoreUnlessSpelledInSource,
                returnStmt(forFunction(functionDecl(hasName("func2"))),
                           hasReturnValue(cxxTemporaryObjectExpr(
                               hasArgument(0, integerLiteral(equals(42)))))))));
   EXPECT_TRUE(matches(
       Code,
-      traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      traverse(TK_IgnoreUnlessSpelledInSource,
                integerLiteral(
                    equals(42),
                    hasParent(cxxTemporaryObjectExpr(hasParent(returnStmt(
                        forFunction(functionDecl(hasName("func2")))))))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func3"))),
                                 hasReturnValue(
                                     cxxFunctionalCastExpr(hasSourceExpression(
                                         integerLiteral(equals(42)))))))));
 
   EXPECT_TRUE(matches(
       Code,
-      traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      traverse(TK_IgnoreUnlessSpelledInSource,
                integerLiteral(
                    equals(42),
                    hasParent(cxxFunctionalCastExpr(hasParent(returnStmt(
                        forFunction(functionDecl(hasName("func3")))))))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func4"))),
                                 hasReturnValue(cxxTemporaryObjectExpr())))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func5"))),
                                 hasReturnValue(cxxTemporaryObjectExpr())))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func6"))),
                                 hasReturnValue(cxxTemporaryObjectExpr())))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func7"))),
                                 hasReturnValue(cxxTemporaryObjectExpr())))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func8"))),
                                 hasReturnValue(cxxFunctionalCastExpr(
                                     hasSourceExpression(initListExpr())))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func9"))),
                                 hasReturnValue(cxxFunctionalCastExpr(
                                     hasSourceExpression(initListExpr())))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func10"))),
                                 hasReturnValue(
                                     declRefExpr(to(varDecl(hasName("a")))))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      declRefExpr(to(varDecl(hasName("a"))),
                                  hasParent(returnStmt(forFunction(
                                      functionDecl(hasName("func10")))))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func11"))),
                                 hasReturnValue(
                                     declRefExpr(to(varDecl(hasName("b")))))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      declRefExpr(to(varDecl(hasName("b"))),
                                  hasParent(returnStmt(forFunction(
                                      functionDecl(hasName("func11")))))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      returnStmt(forFunction(functionDecl(hasName("func12"))),
                                 hasReturnValue(
                                     declRefExpr(to(varDecl(hasName("c")))))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      declRefExpr(to(varDecl(hasName("c"))),
                                  hasParent(returnStmt(forFunction(
                                      functionDecl(hasName("func12")))))))));
 
   EXPECT_TRUE(matches(
       Code,
       traverse(
-          ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+          TK_IgnoreUnlessSpelledInSource,
           lambdaExpr(forFunction(functionDecl(hasName("func13"))),
                      has(compoundStmt(hasDescendant(varDecl(hasName("e"))))),
                      has(declRefExpr(to(varDecl(hasName("a"))))),
                      has(varDecl(hasName("b"), hasInitializer(declRefExpr(to(
                                                    varDecl(hasName("c"))))))),
                      has(parmVarDecl(hasName("d")))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      declRefExpr(to(varDecl(hasName("a"))),
                                  hasParent(lambdaExpr(forFunction(
                                      functionDecl(hasName("func13")))))))));
 
   EXPECT_TRUE(matches(
       Code,
-      traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      traverse(TK_IgnoreUnlessSpelledInSource,
                varDecl(hasName("b"),
                        hasInitializer(declRefExpr(to(varDecl(hasName("c"))))),
                        hasParent(lambdaExpr(
                            forFunction(functionDecl(hasName("func13")))))))));
 
   EXPECT_TRUE(matches(
-      Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      Code, traverse(TK_IgnoreUnlessSpelledInSource,
                      lambdaExpr(
                          forFunction(functionDecl(hasName("func14"))),
                          has(templateTypeParmDecl(hasName("TemplateType")))))));
 
   EXPECT_TRUE(
-      matches(Code, traverse(ast_type_traits::TK_IgnoreUnlessSpelledInSource,
+      matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
                              functionDecl(hasName("func14"),
                                           hasDescendant(floatLiteral())))));
 }
 
 TEST(IgnoringImpCasts, MatchesImpCasts) {
   // This test checks that ignoringImpCasts matches when implicit casts are
   // present and its inner matcher alone does not match.
   // Note that this test creates an implicit const cast.