| 1 |
# This file is a minimal clang-include-fixer vim-integration. To install: |
| 2 |
# - Change 'binary' if clang-include-fixer is not on the path (see below). |
| 3 |
# - Add to your .vimrc: |
| 4 |
# |
| 5 |
# noremap <leader>cf :pyf path/to/llvm/source/tools/clang/tools/extra/clang-include-fixer/tool/clang-include-fixer.py<cr> |
| 6 |
# |
| 7 |
# This enables clang-include-fixer for NORMAL and VISUAL mode. Change |
| 8 |
# "<leader>cf" to another binding if you need clang-include-fixer on a |
| 9 |
# different key. |
| 10 |
# |
| 11 |
# To set up clang-include-fixer, see |
| 12 |
# http://clang.llvm.org/extra/clang-include-fixer.html |
| 13 |
# |
| 14 |
# With this integration you can press the bound key and clang-include-fixer will |
| 15 |
# be run on the current buffer. |
| 16 |
# |
| 17 |
# It operates on the current, potentially unsaved buffer and does not create |
| 18 |
# or save any files. To revert a fix, just undo. |
| 19 |
|
| 20 |
from __future__ import print_function |
| 21 |
import argparse |
| 22 |
import difflib |
| 23 |
import json |
| 24 |
import re |
| 25 |
import subprocess |
| 26 |
import vim |
| 27 |
|
| 28 |
# set g:clang_include_fixer_path to the path to clang-include-fixer if it is not |
| 29 |
# on the path. |
| 30 |
# Change this to the full path if clang-include-fixer is not on the path. |
| 31 |
binary = "clang-include-fixer" |
| 32 |
if vim.eval('exists("g:clang_include_fixer_path")') == "1": |
| 33 |
binary = vim.eval("g:clang_include_fixer_path") |
| 34 |
|
| 35 |
maximum_suggested_headers = 3 |
| 36 |
if vim.eval('exists("g:clang_include_fixer_maximum_suggested_headers")') == "1": |
| 37 |
maximum_suggested_headers = max( |
| 38 |
1, vim.eval("g:clang_include_fixer_maximum_suggested_headers") |
| 39 |
) |
| 40 |
|
| 41 |
increment_num = 5 |
| 42 |
if vim.eval('exists("g:clang_include_fixer_increment_num")') == "1": |
| 43 |
increment_num = max(1, vim.eval("g:clang_include_fixer_increment_num")) |
| 44 |
|
| 45 |
jump_to_include = False |
| 46 |
if vim.eval('exists("g:clang_include_fixer_jump_to_include")') == "1": |
| 47 |
jump_to_include = vim.eval("g:clang_include_fixer_jump_to_include") != "0" |
| 48 |
|
| 49 |
query_mode = False |
| 50 |
if vim.eval('exists("g:clang_include_fixer_query_mode")') == "1": |
| 51 |
query_mode = vim.eval("g:clang_include_fixer_query_mode") != "0" |
| 52 |
|
| 53 |
|
| 54 |
def GetUserSelection(message, headers, maximum_suggested_headers): |
| 55 |
eval_message = message + "\n" |
| 56 |
for idx, header in enumerate(headers[0:maximum_suggested_headers]): |
| 57 |
eval_message += "({0}). {1}\n".format(idx + 1, header) |
| 58 |
eval_message += "Enter (q) to quit;" |
| 59 |
if maximum_suggested_headers < len(headers): |
| 60 |
eval_message += " (m) to show {0} more candidates.".format( |
| 61 |
min(increment_num, len(headers) - maximum_suggested_headers) |
| 62 |
) |
| 63 |
|
| 64 |
eval_message += "\nSelect (default 1): " |
| 65 |
res = vim.eval("input('{0}')".format(eval_message)) |
| 66 |
if res == "": |
| 67 |
# choose the top ranked header by default |
| 68 |
idx = 1 |
| 69 |
elif res == "q": |
| 70 |
raise Exception(" Insertion cancelled...") |
| 71 |
elif res == "m": |
| 72 |
return GetUserSelection( |
| 73 |
message, headers, maximum_suggested_headers + increment_num |
| 74 |
) |
| 75 |
else: |
| 76 |
try: |
| 77 |
idx = int(res) |
| 78 |
if idx <= 0 or idx > len(headers): |
| 79 |
raise Exception() |
| 80 |
except Exception: |
| 81 |
# Show a new prompt on invalid option instead of aborting so that users |
| 82 |
# don't need to wait for another clang-include-fixer run. |
| 83 |
print("Invalid option: {}".format(res), file=sys.stderr) |
| 84 |
return GetUserSelection(message, headers, maximum_suggested_headers) |
| 85 |
return headers[idx - 1] |
| 86 |
|
| 87 |
|
| 88 |
def execute(command, text): |
| 89 |
# Avoid flashing a cmd prompt on Windows. |
| 90 |
startupinfo = None |
| 91 |
if sys.platform.startswith("win32"): |
| 92 |
startupinfo = subprocess.STARTUPINFO() |
| 93 |
startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW |
| 94 |
startupinfo.wShowWindow = subprocess.SW_HIDE |
| 95 |
|
| 96 |
p = subprocess.Popen( |
| 97 |
command, |
| 98 |
stdout=subprocess.PIPE, |
| 99 |
stderr=subprocess.PIPE, |
| 100 |
stdin=subprocess.PIPE, |
| 101 |
startupinfo=startupinfo, |
| 102 |
) |
| 103 |
return p.communicate(input=text.encode("utf-8")) |
| 104 |
|
| 105 |
|
| 106 |
def InsertHeaderToVimBuffer(header, text): |
| 107 |
command = [ |
| 108 |
binary, |
| 109 |
"-stdin", |
| 110 |
"-insert-header=" + json.dumps(header), |
| 111 |
vim.current.buffer.name, |
| 112 |
] |
| 113 |
stdout, stderr = execute(command, text) |
| 114 |
if stderr: |
| 115 |
raise Exception(stderr) |
| 116 |
if stdout: |
| 117 |
lines = stdout.splitlines() |
| 118 |
sequence = difflib.SequenceMatcher(None, vim.current.buffer, lines) |
| 119 |
line_num = None |
| 120 |
for op in reversed(sequence.get_opcodes()): |
| 121 |
if op[0] != "equal": |
| 122 |
vim.current.buffer[op[1] : op[2]] = lines[op[3] : op[4]] |
| 123 |
if op[0] == "insert": |
| 124 |
# line_num in vim is 1-based. |
| 125 |
line_num = op[1] + 1 |
| 126 |
|
| 127 |
if jump_to_include and line_num: |
| 128 |
vim.current.window.cursor = (line_num, 0) |
| 129 |
|
| 130 |
|
| 131 |
# The vim internal implementation (expand("cword"/"cWORD")) doesn't support |
| 132 |
# our use case very well, we re-implement our own one. |
| 133 |
def get_symbol_under_cursor(): |
| 134 |
line = vim.eval('line(".")') |
| 135 |
# column number in vim is 1-based. |
| 136 |
col = int(vim.eval('col(".")')) - 1 |
| 137 |
line_text = vim.eval("getline({0})".format(line)) |
| 138 |
if len(line_text) == 0: |
| 139 |
return "" |
| 140 |
symbol_pos_begin = col |
| 141 |
p = re.compile("[a-zA-Z0-9:_]") |
| 142 |
while symbol_pos_begin >= 0 and p.match(line_text[symbol_pos_begin]): |
| 143 |
symbol_pos_begin -= 1 |
| 144 |
|
| 145 |
symbol_pos_end = col |
| 146 |
while symbol_pos_end < len(line_text) and p.match(line_text[symbol_pos_end]): |
| 147 |
symbol_pos_end += 1 |
| 148 |
return line_text[symbol_pos_begin + 1 : symbol_pos_end] |
| 149 |
|
| 150 |
|
| 151 |
def main(): |
| 152 |
parser = argparse.ArgumentParser( |
| 153 |
description="Vim integration for clang-include-fixer" |
| 154 |
) |
| 155 |
parser.add_argument("-db", default="yaml", help="clang-include-fixer input format.") |
| 156 |
parser.add_argument("-input", default="", help="String to initialize the database.") |
| 157 |
# Don't throw exception when parsing unknown arguments to make the script |
| 158 |
# work in neovim. |
| 159 |
# Neovim (at least v0.2.1) somehow mangles the sys.argv in a weird way: it |
| 160 |
# will pass additional arguments (e.g. "-c script_host.py") to sys.argv, |
| 161 |
# which makes the script fail. |
| 162 |
args, _ = parser.parse_known_args() |
| 163 |
|
| 164 |
# Get the current text. |
| 165 |
buf = vim.current.buffer |
| 166 |
text = "\n".join(buf) |
| 167 |
|
| 168 |
if query_mode: |
| 169 |
symbol = get_symbol_under_cursor() |
| 170 |
if len(symbol) == 0: |
| 171 |
print("Skip querying empty symbol.") |
| 172 |
return |
| 173 |
command = [ |
| 174 |
binary, |
| 175 |
"-stdin", |
| 176 |
"-query-symbol=" + get_symbol_under_cursor(), |
| 177 |
"-db=" + args.db, |
| 178 |
"-input=" + args.input, |
| 179 |
vim.current.buffer.name, |
| 180 |
] |
| 181 |
else: |
| 182 |
# Run command to get all headers. |
| 183 |
command = [ |
| 184 |
binary, |
| 185 |
"-stdin", |
| 186 |
"-output-headers", |
| 187 |
"-db=" + args.db, |
| 188 |
"-input=" + args.input, |
| 189 |
vim.current.buffer.name, |
| 190 |
] |
| 191 |
stdout, stderr = execute(command, text) |
| 192 |
if stderr: |
| 193 |
print( |
| 194 |
"Error while running clang-include-fixer: {}".format(stderr), |
| 195 |
file=sys.stderr, |
| 196 |
) |
| 197 |
return |
| 198 |
|
| 199 |
include_fixer_context = json.loads(stdout) |
| 200 |
query_symbol_infos = include_fixer_context["QuerySymbolInfos"] |
| 201 |
if not query_symbol_infos: |
| 202 |
print("The file is fine, no need to add a header.") |
| 203 |
return |
| 204 |
symbol = query_symbol_infos[0]["RawIdentifier"] |
| 205 |
# The header_infos is already sorted by clang-include-fixer. |
| 206 |
header_infos = include_fixer_context["HeaderInfos"] |
| 207 |
# Deduplicate headers while keeping the order, so that the same header would |
| 208 |
# not be suggested twice. |
| 209 |
unique_headers = [] |
| 210 |
seen = set() |
| 211 |
for header_info in header_infos: |
| 212 |
header = header_info["Header"] |
| 213 |
if header not in seen: |
| 214 |
seen.add(header) |
| 215 |
unique_headers.append(header) |
| 216 |
|
| 217 |
if not unique_headers: |
| 218 |
print("Couldn't find a header for {0}.".format(symbol)) |
| 219 |
return |
| 220 |
|
| 221 |
try: |
| 222 |
selected = unique_headers[0] |
| 223 |
inserted_header_infos = header_infos |
| 224 |
if len(unique_headers) > 1: |
| 225 |
selected = GetUserSelection( |
| 226 |
"choose a header file for {0}.".format(symbol), |
| 227 |
unique_headers, |
| 228 |
maximum_suggested_headers, |
| 229 |
) |
| 230 |
inserted_header_infos = [ |
| 231 |
header for header in header_infos if header["Header"] == selected |
| 232 |
] |
| 233 |
include_fixer_context["HeaderInfos"] = inserted_header_infos |
| 234 |
|
| 235 |
InsertHeaderToVimBuffer(include_fixer_context, text) |
| 236 |
print("Added #include {0} for {1}.".format(selected, symbol)) |
| 237 |
except Exception as error: |
| 238 |
print(error, file=sys.stderr) |
| 239 |
return |
| 240 |
|
| 241 |
|
| 242 |
if __name__ == "__main__": |
| 243 |
main() |