Added XrefsDBManager into include-fixer and made XrefsDB return SymbolInfo.

[ioeric]

Summary

Added XrefsDBManager into include-fixer and made XrefsDB return SymbolInfo.

[klimek]

include-fixer/InMemoryXrefsDB.cpp

18 ↗

(On Diff #55995)

I'd make that a const ref.

24–26 ↗

(On Diff #55995)

I assume it's intentional that SymbolInfo doesn't have a constructor; what's the reasoning behind that?

include-fixer/IncludeFixer.h

34 ↗

(On Diff #55995)

Why wouldn't we still use the interface here? (usually we want to take the least specific type we can deal with)

[ioeric]

• Addressed reviewer comment.

include-fixer/InMemoryXrefsDB.cpp

24–26 ↗

(On Diff #55995)

SymbolInfo can be of different kinds, e.g. Function, Class etc. and has optional fields. I think this was the reason we didn't have a constructor for it. @hokein, right?

include-fixer/IncludeFixer.h

34 ↗

(On Diff #55995)

XrefsDBManager now provides a different interface. XrefsDB provides std::vector<SymbolInfo> search(...), while XrefsDBManager provides std::vector<std::string> search(...), which just returns the #include paths.

[klimek]

include-fixer/IncludeFixer.h

34–35 ↗

(On Diff #56026)

That seems unexpected. Why is the XrefsDBManager in the business of doing SymbolInfo -> include path mappings?

[ioeric]

include-fixer/IncludeFixer.h

34–35 ↗

(On Diff #56026)

Since the mapping was done in XrefsDB before, I kept the way it was. Migrating SymbolInfo -> Include path mappings into IncludeFixer will be the next step, and I'll need to discuss with Ben about where exactly we want to place it.

[hokein]

include-fixer/InMemoryXrefsDB.cpp

24–26 ↗

(On Diff #56026)

Yeah, the intention is that it's not easy to construct a completed instance at one time since it has many fields.

[klimek]

lg

include-fixer/InMemoryXrefsDB.cpp

24–26 ↗

(On Diff #56026)

Overall, I think creating an instance and then setting members should only be done from places very strongly coupled to the class.
Generally, I think in these cases creating static members of the class that construct the objects from the various data sources you have (like in this case from a string, and a vector<string>) are preferable; not necessary to address this in this CL, but please add a FIXME.

(also, specifically regarding the comment that it's not easy to construct a completed instance: that is a large hint that it should be encoded somewhere close to the class)

include-fixer/IncludeFixer.h

34–35 ↗

(On Diff #56026)

Please add a FIXME that this is going to change.

unittests/include-fixer/IncludeFixerTest.cpp

86 ↗

(On Diff #56026)

identifiers

[ioeric]

• Added FIXMEs and fixed a nit.

clang-tools-extra/trunk/include-fixer/CMakeLists.txt

 set(LLVM_LINK_COMPONENTS
   support
   )
 
 add_clang_library(clangIncludeFixer
   IncludeFixer.cpp
   InMemoryXrefsDB.cpp
+  XrefsDBManager.cpp
   YamlXrefsDB.cpp
 
   LINK_LIBS
   clangAST
   clangBasic
   clangFrontend
   clangLex
   clangParse
   clangSema
   clangTooling
   clangToolingCore
   findAllSymbols
   )
 
 add_subdirectory(tool)
 add_subdirectory(find-all-symbols)

clang-tools-extra/trunk/include-fixer/InMemoryXrefsDB.h

 #include <vector>
 
 namespace clang {
 namespace include_fixer {
 
 /// Xref database with fixed content.
 class InMemoryXrefsDB : public XrefsDB {
 public:
-  InMemoryXrefsDB(std::map<std::string, std::vector<std::string>> LookupTable)
-      : LookupTable(std::move(LookupTable)) {}
+  InMemoryXrefsDB(
+      const std::map<std::string, std::vector<std::string>> &LookupTable);
 
-  std::vector<std::string> search(llvm::StringRef Identifier) override;
+  std::vector<clang::find_all_symbols::SymbolInfo>
+  search(llvm::StringRef Identifier) override;
 
 private:
-  std::map<std::string, std::vector<std::string>> LookupTable;
+  std::map<std::string, std::vector<clang::find_all_symbols::SymbolInfo>>
+      LookupTable;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INMEMORYXREFSDB_H

clang-tools-extra/trunk/include-fixer/InMemoryXrefsDB.cpp

 //===-- InMemoryXrefsDB.cpp -----------------------------------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InMemoryXrefsDB.h"
 
+using clang::find_all_symbols::SymbolInfo;
+
 namespace clang {
 namespace include_fixer {
 
-std::vector<std::string> InMemoryXrefsDB::search(llvm::StringRef Identifier) {
+InMemoryXrefsDB::InMemoryXrefsDB(
+    const std::map<std::string, std::vector<std::string>> &LookupTable) {
+  for (const auto &Entry : LookupTable) {
+    llvm::StringRef Identifier(Entry.first);
+    llvm::SmallVector<llvm::StringRef, 8> Names;
+    Identifier.split(Names, "::");
+    for (const auto &Header : Entry.second) {
+      // FIXME: create a complete instance with static member function when it
+      // is implemented.
+      SymbolInfo Info;
+      Info.Name = Names.back();
+      Info.FilePath = Header;
+      for (auto IdentiferContext = Names.rbegin() + 1;
+           IdentiferContext != Names.rend(); ++IdentiferContext) {
+        Info.Contexts.push_back(
+            {SymbolInfo::ContextType::Namespace, *IdentiferContext});
+      }
+      this->LookupTable[Info.Name].push_back(Info);
+    }
+  }
+}
+
+std::vector<SymbolInfo> InMemoryXrefsDB::search(llvm::StringRef Identifier) {
   auto I = LookupTable.find(Identifier);
   if (I != LookupTable.end())
     return I->second;
   return {};
 }
 
 } // namespace include_fixer
 } // namespace clang

clang-tools-extra/trunk/include-fixer/IncludeFixer.h

 //===-- IncludeFixer.h - Include inserter -----------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXER_H
 #define LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXER_H
 
-#include "XrefsDB.h"
+#include "XrefsDBManager.h"
 #include "clang/Tooling/Core/Replacement.h"
 #include "clang/Tooling/Tooling.h"
 #include <memory>
 #include <vector>
 
 namespace clang {
 
 class CompilerInvocation;
 class DiagnosticConsumer;
 class FileManager;
 class PCHContainerOperations;
 
 namespace include_fixer {
 
 class IncludeFixerActionFactory : public clang::tooling::ToolAction {
 public:
-  /// \param Xrefs A source for matching symbols to header files.
+  /// \param XrefsDBMgr A source for matching symbols to header files.
   /// \param Replacements Storage for the output of the fixer.
   /// \param MinimizeIncludePaths whether inserted include paths are optimized.
   IncludeFixerActionFactory(
-      XrefsDB &Xrefs, std::vector<clang::tooling::Replacement> &Replacements,
+      XrefsDBManager &XrefsDBMgr,
+      std::vector<clang::tooling::Replacement> &Replacements,
       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.
-  XrefsDB &Xrefs;
+  XrefsDBManager &XrefsDBMgr;
 
   /// Replacements are written here.
   std::vector<clang::tooling::Replacement> &Replacements;
 
   /// Whether inserted include paths should be optimized.
   bool MinimizeIncludePaths;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_INCLUDEFIXER_H

clang-tools-extra/trunk/include-fixer/IncludeFixer.cpp

private:
   /// The current FileEntry.
   const clang::FileEntry *TrackedFile;
 };
 
 /// Manages the parse, gathers include suggestions.
 class Action : public clang::ASTFrontendAction,
                public clang::ExternalSemaSource {
 public:
-  explicit Action(XrefsDB &Xrefs, bool MinimizeIncludePaths)
-      : Xrefs(Xrefs), MinimizeIncludePaths(MinimizeIncludePaths) {}
+  explicit Action(XrefsDBManager &XrefsDBMgr, bool MinimizeIncludePaths)
+      : XrefsDBMgr(XrefsDBMgr), MinimizeIncludePaths(MinimizeIncludePaths) {}
 
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &Compiler,
                     StringRef InFile) override {
     Filename = InFile;
     Compiler.getPreprocessor().addPPCallbacks(
         llvm::make_unique<PreprocessorHooks>(this));
     return llvm::make_unique<clang::ASTConsumer>();
clang::TypoCorrection query(StringRef Query) {
 
     // Save database lookups by not looking up identifiers multiple times.
     if (!SeenQueries.insert(Query).second)
       return clang::TypoCorrection();
 
     DEBUG(llvm::dbgs() << "Looking up " << Query << " ... ");
 
     std::string error_text;
-    auto SearchReply = Xrefs.search(Query);
+    auto SearchReply = XrefsDBMgr.search(Query);
     DEBUG(llvm::dbgs() << SearchReply.size() << " replies\n");
     if (SearchReply.empty())
       return clang::TypoCorrection();
 
     // Add those files to the set of includes to try out.
     // FIXME: Rank the results and pick the best one instead of the first one.
     TryInclude(Query, SearchReply[0]);
 
     // FIXME: We should just return the name we got as input here and prevent
     // clang from trying to correct the typo by itself. That may change the
     // identifier to something that's not wanted by the user.
     return clang::TypoCorrection();
   }
 
   /// The client to use to find cross-references.
-  XrefsDB &Xrefs;
+  XrefsDBManager &XrefsDBMgr;
 
   // Remeber things we looked up to avoid querying things twice.
   llvm::StringSet<> SeenQueries;
 
   /// The absolute path to the file being processed.
   std::string Filename;
 
   /// The location of the beginning of the tracked file.
if (!IncludeFile || TrackedFile != SourceFile)
     return;
   EnclosingPass->NextInclude(SourceManager, IncludeFile->getName(), FileName,
                              IsAngled, HashLocation, FileNameRange.getEnd());
 }
 
 } // namespace
 
 IncludeFixerActionFactory::IncludeFixerActionFactory(
-    XrefsDB &Xrefs, std::vector<clang::tooling::Replacement> &Replacements,
+    XrefsDBManager &XrefsDBMgr,
+    std::vector<clang::tooling::Replacement> &Replacements,
     bool MinimizeIncludePaths)
-    : Xrefs(Xrefs), Replacements(Replacements),
+    : XrefsDBMgr(XrefsDBMgr), Replacements(Replacements),
       MinimizeIncludePaths(MinimizeIncludePaths) {}
 
 IncludeFixerActionFactory::~IncludeFixerActionFactory() = default;
 
 bool IncludeFixerActionFactory::runInvocation(
     clang::CompilerInvocation *Invocation, clang::FileManager *Files,
     std::shared_ptr<clang::PCHContainerOperations> PCHContainerOps,
     clang::DiagnosticConsumer *Diagnostics) {
   assert(Invocation->getFrontendOpts().Inputs.size() == 1);
 
   // Set up Clang.
   clang::CompilerInstance Compiler(PCHContainerOps);
   Compiler.setInvocation(Invocation);
   Compiler.setFileManager(Files);
 
   // Create the compiler's actual diagnostics engine. We want to drop all
   // diagnostics here.
   Compiler.createDiagnostics(new clang::IgnoringDiagConsumer,
                              /*ShouldOwnClient=*/true);
   Compiler.createSourceManager(*Files);
 
   // Run the parser, gather missing includes.
   auto ScopedToolAction =
-      llvm::make_unique<Action>(Xrefs, MinimizeIncludePaths);
+      llvm::make_unique<Action>(XrefsDBMgr, MinimizeIncludePaths);
   Compiler.ExecuteAction(*ScopedToolAction);
 
   // Generate replacements.
   ScopedToolAction->Rewrite(Compiler.getSourceManager(),
                             Compiler.getPreprocessor().getHeaderSearchInfo(),
                             Replacements);
 
   // Technically this should only return true if we're sure that we have a
   // parseable file. We don't know that though.
   return true;
 }
 
 } // namespace include_fixer
 } // namespace clang

clang-tools-extra/trunk/include-fixer/XrefsDB.h

 //===-- XrefsDB.h - Interface for symbol-header matching --------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_XREFSDB_H
 #define LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_XREFSDB_H
 
+#include "find-all-symbols/SymbolInfo.h"
 #include "llvm/ADT/StringRef.h"
 #include <vector>
 
 namespace clang {
 namespace include_fixer {
 
-/// This class provides an interface for finding the header files corresponding
-/// to an indentifier in the source code.
+/// This class provides an interface for finding all `SymbolInfo`s corresponding
+/// to a symbol name from a symbol database.
 class XrefsDB {
 public:
   virtual ~XrefsDB() = default;
 
-  /// Search for header files to be included for an identifier.
-  /// \param Identifier The identifier being searched for. May or may not be
-  ///                   fully qualified.
-  /// \returns A list of inclusion candidates, in a format ready for being
-  ///          pasted after an #include token.
+  /// Search for all `SymbolInfo`s corresponding to an identifier.
+  /// \param Identifier The unqualified identifier being searched for.
+  /// \returns A list of `SymbolInfo` candidates.
   // FIXME: Expose the type name so we can also insert using declarations (or
   // fix the usage)
-  virtual std::vector<std::string> search(llvm::StringRef Identifier) = 0;
+  virtual std::vector<clang::find_all_symbols::SymbolInfo>
+  search(llvm::StringRef Identifier) = 0;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_XREFSDB_H

clang-tools-extra/trunk/include-fixer/XrefsDBManager.h

+//===-- XrefsDBManager.h - Managing multiple XrefsDBs -----------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_XREFSDBMANAGER_H
+#define LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_XREFSDBMANAGER_H
+
+#include "XrefsDB.h"
+#include "llvm/ADT/StringRef.h"
+
+namespace clang {
+namespace include_fixer {
+
+/// This class provides an interface for finding the header files corresponding
+/// to an indentifier in the source code from multiple symbol databases.
+class XrefsDBManager {
+public:
+  void addXrefsDB(std::unique_ptr<XrefsDB> DB) {
+    XrefsDBs.push_back(std::move(DB));
+  }
+
+  /// Search for header files to be included for an identifier.
+  /// \param Identifier The identifier being searched for. May or may not be
+  ///                   fully qualified.
+  /// \returns A list of inclusion candidates, in a format ready for being
+  ///          pasted after an #include token.
+  // FIXME: Expose the type name so we can also insert using declarations (or
+  // fix the usage)
+  // FIXME: Move mapping from SymbolInfo to headers out of
+  // XrefsDBManager::search and return SymbolInfos instead of header paths.
+  std::vector<std::string> search(llvm::StringRef Identifier) const;
+
+private:
+  std::vector<std::unique_ptr<XrefsDB>> XrefsDBs;
+};
+
+} // namespace include_fixer
+} // namespace clang
+
+#endif

clang-tools-extra/trunk/include-fixer/XrefsDBManager.cpp

+//===-- XrefsDBManager.cpp - Managing multiple XrefsDBs ---------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "XrefsDBManager.h"
+#include "find-all-symbols/SymbolInfo.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/Debug.h"
+
+#define DEBUG_TYPE "include-fixer"
+
+namespace clang {
+namespace include_fixer {
+
+std::vector<std::string>
+XrefsDBManager::search(llvm::StringRef Identifier) const {
+  // The identifier may be fully qualified, so split it and get all the context
+  // names.
+  llvm::SmallVector<llvm::StringRef, 8> Names;
+  Identifier.split(Names, "::");
+
+  std::vector<clang::find_all_symbols::SymbolInfo> Symbols;
+  for (const auto &DB : XrefsDBs) {
+    auto Res = DB->search(Names.back().str());
+    Symbols.insert(Symbols.end(), Res.begin(), Res.end());
+  }
+
+  DEBUG(llvm::dbgs() << "Searching " << Names.back() << "... got "
+                     << Symbols.size() << " results...\n");
+
+  std::vector<std::string> Results;
+  for (const auto &Symbol : Symbols) {
+    // Match the identifier name without qualifier.
+    if (Symbol.Name == Names.back()) {
+      bool IsMatched = true;
+      auto SymbolContext = Symbol.Contexts.begin();
+      // Match the remaining context names.
+      for (auto IdentiferContext = Names.rbegin() + 1;
+           IdentiferContext != Names.rend() &&
+           SymbolContext != Symbol.Contexts.end();
+           ++IdentiferContext, ++SymbolContext) {
+        if (SymbolContext->second != *IdentiferContext) {
+          IsMatched = false;
+          break;
+        }
+      }
+
+      if (IsMatched) {
+        // FIXME: file path should never be in the form of <...> or "...", but
+        // the unit test with fixed database use <...> file path, which might
+        // need to be changed.
+        // FIXME: if the file path is a system header name, we want to use angle
+        // brackets.
+        Results.push_back(
+            (Symbol.FilePath[0] == '"' || Symbol.FilePath[0] == '<')
+                ? Symbol.FilePath
+                : "\"" + Symbol.FilePath + "\"");
+      }
+    }
+  }
+  return Results;
+}
+
+} // namespace include_fixer
+} // namespace clang

clang-tools-extra/trunk/include-fixer/YamlXrefsDB.h

 namespace clang {
 namespace include_fixer {
 
 /// Yaml format database.
 class YamlXrefsDB : public XrefsDB {
 public:
   YamlXrefsDB(llvm::StringRef FilePath);
 
-  std::vector<std::string> search(llvm::StringRef Identifier) override;
+  std::vector<clang::find_all_symbols::SymbolInfo>
+  search(llvm::StringRef Identifier) override;
 
 private:
   std::vector<clang::find_all_symbols::SymbolInfo> Symbols;
 };
 
 } // namespace include_fixer
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_INCLUDE_FIXER_YAMLXREFSDB_H

clang-tools-extra/trunk/include-fixer/YamlXrefsDB.cpp

 #include "YamlXrefsDB.h"
 
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include <string>
 #include <vector>
 
+using clang::find_all_symbols::SymbolInfo;
+
 namespace clang {
 namespace include_fixer {
 
 YamlXrefsDB::YamlXrefsDB(llvm::StringRef FilePath) {
   int ReadFD = 0;
   if (llvm::sys::fs::openFileForRead(FilePath, ReadFD))
     return;
   auto Buffer = llvm::MemoryBuffer::getOpenFile(ReadFD, FilePath, -1);
   if (!Buffer)
     return;
   Symbols = clang::find_all_symbols::ReadSymbolInfosFromYAML(
       Buffer.get()->getBuffer());
 }
 
-std::vector<std::string> YamlXrefsDB::search(llvm::StringRef Identifier) {
-  llvm::SmallVector<llvm::StringRef, 16> Names;
-  std::vector<std::string> Results;
-
-  // The identifier may be fully qualified, so split it and get all the context
-  // names.
-  Identifier.split(Names, "::");
+std::vector<SymbolInfo> YamlXrefsDB::search(llvm::StringRef Identifier) {
+  std::vector<SymbolInfo> Results;
   for (const auto &Symbol : Symbols) {
-    // Match the identifier name without qualifier.
-    if (Symbol.Name == Names.back()) {
-      bool IsMatched = true;
-      auto SymbolContext = Symbol.Contexts.begin();
-      // Match the remaining context names.
-      for (auto IdentiferContext = Names.rbegin() + 1;
-           IdentiferContext != Names.rend() &&
-           SymbolContext != Symbol.Contexts.end();
-           ++IdentiferContext, ++SymbolContext) {
-        if (SymbolContext->second != *IdentiferContext) {
-          IsMatched = false;
-          break;
-        }
-      }
-
-      if (IsMatched) {
-        Results.push_back("\"" + Symbol.FilePath + "\"");
-      }
-    }
+    if (Symbol.Name == Identifier)
+      Results.push_back(Symbol);
   }
   return Results;
 }
 
 } // namespace include_fixer
 } // namespace clang

clang-tools-extra/trunk/include-fixer/find-all-symbols/SymbolInfo.h

 #include <set>
 #include <string>
 #include <vector>
 
 namespace clang {
 namespace find_all_symbols {
 
 /// \brief Contains all information for a Symbol.
+// FIXME: add static members for creating complete instances.
 struct SymbolInfo {
   enum SymbolKind {
     Function,
     Class,
     Variable,
     TypedefName,
   };
 

clang-tools-extra/trunk/include-fixer/tool/ClangIncludeFixer.cpp

 //===-- ClangIncludeFixer.cpp - Standalone include fixer ------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InMemoryXrefsDB.h"
 #include "IncludeFixer.h"
+#include "XrefsDBManager.h"
 #include "YamlXrefsDB.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
 #include "clang/Rewrite/Core/Rewriter.h"
 #include "clang/Tooling/CommonOptionsParser.h"
 #include "clang/Tooling/Tooling.h"
 #include "llvm/Support/CommandLine.h"
 
 using namespace clang;
MinimizeIncludePaths("minimize-paths",
                          cl::desc("Whether to minimize added include paths"),
                          cl::init(true), cl::cat(IncludeFixerCategory));
 
 int includeFixerMain(int argc, const char **argv) {
   tooling::CommonOptionsParser options(argc, argv, IncludeFixerCategory);
   tooling::ClangTool tool(options.getCompilations(),
                           options.getSourcePathList());
 
-  // Set up the data source.
-  std::unique_ptr<include_fixer::XrefsDB> XrefsDB;
+  // Set up data source.
+  auto XrefsDBMgr = llvm::make_unique<include_fixer::XrefsDBManager>();
   switch (DatabaseFormat) {
   case fixed: {
     // Parse input and fill the database with it.
     // <symbol>=<header><, header...>
     // Multiple symbols can be given, separated by semicolons.
     std::map<std::string, std::vector<std::string>> XrefsMap;
     SmallVector<StringRef, 4> SemicolonSplits;
     StringRef(Input).split(SemicolonSplits, ";");
     for (StringRef Pair : SemicolonSplits) {
       auto Split = Pair.split('=');
       std::vector<std::string> Headers;
       SmallVector<StringRef, 4> CommaSplits;
       Split.second.split(CommaSplits, ",");
       for (StringRef Header : CommaSplits)
         Headers.push_back(Header.trim());
       XrefsMap[Split.first.trim()] = std::move(Headers);
     }
-    XrefsDB =
-        llvm::make_unique<include_fixer::InMemoryXrefsDB>(std::move(XrefsMap));
+    XrefsDBMgr->addXrefsDB(
+        llvm::make_unique<include_fixer::InMemoryXrefsDB>(std::move(XrefsMap)));
     break;
   }
   case yaml: {
-    XrefsDB = llvm::make_unique<include_fixer::YamlXrefsDB>(Input);
+    XrefsDBMgr->addXrefsDB(
+        llvm::make_unique<include_fixer::YamlXrefsDB>(Input));
     break;
   }
   }
 
   // Now run our tool.
   std::vector<tooling::Replacement> Replacements;
-  include_fixer::IncludeFixerActionFactory Factory(*XrefsDB, Replacements,
+  include_fixer::IncludeFixerActionFactory Factory(*XrefsDBMgr, Replacements,
                                                    MinimizeIncludePaths);
 
   tool.run(&Factory); // Always succeeds.
 
   // 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);

clang-tools-extra/trunk/unittests/include-fixer/IncludeFixerTest.cpp

 //===-- IncludeFixerTest.cpp - Include fixer unit tests -------------------===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "InMemoryXrefsDB.h"
 #include "IncludeFixer.h"
+#include "XrefsDBManager.h"
 #include "unittests/Tooling/RewriterTestContext.h"
 #include "clang/Tooling/Tooling.h"
 #include "gtest/gtest.h"
 using namespace clang;
 
 namespace clang {
 namespace include_fixer {
 namespace {

 static std::string runIncludeFixer(
     StringRef Code,
     const std::vector<std::string> &ExtraArgs = std::vector<std::string>()) {
   std::map<std::string, std::vector<std::string>> XrefsMap = {
       {"std::string", {"<string>"}},
       {"std::string::size_type", {"<string>"}},
       {"a::b::foo", {"dir/otherdir/qux.h"}},
   };
-  auto XrefsDB =
-      llvm::make_unique<include_fixer::InMemoryXrefsDB>(std::move(XrefsMap));
+  auto XrefsDBMgr = llvm::make_unique<include_fixer::XrefsDBManager>();
+  XrefsDBMgr->addXrefsDB(
+      llvm::make_unique<include_fixer::InMemoryXrefsDB>(std::move(XrefsMap)));
+
   std::vector<clang::tooling::Replacement> Replacements;
-  IncludeFixerActionFactory Factory(*XrefsDB, Replacements);
+  IncludeFixerActionFactory Factory(*XrefsDBMgr, Replacements);
   runOnCode(&Factory, Code, "input.cc", ExtraArgs);
   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>\nstd::string foo;\n",
             runIncludeFixer("std::string foo;\n"));
 
   EXPECT_EQ(
       "// comment\n#include <string>\n#include \"foo.h\"\nstd::string foo;\n"
       "#include \"dir/bar.h\"\n",
       runIncludeFixer("// comment\n#include \"foo.h\"\nstd::string foo;\n"
                       "#include \"dir/bar.h\"\n"));
 
   EXPECT_EQ("#include <string>\n#include \"foo.h\"\nstd::string foo;\n",
             runIncludeFixer("#include \"foo.h\"\nstd::string foo;\n"));
 
   EXPECT_EQ(
       "#include <string>\n#include \"foo.h\"\nstd::string::size_type foo;\n",
       runIncludeFixer("#include \"foo.h\"\nstd::string::size_type foo;\n"));
 
-  // The fixed xrefs db doesn't know how to handle string without std::.
-  EXPECT_EQ("string foo;\n", runIncludeFixer("string foo;\n"));
+  // string without "std::" can also be fixed since fixed db results go through
+  // XrefsDBManager, and XrefsDBManager matches unqualified identifiers too.
+  EXPECT_EQ("#include <string>\nstring foo;\n",
+            runIncludeFixer("string foo;\n"));
 }
 
 TEST(IncludeFixer, IncompleteType) {
   EXPECT_EQ(
       "#include <string>\n#include \"foo.h\"\n"
       "namespace std {\nclass string;\n}\nstring foo;\n",
       runIncludeFixer("#include \"foo.h\"\n"
                       "namespace std {\nclass string;\n}\nstring foo;\n"));