[include-fixer] Support processing multiple files in one run.

[hokein]

Summary

Previously, if we pass multiple files or a file pattern (e.g. /path/to/*.cc) to
include-fixer, include-fixer will apply all replacements to the first argument,
which probably causes crashes.

With this patch, include-fixer can process multiple files now.

Vim and Emacs integration are tested manually.

[hokein]

Remove unneeded header.

[hokein]

Add missing tests.

[bkramer]

Can you add a lit test for this? We should've added that earlier :|

include-fixer/IncludeFixer.h

53

This comment is now outdated, there are multiple contexts.

include-fixer/IncludeFixerContext.h

21–22

A context for a file being processed.

78

Does it have to be absolute?

[hokein]

Address review comments.

[hokein]

Can you add a lit test for this? We should've added that earlier :|

I forgot to upload the test first time. But I have already uploaded it, see multiple_fixes.cpp

include-fixer/IncludeFixerContext.h

78

It depends on InFile parameter in clang::ASTFrontendAction::CreateASTConsumer method. Isn't it always an absolute file path?

[bkramer]

lgtm

include-fixer/IncludeFixerContext.h

78

I don't think there are any guarantees about that.

[hokein]

Update comments, don't mention absolute file path since this is no guarantee
about that.

include-fixer/IncludeFixer.h

 
 class IncludeFixerActionFactory : public clang::tooling::ToolAction {
 public:
   /// \param SymbolIndexMgr A source for matching symbols to header files.
   /// \param Context A context for the symbol being queried.
   /// \param StyleName Fallback style for reformatting.
   /// \param MinimizeIncludePaths whether inserted include paths are optimized.
   IncludeFixerActionFactory(SymbolIndexManager &SymbolIndexMgr,
-                            IncludeFixerContext &Context, StringRef StyleName,
+                            std::vector<IncludeFixerContext> &Contexts,
+                            StringRef StyleName,
                             bool MinimizeIncludePaths = true);
 
   ~IncludeFixerActionFactory() override;
 
   bool
   runInvocation(clang::CompilerInvocation *Invocation,
                 clang::FileManager *Files,
                 std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps,
                 clang::DiagnosticConsumer *Diagnostics) override;
 
 private:
   /// The client to use to find cross-references.
   SymbolIndexManager &SymbolIndexMgr;
 
   /// The context that contains all information about the symbol being queried.
-  IncludeFixerContext &Context;
+  std::vector<IncludeFixerContext> &Contexts;
 
   /// Whether inserted include paths should be optimized.
   bool MinimizeIncludePaths;
 
   /// The fallback format style for formatting after insertion if no
   /// clang-format config file was found.
   std::string FallbackStyle;
 };
 
 /// Create replacements, which are generated by clang-format, for the
 /// missing header and mising qualifiers insertions. The function uses the
 /// first header for insertion.
 ///
 /// \param Code The source code.
-/// \param FilePath The source file path.
 /// \param Context The context which contains all information for creating
 /// include-fixer replacements.
 /// \param Style clang-format style being used.
 /// \param AddQualifiers  Whether we should add qualifiers to all instances of
 /// an unidentified symbol.
 ///
 /// \return Formatted replacements for inserting, sorting headers and adding
 /// qualifiers on success; otherwise, an llvm::Error carrying llvm::StringError
 /// is returned.
 llvm::Expected<tooling::Replacements> createIncludeFixerReplacements(
-    StringRef Code, StringRef FilePath, const IncludeFixerContext &Context,
+    StringRef Code, const IncludeFixerContext &Context,
     const format::FormatStyle &Style = format::getLLVMStyle(),
     bool AddQualifiers = true);
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXER_H

include-fixer/IncludeFixer.cpp

 public:
   explicit Action(SymbolIndexManager &SymbolIndexMgr, bool MinimizeIncludePaths)
       : SymbolIndexMgr(SymbolIndexMgr),
         MinimizeIncludePaths(MinimizeIncludePaths) {}
 
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &Compiler,
                     StringRef InFile) override {
+    FilePath = InFile;
     return llvm::make_unique<clang::ASTConsumer>();
   }
 
   void ExecuteAction() override {
     clang::CompilerInstance *Compiler = &getCompilerInstance();
     assert(!Compiler->hasSema() && "CI already has Sema");
 
     // Set up our hooks into sema and parse the AST.
for (const auto &Symbol : MatchedSymbols) {
           ((FilePath[0] == '"' || FilePath[0] == '<') ? FilePath
                                                       : "\"" + FilePath + "\""),
           SourceManager, HeaderSearch);
       SymbolCandidates.emplace_back(Symbol.getName(), Symbol.getSymbolKind(),
                                     MinimizedFilePath, Symbol.getLineNumber(),
                                     Symbol.getContexts(),
                                     Symbol.getNumOccurrences());
     }
-    return IncludeFixerContext(QuerySymbolInfos, SymbolCandidates);
+    return IncludeFixerContext(FilePath, QuerySymbolInfos, SymbolCandidates);
   }
 
 private:
   /// Query the database for a given identifier.
   bool query(StringRef Query, StringRef ScopedQualifiers,
              tooling::Range Range) {
     assert(!Query.empty() && "Empty query!");
 
private:
   /// The information of the symbols being queried.
   std::vector<IncludeFixerContext::QuerySymbolInfo> QuerySymbolInfos;
 
   /// All symbol candidates which match QuerySymbol. We only include the first
   /// discovered identifier to avoid getting caught in results from error
   /// recovery.
   std::vector<find_all_symbols::SymbolInfo> MatchedSymbols;
 
+  /// The absolute path to the file being processed.
+  std::string FilePath;
+
   /// Whether we should use the smallest possible include path.
   bool MinimizeIncludePaths = true;
 };
 
 } // namespace
 
 IncludeFixerActionFactory::IncludeFixerActionFactory(
-    SymbolIndexManager &SymbolIndexMgr, IncludeFixerContext &Context,
-    StringRef StyleName, bool MinimizeIncludePaths)
-    : SymbolIndexMgr(SymbolIndexMgr), Context(Context),
+    SymbolIndexManager &SymbolIndexMgr,
+    std::vector<IncludeFixerContext> &Contexts, StringRef StyleName,
+    bool MinimizeIncludePaths)
+    : SymbolIndexMgr(SymbolIndexMgr), Contexts(Contexts),
       MinimizeIncludePaths(MinimizeIncludePaths) {}
 
 IncludeFixerActionFactory::~IncludeFixerActionFactory() = default;
 
 bool IncludeFixerActionFactory::runInvocation(
     clang::CompilerInvocation *Invocation, clang::FileManager *Files,
     std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps,
     clang::DiagnosticConsumer *Diagnostics) {
bool IncludeFixerActionFactory::runInvocation(
   // fatal. A missing #include can cause thousands of errors.
   Compiler.getDiagnostics().setErrorLimit(0);
 
   // Run the parser, gather missing includes.
   auto ScopedToolAction =
       llvm::make_unique<Action>(SymbolIndexMgr, MinimizeIncludePaths);
   Compiler.ExecuteAction(*ScopedToolAction);
 
-  Context = ScopedToolAction->getIncludeFixerContext(
+  Contexts.push_back(ScopedToolAction->getIncludeFixerContext(
       Compiler.getSourceManager(),
-      Compiler.getPreprocessor().getHeaderSearchInfo());
+      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();
 }
 
 llvm::Expected<tooling::Replacements> createIncludeFixerReplacements(
-    StringRef Code, StringRef FilePath, const IncludeFixerContext &Context,
+    StringRef Code, const IncludeFixerContext &Context,
     const clang::format::FormatStyle &Style, bool AddQualifiers) {
   if (Context.getHeaderInfos().empty())
     return tooling::Replacements();
+  StringRef FilePath = Context.getFilePath();
   std::string IncludeName =
       "#include " + Context.getHeaderInfos().front().Header + "\n";
   // Create replacements for the new header.
   clang::tooling::Replacements Insertions;
   auto Err =
       Insertions.add(tooling::Replacement(FilePath, UINT_MAX, 0, IncludeName));
   if (Err)
     return std::move(Err);

include-fixer/IncludeFixerContext.h

 #include "find-all-symbols/SymbolInfo.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace include_fixer {
 
-/// \brief A context for the symbol being queried.
+/// \brief A context for the file being processed. It includes all query
+/// information, e.g. symbols being queried in database, all header candiates.
 class IncludeFixerContext {
 public:
   struct HeaderInfo {
     /// \brief The header where QualifiedName comes from.
     std::string Header;
     /// \brief A symbol name with completed namespace qualifiers which will
     /// replace the original symbol.
     std::string QualifiedName;
struct QuerySymbolInfo {
     /// Empty if SymbolIdentifier is not in a specific scope.
     std::string ScopedQualifiers;
 
     /// \brief The replacement range of RawIdentifier.
     tooling::Range Range;
   };
 
   IncludeFixerContext() = default;
-  IncludeFixerContext(std::vector<QuerySymbolInfo> QuerySymbols,
+  IncludeFixerContext(StringRef FilePath,
+                      std::vector<QuerySymbolInfo> QuerySymbols,
                       std::vector<find_all_symbols::SymbolInfo> Symbols);
 
   /// \brief Get symbol name.
   llvm::StringRef getSymbolIdentifier() const {
     return QuerySymbolInfos.front().RawIdentifier;
   }
 
   /// \brief Get replacement range of the symbol.
   tooling::Range getSymbolRange() const {
     return QuerySymbolInfos.front().Range;
   }
 
+  /// \brief Get the absolute file path.
+  StringRef getFilePath() const { return FilePath; }
+
   /// \brief Get header information.
   const std::vector<HeaderInfo> &getHeaderInfos() const { return HeaderInfos; }
 
   /// \brief Get information of symbols being querid.
   const std::vector<QuerySymbolInfo> &getQuerySymbolInfos() const {
     return QuerySymbolInfos;
   }
 
 private:
   friend struct llvm::yaml::MappingTraits<IncludeFixerContext>;
 
+  /// \brief The absolute path to the file being processed.
+  std::string FilePath;
+
   /// \brief All instances of an unidentified symbol being queried.
   std::vector<QuerySymbolInfo> QuerySymbolInfos;
 
   /// \brief The symbol candidates which match SymbolIdentifier. The symbols are
   /// sorted in a descending order based on the popularity info in SymbolInfo.
   std::vector<find_all_symbols::SymbolInfo> MatchedSymbols;
 
   /// \brief The header information.
   std::vector<HeaderInfo> HeaderInfos;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXERCONTEXT_H

include-fixer/IncludeFixerContext.cpp

for (; FullySymbolQualifiersIter != FullySymbolQualifiers.end();
     Result += *FullySymbolQualifiersIter;
   }
   return Result;
 }
 
 } // anonymous namespace
 
 IncludeFixerContext::IncludeFixerContext(
-    std::vector<QuerySymbolInfo> QuerySymbols,
+    StringRef FilePath, std::vector<QuerySymbolInfo> QuerySymbols,
     std::vector<find_all_symbols::SymbolInfo> Symbols)
-    : QuerySymbolInfos(std::move(QuerySymbols)),
+    : FilePath(FilePath), QuerySymbolInfos(std::move(QuerySymbols)),
       MatchedSymbols(std::move(Symbols)) {
   // Remove replicated QuerySymbolInfos with the same range.
   //
   // QuerySymbolInfos may contain replicated elements. Because CorrectTypo
   // callback doesn't always work as we expected. In somecases, it will be
   // triggered at the same position or unidentified symbol multiple times.
   std::sort(QuerySymbolInfos.begin(), QuerySymbolInfos.end(),
             [&](const QuerySymbolInfo &A, const QuerySymbolInfo &B) {

include-fixer/tool/ClangIncludeFixer.cpp

static void mapping(IO &io, IncludeFixerContext::QuerySymbolInfo &Info) {
     io.mapRequired("Range", Info.Range);
   }
 };
 
 template <> struct MappingTraits<IncludeFixerContext> {
   static void mapping(IO &IO, IncludeFixerContext &Context) {
     IO.mapRequired("QuerySymbolInfos", Context.QuerySymbolInfos);
     IO.mapRequired("HeaderInfos", Context.HeaderInfos);
+    IO.mapRequired("FilePath", Context.FilePath);
   }
 };
 } // namespace yaml
 } // namespace llvm
 
 namespace {
 cl::OptionCategory IncludeFixerCategory("Tool options");
 
case yaml: {
     break;
   }
   }
   return SymbolIndexMgr;
 }
 
 void writeToJson(llvm::raw_ostream &OS, const IncludeFixerContext& Context) {
   OS << "{\n"
-        "  \"QuerySymbolInfos\": [\n";
+     << "  \"FilePath\": \""
+     << llvm::yaml::escape(Context.getFilePath()) << "\",\n"
+     << "  \"QuerySymbolInfos\": [\n";
   for (const auto &Info : Context.getQuerySymbolInfos()) {
     OS << "     {\"RawIdentifier\": \"" << Info.RawIdentifier << "\",\n";
     OS << "      \"Range\":{";
     OS << "\"Offset\":" << Info.Range.getOffset() << ",";
     OS << "\"Length\":" << Info.Range.getLength() << "}}";
     if (&Info != &Context.getQuerySymbolInfos().back())
       OS << ",\n";
   }
if (STDINMode) {
     }
     Code = std::move(CodeOrErr.get());
     if (Code->getBufferSize() == 0)
       return 0;  // Skip empty files.
 
     tool.mapVirtualFile(options.getSourcePathList().front(), Code->getBuffer());
   }
 
-  StringRef FilePath = options.getSourcePathList().front();
-  format::FormatStyle InsertStyle = format::getStyle("file", FilePath, Style);
-
   if (!InsertHeader.empty()) {
     if (!STDINMode) {
       errs() << "Should be running in STDIN mode\n";
       return 1;
     }
 
     llvm::yaml::Input yin(InsertHeader);
     IncludeFixerContext Context;
if (!InsertHeader.empty()) {
     //
     // Check whether all elements in HeaderInfos have the same qualified name.
     bool IsUniqueQualifiedName = std::equal(
         HeaderInfos.begin() + 1, HeaderInfos.end(), HeaderInfos.begin(),
         [](const IncludeFixerContext::HeaderInfo &LHS,
            const IncludeFixerContext::HeaderInfo &RHS) {
           return LHS.QualifiedName == RHS.QualifiedName;
         });
-
+    format::FormatStyle InsertStyle =
+        format::getStyle("file", Context.getFilePath(), Style);
     auto Replacements = clang::include_fixer::createIncludeFixerReplacements(
-        Code->getBuffer(), FilePath, Context, InsertStyle,
+        Code->getBuffer(), Context, InsertStyle,
         /*AddQualifiers=*/IsUniqueQualifiedName);
     if (!Replacements) {
       errs() << "Failed to create replacements: "
              << llvm::toString(Replacements.takeError()) << "\n";
       return 1;
     }
 
     auto ChangedCode =
         tooling::applyAllReplacements(Code->getBuffer(), *Replacements);
     if (!ChangedCode) {
       llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
       return 1;
     }
     llvm::outs() << *ChangedCode;
     return 0;
   }
 
   // Set up data source.
   std::unique_ptr<include_fixer::SymbolIndexManager> SymbolIndexMgr =
       createSymbolIndexManager(options.getSourcePathList().front());
   if (!SymbolIndexMgr)
     return 1;
 
   // Now run our tool.
-  include_fixer::IncludeFixerContext Context;
-  include_fixer::IncludeFixerActionFactory Factory(*SymbolIndexMgr, Context,
+  std::vector<include_fixer::IncludeFixerContext> Contexts;
+  include_fixer::IncludeFixerActionFactory Factory(*SymbolIndexMgr, Contexts,
                                                    Style, MinimizeIncludePaths);
 
   if (tool.run(&Factory) != 0) {
     llvm::errs()
         << "Clang died with a fatal error! (incorrect include paths?)\n";
     return 1;
   }
 
+  assert(!Contexts.empty());
+
   if (OutputHeaders) {
-    writeToJson(llvm::outs(), Context);
+    // FIXME: Print contexts of all processing files instead of the first one.
+    writeToJson(llvm::outs(), Contexts.front());
     return 0;
   }
 
-  if (Context.getHeaderInfos().empty())
-    return 0;
-
+  std::vector<tooling::Replacements> FixerReplacements;
+  for (const auto &Context : Contexts) {
+    StringRef FilePath = Context.getFilePath();
+    format::FormatStyle InsertStyle = format::getStyle("file", FilePath, Style);
     auto Buffer = llvm::MemoryBuffer::getFile(FilePath);
     if (!Buffer) {
-    errs() << "Couldn't open file: " << FilePath << ": "
-           << Buffer.getError().message() << '\n';
+      errs() << "Couldn't open file: " + FilePath.str() + ": "
+             << Buffer.getError().message() + "\n";
       return 1;
     }
 
     auto Replacements = clang::include_fixer::createIncludeFixerReplacements(
-      /*Code=*/Buffer.get()->getBuffer(), FilePath, Context, InsertStyle);
+        Buffer.get()->getBuffer(), Context, InsertStyle);
     if (!Replacements) {
-    errs() << "Failed to create header insertion replacement: "
+      errs() << "Failed to create replacement: "
              << llvm::toString(Replacements.takeError()) << "\n";
       return 1;
     }
+    FixerReplacements.push_back(*Replacements);
+  }
 
-  if (!Quiet)
-    llvm::errs() << "Added #include " << Context.getHeaderInfos().front().Header
-                 << "\n";
-
-  // 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 (!Quiet) {
+    for (const auto &Context : Contexts) {
+      if (!Context.getHeaderInfos().empty()) {
+        llvm::errs() << "Added #include "
+                     << Context.getHeaderInfos().front().Header << " for "
+                     << Context.getFilePath() << "\n";
+      }
+    }
+  }
 
   if (STDINMode) {
-    auto ChangedCode =
-        tooling::applyAllReplacements(Code->getBuffer(), *Replacements);
+    assert(FixerReplacements.size() == 1);
+    auto ChangedCode = tooling::applyAllReplacements(Code->getBuffer(),
+                                                     FixerReplacements.front());
     if (!ChangedCode) {
       llvm::errs() << llvm::toString(ChangedCode.takeError()) << "\n";
       return 1;
     }
     llvm::outs() << *ChangedCode;
     return 0;
   }
 
+  // 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);
+
   // Write replacements to disk.
   Rewriter Rewrites(SM, LangOptions());
-  tooling::applyAllReplacements(*Replacements, Rewrites);
+  for (const auto Replacement : FixerReplacements) {
+    if (!tooling::applyAllReplacements(Replacement, Rewrites)) {
+      llvm::errs() << "Failed to apply replacements for "
+                   << Replacement.begin()->getFilePath() << '\n';
+      return 1;
+    }
+  }
   return Rewrites.overwriteChangedFiles();
 }
 
 } // namespace
 
 int main(int argc, const char **argv) {
   return includeFixerMain(argc, argv);
 }

include-fixer/tool/clang-include-fixer.py

if header not in seen:
       seen.add(header)
       unique_headers.append(header)
 
   if not unique_headers:
     print "Couldn't find a header for {0}.".format(symbol)
     return
 
   try:
-    # If there is only one suggested header, insert it directly.
-    if len(unique_headers) == 1 or maximum_suggested_headers == 1:
-      InsertHeaderToVimBuffer({"QuerySymbolInfos": query_symbol_infos,
-                               "HeaderInfos": header_infos}, text)
-      print "Added #include {0} for {1}.".format(unique_headers[0], symbol)
-      return
-
-    selected = GetUserSelection("choose a header file for {0}.".format(symbol),
-                                unique_headers, maximum_suggested_headers)
-    selected_header_infos = [
+    inserted_header_infos = header_infos
+    if len(unique_headers) > 1:
+      selected = GetUserSelection(
+          "choose a header file for {0}.".format(symbol),
+      inserted_header_infos = [
       header for header in header_infos if header["Header"] == selected]
+    include_fixer_context["HeaderInfos"] = inserted_header_infos
 
-    # Insert a selected header.
-    InsertHeaderToVimBuffer({"QuerySymbolInfos": query_symbol_infos,
-                             "HeaderInfos": selected_header_infos}, text)
+    InsertHeaderToVimBuffer(include_fixer_context, text)
     print "Added #include {0} for {1}.".format(selected, symbol)
   except Exception as error:
     print >> sys.stderr, error.message
   return
 
 
 if __name__ == '__main__':
   main()

test/include-fixer/commandline_options.cpp

 // REQUIRES: shell
 // RUN: echo "foo f;" > %t.cpp
 // RUN: clang-include-fixer -db=fixed -input='foo= "foo.h","bar.h"' -output-headers %t.cpp -- | FileCheck %s
-// RUN: cat %t.cpp | clang-include-fixer -stdin -insert-header='{QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "foo"}]}' %t.cpp | FileCheck %s -check-prefix=CHECK-CODE
-// RUN: cat %t.cpp | not clang-include-fixer -stdin -insert-header='{QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "foo"},{Header: "\"foo2.h\"", QualifiedName: "foo"}]}' %t.cpp
-// RUN: cat %t.cpp | clang-include-fixer -stdin -insert-header='{QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "a:foo"},{Header: "\"foo.h\"", QualifiedName: "b:foo"}]}' %t.cpp
+// RUN: cat %t.cpp | clang-include-fixer -stdin -insert-header='{FilePath: %t.cpp, QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "foo"}]}' %t.cpp | FileCheck %s -check-prefix=CHECK-CODE
+// RUN: cat %t.cpp | not clang-include-fixer -stdin -insert-header='{FilePath: %t.cpp, QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "foo"},{Header: "\"foo2.h\"", QualifiedName: "foo"}]}' %t.cpp
+// RUN: cat %t.cpp | clang-include-fixer -stdin -insert-header='{FilePath: %t.cpp, QuerySymbolInfos: [{RawIdentifier: foo, Range: {Offset: 0, Length: 3}}], HeaderInfos: [{Header: "\"foo.h\"", QualifiedName: "a:foo"},{Header: "\"foo.h\"", QualifiedName: "b:foo"}]}' %t.cpp
 //
 // CHECK:     "HeaderInfos": [
 // CHECK-NEXT:  {"Header": "\"foo.h\"",
 // CHECK-NEXT:   "QualifiedName": "foo"},
 // CHECK-NEXT:  {"Header": "\"bar.h\"",
 // CHECK-NEXT:   "QualifiedName": "foo"}
 // CHECK-NEXT:]
 //
 // CHECK-CODE: #include "foo.h"
 // CHECK-CODE: foo f;

test/include-fixer/multiple_fixes.cpp

+// REQUIRES: shell
+// RUN: sed -e 's#//.*$##' %s > %t.cpp
+// RUN: mkdir -p %T/include-fixer/multiple-fixes
+// RUN: echo 'foo f;' > %T/include-fixer/multiple-fixes/foo.cpp
+// RUN: echo 'bar b;' > %T/include-fixer/multiple-fixes/bar.cpp
+// RUN: clang-include-fixer -db=fixed -input='foo= "foo.h";bar= "bar.h"' %T/include-fixer/multiple-fixes/*.cpp --
+// RUN: FileCheck -input-file=%T/include-fixer/multiple-fixes/bar.cpp %s -check-prefix=CHECK-BAR
+// RUN: FileCheck -input-file=%T/include-fixer/multiple-fixes/foo.cpp %s -check-prefix=CHECK-FOO
+//
+// CHECK-FOO: #include "foo.h"
+// CHECK-FOO: foo f;
+// CHECK-BAR: #include "bar.h"
+// CHECK-BAR: bar b;

unittests/include-fixer/IncludeFixerTest.cpp

std::vector<SymbolInfo> Symbols = {
                  1, {}),
       SymbolInfo("foo2", SymbolInfo::SymbolKind::Class, "\"foo2.h\"",
                  1, {}),
   };
   auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
   SymbolIndexMgr->addSymbolIndex(
       llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols));
 
-  IncludeFixerContext FixerContext;
-  IncludeFixerActionFactory Factory(*SymbolIndexMgr, FixerContext, "llvm");
-
+  std::vector<IncludeFixerContext> FixerContexts;
+  IncludeFixerActionFactory Factory(*SymbolIndexMgr, FixerContexts, "llvm");
   std::string FakeFileName = "input.cc";
   runOnCode(&Factory, Code, FakeFileName, ExtraArgs);
-  if (FixerContext.getHeaderInfos().empty())
+  assert(FixerContexts.size() == 1);
+  if (FixerContexts.front().getHeaderInfos().empty())
     return Code;
   auto Replaces = clang::include_fixer::createIncludeFixerReplacements(
-      Code, FakeFileName, FixerContext);
+      Code, FixerContexts.front());
   EXPECT_TRUE(static_cast<bool>(Replaces))
       << llvm::toString(Replaces.takeError()) << "\n";
   if (!Replaces)
     return "";
   clang::RewriterTestContext Context;
   clang::FileID ID = Context.createInMemoryFile(FakeFileName, Code);
   clang::tooling::applyAllReplacements(*Replaces, Context.Rewrite);
   return Context.getRewrittenText(ID);