Remove the IgnoreImplicitCastsAndParentheses traversal kind

[aaron.ballman]

LGTM aside from a documentation request, thank you for this cleanup!

clang/docs/ReleaseNotes.rst

237

Can you add a similar note in clang-tools-extra/docs/ReleaseNotes.rst for the change in clang-query?

clang-tools-extra/clang-query/QueryParser.cpp

 }
 
 QueryRef QueryParser::parseSetTraversalKind(
     ast_type_traits::TraversalKind QuerySession::*Var) {
   StringRef ValStr;
   unsigned Value =
       LexOrCompleteWord<unsigned>(this, ValStr)
           .Case("AsIs", ast_type_traits::TK_AsIs)
-          .Case("IgnoreImplicitCastsAndParentheses",
-                ast_type_traits::TK_IgnoreImplicitCastsAndParentheses)
           .Case("IgnoreUnlessSpelledInSource",
                 ast_type_traits::TK_IgnoreUnlessSpelledInSource)
           .Default(~0u);
   if (Value == ~0u) {
     return new InvalidQuery("expected traversal kind, got '" + ValStr + "'");
   }
   return new SetQuery<ast_type_traits::TraversalKind>(
       Var, static_cast<ast_type_traits::TraversalKind>(Value));

clang-tools-extra/docs/ReleaseNotes.rst

 Improvements to clang-doc
 -------------------------
 
 The improvements are...
 
 Improvements to clang-query
 ---------------------------
 
-The improvements are...
+- The IgnoreImplicitCastsAndParentheses traversal mode has been removed.
 
 Improvements to clang-rename
 ----------------------------
 
 The improvements are...
 
 Improvements to clang-tidy
 --------------------------

clang/docs/ReleaseNotes.rst

 
 AST Matchers
 ------------
 
 - The behavior of TK_IgnoreUnlessSpelledInSource with the traverse() matcher
   has been changed to no longer match on template instantiations or on
   implicit nodes which are not spelled in the source.
 
+- The TK_IgnoreImplicitCastsAndParentheses traversal kind was removed. It
+  is recommended to use TK_IgnoreUnlessSpelledInSource instead.
+
 - The behavior of the forEach() matcher was changed to not internally ignore
   implicit and parenthesis nodes.
 
 clang-format
 ------------
 
 - Option ``BitFieldColonSpacing`` has been added that decides how
   space should be added around identifier, colon and bit-width in

clang/include/clang/AST/ASTNodeTraverser.h

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 TK_AsIs:
           break;
-        case TK_IgnoreImplicitCastsAndParentheses:
-          S = E->IgnoreParenImpCasts();
-          break;
         case TK_IgnoreUnlessSpelledInSource:
           S = E->IgnoreUnlessSpelledInSource();
           break;
         }
       }
 
       getNodeDelegate().Visit(S);
 

clang/include/clang/AST/ASTTypeTraits.h

 struct PrintingPolicy;
 
 /// 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()
-  TK_IgnoreImplicitCastsAndParentheses,
-
   /// Ignore AST nodes not written in the source
   TK_IgnoreUnlessSpelledInSource
 };
 
 /// Kind identifier.
 ///
 /// It can be constructed from any node kind and allows for runtime type
 /// hierarchy checks.

 // 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 {
 

clang/lib/AST/ParentMapContext.cpp

 
 Expr *ParentMapContext::traverseIgnored(Expr *E) const {
   if (!E)
     return nullptr;
 
   switch (Traversal) {
   case TK_AsIs:
     return E;
-  case TK_IgnoreImplicitCastsAndParentheses:
-    return E->IgnoreParenImpCasts();
   case TK_IgnoreUnlessSpelledInSource:
     return E->IgnoreUnlessSpelledInSource();
   }
   llvm_unreachable("Invalid Traversal type!");
 }
 
 DynTypedNode ParentMapContext::traverseIgnored(const DynTypedNode &N) const {
   if (const auto *E = N.get<Expr>()) {