[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?

78

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

109

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

clang-move/ClangMove.h

63

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

64

Should SearchPath be absolute or relative?

88

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);
+  void addIncludes(llvm::StringRef IncludeHeader,
+                   llvm::StringRef SearchPath,
+                   bool IsAngled,
+                   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 analysising the source file. We saves 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 {
 
+std::string MakeAbsolutePath(StringRef Dir, StringRef Path) {
+  if (Path.empty())
+    return "";
+  llvm::SmallString<128> InitialDirectory(Dir);
+  llvm::SmallString<128> AbsolutePath(Path);
+  auto EC = llvm::sys::fs::make_absolute(InitialDirectory, AbsolutePath);
+  assert(!EC);
+  (void)EC;
+  llvm::sys::path::remove_dots(AbsolutePath, /*remove_dot_dot=*/true);
+  return AbsolutePath.str();
+}
+
+std::string MakeAbsolutePath(const SourceManager& SM, StringRef Path) {
+  llvm::SmallString<128> AbsolutePath(Path);
+  auto EC =
+      SM.getFileManager().getVirtualFileSystem()->makeAbsolute(AbsolutePath);
+  assert(!EC);
+  (void)EC;
+  llvm::sys::path::remove_dots(AbsolutePath, /*remove_dot_dot=*/true);
+  return AbsolutePath.str();
+}
+
+// Matches AST nodes that are expanded within the givien 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, MakeAbsolutePath(SM, SearchPath),
+                            IsAngled, FileEntry->getName(), SM);
   }
 
 private:
   const SourceManager &SM;
   ClangMoveTool *const MoveTool;
 };
 
 clang::tooling::Replacement
void addOrMergeReplacement(const clang::tooling::Replacement &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())
+                    llvm::StringRef OldHeader,
+                    llvm::StringRef OriginalRunningDirectory) {
+  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,
+                                llvm::StringRef SearchPath,
+                                bool IsAngled,
+                                llvm::StringRef FileName,
+                                const SourceManager& SM) {
   // 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(SearchPath, 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, Spec.OldHeader,
+                       OriginalRunningDirectory))
       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/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) {