[clang-move] Cleanup around replacements.

[hokein]

Summary

cleanup the remaining empty namespace after moving out the
class defintitions.

[ioeric]

Lg

clang-tools-extra/trunk/clang-move/ClangMove.h

struct MoveDefinitionSpec {
     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 OriginalRunningDirectory, 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.
private:
   // 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)
-      : MoveTool(spec, FileToReplacements, OriginalRunningDirectory) {
+      llvm::StringRef OriginalRunningDirectory, llvm::StringRef FallbackStyle)
+      : MoveTool(spec, FileToReplacements, OriginalRunningDirectory,
+                 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 OriginalRunningDirectory, llvm::StringRef FallbackStyle)
       : Spec(Spec), FileToReplacements(FileToReplacements),
-        OriginalRunningDirectory(OriginalRunningDirectory) {}
+        OriginalRunningDirectory(OriginalRunningDirectory),
+        FallbackStyle(FallbackStyle) {}
 
   clang::FrontendAction *create() override {
-    return new ClangMoveAction(Spec, FileToReplacements, OriginalRunningDirectory);
+    return new ClangMoveAction(Spec, FileToReplacements,
+                               OriginalRunningDirectory, 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-tools-extra/trunk/clang-move/ClangMove.cpp

 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)
-      : Spec(MoveSpec), FileToReplacements(FileToReplacements),
-        OriginalRunningDirectory(OriginalRunningDirectory) {
+    llvm::StringRef OriginalRunningDirectory, llvm::StringRef FallbackStyle)
+      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(
void ClangMoveTool::addIncludes(llvm::StringRef IncludeHeader,
   } 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);
+    const auto &SM = *MovedDecl.SM;
+    auto EndLoc = getLocForEndOfDecl(MovedDecl.Decl, &SM);
     clang::tooling::Replacement RemoveReplacement(
-        *MovedDecl.SM, clang::CharSourceRange::getTokenRange(
-                           MovedDecl.Decl->getLocStart(), EndLoc),
+        SM, clang::CharSourceRange::getTokenRange(MovedDecl.Decl->getLocStart(),
+                                                  EndLoc),
         "");
     std::string FilePath = RemoveReplacement.getFilePath().str();
     addOrMergeReplacement(RemoveReplacement, &FileToReplacements[FilePath]);
+
+    llvm::StringRef Code =
+        SM.getBufferData(SM.getFileID(MovedDecl.Decl->getLocation()));
+    format::FormatStyle Style =
+        format::getStyle("file", FilePath, FallbackStyle);
+    auto CleanReplacements = format::cleanupAroundReplacements(
+        Code, FileToReplacements[FilePath], Style);
+
+    if (!CleanReplacements) {
+      llvm::errs() << llvm::toString(CleanReplacements.takeError()) << "\n";
+      continue;
+    }
+    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,

clang-tools-extra/trunk/clang-move/tool/ClangMoveMain.cpp

int main(int argc, const char **argv) {
   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());
+      Spec, Tool.getReplacements(), InitialDirectory.str(), Style);
 
   int CodeStatus = Tool.run(Factory.get());
   if (CodeStatus)
     return CodeStatus;
 
   if (!NewCC.empty())
     CreateNewFile(NewCC);
   if (!NewHeader.empty())

clang-tools-extra/trunk/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 %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: 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: 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 -check-prefix=CHECK-OLD-TEST-H %s
+// RUN: FileCheck -input-file=%T/clang-move/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-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

clang-tools-extra/trunk/unittests/clang-move/ClangMoveTests.cpp

runClangMoveOnCode(const move::ClangMoveTool::MoveDefinitionSpec &Spec) {
   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());
+      Spec, FileToReplacements, InitialDirectory.str(), "LLVM");
 
   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) {