[include-fixer] Code cleanup.

[hokein]

Summary

• Abstract the DB setting code to a function.
• Remove the unused FallbackStyle.

[bkramer]

lg

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(SymbolIndexManager &SymbolIndexMgr, StringRef StyleName,
-                  bool MinimizeIncludePaths)
-      : SymbolIndexMgr(SymbolIndexMgr), FallbackStyle(StyleName),
+  explicit Action(SymbolIndexManager &SymbolIndexMgr, bool MinimizeIncludePaths)
+      : SymbolIndexMgr(SymbolIndexMgr),
         MinimizeIncludePaths(MinimizeIncludePaths) {}
 
   std::unique_ptr<clang::ASTConsumer>
   CreateASTConsumer(clang::CompilerInstance &Compiler,
                     StringRef InFile) override {
     Filename = InFile;
     Compiler.getPreprocessor().addPPCallbacks(
         llvm::make_unique<PreprocessorHooks>(this));
private:
 
   /// The location of the beginning of the tracked file.
   clang::SourceLocation FileBegin;
 
   /// The offset of the last include in the original source file. This will
   /// be used as the insertion point for new include directives.
   unsigned FirstIncludeOffset = -1U;
 
-  /// The fallback format style for formatting after insertion if there is no
-  /// clang-format config file found.
-  std::string FallbackStyle;
-
   /// The symbol being queried.
   std::string QuerySymbol;
 
   /// The query results of an identifier. We only include the first discovered
   /// identifier to avoid getting caught in results from error recovery.
   std::vector<std::string> SymbolQueryResults;
 
   /// Whether we should use the smallest possible include path.

 }
 
 } // namespace
 
 IncludeFixerActionFactory::IncludeFixerActionFactory(
     SymbolIndexManager &SymbolIndexMgr, IncludeFixerContext &Context,
     StringRef StyleName, bool MinimizeIncludePaths)
     : SymbolIndexMgr(SymbolIndexMgr), Context(Context),
-      MinimizeIncludePaths(MinimizeIncludePaths), FallbackStyle(StyleName) {}
+      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);
Compiler.createDiagnostics(new clang::IgnoringDiagConsumer,
                              /*ShouldOwnClient=*/true);
   Compiler.createSourceManager(*Files);
 
   // We abort on fatal errors so don't let a large number of errors become
   // 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, FallbackStyle, MinimizeIncludePaths);
+  auto ScopedToolAction =
+      llvm::make_unique<Action>(SymbolIndexMgr, MinimizeIncludePaths);
   Compiler.ExecuteAction(*ScopedToolAction);
 
   Context = ScopedToolAction->getIncludeFixerContext(
       Compiler.getSourceManager(),
       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

include-fixer/tool/ClangIncludeFixer.cpp

cl::opt<std::string> InsertHeader(
     cl::init(""), cl::cat(IncludeFixerCategory));
 
 cl::opt<std::string>
     Style("style",
           cl::desc("Fallback style for reformatting after inserting new "
                    "headers if there is no clang-format config file found."),
           cl::init("llvm"), cl::cat(IncludeFixerCategory));
 
+std::unique_ptr<include_fixer::SymbolIndexManager>
+createSymbolIndexManager(StringRef FilePath) {
+  auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
+  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>> SymbolsMap;
+    SmallVector<StringRef, 4> SemicolonSplits;
+    StringRef(Input).split(SemicolonSplits, ";");
+    std::vector<find_all_symbols::SymbolInfo> Symbols;
+    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)
+        Symbols.push_back(find_all_symbols::SymbolInfo(
+            Split.first.trim(),
+            find_all_symbols::SymbolInfo::SymbolKind::Unknown, Header.trim(), 1,
+            {}));
+    }
+    SymbolIndexMgr->addSymbolIndex(
+        llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols));
+    break;
+  }
+  case yaml: {
+    llvm::ErrorOr<std::unique_ptr<include_fixer::YamlSymbolIndex>> DB(nullptr);
+    if (!Input.empty()) {
+      DB = include_fixer::YamlSymbolIndex::createFromFile(Input);
+    } else {
+      // If we don't have any input file, look in the directory of the first
+      // file and its parents.
+      SmallString<128> AbsolutePath(tooling::getAbsolutePath(FilePath));
+      StringRef Directory = llvm::sys::path::parent_path(AbsolutePath);
+      DB = include_fixer::YamlSymbolIndex::createFromDirectory(
+          Directory, "find_all_symbols_db.yaml");
+    }
+
+    if (!DB) {
+      llvm::errs() << "Couldn't find YAML db: " << DB.getError().message()
+                   << '\n';
+      return nullptr;
+    }
+
+    SymbolIndexMgr->addSymbolIndex(std::move(*DB));
+    break;
+  }
+  }
+  return SymbolIndexMgr;
+}
+
 int includeFixerMain(int argc, const char **argv) {
   tooling::CommonOptionsParser options(argc, argv, IncludeFixerCategory);
   tooling::ClangTool tool(options.getCompilations(),
                           options.getSourcePathList());
 
   // In STDINMode, we override the file content with the <stdin> input.
   // Since `tool.mapVirtualFile` takes `StringRef`, we define `Code` outside of
   // the if-block so that `Code` is not released after the if-block.
if (!InsertHeader.empty()) {
     tooling::Replacements Replaces(Replacements.begin(), Replacements.end());
     std::string ChangedCode =
         tooling::applyAllReplacements(Code->getBuffer(), Replaces);
     llvm::outs() << ChangedCode;
     return 0;
   }
 
   // Set up data source.
-  auto SymbolIndexMgr = llvm::make_unique<include_fixer::SymbolIndexManager>();
-  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>> SymbolsMap;
-    SmallVector<StringRef, 4> SemicolonSplits;
-    StringRef(Input).split(SemicolonSplits, ";");
-    std::vector<find_all_symbols::SymbolInfo> Symbols;
-    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)
-        Symbols.push_back(find_all_symbols::SymbolInfo(
-            Split.first.trim(),
-            find_all_symbols::SymbolInfo::SymbolKind::Unknown, Header.trim(), 1,
-            {}));
-    }
-    SymbolIndexMgr->addSymbolIndex(
-        llvm::make_unique<include_fixer::InMemorySymbolIndex>(Symbols));
-    break;
-  }
-  case yaml: {
-    llvm::ErrorOr<std::unique_ptr<include_fixer::YamlSymbolIndex>> DB(nullptr);
-    if (!Input.empty()) {
-      DB = include_fixer::YamlSymbolIndex::createFromFile(Input);
-    } else {
-      // If we don't have any input file, look in the directory of the first
-      // file and its parents.
-      SmallString<128> AbsolutePath(
-          tooling::getAbsolutePath(options.getSourcePathList().front()));
-      StringRef Directory = llvm::sys::path::parent_path(AbsolutePath);
-      DB = include_fixer::YamlSymbolIndex::createFromDirectory(
-          Directory, "find_all_symbols_db.yaml");
-    }
-
-    if (!DB) {
-      llvm::errs() << "Couldn't find YAML db: " << DB.getError().message()
-                   << '\n';
-      return 1;
-    }
-
-    SymbolIndexMgr->addSymbolIndex(std::move(*DB));
-    break;
-  }
-  }
+  std::unique_ptr<include_fixer::SymbolIndexManager> SymbolIndexMgr =
+      createSymbolIndexManager(options.getSourcePathList().front());
+  if (!SymbolIndexMgr)
 
   // Now run our tool.
   include_fixer::IncludeFixerContext Context;
   include_fixer::IncludeFixerActionFactory Factory(*SymbolIndexMgr, Context,
                                                    Style, MinimizeIncludePaths);
 
   if (tool.run(&Factory) != 0) {
     llvm::errs()