[include-fixer] Support finding headers for the symbol under cursor.

[hokein]

Summary

• Add a query-symbol option to query symbol without parsing the source file.
• Update Vim & Emacs integration scripts.

[hokein]

Update the test.

[hokein]

Add editor scripts support.

[bkramer]

I can't really comment on the emacs integration with my limited knowledge of elisp. The rest looks good to me.

[hokein]

+ Jens for reviewing emacs integration part.

[massberg]

Added two comments. It took some time for me to recall Emacs Lisps ;)

include-fixer/tool/clang-include-fixer.el

48 ↗

(On Diff #69994)

Please use 'boolean here

204 ↗

(On Diff #69994)

Is this message still accurate when using the new query mode?

[hokein]

bool => boolean

[hokein]

include-fixer/tool/clang-include-fixer.el

204 ↗

(On Diff #69994)

I think it is fine to keep it here.

[massberg]

The Emacs part looks good for me now.

include-fixer/tool/clang-include-fixer.el

204 ↗

(On Diff #70545)

Then it fine for me, too.

include-fixer/find-all-symbols/SymbolInfo.h

public:
   // The default constructor is required by YAML traits in
   // LLVM_YAML_IS_DOCUMENT_LIST_VECTOR.
   SymbolInfo() : Type(SymbolKind::Unknown), LineNumber(-1) {}
 
   SymbolInfo(llvm::StringRef Name, SymbolKind Type, llvm::StringRef FilePath,
              int LineNumber, const std::vector<Context> &Contexts,
              unsigned NumOccurrences = 0);
 
+  void SetFilePath(llvm::StringRef Path) { FilePath = Path; }
+
   /// \brief Get symbol name.
   llvm::StringRef getName() const { return Name; }
 
   /// \brief Get the fully-qualified symbol name.
   std::string getQualifiedName() const;
 
   /// \brief Get symbol type.
   SymbolKind getSymbolKind() const { return Type; }

include-fixer/tool/ClangIncludeFixer.cpp

cl::values(clEnumVal(fixed, "Hard-coded mapping"),
                clEnumVal(yaml, "Yaml database created by find-all-symbols"),
                clEnumValEnd),
     cl::init(yaml), cl::cat(IncludeFixerCategory));
 
 cl::opt<std::string> Input("input",
                            cl::desc("String to initialize the database"),
                            cl::cat(IncludeFixerCategory));
 
+cl::opt<std::string>
+    QuerySymbol("query-symbol",
+                 cl::desc("Query a given symbol (e.g. \"a::b::foo\") in\n"
+                          "database directly without parsing the file."),
+                 cl::cat(IncludeFixerCategory));
+
 cl::opt<bool>
     MinimizeIncludePaths("minimize-paths",
                          cl::desc("Whether to minimize added include paths"),
                          cl::init(true), cl::cat(IncludeFixerCategory));
 
 cl::opt<bool> Quiet("q", cl::desc("Reduce terminal output"), cl::init(false),
                     cl::cat(IncludeFixerCategory));
 
void writeToJson(llvm::raw_ostream &OS, const IncludeFixerContext& Context) {
   OS << "}\n";
 }
 
 int includeFixerMain(int argc, const char **argv) {
   tooling::CommonOptionsParser options(argc, argv, IncludeFixerCategory);
   tooling::ClangTool tool(options.getCompilations(),
                           options.getSourcePathList());
 
+  llvm::StringRef SourceFilePath = options.getSourcePathList().front();
   // 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.
   std::unique_ptr<llvm::MemoryBuffer> Code;
   if (STDINMode) {
     assert(options.getSourcePathList().size() == 1 &&
            "Expect exactly one file path in STDINMode.");
     llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> CodeOrErr =
         MemoryBuffer::getSTDIN();
     if (std::error_code EC = CodeOrErr.getError()) {
       errs() << EC.message() << "\n";
       return 1;
     }
     Code = std::move(CodeOrErr.get());
     if (Code->getBufferSize() == 0)
       return 0;  // Skip empty files.
 
-    tool.mapVirtualFile(options.getSourcePathList().front(), Code->getBuffer());
+    tool.mapVirtualFile(SourceFilePath, Code->getBuffer());
   }
 
   if (!InsertHeader.empty()) {
     if (!STDINMode) {
       errs() << "Should be running in STDIN mode\n";
       return 1;
     }
 
if (!ChangedCode) {
       return 1;
     }
     llvm::outs() << *ChangedCode;
     return 0;
   }
 
   // Set up data source.
   std::unique_ptr<include_fixer::SymbolIndexManager> SymbolIndexMgr =
-      createSymbolIndexManager(options.getSourcePathList().front());
+      createSymbolIndexManager(SourceFilePath);
   if (!SymbolIndexMgr)
     return 1;
 
+  // Query symbol mode.
+  if (!QuerySymbol.empty()) {
+    auto MatchedSymbols = SymbolIndexMgr->search(QuerySymbol);
+    for (auto &Symbol : MatchedSymbols) {
+      std::string HeaderPath = Symbol.getFilePath().str();
+      Symbol.SetFilePath(((HeaderPath[0] == '"' || HeaderPath[0] == '<')
+                              ? HeaderPath
+                              : "\"" + HeaderPath + "\""));
+    }
+
+    // We leave an empty symbol range as we don't know the range of the symbol
+    // being queried in this mode. include-fixer won't add namespace qualifiers
+    // if the symbol range is empty, which also fits this case.
+    IncludeFixerContext::QuerySymbolInfo Symbol;
+    Symbol.RawIdentifier = QuerySymbol;
+    auto Context =
+        IncludeFixerContext(SourceFilePath, {Symbol}, MatchedSymbols);
+    writeToJson(llvm::outs(), Context);
+    return 0;
+  }
+
   // Now run our tool.
   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";

test/include-fixer/query_symbol.cpp

+// RUN: clang-include-fixer -db=fixed -input='foo= "foo.h","bar.h"' -query-symbol="foo" test.cpp -- | FileCheck %s
+
+// CHECK:     "FilePath": "test.cpp",
+// CHECK-NEXT:"QuerySymbolInfos": [
+// CHECK-NEXT:   {"RawIdentifier": "foo",
+// CHECK-NEXT:    "Range":{"Offset":0,"Length":0}}
+// CHECK-NEXT:],
+// CHECK-NEXT:"HeaderInfos": [
+// CHECK-NEXT:  {"Header": "\"foo.h\"",
+// CHECK-NEXT:   "QualifiedName": "foo"},
+// CHECK-NEXT:  {"Header": "\"bar.h\"",
+// CHECK-NEXT:   "QualifiedName": "foo"}
+// CHECK-NEXT:]