Revert AST Matchers default to AsIs mode

[steveire]

Update

[steveire]

Update

[klimek]

lg

[aaron.ballman]

LG, but should this also update the release notes to remove the mention about the new default?

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

OS << "Available commands:\n\n"
         "as part of other expressions.\n"
         "  set bind-root (true|false)        "
         "Set whether to bind the root matcher to \"root\".\n"
         "  set print-matcher (true|false)    "
         "Set whether to print the current matcher,\n"
         "  set traversal <kind>              "
         "Set traversal kind of clang-query session. Available kinds are:\n"
         "    AsIs                            "
-        "Print and match the AST as clang sees it.\n"
+        "Print and match the AST as clang sees it.  This mode is the "
+        "default.\n"
         "    IgnoreImplicitCastsAndParentheses  "
         "Omit implicit casts and parens in matching and dumping.\n"
         "    IgnoreUnlessSpelledInSource     "
-        "Omit AST nodes unless spelled in the source.  This mode is the "
-        "default.\n"
+        "Omit AST nodes unless spelled in the source.\n"
         "  set output <feature>              "
         "Set whether to output only <feature> content.\n"
         "  enable output <feature>           "
         "Enable <feature> content non-exclusively.\n"
         "  disable output <feature>          "
         "Disable <feature> content non-exclusively.\n"
         "  quit, q                           "
         "Terminates the query session.\n\n"

clang-tools-extra/clang-query/QuerySession.h

 namespace query {
 
 /// Represents the state for a particular clang-query session.
 class QuerySession {
 public:
   QuerySession(llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs)
       : ASTs(ASTs), PrintOutput(false), DiagOutput(true),
         DetailedASTOutput(false), BindRoot(true), PrintMatcher(false),
-        Terminate(false), TK(ast_type_traits::TK_IgnoreUnlessSpelledInSource) {}
+        Terminate(false), TK(ast_type_traits::TK_AsIs) {}
 
   llvm::ArrayRef<std::unique_ptr<ASTUnit>> ASTs;
 
   bool PrintOutput;
   bool DiagOutput;
   bool DetailedASTOutput;
 
   bool BindRoot;

clang/docs/ReleaseNotes.rst

- clang-tidy and clang-include-fixer are no longer compiled into libclang by
   default. You can set ``LIBCLANG_INCLUDE_CLANG_TOOLS_EXTRA=ON`` to undo that,
   but it's expected that that setting will go away eventually. If this is
   something you need, please reach out to the mailing list to discuss possible
   ways forward.
 
 AST Matchers
 ------------
 
-- Traversal in AST Matchers was simplified to use the
-  ``TK_IgnoreUnlessSpelledInSource`` mode by default, instead of ``TK_AsIs``.
-  This means that many uses of the ``ignoringImplicit()`` and similar matchers
-  is no longer necessary.  Clients of AST Matchers which wish to match on
-  implicit AST nodes can wrap their matcher in ``traverse(TK_AsIs, ...)`` or
-  use ``TraversalKindScope`` if appropriate.  The ``clang-query`` tool also
-  uses ``IgnoreUnlessSpelledInSource`` by default.  The mode can be changed
-  using ``set traversal AsIs`` in the ``clang-query`` environment.
-
-  As this change requires downstream tools which use AST Matchers to adapt
-  to the new default, a porting guide may be useful for downstream tools
-  needing to adapt.
-
-  Note that although there are many steps below, only the first is
-  non-optional. The steps are intentionally extemely granular to facilitate
-  understanding of the guide itself. It is reasonable to do some of the
-  steps at the same time if you understand the guide:
-
-  1. Use ``(your ASTContext instance).getParentMapContext().setTraversalKind(TK_AsIs)``
-     to restore the previous behavior for your tool.  All further steps in
-     this porting guide are optional.
-  2. Wrap your existing matcher expressions with ``traverse(TK_AsIs, ...)``
-     before passing them to ``ASTMatchFinder::addMatcher``.
-  3. Remove ``(your ASTContext instance).getParentMapContext().setTraversalKind(TK_AsIs)``
-     from your tool so that the default behavior of your tool matches the
-     default behavior of upstream clang. This is made possible by wrapping
-     your matchers in ``traverse(TK_AsIs, ...)`` from step (2).
-  4. Audit your matcher expressions and remove ``traverse(TK_AsIs, ...)``
-     where not needed.
-  5. Audit your matcher expressions and remove calls to ``ignoring*()``
-     matchers where not needed.
-  6. Audit your matcher expressions and consider whether the matcher is
-     better using the ``TK_AsIs`` mode or if it can be better expressed in
-     the default mode. For example, some matchers explicitly match
-     ``has(implicitCastExpr(has(...)))``. Such matchers are sometimes
-     written by author who were unaware of the existence of the
-     ``ignoring*()`` matchers.
-
+- ...
 
 clang-format
 ------------
 
 - Option ``IndentExternBlock`` has been added to optionally apply indenting inside ``extern "C"`` and ``extern "C++"`` blocks.
 
 - ``IndentExternBlock`` option accepts ``AfterExternBlock`` to use the old behavior, as well as Indent and NoIndent options, which map to true and false, respectively.
 

clang/include/clang/AST/ParentMapContext.h

public:
 
   const Expr *traverseIgnored(const Expr *E) const;
   Expr *traverseIgnored(Expr *E) const;
   DynTypedNode traverseIgnored(const DynTypedNode &N) const;
 
 private:
   ASTContext &ASTCtx;
   class ParentMap;
-  TraversalKind Traversal = TK_IgnoreUnlessSpelledInSource;
+  TraversalKind Traversal = TK_AsIs;
   std::unique_ptr<ParentMap> Parents;
 };
 
 class TraversalKindScope {
   ParentMapContext &Ctx;
   TraversalKind TK = TK_AsIs;
 
 public:

clang/unittests/ASTMatchers/ASTMatchersNodeTest.cpp

TEST_P(ASTMatchersTest, CastExpression_MatchesImplicitCasts) {
   EXPECT_TRUE(
       matches("char c = 0;", traverse(ast_type_traits::TK_AsIs, castExpr())));
   // This test creates an implicit cast from lvalue to rvalue.
   EXPECT_TRUE(matches("void f() { char c = 0, d = c; }",
                       traverse(ast_type_traits::TK_AsIs, castExpr())));
 }
 
 TEST_P(ASTMatchersTest, CastExpr_DoesNotMatchNonCasts) {
+  if (GetParam().Language == Lang_C89 || GetParam().Language == Lang_C99) {
+    // This does have a cast in C
+    EXPECT_TRUE(matches("char c = '0';", implicitCastExpr()));
+  } else {
     EXPECT_TRUE(notMatches("char c = '0';", castExpr()));
+  }
   EXPECT_TRUE(notMatches("int i = (0);", castExpr()));
   EXPECT_TRUE(notMatches("int i = 0;", castExpr()));
 }
 
 TEST_P(ASTMatchersTest, CastExpr_DoesNotMatchNonCasts_CXX) {
   if (!GetParam().isCXX()) {
     return;
   }