[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

Please use 'boolean here

204

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

[hokein]

bool => boolean

[hokein]

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

204

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

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";

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

(defcustom clang-include-fixer-input-format
   "yaml"
   "clang-include-fixer input format."
   :group 'clang-include-fixer
   :type 'string
   :risky t)
 
 (defcustom clang-include-fixer-init-string
   ""
-  "clang-include-fixer input format."
+  "clang-include-fixer init string."
   :group 'clang-include-fixer
   :type 'string
   :risky t)
 
+(defcustom clang-include-fixer-query-mode
+  nil
+  "clang-include-fixer query mode."
+  :group 'clang-include-fixer
+  :type 'bool
+  :risky t)
 
 (defun clang-include-fixer-call-executable (callee
                                             include-fixer-parameter-a
                                             &optional include-fixer-parameter-b
                                             &optional include-fixer-parameter-c
                                             )
   "Calls clang-include-fixer with parameters INCLUDE-FIXER-PARAMETER-[ABC].
    If the call was successful the returned result is stored in a temp buffer
(if (eq (plist-get entry :Header) missing-header)
       (delete-overlay symbol-overlay))))
 
 
 (defun clang-include-fixer ()
   "Invokes the Include Fixer to insert missing C++ headers."
   (interactive)
 
   (message (concat "Calling the include fixer. "
            "This might take some seconds. Please wait."))
 
+  (if clang-include-fixer-query-mode
+      (let (p1 p2)
+      (save-excursion
+        (skip-chars-backward "-a-zA-Z0-9_:")
+        (setq p1 (point))
+        (skip-chars-forward "-a-zA-Z0-9_:")
+        (setq p2 (point))
+        (setq query-symbol (buffer-substring-no-properties p1 p2))
+        (if (string= "" query-symbol)
+            (message "Skip querying empty symbol.")
+          (clang-include-fixer-call-executable
+            'clang-include-fixer-add-header
+            (concat "-db=" clang-include-fixer-input-format)
+            (concat "-input=" clang-include-fixer-init-string)
+            (concat "-query-symbol=" (thing-at-point 'symbol))
+          ))))
     (clang-include-fixer-call-executable
       'clang-include-fixer-add-header
       (concat "-db=" clang-include-fixer-input-format)
       (concat "-input=" clang-include-fixer-init-string)
       "-output-headers"))
+  )
 
 (provide 'clang-include-fixer)
 ;;; clang-include-fixer.el ends here

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

 # With this integration you can press the bound key and clang-include-fixer will
 # be run on the current buffer.
 #
 # It operates on the current, potentially unsaved buffer and does not create
 # or save any files. To revert a fix, just undo.
 
 import argparse
 import difflib
+import json
+import re
 import subprocess
 import vim
-import json
 
 # set g:clang_include_fixer_path to the path to clang-include-fixer if it is not
 # on the path.
 # Change this to the full path if clang-include-fixer is not on the path.
 binary = 'clang-include-fixer'
 if vim.eval('exists("g:clang_include_fixer_path")') == "1":
   binary = vim.eval('g:clang_include_fixer_path')
 
 maximum_suggested_headers = 3
 if vim.eval('exists("g:clang_include_fixer_maximum_suggested_headers")') == "1":
   maximum_suggested_headers = max(
       1,
       vim.eval('g:clang_include_fixer_maximum_suggested_headers'))
 
 increment_num = 5
 if vim.eval('exists("g:clang_include_fixer_increment_num")') == "1":
   increment_num = max(
       1,
       vim.eval('g:clang_include_fixer_increment_num'))
 
 jump_to_include = False
 if vim.eval('exists("g:clang_include_fixer_jump_to_include")') == "1":
   jump_to_include = vim.eval('g:clang_include_fixer_jump_to_include') != "0"
 
+query_mode = True
+if vim.eval('exists("g:clang_include_fixer_query_mode")') == "1":
+  query_mode = vim.eval('g:clang_include_fixer_query_mode') != "0"
+
 
 def GetUserSelection(message, headers, maximum_suggested_headers):
   eval_message = message + '\n'
   for idx, header in enumerate(headers[0:maximum_suggested_headers]):
     eval_message += "({0}). {1}\n".format(idx + 1, header)
   eval_message += "Enter (q) to quit;"
   if maximum_suggested_headers < len(headers):
     eval_message += " (m) to show {0} more candidates.".format(
for op in reversed(sequence.get_opcodes()):
       if op[0] == 'insert':
         # line_num in vim is 1-based.
         line_num = op[1] + 1
 
     if jump_to_include and line_num:
       vim.current.window.cursor = (line_num, 0)
 
 
+# The vim internal implementation (expand("cword"/"cWORD")) doesn't support
+# our use case very well, we re-implement our own one.
+def get_symbol_under_cursor():
+  line = vim.eval("line(\".\")")
+  # column number in vim is 1-based.
+  col = int(vim.eval("col(\".\")")) - 1
+  line_text = vim.eval("getline({0})".format(line))
+  if len(line_text) == 0: return ""
+  symbol_pos_begin = col
+  p = re.compile('[a-zA-Z0-9:_]')
+  while symbol_pos_begin >= 0 and p.match(line_text[symbol_pos_begin]):
+    symbol_pos_begin -= 1
+
+  symbol_pos_end = col
+  while symbol_pos_end < len(line_text) and p.match(line_text[symbol_pos_end]):
+    symbol_pos_end += 1
+  return line_text[symbol_pos_begin+1:symbol_pos_end]
+
+
 def main():
   parser = argparse.ArgumentParser(
       description='Vim integration for clang-include-fixer')
   parser.add_argument('-db', default='yaml',
                       help='clang-include-fixer input format.')
   parser.add_argument('-input', default='',
                       help='String to initialize the database.')
   args = parser.parse_args()
 
   # Get the current text.
   buf = vim.current.buffer
   text = '\n'.join(buf)
 
+  if query_mode:
+    symbol = get_symbol_under_cursor()
+    if len(symbol) == 0:
+      print "Skip querying empty symbol."
+      return
+    command = [binary, "-stdin", "-query-symbol="+get_symbol_under_cursor(),
+               "-db=" + args.db, "-input=" + args.input,
+               vim.current.buffer.name]
+  else:
     # Run command to get all headers.
     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)
   query_symbol_infos = include_fixer_context["QuerySymbolInfos"]
   if not query_symbol_infos:

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:]