[include-fixer] use tooling::Replacements since the order of replacements don't matter anymore.

[ioeric]

Summary

[include-fixer] use tooling::Replacements since the order of replacements don't matter anymore.

[bkramer]

nice cleanup

include-fixer/IncludeFixer.h

 /// \param Header The header being inserted.
 /// \param FirstIncludeOffset The insertion point for new include directives.
 /// The default value -1U means inserting the header at the first line, and if
 /// there is no #include block, it will create a header block by inserting a
 /// newline.
 /// \param Style clang-format style being used.
 ///
 /// \return Replacements for inserting and sorting headers.
-std::vector<clang::tooling::Replacement> createInsertHeaderReplacements(
+tooling::Replacements createInsertHeaderReplacements(
     StringRef Code, StringRef FilePath, StringRef Header,
     unsigned FirstIncludeOffset = -1U,
     const clang::format::FormatStyle &Style = clang::format::getLLVMStyle());
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXER_H

include-fixer/IncludeFixer.cpp

Context = ScopedToolAction->getIncludeFixerContext(
       Compiler.getPreprocessor().getHeaderSearchInfo());
 
   // Technically this should only return true if we're sure that we have a
   // parseable file. We don't know that though. Only inform users of fatal
   // errors.
   return !Compiler.getDiagnostics().hasFatalErrorOccurred();
 }
 
-std::vector<clang::tooling::Replacement>
+tooling::Replacements
 createInsertHeaderReplacements(StringRef Code, StringRef FilePath,
                                StringRef Header, unsigned FirstIncludeOffset,
                                const clang::format::FormatStyle &Style) {
   if (Header.empty())
-    return {};
+    return tooling::Replacements();
   // Create replacements for new headers.
   clang::tooling::Replacements Insertions;
   if (FirstIncludeOffset == -1U) {
     // FIXME: skip header guards.
     FirstIncludeOffset = 0;
     // If there is no existing #include, then insert an empty line after new
     // header block.
     if (Code.front() != '\n')
       Insertions.insert(
           clang::tooling::Replacement(FilePath, FirstIncludeOffset, 0, "\n"));
   }
   // Keep inserting new headers before the first header.
   std::string Text = "#include " + Header.str() + "\n";
   Insertions.insert(
       clang::tooling::Replacement(FilePath, FirstIncludeOffset, 0, Text));
   DEBUG({
     llvm::dbgs() << "Header insertions:\n";
     for (const auto &R : Insertions)
       llvm::dbgs() << R.toString() << '\n';
   });
 
-  clang::tooling::Replacements Replaces =
-      formatReplacements(Code, Insertions, Style);
-  // FIXME: remove this when `clang::tooling::Replacements` is implemented as
-  // `std::vector<clang::tooling::Replacement>`.
-  std::vector<clang::tooling::Replacement> Results;
-  std::copy(Replaces.begin(), Replaces.end(), std::back_inserter(Results));
-  return Results;
+  return formatReplacements(Code, Insertions, Style);
 }
 
 } // namespace include_fixer
 } // namespace clang

include-fixer/tool/ClangIncludeFixer.cpp

int includeFixerMain(int argc, const char **argv) {
 
   if (!InsertHeader.empty()) {
     if (!STDINMode) {
       errs() << "Should be running in STDIN mode\n";
       return 1;
     }
 
     // FIXME: Insert the header in right FirstIncludeOffset.
-    std::vector<tooling::Replacement> Replacements =
+    tooling::Replacements Replacements =
         clang::include_fixer::createInsertHeaderReplacements(
             Code->getBuffer(), FilePath, InsertHeader,
             /*FirstIncludeOffset=*/0, InsertStyle);
     tooling::Replacements Replaces(Replacements.begin(), Replacements.end());
     std::string ChangedCode =
         tooling::applyAllReplacements(Code->getBuffer(), Replaces);
     llvm::outs() << ChangedCode;
     return 0;
int includeFixerMain(int argc, const char **argv) {
 
   auto Buffer = llvm::MemoryBuffer::getFile(FilePath);
   if (!Buffer) {
     errs() << "Couldn't open file: " << FilePath;
     return 1;
   }
 
   // FIXME: Rank the results and pick the best one instead of the first one.
-  std::vector<tooling::Replacement> Replacements =
+  tooling::Replacements Replacements =
       clang::include_fixer::createInsertHeaderReplacements(
           /*Code=*/Buffer.get()->getBuffer(), FilePath, Context.Headers.front(),
           Context.FirstIncludeOffset, InsertStyle);
 
   if (!Quiet)
     llvm::errs() << "Added #include" << Context.Headers.front();
 
   // Set up a new source manager for applying the resulting replacements.
   IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts(new DiagnosticOptions);
   DiagnosticsEngine Diagnostics(new DiagnosticIDs, &*DiagOpts);
   TextDiagnosticPrinter DiagnosticPrinter(outs(), &*DiagOpts);
   SourceManager SM(Diagnostics, tool.getFiles());
   Diagnostics.setClient(&DiagnosticPrinter, false);
 
   if (STDINMode) {
-    tooling::Replacements Replaces(Replacements.begin(), Replacements.end());
     std::string ChangedCode =
-        tooling::applyAllReplacements(Code->getBuffer(), Replaces);
+        tooling::applyAllReplacements(Code->getBuffer(), Replacements);
     llvm::outs() << ChangedCode;
     return 0;
   }
 
   // Write replacements to disk.
   Rewriter Rewrites(SM, LangOptions());
   tooling::applyAllReplacements(Replacements, Rewrites);
   return Rewrites.overwriteChangedFiles();
 }
 
 } // namespace
 
 int main(int argc, const char **argv) {
   return includeFixerMain(argc, argv);
 }

unittests/include-fixer/IncludeFixerTest.cpp

static std::string runIncludeFixer(
   auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
   SymbolIndexMgr->addSymbolIndex(
       llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols));
 
   IncludeFixerContext FixerContext;
   IncludeFixerActionFactory Factory(*SymbolIndexMgr, FixerContext, "llvm");
 
   runOnCode(&Factory, Code, "input.cc", ExtraArgs);
-  std::vector<clang::tooling::Replacement> Replacements;
-  if (!FixerContext.Headers.empty()) {
-    Replacements = clang::include_fixer::createInsertHeaderReplacements(
+  if (FixerContext.Headers.empty())
+    return Code;
+  tooling::Replacements Replacements =
+      clang::include_fixer::createInsertHeaderReplacements(
           Code, "input.cc", FixerContext.Headers.front(),
           FixerContext.FirstIncludeOffset);
-  }
   clang::RewriterTestContext Context;
   clang::FileID ID = Context.createInMemoryFile("input.cc", Code);
   clang::tooling::applyAllReplacements(Replacements, Context.Rewrite);
   return Context.getRewrittenText(ID);
 }
 
 TEST(IncludeFixer, Typo) {
   EXPECT_EQ("#include <string>\n\nstd::string foo;\n",