[clang-move] Make it support both relative and absolute file path arguments.

[hokein]

Rebase to master

[ioeric]

clang-move/ClangMove.cpp

33

This doesn't seems to be good error handling... maybe also print an error message in case this fails in release binary.

39

There are two versions of this. Please add comments about the differences.

43

Same as above. Error handling.

62

To generalize the function, maybe also remove dots in AbsoluteFilePath?

86–87

Looks like MakeAbsolutePath(SM, SearchPath) can be done in addIncludes since you are also passing SM.

116–119

I think it would be easier to read if you put OriginalRunningDirectory before OldHeader .

clang-move/ClangMove.h

61–74

This function could use more comments. What are those parameters and what are they for?

62

Should SearchPath be absolute or relative?

95

s/saves/save the/

[hokein]

Address review comments.

clang-move/ClangMove.cpp

62

AbsoluteFilePath has been removed dots, and the matcher here is only used internally by clang-move, so I'd prefer the current way here, if we meet the generalized case in the future, I will be happy to extend it.

[ioeric]

Lg with nits.

clang-move/ClangMove.cpp

36

s/warning/Warning/

51

s/warning/Warning

test/clang-move/Inputs/database_template.json

4

Maybe decorate "test_dir" as "$test_dir" or "%test_dir" or similar so that others would know it is gonna replaced.

[hokein]

Add clang-move tool in test/CMakeLists.

clang-move/ClangMove.h

struct MovedDecl {
     MovedDecl() = default;
     MovedDecl(const clang::NamedDecl *Decl, clang::SourceManager *SM)
         : Decl(Decl), SM(SM) {}
   };
 
   struct MoveDefinitionSpec {
     // A fully qualified name, e.g. "X", "a::X".
     std::string Name;
+    // The file path of old header, can be relative path and absolute path.
     std::string OldHeader;
+    // The file path of old cc, can be relative path and absolute path.
     std::string OldCC;
+    // The file path of new header, can be relative path and absolute path.
     std::string NewHeader;
+    // The file path of new cc, can be relative path and absolute path.
     std::string NewCC;
   };
 
   ClangMoveTool(
       const MoveDefinitionSpec &MoveSpec,
-      std::map<std::string, tooling::Replacements> &FileToReplacements);
+      std::map<std::string, tooling::Replacements> &FileToReplacements,
+      llvm::StringRef OriginalRunningDirectory);
 
   void registerMatchers(ast_matchers::MatchFinder *Finder);
 
   void run(const ast_matchers::MatchFinder::MatchResult &Result) override;
 
   void onEndOfTranslationUnit() override;
 
-  // Add #includes from old.h/cc files. The FileName is where the #include
-  // comes from.
-  void addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
-                   llvm::StringRef FileName);
+  /// Add #includes from old.h/cc files.
+  ///
+  /// \param IncludeHeader The name of the file being included, as written in
+  /// the source code.
+  /// \param IsAngled Whether the file name was enclosed in angle brackets.
+  /// \param SearchPath The search path which was used to find the IncludeHeader
+  /// in the file system. It can be a relative path or an absolute path.
+  /// \param FileName The name of file where the IncludeHeader comes from.
+  /// \param SourceManager The SourceManager.
+  void addIncludes(llvm::StringRef IncludeHeader,
+                   bool IsAngled,
+                   llvm::StringRef SearchPath,
+                   llvm::StringRef FileName,
+                   const SourceManager& SM);
 
 private:
   void removeClassDefinitionInOldFiles();
   void moveClassDefinitionToNewFiles();
 
   MoveDefinitionSpec Spec;
   // The Key is file path, value is the replacements being applied to the file.
   std::map<std::string, tooling::Replacements> &FileToReplacements;
   // All declarations (the class decl being moved, forward decls) that need to
   // be moved/copy to the new files, saving in an AST-visited order.
   std::vector<MovedDecl> MovedDecls;
   // The declarations that needs to be removed in old.cc/h.
   std::vector<MovedDecl> RemovedDecls;
   // The #includes in old_header.h.
   std::vector<std::string> HeaderIncludes;
   // The #includes in old_cc.cc.
   std::vector<std::string> CCIncludes;
+  // The original working directory where the local clang-move binary runs.
+  //
+  // clang-move will change its current working directory to the build
+  // directory when analyzing the source file. We save the original working
+  // directory in order to get the absolute file path for the fields in Spec.
+  std::string OriginalRunningDirectory;
 };
 
 class ClangMoveAction : public clang::ASTFrontendAction {
 public:
   ClangMoveAction(
       const ClangMoveTool::MoveDefinitionSpec &spec,
-      std::map<std::string, tooling::Replacements> &FileToReplacements)
-      : MoveTool(spec, FileToReplacements) {
+      std::map<std::string, tooling::Replacements> &FileToReplacements,
+      llvm::StringRef OriginalRunningDirectory)
+      : MoveTool(spec, FileToReplacements, OriginalRunningDirectory) {
     MoveTool.registerMatchers(&MatchFinder);
   }
 
   ~ClangMoveAction() override = default;
 
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &Compiler,
                     llvm::StringRef InFile) override;
 
 private:
   ast_matchers::MatchFinder MatchFinder;
   ClangMoveTool MoveTool;
 };
 
 class ClangMoveActionFactory : public tooling::FrontendActionFactory {
 public:
   ClangMoveActionFactory(
       const ClangMoveTool::MoveDefinitionSpec &Spec,
-      std::map<std::string, tooling::Replacements> &FileToReplacements)
-      : Spec(Spec), FileToReplacements(FileToReplacements) {}
+      std::map<std::string, tooling::Replacements> &FileToReplacements,
+      llvm::StringRef OriginalRunningDirectory)
+      : Spec(Spec), FileToReplacements(FileToReplacements),
+        OriginalRunningDirectory(OriginalRunningDirectory) {}
 
   clang::FrontendAction *create() override {
-    return new ClangMoveAction(Spec, FileToReplacements);
+    return new ClangMoveAction(Spec, FileToReplacements, OriginalRunningDirectory);
   }
 
 private:
   const ClangMoveTool::MoveDefinitionSpec &Spec;
   std::map<std::string, tooling::Replacements> &FileToReplacements;
+  std::string OriginalRunningDirectory;
 };
 
 } // namespace move
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANG_MOVE_CLANGMOVE_H

clang-move/ClangMove.cpp

 #include "clang/ASTMatchers/ASTMatchers.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Format/Format.h"
 #include "clang/Frontend/CompilerInstance.h"
 #include "clang/Lex/Lexer.h"
 #include "clang/Lex/Preprocessor.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/Core/Replacement.h"
+#include "llvm/Support/Path.h"
 
 using namespace clang::ast_matchers;
 
 namespace clang {
 namespace move {
 namespace {
 
+// Make the Path absolute using the CurrentDir if the Path is not an absolute
+// path. An empty Path will result in an empty string.
+std::string MakeAbsolutePath(StringRef CurrentDir, StringRef Path) {
+  if (Path.empty())
+    return "";
+  llvm::SmallString<128> InitialDirectory(CurrentDir);
+  llvm::SmallString<128> AbsolutePath(Path);
+  if (std::error_code EC =
+          llvm::sys::fs::make_absolute(InitialDirectory, AbsolutePath))
+    llvm::errs() << "Warning: could not make absolute file: '" <<  EC.message()
+                 << '\n';
+  llvm::sys::path::remove_dots(AbsolutePath, /*remove_dot_dot=*/true);
+  return AbsolutePath.str();
+}
+
+// Make the Path absolute using the current working directory of the given
+// SourceManager if the Path is not an absolute path.
+//
+// The Path can be a path relative to the build directory, or retrieved from
+// the SourceManager.
+std::string MakeAbsolutePath(const SourceManager& SM, StringRef Path) {
+  llvm::SmallString<128> AbsolutePath(Path);
+  if (std::error_code EC =
+       SM.getFileManager().getVirtualFileSystem()->makeAbsolute(AbsolutePath))
+    llvm::errs() << "Warning: could not make absolute file: '" <<  EC.message()
+                 << '\n';
+  llvm::sys::path::remove_dots(AbsolutePath, /*remove_dot_dot=*/true);
+  return AbsolutePath.str();
+}
+
+// Matches AST nodes that are expanded within the given AbsoluteFilePath.
+AST_POLYMORPHIC_MATCHER_P(isExpansionInFile,
+                          AST_POLYMORPHIC_SUPPORTED_TYPES(Decl, Stmt, TypeLoc),
+                          std::string, AbsoluteFilePath) {
+  auto &SourceManager = Finder->getASTContext().getSourceManager();
+  auto ExpansionLoc = SourceManager.getExpansionLoc(Node.getLocStart());
+  if (ExpansionLoc.isInvalid())
+    return false;
+  auto FileEntry =
+      SourceManager.getFileEntryForID(SourceManager.getFileID(ExpansionLoc));
+  if (!FileEntry)
+    return false;
+  return MakeAbsolutePath(SourceManager, FileEntry->getName()) ==
+         AbsoluteFilePath;
+}
+
 class FindAllIncludes : public clang::PPCallbacks {
 public:
   explicit FindAllIncludes(SourceManager *SM, ClangMoveTool *const MoveTool)
       : SM(*SM), MoveTool(MoveTool) {}
 
   void InclusionDirective(clang::SourceLocation HashLoc,
                           const clang::Token & /*IncludeTok*/,
                           StringRef FileName, bool IsAngled,
                           clang::CharSourceRange /*FilenameRange*/,
                           const clang::FileEntry * /*File*/,
-                          StringRef /*SearchPath*/, StringRef /*RelativePath*/,
+                          StringRef SearchPath, StringRef /*RelativePath*/,
                           const clang::Module * /*Imported*/) override {
     if (const auto *FileEntry = SM.getFileEntryForID(SM.getFileID(HashLoc)))
-      MoveTool->addIncludes(FileName, IsAngled, FileEntry->getName());
+      MoveTool->addIncludes(FileName, IsAngled, SearchPath,
+                            FileEntry->getName(), SM);
   }
 
 private:
   const SourceManager &SM;
   ClangMoveTool *const MoveTool;
 };
 
 clang::tooling::Replacement
void addOrMergeReplacement(const clang::tooling::Replacement &Replacement,
   auto Err = Replacements->add(Replacement);
   if (Err) {
     llvm::consumeError(std::move(Err));
     auto Replace = getReplacementInChangedCode(*Replacements, Replacement);
     *Replacements = Replacements->merge(clang::tooling::Replacements(Replace));
   }
 }
 
-bool IsInHeaderFile(const clang::SourceManager &SM, const clang::Decl *D,
-                    llvm::StringRef HeaderFile) {
-  if (HeaderFile.empty())
+bool isInHeaderFile(const clang::SourceManager &SM, const clang::Decl *D,
+                    llvm::StringRef OriginalRunningDirectory,
+                    llvm::StringRef OldHeader) {
+  if (OldHeader.empty())
     return false;
   auto ExpansionLoc = SM.getExpansionLoc(D->getLocStart());
   if (ExpansionLoc.isInvalid())
     return false;
 
-  if (const auto *FE = SM.getFileEntryForID(SM.getFileID(ExpansionLoc)))
-    return llvm::StringRef(FE->getName()).endswith(HeaderFile);
+  if (const auto *FE = SM.getFileEntryForID(SM.getFileID(ExpansionLoc))) {
+    return MakeAbsolutePath(SM, FE->getName()) ==
+           MakeAbsolutePath(OriginalRunningDirectory, OldHeader);
+  }
 
   return false;
 }
 
 std::vector<std::string> GetNamespaces(const clang::Decl *D) {
   std::vector<std::string> Namespaces;
   for (const auto *Context = D->getDeclContext(); Context;
        Context = Context->getParent()) {

 std::unique_ptr<clang::ASTConsumer>
 ClangMoveAction::CreateASTConsumer(clang::CompilerInstance &Compiler,
                                    StringRef /*InFile*/) {
   Compiler.getPreprocessor().addPPCallbacks(llvm::make_unique<FindAllIncludes>(
       &Compiler.getSourceManager(), &MoveTool));
   return MatchFinder.newASTConsumer();
 }
 
-
 ClangMoveTool::ClangMoveTool(
       const MoveDefinitionSpec &MoveSpec,
-      std::map<std::string, tooling::Replacements> &FileToReplacements)
-      : Spec(MoveSpec), FileToReplacements(FileToReplacements) {
+      std::map<std::string, tooling::Replacements> &FileToReplacements,
+      llvm::StringRef OriginalRunningDirectory)
+      : Spec(MoveSpec), FileToReplacements(FileToReplacements),
+        OriginalRunningDirectory(OriginalRunningDirectory) {
   Spec.Name = llvm::StringRef(Spec.Name).ltrim(':');
   if (!Spec.NewHeader.empty())
     CCIncludes.push_back("#include \"" + Spec.NewHeader + "\"\n");
 }
 
 void ClangMoveTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   std::string FullyQualifiedName = "::" + Spec.Name;
-  auto InOldHeader = isExpansionInFileMatching(Spec.OldHeader);
-  auto InOldCC = isExpansionInFileMatching(Spec.OldCC);
+  auto InOldHeader = isExpansionInFile(
+      MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader));
+  auto InOldCC = isExpansionInFile(
+      MakeAbsolutePath(OriginalRunningDirectory, Spec.OldCC));
   auto InOldFiles = anyOf(InOldHeader, InOldCC);
   auto InMovedClass =
       hasDeclContext(cxxRecordDecl(hasName(FullyQualifiedName)));
 
   // Match moved class declarations.
   auto MovedClass = cxxRecordDecl(
       InOldFiles, hasName(FullyQualifiedName), isDefinition(),
       hasDeclContext(anyOf(namespaceDecl(), translationUnitDecl())));
if (RemovedDecls.empty())
                  "decls_in_anonymous_ns")) {
     MovedDecls.emplace_back(FD, &Result.Context->getSourceManager());
   } else if (const auto *ND =
                  Result.Nodes.getNodeAs<clang::NamedDecl>("static_decls")) {
     MovedDecls.emplace_back(ND, &Result.Context->getSourceManager());
   }
 }
 
-void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
-                                llvm::StringRef FileName) {
+void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader,
+                                bool IsAngled,
+                                llvm::StringRef SearchPath,
+                                llvm::StringRef FileName,
+                                const SourceManager& SM) {
+  auto AbsoluteSearchPath = MakeAbsolutePath(SM, SearchPath);
   // FIXME: Add old.h to the new.cc/h when the new target has dependencies on
   // old.h/c. For instance, when moved class uses another class defined in
   // old.h, the old.h should be added in new.h.
-  if (!Spec.OldHeader.empty() &&
-      llvm::StringRef(Spec.OldHeader).endswith(IncludeHeader))
+  if (MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader) ==
+      MakeAbsolutePath(AbsoluteSearchPath, IncludeHeader))
     return;
 
   std::string IncludeLine =
       IsAngled ? ("#include <" + IncludeHeader + ">\n").str()
                : ("#include \"" + IncludeHeader + "\"\n").str();
-  if (!Spec.OldHeader.empty() && FileName.endswith(Spec.OldHeader))
+
+  std::string AbsolutePath = MakeAbsolutePath(SM, FileName);
+  if (MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader) ==
+      AbsolutePath) {
     HeaderIncludes.push_back(IncludeLine);
-  else if (!Spec.OldCC.empty() && FileName.endswith(Spec.OldCC))
+  } else if (MakeAbsolutePath(OriginalRunningDirectory, Spec.OldCC) ==
+             AbsolutePath) {
     CCIncludes.push_back(IncludeLine);
   }
+}
 
 void ClangMoveTool::removeClassDefinitionInOldFiles() {
   for (const auto &MovedDecl : RemovedDecls) {
     auto EndLoc = getLocForEndOfDecl(MovedDecl.Decl, MovedDecl.SM);
     clang::tooling::Replacement RemoveReplacement(
         *MovedDecl.SM, clang::CharSourceRange::getTokenRange(
                            MovedDecl.Decl->getLocStart(), EndLoc),
         "");
     std::string FilePath = RemoveReplacement.getFilePath().str();
     addOrMergeReplacement(RemoveReplacement, &FileToReplacements[FilePath]);
   }
 }
 
 void ClangMoveTool::moveClassDefinitionToNewFiles() {
   std::vector<MovedDecl> NewHeaderDecls;
   std::vector<MovedDecl> NewCCDecls;
   for (const auto &MovedDecl : MovedDecls) {
-    if (IsInHeaderFile(*MovedDecl.SM, MovedDecl.Decl, Spec.OldHeader))
+    if (isInHeaderFile(*MovedDecl.SM, MovedDecl.Decl, OriginalRunningDirectory,
+                       Spec.OldHeader))
       NewHeaderDecls.push_back(MovedDecl);
     else
       NewCCDecls.push_back(MovedDecl);
   }
 
   if (!Spec.NewHeader.empty())
     FileToReplacements[Spec.NewHeader] = createInsertedReplacements(
         HeaderIncludes, NewHeaderDecls, Spec.NewHeader);

clang-move/tool/ClangMoveMain.cpp

 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Refactoring.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/YAMLTraits.h"
+#include "llvm/Support/Path.h"
 #include <set>
 #include <string>
 
 using namespace clang;
 using namespace llvm;
 
 namespace {
+
 std::error_code CreateNewFile(const llvm::Twine &path) {
   int fd = 0;
   if (std::error_code ec =
           llvm::sys::fs::openFileForWrite(path, fd, llvm::sys::fs::F_Text))
     return ec;
 
   return llvm::sys::Process::SafelyCloseFileDescriptor(fd);
 }
 
 cl::OptionCategory ClangMoveCategory("clang-move options");
 
 cl::opt<std::string> Name("name", cl::desc("The name of class being moved."),
                           cl::cat(ClangMoveCategory));
 
-cl::opt<std::string> OldHeader("old_header", cl::desc("Old header."),
-                               cl::cat(ClangMoveCategory));
+cl::opt<std::string>
+    OldHeader("old_header",
+              cl::desc("The relative/absolute file path of old header."),
 
-cl::opt<std::string> OldCC("old_cc", cl::desc("Old CC file."),
-                           cl::cat(ClangMoveCategory));
+cl::opt<std::string>
+    OldCC("old_cc", cl::desc("The relative/absolute file path of old cc."),
 
-cl::opt<std::string> NewHeader("new_header", cl::desc("New header."),
-                               cl::cat(ClangMoveCategory));
+cl::opt<std::string>
+    NewHeader("new_header",
+              cl::desc("The relative/absolute file path of new header."),
 
-cl::opt<std::string> NewCC("new_cc", cl::desc("New CC file."),
-                           cl::cat(ClangMoveCategory));
+cl::opt<std::string>
+    NewCC("new_cc", cl::desc("The relative/absolute file path of new cc."),
 
 cl::opt<std::string>
     Style("style",
           cl::desc("The style name used for reformatting. Default is \"llvm\""),
           cl::init("llvm"), cl::cat(ClangMoveCategory));
 
 cl::opt<bool> Dump("dump_result",
                    cl::desc("Dump results in JSON format to stdout."),
                    cl::cat(ClangMoveCategory));
 
 } // namespace
 
 int main(int argc, const char **argv) {
   tooling::CommonOptionsParser OptionsParser(argc, argv, ClangMoveCategory);
   tooling::RefactoringTool Tool(OptionsParser.getCompilations(),
                                 OptionsParser.getSourcePathList());
   move::ClangMoveTool::MoveDefinitionSpec Spec;
   Spec.Name = Name;
   Spec.OldHeader = OldHeader;
   Spec.NewHeader = NewHeader;
   Spec.OldCC = OldCC;
   Spec.NewCC = NewCC;
+
+  llvm::SmallString<128> InitialDirectory;
+  if (std::error_code EC = llvm::sys::fs::current_path(InitialDirectory))
+    llvm::report_fatal_error("Cannot detect current path: " +
+                             Twine(EC.message()));
+
   auto Factory = llvm::make_unique<clang::move::ClangMoveActionFactory>(
-      Spec, Tool.getReplacements());
+      Spec, Tool.getReplacements(), InitialDirectory.str());
+
   int CodeStatus = Tool.run(Factory.get());
   if (CodeStatus)
     return CodeStatus;
 
   if (!NewCC.empty())
     CreateNewFile(NewCC);
   if (!NewHeader.empty())
     CreateNewFile(NewHeader);

test/CMakeLists.txt

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

test/clang-move/Inputs/database_template.json

+[
+{
+  "directory": "$test_dir/build",
+  "command": "clang++ -o test.o $test_dir/test.cpp",
+  "file": "$test_dir/test.cpp"
+}
+]

test/clang-move/Inputs/test.h

+namespace a {
+class Foo {
+public:
+  int f();
+};
+} // namespace a

test/clang-move/Inputs/test.cpp

+#include "test.h"
+#include "test2.h"
+
+namespace a {
+int Foo::f() {
+  return 0;
+}
+} // namespace a

test/clang-move/move-class.cpp

+// RUN: mkdir -p %T/clang-move/build
+// RUN: sed 's|$test_dir|%/T/clang-move|g' %S/Inputs/database_template.json > %T/clang-move/compile_commands.json
+// RUN: cp %S/Inputs/test*  %T/clang-move/
+// RUN: touch test2.h
+// RUN: cd %T/clang-move
+// RUN: clang-move -name="a::Foo" -new_cc=%T/clang-move/new_test.cpp -new_header=%T/clang-move/new_test.h -old_cc=../clang-move/test.cpp -old_header=../clang-move/test.h %T/clang-move/test.cpp
+// RUN: FileCheck -input-file=%T/clang-move/new_test.cpp -check-prefix=CHECK-NEW-TEST-CPP %s
+// RUN: FileCheck -input-file=%T/clang-move/new_test.h -check-prefix=CHECK-NEW-TEST-H %s
+// RUN: FileCheck -input-file=%T/clang-move/test.cpp -check-prefix=CHECK-OLD-TEST-CPP %s
+// RUN: FileCheck -input-file=%T/clang-move/test.h -check-prefix=CHECK-OLD-TEST-H %s
+//
+// RUN: cp %S/Inputs/test*  %T/clang-move/
+// RUN: cd %T/clang-move
+// RUN: clang-move -name="a::Foo" -new_cc=%T/clang-move/new_test.cpp -new_header=%T/clang-move/new_test.h -old_cc=%T/clang-move/test.cpp -old_header=%T/clang-move/test.h %T/clang-move/test.cpp
+// RUN: FileCheck -input-file=%T/clang-move/new_test.cpp -check-prefix=CHECK-NEW-TEST-CPP %s
+// RUN: FileCheck -input-file=%T/clang-move/new_test.h -check-prefix=CHECK-NEW-TEST-H %s
+// RUN: FileCheck -input-file=%T/clang-move/test.cpp -check-prefix=CHECK-OLD-TEST-CPP %s
+// RUN: FileCheck -input-file=%T/clang-move/test.h -check-prefix=CHECK-OLD-TEST-H %s
+//
+// CHECK-NEW-TEST-H: namespace a {
+// CHECK-NEW-TEST-H: class Foo {
+// CHECK-NEW-TEST-H: public:
+// CHECK-NEW-TEST-H:   int f();
+// CHECK-NEW-TEST-H: };
+// CHECK-NEW-TEST-H: } // namespace a
+//
+// CHECK-NEW-TEST-CPP: #include "{{.*}}new_test.h"
+// CHECK-NEW-TEST-CPP: #include "test2.h"
+// CHECK-NEW-TEST-CPP: namespace a {
+// CHECK-NEW-TEST-CPP: int Foo::f() { return 0; }
+// CHECK-NEW-TEST-CPP: } // namespace a
+//
+// CHECK-OLD-TEST-H: namespace a {
+// CHECK-OLD-TEST-H: } // namespace a
+//
+// CHECK-OLD-TEST-CPP: #include "test.h"
+// CHECK-OLD-TEST-CPP: #include "test2.h"
+// CHECK-OLD-TEST-CPP: namespace a {
+// CHECK-OLD-TEST-CPP: } // namespace a

unittests/clang-move/ClangMoveTests.cpp

auto CreateFiles = [&FileToSourceText, &Context, &FileToFileID](
     }
   };
   CreateFiles(Spec.NewCC, "");
   CreateFiles(Spec.NewHeader, "");
   CreateFiles(Spec.OldHeader, TestHeader);
   CreateFiles(Spec.OldCC, TestCC);
 
   std::map<std::string, tooling::Replacements> FileToReplacements;
-  ClangMoveTool MoveTool(Spec, FileToReplacements);
+  llvm::SmallString<128> InitialDirectory;
+  std::error_code EC = llvm::sys::fs::current_path(InitialDirectory);
+  assert(!EC);
+  (void)EC;
   auto Factory = llvm::make_unique<clang::move::ClangMoveActionFactory>(
-      Spec, FileToReplacements);
+      Spec, FileToReplacements, InitialDirectory.str());
 
   tooling::runToolOnCodeWithArgs(
       Factory->create(), TestCC, {"-std=c++11"}, TestCCName, "clang-move",
       std::make_shared<PCHContainerOperations>(), FileToSourceText);
   formatAndApplyAllReplacements(FileToReplacements, Context.Rewrite, "llvm");
   // The Key is file name, value is the new code after moving the class.
   std::map<std::string, std::string> Results;
   for (const auto &It : FileToReplacements) {