[ASTMatchers] Omit methods from explicit template instantations

[aaron.ballman]

LGTM with a commenting nit.

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

2288–2289

2336

clang/lib/ASTMatchers/ASTMatchFinder.cpp

bool MatchASTVisitor::TraverseDecl(Decl *DeclNode) {
   if (const auto *CTSD = dyn_cast<ClassTemplateSpecializationDecl>(DeclNode)) {
     auto SK = CTSD->getSpecializationKind();
     if (SK == TSK_ExplicitInstantiationDeclaration ||
         SK == TSK_ExplicitInstantiationDefinition)
       ScopedChildren = true;
   } else if (const auto *FD = dyn_cast<FunctionDecl>(DeclNode)) {
     if (FD->isDefaulted())
       ScopedChildren = true;
+    if (FD->isTemplateInstantiation())
+      ScopedTraversal = true;
   }
 
   ASTNodeNotSpelledInSourceScope RAII1(this, ScopedTraversal);
   ASTChildrenNotSpelledInSourceScope RAII2(this, ScopedChildren);
 
   match(*DeclNode);
   return RecursiveASTVisitor<MatchASTVisitor>::TraverseDecl(DeclNode);
 }

clang/unittests/ASTMatchers/ASTMatchersTraversalTest.cpp

)cpp";
 
   Code = R"cpp(
 
 template<typename T>
 struct TemplStruct {
   TemplStruct() {}
   ~TemplStruct() {}
 
+  void outOfLine(T);
+
 private:
   T m_t;
 };
 
 template<typename T>
+void TemplStruct<T>::outOfLine(T)
+{
+
+}
+
+template<typename T>
 T timesTwo(T input)
 {
   return input * 2;
 }
 
 void instantiate()
 {
   TemplStruct<int> ti;
)cpp";
     EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MDef)));
     EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MDef)));
 
     auto MTempl =
         functionDecl(hasName("timesTwo"),
                      hasTemplateArgument(0, refersToType(asString("float"))));
     EXPECT_TRUE(matches(Code, traverse(TK_AsIs, MTempl)));
     // TODO: If we could match on explicit instantiations of function templates,
-    // this would be EXPECT_TRUE.
+    // this would be EXPECT_TRUE. See Sema::ActOnExplicitInstantiation.
     EXPECT_FALSE(
         matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, MTempl)));
   }
   {
     auto M = functionDecl(hasName("timesTwo"),
                           hasParameter(0, parmVarDecl(hasType(booleanType()))));
     EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
     EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
   }
auto M = classTemplateSpecializationDecl(
         hasName("TemplStruct"),
         hasTemplateArgument(0,
                             templateArgument(refersToType(asString("long")))),
         has(cxxConstructorDecl(hasName("TemplStruct"))));
     EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
     EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
   }
   {
+    // Instantiated, out-of-line methods are not matchable.
+    auto M =
+        cxxMethodDecl(hasName("outOfLine"), isDefinition(),
+                      hasParameter(0, parmVarDecl(hasType(asString("float")))));
+    EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
+    EXPECT_FALSE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));
+  }
+  {
     // Explicit specialization is written in source and it matches:
     auto M = classTemplateSpecializationDecl(
         hasName("TemplStruct"),
         hasTemplateArgument(0, templateArgument(refersToType(booleanType()))),
         has(cxxConstructorDecl(hasName("TemplStruct"))),
         has(cxxMethodDecl(hasName("boolSpecializationMethodOnly"))));
     EXPECT_TRUE(matches(Code, traverse(TK_AsIs, M)));
     EXPECT_TRUE(matches(Code, traverse(TK_IgnoreUnlessSpelledInSource, M)));