[ASTMatchers] isTemplateInstantiation: also match explicit instantiation declaration.

[ioeric]

Summary

Example:
template <typename T> class X {}; class A {};
// Explicit instantiation declaration.
extern template class X<A>;

[bkramer]

lg

cfe/trunk/include/clang/ASTMatchers/ASTMatchers.h

 /// Given
 /// \code
 ///   template <typename T> class X {}; class A {}; X<A> x;
 /// \endcode
 /// or
 /// \code
 ///   template <typename T> class X {}; class A {}; template class X<A>;
 /// \endcode
+/// or
+/// \code
+///   template <typename T> class X {}; class A {}; extern template class X<A>;
+/// \endcode
 /// cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
 ///   matches the template instantiation of X<A>.
 ///
 /// But given
 /// \code
 ///   template <typename T>  class X {}; class A {};
 ///   template <> class X<A> {}; X<A> x;
 /// \endcode
 /// cxxRecordDecl(hasName("::X"), isTemplateInstantiation())
 ///   does not match, as X<A> is an explicit template specialization.
 ///
 /// Usable as: Matcher<FunctionDecl>, Matcher<VarDecl>, Matcher<CXXRecordDecl>
 AST_POLYMORPHIC_MATCHER(isTemplateInstantiation,
                         AST_POLYMORPHIC_SUPPORTED_TYPES(FunctionDecl, VarDecl,
                                                         CXXRecordDecl)) {
   return (Node.getTemplateSpecializationKind() == TSK_ImplicitInstantiation ||
           Node.getTemplateSpecializationKind() ==
-          TSK_ExplicitInstantiationDefinition);
+              TSK_ExplicitInstantiationDefinition ||
+          Node.getTemplateSpecializationKind() ==
+              TSK_ExplicitInstantiationDeclaration);
 }
 
 /// \brief Matches declarations that are template instantiations or are inside
 /// template instantiations.
 ///
 /// Given
 /// \code
 ///   template<typename T> void A(T t) { T i; }

cfe/trunk/unittests/ASTMatchers/ASTMatchersNarrowingTest.cpp

 }
 
 TEST(IsTemplateInstantiation, MatchesExplicitClassTemplateInstantiation) {
   EXPECT_TRUE(matches(
     "template <typename T> class X { T t; }; class A {};"
       "template class X<A>;",
     cxxRecordDecl(isTemplateInstantiation(), hasDescendant(
       fieldDecl(hasType(recordDecl(hasName("A"))))))));
+
+  // Make sure that we match the instantiation instead of the template
+  // definition by checking whether the member function is present.
+  EXPECT_TRUE(
+      matches("template <typename T> class X { void f() { T t; } };"
+              "extern template class X<int>;",
+              cxxRecordDecl(isTemplateInstantiation(),
+                            unless(hasDescendant(varDecl(hasName("t")))))));
 }
 
 TEST(IsTemplateInstantiation,
      MatchesInstantiationOfPartiallySpecializedClassTemplate) {
   EXPECT_TRUE(matches(
     "template <typename T> class X {};"
       "template <typename T> class X<T*> {}; class A {}; X<A*> x;",
     cxxRecordDecl(hasName("::X"), isTemplateInstantiation())));