[clang-move] Don't overuse Replacements::add.

[ioeric]

clang-move/ClangMove.cpp

472 ↗

(On Diff #74672)

For deletions, you can simply use add, which now simply merges overlapping deletions. And I think it should be considered an error if add fails. With add, you can get rid of addOrMergeReplacement.

[hokein]

woohoo, delete more code!

[hokein]

Delete one more function.

[ioeric]

Awesome! Lg with one nit.

clang-move/ClangMove.cpp

197 ↗

(On Diff #74675)

This is also dead I think :P

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

 
 std::string getDeclarationSourceText(const clang::Decl *D,
                                      const clang::SourceManager *SM) {
   llvm::StringRef SourceText = clang::Lexer::getSourceText(
       GetFullRange(SM, D), *SM, clang::LangOptions());
   return SourceText.str();
 }
 
-clang::tooling::Replacement
-getReplacementInChangedCode(const clang::tooling::Replacements &Replacements,
-                            const clang::tooling::Replacement &Replacement) {
-  unsigned Start = Replacements.getShiftedCodePosition(Replacement.getOffset());
-  unsigned End = Replacements.getShiftedCodePosition(Replacement.getOffset() +
-                                                     Replacement.getLength());
-  return clang::tooling::Replacement(Replacement.getFilePath(), Start,
-                                     End - Start,
-                                     Replacement.getReplacementText());
-}
-
-void addOrMergeReplacement(const clang::tooling::Replacement &Replacement,
-                           clang::tooling::Replacements *Replacements) {
-  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())
     return false;
   auto ExpansionLoc = SM.getExpansionLoc(D->getLocStart());
   if (ExpansionLoc.isInvalid())
     return false;
std::vector<std::string> GetNamespaces(const clang::Decl *D) {
   return Namespaces;
 }
 
 clang::tooling::Replacements
 createInsertedReplacements(const std::vector<std::string> &Includes,
                            const std::vector<ClangMoveTool::MovedDecl> &Decls,
                            llvm::StringRef FileName,
                            bool IsHeader = false) {
-  clang::tooling::Replacements InsertedReplacements;
+  std::string NewCode;
   std::string GuardName(FileName);
   if (IsHeader) {
     std::replace(GuardName.begin(), GuardName.end(), '/', '_');
     std::replace(GuardName.begin(), GuardName.end(), '.', '_');
     std::replace(GuardName.begin(), GuardName.end(), '-', '_');
 
     GuardName = StringRef(GuardName).upper();
-    std::string HeaderGuard = "#ifndef " + GuardName + "\n";
-    HeaderGuard += "#define " + GuardName + "\n";
-    clang::tooling::Replacement HeaderGuardInclude(FileName, 0, 0,
-                                                   HeaderGuard);
-    addOrMergeReplacement(HeaderGuardInclude, &InsertedReplacements);
+    NewCode += "#ifndef " + GuardName + "\n";
+    NewCode += "#define " + GuardName + "\n";
   }
 
   // Add #Includes.
-  std::string AllIncludesString;
-  // FIXME: Add header guard.
   for (const auto &Include : Includes)
-    AllIncludesString += Include;
+    NewCode += Include;
 
-  if (!AllIncludesString.empty()) {
-    clang::tooling::Replacement InsertInclude(FileName, 0, 0,
-                                              AllIncludesString + "\n");
-    addOrMergeReplacement(InsertInclude, &InsertedReplacements);
-  }
+  if (!Includes.empty())
+    NewCode += "\n";
 
   // Add moved class definition and its related declarations. All declarations
   // in same namespace are grouped together.
   std::vector<std::string> CurrentNamespaces;
   for (const auto &MovedDecl : Decls) {
     std::vector<std::string> DeclNamespaces = GetNamespaces(MovedDecl.Decl);
     auto CurrentIt = CurrentNamespaces.begin();
     auto DeclIt = DeclNamespaces.begin();
     while (CurrentIt != CurrentNamespaces.end() &&
            DeclIt != DeclNamespaces.end()) {
       if (*CurrentIt != *DeclIt)
         break;
       ++CurrentIt;
       ++DeclIt;
     }
     std::vector<std::string> NextNamespaces(CurrentNamespaces.begin(),
                                             CurrentIt);
     NextNamespaces.insert(NextNamespaces.end(), DeclIt, DeclNamespaces.end());
     auto RemainingSize = CurrentNamespaces.end() - CurrentIt;
     for (auto It = CurrentNamespaces.rbegin(); RemainingSize > 0;
          --RemainingSize, ++It) {
       assert(It < CurrentNamespaces.rend());
-      auto code = "} // namespace " + *It + "\n";
-      clang::tooling::Replacement InsertedReplacement(FileName, 0, 0, code);
-      addOrMergeReplacement(InsertedReplacement, &InsertedReplacements);
+      NewCode += "} // namespace " + *It + "\n";
     }
     while (DeclIt != DeclNamespaces.end()) {
-      clang::tooling::Replacement InsertedReplacement(
-          FileName, 0, 0, "namespace " + *DeclIt + " {\n");
-      addOrMergeReplacement(InsertedReplacement, &InsertedReplacements);
+      NewCode += "namespace " + *DeclIt + " {\n";
       ++DeclIt;
     }
-
-    clang::tooling::Replacement InsertedReplacement(
-        FileName, 0, 0, getDeclarationSourceText(MovedDecl.Decl, MovedDecl.SM));
-    addOrMergeReplacement(InsertedReplacement, &InsertedReplacements);
-
+    NewCode += getDeclarationSourceText(MovedDecl.Decl, MovedDecl.SM);
     CurrentNamespaces = std::move(NextNamespaces);
   }
   std::reverse(CurrentNamespaces.begin(), CurrentNamespaces.end());
-  for (const auto &NS : CurrentNamespaces) {
-    clang::tooling::Replacement InsertedReplacement(
-        FileName, 0, 0, "} // namespace " + NS + "\n");
-    addOrMergeReplacement(InsertedReplacement, &InsertedReplacements);
-  }
+  for (const auto &NS : CurrentNamespaces)
+    NewCode += "} // namespace " + NS + "\n";
 
-  if (IsHeader) {
-    clang::tooling::Replacement HeaderGuardEnd(FileName, 0, 0,
-                                               "#endif // " + GuardName + "\n");
-    addOrMergeReplacement(HeaderGuardEnd, &InsertedReplacements);
-  }
-  return InsertedReplacements;
+  if (IsHeader)
+    NewCode += "#endif // " + GuardName + "\n";
+  return clang::tooling::Replacements(
+      clang::tooling::Replacement(FileName, 0, 0, NewCode));
 }
 
 } // namespace
 
 std::unique_ptr<clang::ASTConsumer>
 ClangMoveAction::CreateASTConsumer(clang::CompilerInstance &Compiler,
                                    StringRef /*InFile*/) {
   Compiler.getPreprocessor().addPPCallbacks(llvm::make_unique<FindAllIncludes>(
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()),
         "");
     std::string FilePath = RemoveReplacement.getFilePath().str();
-    addOrMergeReplacement(RemoveReplacement, &FileToReplacements[FilePath]);
+    auto Err = FileToReplacements[FilePath].add(RemoveReplacement);
+    if (Err) {
+      llvm::errs() << llvm::toString(std::move(Err)) << "\n";
+      continue;
+    }
 
     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);