[clang-move] Compare with real paths of symlinks

[hokein]

Summary

MakeAbsolutePath does wrong things with symlinks previously. When comparing with a symlink, we need to compare with the real path of it. This fixes issues when the build directory is a symlink.

[hokein]

Update the patch based on offline discussion.

[ioeric]

Lg with one nit.

clang-move/ClangMove.cpp

336–337

This duplicates MakeAbsolutePath in line 400

[hokein]

Update.

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.
+    // The old header name.
     std::string OldHeader;
-    // The file path of old cc, can be relative path and absolute path.
+    // The old cc name.
     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,
-      llvm::StringRef OriginalRunningDirectory, llvm::StringRef Style);
+      llvm::StringRef Style);
 
   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.
   ///
   /// \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 SM The SourceManager.
   void addIncludes(llvm::StringRef IncludeHeader,
                    bool IsAngled,
-                   llvm::StringRef SearchPath,
-                   llvm::StringRef FileName,
-                   const SourceManager& SM);
+                   llvm::StringRef FileName);
 
 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;
   // The name of a predefined code style.
   std::string FallbackStyle;
 };
 
 class ClangMoveAction : public clang::ASTFrontendAction {
 public:
   ClangMoveAction(
       const ClangMoveTool::MoveDefinitionSpec &spec,
       std::map<std::string, tooling::Replacements> &FileToReplacements,
-      llvm::StringRef OriginalRunningDirectory, llvm::StringRef FallbackStyle)
-      : MoveTool(spec, FileToReplacements, OriginalRunningDirectory,
-                 FallbackStyle) {
+      llvm::StringRef FallbackStyle)
+      : MoveTool(spec, FileToReplacements, FallbackStyle) {
     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,
-      llvm::StringRef OriginalRunningDirectory, llvm::StringRef FallbackStyle)
+      llvm::StringRef FallbackStyle)
       : Spec(Spec), FileToReplacements(FileToReplacements),
-        OriginalRunningDirectory(OriginalRunningDirectory),
         FallbackStyle(FallbackStyle) {}
 
   clang::FrontendAction *create() override {
-    return new ClangMoveAction(Spec, FileToReplacements,
-                               OriginalRunningDirectory, FallbackStyle);
+    return new ClangMoveAction(Spec, FileToReplacements, FallbackStyle);
   }
 
 private:
   const ClangMoveTool::MoveDefinitionSpec &Spec;
   std::map<std::string, tooling::Replacements> &FileToReplacements;
-  std::string OriginalRunningDirectory;
   std::string FallbackStyle;
 };
 
 } // 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);
-  llvm::sys::path::native(AbsolutePath);
-  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);
-  llvm::sys::path::native(AbsolutePath);
-  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, SearchPath,
-                            FileEntry->getName(), SM);
+      MoveTool->addIncludes(FileName, IsAngled, FileEntry->getName());
   }
 
 private:
   const SourceManager &SM;
   ClangMoveTool *const MoveTool;
 };
 
 // Expand to get the end location of the line where the EndLoc of the given
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 OriginalRunningDirectory,
-                    llvm::StringRef OldHeader) {
-  if (OldHeader.empty())
+bool IsInHeaderFile(const clang::SourceManager &SM, const clang::Decl *D,
+                    llvm::StringRef HeaderFile) {
+  if (HeaderFile.empty())
     return false;
   auto ExpansionLoc = SM.getExpansionLoc(D->getLocStart());
   if (ExpansionLoc.isInvalid())
     return false;
 
-  if (const auto *FE = SM.getFileEntryForID(SM.getFileID(ExpansionLoc))) {
-    return MakeAbsolutePath(SM, FE->getName()) ==
-           MakeAbsolutePath(OriginalRunningDirectory, OldHeader);
-  }
+  if (const auto *FE = SM.getFileEntryForID(SM.getFileID(ExpansionLoc)))
+    return llvm::StringRef(FE->getName()).endswith(HeaderFile);
 
   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,
-    llvm::StringRef OriginalRunningDirectory, llvm::StringRef FallbackStyle)
+    llvm::StringRef FallbackStyle)
     : Spec(MoveSpec), FileToReplacements(FileToReplacements),
-      OriginalRunningDirectory(OriginalRunningDirectory),
       FallbackStyle(FallbackStyle) {
   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 = isExpansionInFile(
-      MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader));
-  auto InOldCC = isExpansionInFile(
-      MakeAbsolutePath(OriginalRunningDirectory, Spec.OldCC));
+  auto InOldHeader = isExpansionInFileMatching(Spec.OldHeader);
+  auto InOldCC = isExpansionInFileMatching(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 SearchPath,
-                                llvm::StringRef FileName,
-                                const SourceManager& SM) {
-  auto AbsoluteSearchPath = MakeAbsolutePath(SM, SearchPath);
+void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader, bool IsAngled,
+                                llvm::StringRef FileName) {
   // 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 (MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader) ==
-      MakeAbsolutePath(AbsoluteSearchPath, IncludeHeader))
+  if (!Spec.OldHeader.empty() &&
+      llvm::StringRef(Spec.OldHeader).endswith(IncludeHeader))
     return;
 
   std::string IncludeLine =
       IsAngled ? ("#include <" + IncludeHeader + ">\n").str()
                : ("#include \"" + IncludeHeader + "\"\n").str();
-
-  std::string AbsolutePath = MakeAbsolutePath(SM, FileName);
-  if (MakeAbsolutePath(OriginalRunningDirectory, Spec.OldHeader) ==
-      AbsolutePath) {
+  if (!Spec.OldHeader.empty() && FileName.endswith(Spec.OldHeader))
     HeaderIncludes.push_back(IncludeLine);
-  } else if (MakeAbsolutePath(OriginalRunningDirectory, Spec.OldCC) ==
-             AbsolutePath) {
+  else if (!Spec.OldCC.empty() && FileName.endswith(Spec.OldCC))
     CCIncludes.push_back(IncludeLine);
-  }
-}
 
 void ClangMoveTool::removeClassDefinitionInOldFiles() {
   for (const auto &MovedDecl : RemovedDecls) {
     const auto &SM = *MovedDecl.SM;
     auto Range = GetFullRange(&SM, MovedDecl.Decl);
     clang::tooling::Replacement RemoveReplacement(
         *MovedDecl.SM, clang::CharSourceRange::getCharRange(
                            Range.getBegin(), Range.getEnd()),
for (const auto &MovedDecl : RemovedDecls) {
     FileToReplacements[FilePath] = *CleanReplacements;
   }
 }
 
 void ClangMoveTool::moveClassDefinitionToNewFiles() {
   std::vector<MovedDecl> NewHeaderDecls;
   std::vector<MovedDecl> NewCCDecls;
   for (const auto &MovedDecl : MovedDecls) {
-    if (isInHeaderFile(*MovedDecl.SM, MovedDecl.Decl, OriginalRunningDirectory,
-                       Spec.OldHeader))
+    if (IsInHeaderFile(*MovedDecl.SM, MovedDecl.Decl, 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("The relative/absolute file path of old header."),
+cl::opt<std::string> OldHeader("old_header", cl::desc("Old header name."),
                                cl::cat(ClangMoveCategory));
 
-cl::opt<std::string>
-    OldCC("old_cc", cl::desc("The relative/absolute file path of old cc."),
+cl::opt<std::string> OldCC("old_cc", cl::desc("Old CC file name."),
                            cl::cat(ClangMoveCategory));
 
 cl::opt<std::string>
     NewHeader("new_header",
               cl::desc("The relative/absolute file path of new header."),
               cl::cat(ClangMoveCategory));
 
 cl::opt<std::string>
-    NewCC("new_cc", cl::desc("The relative/absolute file path of new cc."),
+    NewCC("new_cc", cl::desc("The relative/absolute file path of new cc file."),
           cl::cat(ClangMoveCategory));
 
 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",
int main(int argc, const char **argv) {
   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(), InitialDirectory.str(), Style);
-
+      Spec, Tool.getReplacements(), Style);
   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",
+  "command": "clang++ -o test.o -I../include $test_dir/test.cpp",
   "file": "$test_dir/test.cpp"
 }
 ]

test/clang-move/move-class.cpp

 // RUN: mkdir -p %T/clang-move/build
+// RUN: mkdir -p %T/clang-move/include
 // 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 %T/clang-move/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: cp %S/Inputs/test.h  %T/clang-move/include
+// RUN: cp %S/Inputs/test.cpp  %T/clang-move/
+// RUN: touch %T/clang-move/include/test2.h
+// RUN: cd %T/clang-move/build
+// RUN: clang-move -name="a::Foo" -new_cc=%T/clang-move/new_test.cpp -new_header=%T/clang-move/new_test.h -old_cc=test.cpp -old_header=../include/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 %s -implicit-check-not='{{namespace.*}}'
-//
-// 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 %s -implicit-check-not='{{namespace.*}}'
+// RUN: FileCheck -input-file=%T/clang-move/include/test.h %s -implicit-check-not='{{namespace.*}}'
 //
 // 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-CPP: #include "test.h"
 // CHECK-OLD-TEST-CPP: #include "test2.h"

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;
-  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, InitialDirectory.str(), "LLVM");
+      Spec, FileToReplacements, "LLVM");
 
   tooling::runToolOnCodeWithArgs(
       Factory->create(), TestCC, {"-std=c++11", "-fparse-all-comments"},
       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;