[include-fixer] A refactoring of IncludeFixerContext.

[hokein]

Summary

No functional changes in this patch. It is a refactoring (pull out a
structure representing the symbol being queried).

This is a preparing step for inserting missing namespace qualifiers to all
instances of an unidentified symbol.

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 {
-    Filename = 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.
clang::TypoCorrection CorrectTypo(const DeclarationNameInfo &Typo,
     query(QueryString, TypoScopeString, SymbolRange);
 
     // 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();
   }
 
-  StringRef filename() const { return Filename; }
-
   /// Get the minimal include for a given path.
   std::string minimizeInclude(StringRef Include,
                               const clang::SourceManager &SourceManager,
                               clang::HeaderSearch &HeaderSearch) {
     if (!MinimizeIncludePaths)
       return Include;
 
     // Get the FileEntry for the include.
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(QuerySymbol, SymbolScopedQualifiers,
-                               SymbolCandidates, QuerySymbolRange);
+    return IncludeFixerContext(QuerySymbolInfo, SymbolCandidates);
   }
 
 private:
   /// Query the database for a given identifier.
   bool query(StringRef Query, StringRef ScopedQualifiers, tooling::Range Range) {
     assert(!Query.empty() && "Empty query!");
 
     // Skip other identifiers once we have discovered an identfier successfully.
     if (!MatchedSymbols.empty())
       return false;
 
     DEBUG(llvm::dbgs() << "Looking up '" << Query << "' at ");
     DEBUG(getCompilerInstance()
               .getSourceManager()
               .getLocForStartOfFile(
                   getCompilerInstance().getSourceManager().getMainFileID())
               .getLocWithOffset(Range.getOffset())
               .print(llvm::dbgs(), getCompilerInstance().getSourceManager()));
     DEBUG(llvm::dbgs() << " ...");
 
-    QuerySymbol = Query.str();
-    QuerySymbolRange = Range;
-    SymbolScopedQualifiers = ScopedQualifiers;
+    QuerySymbolInfo = {Query.str(), ScopedQualifiers, Range};
 
     // Query the symbol based on C++ name Lookup rules.
     // Firstly, lookup the identifier with scoped namespace contexts;
     // If that fails, falls back to look up the identifier directly.
     //
     // For example:
     //
     // namespace a {
bool query(StringRef Query, StringRef ScopedQualifiers, tooling::Range Range) {
     DEBUG(llvm::dbgs() << "Having found " << MatchedSymbols.size()
                        << " symbols\n");
     return !MatchedSymbols.empty();
   }
 
   /// The client to use to find cross-references.
   SymbolIndexManager &SymbolIndexMgr;
 
-  /// The absolute path to the file being processed.
-  std::string Filename;
-
-  /// The symbol being queried.
-  std::string QuerySymbol;
-
-  /// The scoped qualifiers of QuerySymbol. It is represented as a sequence of
-  /// names and scope resolution operatiors ::, ending with a scope resolution
-  /// operator (e.g. a::b::). Empty if the symbol is not in a specific scope.
-  std::string SymbolScopedQualifiers;
-
-  /// The replacement range of the first discovered QuerySymbol.
-  tooling::Range QuerySymbolRange;
+  /// The symbol information.
+  IncludeFixerContext::QuerySymbolInfo QuerySymbolInfo;
 
   /// 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;
 
   /// Whether we should use the smallest possible include path.
   bool MinimizeIncludePaths = true;

include-fixer/IncludeFixerContext.h

 #include <vector>
 
 namespace clang {
 namespace include_fixer {
 
 /// \brief A context for the symbol being queried.
 class IncludeFixerContext {
 public:
-  IncludeFixerContext() = default;
-  IncludeFixerContext(llvm::StringRef Name, llvm::StringRef ScopeQualifiers,
-                      const std::vector<find_all_symbols::SymbolInfo> Symbols,
-                      tooling::Range Range);
-
   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 {
+    /// \brief The raw symbol name being queried in database. This name might
+    /// miss some namespace qualifiers, and will be replaced by a fully
+    /// qualified one.
+    std::string RawIdentifier;
+
+    /// \brief The qualifiers of the scope in which SymbolIdentifier lookup
+    /// occurs. It is represented as a sequence of names and scope resolution
+    /// operatiors ::, ending with a scope resolution operator (e.g. a::b::).
+    /// Empty if SymbolIdentifier is not in a specific scope.
+    std::string ScopedQualifiers;
+
+    /// \brief The replacement range of RawIdentifier.
+    tooling::Range Range;
+  };
+
+  IncludeFixerContext() = default;
+  IncludeFixerContext(const QuerySymbolInfo &QuerySymbol,
+                      const std::vector<find_all_symbols::SymbolInfo> Symbols);
+
   /// \brief Get symbol name.
-  llvm::StringRef getSymbolIdentifier() const { return SymbolIdentifier; }
+  llvm::StringRef getSymbolIdentifier() const {
+    return QuerySymbol.RawIdentifier;
+  }
 
   /// \brief Get replacement range of the symbol.
-  tooling::Range getSymbolRange() const { return SymbolRange; }
+  tooling::Range getSymbolRange() const { return QuerySymbol.Range; }
 
   const std::vector<HeaderInfo> &getHeaderInfos() const { return HeaderInfos; }
 
 private:
   friend struct llvm::yaml::MappingTraits<IncludeFixerContext>;
 
-  /// \brief The raw symbol name being queried in database. This name might miss
-  /// some namespace qualifiers, and will be replaced by a fully qualified one.
-  std::string SymbolIdentifier;
-
-  /// \brief The qualifiers of the scope in which SymbolIdentifier lookup
-  /// occurs. It is represented as a sequence of names and scope resolution
-  /// operatiors ::, ending with a scope resolution operator (e.g. a::b::).
-  /// Empty if SymbolIdentifier is not in a specific scope.
-  std::string SymbolScopedQualifiers;
-
   /// \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 replacement range of SymbolIdentifier.
-  tooling::Range SymbolRange;
-
   /// \brief The header information.
   std::vector<HeaderInfo> HeaderInfos;
+
+  /// \brief The information of the symbol being queried.
+  QuerySymbolInfo QuerySymbol;
 };
 
 } // 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(
-    llvm::StringRef Name, llvm::StringRef ScopeQualifiers,
-    std::vector<find_all_symbols::SymbolInfo> Symbols,
-    tooling::Range Range)
-    : SymbolIdentifier(Name), SymbolScopedQualifiers(ScopeQualifiers),
-      MatchedSymbols(std::move(Symbols)), SymbolRange(Range) {
+    const QuerySymbolInfo &QuerySymbol,
+    const std::vector<find_all_symbols::SymbolInfo> Symbols)
+    : MatchedSymbols(std::move(Symbols)), QuerySymbol(QuerySymbol) {
   for (const auto &Symbol : MatchedSymbols) {
-    HeaderInfos.push_back({Symbol.getFilePath().str(),
-                           createQualifiedNameForReplacement(
-                               SymbolIdentifier, ScopeQualifiers, Symbol)});
+    HeaderInfos.push_back(
+        {Symbol.getFilePath().str(),
+             QuerySymbol.RawIdentifier, QuerySymbol.ScopedQualifiers, Symbol)});
   }
   // Deduplicate header infos.
   HeaderInfos.erase(std::unique(HeaderInfos.begin(), HeaderInfos.end(),
                                 [](const HeaderInfo &A, const HeaderInfo &B) {
                                   return A.Header == B.Header &&
                                          A.QualifiedName == B.QualifiedName;
                                 }),
                     HeaderInfos.end());
 }
 
 } // include_fixer
 } // clang

include-fixer/tool/ClangIncludeFixer.cpp

 
 template <> struct MappingTraits<IncludeFixerContext::HeaderInfo> {
   static void mapping(IO &io, IncludeFixerContext::HeaderInfo &Info) {
     io.mapRequired("Header", Info.Header);
     io.mapRequired("QualifiedName", Info.QualifiedName);
   }
 };
 
+template <> struct MappingTraits<IncludeFixerContext::QuerySymbolInfo> {
+  static void mapping(IO &io, IncludeFixerContext::QuerySymbolInfo &Info) {
+    io.mapRequired("RawIdentifier", Info.RawIdentifier);
+    io.mapRequired("Range", Info.Range);
+  }
+};
+
 template <> struct MappingTraits<IncludeFixerContext> {
   static void mapping(IO &IO, IncludeFixerContext &Context) {
-    IO.mapRequired("SymbolIdentifier", Context.SymbolIdentifier);
+    IO.mapRequired("QuerySymbolInfo", Context.QuerySymbol);
     IO.mapRequired("HeaderInfos", Context.HeaderInfos);
-    IO.mapRequired("Range", Context.SymbolRange);
   }
 };
 } // namespace yaml
 } // namespace llvm
 
 namespace {
 cl::OptionCategory IncludeFixerCategory("Tool options");
 
STDINMode("stdin",
                        "used for editor integration."),
               cl::init(false), cl::cat(IncludeFixerCategory));
 
 cl::opt<bool> OutputHeaders(
     "output-headers",
     cl::desc("Print the symbol being queried and all its relevant headers in\n"
              "JSON format to stdout:\n"
              "  {\n"
-             "    \"SymbolIdentifier\": \"foo\",\n"
-             "    \"Range\": {\"Offset\":0, \"Length\": 3},\n"
+             "    \"QuerySymbolInfo\": {\n"
+             "       \"RawIdentifier\": \"foo\",\n"
+             "       \"Range\": {\"Offset\":0, \"Length\": 3}\n"
+             "    },\n"
              "    \"HeaderInfos\": [ {\"Header\": \"\\\"foo_a.h\\\"\",\n"
              "                      \"QualifiedName\": \"a::foo\"} ]\n"
              "  }"),
     cl::init(false), cl::cat(IncludeFixerCategory));
 
 cl::opt<std::string> InsertHeader(
     "insert-header",
     cl::desc("Insert a specific header. This should run with STDIN mode.\n"
              "The result is written to stdout. It is currently used for\n"
              "editor integration. Support YAML/JSON format:\n"
              "  -insert-header=\"{\n"
-             "     SymbolIdentifier: foo,\n"
-             "     Range: {Offset: 0, Length: 3},\n"
+             "     QuerySymbolInfo: {\n"
+             "       RawIdentifier: foo,\n"
+             "       Range: {Offset: 0, Length: 3}\n"
+             "     },\n"
              "     HeaderInfos: [ {Headers: \"\\\"foo_a.h\\\"\",\n"
              "                     QualifiedName: \"a::foo\"} ]}\""),
     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."),
case yaml: {
     break;
   }
   }
   return SymbolIndexMgr;
 }
 
 void writeToJson(llvm::raw_ostream &OS, const IncludeFixerContext& Context) {
   OS << "{\n"
-        "  \"SymbolIdentifier\": \""
+        "  \"QuerySymbolInfo\": {\n"
+        "     \"RawIdentifier\": \""
      << Context.getSymbolIdentifier() << "\",\n";
-  OS << "  \"Range\": {";
+  OS << "     \"Range\": {";
   OS << " \"Offset\":" << Context.getSymbolRange().getOffset() << ",";
-  OS << " \"Length\":" << Context.getSymbolRange().getLength() << " },\n";
+  OS << " \"Length\":" << Context.getSymbolRange().getLength() << " }\n";
+  OS << "  },\n";
   OS << "  \"HeaderInfos\": [\n";
   const auto &HeaderInfos = Context.getHeaderInfos();
   for (const auto &Info : HeaderInfos) {
     OS << "     {\"Header\": \"" << llvm::yaml::escape(Info.Header) << "\",\n"
        << "      \"QualifiedName\": \"" << Info.QualifiedName << "\"}";
     if (&Info != &HeaderInfos.back())
       OS << ",\n";
   }

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

def main():
   command = [binary, "-stdin", "-output-headers", "-db=" + args.db,
              "-input=" + args.input, vim.current.buffer.name]
   stdout, stderr = execute(command, text)
   if stderr:
     print >> sys.stderr, "Error while running clang-include-fixer: " + stderr
     return
 
   include_fixer_context = json.loads(stdout)
-  symbol = include_fixer_context["SymbolIdentifier"]
+  query_symbol_info = include_fixer_context["QuerySymbolInfo"]
+  symbol = query_symbol_info["RawIdentifier"]
   # The header_infos is already sorted by include-fixer.
   header_infos = include_fixer_context["HeaderInfos"]
   # Deduplicate headers while keeping the order, so that the same header would
   # not be suggested twice.
   unique_headers = []
   seen = set()
   for header_info in header_infos:
     header = header_info["Header"]
     if header not in seen:
       seen.add(header)
       unique_headers.append(header)
 
   if not symbol:
     print "The file is fine, no need to add a header."
     return
 
   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({"SymbolIdentifier": symbol,
-                               "Range": include_fixer_context["Range"],
+      InsertHeaderToVimBuffer({"QuerySymbolInfo": query_symbol_info,
                                "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 = [
       header for header in header_infos if header["Header"] == selected]
 
     # Insert a selected header.
-    InsertHeaderToVimBuffer({"SymbolIdentifier": symbol,
-                             "Range": include_fixer_context["Range"],
+    InsertHeaderToVimBuffer({"QuerySymbolInfo": query_symbol_info,
                              "HeaderInfos": selected_header_infos}, 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='{SymbolIdentifier: 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='{SymbolIdentifier: 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='{SymbolIdentifier: 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='{QuerySymbolInfo: {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='{QuerySymbolInfo: {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='{QuerySymbolInfo: {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;