[clang][AST] Ignore template instantiations if not in AsIs mode

[steveire]

Summary

IgnoreUnlessSpelledInSource mode should ignore these because they are
not written in the source. This matters for example when trying to
replace types or values which are templated. The new test in
TransformerTest.cpp in this commit demonstrates the problem.

In existing matcher code, users can write
unless(isInTemplateInstantiation()) or unless(isInstantiated()) (the
user must know which to use). The point of the
TK_IgnoreUnlessSpelledInSource mode is to allow the novice to avoid such
details. This patch changes the IgnoreUnlessSpelledInSource mode to
skip over implicit template instantiations.

This patch does not change the TK_AsIs mode. Adjust existing clang-tidy
matchers which explicitly desire to match implicit template
instantiations.

Note: An obvious attempt at an alternative implementation would simply
change the shouldVisitTemplateInstantiations() in ASTMatchFinder.cpp to
return something conditional on the operational TraversalKind. That
does not work because shouldVisitTemplateInstantiations() is called
before a possible top-level traverse() matcher changes the operational
TraversalKind.

The fact that RAV excludes these nodes by default is also justification
for this behavior in IgnoreUnlessSpelledInSource mode. It contains the
following comment:

By default, we do not traverse the instantiations of                   
class templates since they do not appear in the user code.

[steveire]

Update

[gribozavr2]

I think it makes sense to align the documentation and the definition of IgnoreUnlessSpelledInSource, I'm just not sure which component we should change -- the documentation or the implementation.

Making IgnoreUnlessSpelledInSource not match template instantiations is a nice and simple mental model. However, I'm not sure it is more useful in practice, and here's why. Processing non-instantiated templates is generally very difficult to do correctly: major parts of AST semantics are still unknown, and the parts that can be known are not reliably available. Clang does not provide guarantees about what parts of the template AST are type checked and what are not (I think there are only aspirations), so AST matchers that work in simple tests (where Clang decides to type check more expressions) could fail in more complex templates (where Clang decides to type check less). Generally, processing non-instantiated templates is difficult for the same reasons that make analyzing macro definitions difficult. Analyzing macro definitions is so difficult that tools generally don't do it at all and analyze expansions instead. Analyzing template definitions is more tractable (at least we have some AST nodes), but still, in practice, I'd generally recommend people to analyze template instantiations instead and if they need to perform a refactoring (like renaming a method), trying to cross-reference information across multiple template instantiations.

If IgnoreUnlessSpelledInSource is indeed for novice users (and not to be strictly interpreted as "it does what it says") we should think about whether it more useful to ignore instantiations or to match in instantiations.

For example, imagine someone who is trying to find usages of a certain function in their codebase by writing a matcher (for example so that they can rename it, or delete as dead code or whatever -- "find usages" is a very common first step). A matcher in IgnoreUnlessSpelledInSource mode that ignores instantiations could find no matches when in fact there are usages from templates. The user deletes the function, and in the best case they get a compilation error (and frustration because the AST matchers lied to them), or in the worst case due to the magic of overload resolution and ADL the code still compiles, but calls a different function that was in the overload set.

[ymandel]

Thank you for bringing up this issue. I think it highlights an underlying problem -- editing templates is quite difficult -- that neither setting will address, as Dmitri expanded on above. Given the parallel to macros, I'd say your change is better than the status quo. Most clang tidies and other rewriting tools that I've encountered simply skip code in macro expansions, rather than reason about how to update the macro definition or whatnot. So, by that reasoning, we should skip template instantations.

[aaron.ballman]

My experience with clang-tidy has been that template instantiations are a double-edged sword. The instantiation is the only place at which you have sufficient information to perform many kinds of analyses, but it's also often not plausible to modify the templated code because it's not clear from the instantiation context how changes may impact other instantiations. The result is that most of the clang-tidy checks wind up punting on template instantiations similar to what they do for macros. Based on that experience, I think it makes sense to continue in the proposed direction.

[steveire]

In D80961#2068865, @ymandel wrote:

Thank you for bringing up this issue. I think it highlights an underlying problem -- editing templates is quite difficult -- that neither setting will address, as Dmitri expanded on above. Given the parallel to macros, I'd say your change is better than the status quo. Most clang tidies and other rewriting tools that I've encountered simply skip code in macro expansions, rather than reason about how to update the macro definition or whatnot. So, by that reasoning, we should skip template instantations.

Yes, it's generally true for tools that given the choice of

1. possibly making a change which is definitely incorrect (as is currently done by default and as demonstrated in the Transformer test case)
2. not making a particular change meaning the overall change is incomplete (as in Dmitris response)

number (2) would always be way to go. I don't think Dmitris objection makes any sense.

[steveire]

In D80961#2068902, @aaron.ballman wrote:

My experience with clang-tidy has been that template instantiations are a double-edged sword. The instantiation is the only place at which you have sufficient information to perform many kinds of analyses, but it's also often not plausible to modify the templated code because it's not clear from the instantiation context how changes may impact other instantiations. The result is that most of the clang-tidy checks wind up punting on template instantiations similar to what they do for macros. Based on that experience, I think it makes sense to continue in the proposed direction.

Great. I also think that given that the default has just been changed to TK_IgnoreUnlessSpelledInSource, we should change this soon. The facts would still be the same if we do this at some future date, but it would be needlessly more disruptive.

[steveire]

In D80961#2067638, @gribozavr2 wrote:

If IgnoreUnlessSpelledInSource is indeed for novice users (and not to be strictly interpreted as "it does what it says") we should think about whether it more useful to ignore instantiations or to match in instantiations.

Tools should generally follow the Hippocratic: First do no harm.

As I demonstrated, simple tools currently accidentally make unintended and incorrect changes to code. That is wrong.

Do you have a standing objection to this being changed?

I can't really work on this if I know or assume that you're going to prevent it going in (ever or for a significant time which results in this being harder than it should be).

[klimek]

In D80961#2068865, @ymandel wrote:

Thank you for bringing up this issue. I think it highlights an underlying problem -- editing templates is quite difficult -- that neither setting will address, as Dmitri expanded on above. Given the parallel to macros, I'd say your change is better than the status quo. Most clang tidies and other rewriting tools that I've encountered simply skip code in macro expansions, rather than reason about how to update the macro definition or whatnot. So, by that reasoning, we should skip template instantations.

I've personally written quite a few tools that changed macro definitions. Do you have numbers on how many of the library team's tools generally want to match template instantiations?

[klimek]

Without jumping into the discussion whether it should be the default, I think we should be able to control template instantiation visitation separately from other implicit nodes.
Having to put AsIs on a matcher every time you need to match template instantiations is a rather big change (suddenly you have to change all the matchers you've written so far).
I love the idea of being able to control visitation of template instantiation.
I am somewhat torn on whether it should be the default, and would like to see more data.
I feel more strongly about needing AsIs when I want to match template instantiations.

[steveire]

In D80961#2073049, @klimek wrote:

Without jumping into the discussion whether it should be the default, I think we should be able to control template instantiation visitation separately from other implicit nodes.

Hmm, IgnoreUnlessSpelledInSource is designed and named to fill that role. After this patch is in, I intend to make it also control whether the implicit node here is dumped/matchable: https://godbolt.org/z/V_KCFm

Having to put AsIs on a matcher every time you need to match template instantiations is a rather big change (suddenly you have to change all the matchers you've written so far).

I don't think that's true. You have to change the matchers you've written which deliberately match the instantiation, but you can also (optionally) simplify the others to remove unless(isInTemplateInstantiation()) from them. The third category of matchers are the ones where you haven't used unless(isInTemplateInstantiation()) even though you should have and you have a bug that you don't know about yet. This change fixes those ones.

I love the idea of being able to control visitation of template instantiation.
I am somewhat torn on whether it should be the default, and would like to see more data.
I feel more strongly about needing AsIs when I want to match template instantiations.

I feel strongly that the default should not change code in a known-wrong way, as the unit test demonstrates. It's not a novice-friendly default.

[steveire]

In D80961#2074915, @steveire wrote:

Hmm, IgnoreUnlessSpelledInSource is designed and named to fill that role.

In other words: to me this change is a bug fix.

[aaron.ballman]

In D80961#2073049, @klimek wrote:

Without jumping into the discussion whether it should be the default, I think we should be able to control template instantiation visitation separately from other implicit nodes.
Having to put AsIs on a matcher every time you need to match template instantiations is a rather big change (suddenly you have to change all the matchers you've written so far).

I think that's the intended meaning of AsIs though. Template instantiations are not source code the user wrote, they're source code the compiler stamped out from code the user wrote. I hope IgnoreUnlessSpelledInSource isn't a misnomer.

I love the idea of being able to control visitation of template instantiation.
I am somewhat torn on whether it should be the default, and would like to see more data.
I feel more strongly about needing AsIs when I want to match template instantiations.

FWIW, my experience in clang-tidy has been that template instantiations are ignored far more often than they're desired. In fact, instantiations tend to be a source of bugs for us because they're easy to forget about when writing matchers without keeping templates in mind. The times when template instantiations become important to *not* ignore within the checks is when the check is specific to template behavior, but that's a minority of the public checks thus far.

[steveire]

In D80961#2074915, @steveire wrote:

I don't think that's true. You have to change the matchers you've written which deliberately match the instantiation, but you can also (optionally) simplify the others to remove unless(isInTemplateInstantiation()) from them. The third category of matchers are the ones where you haven't used unless(isInTemplateInstantiation()) even though you should have and you have a bug that you don't know about yet. This change fixes those ones.

This seems to be an example of that third category: https://reviews.llvm.org/D81336

I love the idea of being able to control visitation of template instantiation.
I am somewhat torn on whether it should be the default, and would like to see more data.
I feel more strongly about needing AsIs when I want to match template instantiations.

I feel strongly that the default should not change code in a known-wrong way, as the unit test demonstrates. It's not a novice-friendly default.

Any more feelings on this?

[steveire]

Port unit tests

[sammccall]

Yeah, I think this is consistent with the naming/doc of IgnoreUnlessSpelledInSource, and the concerns are more about the implications of making a less-powerful, more conservative version of matchers the default.
Which isn't really what *this* patch is about, but it's reasonable to be concerned at how much functionality is being "buried" beneath a pretty awkward API.

[klimek]

In D80961#2076242, @aaron.ballman wrote:

In D80961#2073049, @klimek wrote:

Without jumping into the discussion whether it should be the default, I think we should be able to control template instantiation visitation separately from other implicit nodes.
Having to put AsIs on a matcher every time you need to match template instantiations is a rather big change (suddenly you have to change all the matchers you've written so far).

I think that's the intended meaning of AsIs though. Template instantiations are not source code the user wrote, they're source code the compiler stamped out from code the user wrote. I hope IgnoreUnlessSpelledInSource isn't a misnomer.

I love the idea of being able to control visitation of template instantiation.
I am somewhat torn on whether it should be the default, and would like to see more data.
I feel more strongly about needing AsIs when I want to match template instantiations.

FWIW, my experience in clang-tidy has been that template instantiations are ignored far more often than they're desired. In fact, instantiations tend to be a source of bugs for us because they're easy to forget about when writing matchers without keeping templates in mind. The times when template instantiations become important to *not* ignore within the checks is when the check is specific to template behavior, but that's a minority of the public checks thus far.

So I assume the idea is that this will work & be what we'll want people to write?
traverse(AsIs, decl(traverse(IgnoreImplicit, hasFoo)))

[aaron.ballman]

In D80961#2079044, @klimek wrote:

In D80961#2076242, @aaron.ballman wrote:

In D80961#2073049, @klimek wrote:

Without jumping into the discussion whether it should be the default, I think we should be able to control template instantiation visitation separately from other implicit nodes.
Having to put AsIs on a matcher every time you need to match template instantiations is a rather big change (suddenly you have to change all the matchers you've written so far).

I think that's the intended meaning of AsIs though. Template instantiations are not source code the user wrote, they're source code the compiler stamped out from code the user wrote. I hope IgnoreUnlessSpelledInSource isn't a misnomer.

I love the idea of being able to control visitation of template instantiation.
I am somewhat torn on whether it should be the default, and would like to see more data.
I feel more strongly about needing AsIs when I want to match template instantiations.

FWIW, my experience in clang-tidy has been that template instantiations are ignored far more often than they're desired. In fact, instantiations tend to be a source of bugs for us because they're easy to forget about when writing matchers without keeping templates in mind. The times when template instantiations become important to *not* ignore within the checks is when the check is specific to template behavior, but that's a minority of the public checks thus far.

So I assume the idea is that this will work & be what we'll want people to write?
traverse(AsIs, decl(traverse(IgnoreImplicit, hasFoo)))

I believe so, yes. It's explicit about which traversal mode you want any given set of matchers to match with, so it is more flexible at the expense of being more verbose. Alternatively, you could be in AsIs mode for all of it and explicitly ignore the implicit nodes you wish to ignore (which may be even more verbose with the same results, depending on the matchers involved).

[steveire]

In D80961#2079419, @aaron.ballman wrote:

In D80961#2079044, @klimek wrote:

In D80961#2076242, @aaron.ballman wrote:

In D80961#2073049, @klimek wrote:

Without jumping into the discussion whether it should be the default, I think we should be able to control template instantiation visitation separately from other implicit nodes.
Having to put AsIs on a matcher every time you need to match template instantiations is a rather big change (suddenly you have to change all the matchers you've written so far).

I think that's the intended meaning of AsIs though. Template instantiations are not source code the user wrote, they're source code the compiler stamped out from code the user wrote. I hope IgnoreUnlessSpelledInSource isn't a misnomer.

I love the idea of being able to control visitation of template instantiation.
I am somewhat torn on whether it should be the default, and would like to see more data.
I feel more strongly about needing AsIs when I want to match template instantiations.

FWIW, my experience in clang-tidy has been that template instantiations are ignored far more often than they're desired. In fact, instantiations tend to be a source of bugs for us because they're easy to forget about when writing matchers without keeping templates in mind. The times when template instantiations become important to *not* ignore within the checks is when the check is specific to template behavior, but that's a minority of the public checks thus far.

So I assume the idea is that this will work & be what we'll want people to write?
traverse(AsIs, decl(traverse(IgnoreImplicit, hasFoo)))

I believe so, yes. It's explicit about which traversal mode you want any given set of matchers to match with, so it is more flexible at the expense of being more verbose. Alternatively, you could be in AsIs mode for all of it and explicitly ignore the implicit nodes you wish to ignore (which may be even more verbose with the same results, depending on the matchers involved).

As far as I can tell, the people who had "standing objections" to fixing this bug have been convinced that it makes sense. At least that is implied.

The problem is they haven't explicitly reversed so progress is still blocked.

Please respond to either say you're no longer blocking this or say why you continue to block it.

There is no reason not to fix this.

[steveire]

Update

[steveire]

Update

[klimek]

In D80961#2090216, @steveire wrote:

In D80961#2079419, @aaron.ballman wrote:

In D80961#2079044, @klimek wrote:

In D80961#2076242, @aaron.ballman wrote:

In D80961#2073049, @klimek wrote:

Without jumping into the discussion whether it should be the default, I think we should be able to control template instantiation visitation separately from other implicit nodes.
Having to put AsIs on a matcher every time you need to match template instantiations is a rather big change (suddenly you have to change all the matchers you've written so far).

I think that's the intended meaning of AsIs though. Template instantiations are not source code the user wrote, they're source code the compiler stamped out from code the user wrote. I hope IgnoreUnlessSpelledInSource isn't a misnomer.

I love the idea of being able to control visitation of template instantiation.
I am somewhat torn on whether it should be the default, and would like to see more data.
I feel more strongly about needing AsIs when I want to match template instantiations.

FWIW, my experience in clang-tidy has been that template instantiations are ignored far more often than they're desired. In fact, instantiations tend to be a source of bugs for us because they're easy to forget about when writing matchers without keeping templates in mind. The times when template instantiations become important to *not* ignore within the checks is when the check is specific to template behavior, but that's a minority of the public checks thus far.

So I assume the idea is that this will work & be what we'll want people to write?
traverse(AsIs, decl(traverse(IgnoreImplicit, hasFoo)))

I believe so, yes. It's explicit about which traversal mode you want any given set of matchers to match with, so it is more flexible at the expense of being more verbose. Alternatively, you could be in AsIs mode for all of it and explicitly ignore the implicit nodes you wish to ignore (which may be even more verbose with the same results, depending on the matchers involved).

Support for clang-query is coming up, I assume? If that works & will work in clang-query that addresses my concern.

As far as I can tell, the people who had "standing objections" to fixing this bug have been convinced that it makes sense. At least that is implied.

The problem is they haven't explicitly reversed so progress is still blocked.

Please respond to either say you're no longer blocking this or say why you continue to block it.

There is no reason not to fix this.

Stephen, I want to call this out, as I think the way you write here is not OK:

1. the scare quotes around "standing objections" reads like you're not respecting the opinions of others here; it's fine to be frustrated, it's fine to call out why you're frustrated (for example, reviews taking long time, or it being hard to find consensus), but it's not OK to use sarcasm to implicitly attack folks - the only result is that people are hurt
2. if you want somebody to chime in, please say so; implicitly alluding to people you want to respond reads as an implicit accusation of folks trying to block you; nobody wants to block you; we're professionals trying to create a great product, and we often have different opinions what that means; that's part of the process, and in the end makes for a better product
3. "There is no reason not to fix this" - asserting your believes is not an argument, and comes across as arrogant - the moment other people have objections there are reasons to object; whether those reasons in the end are more important than the reasons you cited for doing it is often a value call, and different people have different values

If you need to vent, feel free to write me (and only me) angry emails (if you preface with Vent: I also know the context, which helps :), or I'm also happy to add you to my work chat so you can vent at me in chat. I understand the need to vent - but it must not be done at the emotional expense of others on the project. In the end, behaving like this in code reviews will reduce the chance that people are willing to engage with you and spend time on reviewing your code, leading to even longer review times. This is a vicious cycle. It's in your hands to break it, but it will take time and patience.
As I've said before, I love what you're doing for the project, but ultimately, if you cannot engage constructively, we are an OSS project exactly so people who don't want to be part of the community can fork and do their own thing.
If you want to be part of the community (and I do sincerely hope that you do!), it's important to play by its rules; in the long run, it will make it a significantly better experience (and better product!) for everyone.

[steveire]

In D80961#2095254, @klimek wrote:

1. the scare quotes around "standing objections" reads like you're not respecting the opinions of others here;

Hmm, this wasn't intended. I sometimes quote things if they are a particular term (ordinarily I would quote "particular term").

Nevertheless, I'll take on your message. I don't have more to say.

[klimek]

In D80961#2099262, @steveire wrote:

In D80961#2095254, @klimek wrote:

1. the scare quotes around "standing objections" reads like you're not respecting the opinions of others here;

Hmm, this wasn't intended. I sometimes quote things if they are a particular term (ordinarily I would quote "particular term").

Nevertheless, I'll take on your message. I don't have more to say.

Thanks!

[steveire]

Here's another example where it is not appropriate to transform a template instantiation:

http://clang-developers.42468.n3.nabble.com/Questions-discussions-about-cast-types-in-clang-td4068626.html

"If we call foo<int>, it can be a const_cast, but if we call foo<double>, it has to be a reinterpret_cast. In a situation where the user is writing library code, it won't only be relevant to the current translation unit but also for future purposes. Therefore, I propose that we leave dependent type c-style casts as they are."

Just recording it as part of the motivation of this patch.

[aaron.ballman]

I reviewed the changes in the patch and they seem reasonable, but this patch is hard to have high confidence in because you need to audit all the places where the default behavior silently changed and no changes were made in the patch. I'm assuming that the code changes were made to cause existing tests to pass, but did you verify that changes weren't needed to checks that show no behavioral test changes to ensure that it wasn't because the tests have poor template test coverage?

clang-tools-extra/clang-tidy/bugprone/TooSmallLoopVariableCheck.cpp

62

Do we still need this TK_AsIs with the below changes?

clang/lib/ASTMatchers/ASTMatchFinder.cpp

564

This should not be part of the public interface.

570

Nor should this, right?

[steveire]

Rebase

[steveire]

Update

[steveire]

Many of the changes which were part of a previous iteration of this change were related to the change of default behavior of matchers. As the default is no longer changed, those changes fell away.

[aaron.ballman]

In D80961#2353384, @steveire wrote:

Many of the changes which were part of a previous iteration of this change were related to the change of default behavior of matchers. As the default is no longer changed, those changes fell away.

Indeed! Thank you for continuing on this. Aside from a few small nits, I think this LGTM.

clang/include/clang/AST/ASTNodeTraverser.h

479–481

Any interest in using curly braces here for readability?

clang/lib/AST/ASTDumper.cpp

132–135

Any interest in using curly braces here for readability?

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

285–287

You can combine these into a single if statement (and then elide the braces).

312

Same here.

[aaron.ballman]

Oops, forgot to click the important bit to actually accept the review. :-)

[sammccall]

This seems to make asan buildbots unhappy: http://lab.llvm.org:8011/#/builders/5/builds/744
I can't see anything immediately suspicious, but I don't know the matcher internals that well :-\

clang-tools-extra/clang-tidy/abseil/TimeSubtractionCheck.cpp

for (auto ScaleName :
     // that the second operand must be a 'Time'.
     auto CallMatcher =
         callExpr(
             callee(functionDecl(hasName(getDurationFactoryForScale(*Scale)))),
             hasArgument(0, binaryOperator(hasOperatorName("-"),
                                           hasLHS(TimeInverseMatcher))
                                .bind("binop")))
             .bind("outer_call");
-    Finder->addMatcher(CallMatcher, this);
+    Finder->addMatcher(traverse(TK_AsIs, CallMatcher), this);
 
     // Match cases where we know the second operand is a 'Time'. Since
     // subtracting a 'Time' from a 'Duration' is not defined, in these cases,
     // we always know the first operand is a 'Time' if the second is a 'Time'.
     auto OperandMatcher =
         binaryOperator(hasOperatorName("-"), hasRHS(TimeInverseMatcher))
             .bind("binop");
-    Finder->addMatcher(OperandMatcher, this);
+    Finder->addMatcher(traverse(TK_AsIs, OperandMatcher), this);
   }
 }
 
 void TimeSubtractionCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *BinOp = Result.Nodes.getNodeAs<BinaryOperator>("binop");
   std::string InverseName =
       Result.Nodes.getNodeAs<FunctionDecl>("func_decl")->getNameAsString();
   if (InsideMacroDefinition(Result, BinOp->getSourceRange()))

clang-tools-extra/clang-tidy/abseil/UpgradeDurationConversionsCheck.cpp

void UpgradeDurationConversionsCheck::registerMatchers(MatchFinder *Finder) {
   // `int64_t`.
   //
   // The implementation of these templates will be updated to fail SFINAE for
   // non-integral types. We match them to suggest an explicit cast.
 
   // Match expressions like `a *= b` and `a /= b` where `a` has type
   // `absl::Duration` and `b` is not of a built-in type.
   Finder->addMatcher(
+      traverse(
+          ast_type_traits::TK_AsIs,
           cxxOperatorCallExpr(
               argumentCountIs(2),
               hasArgument(
                   0, expr(hasType(cxxRecordDecl(hasName("::absl::Duration"))))),
               hasArgument(1, expr().bind("arg")),
               callee(functionDecl(
                   hasParent(functionTemplateDecl()),
                   unless(hasTemplateArgument(0, refersToType(builtinType()))),
                   hasAnyName("operator*=", "operator/="))))
-          .bind("OuterExpr"),
+              .bind("OuterExpr")),
       this);
 
   // Match expressions like `a.operator*=(b)` and `a.operator/=(b)` where `a`
   // has type `absl::Duration` and `b` is not of a built-in type.
   Finder->addMatcher(
+      traverse(
+          ast_type_traits::TK_AsIs,
           cxxMemberCallExpr(
               callee(cxxMethodDecl(
                   ofClass(cxxRecordDecl(hasName("::absl::Duration"))),
                   hasParent(functionTemplateDecl()),
                   unless(hasTemplateArgument(0, refersToType(builtinType()))),
                   hasAnyName("operator*=", "operator/="))),
               argumentCountIs(1), hasArgument(0, expr().bind("arg")))
-          .bind("OuterExpr"),
+              .bind("OuterExpr")),
       this);
 
   // Match expressions like `a * b`, `a / b`, `operator*(a, b)`, and
   // `operator/(a, b)` where `a` has type `absl::Duration` and `b` is not of a
   // built-in type.
   Finder->addMatcher(
-      callExpr(callee(functionDecl(
-                   hasParent(functionTemplateDecl()),
-                   unless(hasTemplateArgument(0, refersToType(builtinType()))),
-                   hasAnyName("::absl::operator*", "::absl::operator/"))),
-               argumentCountIs(2),
-               hasArgument(0, expr(hasType(
-                                  cxxRecordDecl(hasName("::absl::Duration"))))),
-               hasArgument(1, expr().bind("arg")))
-          .bind("OuterExpr"),
+      traverse(
+          ast_type_traits::TK_AsIs,
+          callExpr(
+              callee(functionDecl(
+              hasArgument(
+                  0, expr(hasType(cxxRecordDecl(hasName("::absl::Duration"))))),
+              .bind("OuterExpr")),
       this);
 
   // Match expressions like `a * b` and `operator*(a, b)` where `a` is not of a
   // built-in type and `b` has type `absl::Duration`.
   Finder->addMatcher(
-      callExpr(callee(functionDecl(
-                   hasParent(functionTemplateDecl()),
-                   unless(hasTemplateArgument(0, refersToType(builtinType()))),
+      traverse(
+          ast_type_traits::TK_AsIs,
+          callExpr(callee(functionDecl(hasParent(functionTemplateDecl()),
+                                       unless(hasTemplateArgument(
+                                           0, refersToType(builtinType()))),
                                        hasName("::absl::operator*"))),
                    argumentCountIs(2), hasArgument(0, expr().bind("arg")),
-               hasArgument(1, expr(hasType(
-                                  cxxRecordDecl(hasName("::absl::Duration"))))))
-          .bind("OuterExpr"),
+                   hasArgument(1, expr(hasType(cxxRecordDecl(
+                                      hasName("::absl::Duration"))))))
+              .bind("OuterExpr")),
       this);
 
   // For the factory functions, we match only the non-templated overloads that
   // take an `int64_t` parameter. Within these calls, we care about implicit
   // casts through a user defined conversion to `int64_t`.
   //
   // The factory functions will be updated to be templated and SFINAE on whether
   // the template parameter is an integral type. This complements the already

clang-tools-extra/clang-tidy/bugprone/SizeofExpressionCheck.cpp

void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
   const auto SizeOfZero = expr(
       sizeOfExpr(has(ignoringParenImpCasts(expr(integerLiteral(equals(0)))))));
 
   // Detect expression like: sizeof(ARRAYLEN);
   // Note: The expression 'sizeof(sizeof(0))' is a portable trick used to know
   //       the sizeof size_t.
   if (WarnOnSizeOfConstant) {
     Finder->addMatcher(
+        traverse(TK_AsIs,
                  expr(sizeOfExpr(has(ignoringParenImpCasts(ConstantExpr))),
                       unless(SizeOfZero))
-            .bind("sizeof-constant"),
+                     .bind("sizeof-constant")),
         this);
   }
 
   // Detect sizeof(f())
   if (WarnOnSizeOfIntegerExpression) {
     Finder->addMatcher(
         expr(sizeOfExpr(ignoringParenImpCasts(has(IntegerCallExpr))))
             .bind("sizeof-integer-call"),
void SizeofExpressionCheck::registerMatchers(MatchFinder *Finder) {
   const auto ElemType =
       arrayType(hasElementType(recordType().bind("elem-type")));
   const auto ElemPtrType = pointerType(pointee(type().bind("elem-ptr-type")));
   const auto NumType = qualType(hasCanonicalType(
       type(anyOf(ElemType, ElemPtrType, type())).bind("num-type")));
   const auto DenomType = qualType(hasCanonicalType(type().bind("denom-type")));
 
   Finder->addMatcher(
+      traverse(TK_AsIs,
                binaryOperator(hasOperatorName("/"),
-                     hasLHS(expr(ignoringParenImpCasts(
-                         anyOf(sizeOfExpr(has(NumType)),
+                              hasLHS(expr(ignoringParenImpCasts(anyOf(
+                                  sizeOfExpr(has(NumType)),
                                   sizeOfExpr(has(expr(hasType(NumType)))))))),
-                     hasRHS(expr(ignoringParenImpCasts(
-                         anyOf(sizeOfExpr(has(DenomType)),
+                              hasRHS(expr(ignoringParenImpCasts(anyOf(
+                                  sizeOfExpr(has(DenomType)),
                                   sizeOfExpr(has(expr(hasType(DenomType)))))))))
-          .bind("sizeof-divide-expr"),
+                   .bind("sizeof-divide-expr")),
       this);
 
   // Detect expression like: sizeof(...) * sizeof(...)); most likely an error.
   Finder->addMatcher(binaryOperator(hasOperatorName("*"),
                                     hasLHS(ignoringParenImpCasts(SizeOfExpr)),
                                     hasRHS(ignoringParenImpCasts(SizeOfExpr)))
                          .bind("sizeof-multiply-sizeof"),
                      this);

clang-tools-extra/clang-tidy/bugprone/TooSmallLoopVariableCheck.cpp

 void TooSmallLoopVariableCheck::registerMatchers(MatchFinder *Finder) {
   StatementMatcher LoopVarMatcher =
       expr(
           ignoringParenImpCasts(declRefExpr(to(varDecl(hasType(isInteger()))))))
           .bind(LoopVarName);
 
   // We need to catch only those comparisons which contain any integer cast.
   StatementMatcher LoopVarConversionMatcher =
       traverse(ast_type_traits::TK_AsIs,
                implicitCastExpr(hasImplicitDestinationType(isInteger()),
                                 has(ignoringParenImpCasts(LoopVarMatcher)))
                    .bind(LoopVarCastName));
 
   // We are interested in only those cases when the loop bound is a variable
   // value (not const, enum, etc.).
   StatementMatcher LoopBoundMatcher =
       expr(ignoringParenImpCasts(allOf(hasType(isInteger()),
                                        unless(integerLiteral()),
                                        unless(hasType(isConstQualified())),
                                        unless(hasType(enumType())))))
           .bind(LoopUpperBoundName);
 
   // We use the loop increment expression only to make sure we found the right
   // loop variable.
   StatementMatcher IncrementMatcher =
       expr(ignoringParenImpCasts(hasType(isInteger()))).bind(LoopIncrementName);
 
   Finder->addMatcher(
-      forStmt(
-          hasCondition(anyOf(
+      traverse(TK_AsIs,
+               forStmt(hasCondition(anyOf(
                            binaryOperator(hasOperatorName("<"),
                                           hasLHS(LoopVarConversionMatcher),
                                           hasRHS(LoopBoundMatcher)),
                            binaryOperator(hasOperatorName("<="),
                                           hasLHS(LoopVarConversionMatcher),
                                           hasRHS(LoopBoundMatcher)),
-              binaryOperator(hasOperatorName(">"), hasLHS(LoopBoundMatcher),
+                           binaryOperator(hasOperatorName(">"),
+                                          hasLHS(LoopBoundMatcher),
                                           hasRHS(LoopVarConversionMatcher)),
-              binaryOperator(hasOperatorName(">="), hasLHS(LoopBoundMatcher),
+                           binaryOperator(hasOperatorName(">="),
+                                          hasLHS(LoopBoundMatcher),
                                           hasRHS(LoopVarConversionMatcher)))),
                        hasIncrement(IncrementMatcher))
-          .bind(LoopName),
+                   .bind(LoopName)),
       this);
 }
 
 /// Returns the magnitude bits of an integer type.
 static unsigned calcMagnitudeBits(const ASTContext &Context,
                                   const QualType &IntExprType) {
   assert(IntExprType->isIntegerType());
 

clang-tools-extra/clang-tidy/bugprone/UndefinedMemoryManipulationCheck.cpp

 
 void UndefinedMemoryManipulationCheck::registerMatchers(MatchFinder *Finder) {
   const auto NotTriviallyCopyableObject =
       hasType(ast_matchers::hasCanonicalType(
           pointsTo(cxxRecordDecl(isNotTriviallyCopyable()))));
 
   // Check whether destination object is not TriviallyCopyable.
   // Applicable to all three memory manipulation functions.
-  Finder->addMatcher(callExpr(callee(functionDecl(hasAnyName(
+  Finder->addMatcher(
+      traverse(TK_AsIs, callExpr(callee(functionDecl(hasAnyName(
                                      "::memset", "::memcpy", "::memmove"))),
                                  hasArgument(0, NotTriviallyCopyableObject))
-                         .bind("dest"),
-                     this);
+                            .bind("dest")),
 
   // Check whether source object is not TriviallyCopyable.
   // Only applicable to memcpy() and memmove().
   Finder->addMatcher(
-      callExpr(callee(functionDecl(hasAnyName("::memcpy", "::memmove"))),
+      traverse(TK_AsIs, callExpr(callee(functionDecl(
+                                     hasAnyName("::memcpy", "::memmove"))),
                                  hasArgument(1, NotTriviallyCopyableObject))
-          .bind("src"),
+                            .bind("src")),
       this);
 }
 
 void UndefinedMemoryManipulationCheck::check(
     const MatchFinder::MatchResult &Result) {
   if (const auto *Call = Result.Nodes.getNodeAs<CallExpr>("dest")) {
     QualType DestType = Call->getArg(0)->IgnoreImplicit()->getType();
     if (!DestType->getPointeeType().isNull())

clang-tools-extra/clang-tidy/bugprone/VirtualNearMissCheck.cpp

for (const CXXMethodDecl *DerivedMD : DerivedRD->methods()) {
     }
   }
   OverriddenMap[Key] = IsOverridden;
   return IsOverridden;
 }
 
 void VirtualNearMissCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
+      traverse(
+          TK_AsIs,
           cxxMethodDecl(
               unless(anyOf(isOverride(), isImplicit(), cxxConstructorDecl(),
                            cxxDestructorDecl(), cxxConversionDecl(), isStatic(),
                            isOverloadedOperator())))
-          .bind("method"),
+              .bind("method")),
       this);
 }
 
 void VirtualNearMissCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *DerivedMD = Result.Nodes.getNodeAs<CXXMethodDecl>("method");
   assert(DerivedMD);
 
   const ASTContext *Context = Result.Context;

clang-tools-extra/clang-tidy/google/UpgradeGoogletestCaseCheck.cpp

auto Methods =
                              "test_case_to_run_count", "GetTestCase"),
                   ofClass(cxxRecordDecl(
                               isSameOrDerivedFrom(cxxRecordDecl(
                                   hasName("::testing::UnitTest"),
                                   hasMethod(hasName("current_test_suite")))))
                               .bind("class")))))
           .bind("method");
 
-  Finder->addMatcher(expr(anyOf(callExpr(callee(Methods)).bind("call"),
+  Finder->addMatcher(
+      traverse(TK_AsIs, expr(anyOf(callExpr(callee(Methods)).bind("call"),
                                    declRefExpr(to(Methods)).bind("ref")),
-                          LocationFilter),
-                     this);
+                             LocationFilter)),
 
   Finder->addMatcher(
       usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(Methods)), LocationFilter)
           .bind("using"),
       this);
 
   Finder->addMatcher(cxxMethodDecl(Methods, LocationFilter), this);
 

clang-tools-extra/clang-tidy/hicpp/ExceptionBaseclassCheck.cpp

 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace tidy {
 namespace hicpp {
 
 void ExceptionBaseclassCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
+      traverse(
+          TK_AsIs,
           cxxThrowExpr(
               unless(has(expr(anyOf(isTypeDependent(), isValueDependent())))),
               // The thrown value is not derived from 'std::exception'.
-          has(expr(unless(
-              hasType(qualType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
+              has(expr(unless(hasType(
+                  qualType(hasCanonicalType(hasDeclaration(cxxRecordDecl(
                       isSameOrDerivedFrom(hasName("::std::exception")))))))))),
               // This condition is always true, but will bind to the
               // template value if the thrown type is templated.
-          anyOf(has(expr(
-                    hasType(substTemplateTypeParmType().bind("templ_type")))),
+              anyOf(has(expr(hasType(
+                        substTemplateTypeParmType().bind("templ_type")))),
                     anything()),
               // Bind to the declaration of the type of the value that
               // is thrown. 'anything()' is necessary to always succeed
               // in the 'eachOf' because builtin types are not
               // 'namedDecl'.
               eachOf(has(expr(hasType(namedDecl().bind("decl")))), anything()))
-          .bind("bad_throw"),
+              .bind("bad_throw")),
       this);
 }
 
 void ExceptionBaseclassCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *BadThrow = Result.Nodes.getNodeAs<CXXThrowExpr>("bad_throw");
   assert(BadThrow && "Did not match the throw expression");
 
   diag(BadThrow->getSubExpr()->getBeginLoc(), "throwing an exception whose "

clang-tools-extra/clang-tidy/modernize/DeprecatedIosBaseAliasesCheck.cpp

return llvm::StringSwitch<llvm::Optional<const char *>>(Type)
       .Default(llvm::None);
 }
 
 void DeprecatedIosBaseAliasesCheck::registerMatchers(MatchFinder *Finder) {
   auto IoStateDecl = typedefDecl(hasAnyName(DeprecatedTypes)).bind("TypeDecl");
   auto IoStateType =
       qualType(hasDeclaration(IoStateDecl), unless(elaboratedType()));
 
-  Finder->addMatcher(typeLoc(loc(IoStateType)).bind("TypeLoc"), this);
+  Finder->addMatcher(
+      traverse(TK_AsIs, typeLoc(loc(IoStateType)).bind("TypeLoc")), this);
 }
 
 void DeprecatedIosBaseAliasesCheck::check(
     const MatchFinder::MatchResult &Result) {
   SourceManager &SM = *Result.SourceManager;
 
   const auto *Typedef = Result.Nodes.getNodeAs<TypedefDecl>("TypeDecl");
   StringRef TypeName = Typedef->getName();

clang-tools-extra/clang-tidy/modernize/MakeSmartPtrCheck.cpp

Finder->addMatcher(
       this);
 }
 
 void MakeSmartPtrCheck::check(const MatchFinder::MatchResult &Result) {
   // 'smart_ptr' refers to 'std::shared_ptr' or 'std::unique_ptr' or other
   // pointer, 'make_smart_ptr' refers to 'std::make_shared' or
   // 'std::make_unique' or other function that creates smart_ptr.
 
+  TraversalKindScope RAII(*Result.Context, TK_AsIs);
+
   SourceManager &SM = *Result.SourceManager;
   const auto *Construct =
       Result.Nodes.getNodeAs<CXXConstructExpr>(ConstructorCall);
   const auto *Reset = Result.Nodes.getNodeAs<CXXMemberCallExpr>(ResetCall);
   const auto *Type = Result.Nodes.getNodeAs<QualType>(PointerType);
   const auto *New = Result.Nodes.getNodeAs<CXXNewExpr>(NewExpression);
 
   // Skip when this is a new-expression with `auto`, e.g. new auto(1)

clang-tools-extra/clang-tidy/modernize/ReplaceAutoPtrCheck.cpp

void ReplaceAutoPtrCheck::registerMatchers(MatchFinder *Finder) {
   //   std::auto_ptr<int> a;
   //        ^~~~~~~~~~~~~
   //
   //   typedef std::auto_ptr<int> int_ptr_t;
   //                ^~~~~~~~~~~~~
   //
   //   std::auto_ptr<int> fn(std::auto_ptr<int>);
   //        ^~~~~~~~~~~~~         ^~~~~~~~~~~~~
-  Finder->addMatcher(typeLoc(loc(qualType(AutoPtrType,
-                                          // Skip elaboratedType() as the named
-                                          // type will match soon thereafter.
-                                          unless(elaboratedType()))))
-                         .bind(AutoPtrTokenId),
-                     this);
+  Finder->addMatcher(
+      traverse(TK_AsIs,
+               typeLoc(loc(qualType(AutoPtrType,
+                   .bind(AutoPtrTokenId)),
 
   //   using std::auto_ptr;
   //   ^~~~~~~~~~~~~~~~~~~
-  Finder->addMatcher(usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(namedDecl(
-                                   hasName("auto_ptr"), isFromStdNamespace()))))
-                         .bind(AutoPtrTokenId),
-                     this);
+  Finder->addMatcher(
+      traverse(TK_AsIs,
+               usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(namedDecl(
+                   .bind(AutoPtrTokenId)),
 
   // Find ownership transfers via copy construction and assignment.
   // AutoPtrOwnershipTransferId is bound to the part that has to be wrapped
   // into std::move().
   //   std::auto_ptr<int> i, j;
   //   i = j;
   //   ~~~~^
   auto MovableArgumentMatcher =
       expr(isLValue(), hasType(AutoPtrType)).bind(AutoPtrOwnershipTransferId);
 
   Finder->addMatcher(
+      traverse(TK_AsIs,
                cxxOperatorCallExpr(hasOverloadedOperatorName("="),
                                    callee(cxxMethodDecl(ofClass(AutoPtrDecl))),
-                          hasArgument(1, MovableArgumentMatcher)),
+                                   hasArgument(1, MovableArgumentMatcher))),
       this);
   Finder->addMatcher(
       traverse(ast_type_traits::TK_AsIs,
                cxxConstructExpr(hasType(AutoPtrType), argumentCountIs(1),
                                 hasArgument(0, MovableArgumentMatcher))),
       this);
 }
 

clang-tools-extra/clang-tidy/modernize/UseOverrideCheck.cpp

void UseOverrideCheck::storeOptions(ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "AllowOverrideAndFinal", AllowOverrideAndFinal);
   Options.store(Opts, "OverrideSpelling", OverrideSpelling);
   Options.store(Opts, "FinalSpelling", FinalSpelling);
 }
 
 void UseOverrideCheck::registerMatchers(MatchFinder *Finder) {
   if (IgnoreDestructors)
     Finder->addMatcher(
-        cxxMethodDecl(isOverride(), unless(cxxDestructorDecl())).bind("method"),
+        traverse(TK_AsIs,
+                 cxxMethodDecl(isOverride(), unless(cxxDestructorDecl()))
+                     .bind("method")),
         this);
   else
-    Finder->addMatcher(cxxMethodDecl(isOverride()).bind("method"), this);
+    Finder->addMatcher(
+        traverse(TK_AsIs, cxxMethodDecl(isOverride()).bind("method")), this);
 }
 
 // Re-lex the tokens to get precise locations to insert 'override' and remove
 // 'virtual'.
 static SmallVector<Token, 16>
 ParseTokens(CharSourceRange Range, const MatchFinder::MatchResult &Result) {
   const SourceManager &Sources = *Result.SourceManager;
   std::pair<FileID, unsigned> LocInfo =

clang-tools-extra/clang-tidy/modernize/UseUncaughtExceptionsCheck.cpp

 namespace tidy {
 namespace modernize {
 
 void UseUncaughtExceptionsCheck::registerMatchers(MatchFinder *Finder) {
   std::string MatchText = "::std::uncaught_exception";
 
   // Using declaration: warning and fix-it.
   Finder->addMatcher(
-      usingDecl(hasAnyUsingShadowDecl(hasTargetDecl(hasName(MatchText))))
-          .bind("using_decl"),
+      traverse(TK_AsIs, usingDecl(hasAnyUsingShadowDecl(
+                                      hasTargetDecl(hasName(MatchText))))
+                            .bind("using_decl")),
       this);
 
   // DeclRefExpr: warning, no fix-it.
   Finder->addMatcher(
-      declRefExpr(to(functionDecl(hasName(MatchText))), unless(callExpr()))
-          .bind("decl_ref_expr"),
+      traverse(TK_AsIs, declRefExpr(to(functionDecl(hasName(MatchText))),
+                                    unless(callExpr()))
+                            .bind("decl_ref_expr")),
       this);
 
   auto DirectCallToUncaughtException = callee(expr(ignoringImpCasts(
       declRefExpr(hasDeclaration(functionDecl(hasName(MatchText)))))));
 
   // CallExpr: warning, fix-it.
-  Finder->addMatcher(callExpr(DirectCallToUncaughtException,
+  Finder->addMatcher(
+      traverse(TK_AsIs, callExpr(DirectCallToUncaughtException,
                                  unless(hasAncestor(initListExpr())))
-                         .bind("call_expr"),
-                     this);
+                            .bind("call_expr")),
   // CallExpr in initialisation list: warning, fix-it with avoiding narrowing
   // conversions.
-  Finder->addMatcher(callExpr(DirectCallToUncaughtException,
+  Finder->addMatcher(traverse(TK_AsIs, callExpr(DirectCallToUncaughtException,
                                                 hasAncestor(initListExpr()))
-                         .bind("init_call_expr"),
+                                           .bind("init_call_expr")),
                      this);
 }
 
 void UseUncaughtExceptionsCheck::check(const MatchFinder::MatchResult &Result) {
   SourceLocation BeginLoc;
   SourceLocation EndLoc;
   const CallExpr *C = Result.Nodes.getNodeAs<CallExpr>("init_call_expr");
   bool WarnOnly = false;

clang-tools-extra/clang-tidy/performance/FasterStringFindCheck.cpp

void FasterStringFindCheck::registerMatchers(MatchFinder *Finder) {
 
   const auto SingleChar =
       expr(ignoringParenCasts(stringLiteral(hasSize(1)).bind("literal")));
   const auto StringFindFunctions =
       hasAnyName("find", "rfind", "find_first_of", "find_first_not_of",
                  "find_last_of", "find_last_not_of");
 
   Finder->addMatcher(
+      traverse(TK_AsIs,
                cxxMemberCallExpr(
                    callee(functionDecl(StringFindFunctions).bind("func")),
                    anyOf(argumentCountIs(1), argumentCountIs(2)),
                    hasArgument(0, SingleChar),
-          on(expr(
-              hasType(hasUnqualifiedDesugaredType(recordType(hasDeclaration(
-                  recordDecl(hasAnyName(SmallVector<StringRef, 4>(
-                      StringLikeClasses.begin(), StringLikeClasses.end()))))))),
-              unless(hasSubstitutedType())))),
+                   on(expr(hasType(hasUnqualifiedDesugaredType(
+                               recordType(hasDeclaration(recordDecl(
+                                   hasAnyName(SmallVector<StringRef, 4>(
+                                       StringLikeClasses.begin(),
+                                       StringLikeClasses.end()))))))),
+                           unless(hasSubstitutedType()))))),
       this);
 }
 
 void FasterStringFindCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *Literal = Result.Nodes.getNodeAs<StringLiteral>("literal");
   const auto *FindFunc = Result.Nodes.getNodeAs<FunctionDecl>("func");
 
   auto Replacement = MakeCharacterLiteral(Literal);

clang-tools-extra/clang-tidy/readability/ContainerSizeEmptyCheck.cpp

const auto WrongUse = traverse(
           hasParent(implicitCastExpr(
               hasImplicitDestinationType(booleanType()),
               anyOf(hasParent(
                         unaryOperator(hasOperatorName("!")).bind("NegOnSize")),
                     anything()))),
           hasParent(explicitCastExpr(hasDestinationType(booleanType())))));
 
   Finder->addMatcher(
-      cxxMemberCallExpr(on(expr(anyOf(hasType(ValidContainer),
-                                      hasType(pointsTo(ValidContainer)),
-                                      hasType(references(ValidContainer))))),
-                        callee(cxxMethodDecl(hasName("size"))), WrongUse,
-                        unless(hasAncestor(cxxMethodDecl(
-                            ofClass(equalsBoundNode("container"))))))
-          .bind("SizeCallExpr"),
+      traverse(TK_AsIs,
+               cxxMemberCallExpr(
+                   on(expr(anyOf(hasType(ValidContainer),
+                   unless(hasAncestor(
+                       cxxMethodDecl(ofClass(equalsBoundNode("container"))))))
+                   .bind("SizeCallExpr")),
       this);
 
   // Empty constructor matcher.
   const auto DefaultConstructor = cxxConstructExpr(
           hasDeclaration(cxxConstructorDecl(isDefaultConstructor())));
   // Comparison to empty string or empty constructor.
   const auto WrongComparend = anyOf(
       ignoringImpCasts(stringLiteral(hasSize(0))),
       ignoringImpCasts(cxxBindTemporaryExpr(has(DefaultConstructor))),
       ignoringImplicit(DefaultConstructor),
       cxxConstructExpr(
           hasDeclaration(cxxConstructorDecl(isCopyConstructor())),
           has(expr(ignoringImpCasts(DefaultConstructor)))),
       cxxConstructExpr(
           hasDeclaration(cxxConstructorDecl(isMoveConstructor())),
           has(expr(ignoringImpCasts(DefaultConstructor)))));
   // Match the object being compared.
   const auto STLArg =
       anyOf(unaryOperator(
                 hasOperatorName("*"),
                 hasUnaryOperand(
                     expr(hasType(pointsTo(ValidContainer))).bind("Pointee"))),
             expr(hasType(ValidContainer)).bind("STLObject"));
   Finder->addMatcher(
-      cxxOperatorCallExpr(
-          hasAnyOverloadedOperatorName("==", "!="),
-          anyOf(allOf(hasArgument(0, WrongComparend), hasArgument(1, STLArg)),
-                allOf(hasArgument(0, STLArg), hasArgument(1, WrongComparend))),
-          unless(hasAncestor(
-              cxxMethodDecl(ofClass(equalsBoundNode("container"))))))
-          .bind("BinCmp"),
+      traverse(TK_AsIs,
+               cxxOperatorCallExpr(hasAnyOverloadedOperatorName("==", "!="),
+                                   anyOf(allOf(hasArgument(0, WrongComparend),
+                                               hasArgument(1, STLArg)),
+                                         allOf(hasArgument(0, STLArg),
+                                               hasArgument(1, WrongComparend))),
+                                   unless(hasAncestor(cxxMethodDecl(
+                                       ofClass(equalsBoundNode("container"))))))
+                   .bind("BinCmp")),
       this);
 }
 
 void ContainerSizeEmptyCheck::check(const MatchFinder::MatchResult &Result) {
   const auto *MemberCall =
       Result.Nodes.getNodeAs<CXXMemberCallExpr>("SizeCallExpr");
   const auto *BinCmp = Result.Nodes.getNodeAs<CXXOperatorCallExpr>("BinCmp");
   const auto *BinaryOp = Result.Nodes.getNodeAs<BinaryOperator>("SizeBinaryOp");

clang-tools-extra/clang-tidy/readability/QualifiedAutoCheck.cpp

auto ExplicitSingleVarDeclInTemplate =
             isInTemplateInstantiation(),
             hasSingleDecl(
                 varDecl(unless(isImplicit()), InnerMatcher).bind(ID)));
       };
 
   auto IsBoundToType = refersToType(equalsBoundNode("type"));
 
   Finder->addMatcher(
-      ExplicitSingleVarDecl(hasType(autoType(hasDeducedType(
+      traverse(TK_AsIs, ExplicitSingleVarDecl(
+                            hasType(autoType(hasDeducedType(
                                 pointerType(pointee(unless(functionType())))))),
-                            "auto"),
+                            "auto")),
       this);
 
   Finder->addMatcher(
+      traverse(TK_AsIs,
                ExplicitSingleVarDeclInTemplate(
-          allOf(hasType(autoType(hasDeducedType(pointerType(
-                    pointee(hasUnqualifiedType(qualType().bind("type")),
+                   allOf(hasType(autoType(hasDeducedType(pointerType(pointee(
+                             hasUnqualifiedType(qualType().bind("type")),
                              unless(functionType())))))),
-                anyOf(hasAncestor(
-                          functionDecl(hasAnyTemplateArgument(IsBoundToType))),
+                         anyOf(hasAncestor(functionDecl(
+                                   hasAnyTemplateArgument(IsBoundToType))),
                                hasAncestor(classTemplateSpecializationDecl(
                                    hasAnyTemplateArgument(IsBoundToType))))),
-          "auto"),
+                   "auto")),
       this);
   if (!AddConstToQualified)
     return;
-  Finder->addMatcher(ExplicitSingleVarDecl(
-                         hasType(pointerType(pointee(autoType()))), "auto_ptr"),
-                     this);
+  Finder->addMatcher(
+      traverse(TK_AsIs,
+               ExplicitSingleVarDecl(hasType(pointerType(pointee(autoType()))),
+                                     "auto_ptr")),
   Finder->addMatcher(
-      ExplicitSingleVarDecl(hasType(lValueReferenceType(pointee(autoType()))),
-                            "auto_ref"),
+      traverse(TK_AsIs, ExplicitSingleVarDecl(
+                            hasType(lValueReferenceType(pointee(autoType()))),
+                            "auto_ref")),
       this);
 }
 
 void QualifiedAutoCheck::check(const MatchFinder::MatchResult &Result) {
   if (const auto *Var = Result.Nodes.getNodeAs<VarDecl>("auto")) {
     SourceRange TypeSpecifier;
     if (llvm::Optional<SourceRange> TypeSpec =
             getTypeSpecifierLocation(Var, Result)) {

clang-tools-extra/clang-tidy/readability/StaticAccessedThroughInstanceCheck.cpp

void StaticAccessedThroughInstanceCheck::storeOptions(
     ClangTidyOptions::OptionMap &Opts) {
   Options.store(Opts, "NameSpecifierNestingThreshold",
                 NameSpecifierNestingThreshold);
 }
 
 void StaticAccessedThroughInstanceCheck::registerMatchers(MatchFinder *Finder) {
   Finder->addMatcher(
       memberExpr(hasDeclaration(anyOf(cxxMethodDecl(isStaticStorageClass()),
-                                      varDecl(hasStaticStorageDuration()))),
-                 unless(isInTemplateInstantiation()))
+                                      varDecl(hasStaticStorageDuration()))))
           .bind("memberExpression"),
       this);
 }
 
 void StaticAccessedThroughInstanceCheck::check(
     const MatchFinder::MatchResult &Result) {
   const auto *MemberExpression =
       Result.Nodes.getNodeAs<MemberExpr>("memberExpression");

clang-tools-extra/clang-tidy/zircon/TemporaryObjectsCheck.cpp

 AST_MATCHER_P(CXXRecordDecl, matchesAnyName, ArrayRef<std::string>, Names) {
   std::string QualifiedName = Node.getQualifiedNameAsString();
   return llvm::any_of(Names,
                       [&](StringRef Name) { return QualifiedName == Name; });
 }
 
 void TemporaryObjectsCheck::registerMatchers(MatchFinder *Finder) {
   // Matcher for default constructors.
-  Finder->addMatcher(
-      cxxTemporaryObjectExpr(hasDeclaration(cxxConstructorDecl(hasParent(
+  Finder->addMatcher(traverse(ast_type_traits::TK_AsIs,
+                              cxxTemporaryObjectExpr(
+                                  hasDeclaration(cxxConstructorDecl(hasParent(
                                       cxxRecordDecl(matchesAnyName(Names))))))
-          .bind("temps"),
+                                  .bind("temps")),
                      this);
 
   // Matcher for user-defined constructors.
   Finder->addMatcher(
       traverse(ast_type_traits::TK_AsIs,
                cxxConstructExpr(hasParent(cxxFunctionalCastExpr()),
                                 hasDeclaration(cxxConstructorDecl(hasParent(
                                     cxxRecordDecl(matchesAnyName(Names))))))
                    .bind("temps")),

clang/include/clang/AST/ASTNodeTraverser.h

class ASTNodeTraverser
   }
   Derived &getDerived() { return *static_cast<Derived *>(this); }
 
 public:
   void setDeserialize(bool D) { Deserialize = D; }
   bool getDeserialize() const { return Deserialize; }
 
   void SetTraversalKind(TraversalKind TK) { Traversal = TK; }
+  TraversalKind GetTraversalKind() const { return Traversal; }
 
   void Visit(const Decl *D) {
     getNodeDelegate().AddChild([=] {
       getNodeDelegate().Visit(D);
       if (!D)
         return;
 
       ConstDeclVisitor<Derived>::Visit(D);
public:
   }
 
   template <typename TemplateDecl>
   void dumpTemplateDecl(const TemplateDecl *D) {
     dumpTemplateParameters(D->getTemplateParameters());
 
     Visit(D->getTemplatedDecl());
 
+    if (Traversal == TK_AsIs)
       for (const auto *Child : D->specializations())
         dumpTemplateDeclSpecialization(Child);
   }
 
   void VisitTypeAliasDecl(const TypeAliasDecl *D) {
     Visit(D->getUnderlyingType());
   }
 
   void VisitTypeAliasTemplateDecl(const TypeAliasTemplateDecl *D) {
     dumpTemplateParameters(D->getTemplateParameters());

clang/include/clang/ASTMatchers/ASTMatchersInternal.h

static_assert(std::is_base_of<Decl, T>::value ||
                       std::is_base_of<TypeLoc, T>::value,
                   "type not allowed for recursive matching");
     return matchesAncestorOf(DynTypedNode::create(Node), getASTContext(),
                              Matcher, Builder, MatchMode);
   }
 
   virtual ASTContext &getASTContext() const = 0;
 
+  virtual bool isMatchingInImplicitTemplateInstantiation() const = 0;
+
 protected:
   virtual bool matchesChildOf(const DynTypedNode &Node, ASTContext &Ctx,
                               const DynTypedMatcher &Matcher,
                               BoundNodesTreeBuilder *Builder,
                               TraversalKind Traverse, BindKind Bind) = 0;
 
   virtual bool matchesDescendantOf(const DynTypedNode &Node, ASTContext &Ctx,
                                    const DynTypedMatcher &Matcher,

clang/lib/AST/ASTDumper.cpp

 }
 
 template <typename TemplateDecl>
 void ASTDumper::dumpTemplateDecl(const TemplateDecl *D, bool DumpExplicitInst) {
   dumpTemplateParameters(D->getTemplateParameters());
 
   Visit(D->getTemplatedDecl());
 
+  if (GetTraversalKind() == TK_AsIs)
     for (const auto *Child : D->specializations())
       dumpTemplateDeclSpecialization(Child, DumpExplicitInst,
                                      !D->isCanonicalDecl());
 }
 
 void ASTDumper::VisitFunctionTemplateDecl(const FunctionTemplateDecl *D) {
   // FIXME: We don't add a declaration of a function template specialization
   // to its context when it's explicitly instantiated, so dump explicit
   // instantiations when we dump the template itself.
   dumpTemplateDecl(D, true);
 }

clang/lib/ASTMatchers/ASTMatchFinder.cpp

public:
   }
 
   // Implements ASTMatchFinder::getASTContext.
   ASTContext &getASTContext() const override { return *ActiveASTContext; }
 
   bool shouldVisitTemplateInstantiations() const { return true; }
   bool shouldVisitImplicitCode() const { return true; }
 
+  bool m_traversingImplicitTemplateInstantiation = false;
+
+  bool isMatchingInImplicitTemplateInstantiation() const override {
+    return m_traversingImplicitTemplateInstantiation;
+  }
+
+  struct ImplicitTemplateInstantiationScope {
+    ImplicitTemplateInstantiationScope(MatchASTVisitor *V, bool b) : m_V(V) {
+      m_B = V->m_traversingImplicitTemplateInstantiation;
+      V->m_traversingImplicitTemplateInstantiation = b;
+    }
+    ~ImplicitTemplateInstantiationScope() {
+      m_V->m_traversingImplicitTemplateInstantiation = m_B;
+    }
+
+  private:
+    MatchASTVisitor *m_V;
+    bool m_B;
+  };
+
+#define TRY_TO(CALL_EXPR)                                                      \
+  do {                                                                         \
+    if (!getDerived().CALL_EXPR)                                               \
+      return false;                                                            \
+  } while (false)
+
+  bool TraverseTemplateInstantiations(ClassTemplateDecl *D) {
+    for (auto *SD : D->specializations()) {
+      for (auto *RD : SD->redecls()) {
+        // We don't want to visit injected-class-names in this traversal.
+        if (cast<CXXRecordDecl>(RD)->isInjectedClassName())
+          continue;
+
+        switch (cast<ClassTemplateSpecializationDecl>(RD)
+                    ->getSpecializationKind()) {
+        // Visit the implicit instantiations with the requested pattern.
+        case TSK_Undeclared:
+        case TSK_ImplicitInstantiation: {
+          ImplicitTemplateInstantiationScope RAII(this, true);
+          TRY_TO(TraverseDecl(RD));
+          break;
+        }
+
+        // We don't need to do anything on an explicit instantiation
+        // or explicit specialization because there will be an explicit
+        // node for it elsewhere.
+        case TSK_ExplicitInstantiationDeclaration:
+        case TSK_ExplicitInstantiationDefinition:
+        case TSK_ExplicitSpecialization:
+          break;
+        }
+      }
+    }
+
+    return true;
+  }
+
+  bool TraverseTemplateInstantiations(VarTemplateDecl *D) {
+    for (auto *SD : D->specializations()) {
+      for (auto *RD : SD->redecls()) {
+        switch (
+            cast<VarTemplateSpecializationDecl>(RD)->getSpecializationKind()) {
+        case TSK_Undeclared:
+        case TSK_ImplicitInstantiation: {
+          ImplicitTemplateInstantiationScope RAII(this, true);
+          TRY_TO(TraverseDecl(RD));
+          break;
+        }
+
+        case TSK_ExplicitInstantiationDeclaration:
+        case TSK_ExplicitInstantiationDefinition:
+        case TSK_ExplicitSpecialization:
+          break;
+        }
+      }
+    }
+
+    return true;
+  }
+
+  bool TraverseTemplateInstantiations(FunctionTemplateDecl *D) {
+    for (auto *FD : D->specializations()) {
+      for (auto *RD : FD->redecls()) {
+        switch (RD->getTemplateSpecializationKind()) {
+        case TSK_Undeclared:
+        case TSK_ImplicitInstantiation: {
+          // We don't know what kind of FunctionDecl this is.
+          ImplicitTemplateInstantiationScope RAII(this, true);
+          TRY_TO(TraverseDecl(RD));
+          break;
+        }
+
+        // FIXME: For now traverse explicit instantiations here. Change that
+        // once they are represented as dedicated nodes in the AST.
+        case TSK_ExplicitInstantiationDeclaration:
+        case TSK_ExplicitInstantiationDefinition:
+          TRY_TO(TraverseDecl(RD));
+          break;
+
+        case TSK_ExplicitSpecialization:
+          break;
+        }
+      }
+    }
+
+    return true;
+  }
+
 private:
   class TimeBucketRegion {
   public:
     TimeBucketRegion() : Bucket(nullptr) {}
     ~TimeBucketRegion() { setBucket(nullptr); }
 
     /// Start timing for \p NewBucket.
     ///

clang/lib/ASTMatchers/ASTMatchersInternal.cpp

 }
 
 bool DynTypedMatcher::matches(const DynTypedNode &DynNode,
                               ASTMatchFinder *Finder,
                               BoundNodesTreeBuilder *Builder) const {
   TraversalKindScope RAII(Finder->getASTContext(),
                           Implementation->TraversalKind());
 
+  if (Finder->getASTContext().getParentMapContext().getTraversalKind() ==
+      TK_IgnoreUnlessSpelledInSource) {
+    if (Finder->isMatchingInImplicitTemplateInstantiation()) {
+      return false;
+    }
+  }
+
   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 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)) {
     return true;
   }
   // Delete all bindings when a matcher does not match.
   // This prevents unexpected exposure of bound nodes in unmatches

clang/unittests/AST/ASTTraverserTest.cpp

#include "clang/Basic/AttrList.inc"
     }
     OS << "Attr";
   }
 
   void Visit(const OMPClause *C) { OS << "OMPClause"; }
   void Visit(const TemplateArgument &A, SourceRange R = {},
              const Decl *From = nullptr, const char *Label = nullptr) {
     OS << "TemplateArgument";
+    switch (A.getKind()) {
+    case TemplateArgument::Type: {
+      OS << " type " << A.getAsType().getAsString();
+      break;
+    }
+    default:
+      break;
+    }
   }
 
   template <typename... T> void Visit(T...) {}
 };
 
 class TestASTDumper : public ASTNodeTraverser<TestASTDumper, NodeTreePrinter> {
 
   NodeTreePrinter MyNodeRecorder;

 VarDecl 'c1'
 `-UnaryOperator
   `-DeclRefExpr 'c2'
 )cpp");
   }
 
   {
     auto FN = ast_matchers::match(
-        functionDecl(hasName("template_test"),
-                     hasDescendant(staticAssertDecl().bind("staticAssert"))),
+        traverse(TK_AsIs, functionDecl(hasName("template_test"),
+                                       hasDescendant(staticAssertDecl().bind(
+                                           "staticAssert")))),
         AST->getASTContext());
     EXPECT_EQ(FN.size(), 2u);
 
     EXPECT_EQ(dumpASTString(TK_AsIs, FN[1].getNodeAs<Decl>("staticAssert")),
               R"cpp(
 StaticAssertDecl
 |-ImplicitCastExpr
 | `-SubstNonTypeTemplateParmExpr

 | `-UnaryOperator
 |   `-CXXThisExpr
 `-CompoundStmt
 )cpp";
     EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource, L), Expected);
   }
 }
 
+TEST(Traverse, IgnoreUnlessSpelledInSourceTemplateInstantiations) {
+
+  auto AST = buildASTFromCode(R"cpp(
+template<typename T>
+struct TemplStruct {
+  TemplStruct() {}
+  ~TemplStruct() {}
+
+private:
+  T m_t;
+};
+
+template<typename T>
+T timesTwo(T input)
+{
+  return input * 2;
+}
+
+void instantiate()
+{
+  TemplStruct<int> ti;
+  TemplStruct<double> td;
+  (void)timesTwo<int>(2);
+  (void)timesTwo<double>(2);
+}
+)cpp");
+  {
+    auto BN = ast_matchers::match(
+        classTemplateDecl(hasName("TemplStruct")).bind("rec"),
+        AST->getASTContext());
+    EXPECT_EQ(BN.size(), 1u);
+
+    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
+                            BN[0].getNodeAs<Decl>("rec")),
+              R"cpp(
+ClassTemplateDecl 'TemplStruct'
+|-TemplateTypeParmDecl 'T'
+`-CXXRecordDecl 'TemplStruct'
+  |-CXXRecordDecl 'TemplStruct'
+  |-CXXConstructorDecl 'TemplStruct<T>'
+  | `-CompoundStmt
+  |-CXXDestructorDecl '~TemplStruct<T>'
+  | `-CompoundStmt
+  |-AccessSpecDecl
+  `-FieldDecl 'm_t'
+)cpp");
+
+    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("rec")),
+              R"cpp(
+ClassTemplateDecl 'TemplStruct'
+|-TemplateTypeParmDecl 'T'
+|-CXXRecordDecl 'TemplStruct'
+| |-CXXRecordDecl 'TemplStruct'
+| |-CXXConstructorDecl 'TemplStruct<T>'
+| | `-CompoundStmt
+| |-CXXDestructorDecl '~TemplStruct<T>'
+| | `-CompoundStmt
+| |-AccessSpecDecl
+| `-FieldDecl 'm_t'
+|-ClassTemplateSpecializationDecl 'TemplStruct'
+| |-TemplateArgument type int
+| |-CXXRecordDecl 'TemplStruct'
+| |-CXXConstructorDecl 'TemplStruct'
+| | `-CompoundStmt
+| |-CXXDestructorDecl '~TemplStruct'
+| | `-CompoundStmt
+| |-AccessSpecDecl
+| |-FieldDecl 'm_t'
+| `-CXXConstructorDecl 'TemplStruct'
+|   `-ParmVarDecl ''
+`-ClassTemplateSpecializationDecl 'TemplStruct'
+  |-TemplateArgument type double
+  |-CXXRecordDecl 'TemplStruct'
+  |-CXXConstructorDecl 'TemplStruct'
+  | `-CompoundStmt
+  |-CXXDestructorDecl '~TemplStruct'
+  | `-CompoundStmt
+  |-AccessSpecDecl
+  |-FieldDecl 'm_t'
+  `-CXXConstructorDecl 'TemplStruct'
+    `-ParmVarDecl ''
+)cpp");
+  }
+  {
+    auto BN = ast_matchers::match(
+        functionTemplateDecl(hasName("timesTwo")).bind("fn"),
+        AST->getASTContext());
+    EXPECT_EQ(BN.size(), 1u);
+
+    EXPECT_EQ(dumpASTString(TK_IgnoreUnlessSpelledInSource,
+                            BN[0].getNodeAs<Decl>("fn")),
+              R"cpp(
+FunctionTemplateDecl 'timesTwo'
+|-TemplateTypeParmDecl 'T'
+`-FunctionDecl 'timesTwo'
+  |-ParmVarDecl 'input'
+  `-CompoundStmt
+    `-ReturnStmt
+      `-BinaryOperator
+        |-DeclRefExpr 'input'
+        `-IntegerLiteral
+)cpp");
+
+    EXPECT_EQ(dumpASTString(TK_AsIs, BN[0].getNodeAs<Decl>("fn")),
+              R"cpp(
+FunctionTemplateDecl 'timesTwo'
+|-TemplateTypeParmDecl 'T'
+|-FunctionDecl 'timesTwo'
+| |-ParmVarDecl 'input'
+| `-CompoundStmt
+|   `-ReturnStmt
+|     `-BinaryOperator
+|       |-DeclRefExpr 'input'
+|       `-IntegerLiteral
+|-FunctionDecl 'timesTwo'
+| |-TemplateArgument type int
+| |-ParmVarDecl 'input'
+| `-CompoundStmt
+|   `-ReturnStmt
+|     `-BinaryOperator
+|       |-ImplicitCastExpr
+|       | `-DeclRefExpr 'input'
+|       `-IntegerLiteral
+`-FunctionDecl 'timesTwo'
+  |-TemplateArgument type double
+  |-ParmVarDecl 'input'
+  `-CompoundStmt
+    `-ReturnStmt
+      `-BinaryOperator
+        |-ImplicitCastExpr
+        | `-DeclRefExpr 'input'
+        `-ImplicitCastExpr
+          `-IntegerLiteral
+)cpp");
+  }
+}
+
 } // namespace clang

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

 )cpp";
   EXPECT_TRUE(matches(
       Code,
       traverse(TK_AsIs,
                staticAssertDecl(has(implicitCastExpr(has(
                    substNonTypeTemplateParmExpr(has(integerLiteral())))))))));
 
   EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource,
-                                     staticAssertDecl(has(integerLiteral())))));
+                                     staticAssertDecl(has(declRefExpr())))));
+
+  Code = R"cpp(
+
+template<typename T>
+struct TemplStruct {
+  TemplStruct() {}
+  ~TemplStruct() {}
+
+private:
+  T m_t;
+};
+
+template<typename T>
+T timesTwo(T input)
+{
+  return input * 2;
+}
+
+void instantiate()
+{
+  TemplStruct<int> ti;
+  TemplStruct<double> td;
+  (void)timesTwo<int>(2);
+  (void)timesTwo<double>(2);
+}
+
+)cpp";
+  {
+    auto M = cxxRecordDecl(hasName("TemplStruct"),
+                           has(fieldDecl(hasType(asString("int")))));
+    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
+    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
+  }
+  {
+    auto M = cxxRecordDecl(hasName("TemplStruct"),
+                           has(fieldDecl(hasType(asString("double")))));
+    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
+    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
+  }
+  {
+    auto M = cxxRecordDecl(hasName("TemplStruct"),
+                           has(fieldDecl(hasType(asString("double")))));
+    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
+    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
+  }
+  {
+    auto M =
+        functionDecl(hasName("timesTwo"),
+                     hasParameter(0, parmVarDecl(hasType(asString("int")))));
+    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
+    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
+  }
+  {
+    auto M =
+        functionDecl(hasName("timesTwo"),
+                     hasParameter(0, parmVarDecl(hasType(asString("double")))));
+    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
+    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
+  }
 }
 
 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(CXXNewExpr, Array) {
   EXPECT_TRUE(
       notMatches("void foo() { int *Ptr = new int[20]; }", NewArraySize10));
 }
 
 TEST(CXXNewExpr, PlacementArgs) {
   StatementMatcher IsPlacementNew = cxxNewExpr(hasAnyPlacementArg(anything()));
 
   EXPECT_TRUE(matches(R"(
-    void* operator new(decltype(sizeof(void*)), void*); 
+    void* operator new(decltype(sizeof(void*)), void*);
     int *foo(void* Storage) {
-      return new (Storage) int; 
+      return new (Storage) int;
     })",
                       IsPlacementNew));
 
   EXPECT_TRUE(matches(R"(
-    void* operator new(decltype(sizeof(void*)), void*, unsigned); 
+    void* operator new(decltype(sizeof(void*)), void*, unsigned);
     int *foo(void* Storage) {
-      return new (Storage, 16) int; 
+      return new (Storage, 16) int;
     })",
                       cxxNewExpr(hasPlacementArg(
                           1, ignoringImpCasts(integerLiteral(equals(16)))))));
 
   EXPECT_TRUE(notMatches(R"(
-    void* operator new(decltype(sizeof(void*)), void*); 
+    void* operator new(decltype(sizeof(void*)), void*);
     int *foo(void* Storage) {
-      return new int; 
+      return new int;
     })",
                          IsPlacementNew));
 }
 
 } // namespace ast_matchers
 } // namespace clang

clang/unittests/Tooling/TransformerTest.cpp

TEST_F(TransformerTest, ErrorOccurredMatchSkipped) {
   T.registerMatchers(&MatchFinder);
   // The rewrite process itself fails...
   EXPECT_FALSE(rewrite(Input));
   // ... and no changes or errors are produced in the process.
   EXPECT_THAT(Changes, IsEmpty());
   EXPECT_EQ(ErrorCount, 0);
 }
 
+TEST_F(TransformerTest, TemplateInstantiation) {
+
+  std::string NonTemplatesInput = R"cpp(
+struct S {
+  int m_i;
+};
+)cpp";
+  std::string NonTemplatesExpected = R"cpp(
+struct S {
+  safe_int m_i;
+};
+)cpp";
+
+  std::string TemplatesInput = R"cpp(
+template<typename T>
+struct TemplStruct {
+  TemplStruct() {}
+  ~TemplStruct() {}
+
+private:
+  T m_t;
+};
+
+void instantiate()
+{
+  TemplStruct<int> ti;
+}
+)cpp";
+
+  auto MatchedField = fieldDecl(hasType(asString("int"))).bind("theField");
+
+  // Changes the 'int' in 'S', but not the 'T' in 'TemplStruct':
+  testRule(makeRule(traverse(TK_IgnoreUnlessSpelledInSource, MatchedField),
+                    changeTo(cat("safe_int ", name("theField")))),
+           NonTemplatesInput + TemplatesInput,
+           NonTemplatesExpected + TemplatesInput);
+
+  // In AsIs mode, template instantiations are modified, which is
+  // often not desired:
+
+  std::string IncorrectTemplatesExpected = R"cpp(
+template<typename T>
+struct TemplStruct {
+  TemplStruct() {}
+  ~TemplStruct() {}
+
+private:
+  safe_int m_t;
+};
+
+void instantiate()
+{
+  TemplStruct<int> ti;
+}
+)cpp";
+
+  // Changes the 'int' in 'S', and (incorrectly) the 'T' in 'TemplStruct':
+  testRule(makeRule(traverse(TK_AsIs, MatchedField),
+                    changeTo(cat("safe_int ", name("theField")))),
+
+           NonTemplatesInput + TemplatesInput,
+           NonTemplatesExpected + IncorrectTemplatesExpected);
+}
+
 // Transformation of macro source text when the change encompasses the entirety
 // of the expanded text.
 TEST_F(TransformerTest, SimpleMacro) {
   std::string Input = R"cc(
 #define ZERO 0
     int f(string s) { return ZERO; }
   )cc";
   std::string Expected = R"cc(