[change-namespace] check using shadow decl correctly when shortening namespace specifiers.

[ioeric]

Summary

This fixes mismatch between template decls and template specialization decls.

Also added a few more test cases.

[bkramer]

lg

clang-tools-extra/trunk/change-namespace/ChangeNamespace.cpp

void ChangeNamespaceTool::replaceQualifiedSymbolInDeclContext(
   // qualified name.
   bool Matched = false;
   for (const UsingDecl *Using : UsingDecls) {
     if (Matched)
       break;
     if (isDeclVisibleAtLocation(*Result.SourceManager, Using, DeclCtx, Start)) {
       for (const auto *UsingShadow : Using->shadows()) {
         const auto *TargetDecl = UsingShadow->getTargetDecl();
-        if (TargetDecl == FromDecl) {
+        if (TargetDecl->getQualifiedNameAsString() ==
+            FromDecl->getQualifiedNameAsString()) {
           ReplaceName = FromDecl->getNameAsString();
           Matched = true;
           break;
         }
       }
     }
   }
   // If the new nested name in the new namespace is the same as it was in the

clang-tools-extra/trunk/unittests/change-namespace/ChangeNamespaceTests.cpp

std::string Expected = "namespace nx { void f(); void g(); }\n"
                          "void d() { f(); ::nx::g(); }\n"
                          "} // namespace y\n"
                          "} // namespace x\n"
                          "} // b\n"
                          "} // a\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
-TEST_F(ChangeNamespaceTest, UsingDeclInTheParentOfOldNamespace) {
+TEST_F(ChangeNamespaceTest, UsingShadowDeclInTheParentOfOldNamespace) {
   OldNamespace = "nb::nc";
   NewNamespace = "nb::nd";
   std::string Code = "namespace na { class A {}; }\n"
                      "namespace nb {\n"
                      "using na::A;\n"
                      "namespace nc {\n"
                      "void d() { A a; }\n"
                      "} // nc\n"
                      "} // nb\n";
 
   std::string Expected = "namespace na { class A {}; }\n"
                          "namespace nb {\n"
                          "using na::A;\n"
                          "\n"
                          "namespace nd {\n"
                          "void d() { A a; }\n"
                          "} // namespace nd\n"
                          "} // nb\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
+TEST_F(ChangeNamespaceTest, UsingShadowDeclInOldNamespace) {
+  OldNamespace = "nb";
+  NewNamespace = "nc";
+  std::string Code = "namespace na { class A {}; }\n"
+                     "namespace nb {\n"
+                     "using na::A;\n"
+                     "void d() { A a; }\n"
+                     "struct X { A a; };\n"
+                     "} // nb\n";
+
+  std::string Expected = "namespace na { class A {}; }\n"
+                         "\n"
+                         "namespace nc {\n"
+                         "using ::na::A;\n"
+                         "void d() { A a; }\n"
+                         "struct X { A a; };\n"
+                         "} // namespace nc\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, UsingShadowDeclOfTemplateClass) {
+  OldNamespace = "nb";
+  NewNamespace = "nc";
+  std::string Code = "namespace na {\n"
+                     "template <typename T>\n"
+                     "class A { T t; };\n"
+                     "} // namespace na\n"
+                     "namespace nb {\n"
+                     "using na::A;\n"
+                     "void d() { A<int> a; }\n"
+                     "} // nb\n";
+
+  std::string Expected = "namespace na {\n"
+                         "template <typename T>\n"
+                         "class A { T t; };\n"
+                         "} // namespace na\n"
+                         "\n"
+                         "namespace nc {\n"
+                         "using ::na::A;\n"
+                         "void d() { A<int> a; }\n"
+                         "} // namespace nc\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, UsingShadowDeclOfTemplateFunction) {
+  OldNamespace = "nb";
+  NewNamespace = "nc";
+  std::string Code = "namespace na {\n"
+                     "template <typename T>\n"
+                     "void f() { T t; };\n"
+                     "} // namespace na\n"
+                     "namespace nb {\n"
+                     "using na::f;\n"
+                     "void d() { f<int>(); }\n"
+                     "} // nb\n";
+
+  std::string Expected = "namespace na {\n"
+                         "template <typename T>\n"
+                         "void f() { T t; };\n"
+                         "} // namespace na\n"
+                         "\n"
+                         "namespace nc {\n"
+                         "using ::na::f;\n"
+                         "void d() { f<int>(); }\n"
+                         "} // namespace nc\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
 TEST_F(ChangeNamespaceTest, UsingAliasDecl) {
   std::string Code =
       "namespace nx { namespace ny { class X {}; } }\n"
       "namespace na {\n"
       "namespace nb {\n"
       "using Y = nx::ny::X;\n"
       "void f() { Y y; }\n"
       "} // namespace nb\n"