[change-namespace] avoid adding leading '::' when possible.

[ioeric]

Summary

When changing namespaces, the tool adds leading "::" to references that need to
be fully-qualified, which would affect readability.

We avoid adding "::" when the symbol name does not conflict with the new
namespace name. For example, a symbol name "na::nb::X" conflicts with "ns::na"
since it would be resolved to "ns::na::nb::X" in the new namespace.

[hokein]

I like removing the leading "::" when possible. :)

change-namespace/ChangeNamespace.cpp

291

Is this needed? Looks like you are removing the name of the symbol here, but from the code below, you only use the first element of it. The QualifiedSymbol should always be a fully-qualified name with at least 1 namespace qualifier in the code, right?

296

Why skipping the first element? And use is_contained instead?

unittests/change-namespace/ChangeNamespaceTests.cpp

718

The code style is not correct. Also fix it.

[ioeric]

• Merged with origin/master
• Addressed comments. Merged with origin/master.

change-namespace/ChangeNamespace.cpp

291

QualifiedSymbol can be in the global namespace, so SymbolSplitted could be empty after pop_back.

296

See newly added comments for reasoning.

[ioeric]

Ping ;)

[hokein]

Sorry, I missed this patch.

LGTM with one nit.

change-namespace/ChangeNamespace.cpp

296

I see. This sounds the conflictInNamespace is too coupled with caller because it relies on "it equals to the symbol's outermost namespace and the symbol name would have been shortened" assumption. It is not straightforward especially for readers who read the code at the first time. So I'd like to search from 0 (and this operation is trivial).

[ioeric]

change-namespace/ChangeNamespace.cpp

296

This is also for correctness since it is really not a conflict when symbol and namespace has the same outer-most namespace. I could've dropped "the symbol name would have been shortened" part.

[ioeric]

• fixed newly added tests.

change-namespace/ChangeNamespace.cpp

joinNamespaces(const llvm::SmallVectorImpl<StringRef> &Namespaces) {
   if (Namespaces.empty())
     return "";
   std::string Result = Namespaces.front();
   for (auto I = Namespaces.begin() + 1, E = Namespaces.end(); I != E; ++I)
     Result += ("::" + *I).str();
   return Result;
 }
 
+// Given "a::b::c", returns {"a", "b", "c"}.
+llvm::SmallVector<llvm::StringRef, 4> splitSymbolName(llvm::StringRef Name) {
+  llvm::SmallVector<llvm::StringRef, 4> Splitted;
+  Name.split(Splitted, "::", /*MaxSplit=*/-1,
+             /*KeepEmpty=*/false);
+  return Splitted;
+}
+
 SourceLocation startLocationForType(TypeLoc TLoc) {
   // For elaborated types (e.g. `struct a::A`) we want the portion after the
   // `struct` but including the namespace qualifier, `a::`.
   if (TLoc.getTypeLocClass() == TypeLoc::Elaborated) {
     NestedNameSpecifierLoc NestedNameSpecifier =
         TLoc.castAs<ElaboratedTypeLoc>().getQualifierLoc();
     if (NestedNameSpecifier.getNestedNameSpecifier())
       return NestedNameSpecifier.getBeginLoc();

 // For example, if `InnerNs` is "a::b::c" and `PartialNsName` is "b::c", then
 // the NamespaceDecl of namespace "a" will be returned.
 const NamespaceDecl *getOuterNamespace(const NamespaceDecl *InnerNs,
                                        llvm::StringRef PartialNsName) {
   if (!InnerNs || PartialNsName.empty())
     return nullptr;
   const auto *CurrentContext = llvm::cast<DeclContext>(InnerNs);
   const auto *CurrentNs = InnerNs;
-  llvm::SmallVector<llvm::StringRef, 4> PartialNsNameSplitted;
-  PartialNsName.split(PartialNsNameSplitted, "::", /*MaxSplit=*/-1,
-                      /*KeepEmpty=*/false);
+  auto PartialNsNameSplitted = splitSymbolName(PartialNsName);
   while (!PartialNsNameSplitted.empty()) {
     // Get the inner-most namespace in CurrentContext.
     while (CurrentContext && !llvm::isa<NamespaceDecl>(CurrentContext))
       CurrentContext = CurrentContext->getParent();
     if (!CurrentContext)
       return nullptr;
     CurrentNs = llvm::cast<NamespaceDecl>(CurrentContext);
     if (PartialNsNameSplitted.back() != CurrentNs->getNameAsString())

 //        will have empty name.
 std::string getShortestQualifiedNameInNamespace(llvm::StringRef DeclName,
                                                 llvm::StringRef NsName) {
   DeclName = DeclName.ltrim(':');
   NsName = NsName.ltrim(':');
   if (DeclName.find(':') == llvm::StringRef::npos)
     return DeclName;
 
-  llvm::SmallVector<llvm::StringRef, 4> NsNameSplitted;
-  NsName.split(NsNameSplitted, "::", /*MaxSplit=*/-1,
-               /*KeepEmpty=*/false);
-  llvm::SmallVector<llvm::StringRef, 4> DeclNsSplitted;
-  DeclName.split(DeclNsSplitted, "::", /*MaxSplit=*/-1,
-               /*KeepEmpty=*/false);
+  auto NsNameSplitted = splitSymbolName(NsName);
+  auto DeclNsSplitted = splitSymbolName(DeclName);
   llvm::StringRef UnqualifiedDeclName = DeclNsSplitted.pop_back_val();
   // If the Decl is in global namespace, there is no need to shorten it.
   if (DeclNsSplitted.empty())
     return UnqualifiedDeclName;
   // If NsName is the global namespace, we can simply use the DeclName sans
   // leading "::".
   if (NsNameSplitted.empty())
     return DeclName;
return (DeclI == DeclE)
              ? UnqualifiedDeclName.str()
              : (llvm::join(DeclI, DeclE, "::") + "::" + UnqualifiedDeclName)
                    .str();
 }
 
 std::string wrapCodeInNamespace(StringRef NestedNs, std::string Code) {
   if (Code.back() != '\n')
     Code += "\n";
-  llvm::SmallVector<StringRef, 4> NsSplitted;
-  NestedNs.split(NsSplitted, "::", /*MaxSplit=*/-1,
-                 /*KeepEmpty=*/false);
+  auto NsSplitted = splitSymbolName(NestedNs);
   while (!NsSplitted.empty()) {
     // FIXME: consider code style for comments.
     Code = ("namespace " + NsSplitted.back() + " {\n" + Code +
             "} // namespace " + NsSplitted.back() + "\n")
                .str();
     NsSplitted.pop_back();
   }
   return Code;
bool isDeclVisibleAtLocation(const SourceManager &SM, const Decl *D,
                              const DeclContext *DeclCtx, SourceLocation Loc) {
   SourceLocation DeclLoc = SM.getSpellingLoc(D->getLocStart());
   Loc = SM.getSpellingLoc(Loc);
   return SM.isBeforeInTranslationUnit(DeclLoc, Loc) &&
          (SM.getFileID(DeclLoc) == SM.getFileID(Loc) &&
           isNestedDeclContext(DeclCtx, D->getDeclContext()));
 }
 
+// Given a qualified symbol name, returns true if the symbol will be
+// incorrectly qualified without leading "::".
+bool conflictInNamespace(llvm::StringRef QualifiedSymbol,
+                         llvm::StringRef Namespace) {
+  auto SymbolSplitted = splitSymbolName(QualifiedSymbol.trim(":"));
+  assert(!SymbolSplitted.empty());
+  SymbolSplitted.pop_back();
+
+  if (SymbolSplitted.size() > 1 && !Namespace.empty()) {
+    auto NsSplitted = splitSymbolName(Namespace.trim(":"));
+    assert(!NsSplitted.empty());
+    for (auto I = NsSplitted.begin() + 1, E = NsSplitted.end(); I != E; ++I) {
+      if (*I == SymbolSplitted.front())
+        return true;
+    }
+  }
+  return false;
+}
+
 AST_MATCHER(EnumDecl, isScoped) {
     return Node.isScoped();
 }
 
 } // 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),
       OldNamespace(OldNs.ltrim(':')), NewNamespace(NewNs.ltrim(':')),
       FilePattern(FilePattern), FilePatternRE(FilePattern) {
   FileToReplacements->clear();
-  llvm::SmallVector<llvm::StringRef, 4> OldNsSplitted;
-  llvm::SmallVector<llvm::StringRef, 4> NewNsSplitted;
-  llvm::StringRef(OldNamespace).split(OldNsSplitted, "::");
-  llvm::StringRef(NewNamespace).split(NewNsSplitted, "::");
+  auto OldNsSplitted = splitSymbolName(OldNamespace);
+  auto NewNsSplitted = splitSymbolName(NewNamespace);
   // Calculates `DiffOldNamespace` and `DiffNewNamespace`.
   while (!OldNsSplitted.empty() && !NewNsSplitted.empty() &&
          OldNsSplitted.front() == NewNsSplitted.front()) {
     OldNsSplitted.erase(OldNsSplitted.begin());
     NewNsSplitted.erase(NewNsSplitted.begin());
   }
   DiffOldNamespace = joinNamespaces(OldNsSplitted);
   DiffNewNamespace = joinNamespaces(NewNsSplitted);
void ChangeNamespaceTool::replaceQualifiedSymbolInDeclContext(
   }
   // If the new nested name in the new namespace is the same as it was in the
   // old namespace, we don't create replacement.
   if (NestedName == ReplaceName ||
       (NestedName.startswith("::") && NestedName.drop_front(2) == ReplaceName))
     return;
   // If the reference need to be fully-qualified, add a leading "::" unless
   // NewNamespace is the global namespace.
-  if (ReplaceName == FromDeclName && !NewNamespace.empty())
+  if (ReplaceName == FromDeclName && !NewNamespace.empty() &&
+      conflictInNamespace(ReplaceName, NewNamespace))
     ReplaceName = "::" + ReplaceName;
   addReplacementOrDie(Start, End, ReplaceName, *Result.SourceManager,
                       &FileToReplacements);
 }
 
 // Replace the [Start, End] of `Type` with the shortest qualified name when the
 // `Type` is in `NewNamespace`.
 void ChangeNamespaceTool::fixTypeLoc(

unittests/change-namespace/ChangeNamespaceTests.cpp

std::string Expected = "namespace x {\n"
                          "class T {};\n"
                          "} // namespace y\n"
                          "} // namespace x\n"
                          "namespace na {\n"
                          "class A {};\n\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
-                         "class X { ::na::A a; z::Z zz; T t; };\n"
+                         "class X { na::A a; z::Z zz; T t; };\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, SimpleMoveNestedNamespace) {
   NewNamespace = "na::x::y";
   std::string Code = "namespace na {\n"
std::string Expected = "namespace na {\n"
                          "class C_C {};"
                          "} // namespace nc\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "class C_X {\n"
                          "public:\n"
-                         "  ::na::C_A a;\n"
-                         "  ::na::nc::C_C c;\n"
+                         "  na::C_A a;\n"
+                         "  na::nc::C_C c;\n"
                          "};\n"
                          "class C_Y {\n"
                          "  C_X x;\n"
                          "};\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
std::string Expected = "namespace na {\n"
                          "class Two {};\n"
                          "namespace nc { class C {}; }\n"
                          "} // na\n"
                          "\n"
                          "\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "void f() {\n"
-                         "  ::na::B<::na::A> b;\n"
-                         "  ::na::B<::na::nc::C> b_c;\n"
-                         "  ::na::Two<::na::A, ::na::nc::C> two;\n"
+                         "  na::B<na::A> b;\n"
+                         "  na::B<na::nc::C> b_c;\n"
+                         "  na::Two<na::A, na::nc::C> two;\n"
                          "}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, LeaveForwardDeclarationBehind) {
   std::string Code = "namespace na {\n"
std::string Expected = "namespace na {\n"
                          "class FWD;\n"
                          "class FWD2;\n"
                          "} // namespace nb\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "\n"
                          "class A {\n"
-                         "  ::na::nb::FWD *fwd;\n"
+                         "  na::nb::FWD *fwd;\n"
                          "};\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, InsertForwardDeclsProperly) {
   std::string Code = "namespace na {\n"
std::string Expected = "namespace na {\n"
                          "class FWD;\n"
                          "class FWD2;\n"
                          "} // namespace nb\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "\n"
                          "class A {\n"
-                         "  ::na::nb::FWD *fwd;\n"
+                         "  na::nb::FWD *fwd;\n"
                          "};\n"
                          "\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, TemplateClassForwardDeclaration) {
std::string Expected = "namespace na {\n"
                          "class FWD;\n"
                          "template<typename T> class FWD_TEMP;\n"
                          "} // namespace nb\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "\n"
                          "class A {\n"
-                         "  ::na::nb::FWD *fwd;\n"
+                         "  na::nb::FWD *fwd;\n"
                          "};\n"
                          "template<typename T> class TEMP {};\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, DontMoveForwardDeclarationInClass) {
std::string Expected = "namespace na {\n"
                          "namespace nc {\n"
                          "class C_C {};"
                          "} // namespace nc\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "void fwd();\n"
-                         "void f(::na::C_A ca, ::na::nc::C_C cc) {\n"
-                         "  ::na::C_A ca_1 = ca;\n"
+                         "void f(na::C_A ca, na::nc::C_C cc) {\n"
+                         "  na::C_A ca_1 = ca;\n"
                          "}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, FixUsingShadowDecl) {
   std::string Code = "class GLOB {};\n"
std::string Expected = "class GLOB {};\n"
                          "namespace nd {\n"
                          "class SAME {};\n"
                          "}\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "using ::na::nc::SAME;\n"
-                         "using YO = ::na::nd::SAME;\n"
-                         "typedef ::na::nd::SAME IDENTICAL;\n"
-                         "void f(::na::nd::SAME Same) {}\n"
+                         "using YO = na::nd::SAME;\n"
+                         "typedef na::nd::SAME IDENTICAL;\n"
+                         "void f(na::nd::SAME Same) {}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, DontFixUsingShadowDeclInClasses) {
   std::string Code = "namespace na {\n"
                      "class A {};\n"
TEST_F(ChangeNamespaceTest, DontFixUsingShadowDeclInClasses) {
 
   std::string Expected = "namespace na {\n"
                          "class A {};\n"
                          "class Base { public: Base() {} void m() {} };\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
-                         "class D : public ::na::Base {\n"
+                         "class D : public na::Base {\n"
                          "public:\n"
-                         "  using AA = ::na::A; using B = ::na::Base;\n"
+                         "  using AA = na::A; using B = na::Base;\n"
                          "  using Base::m; using Base::Base;\n"
                          "};"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, TypeInNestedNameSpecifier) {
std::string Expected =
       "      static void nestedFunc() {}\n"
       "  };\n"
       "};\n"
       "\n"
       "}  // namespace na\n"
       "namespace x {\n"
       "namespace y {\n"
       "class C_X {\n"
-      "  ::na::C_A na;\n"
-      "  ::na::C_A::Nested nested;\n"
+      "  na::C_A na;\n"
+      "  na::C_A::Nested nested;\n"
       "  void f() {\n"
-      "    ::na::C_A::Nested::nestedFunc();\n"
-      "    int X = ::na::C_A::Nested::NestedX;\n"
+      "    na::C_A::Nested::nestedFunc();\n"
+      "    int X = na::C_A::Nested::NestedX;\n"
       "  }\n"
       "};\n"
       "}  // namespace y\n"
       "}  // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, FixFunctionNameSpecifiers) {
std::string Expected =
       "};\n"
       "void A::g() {}"
       "void a_f() {}\n"
       "static void static_f() {}\n"
       "\n"
       "}  // namespace na\n"
       "namespace x {\n"
       "namespace y {\n"
-      "void f() { ::na::a_f(); ::na::static_f(); ::na::A::f(); }\n"
-      "void g() { f(); ::na::A::g(); }\n"
+      "void f() { na::a_f(); na::static_f(); na::A::f(); }\n"
+      "void g() { f(); na::A::g(); }\n"
       "}  // namespace y\n"
       "}  // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, FixOverloadedOperatorFunctionNameSpecifiers) {
   std::string Code =
       "namespace na {\n"
std::string Expected =
       "  bool operator==(const A &RHS) const { return x == RHS.x; }\n"
       "};\n"
       "bool operator<(const A &LHS, const A &RHS) { return LHS.x == RHS.x; }\n"
       "\n"
       "}  // namespace na\n"
       "namespace x {\n"
       "namespace y {\n"
       "bool f() {\n"
-      "  ::na::A x, y;\n"
-      "  auto f = ::na::operator<;\n"
+      "  na::A x, y;\n"
+      "  auto f = na::operator<;\n"
       // FIXME: function calls to overloaded operators are not fixed now even if
       // they are referenced by qualified names.
       "  return (x == y) && (x < y) && (operator<(x,y));\n"
       "}\n"
       "}  // namespace y\n"
       "}  // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
std::string Expected =
       "};\n"
       "void a_f() {}\n"
       "static void s_f() {}\n"
       "\n"
       "}  // namespace na\n"
       "namespace x {\n"
       "namespace y {\n"
       "void f() {\n"
-      " auto *ref1 = ::na::A::f;\n"
-      " auto *ref2 = ::na::a_f;\n"
-      " auto *ref3 = ::na::s_f;\n"
+      " auto *ref1 = na::A::f;\n"
+      " auto *ref2 = na::a_f;\n"
+      " auto *ref3 = na::s_f;\n"
       "}\n"
       "}  // namespace y\n"
       "}  // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, MoveAndFixGlobalVariables) {
   std::string Code = "namespace na {\n"
std::string Expected = "namespace na {\n"
                          "static int GlobAStatic = 0;\n"
                          "namespace nc { int GlobC; }\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "int GlobB;\n"
                          "void f() {\n"
-                         "  int a = ::na::GlobA;\n"
-                         "  int b = ::na::GlobAStatic;\n"
-                         "  int c = ::na::nc::GlobC;\n"
+                         "  int a = na::GlobA;\n"
+                         "  int b = na::GlobAStatic;\n"
+                         "  int c = na::nc::GlobC;\n"
                          "}\n"
                          "}  // namespace y\n"
                          "}  // namespace x\n";
 
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, DoNotFixStaticVariableOfClass) {
std::string Expected = "namespace na {\n"
                          "static int A2;\n"
                          "};\n"
                          "int A::A1 = 0;\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "void f() {\n"
-                         "  int a = ::na::A::A1; int b = ::na::A::A2;\n"
+                         "  int a = na::A::A1; int b = na::A::A2;\n"
                          "}\n"
                          "}  // namespace y\n"
                          "}  // namespace x\n";
 
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, NoMisplaceAtEOF) {

 }
 
 TEST_F(ChangeNamespaceTest, NamespaceAliasInGlobal) {
   std::string Code = "namespace glob {\n"
                      "class Glob {};\n"
                      "}\n"
                      "namespace glob2 { class Glob2 {}; }\n"
                      "namespace gl = glob;\n"
-                     "namespace gl2 = ::glob2;\n"
+                     "namespace gl2 = glob2;\n"
                      "namespace na {\n"
                      "namespace nb {\n"
                      "void f() { gl::Glob g; gl2::Glob2 g2; }\n"
                      "} // namespace nb\n"
                      "} // namespace na\n";
 
   std::string Expected =
       "namespace glob {\n"
       "class Glob {};\n"
       "}\n"
       "namespace glob2 { class Glob2 {}; }\n"
       "namespace gl = glob;\n"
-      "namespace gl2 = ::glob2;\n"
+      "namespace gl2 = glob2;\n"
       "\n"
       "namespace x {\n"
       "namespace y {\n"
       "void f() { gl::Glob g; gl2::Glob2 g2; }\n"
       "} // namespace y\n"
       "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespace) {
 
   std::string Expected = "namespace nx { void f(); }\n"
                          "namespace na {\n"
                          "using nx::f;\n"
                          "\n"
                          "} // na\n"
                          "namespace x {\n"
                          "namespace y {\n"
-                         "void d() { ::nx::f(); }\n"
+                         "void d() { nx::f(); }\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespaceNotNested) {
   OldNamespace = "na";
   std::string Code = "namespace nx { void f(); }\n"
std::string Expected = "namespace nx { void f(); void g(); }\n"
                          "namespace b {\n"
                          "using ::nx::f;\n"
                          "namespace c {\n"
                          "using ::nx::g;\n"
                          "\n"
                          "} // c\n"
                          "namespace x {\n"
                          "namespace y {\n"
-                         "void d() { f(); ::nx::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, UsingShadowDeclInTheParentOfOldNamespace) {
std::string Expected =
       "\n\n"
       "namespace x {\n"
       "namespace y {\n"
       "class A : public nx::ny::X {\n"
       "public:\n"
       "  A() : X(0) {}\n"
       "  A(int i);\n"
       "};\n"
-      "A::A(int i) : X(i) { ::nx::ny::X x(1);}\n"
+      "A::A(int i) : X(i) { nx::ny::X x(1);}\n"
       "} // namespace y\n"
       "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, MoveToGlobalNamespace) {
   NewNamespace = "";
   std::string Code = "namespace na {\n"
std::string Expected = "class Glob {};\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "class C_X {\n"
                          "public:\n"
                          "  ::Glob glob_1;\n"
                          "  Glob glob_2;\n"
-                         "  ::na::C_A a_1;\n"
+                         "  na::C_A a_1;\n"
                          "  ::na::C_A a_2;\n"
-                         "  ::na::nc::C_C c;\n"
+                         "  na::nc::C_C c;\n"
                          "};\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, UsingAliasInTemplate) {
   NewNamespace = "na::nb::nc";
std::string Expected = "namespace na {\n"
                          " ::na::A a; nb::B b;\n"
                          "};\n"
                          "} // namespace nc\n"
                          "} // namespace na\n"
                          "} // namespace ny\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
+TEST_F(ChangeNamespaceTest, SymbolConflictWithNewNamespace) {
+  OldNamespace = "nx";
+  NewNamespace = "ny::na::nc";
+  std::string Code = "namespace na {\n"
+                     "class A {};\n"
+                     "namespace nb {\n"
+                     "class B {};\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n"
+                     "namespace ny {\n"
+                     "class Y {};\n"
+                     "}\n"
+                     "namespace nx {\n"
+                     "class X {\n"
+                     "  na::A a; na::nb::B b;\n"
+                     "  ny::Y y;"
+                     "};\n"
+                     "} // namespace nx\n";
+  std::string Expected = "namespace na {\n"
+                         "class A {};\n"
+                         "namespace nb {\n"
+                         "class B {};\n"
+                         "} // namespace nb\n"
+                         "} // namespace na\n"
+                         "namespace ny {\n"
+                         "class Y {};\n"
+                         "}\n"
+                         "\n"
+                         "namespace ny {\n"
+                         "namespace na {\n"
+                         "namespace nc {\n"
+                         "class X {\n"
+                         "  ::na::A a; ::na::nb::B b;\n"
+                         "  Y y;\n"
+                         "};\n"
+                         "} // namespace nc\n"
+                         "} // namespace na\n"
+                         "} // namespace ny\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
 TEST_F(ChangeNamespaceTest, ShortenNamespaceSpecifier) {
   OldNamespace = "nx";
   NewNamespace = "ny::na";
   std::string Code = "class G {};\n"
                      "namespace ny {\n"
                      "class Y {};\n"
                      "namespace na {\n"
                      "class A {};\n"
std::string Expected = "enum Glob { G1, G2 };\n"
                          "enum Y { Y1, Y2 };\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "void f() {\n"
                          "  Glob g1 = Glob::G1;\n"
                          "  Glob g2 = G2;\n"
-                         "  ::na::X x1 = ::na::X::X1;\n"
-                         "  ::na::Y y1 = ::na::Y::Y1;\n"
-                         "  ::na::Y y2 = ::na::Y::Y2;\n"
+                         "  na::X x1 = na::X::X1;\n"
+                         "  na::Y y1 = na::Y::Y1;\n"
+                         "  na::Y y2 = na::Y::Y2;\n"
                          "}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
 
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, NoRedundantEnumUpdate) {
std::string Expected = "namespace ns {\n"
                          "} // namespace ns\n"
                          "\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "void f() {\n"
                          "  ns::X x1 = ns::X::X1;\n"
                          "  ns::Y y1 = ns::Y::Y1;\n"
                          // FIXME: this is redundant
-                         "  ns::Y y2 = ::ns::Y::Y2;\n"
+                         "  ns::Y y2 = ns::Y::Y2;\n"
                          "}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   ;
 
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
std::string Code = "namespace na {\n"
                      "} // namespace na\n";
   std::string Expected = "namespace na {\n"
                          "struct X { enum E { E1 }; };\n"
                          "\n"
                          "} // namespace na\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "void f() {\n"
-                         "  ::na::X::E e = ::na::X::E1;\n"
-                         "  ::na::X::E ee = ::na::X::E::E1;\n"
+                         "  na::X::E e = na::X::E1;\n"
+                         "  na::X::E ee = na::X::E::E1;\n"
                          "}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
 
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 } // anonymous namespace
 } // namespace change_namespace
 } // namespace clang