A clang tool for changing surrouding namespaces of class/function definitions.

[ioeric]

Summary

A tool for changing surrouding namespaces of class/function definitions while keeping
references to types in the changed namespace correctly qualified by prepending
namespace specifiers before them.

Example: test.cc

namespace na {                                                          
class X {};                                                             
namespace nb {                                                          
class Y { X x; };                                                       
} // namespace nb                                                       
} // namespace na

To move the definition of class Y from namespace "na::nb" to "x::y", run:

clang-change-namespace --old_namespace "na::nb" \                       
  --new_namespace "x::y" --file_pattern "test.cc" test.cc --

Output:

namespace na {                                                          
class X {};                                                             
} // namespace na                                                       
namespace x {                                                           
namespace y {                                                           
class Y { na::X x; };                                                   
} // namespace y                                                        
} // namespace x

[ioeric]

• Added comments and cleanup.

[ioeric]

• Minor cleanup.

[Eugene.Zelenko]

Looks like clang-refactor idea should finally go live.

[omtcyfz]

In D24183#532876, @Eugene.Zelenko wrote:

Looks like clang-refactor idea should finally go live.

D24192 up for review.

[omtcyfz]

change-namespace/ChangeNamespace.cpp

22

is (void) intended here?

change-namespace/ChangeNamespace.h

42

FIXME?

[ioeric]

• removed unintended changes.

[omtcyfz]

change-namespace/ChangeNamespace.cpp

31

Braces around single-line statement inside control flow statement body is occasionally not welcome in LLVM Codebase.

There are actually both many braces around single-line statement inside cfs body here and many cfs's without braces around single-line body inside a single file, which isn't good in terms of consistency at least inside the project.

106

Shouldn't this throw an error instead?

[ioeric]

• Addressed review comments.

change-namespace/ChangeNamespace.cpp

23

Yes, it is added to please LLVM_ATTRIBUTE_UNUSED_RESULT of llvm::StringRef::ltrim.

31

You are right! I missed those braces when converting the code from google style :P Thanks for the catch!

106

An empty SourceLocation is invalid and often used to indicate error. Added error handling at callers.

[omtcyfz]

change-namespace/ChangeNamespace.cpp

481

By the way, shouldn't this one be "LLVM"?

[omtcyfz]

change-namespace/ChangeNamespace.cpp

481

Alternatively, it might be nice to provide an option to specify desired formatting style.

[hokein]

some initial comments.

change-namespace/ChangeNamespace.cpp

22

this statement doesn't do the intended thing (It won't change NS). The result returned by ltrim is what you want here, I think.

142

StringRef?

215

Use StringRef.

481

+1 on adding a CodeStyle command-line option.

change-namespace/ChangeNamespace.h

68

The first letter should be lower case.

71

The same.

change-namespace/tool/ClangChangeNamespace.cpp

105

Instead of printing results in a customized format, it makes more sense to print it in a JSON format, like:

[
   { "FilePath": "XXX"
     "SourceText": "YYYY"}
]

test/change-namespace/simple-move.cpp

8

Usually, we put the test scripts at top of the test file, and use CHECK-NEXT is more suitable in your case here?

unittests/change-namespace/ChangeNamespaceTests.cpp

50

Looks like formatAndApplyAllReplacements has already formatted the code, why do we need to format it again?

[hokein]

change-namespace/CMakeLists.txt

10

I think clangASTMatchers is needed here.

change-namespace/tool/ClangChangeNamespace.cpp

95

Add a CodeStyle option?

[ioeric]

• Addressed some review comments.

[ioeric]

change-namespace/ChangeNamespace.cpp

22

Aha, no wonder! Thanks!

481

Will do.

unittests/change-namespace/ChangeNamespaceTests.cpp

50

formatAndApplyAllReplacements only formats around replacements. I added format to format the whole file so that I don't need to get every white space right in Code and Expected.

[alexander-shaposhnikov]

change-namespace/ChangeNamespace.cpp

126

khm, this seems to be a recurring pattern (if i'm not mistaken),
looks like the interface of tooling::Replacements can be changed/improved (although i don't know).
Another (separate) observation is about duplicates. For example for replacements in headers we can get into if(Err) branch pretty frequently because the same replacement can be generated multiple times (if that header is included into several *.cpp files).

[alexander-shaposhnikov]

change-namespace/tool/ClangChangeNamespace.cpp

49

probably you need to add cl::Required

cl::opt<std::string> OldNamespace("old_namespace", cl::Required, cl::desc("Old namespace."),
                                                         cl::cat(ChangeNamespaceCategory));

and the same for NewNamespace.

[ioeric]

• Addressed reviewer comments.

[ioeric]

change-namespace/ChangeNamespace.cpp

126

SGTM. An addOrMerge() interface for tooling::Replacements should be helpful.

482

Added a FallbackStyle.

change-namespace/tool/ClangChangeNamespace.cpp

106

I'd like to keep this for now for better readability. Will change the format in the future if necessary.

[ioeric]

Ping

[omtcyfz]

A round of mostly stylistic comments.

change-namespace/ChangeNamespace.cpp

86

Wouldn't it be better of in some common interface?

A couple of useful cases for other refactorings come to my mind. I.e. getStartOfPreviousLine would be nice to have there, too.

For this patch, though, I think FIXME would be enough.

112

A little confusing wording "a new replacement that is R". Here and later.

125

(probably not very much related to the patch and more out of curiosity)

If there is a conflict, why does it get resolved by applying all existing Replaces first?

140

Alex suggested using diagnostics instead of dumping stuff to llvm::errs() in D24224 and I think it looks way better. Actually, you can output locations with that, which makes error message more informative. It might be also easier to track down bugs with that info, rather than with raw error messages.

That's just a nit, probably FIXME is enough.

Same comment applies to the other llvm::errs() usages in this function.

180

Shouldn't this one be const?

185

Same for Prefix and Pos.

200

Probably "} // end namespace " here, at least that's what LLVM Coding Standards suggest.

232

FIXME without handle here?

308

const here, too?

336

Slightly strange wording. I recall an offline discussion where you told about it, so I can understand that, but probably an example would be cool to have.

348

const here, too?

363

const here, too?

382

Also, if you only use this for an assert, why not just pass Postfix.consume_front(OldNamespace) to assert?

383

asserts are even more cool when they contain informative message, just like couple dozens of LOCs later.

384

Totally confused about this line.

UPD: Ah, I see. You don't use Consumed anywhere else :) See comment above.

385

const here, too?

447

I know, I know...

const here and everywhere else, too?

Maybe just running some clang-tidy check would do that. If we don't have one, I would file a feature request.

change-namespace/ChangeNamespace.h

43

Also, I'm not sure how to do that with gTest, but XFAIL tests are always nice in terms of an illustration what the tool still can't do (at least for me).

change-namespace/tool/ClangChangeNamespace.cpp

85

I'm not sure whether it actually affects something, but I've enabled C++ and C++17 in clang-rename's options passed somewhere.

[omtcyfz]

Also +R Alex if he has some time to take a look at the code.

[ioeric]

• Addressed reviewer comments.

change-namespace/ChangeNamespace.cpp

86

Acked.

125

It's a bit complicated to explain...Please see the comment for tooling::Replacements, specifically the merge function. Generally, the idea is that conflicting replacements will be merged into a single one so that the set of replacements never conflict.

140

Acked.

232

?

336

There is an example in the comment for the class. Also copied it here :)

382

I think it is not a good idea to put code with side-effect into assert since assertion can be disabled.

[omtcyfz]

change-namespace/ChangeNamespace.cpp

233

handle == "ioeric" here

s/FIXME(ioeric)/FIXME

337

Ah, I see. Thank you!

[ioeric]

• Minor cleanup.

[omtcyfz]

change-namespace/ChangeNamespace.cpp

360

The indentation seems a bit off. Semicolon is on the next line for some reason and I think /*SkipTrailingWhitespaceAndNewLine=*/ should be /* SkipTrailingWhitespaceAndNewLine */.

UPD: Semicolon came back :)

[ioeric]

change-namespace/ChangeNamespace.cpp

360

It seems that Phabricator is not behaving well recently. I saw similar indentation inconsistency in other patches as well.

For the comment, I think either way is fine. You can find both styles in the code base, and I'm not sure which is the standard.
Samples:
https://github.com/llvm-mirror/clang/blob/master/include/clang/Basic/SourceManager.h#L782
https://github.com/llvm-mirror/clang/blob/master/include/clang/Basic/SourceManager.h#L847

[ioeric]

PIng

[hokein]

change-namespace/ChangeNamespace.cpp

201

Doesn't formatAndApplyAllReplacements format the comments for us?

214

StringRef.

243

Actually, hasName matches the name which ends with OldNamespace, which doesn't align with the your comments in OldNamespace member variable.

374

s/stores/stored

401

how about assert(Postfix.consume_front(OldNamespace) && "Expect OldNS to start with OldNamespace.");?

422

Could you add some comments describe what stuff does this function do? The name fixTypeLoc doesn't explain too much. Looks like this function is replacing the qualifiers in TypeLoc.

change-namespace/ChangeNamespace.h

44

I think you are missing public keyword here, otherwise, it will be private inheritance.

change-namespace/tool/ClangChangeNamespace.cpp

47

change to "Change namespace"?

107

Might be add a FIXME?

[ioeric]

• Addressed review comments.

change-namespace/ChangeNamespace.cpp

201

formatter only adds/removes white spaces I think.

401

The problem with this is that Postfix.consume_front(OldNamespace) won't be executed if assertion is turned off.

[omtcyfz]

change-namespace/ChangeNamespace.cpp

449

StringRef here too.

[ioeric]

change-namespace/ChangeNamespace.cpp

449

If this was a StringRef, then each map access would require an implicit conversion from StringRef to std::string, which is expensive. And this is already a reference anyway.

[omtcyfz]

change-namespace/ChangeNamespace.cpp

449

Ah, I see. Yes, that's true. Sorry.

[hokein]

The patch looks good to me now.

change-namespace/ChangeNamespace.h

45

You forgot this one.

102

Would be clearer to add comment describing the kinds of these replacements (e.g. deleting the forward declarations, replacing the old qualifiers with the new shortest qualified name).

[omtcyfz]

I have no other objections aswell.
LGTM.

[ioeric]

• Updated commenting, and fix a bug in the binary.

[mehdi_amini]

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

396 ↗

(On Diff #71848)

You shouldn't dereference after a dyn_cast. Either null-check or use cast.

[ioeric]

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

396 ↗

(On Diff #71848)

Thanks! Fixed by rL286485

CMakeLists.txt

 add_subdirectory(clang-apply-replacements)
 add_subdirectory(clang-rename)
 add_subdirectory(modularize)
 if(CLANG_ENABLE_STATIC_ANALYZER)
 add_subdirectory(clang-tidy)
 endif()
 
+add_subdirectory(change-namespace)
 add_subdirectory(clang-query)
 add_subdirectory(include-fixer)
 add_subdirectory(pp-trace)
 add_subdirectory(tool-template)
 
 # Add the common testsuite after all the tools.
 # TODO: Support tests with more granularity when features are off?
 if(CLANG_ENABLE_STATIC_ANALYZER AND CLANG_INCLUDE_TESTS)

change-namespace/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  support
+  )
+
+add_clang_library(clangChangeNamespace
+  ChangeNamespace.cpp
+
+  LINK_LIBS
+  clangAST
+  clangBasic
+  clangFormat
+  clangFrontend
+  clangLex
+  clangTooling
+  clangToolingCore
+  )
+
+add_subdirectory(tool)

change-namespace/ChangeNamespace.h

+//===-- ChangeNamespace.h -- Change namespace  ------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_CHANGE_NAMESPACE_CHANGENAMESPACE_H
+#define LLVM_CLANG_TOOLS_EXTRA_CHANGE_NAMESPACE_CHANGENAMESPACE_H
+
+#include <string>
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Tooling/Core/Replacement.h"
+
+namespace clang {
+namespace change_namespace {
+
+// This tool can be used to change the surrounding namespaces of class/function
+// definitions. Classes/functions in the moved namespace will have new
+// namespaces while references to symbols (e.g. types, functions) which are not
+// defined in the changed namespace will be correctly qualified by prepending
+// namespace specifiers before them.
+// For classes, only classes that are declared/defined in the given namespace in
+// speficifed files will be moved: forward declarations will remain in the old
+// namespace.
+// For example, changing "a" to "x":
+// Old code:
+//   namespace a {
+//   class FWD;
+//   class A { FWD *fwd; }
+//   }  // a
+// New code:
+//   namespace a {
+//   class FWD;
+//   }  // a
+//   namespace x {
+//   class A { a::FWD *fwd; }
+//   }  // x
+// TODO(ioeric): support moving typedef, enums across namespaces.
+class ChangeNamespaceTool : ast_matchers::MatchFinder::MatchCallback {
+public:
+  // Moves code in the old namespace `OldNs` to the new namespace `NewNs` in
+  // files matching `FilePattern`.
+  ChangeNamespaceTool(
+      const std::string &OldNs, const std::string &NewNs,
+      const std::string &FilePattern,
+      std::map<std::string, tooling::Replacements> *FileToReplacements);
+
+  void registerMatchers(ast_matchers::MatchFinder *Finder);
+
+  void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
+
+  // Moves the changed code in old namespaces but leaves class forward
+  // declarations behind.
+  void onEndOfTranslationUnit() override;
+
+private:
+  void moveOldNamespace(const ast_matchers::MatchFinder::MatchResult &Result,
+                        const NamespaceDecl *NsDecl);
+
+  void moveClassForwardDeclaration(
+      const ast_matchers::MatchFinder::MatchResult &Result,
+      const CXXRecordDecl *FwdDecl);
+
+  void FixUsingShadowDecl(const ast_matchers::MatchFinder::MatchResult &Result,
+                          const UsingDecl *UsingDecl);
+
+  void ReplaceQualifiedSymbolInDeclContext(
+      const ast_matchers::MatchFinder::MatchResult &Result,
+      const Decl *DeclContext, SourceLocation Start, SourceLocation End,
+      llvm::StringRef DeclName);
+
+  void fixTypeLoc(const ast_matchers::MatchFinder::MatchResult &Result,
+                  SourceLocation Start, SourceLocation End, TypeLoc Type);
+
+  // Information about moving an old namespace.
+  struct MoveNamespace {
+    // The start offset of the namespace block being moved in the original
+    // code.
+    unsigned Offset;
+    // The length of the namespace block in the original code.
+    unsigned Length;
+    // The offset at which the new namespace block will be inserted in the
+    // original code.
+    unsigned InsertionOffset;
+    // The file in which the namespace is declared.
+    FileID FileID;
+    SourceManager *SourceManager;
+  };
+
+  // Information about inserting a class forward declaration.
+  struct InsertForwardDeclaration {
+    // The offset at while the forward declaration will be inserted in the
+    // original code.
+    unsigned InsertionOffset;
+    // The code to be inserted.
+    std::string ForwardDeclText;
+  };
+
+  std::map<std::string, tooling::Replacements> &FileToReplacements;
+  // A fully qualified name of the old namespace without "::" prefix, e.g.
+  // "a::b::c".
+  std::string OldNamespace;
+  // A fully qualified name of the new namespace without "::" prefix, e.g.
+  // "x::y::z".
+  std::string NewNamespace;
+  // The longest suffix in the old namespace that does not overlap the new
+  // namespace.
+  // For example, if `OldNamespace` is "a::b::c" and `NewNamespace` is
+  // "a::x::y", then `DiffOldNamespace` will be "b::c".
+  std::string DiffOldNamespace;
+  // The longest suffix in the new namespace that does not overlap the old
+  // namespace.
+  // For example, if `OldNamespace` is "a::b::c" and `NewNamespace` is
+  // "a::x::y", then `DiffNewNamespace` will be "x::y".
+  std::string DiffNewNamespace;
+  // A regex pattern that matches files to be processed.
+  std::string FilePattern;
+  // Information about moved namespaces grouped by file.
+  // Since we are modifying code in old namespaces (e.g. add namespace
+  // spedifiers) as well as moving them, we store information about namespaces
+  // to be moved and only move them after all modifications are finished (i.e.
+  // in `onEndOfTranslationUnit`).
+  std::map<std::string, std::vector<MoveNamespace>> MoveNamespaces;
+  // Information about forward declaration insertions grouped by files.
+  // A class forward declaration is not moved, so it will be deleted from the
+  // moved code block and inserted back into the old namespace. The insertion
+  // will be done after removing the code from the old namespace and before
+  // inserting it to the new namespace.
+  std::map<std::string, std::vector<InsertForwardDeclaration>> InsertFwdDecls;
+};
+
+} // namespace change_namespace
+} // namespace clang
+
+#endif // LLVM_CLANG_TOOLS_EXTRA_CHANGE_NAMESPACE_CHANGENAMESPACE_H

change-namespace/ChangeNamespace.cpp

+//===-- ChangeNamespace.cpp - Change namespace implementation -------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+#include "ChangeNamespace.h"
+#include "clang/Format/Format.h"
+#include "clang/Lex/Lexer.h"
+
+using namespace clang::ast_matchers;
+
+namespace clang {
+namespace change_namespace {
+
+namespace {
+
+inline std::string formatNamespace(llvm::StringRef NS) {
+  (void)NS.ltrim(':');
+  return NS.str();
+}
+
+inline std::string
+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;
+}
+
+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();
+    TLoc = TLoc.getNextTypeLoc();
+  }
+  return TLoc.getLocStart();
+}
+
+SourceLocation EndLocationForType(TypeLoc TLoc) {
+  // Dig past any namespace or keyword qualifications.
+  while (TLoc.getTypeLocClass() == TypeLoc::Elaborated ||
+         TLoc.getTypeLocClass() == TypeLoc::Qualified) {
+    TLoc = TLoc.getNextTypeLoc();
+  }
+
+  // The location for template specializations (e.g. Foo<int>) includes the
+  // templated types in its location range.  We want to restrict this to just
+  // before the `<` character.
+  if (TLoc.getTypeLocClass() == TypeLoc::TemplateSpecialization) {
+    return TLoc.castAs<TemplateSpecializationTypeLoc>()
+        .getLAngleLoc()
+        .getLocWithOffset(-1);
+  }
+  return TLoc.getEndLoc();
+}
+
+// Returns the containing namespace of `InnerNs` by skipping `PartialNsName`.
+// If the `InnerNs` does not have `PartialNsName` as suffix, nullptr is
+// returned.
+// 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) {
+  const auto *CurrentContext = llvm::cast<DeclContext>(InnerNs);
+  const auto *CurrentNs = InnerNs;
+  llvm::SmallVector<llvm::StringRef, 4> PartialNsNameSplitted;
+  PartialNsName.split(PartialNsNameSplitted, "::");
+  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())
+      return nullptr;
+    PartialNsNameSplitted.pop_back();
+    CurrentContext = CurrentContext->getParent();
+  }
+  return CurrentNs;
+}
+
+SourceLocation getStartOfNextLine(SourceLocation Loc, const SourceManager &SM,
+                                  const LangOptions &LangOpts) {
+  if (Loc.isMacroID() &&
+      !Lexer::isAtEndOfMacroExpansion(Loc, SM, LangOpts, &Loc)) {
+    return SourceLocation();
+  }
+  // Break down the source location.
+  std::pair<FileID, unsigned> LocInfo = SM.getDecomposedLoc(Loc);
+  // Try to load the file buffer.
+  bool InvalidTemp = false;
+  llvm::StringRef File = SM.getBufferData(LocInfo.first, &InvalidTemp);
+  if (InvalidTemp)
+    return SourceLocation();
+
+  const char *TokBegin = File.data() + LocInfo.second;
+  // Lex from the start of the given location.
+  Lexer Lex(SM.getLocForStartOfFile(LocInfo.first), LangOpts, File.begin(),
+            TokBegin, File.end());
+
+  llvm::SmallVector<char, 16> Line;
+  // FIXME: this is a bit hacky to get ReadToEndOfLine work.
+  Lex.setParsingPreprocessorDirective(true);
+  Lex.ReadToEndOfLine(&Line);
+  // FIXME: should not +1 at EOF.
+  return Loc.getLocWithOffset(Line.size() + 1);
+}
+
+// Returns a new replacement that is `R` with range that refers to
+// code after `Replaces` being applied.
+tooling::Replacement
+getReplacementInChangedCode(const tooling::Replacements &Replaces,
+                            const tooling::Replacement &R) {
+  unsigned NewStart = Replaces.getShiftedCodePosition(R.getOffset());
+  unsigned NewEnd =
+      Replaces.getShiftedCodePosition(R.getOffset() + R.getLength());
+  return tooling::Replacement(R.getFilePath(), NewStart, NewEnd - NewStart,
+                              R.getReplacementText());
+}
+
+// Adds a replacement `R` into `Replaces` or merges it into `Replaces` by
+// applying all existing Replaces first if there is conflict.
+void addOrMergeReplacement(const tooling::Replacement &R,
+                           tooling::Replacements *Replaces) {
+  auto Err = Replaces->add(R);
+  if (Err) {
+    llvm::consumeError(std::move(Err));
+    auto Replace = getReplacementInChangedCode(*Replaces, R);
+    *Replaces = Replaces->merge(tooling::Replacements(Replace));
+  }
+}
+
+tooling::Replacement createReplacement(SourceLocation Start, SourceLocation End,
+                                       const std::string &ReplacementText,
+                                       const SourceManager &SM) {
+  if (!Start.isValid() || !End.isValid()) {
+    llvm::errs() << "start or end location were invalid\n";
+    return tooling::Replacement();
+  }
+  if (SM.getDecomposedLoc(Start).first != SM.getDecomposedLoc(End).first) {
+    llvm::errs()
+        << "start or end location were in different macro expansions\n";
+    return tooling::Replacement();
+  }
+  Start = SM.getSpellingLoc(Start);
+  End = SM.getSpellingLoc(End);
+  if (SM.getFileID(Start) != SM.getFileID(End)) {
+    llvm::errs() << "start or end location were in different files\n";
+    return tooling::Replacement();
+  }
+  return tooling::Replacement(
+      SM, CharSourceRange::getTokenRange(SM.getSpellingLoc(Start),
+                                         SM.getSpellingLoc(End)),
+      ReplacementText.c_str());
+}
+
+tooling::Replacement createInsertion(SourceLocation Loc,
+                                     llvm::StringRef InsertText,
+                                     const SourceManager &SM) {
+  if (Loc.isInvalid()) {
+    llvm::errs() << "insert Location is invalid.\n";
+    return tooling::Replacement();
+  }
+  Loc = SM.getSpellingLoc(Loc);
+  return tooling::Replacement(SM, Loc, 0, InsertText);
+}
+
+// Returns the shortest qualified name for declaration `DeclName` in the
+// namespace `NsName`. For example, if `DeclName` is "a::b::X" and `NsName`
+// is "a::c::d", then "b::X" will be returned.
+std::string getShortestQualifiedNameInNamespace(llvm::StringRef DeclName,
+                                                llvm::StringRef NsName) {
+  llvm::SmallVector<llvm::StringRef, 4> DeclNameSplitted;
+  DeclName.split(DeclNameSplitted, "::");
+  if (DeclNameSplitted.size() == 1)
+    return DeclName;
+  auto UnqualifiedName = DeclNameSplitted.back();
+  while (true) {
+    auto Pos = NsName.find_last_of(':');
+    if (Pos == llvm::StringRef::npos)
+      return DeclName;
+    auto Prefix = NsName.substr(0, Pos - 1);
+    if (DeclName.startswith(Prefix))
+      return (Prefix + "::" + UnqualifiedName).str();
+    NsName = Prefix;
+  }
+  return DeclName;
+}
+
+std::string wrapCodeInNamespace(StringRef NestedNs, std::string Code) {
+  if (Code.back() != '\n') {
+    Code += "\n";
+  }
+  llvm::SmallVector<StringRef, 4> NsSplitted;
+  NestedNs.split(NsSplitted, "::");
+  while (!NsSplitted.empty()) {
+    Code = ("namespace " + NsSplitted.back() + " {\n" + Code +
+            "} // namespace " + NsSplitted.back() + "\n")
+               .str();
+    NsSplitted.pop_back();
+  }
+  return Code;
+}
+
+} // anonymous namespace
+
+ChangeNamespaceTool::ChangeNamespaceTool(
+    const std::string &OldNs, const std::string &NewNs,
+    const std::string &FilePattern,
+    std::map<std::string, tooling::Replacements> *FileToReplacements)
+    : FileToReplacements(*FileToReplacements),
+      OldNamespace(formatNamespace(OldNs)),
+      NewNamespace(formatNamespace(NewNs)), FilePattern(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, "::");
+  // 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);
+  llvm::errs() << "DiffOldNamespace: " << DiffOldNamespace
+               << ", DiffNewNamespace: " << DiffNewNamespace << "\n";
+}
+
+// FIXME(ioeric): handle the following symbols:
+//   - Types in `UsingShadowDecl` (e.g. `using a::b::c;`) which are not matched
+//   by `typeLoc`.
+//   - Types in nested name specifier, e.g. "na::X" in "na::X::Nested".
+//   - Function references.
+//   - Variable references.
+void ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
+  // Match old namespace blocks.
+  Finder->addMatcher(namespaceDecl(hasName(OldNamespace),
+                                   isExpansionInFileMatching(FilePattern))
+                         .bind("old_ns"),
+                     this);
+
+  auto IsInMovedNs =
+      allOf(hasAncestor(namespaceDecl(hasName(OldNamespace)).bind("ns_decl")),
+            isExpansionInFileMatching(FilePattern));
+
+  // Match forward-declarations in the old namespace.
+  Finder->addMatcher(
+      cxxRecordDecl(unless(anyOf(isImplicit(), isDefinition())), IsInMovedNs)
+          .bind("fwd_decl"),
+      this);
+
+  // Match references to types that are not defined in the old namespace.
+  // Forward-declarations in the old namespace are also matched since they will
+  // be moved back to the old namespace.
+  auto DeclMatcher = namedDecl(
+      hasAncestor(namespaceDecl()),
+      unless(anyOf(
+          hasAncestor(namespaceDecl(isAnonymous())),
+          hasAncestor(cxxRecordDecl()),
+          allOf(IsInMovedNs, unless(cxxRecordDecl(unless(isDefinition())))))));
+  // Match TypeLocs on the declaration. Carefully match only the outermost
+  // TypeLoc that's directly linked to the old class and don't handle nested
+  // name specifier locs.
+  // FIXME: match and handle nested name specifier locs.
+  Finder->addMatcher(
+      typeLoc(IsInMovedNs,
+              loc(qualType(hasDeclaration(DeclMatcher.bind("from_decl")))),
+              unless(anyOf(hasParent(typeLoc(
+                               loc(qualType(hasDeclaration(DeclMatcher))))),
+                           hasParent(nestedNameSpecifierLoc()))),
+              hasAncestor(decl().bind("dc")))
+          .bind("type"),
+      this);
+}
+
+void ChangeNamespaceTool::run(
+    const ast_matchers::MatchFinder::MatchResult &Result) {
+  if (const auto *NsDecl = Result.Nodes.getNodeAs<NamespaceDecl>("old_ns")) {
+    moveOldNamespace(Result, NsDecl);
+  } else if (const auto *FwdDecl =
+                 Result.Nodes.getNodeAs<CXXRecordDecl>("fwd_decl")) {
+    moveClassForwardDeclaration(Result, FwdDecl);
+  } else {
+    const auto *TLoc = Result.Nodes.getNodeAs<TypeLoc>("type");
+    assert(TLoc != nullptr && "Expecting callback for TypeLoc");
+    fixTypeLoc(Result, startLocationForType(*TLoc), EndLocationForType(*TLoc),
+               *TLoc);
+  }
+}
+
+// Stores information about a moved namespace in `MoveNamespaces` and leaves
+// the actual movement to `onEndOfTranslationUnit()`.
+void ChangeNamespaceTool::moveOldNamespace(
+    const ast_matchers::MatchFinder::MatchResult &Result,
+    const NamespaceDecl *NsDecl) {
+  // If the namespace is empty, do nothing.
+  if (Decl::castToDeclContext(NsDecl)->decls_empty())
+    return;
+
+  // Get the range of the code in the old namespace.
+  SourceLocation Start = NsDecl->decls_begin()->getLocStart();
+  SourceLocation End = NsDecl->getRBraceLoc().getLocWithOffset(-1);
+  // Create a replacement that deletes the code in the old namespace merely for
+  // retrieving offset and length from it.
+  auto R = createReplacement(Start, End, "", *Result.SourceManager);
+  MoveNamespace MoveNs;
+  MoveNs.Offset = R.getOffset();
+  MoveNs.Length = R.getLength();
+
+  // Insert the new namespace after `DiffOldNamespace`. For example, if
+  // `OldNamespace` is "a::b::c" and `NewNamespace` is `a::x::y`, then
+  // "x::y" will be inserted inside the existing namespace "a" and after "a::b".
+  // `OuterNs` is the first namespace in `DiffOldNamespace`, e.g. "namespace b"
+  // in the above example.
+  // FIXME: consider the case where DiffOldNamespace is empty.
+  const NamespaceDecl *OuterNs = getOuterNamespace(NsDecl, DiffOldNamespace);
+  SourceLocation LocAfterNs =
+      getStartOfNextLine(OuterNs->getRBraceLoc(), *Result.SourceManager,
+                         Result.Context->getLangOpts());
+  MoveNs.InsertionOffset = Result.SourceManager->getFileOffset(
+      Result.SourceManager->getSpellingLoc(LocAfterNs));
+
+  MoveNs.FileID = Result.SourceManager->getFileID(Start);
+  MoveNs.SourceManager = Result.SourceManager;
+  MoveNamespaces[R.getFilePath()].push_back(MoveNs);
+}
+
+// Removes a class forward declaration from the code in the moved namespace and
+// creates an `InsertForwardDeclaration` to insert the forward declaration back
+// into the old namespace after moving code from the old namespace to the new
+// namespace.
+void ChangeNamespaceTool::moveClassForwardDeclaration(
+    const ast_matchers::MatchFinder::MatchResult &Result,
+    const CXXRecordDecl *FwdDecl) {
+  SourceLocation Start = FwdDecl->getLocStart();
+  SourceLocation End = FwdDecl->getLocEnd();
+  SourceLocation AfterSemi = Lexer::findLocationAfterToken(
+      End, tok::semi, *Result.SourceManager, Result.Context->getLangOpts(),
+      /*SkipTrailingWhitespaceAndNewLine=*/true);
+  if (AfterSemi.isValid()) {
+    End = AfterSemi.getLocWithOffset(-1);
+  }
+  // Delete the forward declaration from the code to be moved.
+  auto Deletion = createReplacement(Start, End, "", *Result.SourceManager);
+  addOrMergeReplacement(Deletion, &FileToReplacements[Deletion.getFilePath()]);
+  llvm::StringRef Code = Lexer::getSourceText(
+      CharSourceRange::getTokenRange(
+          Result.SourceManager->getSpellingLoc(Start),
+          Result.SourceManager->getSpellingLoc(End)),
+      *Result.SourceManager, Result.Context->getLangOpts());
+  // Insert the forward declaration back into the old namespace after moving the
+  // code from old namespace to new namespace.
+  // Insertion information is stores in `InsertFwdDecls` and actual
+  // insertion will be performed in `onEndOfTranslationUnit`.
+  // Get the (old) namespace that contains the forward declaration.
+  const auto *NsDecl = Result.Nodes.getNodeAs<NamespaceDecl>("ns_decl");
+  // The namespace contains the forward declaration, so it must not be empty.
+  assert(!NsDecl->decls_empty());
+  auto Insertion = createInsertion(NsDecl->decls_begin()->getLocStart(), Code,
+                                   *Result.SourceManager);
+  InsertForwardDeclaration InsertFwd;
+  InsertFwd.InsertionOffset = Insertion.getOffset();
+  InsertFwd.ForwardDeclText = Insertion.getReplacementText().str();
+  InsertFwdDecls[Insertion.getFilePath()].push_back(InsertFwd);
+}
+
+// Replaces a qualified symbol that refers to a declaration with `DeclName` in
+// a given context with the shortest qualified name.
+void ChangeNamespaceTool::ReplaceQualifiedSymbolInDeclContext(
+    const ast_matchers::MatchFinder::MatchResult &Result, const Decl *DeclCtx,
+    SourceLocation Start, SourceLocation End, llvm::StringRef DeclName) {
+  const auto *NsDeclContext =
+      DeclCtx->getDeclContext()->getEnclosingNamespaceContext();
+  const auto *NsDecl = llvm::dyn_cast<NamespaceDecl>(NsDeclContext);
+  // Calculate the name of the `NsDecl` after it is moved to new namespace.
+  std::string OldNs = NsDecl->getQualifiedNameAsString();
+  llvm::StringRef Postfix = OldNs;
+  bool Consumed = Postfix.consume_front(OldNamespace);
+  assert(Consumed);
+  (void)Consumed;
+  std::string NewNs = (NewNamespace + Postfix).str();
+
+  llvm::StringRef NestedName = Lexer::getSourceText(
+      CharSourceRange::getTokenRange(
+          Result.SourceManager->getSpellingLoc(Start),
+          Result.SourceManager->getSpellingLoc(End)),
+      *Result.SourceManager, Result.Context->getLangOpts());
+  // If the symbol is already fully qualified, no change needs to be make.
+  if (NestedName.startswith("::"))
+    return;
+  std::string ReplaceName =
+      getShortestQualifiedNameInNamespace(DeclName, NewNs);
+  // 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)
+    return;
+  auto R = createReplacement(Start, End, ReplaceName, *Result.SourceManager);
+  addOrMergeReplacement(R, &FileToReplacements[R.getFilePath()]);
+}
+
+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;
+  // 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.
+  if (auto *Typedef = Type.getType()->getAs<TypedefType>()) {
+    FromDecl = Typedef->getDecl();
+  }
+
+  const Decl *DeclCtx = Result.Nodes.getNodeAs<Decl>("dc");
+  assert(DeclCtx && "Empty decl context.");
+  ReplaceQualifiedSymbolInDeclContext(Result, DeclCtx, Start, End,
+                                      FromDecl->getQualifiedNameAsString());
+}
+
+void ChangeNamespaceTool::onEndOfTranslationUnit() {
+  // Move namespace blocks and insert forward declaration to old namespace.
+  for (const auto &FileAndNsMoves : MoveNamespaces) {
+    auto &NsMoves = FileAndNsMoves.second;
+    if (NsMoves.empty())
+      continue;
+    const std::string &FilePath = FileAndNsMoves.first;
+    auto &Replaces = FileToReplacements[FilePath];
+    auto &SM = *NsMoves.begin()->SourceManager;
+    llvm::StringRef Code = SM.getBufferData(NsMoves.begin()->FileID);
+    auto ChangedCode = tooling::applyAllReplacements(Code, Replaces);
+    if (!ChangedCode) {
+      llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
+      continue;
+    }
+    // Replacements on the changed code for moving namespaces and inserting
+    // forward declarations to old namespaces.
+    tooling::Replacements NewReplacements;
+    // Cut the changed code from the old namespace and paste the code in the new
+    // namespace.
+    for (const auto &NsMove : NsMoves) {
+      // Calculate the range of the old namespace block in the changed
+      // code.
+      unsigned NewOffset = Replaces.getShiftedCodePosition(NsMove.Offset);
+      unsigned NewLength =
+          Replaces.getShiftedCodePosition(NsMove.Offset + NsMove.Length) -
+          NewOffset;
+      tooling::Replacement Deletion(FilePath, NewOffset, NewLength, "");
+      std::string MovedCode = ChangedCode->substr(NewOffset, NewLength);
+      std::string MovedCodeWrappedInNewNs =
+          wrapCodeInNamespace(DiffNewNamespace, MovedCode);
+      // Calculate the new offset at which the code will be inserted in the
+      // changed code.
+      unsigned NewInsertionOffset =
+          Replaces.getShiftedCodePosition(NsMove.InsertionOffset);
+      tooling::Replacement Insertion(FilePath, NewInsertionOffset, 0,
+                                     MovedCodeWrappedInNewNs);
+      addOrMergeReplacement(Deletion, &NewReplacements);
+      addOrMergeReplacement(Insertion, &NewReplacements);
+    }
+    // After moving namespaces, insert forward declarations back to old
+    // namespaces.
+    const auto &FwdDeclInsertions = InsertFwdDecls[FilePath];
+    for (const auto &FwdDeclInsertion : FwdDeclInsertions) {
+      unsigned NewInsertionOffset =
+          Replaces.getShiftedCodePosition(FwdDeclInsertion.InsertionOffset);
+      tooling::Replacement Insertion(FilePath, NewInsertionOffset, 0,
+                                     FwdDeclInsertion.ForwardDeclText);
+      addOrMergeReplacement(Insertion, &NewReplacements);
+    }
+    // Add replacements referring to the changed code to existing replacements,
+    // which refers to the original code.
+    Replaces = Replaces.merge(NewReplacements);
+    format::FormatStyle Style = format::getStyle("file", FilePath, "google");
+    // Clean up old namespaces if there is nothing in it after moving.
+    auto CleanReplacements =
+        format::cleanupAroundReplacements(Code, Replaces, Style);
+    if (!CleanReplacements) {
+      llvm::errs() << llvm::toString(CleanReplacements.takeError()) << "\n";
+      continue;
+    }
+    FileToReplacements[FilePath] = *CleanReplacements;
+  }
+}
+
+} // namespace change_namespace
+} // namespace clang

change-namespace/tool/CMakeLists.txt

+include_directories(${CMAKE_CURRENT_SOURCE_DIR}/..)
+
+add_clang_executable(clang-change-namespace
+  ClangChangeNamespace.cpp
+  )
+target_link_libraries(clang-change-namespace
+  clangBasic
+  clangChangeNamespace
+  clangFormat
+  clangFrontend
+  clangRewrite
+  clangTooling
+  clangToolingCore
+  )
+
+install(TARGETS clang-change-namespace
+  RUNTIME DESTINATION bin)

change-namespace/tool/ClangChangeNamespace.cpp

+//===-- ClangIncludeFixer.cpp - Standalone change namespace ---------------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+// This tool can be used to change the surrounding namespaces of class/function
+// definitions.
+//
+// Example: test.cc
+//    namespace na {
+//    class X {};
+//    namespace nb {
+//    class Y { X x; };
+//    } // namespace nb
+//    } // namespace na
+// To move the definition of class Y from namespace "na::nb" to "x::y", run:
+//    clang-change-namespace --old_namespace "na::nb" \
+//      --new_namespace "x::y" --file_pattern "test.cc" test.cc --
+// Output:
+//    namespace na {
+//    class X {};
+//    } // namespace na
+//    namespace x {
+//    namespace y {
+//    class Y { na::X x; };
+//    } // namespace y
+//    } // namespace x
+
+#include "ChangeNamespace.h"
+#include "clang/Frontend/FrontendActions.h"
+#include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "clang/Rewrite/Core/Rewriter.h"
+#include "clang/Tooling/CommonOptionsParser.h"
+#include "clang/Tooling/Refactoring.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/Support/CommandLine.h"
+
+using namespace clang;
+using namespace llvm;
+
+namespace {
+
+cl::OptionCategory ChangeNamespaceCategory("Tool options");
+
+cl::opt<std::string> OldNamespace("old_namespace", cl::desc("Old namespace."),
+                                  cl::cat(ChangeNamespaceCategory));
+
+cl::opt<std::string> NewNamespace("new_namespace", cl::desc("New namespace."),
+                                  cl::cat(ChangeNamespaceCategory));
+
+cl::opt<std::string> FilePattern(
+    "file_pattern",
+    cl::desc("Only rename namespaces in files that match the given pattern."),
+    cl::cat(ChangeNamespaceCategory));
+
+cl::opt<bool> Inplace("i", cl::desc("Inplace edit <file>s, if specified."),
+                      cl::cat(ChangeNamespaceCategory));
+
+} // anonymous namespace
+
+int main(int argc, const char **argv) {
+  tooling::CommonOptionsParser OptionsParser(argc, argv,
+                                             ChangeNamespaceCategory);
+  if (OldNamespace.empty() || NewNamespace.empty() || FilePattern.empty()) {
+    llvm::errs() << "Not all of old_namespace, new_namespace, and file_pattern "
+                    "are provided.\n";
+    return 1;
+  }
+  const auto &Files = OptionsParser.getSourcePathList();
+  tooling::RefactoringTool Tool(OptionsParser.getCompilations(), Files);
+  change_namespace::ChangeNamespaceTool NamespaceTool(
+      OldNamespace, NewNamespace, FilePattern, &Tool.getReplacements());
+  ast_matchers::MatchFinder Finder;
+  NamespaceTool.registerMatchers(&Finder);
+  std::unique_ptr<tooling::FrontendActionFactory> Factory =
+      tooling::newFrontendActionFactory(&Finder);
+  if (Inplace)
+    return Tool.runAndSave(Factory.get());
+
+  if (int Result = Tool.run(Factory.get()))
+    return Result;
+  LangOptions DefaultLangOptions;
+  IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
+  clang::TextDiagnosticPrinter DiagnosticPrinter(errs(), &*DiagOpts);
+  DiagnosticsEngine Diagnostics(
+      IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs()), &*DiagOpts,
+      &DiagnosticPrinter, false);
+  auto &FileMgr = Tool.getFiles();
+  SourceManager Sources(Diagnostics, FileMgr);
+  Rewriter Rewrite(Sources, DefaultLangOptions);
+
+  if (!formatAndApplyAllReplacements(Tool.getReplacements(), Rewrite)) {
+    llvm::errs() << "Failed applying all replacements.\n";
+    return 1;
+  }
+  for (const auto &File : Files) {
+    const auto *Entry = FileMgr.getFile(File);
+
+    auto ID = Sources.translateFile(Entry);
+    outs() << "============== " << File << " ==============\n";
+    Rewrite.getEditBuffer(ID).write(llvm::outs());
+    outs() << "\n============================================\n";
+  }
+  return 0;
+}

clang-rename/tool/clang-rename.py

 import vim
 import subprocess
 import sys
 
 def main():
     binary = 'clang-rename'
     if vim.eval('exists("g:clang_rename_path")') == "1":
         binary = vim.eval('g:clang_rename_path')
+    print 'binary: ', binary
 
     # Get arguments for clang-rename binary.
     offset = int(vim.eval('line2byte(line("."))+col(".")')) - 2
     if offset < 0:
         print >> sys.stderr, '''Couldn\'t determine cursor position.
                                 Is your file empty?'''
         return
     filename = vim.current.buffer.name

test/CMakeLists.txt

set(CLANG_TOOLS_TEST_DEPS
   # clang-tidy tests require it.
   clang-headers
 
   # For the clang-tidy libclang integration test.
   c-index-test
 
   # Individual tools we test.
   clang-apply-replacements
+  clang-change-namespace
   clang-include-fixer
   clang-query
   clang-rename
   clang-tidy
   find-all-symbols
   modularize
   pp-trace
 

test/change-namespace/simple-move.cpp

+namespace na { // CHECK: namespace x {
+namespace nb { // CHECK: namespace y {
+class A {};
+}              // CHECK: } // namespace y
+}              // CHECK: } // namespace x
+
+// RUN: clang-change-namespace -old_namespace "na::nb" -new_namespace "x::y" --file_pattern ".*" %s -- | sed 's,// CHECK.*,,' | FileCheck %s

unittests/CMakeLists.txt

 add_custom_target(ExtraToolsUnitTests)
 set_target_properties(ExtraToolsUnitTests PROPERTIES FOLDER "Extra Tools Unit Tests")
 
 function(add_extra_unittest test_dirname)
   add_unittest(ExtraToolsUnitTests ${test_dirname} ${ARGN})
 endfunction()
 
+add_subdirectory(change-namespace)
 add_subdirectory(clang-apply-replacements)
 add_subdirectory(clang-rename)
 add_subdirectory(clang-query)
 add_subdirectory(clang-tidy)
 add_subdirectory(include-fixer)

unittests/change-namespace/CMakeLists.txt

+set(LLVM_LINK_COMPONENTS
+  support
+  )
+
+get_filename_component(CHANGE_NAMESPACE_SOURCE_DIR
+  ${CMAKE_CURRENT_SOURCE_DIR}/../../change-namespace REALPATH)
+include_directories(
+  ${CHANGE_NAMESPACE_SOURCE_DIR}
+  )
+
+# We'd like clang/unittests/Tooling/RewriterTestContext.h in the test.
+include_directories(${CLANG_SOURCE_DIR})
+
+add_extra_unittest(ChangeNamespaceTests
+  ChangeNamespaceTests.cpp
+  )
+
+target_link_libraries(ChangeNamespaceTests
+  clangAST
+  clangASTMatchers
+  clangBasic
+  clangChangeNamespace
+  clangFormat
+  clangFrontend
+  clangRewrite
+  clangTooling
+  clangToolingCore
+  )

unittests/change-namespace/ChangeNamespaceTests.cpp

+//===-- ChangeNamespaceTests.cpp - Change namespace unit tests ---*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "ChangeNamespace.h"
+#include "unittests/Tooling/RewriterTestContext.h"
+#include "clang/ASTMatchers/ASTMatchFinder.h"
+#include "clang/Basic/FileManager.h"
+#include "clang/Basic/FileSystemOptions.h"
+#include "clang/Basic/VirtualFileSystem.h"
+#include "clang/Format/Format.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Frontend/PCHContainerOperations.h"
+#include "clang/Tooling/Refactoring.h"
+#include "clang/Tooling/Tooling.h"
+#include "llvm/ADT/IntrusiveRefCntPtr.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "gtest/gtest.h"
+#include <memory>
+#include <string>
+#include <vector>
+
+namespace clang {
+namespace change_namespace {
+namespace {
+
+class ChangeNamespaceTest : public ::testing::Test {
+public:
+  std::string runChangeNamespaceOnCode(llvm::StringRef Code) {
+    clang::RewriterTestContext Context;
+    clang::FileID ID = Context.createInMemoryFile(FileName, Code);
+
+    std::map<std::string, tooling::Replacements> FileToReplacements;
+    change_namespace::ChangeNamespaceTool NamespaceTool(
+        OldNamespace, NewNamespace, FilePattern, &FileToReplacements);
+    ast_matchers::MatchFinder Finder;
+    NamespaceTool.registerMatchers(&Finder);
+    std::unique_ptr<tooling::FrontendActionFactory> Factory =
+        tooling::newFrontendActionFactory(&Finder);
+    tooling::runToolOnCodeWithArgs(Factory->create(), Code, {"-std=c++11"},
+                                   FileName);
+    formatAndApplyAllReplacements(FileToReplacements, Context.Rewrite);
+    return format(Context.getRewrittenText(ID));
+  }
+
+  std::string format(llvm::StringRef Code) {
+    tooling::Replacements Replaces = format::reformat(
+        format::getLLVMStyle(), Code, {tooling::Range(0, Code.size())});
+    auto ChangedCode = tooling::applyAllReplacements(Code, Replaces);
+    EXPECT_TRUE(static_cast<bool>(ChangedCode));
+    if (!ChangedCode) {
+      llvm::errs() << llvm::toString(ChangedCode.takeError());
+      return "";
+    }
+    return *ChangedCode;
+  }
+
+protected:
+  std::string FileName = "input.cc";
+  std::string OldNamespace = "na::nb";
+  std::string NewNamespace = "x::y";
+  std::string FilePattern = "input.cc";
+};
+
+TEST_F(ChangeNamespaceTest, NoMatchingNamespace) {
+  std::string Code = "namespace na {\n"
+                     "namespace nx {\n"
+                     "class A {};\n"
+                     "} // namespace nx\n"
+                     "} // namespace na\n";
+  std::string Expected = "namespace na {\n"
+                         "namespace nx {\n"
+                         "class A {};\n"
+                         "} // namespace nx\n"
+                         "} // namespace na\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, SimpleMoveWithoutTypeRefs) {
+  std::string Code = "namespace na {\n"
+                     "namespace nb {\n"
+                     "class A {};\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n";
+  std::string Expected = "\n\n"
+                         "namespace x {\n"
+                         "namespace y {\n"
+                         "class A {};\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, SimpleMoveIntoAnotherNestedNamespace) {
+  NewNamespace = "na::nc";
+  std::string Code = "namespace na {\n"
+                     "namespace nb {\n"
+                     "class A {};\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n";
+  std::string Expected = "namespace na {\n"
+                         "\n"
+                         "namespace nc {\n"
+                         "class A {};\n"
+                         "} // namespace nc\n"
+                         "} // namespace na\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, SimpleMoveNestedNamespace) {
+  NewNamespace = "na::x::y";
+  std::string Code = "namespace na {\n"
+                     "class A {};\n"
+                     "namespace nb {\n"
+                     "class B {};\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n";
+  std::string Expected = "namespace na {\n"
+                         "class A {};\n"
+                         "\n"
+                         "namespace x {\n"
+                         "namespace y {\n"
+                         "class B {};\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n"
+                         "} // namespace na\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, SimpleMoveWithTypeRefs) {
+  std::string Code = "namespace na {\n"
+                     "class C_A {};\n"
+                     "namespace nc {\n"
+                     "class C_C {};"
+                     "} // namespace nc\n"
+                     "namespace nb {\n"
+                     "class C_X {\n"
+                     "public:\n"
+                     "  C_A a;\n"
+                     "  nc::C_C c;\n"
+                     "};\n"
+                     "class C_Y {\n"
+                     "  C_X x;\n"
+                     "};\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n";
+  std::string Expected = "namespace na {\n"
+                         "class C_A {};\n"
+                         "namespace nc {\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"
+                         "};\n"
+                         "class C_Y {\n"
+                         "  C_X x;\n"
+                         "};\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, LeaveForwardDeclarationBehind) {
+  std::string Code = "namespace na {\n"
+                     "namespace nb {\n"
+                     "class FWD;\n"
+                     "class A {\n"
+                     "  FWD *fwd;\n"
+                     "};\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n";
+  std::string Expected = "namespace na {\n"
+                         "namespace nb {\n"
+                         "class FWD;\n"
+                         "} // namespace nb\n"
+                         "} // namespace na\n"
+                         "namespace x {\n"
+                         "namespace y {\n"
+                         "\n"
+                         "class A {\n"
+                         "  na::nb::FWD *fwd;\n"
+                         "};\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, MoveFunctions) {
+  std::string Code = "namespace na {\n"
+                     "class C_A {};\n"
+                     "namespace nc {\n"
+                     "class C_C {};"
+                     "} // namespace nc\n"
+                     "namespace nb {\n"
+                     "void fwd();\n"
+                     "void f(C_A ca, nc::C_C cc) {\n"
+                     "  C_A ca_1 = ca;\n"
+                     "}\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n";
+
+  std::string Expected = "namespace na {\n"
+                         "class C_A {};\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"
+                         "}\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+} // anonymous namespace
+} // namespace change_namespace
+} // namespace clang