[change-namespace] do not rename specialized template parameters.

[hokein]

LGTM.

change-namespace/ChangeNamespace.cpp

return SM.isBeforeInTranslationUnit(DeclLoc, Loc) &&
          (SM.getFileID(DeclLoc) == SM.getFileID(Loc) &&
           isNestedDeclContext(DeclCtx, D->getDeclContext()));
 }
 
 AST_MATCHER(EnumDecl, isScoped) {
     return Node.isScoped();
 }
 
+bool isTemplateParameter(TypeLoc Type) {
+  while (!Type.isNull()) {
+    if (Type.getTypeLocClass() == TypeLoc::SubstTemplateTypeParm)
+      return true;
+    Type = Type.getNextTypeLoc();
+  }
+  return false;
+}
+
 } // anonymous namespace
 
 ChangeNamespaceTool::ChangeNamespaceTool(
     llvm::StringRef OldNs, llvm::StringRef NewNs, llvm::StringRef FilePattern,
     llvm::ArrayRef<std::string> WhiteListedSymbolPatterns,
     std::map<std::string, tooling::Replacements> *FileToReplacements,
     llvm::StringRef FallbackStyle)
     : FallbackStyle(FallbackStyle), FileToReplacements(*FileToReplacements),
void ChangeNamespaceTool::fixTypeLoc(
     const ast_matchers::MatchFinder::MatchResult &Result, SourceLocation Start,
     SourceLocation End, TypeLoc Type) {
   // FIXME: do not rename template parameter.
   if (Start.isInvalid() || End.isInvalid())
     return;
   // Types of CXXCtorInitializers do not need to be fixed.
   if (llvm::is_contained(BaseCtorInitializerTypeLocs, Type))
     return;
+  if (isTemplateParameter(Type))
+    return;
   // The declaration which this TypeLoc refers to.
   const auto *FromDecl = Result.Nodes.getNodeAs<NamedDecl>("from_decl");
   // `hasDeclaration` gives underlying declaration, but if the type is
   // a typedef type, we need to use the typedef type instead.
   auto IsInMovedNs = [&](const NamedDecl *D) {
     if (!llvm::StringRef(D->getQualifiedNameAsString())
              .startswith(OldNamespace + "::"))
       return false;

unittests/change-namespace/ChangeNamespaceTests.cpp

std::string Expected = "namespace na {\n"
                          "  ::na::X::E ee = ::na::X::E::E1;\n"
                          "}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
 
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
+TEST_F(ChangeNamespaceTest, TypeAsTemplateParameter) {
+  std::string Code = "namespace na {\n"
+                     "struct X {};\n"
+                     "namespace nb {\n"
+                     "template <typename TT>\n"
+                     "void TempTemp(const TT& t) {\n"
+                     "  TT tmp;\n"
+                     "}\n"
+                     "template <typename T>\n"
+                     "void Temp(const T& t) {\n"
+                     "  T tmp = t;\n"
+                     "  TempTemp(tmp);\n"
+                     "  TempTemp(t);\n"
+                     "}\n"
+                     "void f() {\n"
+                     "  X x;\n"
+                     "  Temp(x);\n"
+                     "}\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n";
+  std::string Expected = "namespace na {\n"
+                         "struct X {};\n"
+                         "\n"
+                         "} // namespace na\n"
+                         "namespace x {\n"
+                         "namespace y {\n"
+                         "template <typename TT>\n"
+                         "void TempTemp(const TT& t) {\n"
+                         "  TT tmp;\n"
+                         "}\n"
+                         "template <typename T>\n"
+                         "void Temp(const T& t) {\n"
+                         "  T tmp = t;\n"
+                         "  TempTemp(tmp);\n"
+                         "  TempTemp(t);\n"
+                         "}\n"
+                         "void f() {\n"
+                         "  ::na::X x;\n"
+                         "  Temp(x);\n"
+                         "}\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
 } // anonymous namespace
 } // namespace change_namespace
 } // namespace clang