Nelze vybrat více než 25 témat
Téma musí začínat písmenem nebo číslem, může obsahovat pomlčky („-“) a může být dlouhé až 35 znaků.
2478 řádky
93 KiB
2478 řádky
93 KiB
;;; ycmd.el --- emacs bindings to the ycmd completion server -*- lexical-binding: t -*-
|
|
;;
|
|
;; Copyright (c) 2014-2017 Austin Bingham, Peter Vasil
|
|
;;
|
|
;; Authors: Austin Bingham <austin.bingham@gmail.com>
|
|
;; Peter Vasil <mail@petervasil.net>
|
|
;; Version: 1.3-cvs
|
|
;; URL: https://github.com/abingham/emacs-ycmd
|
|
;; Package-Requires: ((emacs "24.4") (dash "2.13.0") (s "1.11.0") (deferred "0.5.1") (cl-lib "0.6.1") (let-alist "1.0.5") (request "0.3.0") (request-deferred "0.3.0") (pkg-info "0.6"))
|
|
;;
|
|
;; This file is not part of GNU Emacs.
|
|
;;
|
|
;;; Commentary:
|
|
;;
|
|
;; Description:
|
|
;;
|
|
;; ycmd is a modular server that provides completion for C/C++/ObjC
|
|
;; and Python, among other languages. This module provides an emacs
|
|
;; client for that server.
|
|
;;
|
|
;; ycmd is a bit peculiar in a few ways. First, communication with the
|
|
;; server uses HMAC to authenticate HTTP messages. The server is
|
|
;; started with an HMAC secret that the client uses to generate hashes
|
|
;; of the content it sends. Second, the server gets this HMAC
|
|
;; information (as well as other configuration information) from a
|
|
;; file that the server deletes after reading. So when the code in
|
|
;; this module starts a server, it has to create a file containing the
|
|
;; secret code. Since the server deletes this file, this code has to
|
|
;; create a new one for each server it starts. Hopefully by knowing
|
|
;; this, you'll be able to make more sense of some of what you see
|
|
;; below.
|
|
;;
|
|
;; For more details, see the project page at
|
|
;; https://github.com/abingham/emacs-ycmd.
|
|
;;
|
|
;; Installation:
|
|
;;
|
|
;; Copy this file to to some location in your emacs load path. Then add
|
|
;; "(require 'ycmd)" to your emacs initialization (.emacs,
|
|
;; init.el, or something).
|
|
;;
|
|
;; Example config:
|
|
;;
|
|
;; (require 'ycmd)
|
|
;; (ycmd-setup)
|
|
;;
|
|
;; Basic usage:
|
|
;;
|
|
;; First you'll want to configure a few things. If you've got a global
|
|
;; ycmd config file, you can specify that with `ycmd-global-config':
|
|
;;
|
|
;; (set-variable 'ycmd-global-config "/path/to/global_conf.py")
|
|
;;
|
|
;; Then you'll want to configure your "extra-config whitelist"
|
|
;; patterns. These patterns determine which extra-conf files will get
|
|
;; loaded automatically by ycmd. So, for example, if you want to make
|
|
;; sure that ycmd will automatically load all of the extra-conf files
|
|
;; underneath your "~/projects" directory, do this:
|
|
;;
|
|
;; (set-variable 'ycmd-extra-conf-whitelist '("~/projects/*"))
|
|
;;
|
|
;; Now, the first time you open a file for which ycmd can perform
|
|
;; completions, a ycmd server will be automatically started.
|
|
;;
|
|
;; When ycmd encounters an extra-config that's not on the white list,
|
|
;; it checks `ycmd-extra-conf-handler' to determine what to do. By
|
|
;; default this is set to `ask', in which case the user is asked
|
|
;; whether to load the file or ignore it. You can also set it to
|
|
;; `load', in which case all extra-confs are loaded (and you don't
|
|
;; really need to worry about `ycmd-extra-conf-whitelist'.) Or you can
|
|
;; set this to `ignore', in which case all extra-confs are
|
|
;; automatically ignored.
|
|
;;
|
|
;; Use `ycmd-get-completions' to get completions at some point in a
|
|
;; file. For example:
|
|
;;
|
|
;; (ycmd-get-completions buffer position)
|
|
;;
|
|
;; You can use `ycmd-display-completions' to toy around with completion
|
|
;; interactively and see the shape of the structures in use.
|
|
;;
|
|
;;; License:
|
|
;;
|
|
;; Permission is hereby granted, free of charge, to any person
|
|
;; obtaining a copy of this software and associated documentation
|
|
;; files (the "Software"), to deal in the Software without
|
|
;; restriction, including without limitation the rights to use, copy,
|
|
;; modify, merge, publish, distribute, sublicense, and/or sell copies
|
|
;; of the Software, and to permit persons to whom the Software is
|
|
;; furnished to do so, subject to the following conditions:
|
|
;;
|
|
;; The above copyright notice and this permission notice shall be
|
|
;; included in all copies or substantial portions of the Software.
|
|
;;
|
|
;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
|
|
;; EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
|
|
;; MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
|
|
;; NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS
|
|
;; BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
|
|
;; ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
|
|
;; CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
|
|
;; SOFTWARE.
|
|
|
|
;;; Code:
|
|
|
|
(eval-when-compile
|
|
(require 'cl-lib)
|
|
(require 'let-alist))
|
|
(require 'dash)
|
|
(require 's)
|
|
(require 'deferred)
|
|
(require 'hmac-def)
|
|
(require 'json)
|
|
(require 'request)
|
|
(require 'request-deferred)
|
|
(require 'etags)
|
|
(require 'easymenu)
|
|
(require 'diff)
|
|
(require 'diff-mode)
|
|
|
|
(declare-function pkg-info-version-info "pkg-info" (package))
|
|
|
|
(defgroup ycmd nil
|
|
"a ycmd emacs client"
|
|
:link '(url-link :tag "Github" "https://github.com/abingham/emacs-ycmd")
|
|
:group 'tools
|
|
:group 'programming)
|
|
|
|
(defcustom ycmd-global-config nil
|
|
"Path to global extra conf file."
|
|
:type '(string))
|
|
|
|
(defcustom ycmd-extra-conf-whitelist nil
|
|
"List of glob expressions which match extra configs.
|
|
Whitelisted configs are loaded without confirmation."
|
|
:type '(repeat string))
|
|
|
|
(defcustom ycmd-extra-conf-handler 'ask
|
|
"What to do when an un-whitelisted extra config is encountered.
|
|
|
|
Options are:
|
|
|
|
`load'
|
|
Automatically load unknown extra confs.
|
|
|
|
`ignore'
|
|
Ignore unknown extra confs and do not load them.
|
|
|
|
`ask'
|
|
Ask the user for each unknown extra conf."
|
|
:type '(choice (const :tag "Load unknown extra confs" load)
|
|
(const :tag "Ignore unknown extra confs" ignore)
|
|
(const :tag "Ask the user" ask))
|
|
:risky t)
|
|
|
|
(defcustom ycmd-host "127.0.0.1"
|
|
"The host on which the ycmd server is running."
|
|
:type '(string))
|
|
|
|
(defcustom ycmd-server-command nil
|
|
"The ycmd server program command.
|
|
|
|
The value is a list of arguments to run the ycmd server.
|
|
Example value:
|
|
|
|
\(set-variable 'ycmd-server-command (\"python\" \"/path/to/ycmd/package/\"))"
|
|
:type '(repeat string))
|
|
|
|
(defcustom ycmd-server-args '("--log=debug"
|
|
"--keep_logfile"
|
|
"--idle_suicide_seconds=10800")
|
|
"Extra arguments to pass to the ycmd server."
|
|
:type '(repeat string))
|
|
|
|
(defcustom ycmd-server-port nil
|
|
"The ycmd server port. If nil, use random port."
|
|
:type '(number))
|
|
|
|
(defcustom ycmd-file-parse-result-hook nil
|
|
"Functions to run with file-parse results.
|
|
|
|
Each function will be called with with the results returned from
|
|
ycmd when it parses a file in response to
|
|
/event_notification."
|
|
:type 'hook
|
|
:risky t)
|
|
|
|
(defcustom ycmd-idle-change-delay 0.5
|
|
"Number of seconds to wait after buffer modification before
|
|
re-parsing the contents."
|
|
:type '(number)
|
|
:safe #'numberp)
|
|
|
|
(defcustom ycmd-keepalive-period 600
|
|
"Number of seconds between keepalive messages."
|
|
:type '(number))
|
|
|
|
(defcustom ycmd-startup-timeout 3
|
|
"Number of seconds to wait for the server to start."
|
|
:type '(number))
|
|
|
|
(defcustom ycmd-delete-process-delay 3
|
|
"Seconds to wait for the server to finish before killing the process."
|
|
:type '(number))
|
|
|
|
(defcustom ycmd-parse-conditions '(save new-line mode-enabled)
|
|
"When ycmd should reparse the buffer.
|
|
|
|
The variable is a list of events that may trigger parsing the
|
|
buffer for new completion:
|
|
|
|
`save'
|
|
Set buffer-needs-parse flag after the buffer was saved.
|
|
|
|
`new-line'
|
|
Set buffer-needs-parse flag immediately after a new
|
|
line was inserted into the buffer.
|
|
|
|
`idle-change'
|
|
Set buffer-needs-parse flag a short time after a
|
|
buffer has changed. (See `ycmd-idle-change-delay')
|
|
|
|
`mode-enabled'
|
|
Set buffer-needs-parse flag after `ycmd-mode' has been
|
|
enabled.
|
|
|
|
`buffer-focus'
|
|
Set buffer-needs-parse flag when an unparsed buffer gets
|
|
focus.
|
|
|
|
If nil, never set buffer-needs-parse flag. For a manual reparse,
|
|
use `ycmd-parse-buffer'."
|
|
:type '(set (const :tag "After the buffer was saved" save)
|
|
(const :tag "After a new line was inserted" new-line)
|
|
(const :tag "After a buffer was changed and idle" idle-change)
|
|
(const :tag "After a `ycmd-mode' was enabled" mode-enabled)
|
|
(const :tag "After an unparsed buffer gets focus" buffer-focus))
|
|
:safe #'listp)
|
|
|
|
(defcustom ycmd-default-tags-file-name "tags"
|
|
"The default tags file name."
|
|
:type 'string)
|
|
|
|
(defcustom ycmd-force-semantic-completion nil
|
|
"Whether to use always semantic completion."
|
|
:type 'boolean)
|
|
|
|
(defcustom ycmd-auto-trigger-semantic-completion t
|
|
"If non-nil, semantic completion is turned off.
|
|
Semantic completion is still available if
|
|
`ycmd-force-semantic-completion' is non-nil."
|
|
:type 'boolean)
|
|
|
|
(defcustom ycmd-hide-url-status t
|
|
"Whether to quash url status messages for ycmd requests."
|
|
:type 'boolean)
|
|
|
|
(defcustom ycmd-bypass-url-proxy-services t
|
|
"Bypass proxies for local traffic with the ycmd server.
|
|
|
|
If non-nil, bypass the variable `url-proxy-services' in
|
|
`ycmd--request' by setting it to nil and add `no_proxy' to
|
|
`process-environment' to bypass proxies when using `curl' as
|
|
`request-backend' and for the ycmd process."
|
|
:type 'boolean)
|
|
|
|
(defcustom ycmd-tag-files nil
|
|
"Whether to collect identifiers from tags file.
|
|
|
|
nil
|
|
Do not collect identifiers from tag files.
|
|
|
|
`auto'
|
|
Look up directory hierarchy for first found tags file with
|
|
`ycmd-default-tags-file-name'.
|
|
|
|
string
|
|
A tags file name.
|
|
|
|
list
|
|
A list of tag file names."
|
|
:type '(choice (const :tag "Don't use tag file." nil)
|
|
(const :tag "Locate tags file automatically" auto)
|
|
(string :tag "Tag file name")
|
|
(repeat :tag "List of tag files"
|
|
(string :tag "Tag file name")))
|
|
:safe (lambda (obj)
|
|
(or (symbolp obj)
|
|
(stringp obj)
|
|
(ycmd--string-list-p obj))))
|
|
|
|
(defcustom ycmd-file-type-map
|
|
'((c++-mode . ("cpp"))
|
|
(c-mode . ("c"))
|
|
(caml-mode . ("ocaml"))
|
|
(csharp-mode . ("cs"))
|
|
(d-mode . ("d"))
|
|
(erlang-mode . ("erlang"))
|
|
(emacs-lisp-mode . ("elisp"))
|
|
(go-mode . ("go"))
|
|
(java-mode . ("java"))
|
|
(js-mode . ("javascript"))
|
|
(js2-mode . ("javascript"))
|
|
(lua-mode . ("lua"))
|
|
(objc-mode . ("objc"))
|
|
(perl-mode . ("perl"))
|
|
(cperl-mode . ("perl"))
|
|
(php-mode . ("php"))
|
|
(python-mode . ("python"))
|
|
(ruby-mode . ("ruby"))
|
|
(rust-mode . ("rust"))
|
|
(swift-mode . ("swift"))
|
|
(scala-mode . ("scala"))
|
|
(tuareg-mode . ("ocaml"))
|
|
(typescript-mode . ("typescript")))
|
|
"Mapping from major modes to ycmd file-type strings.
|
|
|
|
Used to determine a) which major modes we support and b) how to
|
|
describe them to ycmd."
|
|
:type '(alist :key-type symbol :value-type (repeat string)))
|
|
|
|
(defcustom ycmd-min-num-chars-for-completion 2
|
|
"The minimum number of characters for identifier completion.
|
|
|
|
It controls the number of characters the user needs to type
|
|
before identifier-based completion suggestions are triggered.
|
|
|
|
This option is NOT used for semantic completion.
|
|
|
|
Setting this it to a high number like 99 effectively turns off
|
|
the identifier completion engine and just leaves the semantic
|
|
engine."
|
|
:type 'integer)
|
|
|
|
(defcustom ycmd-max-num-identifier-candidates 10
|
|
"The maximum number of identifier completion results."
|
|
:type 'integer)
|
|
|
|
(defcustom ycmd-seed-identifiers-with-keywords nil
|
|
"Whether to seed identifier database with keywords."
|
|
:type 'boolean)
|
|
|
|
(defcustom ycmd-get-keywords-function 'ycmd--get-keywords-from-alist
|
|
"Function to get keywords for current mode."
|
|
:type 'symbol)
|
|
|
|
(defcustom ycmd-gocode-binary-path nil
|
|
"Gocode binary path."
|
|
:type 'string)
|
|
|
|
(defcustom ycmd-godef-binary-path nil
|
|
"Godef binary path."
|
|
:type 'string)
|
|
|
|
(defcustom ycmd-rust-src-path nil
|
|
"Rust source path."
|
|
:type 'string)
|
|
|
|
(defcustom ycmd-swift-src-path nil
|
|
"Swift source path."
|
|
:type 'string)
|
|
|
|
(defcustom ycmd-racerd-binary-path nil
|
|
"Racerd binary path."
|
|
:type 'string)
|
|
|
|
(defcustom ycmd-python-binary-path nil
|
|
"Python binary path."
|
|
:type 'string)
|
|
|
|
(defcustom ycmd-global-modes t
|
|
"Modes for which `ycmd-mode' is turned on by `global-ycmd-mode'.
|
|
|
|
If t, ycmd mode is turned on for all major modes in
|
|
`ycmd-file-type-map'. If set to all, ycmd mode is turned on
|
|
for all major-modes. If a list, ycmd mode is turned on for all
|
|
`major-mode' symbols in that list. If the `car' of the list is
|
|
`not', ycmd mode is turned on for all `major-mode' symbols _not_
|
|
in that list. If nil, ycmd mode is never turned on by
|
|
`global-ycmd-mode'."
|
|
:type '(choice (const :tag "none" nil)
|
|
(const :tag "member in `ycmd-file-type-map'" t)
|
|
(const :tag "all" all)
|
|
(set :menu-tag "mode specific" :tag "modes"
|
|
:value (not)
|
|
(const :tag "Except" not)
|
|
(repeat :inline t (symbol :tag "mode")))))
|
|
|
|
(defcustom ycmd-confirm-fixit t
|
|
"Whether to confirm when applying fixit on line."
|
|
:type 'boolean)
|
|
|
|
(defcustom ycmd-after-exception-hook nil
|
|
"Function to run if server request resulted in exception.
|
|
|
|
This hook is run whenever an exception is thrown after a ycmd
|
|
server request. Four arguments are passed to the function, a
|
|
string with the type of request that triggerd the exception, the
|
|
buffer and the point at the time of the request and the server
|
|
response structure which looks like this:
|
|
|
|
((exception
|
|
(TYPE . \"RuntimeError\"))
|
|
(traceback . \"long traceback string\")
|
|
(message . \"Can't jump to definition.\"))
|
|
|
|
This variable is a normal hook. See Info node `(elisp)Hooks'."
|
|
:type 'hook
|
|
:risky t)
|
|
|
|
(defcustom ycmd-after-teardown-hook nil
|
|
"Functions to run after execution of `ycmd--teardown'.
|
|
|
|
This variable is a normal hook. See Info node `(elisp)Hooks'."
|
|
:type 'hook
|
|
:risky t)
|
|
|
|
(defcustom ycmd-mode-line-prefix "ycmd"
|
|
"Base mode line lighter for ycmd."
|
|
:type 'string
|
|
:package-version '(ycmd . "1.3"))
|
|
|
|
(defcustom ycmd-completing-read-function #'completing-read
|
|
"Function to read from minibuffer with completion.
|
|
|
|
The function must be compatible to the built-in `completing-read'
|
|
function."
|
|
:type '(choice (const :tag "Default" completing-read)
|
|
(const :tag "IDO" ido-completing-read)
|
|
(function :tag "Custom function"))
|
|
:risky t
|
|
:package-version '(ycmd . "1.2"))
|
|
|
|
(defconst ycmd--file-types-with-diagnostics
|
|
'("c"
|
|
"cpp"
|
|
"objc"
|
|
"objcpp"
|
|
"cs"
|
|
"typescript")
|
|
"A list of ycmd file type strings which support semantic diagnostics.")
|
|
|
|
(defvar ycmd-keywords-alist
|
|
'((c++-mode
|
|
"alignas" "alignof" "and" "and_eq" "asm" "auto" "bitand" "bitor" "bool"
|
|
"break" "case" "catch" "char" "char16_t" "char32_t" "class" "compl"
|
|
"concept" "const" "const_cast" "constexpr" "continue" "decltype" "default"
|
|
"define" "defined" "delete" "do" "double" "dynamic_cast" "elif" "else"
|
|
"endif" "enum" "error" "explicit" "export" "extern" "false" "final" "float"
|
|
"for" "friend" "goto" "if" "ifdef" "ifndef" "include" "inline" "int" "line"
|
|
"long" "mutable" "namespace" "new" "noexcept" "not" "not_eq" "nullptr"
|
|
"operator" "or" "or_eq" "override" "pragma" "_Pragma" "private" "protected"
|
|
"public" "register" "reinterpret_cast" "requires" "return" "short" "signed"
|
|
"sizeof" "static" "static_assert" "static_cast" "struct" "switch"
|
|
"template" "this" "thread_local" "throw" "true" "try" "typedef" "typeid"
|
|
"typename" "union" "unsigned" "using" "virtual" "void" "volatile" "wchar_t"
|
|
"while" "xor" "xor_eq")
|
|
(c-mode
|
|
"auto" "_Alignas" "_Alignof" "_Atomic" "_Bool" "break" "case" "char"
|
|
"_Complex" "const" "continue" "default" "define" "defined" "do" "double"
|
|
"elif" "else" "endif" "enum" "error" "extern" "float" "for" "goto"
|
|
"_Generic" "if" "ifdef" "ifndef" "_Imaginary" "include" "inline" "int"
|
|
"line" "long" "_Noreturn" "pragma" "register" "restrict" "return" "short"
|
|
"signed" "sizeof" "static" "struct" "switch" "_Static_assert" "typedef"
|
|
"_Thread_local" "undef" "union" "unsigned" "void" "volatile" "while")
|
|
(go-mode
|
|
"break" "case" "chan" "const" "continue" "default" "defer" "else"
|
|
"fallthrough" "for" "func" "go" "goto" "if" "import" "interface" "map"
|
|
"package" "range" "return" "select" "struct" "switch" "type" "var")
|
|
(lua-mode
|
|
"and" "break" "do" "else" "elseif" "end" "false" "for" "function" "if" "in"
|
|
"local" "nil" "not" "or" "repeat" "return" "then" "true" "until" "while")
|
|
(python-mode
|
|
"ArithmeticError" "AssertionError" "AttributeError" "BaseException"
|
|
"BufferError" "BytesWarning" "DeprecationWarning" "EOFError" "Ellipsis"
|
|
"EnvironmentError" "Exception" "False" "FloatingPointError" "FutureWarning"
|
|
"GeneratorExit" "IOError" "ImportError" "ImportWarning" "IndentationError"
|
|
"IndexError" "KeyError" "KeyboardInterrupt" "LookupError" "MemoryError"
|
|
"NameError" "None" "NotImplemented" "NotImplementedError" "OSError"
|
|
"OverflowError" "PendingDeprecationWarning" "ReferenceError" "RuntimeError"
|
|
"RuntimeWarning" "StandardError" "StopIteration" "SyntaxError"
|
|
"SyntaxWarning" "SystemError" "SystemExit" "TabError" "True" "TypeError"
|
|
"UnboundLocalError" "UnicodeDecodeError" "UnicodeEncodeError"
|
|
"UnicodeError" "UnicodeTranslateError" "UnicodeWarning" "UserWarning"
|
|
"ValueError" "Warning" "ZeroDivisionError" "__builtins__" "__debug__"
|
|
"__doc__" "__file__" "__future__" "__import__" "__init__" "__main__"
|
|
"__name__" "__package__" "_dummy_thread" "_thread" "abc" "abs" "aifc" "all"
|
|
"and" "any" "apply" "argparse" "array" "as" "assert" "ast" "asynchat"
|
|
"asyncio" "asyncore" "atexit" "audioop" "base64" "basestring" "bdb" "bin"
|
|
"binascii" "binhex" "bisect" "bool" "break" "buffer" "builtins" "bytearray"
|
|
"bytes" "bz2" "calendar" "callable" "cgi" "cgitb" "chr" "chuck" "class"
|
|
"classmethod" "cmath" "cmd" "cmp" "code" "codecs" "codeop" "coerce"
|
|
"collections" "colorsys" "compile" "compileall" "complex" "concurrent"
|
|
"configparser" "contextlib" "continue" "copy" "copyreg" "copyright"
|
|
"credits" "crypt" "csv" "ctypes" "curses" "datetime" "dbm" "decimal" "def"
|
|
"del" "delattr" "dict" "difflib" "dir" "dis" "distutils" "divmod" "doctest"
|
|
"dummy_threading" "elif" "else" "email" "enumerate" "ensurepip" "enum"
|
|
"errno" "eval" "except" "exec" "execfile" "exit" "faulthandler" "fcntl"
|
|
"file" "filecmp" "fileinput" "filter" "finally" "float" "fnmatch" "for"
|
|
"format" "formatter" "fpectl" "fractions" "from" "frozenset" "ftplib"
|
|
"functools" "gc" "getattr" "getopt" "getpass" "gettext" "glob" "global"
|
|
"globals" "grp" "gzip" "hasattr" "hash" "hashlib" "heapq" "help" "hex"
|
|
"hmac" "html" "http" "id" "if" "imghdr" "imp" "impalib" "import"
|
|
"importlib" "in" "input" "inspect" "int" "intern" "io" "ipaddress" "is"
|
|
"isinstance" "issubclass" "iter" "itertools" "json" "keyword" "lambda"
|
|
"len" "license" "linecache" "list" "locale" "locals" "logging" "long"
|
|
"lzma" "macpath" "mailbox" "mailcap" "map" "marshal" "math" "max"
|
|
"memoryview" "mimetypes" "min" "mmap" "modulefinder" "msilib" "msvcrt"
|
|
"multiprocessing" "netrc" "next" "nis" "nntplib" "not" "numbers" "object"
|
|
"oct" "open" "operator" "optparse" "or" "ord" "os" "ossaudiodev" "parser"
|
|
"pass" "pathlib" "pdb" "pickle" "pickletools" "pipes" "pkgutil" "platform"
|
|
"plistlib" "poplib" "posix" "pow" "pprint" "print" "profile" "property"
|
|
"pty" "pwd" "py_compiler" "pyclbr" "pydoc" "queue" "quit" "quopri" "raise"
|
|
"random" "range" "raw_input" "re" "readline" "reduce" "reload" "repr"
|
|
"reprlib" "resource" "return" "reversed" "rlcompleter" "round" "runpy"
|
|
"sched" "select" "selectors" "self" "set" "setattr" "shelve" "shlex"
|
|
"shutil" "signal" "site" "slice" "smtpd" "smtplib" "sndhdr" "socket"
|
|
"socketserver" "sorted" "spwd" "sqlite3" "ssl" "stat" "staticmethod"
|
|
"statistics" "str" "string" "stringprep" "struct" "subprocess" "sum"
|
|
"sunau" "super" "symbol" "symtable" "sys" "sysconfig" "syslog" "tabnanny"
|
|
"tarfile" "telnetlib" "tempfile" "termios" "test" "textwrap" "threading"
|
|
"time" "timeit" "tkinter" "token" "tokenize" "trace" "traceback"
|
|
"tracemalloc" "try" "tty" "tuple" "turtle" "type" "types" "unichr"
|
|
"unicode" "unicodedata" "unittest" "urllib" "uu" "uuid" "vars" "venv"
|
|
"warnings" "wave" "weakref" "webbrowser" "while" "winsound" "winreg" "with"
|
|
"wsgiref" "xdrlib" "xml" "xmlrpc" "xrange" "yield" "zip" "zipfile" "zipimport"
|
|
"zlib")
|
|
(rust-mode
|
|
"Self"
|
|
"as" "box" "break" "const" "continue" "crate" "else" "enum" "extern"
|
|
"false" "fn" "for" "if" "impl" "in" "let" "loop" "macro" "match" "mod"
|
|
"move" "mut" "pub" "ref" "return" "self" "static" "struct" "super"
|
|
"trait" "true" "type" "unsafe" "use" "where" "while")
|
|
(swift-mode
|
|
"true" "false" "nil" "#available" "#colorLiteral" "#column" "#else"
|
|
"#elseif" "#endif" "#fileLiteral" "#file" "#function" "#if" "#imageLiteral"
|
|
"#keypath" "#line" "#selector" "#sourceLocation" "associatedtype" "class"
|
|
"deinit" "enum" "extension" "fileprivate" "func" "import" "init" "inout"
|
|
"internal" "let" "open" "operator" "private" "protocol" "public" "static"
|
|
"struct" "subscript" "typealias" "var" "break" "case" "continue" "default"
|
|
"defer" "do" "else" "fallthrough" "for" "guard" "if" "in" "repeat" "return"
|
|
"switch" "where" "while" "as" "catch" "dynamicType" "is" "rethrows" "super"
|
|
"self" "Self" "throws" "throw" "try" "Protocol" "Type" "and" "assignment"
|
|
"associativity" "convenience" "didSet" "dynamic" "final" "get" "higherThan"
|
|
"indirect" "infix" "lazy" "left" "lowerThan" "mutating" "none"
|
|
"nonmutating" "optional" "override" "postfix" "precedence"
|
|
"precedencegroup" "prefix" "required" "right" "set" "unowned" "weak"
|
|
"willSet"))
|
|
"Alist mapping major-modes to keywords for.
|
|
|
|
Keywords source: https://github.com/auto-complete/auto-complete/tree/master/dict
|
|
and `company-keywords'.")
|
|
|
|
(defvar ycmd--server-actual-port nil
|
|
"The actual port being used by the ycmd server.
|
|
This is set based on the value of `ycmd-server-port' if set, or
|
|
the value from the output of the server itself.")
|
|
|
|
(defvar ycmd--hmac-secret nil
|
|
"This is populated with the hmac secret of the current connection.
|
|
Users should never need to modify this, hence the defconst. It is
|
|
not, however, treated as a constant by this code. This value gets
|
|
set in ycmd-open.")
|
|
|
|
(defconst ycmd--server-process-name "ycmd-server"
|
|
"The Emacs name of the server process.
|
|
This is used by functions like `start-process', `get-process'
|
|
and `delete-process'.")
|
|
|
|
(defvar-local ycmd--notification-timer nil
|
|
"Timer for notifying ycmd server to do work, e.g. parsing files.")
|
|
|
|
(defvar ycmd--keepalive-timer nil
|
|
"Timer for sending keepalive messages to the server.")
|
|
|
|
(defvar ycmd--on-focus-timer nil
|
|
"Timer for deferring ycmd server notification to parse a buffer.")
|
|
|
|
(defvar ycmd--server-timeout-timer nil)
|
|
|
|
(defconst ycmd--server-buffer-name "*ycmd-server*"
|
|
"Name of the ycmd server buffer.")
|
|
|
|
(defvar-local ycmd--last-status-change 'unparsed
|
|
"The last status of the current buffer.")
|
|
|
|
(defvar-local ycmd--last-modified-tick nil
|
|
"The BUFFER's last FileReadyToParse tick counter.")
|
|
|
|
(defvar-local ycmd--buffer-visit-flag nil)
|
|
|
|
(defvar ycmd--available-completers (make-hash-table :test 'eq))
|
|
|
|
(defvar ycmd--process-environment nil)
|
|
|
|
(defvar ycmd--mode-keywords-loaded nil
|
|
"List of modes for which keywords have been loaded.")
|
|
|
|
(defconst ycmd-hooks-alist
|
|
'((after-save-hook . ycmd--on-save)
|
|
(after-change-functions . ycmd--on-change)
|
|
(window-configuration-change-hook . ycmd--on-window-configuration-change)
|
|
(kill-buffer-hook . ycmd--on-close-buffer)
|
|
(before-revert-hook . ycmd--teardown)
|
|
(post-command-hook . ycmd--perform-deferred-parse))
|
|
"Hooks which ycmd hooks in.")
|
|
|
|
(add-hook 'kill-emacs-hook 'ycmd-close)
|
|
|
|
(defvar ycmd-command-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(define-key map "p" 'ycmd-parse-buffer)
|
|
(define-key map "o" 'ycmd-open)
|
|
(define-key map "c" 'ycmd-close)
|
|
(define-key map "." 'ycmd-goto)
|
|
(define-key map "gi" 'ycmd-goto-include)
|
|
(define-key map "gd" 'ycmd-goto-definition)
|
|
(define-key map "gD" 'ycmd-goto-declaration)
|
|
(define-key map "gm" 'ycmd-goto-implementation)
|
|
(define-key map "gp" 'ycmd-goto-imprecise)
|
|
(define-key map "gr" 'ycmd-goto-references)
|
|
(define-key map "gt" 'ycmd-goto-type)
|
|
(define-key map "s" 'ycmd-toggle-force-semantic-completion)
|
|
(define-key map "v" 'ycmd-show-debug-info)
|
|
(define-key map "V" 'ycmd-version)
|
|
(define-key map "d" 'ycmd-show-documentation)
|
|
(define-key map "C" 'ycmd-clear-compilation-flag-cache)
|
|
(define-key map "O" 'ycmd-restart-semantic-server)
|
|
(define-key map "t" 'ycmd-get-type)
|
|
(define-key map "T" 'ycmd-get-parent)
|
|
(define-key map "f" 'ycmd-fixit)
|
|
(define-key map "r" 'ycmd-refactor-rename)
|
|
(define-key map "x" 'ycmd-completer)
|
|
map)
|
|
"Keymap for `ycmd-mode' interactive commands.")
|
|
|
|
(defcustom ycmd-keymap-prefix (kbd "C-c Y")
|
|
"Prefix for key bindings of `ycmd-mode'.
|
|
|
|
Changing this variable outside Customize does not have any
|
|
effect. To change the keymap prefix from Lisp, you need to
|
|
explicitly re-define the prefix key:
|
|
|
|
(define-key ycmd-mode-map ycmd-keymap-prefix nil)
|
|
(setq ycmd-keymap-prefix (kbd \"C-c ,\"))
|
|
(define-key ycmd-mode-map ycmd-keymap-prefix
|
|
ycmd-command-map)"
|
|
:type 'string
|
|
:risky t
|
|
:set
|
|
(lambda (variable key)
|
|
(when (and (boundp variable) (boundp 'ycmd-mode-map))
|
|
(define-key ycmd-mode-map (symbol-value variable) nil)
|
|
(define-key ycmd-mode-map key ycmd-command-map))
|
|
(set-default variable key)))
|
|
|
|
(defvar ycmd-mode-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(define-key map ycmd-keymap-prefix ycmd-command-map)
|
|
map)
|
|
"Keymap for `ycmd-mode'.")
|
|
|
|
(easy-menu-define ycmd-mode-menu ycmd-mode-map
|
|
"Menu used when `ycmd-mode' is active."
|
|
'("YCMd"
|
|
["Start server" ycmd-open]
|
|
["Stop server" ycmd-close]
|
|
"---"
|
|
["Parse buffer" ycmd-parse-buffer]
|
|
"---"
|
|
["GoTo" ycmd-goto]
|
|
["GoToDefinition" ycmd-goto-definition]
|
|
["GoToDeclaration" ycmd-goto-declaration]
|
|
["GoToInclude" ycmd-goto-include]
|
|
["GoToImplementation" ycmd-goto-implementation]
|
|
["GoToReferences" ycmd-goto-references]
|
|
["GoToType" ycmd-goto-type]
|
|
["GoToImprecise" ycmd-goto-imprecise]
|
|
"---"
|
|
["Show documentation" ycmd-show-documentation]
|
|
["Show type" ycmd-get-type]
|
|
["Show parent" ycmd-get-parent]
|
|
"---"
|
|
["FixIt" ycmd-fixit]
|
|
["RefactorRename" ycmd-refactor-rename]
|
|
"---"
|
|
["Load extra config" ycmd-load-conf-file]
|
|
["Restart semantic server" ycmd-restart-semantic-server]
|
|
["Clear compilation flag cache" ycmd-clear-compilation-flag-cache]
|
|
["Force semantic completion" ycmd-toggle-force-semantic-completion
|
|
:style toggle :selected ycmd-force-semantic-completion]
|
|
"---"
|
|
["Show debug info" ycmd-show-debug-info]
|
|
["Show version" ycmd-version t]
|
|
["Log enabled" ycmd-toggle-log-enabled
|
|
:style toggle :selected ycmd--log-enabled]))
|
|
|
|
(defmacro ycmd--kill-timer (timer)
|
|
"Cancel TIMER."
|
|
`(when ,timer
|
|
(cancel-timer ,timer)
|
|
(setq ,timer nil)))
|
|
|
|
(defun ycmd-parsing-in-progress-p ()
|
|
"Return t if parsing is in progress."
|
|
(eq ycmd--last-status-change 'parsing))
|
|
|
|
(defun ycmd--report-status (status)
|
|
"Report ycmd STATUS."
|
|
(setq ycmd--last-status-change status)
|
|
(force-mode-line-update))
|
|
|
|
(defun ycmd--mode-line-status-text ()
|
|
"Get text for the mode line."
|
|
(let ((force-semantic
|
|
(when ycmd-force-semantic-completion "/s"))
|
|
(text (pcase ycmd--last-status-change
|
|
(`parsed "")
|
|
(`parsing "*")
|
|
(`unparsed "?")
|
|
(`stopped "-")
|
|
(`starting ">")
|
|
(`errored "!"))))
|
|
(concat " " ycmd-mode-line-prefix force-semantic text)))
|
|
|
|
;;;###autoload
|
|
(define-minor-mode ycmd-mode
|
|
"Minor mode for interaction with the ycmd completion server.
|
|
|
|
When called interactively, toggle `ycmd-mode'. With prefix ARG,
|
|
enable `ycmd-mode' if ARG is positive, otherwise disable it.
|
|
|
|
When called from Lisp, enable `ycmd-mode' if ARG is omitted,
|
|
nil or positive. If ARG is `toggle', toggle `ycmd-mode'.
|
|
Otherwise behave as if called interactively.
|
|
|
|
\\{ycmd-mode-map}"
|
|
:init-value nil
|
|
:keymap ycmd-mode-map
|
|
:lighter (:eval (ycmd--mode-line-status-text))
|
|
:group 'ycmd
|
|
:require 'ycmd
|
|
:after-hook
|
|
(progn (unless (ycmd-running-p) (ycmd-open))
|
|
(ycmd--conditional-parse 'mode-enabled 'deferred))
|
|
(cond
|
|
(ycmd-mode
|
|
(dolist (hook ycmd-hooks-alist)
|
|
(add-hook (car hook) (cdr hook) nil 'local)))
|
|
(t
|
|
(dolist (hook ycmd-hooks-alist)
|
|
(remove-hook (car hook) (cdr hook) 'local))
|
|
(ycmd--teardown))))
|
|
|
|
;;;###autoload
|
|
(defun ycmd-setup ()
|
|
"Setup `ycmd-mode'.
|
|
|
|
Hook `ycmd-mode' into modes in `ycmd-file-type-map'."
|
|
(interactive)
|
|
(dolist (it ycmd-file-type-map)
|
|
(add-hook (intern (format "%s-hook" (symbol-name (car it)))) 'ycmd-mode)))
|
|
(make-obsolete 'ycmd-setup 'global-ycmd-mode "1.0")
|
|
|
|
(defun ycmd-version (&optional show-version)
|
|
"Get the `emacs-ycmd' version as string.
|
|
|
|
If called interactively or if SHOW-VERSION is non-nil, show the
|
|
version in the echo area and the messages buffer.
|
|
|
|
The returned string includes both, the version from package.el
|
|
and the library version, if both a present and different.
|
|
|
|
If the version number could not be determined, signal an error,
|
|
if called interactively, or if SHOW-VERSION is non-nil, otherwise
|
|
just return nil."
|
|
(interactive (list t))
|
|
(if (require 'pkg-info nil :no-error)
|
|
(let ((version (pkg-info-version-info 'ycmd)))
|
|
(when show-version
|
|
(message "emacs-ycmd version: %s" version))
|
|
version)
|
|
(error "Cannot determine version without package pkg-info")))
|
|
|
|
(defun ycmd--maybe-enable-mode ()
|
|
"Enable `ycmd-mode' according `ycmd-global-modes'."
|
|
(when (pcase ycmd-global-modes
|
|
(`t (ycmd-major-mode-to-file-types major-mode))
|
|
(`all t)
|
|
(`(not . ,modes) (not (memq major-mode modes)))
|
|
(modes (memq major-mode modes)))
|
|
(ycmd-mode)))
|
|
|
|
;;;###autoload
|
|
(define-globalized-minor-mode global-ycmd-mode ycmd-mode
|
|
ycmd--maybe-enable-mode
|
|
:init-value nil)
|
|
|
|
(defun ycmd-unload-function ()
|
|
"Unload function for ycmd."
|
|
(global-ycmd-mode -1)
|
|
(remove-hook 'kill-emacs-hook #'ycmd-close))
|
|
|
|
(defvar-local ycmd--deferred-parse nil
|
|
"If non-nil, a deferred file parse notification is pending.")
|
|
|
|
(defun ycmd--must-defer-parse ()
|
|
"Determine whether parsing the file has to be deferred.
|
|
|
|
Return t if parsing is to be deferred, or nil otherwise."
|
|
(or (not (ycmd--server-alive-p))
|
|
(not (get-buffer-window))
|
|
(ycmd-parsing-in-progress-p)
|
|
revert-buffer-in-progress-p))
|
|
|
|
(defun ycmd--deferred-parse-p ()
|
|
"Return non-nil if current buffer has a deferred parse."
|
|
ycmd--deferred-parse)
|
|
|
|
(defun ycmd--parse-deferred ()
|
|
"Defer parse notification for current buffer."
|
|
(setq ycmd--deferred-parse t))
|
|
|
|
(defun ycmd--perform-deferred-parse ()
|
|
"Perform the deferred parse."
|
|
(when (ycmd--deferred-parse-p)
|
|
(setq ycmd--deferred-parse nil)
|
|
(ycmd--conditional-parse)))
|
|
|
|
(defun ycmd--conditional-parse (&optional condition force-deferred)
|
|
"Reparse the buffer under CONDITION.
|
|
|
|
If CONDITION is non-nil, determine whether a ready to parse
|
|
notification should be sent according `ycmd-parse-conditions'.
|
|
|
|
If FORCE-DEFERRED is non-nil perform parse notification later."
|
|
(when (and ycmd-mode
|
|
(or (not condition)
|
|
(memq condition ycmd-parse-conditions)))
|
|
(if (or force-deferred (ycmd--must-defer-parse))
|
|
(ycmd--parse-deferred)
|
|
(let ((buffer (current-buffer)))
|
|
(deferred:$
|
|
(deferred:next
|
|
(lambda ()
|
|
(with-current-buffer buffer
|
|
(ycmd--on-visit-buffer))))
|
|
(deferred:nextc it
|
|
(lambda ()
|
|
(with-current-buffer buffer
|
|
(let ((tick (buffer-chars-modified-tick)))
|
|
(unless (equal tick ycmd--last-modified-tick)
|
|
(setq ycmd--last-modified-tick tick)
|
|
(ycmd-notify-file-ready-to-parse)))))))))))
|
|
|
|
(defun ycmd--on-save ()
|
|
"Function to run when the buffer has been saved."
|
|
(ycmd--conditional-parse 'save))
|
|
|
|
(defun ycmd--on-idle-change ()
|
|
"Function to run on idle-change."
|
|
(ycmd--kill-timer ycmd--notification-timer)
|
|
(ycmd--conditional-parse 'idle-change))
|
|
|
|
(defun ycmd--on-change (beg end _len)
|
|
"Function to run when a buffer change between BEG and END.
|
|
_LEN is ununsed."
|
|
(save-match-data
|
|
(when ycmd-mode
|
|
(ycmd--kill-timer ycmd--notification-timer)
|
|
(if (string-match-p "\n" (buffer-substring beg end))
|
|
(ycmd--conditional-parse 'new-line)
|
|
(setq ycmd--notification-timer
|
|
(run-at-time ycmd-idle-change-delay nil
|
|
#'ycmd--on-idle-change))))))
|
|
|
|
(defun ycmd--on-unparsed-buffer-focus (buffer)
|
|
"Function to run when an unparsed BUFFER gets focus."
|
|
(ycmd--kill-timer ycmd--on-focus-timer)
|
|
(with-current-buffer buffer
|
|
(ycmd--conditional-parse 'buffer-focus)))
|
|
|
|
(defun ycmd--on-window-configuration-change ()
|
|
"Function to run by `window-configuration-change-hook'."
|
|
(if (ycmd--deferred-parse-p)
|
|
(ycmd--perform-deferred-parse)
|
|
(when (and ycmd-mode
|
|
(pcase ycmd--last-status-change
|
|
((or `unparsed `starting) t))
|
|
(memq 'buffer-focus ycmd-parse-conditions))
|
|
(ycmd--kill-timer ycmd--on-focus-timer)
|
|
(let ((on-buffer-focus-fn
|
|
(apply-partially 'ycmd--on-unparsed-buffer-focus
|
|
(current-buffer))))
|
|
(setq ycmd--on-focus-timer
|
|
(run-at-time 1.0 nil on-buffer-focus-fn))))))
|
|
|
|
(defmacro ycmd--with-all-ycmd-buffers (&rest body)
|
|
"Execute BODY with each `ycmd-mode' enabled buffer."
|
|
(declare (indent 0) (debug t))
|
|
`(dolist (buffer (buffer-list))
|
|
(with-current-buffer buffer
|
|
(when ycmd-mode
|
|
,@body))))
|
|
|
|
(defun ycmd--exception-p (response)
|
|
"Check whether RESPONSE is an exception."
|
|
(and (listp response) (assq 'exception response)))
|
|
|
|
(cl-defmacro ycmd-with-handled-server-exceptions (request
|
|
&rest body
|
|
&key
|
|
dont-show-exception-msg
|
|
on-exception-form
|
|
return-form
|
|
bind-current-buffer
|
|
&allow-other-keys)
|
|
"Run a deferred REQUEST and exectute BODY on success. Catch all
|
|
exceptions raised through server communication. If it is raised
|
|
because of a unknown .ycm_extra_conf.py file, load the file or
|
|
ignore it after asking the user. Otherwise print exception to
|
|
minibuffer if NO-EXCEPTION-MESSAGE is nil. ON-EXCEPTION-FORM is
|
|
run if an exception occurs. The value of RETURN-FORM is returned
|
|
on exception. If BIND-CURRENT-BUFFER is non-nil, bind
|
|
`current-buffer' to `request-buffer' var.
|
|
|
|
\(fn REQUEST &key NO-DISPLAY ERROR-FORM RETURN-FORM
|
|
BIND-CURRENT-BUFFER &rest BODY)"
|
|
(declare (indent 1) (debug t))
|
|
(while (keywordp (car body))
|
|
(setq body (cdr (cdr body))))
|
|
`(let ((request-buffer (and ,bind-current-buffer (current-buffer))))
|
|
(deferred:$
|
|
,request
|
|
(deferred:nextc it
|
|
(lambda (response)
|
|
(cl-macrolet ((with-optional-current-buffer
|
|
(buffer-or-name &rest body-2)
|
|
`(if ,buffer-or-name
|
|
(with-current-buffer ,buffer-or-name
|
|
,@body-2)
|
|
,@body-2)))
|
|
(with-optional-current-buffer
|
|
request-buffer
|
|
(if (ycmd--exception-p response)
|
|
(let-alist response
|
|
(if (string= .exception.TYPE "UnknownExtraConf")
|
|
(ycmd--handle-extra-conf-exception
|
|
.exception.extra_conf_file)
|
|
(unless ,dont-show-exception-msg
|
|
(message "%s: %s" .exception.TYPE .message))
|
|
,on-exception-form
|
|
,return-form))
|
|
(if (null ',body) response ,@body)))))))))
|
|
|
|
(defun ycmd--on-visit-buffer ()
|
|
"If `ycmd--buffer-visit-flag' is nil send BufferVisit event."
|
|
(when (and (not ycmd--buffer-visit-flag)
|
|
(ycmd--server-alive-p))
|
|
(ycmd-with-handled-server-exceptions
|
|
(ycmd--event-notification "BufferVisit")
|
|
:bind-current-buffer t
|
|
(setq ycmd--buffer-visit-flag t))))
|
|
|
|
(defun ycmd--on-close-buffer ()
|
|
"Notify server that the current buffer is no longer open.
|
|
Cleanup emacs-ycmd variables."
|
|
(when (ycmd--server-alive-p)
|
|
(ycmd-with-handled-server-exceptions
|
|
(ycmd--event-notification "BufferUnload")))
|
|
(ycmd--teardown))
|
|
|
|
(defun ycmd--reset-parse-status ()
|
|
(ycmd--report-status 'unparsed)
|
|
(setq ycmd--last-modified-tick nil))
|
|
|
|
(defun ycmd--teardown ()
|
|
"Teardown ycmd in current buffer."
|
|
(ycmd--kill-timer ycmd--notification-timer)
|
|
(ycmd--reset-parse-status)
|
|
(setq ycmd--deferred-parse nil)
|
|
(run-hooks 'ycmd-after-teardown-hook))
|
|
|
|
(defun ycmd--global-teardown ()
|
|
"Teardown ycmd in all buffers."
|
|
(ycmd--kill-timer ycmd--on-focus-timer)
|
|
(setq ycmd--mode-keywords-loaded nil)
|
|
(clrhash ycmd--available-completers)
|
|
(ycmd--with-all-ycmd-buffers
|
|
(ycmd--teardown)
|
|
(setq ycmd--buffer-visit-flag nil)))
|
|
|
|
(defun ycmd-file-types-with-diagnostics (mode)
|
|
"Find the ycmd file types for MODE which support semantic diagnostics.
|
|
|
|
Returns a possibly empty list of ycmd file type strings. If this
|
|
is empty, then ycmd doesn't support semantic completion (or
|
|
diagnostics) for MODE."
|
|
(-intersection
|
|
ycmd--file-types-with-diagnostics
|
|
(ycmd-major-mode-to-file-types mode)))
|
|
|
|
(defun ycmd-major-modes-with-diagnostics ()
|
|
"Return a list with major-modes which support semantic diagnostics."
|
|
(->>
|
|
(--filter (member (cadr it) ycmd--file-types-with-diagnostics)
|
|
ycmd-file-type-map)
|
|
(--map (car it))))
|
|
|
|
(defun ycmd-deferred:sync! (d)
|
|
"Wait for the given deferred task.
|
|
Error is raised if it is not processed within deferred chain D.
|
|
This is a slightly modified version of the original
|
|
`deferred:sync!' function, with using `accept-process-output'
|
|
wrapped with `with-current-buffer' for waiting instead of a
|
|
combination of `sit-for' and `sleep-for' and with a shorter wait
|
|
time."
|
|
(progn
|
|
(let ((last-value 'deferred:undefined*)
|
|
uncaught-error)
|
|
(deferred:try
|
|
(deferred:nextc d
|
|
(lambda (x) (setq last-value x)))
|
|
:catch
|
|
(lambda (err) (setq uncaught-error err)))
|
|
(with-local-quit
|
|
(while (and (eq 'deferred:undefined* last-value)
|
|
(not uncaught-error))
|
|
(accept-process-output nil 0.01))
|
|
(when uncaught-error
|
|
(deferred:resignal uncaught-error))
|
|
last-value))))
|
|
|
|
(defmacro ycmd-deferred:timeout (timeout-sec d)
|
|
"Time out macro on a deferred task.
|
|
If the deferred task does not complete within TIMEOUT-SEC, this
|
|
macro cancels the deferred task D and returns nil. This is a
|
|
slightly modified version of the original `deferred:timeout'
|
|
macro, which takes the timeout var in seconds and the timeout
|
|
form returns the symbol `timeout'."
|
|
(declare (indent 1) (debug t))
|
|
`(deferred:earlier
|
|
(deferred:nextc (deferred:wait (* ,timeout-sec 1000))
|
|
(lambda () 'timeout))
|
|
,d))
|
|
|
|
(defun ycmd-open ()
|
|
"Start a new ycmd server.
|
|
|
|
This kills any ycmd server already running (under ycmd.el's
|
|
control.)."
|
|
(interactive)
|
|
(ycmd-close)
|
|
(ycmd--start-server)
|
|
(ycmd--start-server-timeout-timer)
|
|
(ycmd--start-keepalive-timer))
|
|
|
|
(defun ycmd-close (&optional status)
|
|
"Shutdown any running ycmd server.
|
|
STATUS is a status symbol for `ycmd--report-status',
|
|
defaulting to `stopped'."
|
|
(interactive)
|
|
(ycmd--stop-server)
|
|
(ycmd--global-teardown)
|
|
(ycmd--kill-timer ycmd--keepalive-timer)
|
|
(ycmd--kill-timer ycmd--server-timeout-timer)
|
|
(ycmd--with-all-ycmd-buffers
|
|
(ycmd--report-status (or status 'stopped))))
|
|
|
|
(defun ycmd--stop-server ()
|
|
"Stop the ycmd server process.
|
|
|
|
Send a `shutdown' request to the ycmd server and wait for the
|
|
ycmd server to stop. If the ycmd server is still running after a
|
|
timeout specified by `ycmd-delete-process-delay', then kill the
|
|
process with `delete-process'."
|
|
(when (ycmd--server-alive-p)
|
|
(let ((start-time (float-time)))
|
|
(ycmd-deferred:sync!
|
|
(ycmd-deferred:timeout 0.1
|
|
(ycmd-with-handled-server-exceptions
|
|
(ycmd--request (make-ycmd-request-data
|
|
:handler "shutdown" :content nil))
|
|
:dont-show-exception-msg t)))
|
|
(while (and (ycmd-running-p)
|
|
(> ycmd-delete-process-delay
|
|
(- (float-time) start-time)))
|
|
(sit-for 0.05))))
|
|
(ignore-errors
|
|
(delete-process ycmd--server-process-name)))
|
|
|
|
(defun ycmd-running-p ()
|
|
"Return t if a ycmd server is already running."
|
|
(--when-let (get-process ycmd--server-process-name)
|
|
(and (processp it) (process-live-p it) t)))
|
|
|
|
(defun ycmd--server-alive-p ()
|
|
"Return t if server is running and ready for requests."
|
|
(and (ycmd-running-p) ycmd--server-actual-port))
|
|
|
|
(defmacro ycmd--ignore-errors (&rest body)
|
|
"Execute BODY and ignore errors and request errors."
|
|
`(let ((request-message-level -1)
|
|
(request-log-level -1))
|
|
(ignore-errors
|
|
,@body)))
|
|
|
|
(defun ycmd--keepalive ()
|
|
"Sends an unspecified message to the server.
|
|
|
|
This is simply for keepalive functionality."
|
|
(ycmd--ignore-errors
|
|
(ycmd-with-handled-server-exceptions
|
|
(ycmd--request (make-ycmd-request-data
|
|
:handler "healthy" :content nil)
|
|
:type "GET")
|
|
:dont-show-exception-msg t)))
|
|
|
|
(defun ycmd--server-ready-p (&optional include-subserver)
|
|
"Send request for server ready state.
|
|
|
|
If INCLUDE-SUBSERVER is non-nil, also request ready state for
|
|
semantic subserver."
|
|
(when (ycmd--server-alive-p)
|
|
(let* ((file-type
|
|
(and include-subserver
|
|
(car-safe (ycmd-major-mode-to-file-types
|
|
major-mode))))
|
|
(params (and file-type
|
|
(list (cons "subserver" file-type)))))
|
|
(ycmd--ignore-errors
|
|
(eq (ycmd-deferred:sync!
|
|
(ycmd-with-handled-server-exceptions
|
|
(ycmd--request
|
|
(make-ycmd-request-data :handler "ready" :content nil)
|
|
:params params :type "GET")
|
|
:dont-show-exception-msg t))
|
|
t)))))
|
|
|
|
(defun ycmd--extra-conf-request (filename &optional ignore-p)
|
|
"Send extra conf request.
|
|
FILENAME is the path to a ycm_extra_conf file. If optional
|
|
IGNORE-P is non-nil ignore the ycm_extra_conf."
|
|
(let ((handler (if ignore-p
|
|
"ignore_extra_conf_file"
|
|
"load_extra_conf_file"))
|
|
(content (list (cons "filepath" filename))))
|
|
(ycmd-deferred:sync!
|
|
(ycmd-with-handled-server-exceptions
|
|
(ycmd--request (make-ycmd-request-data
|
|
:handler handler :content content))))))
|
|
|
|
(defun ycmd-load-conf-file (filename)
|
|
"Tell the ycmd server to load the configuration file FILENAME."
|
|
(interactive
|
|
(list
|
|
(read-file-name "Filename: ")))
|
|
(let ((filename (expand-file-name filename)))
|
|
(ycmd--extra-conf-request filename)))
|
|
|
|
(defun ycmd-display-completions ()
|
|
"Get completions at the current point and display them in a buffer.
|
|
|
|
This is really a utility/debugging function for developers, but
|
|
it might be interesting for some users."
|
|
(interactive)
|
|
(ycmd-with-handled-server-exceptions (ycmd-get-completions)
|
|
(if (not response)
|
|
(message "No completions available")
|
|
(pop-to-buffer "*ycmd-completions*")
|
|
(erase-buffer)
|
|
(insert (pp-to-string response)))))
|
|
|
|
(defun ycmd-complete (&optional _ignored)
|
|
"Completion candidates at point."
|
|
(-when-let* ((completions (ycmd-deferred:sync!
|
|
(ycmd-deferred:timeout 0.5
|
|
(ycmd-with-handled-server-exceptions
|
|
(ycmd-get-completions)))))
|
|
(candidates (cdr (assq 'completions completions))))
|
|
(--map (let* ((text (cdr (assq 'insertion_text it)))
|
|
(anno (cdr (assq 'menu_text it))))
|
|
(when (and anno (string-match (regexp-quote text) anno))
|
|
(put-text-property
|
|
0 1 'anno (substring anno (match-end 0)) text))
|
|
text)
|
|
candidates)))
|
|
|
|
(defun ycmd-complete-at-point ()
|
|
"Complete symbol at point."
|
|
(unless (nth 3 (syntax-ppss)) ;; not in string
|
|
(let* ((bounds (bounds-of-thing-at-point 'symbol))
|
|
(beg (or (car bounds) (point)))
|
|
(end (or (cdr bounds) (point))))
|
|
(list beg end
|
|
(completion-table-dynamic #'ycmd-complete)
|
|
:annotation-function
|
|
(lambda (arg) (get-text-property 0 'anno arg))))))
|
|
|
|
(defun ycmd-toggle-force-semantic-completion ()
|
|
"Toggle whether to use always semantic completion.
|
|
|
|
Returns the new value of `ycmd-force-semantic-completion'."
|
|
(interactive)
|
|
(let ((force (not ycmd-force-semantic-completion)))
|
|
(message "ycmd: force semantic completion %s."
|
|
(if force "enabled" "disabled"))
|
|
(setq ycmd-force-semantic-completion force)))
|
|
|
|
(defun ycmd--string-list-p (obj)
|
|
"Return t if OBJ is a list of strings."
|
|
(and (listp obj) (-all? #'stringp obj)))
|
|
|
|
(defun ycmd--locate-default-tags-file (buffer)
|
|
"Look up directory hierarchy for first found default tags file for BUFFER."
|
|
(-when-let* ((file (buffer-file-name buffer))
|
|
(dir (and file
|
|
(locate-dominating-file
|
|
file ycmd-default-tags-file-name))))
|
|
(expand-file-name ycmd-default-tags-file-name dir)))
|
|
|
|
(defun ycmd--get-tag-files (buffer)
|
|
"Get tag files list for current BUFFER or nil."
|
|
(--when-let (cond ((eq ycmd-tag-files 'auto)
|
|
(ycmd--locate-default-tags-file buffer))
|
|
((or (stringp ycmd-tag-files)
|
|
(ycmd--string-list-p ycmd-tag-files))
|
|
ycmd-tag-files))
|
|
(unless (listp it)
|
|
(setq it (list it)))
|
|
(mapcar 'expand-file-name it)))
|
|
|
|
(defun ycmd--get-keywords (buffer)
|
|
"Get syntax keywords for BUFFER."
|
|
(with-current-buffer buffer
|
|
(let ((mode major-mode))
|
|
(unless (memq mode ycmd--mode-keywords-loaded)
|
|
(--when-let (and (functionp ycmd-get-keywords-function)
|
|
(funcall ycmd-get-keywords-function mode))
|
|
(when (ycmd--string-list-p it)
|
|
(add-to-list 'ycmd--mode-keywords-loaded mode)
|
|
it))))))
|
|
|
|
(defun ycmd--get-keywords-from-alist (mode)
|
|
"Get keywords from `ycmd-keywords-alist' for MODE."
|
|
(let ((symbols (cdr (assq mode ycmd-keywords-alist))))
|
|
(if (consp symbols)
|
|
symbols
|
|
(cdr (assq symbols ycmd-keywords-alist)))))
|
|
|
|
(defun ycmd-get-completions ()
|
|
"Get completions in current buffer from the ycmd server.
|
|
|
|
Returns a deferred object which yields the HTTP message
|
|
content. If completions are available, the structure looks like
|
|
this:
|
|
|
|
((error)
|
|
(completion_start_column . 6)
|
|
(completions
|
|
((kind . \"FUNCTION\")
|
|
(extra_menu_info . \"long double\")
|
|
(detailed_info . \"long double acoshl( long double )\\n\")
|
|
(insertion_text . \"acoshl\")
|
|
(menu_text . \"acoshl( long double )\"))
|
|
. . .))
|
|
|
|
If ycmd can't do completion because it's busy parsing, the
|
|
structure looks like this:
|
|
|
|
((message . \"Still parsing file, no completions yet.\")
|
|
(traceback . \"long traceback string\")
|
|
(exception
|
|
(TYPE . \"RuntimeError\")))
|
|
|
|
To see what the returned structure looks like, you can use
|
|
`ycmd-display-completions'."
|
|
(let ((extra-data (and ycmd-force-semantic-completion
|
|
(list (cons "force_semantic" t)))))
|
|
(ycmd--request (make-ycmd-request-data
|
|
:handler "completions"
|
|
:content (append (ycmd--get-basic-request-data)
|
|
extra-data)))))
|
|
|
|
(defun ycmd--command-request (subcommand)
|
|
"Send a command request for SUBCOMMAND."
|
|
(let* ((subcommand (if (listp subcommand)
|
|
subcommand
|
|
(list subcommand)))
|
|
(content (cons (append (list "command_arguments")
|
|
subcommand)
|
|
(ycmd--get-basic-request-data))))
|
|
(ycmd--request (make-ycmd-request-data
|
|
:handler "run_completer_command"
|
|
:content content))))
|
|
|
|
(defun ycmd--run-completer-command (subcommand success-handler)
|
|
"Send SUBCOMMAND to the `ycmd' server.
|
|
|
|
SUCCESS-HANDLER is called when for a successful response."
|
|
(declare (indent 1))
|
|
(when ycmd-mode
|
|
(let ((cmd (or (car-safe subcommand) subcommand)))
|
|
(if (ycmd-parsing-in-progress-p)
|
|
(message "Can't send \"%s\" request while parsing is in progress!" cmd)
|
|
(let ((pos (point)))
|
|
(ycmd-with-handled-server-exceptions (ycmd--command-request subcommand)
|
|
:bind-current-buffer t
|
|
:on-exception-form (run-hook-with-args 'ycmd-after-exception-hook
|
|
cmd request-buffer pos response)
|
|
(when (and response success-handler)
|
|
(funcall success-handler response))))))))
|
|
|
|
(defun ycmd--unsupported-subcommand-p (response)
|
|
"Return t if RESPONSE is an unsupported subcommand exception."
|
|
(let-alist response
|
|
(and (string= "ValueError" .exception.TYPE)
|
|
(or (string-prefix-p "Supported commands are:\n" .message)
|
|
(string= "This Completer has no supported subcommands."
|
|
.message)))))
|
|
|
|
(defun ycmd--get-defined-subcommands ()
|
|
"Get available subcommands for current completer.
|
|
This is a blocking request."
|
|
(let* ((data (make-ycmd-request-data
|
|
:handler "defined_subcommands")))
|
|
(ycmd-deferred:sync!
|
|
(ycmd-with-handled-server-exceptions (ycmd--request data)))))
|
|
|
|
(defun ycmd--get-prompt-for-subcommand (subcommand)
|
|
"Return promp for SUBCOMMAND that requires arguments."
|
|
(pcase subcommand
|
|
(`"RefactorRename"
|
|
"New name: ")
|
|
((pred (and "RestartServer" (eq major-mode 'python-mode)))
|
|
"Python binary: ")))
|
|
|
|
(defun ycmd--read-subcommand ()
|
|
"Read subcommand from minibuffer."
|
|
(--when-let (ycmd--get-defined-subcommands)
|
|
(funcall ycmd-completing-read-function
|
|
"Subcommand: " it nil t)))
|
|
|
|
(defun ycmd-completer (subcommand)
|
|
"Run SUBCOMMAND for current completer."
|
|
(interactive
|
|
(list (-when-let (cmd (ycmd--read-subcommand))
|
|
(--when-let (ycmd--get-prompt-for-subcommand cmd)
|
|
(let ((arg (read-string it)))
|
|
(unless (s-blank-str? arg)
|
|
(setq cmd (list cmd arg)))))
|
|
cmd)))
|
|
(when subcommand
|
|
(ycmd--run-completer-command subcommand
|
|
(lambda (response)
|
|
(cond ((not (listp response))
|
|
;; If not a list, the response is necessarily a scalar:
|
|
;; boolean, number, string, etc. In this case, we print it to
|
|
;; the user.
|
|
(message "%s" response))
|
|
((assq 'fixits response)
|
|
(ycmd--handle-fixit-response response))
|
|
((assq 'message response)
|
|
(ycmd--handle-message-response response))
|
|
((assq 'detailed_info response)
|
|
(ycmd--handle-detailed-info-response response))
|
|
(t
|
|
(ycmd--handle-goto-response response)))))))
|
|
|
|
(defun ycmd-goto ()
|
|
"Go to the definition or declaration of the symbol at current position."
|
|
(interactive)
|
|
(ycmd--goto "GoTo"))
|
|
|
|
(defun ycmd-goto-declaration ()
|
|
"Go to the declaration of the symbol at the current position."
|
|
(interactive)
|
|
(ycmd--goto "GoToDeclaration"))
|
|
|
|
(defun ycmd-goto-definition ()
|
|
"Go to the definition of the symbol at the current position."
|
|
(interactive)
|
|
(ycmd--goto "GoToDefinition"))
|
|
|
|
(defun ycmd-goto-implementation ()
|
|
"Go to the implementation of the symbol at the current position."
|
|
(interactive)
|
|
(ycmd--goto "GoToImplementation"))
|
|
|
|
(defun ycmd-goto-include ()
|
|
"Go to the include of the symbol at the current position."
|
|
(interactive)
|
|
(ycmd--goto "GoToInclude"))
|
|
|
|
(defun ycmd-goto-imprecise ()
|
|
"Fast implementation of Go To at the cost of precision.
|
|
Useful in case compile-time is considerable."
|
|
(interactive)
|
|
(ycmd--goto "GoToImprecise"))
|
|
|
|
(defun ycmd-goto-references ()
|
|
"Get references."
|
|
(interactive)
|
|
(ycmd--goto "GoToReferences"))
|
|
|
|
(defun ycmd-goto-type ()
|
|
"Go to the type of the symbol at the current position."
|
|
(interactive)
|
|
(ycmd--goto "GoToType"))
|
|
|
|
(defun ycmd--save-marker ()
|
|
"Save marker."
|
|
(push-mark)
|
|
(if (fboundp 'xref-push-marker-stack)
|
|
(xref-push-marker-stack)
|
|
(with-no-warnings
|
|
(ring-insert find-tag-marker-ring (point-marker)))))
|
|
|
|
(defun ycmd--location-data-p (response)
|
|
"Return t if RESPONSE is a GoTo location."
|
|
(and (assq 'filepath response)
|
|
(assq 'line_num response)
|
|
(assq 'column_num response)))
|
|
|
|
(defun ycmd--handle-goto-response (response)
|
|
"Handle a successfull GoTo RESPONSE."
|
|
(ycmd--save-marker)
|
|
(if (ycmd--location-data-p response)
|
|
(ycmd--goto-location response 'find-file)
|
|
(ycmd--view response major-mode)))
|
|
|
|
(defun ycmd--goto (type)
|
|
"Implementation of GoTo according to the request TYPE."
|
|
(save-excursion
|
|
(--when-let (bounds-of-thing-at-point 'symbol)
|
|
(goto-char (car it)))
|
|
(ycmd-completer type)))
|
|
|
|
(defun ycmd--goto-location (location find-function)
|
|
"Move cursor to LOCATION with FIND-FUNCTION.
|
|
|
|
LOCATION is a structure as returned from e.g. the various GoTo
|
|
commands."
|
|
(let-alist location
|
|
(when .filepath
|
|
(funcall find-function .filepath)
|
|
(goto-char (ycmd--col-line-to-position
|
|
.column_num .line_num)))))
|
|
|
|
(defun ycmd--goto-line (line)
|
|
"Go to LINE."
|
|
(goto-char (point-min))
|
|
(forward-line (1- line)))
|
|
|
|
(defun ycmd--col-line-to-position (col line &optional buffer)
|
|
"Convert COL and LINE into a position in the current buffer.
|
|
|
|
COL and LINE are expected to be as returned from ycmd, e.g. from
|
|
notify-file-ready. Apparently COL can be 0 sometimes, in which
|
|
case this function returns 0.
|
|
Use BUFFER if non-nil or `current-buffer'."
|
|
(let ((buff (or buffer (current-buffer))))
|
|
(if (= col 0)
|
|
0
|
|
(with-current-buffer buff
|
|
(ycmd--goto-line line)
|
|
(forward-char (- col 1))
|
|
(point)))))
|
|
|
|
(defun ycmd-clear-compilation-flag-cache ()
|
|
"Clear the compilation flags cache."
|
|
(interactive)
|
|
(ycmd-completer "ClearCompilationFlagCache"))
|
|
|
|
(defun ycmd-restart-semantic-server (&optional arg)
|
|
"Send request to restart the semantic completion backend server.
|
|
If ARG is non-nil and current `major-mode' is `python-mode',
|
|
prompt for the Python binary."
|
|
(interactive
|
|
(list (and current-prefix-arg
|
|
(eq major-mode 'python-mode)
|
|
(read-string "Python binary: "))))
|
|
(let ((subcommand "RestartServer"))
|
|
(unless (s-blank-str? arg)
|
|
(setq subcommand (list subcommand arg)))
|
|
(ycmd-completer subcommand)))
|
|
|
|
(cl-defun ycmd--fontify-code (code &optional (mode major-mode))
|
|
"Fontify CODE."
|
|
(cl-check-type mode function)
|
|
(if (not (stringp code))
|
|
code
|
|
(with-temp-buffer
|
|
(delay-mode-hooks (funcall mode))
|
|
(setq font-lock-mode t)
|
|
(funcall font-lock-function font-lock-mode)
|
|
(let ((inhibit-read-only t))
|
|
(erase-buffer)
|
|
(insert code)
|
|
(font-lock-default-fontify-region
|
|
(point-min) (point-max) nil))
|
|
(buffer-string))))
|
|
|
|
(defun ycmd--get-message (response)
|
|
"Extract message from RESPONSE.
|
|
Return a cons cell with the type or parent as car. If cdr is
|
|
non-nil, the result is a valid type or parent."
|
|
(--when-let (cdr (assq 'message response))
|
|
(pcase it
|
|
((or `"Unknown semantic parent"
|
|
`"Unknown type"
|
|
`"Internal error: cursor not valid"
|
|
`"Internal error: no translation unit")
|
|
(cons it nil))
|
|
(_ (cons it t)))))
|
|
|
|
(defun ycmd--handle-message-response (response)
|
|
"Handle a successful GetParent or GetType RESPONSE."
|
|
(--when-let (ycmd--get-message response)
|
|
(pcase-let ((`(,msg . ,is-type-p) it))
|
|
(message "%s" (if is-type-p
|
|
(ycmd--fontify-code msg)
|
|
msg)))))
|
|
|
|
(defun ycmd-get-parent ()
|
|
"Get semantic parent for symbol at point."
|
|
(interactive)
|
|
(ycmd-completer "GetParent"))
|
|
|
|
(defun ycmd-get-type (&optional arg)
|
|
"Get type for symbol at point.
|
|
If optional ARG is non-nil, get type without reparsing buffer."
|
|
(interactive "P")
|
|
(ycmd-completer (if arg "GetTypeImprecise" "GetType")))
|
|
|
|
;;; FixIts
|
|
|
|
(defmacro ycmd--loop-chunks-by-filename (spec &rest body)
|
|
"Loop over an alist of fixit chunks grouped by filepath.
|
|
Evaluate BODY with `it' bound to each car from FIXIT-CHUNKS, in
|
|
turn. The structure of `it' is a cons cell (FILEPATH CHUNK-LIST).
|
|
Then evaluate RESULT to get return value, default nil.
|
|
|
|
\(fn (FIXIT-CHUNKS [RESULT]) BODY...)"
|
|
(declare (indent 1) (debug ((form &optional form) body)))
|
|
`(let ((chunks-by-filepath
|
|
(--group-by (let-alist it .range.start.filepath)
|
|
,(car spec))))
|
|
(dolist (it chunks-by-filepath)
|
|
,@body)
|
|
,@(cdr spec)))
|
|
|
|
(defun ycmd--show-fixits (fixits &optional title)
|
|
"Select a buffer and display FIXITS.
|
|
Optional TITLE is shown on first line."
|
|
(let ((fixits-buffer (get-buffer-create "*ycmd-fixits*"))
|
|
(fixit-num 1))
|
|
(with-current-buffer fixits-buffer
|
|
(setq buffer-read-only nil)
|
|
(erase-buffer)
|
|
(when title (insert (propertize title 'face 'bold)))
|
|
(dolist (fixit fixits)
|
|
(let-alist fixit
|
|
(let* ((diffs (ycmd--get-fixit-diffs .chunks))
|
|
(multiple-fixits-p (> (length diffs) 1))
|
|
button-diff)
|
|
(dolist (diff diffs)
|
|
(pcase-let ((`(,diff-text . ,diff-path) diff))
|
|
(setq button-diff
|
|
(concat button-diff (when (or (s-blank-str? .text)
|
|
multiple-fixits-p)
|
|
(format "%s\n" diff-path))
|
|
(ycmd--fontify-code diff-text 'diff-mode) "\n"))))
|
|
(ycmd--insert-fixit-button
|
|
(concat (format "%d: %s\n" fixit-num .text) button-diff) .chunks)
|
|
(cl-incf fixit-num))))
|
|
(goto-char (point-min))
|
|
(when title (forward-line 1))
|
|
(ycmd-fixit-mode))
|
|
(pop-to-buffer fixits-buffer)
|
|
(setq next-error-last-buffer fixits-buffer)))
|
|
|
|
(defun ycmd--get-fixit-diffs (chunks)
|
|
"Return a list of diffs for CHUNKS.
|
|
Each diff is a list of the actual diff, the path of the file for
|
|
the diff and a flag whether to show the filepath as part of the
|
|
button text. The flag is set to t when there are multiple diff
|
|
chunks for the file."
|
|
(let (diffs)
|
|
(ycmd--loop-chunks-by-filename (chunks (nreverse diffs))
|
|
(pcase-let* ((`(,filepath . ,chunk) it)
|
|
(buffer (find-file-noselect filepath))
|
|
(buffertext (with-current-buffer buffer (buffer-string)))
|
|
(diff-buffer (with-temp-buffer
|
|
(insert buffertext)
|
|
(ycmd--replace-chunk-list chunk (current-buffer))
|
|
(diff-no-select buffer (current-buffer)
|
|
"-U0 --strip-trailing-cr" t))))
|
|
(with-current-buffer diff-buffer
|
|
(goto-char (point-min))
|
|
(unless (eobp)
|
|
(ignore-errors
|
|
(diff-beginning-of-hunk t))
|
|
(while (looking-at diff-hunk-header-re-unified)
|
|
(let* ((beg (point))
|
|
(end (diff-end-of-hunk))
|
|
(diff (buffer-substring-no-properties beg end)))
|
|
(push (cons diff filepath) diffs)))))))))
|
|
|
|
(define-button-type 'ycmd--fixit-button
|
|
'action #'ycmd--apply-fixit
|
|
'face nil)
|
|
|
|
(defun ycmd--insert-fixit-button (name fixit)
|
|
"Insert a button with NAME and FIXIT."
|
|
(insert-text-button
|
|
name
|
|
'type 'ycmd--fixit-button
|
|
'fixit fixit))
|
|
|
|
(defun ycmd--apply-fixit (button)
|
|
"Apply BUTTON's FixIt chunk."
|
|
(-when-let (chunks (button-get button 'fixit))
|
|
(ycmd--loop-chunks-by-filename (chunks)
|
|
(ycmd--replace-chunk-list (cdr it)))
|
|
(quit-window t (get-buffer-window "*ycmd-fixits*"))))
|
|
|
|
(define-derived-mode ycmd-fixit-mode ycmd-view-mode "ycmd-fixits"
|
|
"Major mode for viewing and navigation of fixits.
|
|
|
|
\\{ycmd-view-mode-map}"
|
|
(local-set-key (kbd "q") (lambda () (interactive) (quit-window t))))
|
|
|
|
(defun ycmd--replace-chunk (bounds replacement-text line-delta char-delta buffer)
|
|
"Replace text between BOUNDS with REPLACEMENT-TEXT.
|
|
|
|
BOUNDS is a list of two cons cells representing the start and end
|
|
of a chunk with a line and column pair (car and cdr). LINE-DELTA
|
|
and CHAR-DELTA are offset from -former replacements on the
|
|
current line. BUFFER is the current working buffer."
|
|
(pcase-let* ((`((,start-line . ,start-column) (,end-line . ,end-column)) bounds)
|
|
(start-line (+ start-line line-delta))
|
|
(end-line (+ end-line line-delta))
|
|
(source-line-count (1+ (- end-line start-line)))
|
|
(start-column (+ start-column char-delta))
|
|
(end-column (if (= source-line-count 1)
|
|
(+ end-column char-delta)
|
|
end-column))
|
|
(replacement-lines (s-split "\n" replacement-text))
|
|
(replacement-lines-count (length replacement-lines))
|
|
(new-line-delta (- replacement-lines-count source-line-count))
|
|
(new-char-delta (- (length (car (last replacement-lines)))
|
|
(- end-column start-column))))
|
|
(when (> replacement-lines-count 1)
|
|
(setq new-char-delta (- new-char-delta start-column)))
|
|
(save-excursion
|
|
(with-current-buffer buffer
|
|
(delete-region
|
|
(ycmd--col-line-to-position start-column start-line buffer)
|
|
(ycmd--col-line-to-position end-column end-line buffer))
|
|
(insert replacement-text)
|
|
(cons new-line-delta new-char-delta)))))
|
|
|
|
(defun ycmd--get-chunk-bounds (chunk)
|
|
"Get an list with bounds of CHUNK."
|
|
(let-alist chunk
|
|
(list (cons .range.start.line_num .range.start.column_num)
|
|
(cons .range.end.line_num .range.end.column_num))))
|
|
|
|
(defun ycmd--chunk-< (c1 c2)
|
|
"Return t if C1 should go before C2."
|
|
(pcase-let ((`((,line-num-1 . ,column-num-1) ,_) (ycmd--get-chunk-bounds c1))
|
|
(`((,line-num-2 . ,column-num-2) ,_) (ycmd--get-chunk-bounds c2)))
|
|
(or (< line-num-1 line-num-2)
|
|
(and (= line-num-1 line-num-2)
|
|
(< column-num-1 column-num-2)))))
|
|
|
|
(defun ycmd--replace-chunk-list (chunks &optional buffer)
|
|
"Replace list of CHUNKS.
|
|
|
|
If BUFFER is specified use it as working buffer, else use buffer
|
|
specified in fixit chunk."
|
|
(let ((chunks-sorted (sort chunks 'ycmd--chunk-<))
|
|
(last-line -1)
|
|
(line-delta 0)
|
|
(char-delta 0))
|
|
(dolist (c chunks-sorted)
|
|
(let-alist c
|
|
(pcase-let* ((chunk-bounds (ycmd--get-chunk-bounds c))
|
|
(`((,start-line . ,_) (,end-line . ,_)) chunk-bounds)
|
|
(buffer (or buffer (find-file-noselect
|
|
.range.start.filepath))))
|
|
(unless (= start-line last-line)
|
|
(setq last-line end-line)
|
|
(setq char-delta 0))
|
|
(pcase-let ((`(,new-line-delta . ,new-char-delta)
|
|
(ycmd--replace-chunk chunk-bounds .replacement_text
|
|
line-delta char-delta buffer)))
|
|
(setq line-delta (+ line-delta new-line-delta))
|
|
(setq char-delta (+ char-delta new-char-delta))))))))
|
|
|
|
(defun ycmd--fixits-have-same-location-p (fixits)
|
|
"Check if mutiple FIXITS have the same location."
|
|
(let ((fixits-by-location
|
|
(--group-by (cdr (assq 'location it)) fixits)))
|
|
(catch 'done
|
|
(dolist (f fixits-by-location)
|
|
(when (> (length (cdr f)) 1)
|
|
(throw 'done t))))))
|
|
|
|
(defun ycmd--handle-fixit-response (response)
|
|
"Handle a fixit RESPONSE."
|
|
(let ((fixits (cdr (assq 'fixits response))))
|
|
(if (not fixits)
|
|
(message "No fixits found for current line")
|
|
(let ((multiple-fixits-p
|
|
(and (> (length fixits) 1)
|
|
(ycmd--fixits-have-same-location-p fixits))))
|
|
(if (and (not ycmd-confirm-fixit) (not multiple-fixits-p))
|
|
(let ((num-changes-applied 0)
|
|
files-changed)
|
|
(dolist (fixit fixits)
|
|
(-when-let (chunks (cdr (assq 'chunks fixit)))
|
|
(ycmd--loop-chunks-by-filename (chunks)
|
|
(pcase-let ((`(,chunk-path . ,chunk) it))
|
|
(ycmd--replace-chunk-list chunk)
|
|
(cl-incf num-changes-applied (length chunk))
|
|
(unless (member chunk-path files-changed)
|
|
(setq files-changed (append (list chunk-path)
|
|
files-changed)))))))
|
|
(when (> num-changes-applied 0)
|
|
(let* ((num-files-changed (length files-changed))
|
|
(text
|
|
(concat (format "Applied %d changes" num-changes-applied)
|
|
(when (> num-files-changed 1)
|
|
(format " in %d files" num-files-changed)))))
|
|
(message text))))
|
|
(save-current-buffer
|
|
(ycmd--show-fixits
|
|
fixits (and multiple-fixits-p
|
|
(concat
|
|
"Multiple FixIt suggestions are available at this location."
|
|
"Which one would you like to apply?\n")))))))))
|
|
|
|
(defun ycmd-fixit()
|
|
"Get FixIts for current line."
|
|
(interactive)
|
|
(ycmd-completer "FixIt"))
|
|
|
|
(defun ycmd-refactor-rename (new-name)
|
|
"Refactor current context with NEW-NAME."
|
|
(interactive "MNew variable name: ")
|
|
(let ((subcommand "RefactorRename"))
|
|
(unless (s-blank-str? new-name)
|
|
(setq subcommand (list subcommand new-name)))
|
|
(ycmd-completer subcommand)))
|
|
|
|
(defun ycmd-show-documentation (&optional arg)
|
|
"Show documentation for current point in buffer.
|
|
|
|
If optional ARG is non-nil do not reparse buffer before getting
|
|
the documentation."
|
|
(interactive "P")
|
|
(ycmd-completer (if arg "GetDocImprecise" "GetDoc")))
|
|
|
|
(defun ycmd--handle-detailed-info-response (response)
|
|
"Handle successful GetDoc RESPONSE."
|
|
(let ((documentation (cdr (assq 'detailed_info response))))
|
|
(if (not (s-blank? documentation))
|
|
(with-help-window (get-buffer-create " *ycmd-documentation*")
|
|
(with-current-buffer standard-output
|
|
(insert documentation)))
|
|
(message "No documentation available for current context"))))
|
|
|
|
(defmacro ycmd--with-view-buffer (&rest body)
|
|
"Create view buffer and execute BODY in it."
|
|
`(let ((buf (get-buffer-create "*ycmd-locations*")))
|
|
(with-current-buffer buf
|
|
(setq buffer-read-only nil)
|
|
(erase-buffer)
|
|
,@body
|
|
(goto-char (point-min))
|
|
(ycmd-view-mode)
|
|
buf)))
|
|
|
|
(defun ycmd--view (response mode)
|
|
"Select `ycmd-view-mode' buffer and display items from RESPONSE.
|
|
MODE is a major mode for fontifaction."
|
|
(let ((view-buffer
|
|
(ycmd--with-view-buffer
|
|
(->>
|
|
(--group-by (cdr (assq 'filepath it)) response)
|
|
(mapc (lambda (it) (ycmd--view-insert-location it mode)))))))
|
|
(pop-to-buffer view-buffer)
|
|
(setq next-error-last-buffer view-buffer)))
|
|
|
|
(define-button-type 'ycmd--location-button
|
|
'action #'ycmd--view-jump
|
|
'face nil)
|
|
|
|
(defun ycmd--view-jump (button)
|
|
"Jump to BUTTON's location in current window."
|
|
(let ((location (button-get button 'location)))
|
|
(ycmd--goto-location location 'find-file)))
|
|
|
|
(defun ycmd--view-jump-other-window (button)
|
|
"Jump to BUTTON's location in other window."
|
|
(let ((location (button-get button 'location)))
|
|
(ycmd--goto-location location 'find-file-other-window)))
|
|
|
|
(defun ycmd--view-insert-button (name location)
|
|
"Insert a view button with NAME and LOCATION."
|
|
(insert-text-button
|
|
name
|
|
'type 'ycmd--location-button
|
|
'location location))
|
|
|
|
(defun ycmd--get-line-from-location (location)
|
|
"Return line from LOCATION."
|
|
(let-alist location
|
|
(--when-let (and .filepath (find-file-noselect .filepath))
|
|
(with-current-buffer it
|
|
(goto-char (ycmd--col-line-to-position
|
|
.column_num .line_num))
|
|
(back-to-indentation)
|
|
(buffer-substring (point) (line-end-position))))))
|
|
|
|
(defun ycmd--view-insert-location (location-group mode)
|
|
"Insert LOCATION-GROUP into `current-buffer' and fontify according MODE.
|
|
LOCATION-GROUP is a cons cell whose car is the filepath and the whose
|
|
cdr is a list of location objects."
|
|
(pcase-let* ((`(,filepath . ,locations) location-group)
|
|
(max-line-num-width
|
|
(cl-loop for location in locations
|
|
maximize (let ((line-num (cdr (assq 'line_num location))))
|
|
(and line-num (length (format "%d" line-num))))))
|
|
(line-num-format (and max-line-num-width
|
|
(format "%%%dd:" max-line-num-width))))
|
|
(insert (propertize (concat filepath "\n") 'face 'bold))
|
|
(mapc (lambda (it)
|
|
(let-alist it
|
|
(when line-num-format
|
|
(insert (format line-num-format .line_num)))
|
|
(insert " ")
|
|
(let ((description (or (and (not (s-blank? .description))
|
|
(s-trim-left .description))
|
|
(ycmd--get-line-from-location it))))
|
|
(ycmd--view-insert-button
|
|
(ycmd--fontify-code (or description "") mode) it))
|
|
(insert "\n")))
|
|
locations)))
|
|
|
|
(defvar ycmd-view-mode-map
|
|
(let ((map (make-sparse-keymap)))
|
|
(define-key map (kbd "n") 'next-error-no-select)
|
|
(define-key map (kbd "p") 'previous-error-no-select)
|
|
(define-key map (kbd "q") 'quit-window)
|
|
map))
|
|
|
|
(define-derived-mode ycmd-view-mode special-mode "ycmd-view"
|
|
"Major mode for locations view and navigation for `ycmd-mode'.
|
|
|
|
\\{ycmd-view-mode-map}"
|
|
(setq next-error-function #'ycmd--next-location))
|
|
|
|
(defun ycmd--next-location (num _reset)
|
|
"Navigate to the next location in the view buffer.
|
|
NUM is the number of locations to move forward. If RESET is
|
|
non-nil got to the beginning of buffer before locations
|
|
navigation."
|
|
(forward-button num)
|
|
(ycmd--view-jump-other-window (button-at (point))))
|
|
|
|
(define-button-type 'ycmd--error-button
|
|
'face '(error bold underline)
|
|
'button 't)
|
|
|
|
(define-button-type 'ycmd--warning-button
|
|
'face '(warning bold underline)
|
|
'button 't)
|
|
|
|
(defun ycmd--make-button (start end type msg)
|
|
"Make a button from START to END of TYPE in the current buffer.
|
|
|
|
When clicked, MSG will be shown in the minibuffer."
|
|
(make-text-button
|
|
start end
|
|
'type type
|
|
'action (lambda (_) (message msg))))
|
|
|
|
(defconst ycmd--file-ready-buttons
|
|
'(("ERROR" . ycmd--error-button)
|
|
("WARNING" . ycmd--warning-button))
|
|
"A mapping from parse 'kind' to button types.")
|
|
|
|
(defun ycmd--line-start-position (line)
|
|
"Find position at the start of LINE."
|
|
(save-excursion
|
|
(ycmd--goto-line line)
|
|
(beginning-of-line)
|
|
(point)))
|
|
|
|
(defun ycmd--line-end-position (line)
|
|
"Find position at the end of LINE."
|
|
(save-excursion
|
|
(ycmd--goto-line line)
|
|
(end-of-line)
|
|
(point)))
|
|
|
|
(defun ycmd--decorate-single-parse-result (result)
|
|
"Decorates a buffer based on the contents of a single parse RESULT.
|
|
|
|
This is a fairly crude form of decoration, but it does give
|
|
reasonable visual feedback on the problems found by ycmd."
|
|
(let-alist result
|
|
(--when-let (find-buffer-visiting .location.filepath)
|
|
(with-current-buffer it
|
|
(let* ((start-pos (ycmd--line-start-position .location.line_num))
|
|
(end-pos (ycmd--line-end-position .location.line_num))
|
|
(btype (cdr (assoc .kind ycmd--file-ready-buttons))))
|
|
(when btype
|
|
(with-silent-modifications
|
|
(ycmd--make-button
|
|
start-pos end-pos
|
|
btype (concat .kind ": " .text
|
|
(when (eq .fixit_available t)
|
|
" (FixIt available)"))))))))))
|
|
|
|
(defun ycmd-decorate-with-parse-results (results)
|
|
"Decorates a buffer using the RESULTS of a file-ready parse list.
|
|
|
|
This is suitable as an entry in `ycmd-file-parse-result-hook'."
|
|
(with-silent-modifications
|
|
(set-text-properties (point-min) (point-max) nil))
|
|
(mapc 'ycmd--decorate-single-parse-result results)
|
|
results)
|
|
|
|
(defun ycmd--display-single-file-parse-result (result)
|
|
"Insert a single file parse RESULT."
|
|
(let-alist result
|
|
(insert (format "%s:%s - %s - %s\n"
|
|
.location.filepath .location.line_num
|
|
.kind .text))))
|
|
|
|
(defun ycmd-display-file-parse-results (results)
|
|
"Display parse RESULTS in a buffer."
|
|
(let ((buffer "*ycmd-file-parse-results*"))
|
|
(get-buffer-create buffer)
|
|
(with-current-buffer buffer
|
|
(erase-buffer)
|
|
(mapc 'ycmd--display-single-file-parse-result results))
|
|
(display-buffer buffer)))
|
|
|
|
(defun ycmd-parse-buffer ()
|
|
"Parse buffer."
|
|
(interactive)
|
|
(if (not (ycmd-semantic-completer-available-p))
|
|
(message "Native filetype completion not supported for current file, \
|
|
cannot send parse request")
|
|
(when (ycmd--server-alive-p)
|
|
(let ((buffer (current-buffer)))
|
|
(deferred:$
|
|
(deferred:next
|
|
(lambda ()
|
|
(message "Parsing buffer...")
|
|
(ycmd--reset-parse-status)
|
|
(ycmd--conditional-parse)))
|
|
(deferred:nextc it
|
|
(lambda ()
|
|
(with-current-buffer buffer
|
|
(when (eq ycmd--last-status-change 'parsed)
|
|
(message "Parsing buffer done"))))))))))
|
|
|
|
(defun ycmd--handle-extra-conf-exception (conf-file)
|
|
"Handle an exception of type `UnknownExtraConf'.
|
|
|
|
Handle CONF-FILE according the value of `ycmd-extra-conf-handler'."
|
|
(if (not conf-file)
|
|
(warn "No extra_conf_file included in UnknownExtraConf exception. \
|
|
Consider reporting this.")
|
|
(let ((ignore-p (or (eq ycmd-extra-conf-handler 'ignore)
|
|
(not (y-or-n-p (format "Load YCMD extra conf %s? "
|
|
conf-file))))))
|
|
(ycmd--extra-conf-request conf-file ignore-p)
|
|
(ycmd--reset-parse-status)
|
|
(ycmd-notify-file-ready-to-parse))))
|
|
|
|
(defun ycmd--event-notification (event-name &optional extra-data)
|
|
"Send a event notification for EVENT-NAME.
|
|
Optional EXTRA-DATA contains additional data for the request."
|
|
(let ((content (append (list (cons "event_name" event-name))
|
|
(ycmd--get-basic-request-data)
|
|
extra-data)))
|
|
(deferred:try
|
|
(ycmd--request (make-ycmd-request-data
|
|
:handler "event_notification"
|
|
:content content))
|
|
:catch
|
|
(lambda (err)
|
|
(message "Error sending %s request: %s" event-name err)
|
|
(ycmd--report-status 'errored)
|
|
nil))))
|
|
|
|
(defun ycmd-notify-file-ready-to-parse ()
|
|
"Send a notification to ycmd that the buffer is ready to be parsed.
|
|
|
|
Only one active notification is allowed per buffer, and this
|
|
function enforces that constraint.
|
|
|
|
The response of the notification are passed to all of the
|
|
functions in `ycmd-file-parse-result-hook'."
|
|
(when (and ycmd-mode (not (ycmd-parsing-in-progress-p)))
|
|
(ycmd-with-handled-server-exceptions
|
|
(let ((extra-data
|
|
(append (--when-let (and ycmd-tag-files
|
|
(ycmd--get-tag-files request-buffer))
|
|
(list (cons "tag_files" it)))
|
|
(--when-let (and ycmd-seed-identifiers-with-keywords
|
|
(ycmd--get-keywords request-buffer))
|
|
(list (cons "syntax_keywords" it))))))
|
|
(ycmd--report-status 'parsing)
|
|
(ycmd--event-notification "FileReadyToParse" extra-data))
|
|
:bind-current-buffer t
|
|
:on-exception-form (ycmd--report-status 'errored)
|
|
(ycmd--report-status 'parsed)
|
|
(run-hook-with-args 'ycmd-file-parse-result-hook response))))
|
|
|
|
(defun ycmd-major-mode-to-file-types (mode)
|
|
"Map a major mode MODE to a list of file-types suitable for ycmd.
|
|
|
|
If there is no established mapping, return nil."
|
|
(cdr (assq mode ycmd-file-type-map)))
|
|
|
|
(defun ycmd--on-server-timeout ()
|
|
"Kill server process due to timeout."
|
|
(ycmd-close 'errored)
|
|
(message "ERROR: Ycmd server timeout. If this happens regularly you may need to increase `ycmd-startup-timeout'."))
|
|
|
|
(defun ycmd--start-server-timeout-timer ()
|
|
"Start the server timeout timer."
|
|
(ycmd--kill-timer ycmd--server-timeout-timer)
|
|
(setq ycmd--server-timeout-timer
|
|
(run-with-timer
|
|
ycmd-startup-timeout nil
|
|
#'ycmd--on-server-timeout)))
|
|
|
|
(defun ycmd--start-keepalive-timer ()
|
|
"Kill any existing keepalive timer and start a new one."
|
|
(ycmd--kill-timer ycmd--keepalive-timer)
|
|
(setq ycmd--keepalive-timer
|
|
(run-with-timer
|
|
ycmd-keepalive-period
|
|
ycmd-keepalive-period
|
|
#'ycmd--keepalive)))
|
|
|
|
(defun ycmd--generate-hmac-secret ()
|
|
"Generate a new, random 16-byte HMAC secret key."
|
|
(let ((result '()))
|
|
(dotimes (_ 16 result)
|
|
(setq result (cons (byte-to-string (random 256)) result)))
|
|
(apply 'concat result)))
|
|
|
|
(defun ycmd--json-encode (obj)
|
|
"Encode a json object OBJ.
|
|
A version of json-encode that uses {} instead of null for nil values.
|
|
This produces output for empty alists that ycmd expects."
|
|
(cl-letf (((symbol-function 'json-encode-keyword)
|
|
(lambda (k) (cond ((eq k t) "true")
|
|
((eq k json-false) "false")
|
|
((eq k json-null) "{}")))))
|
|
(json-encode obj)))
|
|
|
|
;; This defines 'ycmd--hmac-function which we use to combine an HMAC
|
|
;; key and message contents.
|
|
(defun ycmd--secure-hash (x)
|
|
"Generate secure sha256 hash of X."
|
|
(secure-hash 'sha256 x nil nil 1))
|
|
(define-hmac-function ycmd--hmac-function
|
|
ycmd--secure-hash 64 64)
|
|
|
|
(defun ycmd--options-contents (hmac-secret)
|
|
"Return a struct with ycmd options and the HMAC-SECRET applied.
|
|
The struct can be json encoded into a file to create a ycmd
|
|
options file.
|
|
|
|
When we start a new ycmd server, it needs an options file. It
|
|
reads this file and then deletes it since it contains a secret
|
|
key. So we need to generate a new options file for each ycmd
|
|
instance. This function effectively produces the contents of that
|
|
file."
|
|
(let ((hmac-secret (base64-encode-string hmac-secret))
|
|
(global-config (or ycmd-global-config ""))
|
|
(extra-conf-whitelist (or ycmd-extra-conf-whitelist []))
|
|
(confirm-extra-conf (if (eq ycmd-extra-conf-handler 'load) 0 1))
|
|
(gocode-binary-path (or ycmd-gocode-binary-path ""))
|
|
(godef-binary-path (or ycmd-godef-binary-path ""))
|
|
(rust-src-path (or ycmd-rust-src-path ""))
|
|
(swift-src-path (or ycmd-swift-src-path ""))
|
|
(racerd-binary-path (or ycmd-racerd-binary-path ""))
|
|
(python-binary-path (or ycmd-python-binary-path ""))
|
|
(auto-trigger (if ycmd-auto-trigger-semantic-completion 1 0)))
|
|
`((filepath_completion_use_working_dir . 0)
|
|
(auto_trigger . ,auto-trigger)
|
|
(min_num_of_chars_for_completion . ,ycmd-min-num-chars-for-completion)
|
|
(min_num_identifier_candidate_chars . 0)
|
|
(semantic_triggers . ())
|
|
(filetype_specific_completion_to_disable (gitcommit . 1))
|
|
(collect_identifiers_from_comments_and_strings . 0)
|
|
(max_num_identifier_candidates . ,ycmd-max-num-identifier-candidates)
|
|
(extra_conf_globlist . ,extra-conf-whitelist)
|
|
(global_ycm_extra_conf . ,global-config)
|
|
(confirm_extra_conf . ,confirm-extra-conf)
|
|
(max_diagnostics_to_display . 30)
|
|
(auto_start_csharp_server . 1)
|
|
(auto_stop_csharp_server . 1)
|
|
(use_ultisnips_completer . 1)
|
|
(csharp_server_port . 0)
|
|
(hmac_secret . ,hmac-secret)
|
|
(server_keep_logfiles . 1)
|
|
(gocode_binary_path . ,gocode-binary-path)
|
|
(godef_binary_path . ,godef-binary-path)
|
|
(rust_src_path . ,rust-src-path)
|
|
(swift_src_path . ,swift-src-path)
|
|
(racerd_binary_path . ,racerd-binary-path)
|
|
(python_binary_path . ,python-binary-path))))
|
|
|
|
(defun ycmd--create-options-file (hmac-secret)
|
|
"Create a new options file for a ycmd server with HMAC-SECRET.
|
|
|
|
This creates a new tempfile and fills it with options. Returns
|
|
the name of the newly created file."
|
|
(let ((options-file (make-temp-file "ycmd-options"))
|
|
(options (ycmd--options-contents hmac-secret)))
|
|
(with-temp-file options-file
|
|
(insert (ycmd--json-encode options)))
|
|
options-file))
|
|
|
|
(defun ycmd--exit-code-as-string (code)
|
|
"Return exit status message for CODE."
|
|
(pcase code
|
|
(`3 "unexpected error while loading ycm_core.")
|
|
(`4 (concat "ycm_core library not detected; "
|
|
"you need to compile it by running the "
|
|
"build.py script. See the documentation "
|
|
"for more details."))
|
|
(`5 (concat "ycm_core library compiled for Python 2 "
|
|
"but loaded in Python 3."))
|
|
(`6 (concat "ycm_core library compiled for Python 3 "
|
|
"but loaded in Python 2."))
|
|
(`7 (concat "ycm_core library too old; "
|
|
"PLEASE RECOMPILE by running the build.py "
|
|
"script. See the documentation for more details."))))
|
|
|
|
(defun ycmd--server-process-sentinel (process event)
|
|
"Handle Ycmd server PROCESS EVENT."
|
|
(when (memq (process-status process) '(exit signal))
|
|
(let* ((code (process-exit-status process))
|
|
(status (if (eq code 0) 'stopped 'errored)))
|
|
(when (eq status 'errored)
|
|
(--if-let (and (eq (process-status process) 'exit)
|
|
(ycmd--exit-code-as-string code))
|
|
(message "Ycmd server error: %s" it)
|
|
(message "Ycmd server %s" (s-replace "\n" "" event))))
|
|
(ycmd--with-all-ycmd-buffers
|
|
(ycmd--report-status status))
|
|
(ycmd--kill-timer ycmd--keepalive-timer))))
|
|
|
|
(defun ycmd--server-process-filter (process string)
|
|
"Filter function for the Ycmd server PROCESS output STRING."
|
|
;; insert string into process-buffer
|
|
(when (buffer-live-p (process-buffer process))
|
|
(with-current-buffer (process-buffer process)
|
|
(let ((moving (= (point) (process-mark process))))
|
|
(save-excursion
|
|
(goto-char (process-mark process))
|
|
(let ((inhibit-read-only t))
|
|
(insert-before-markers string))
|
|
(set-marker (process-mark process) (point)))
|
|
(when moving (goto-char (process-mark process))))))
|
|
;; parse port from server output
|
|
(when (and (not ycmd--server-actual-port)
|
|
(string-match "^serving on http://.*:\\\([0-9]+\\\)$"
|
|
string))
|
|
(ycmd--kill-timer ycmd--server-timeout-timer)
|
|
(setq ycmd--server-actual-port
|
|
(string-to-number (match-string 1 string)))
|
|
(ycmd--with-all-ycmd-buffers
|
|
(ycmd--reset-parse-status))
|
|
(ycmd--perform-deferred-parse)))
|
|
|
|
(defun ycmd--get-process-environment ()
|
|
"Return `process-evironment'.
|
|
If `ycmd-bypass-url-proxy-services' is non-nil, prepend
|
|
`no_proxy' variable to environment."
|
|
(or ycmd--process-environment
|
|
(setq ycmd--process-environment
|
|
(append (and ycmd-bypass-url-proxy-services
|
|
(not (or (getenv "NO_PROXY")
|
|
(getenv "no_PROXY")
|
|
(getenv "no_proxy")))
|
|
(list (concat "NO_PROXY=" ycmd-host)))
|
|
process-environment))))
|
|
|
|
(defun ycmd--start-server ()
|
|
"Start a new server and return the process."
|
|
(unless ycmd-server-command
|
|
(user-error "Error: The variable `ycmd-server-command' is not set. \
|
|
See the docstring of the variable for an example"))
|
|
(let ((proc-buff (get-buffer-create ycmd--server-buffer-name)))
|
|
(with-current-buffer proc-buff
|
|
(setq buffer-read-only t)
|
|
(let ((inhibit-read-only t))
|
|
(buffer-disable-undo)
|
|
(erase-buffer)))
|
|
(setq ycmd--process-environment nil)
|
|
(let* ((port (and (numberp ycmd-server-port)
|
|
(> ycmd-server-port 0)
|
|
ycmd-server-port))
|
|
(hmac-secret (ycmd--generate-hmac-secret))
|
|
(options-file (ycmd--create-options-file hmac-secret))
|
|
(args (append (and port (list (format "--port=%d" port)))
|
|
(list (concat "--options_file=" options-file))
|
|
ycmd-server-args))
|
|
(server-program+args (append ycmd-server-command args))
|
|
(process-environment (ycmd--get-process-environment))
|
|
(proc (apply #'start-process ycmd--server-process-name proc-buff
|
|
server-program+args)))
|
|
(ycmd--with-all-ycmd-buffers
|
|
(ycmd--report-status 'starting))
|
|
(setq ycmd--server-actual-port nil
|
|
ycmd--hmac-secret hmac-secret)
|
|
(set-process-query-on-exit-flag proc nil)
|
|
(set-process-sentinel proc #'ycmd--server-process-sentinel)
|
|
(set-process-filter proc #'ycmd--server-process-filter)
|
|
proc)))
|
|
|
|
(defun ycmd-wait-until-server-is-ready (&optional include-subserver)
|
|
"Wait until server is ready.
|
|
If INCLUDE-SUBSERVER is non-nil wait until subserver is ready.
|
|
Return t when server is ready. Signal error in case of timeout.
|
|
The timeout can be set with the variable
|
|
`ycmd-startup-timeout'."
|
|
(catch 'ready
|
|
(let ((server-start-time (float-time)))
|
|
(ycmd--kill-timer ycmd--server-timeout-timer)
|
|
(while (ycmd-running-p)
|
|
(sit-for 0.1)
|
|
(if (ycmd--server-ready-p include-subserver)
|
|
(progn
|
|
(ycmd--with-all-ycmd-buffers
|
|
(ycmd--reset-parse-status))
|
|
(throw 'ready t))
|
|
;; timeout after specified period
|
|
(when (< ycmd-startup-timeout
|
|
(- (float-time) server-start-time))
|
|
(ycmd--on-server-timeout)))))))
|
|
|
|
(defun ycmd--column-in-bytes ()
|
|
"Calculate column offset in bytes for the current position and buffer."
|
|
(- (position-bytes (point))
|
|
(position-bytes (line-beginning-position))))
|
|
|
|
;; https://github.com/abingham/emacs-ycmd/issues/165
|
|
(eval-and-compile
|
|
(if (version-list-< (version-to-list emacs-version) '(25))
|
|
(defun ycmd--encode-string (s) s)
|
|
(defun ycmd--encode-string (s) (encode-coding-string s 'utf-8 t))))
|
|
|
|
(defun ycmd--get-basic-request-data ()
|
|
"Build the basic request data alist for a server request."
|
|
(let* ((column-num (+ 1 (ycmd--column-in-bytes)))
|
|
(line-num (line-number-at-pos (point)))
|
|
(full-path (ycmd--encode-string (or (buffer-file-name) "")))
|
|
(file-contents (ycmd--encode-string
|
|
(buffer-substring-no-properties
|
|
(point-min) (point-max))))
|
|
(file-types (or (ycmd-major-mode-to-file-types major-mode)
|
|
'("generic"))))
|
|
`(("file_data" .
|
|
((,full-path . (("contents" . ,file-contents)
|
|
("filetypes" . ,file-types)))))
|
|
("filepath" . ,full-path)
|
|
("line_num" . ,line-num)
|
|
("column_num" . ,column-num))))
|
|
|
|
|
|
(defvar ycmd--log-enabled nil
|
|
"If non-nil, http content will be logged.
|
|
This is useful for debugging.")
|
|
|
|
(defun ycmd-toggle-log-enabled ()
|
|
"Toggle `ycmd--log-enabled' variable."
|
|
(interactive)
|
|
(let ((log-enabled (not ycmd--log-enabled)))
|
|
(message "Ycmd Log %s" (if log-enabled "enabled" "disabled"))
|
|
(setq ycmd--log-enabled log-enabled)))
|
|
|
|
(defun ycmd--log-content (header content)
|
|
"Insert log with HEADER and CONTENT in a buffer."
|
|
(when ycmd--log-enabled
|
|
(let ((buffer (get-buffer-create "*ycmd-content-log*")))
|
|
(with-current-buffer buffer
|
|
(save-excursion
|
|
(goto-char (point-max))
|
|
(insert (format "\n%s\n\n" header))
|
|
(insert (pp-to-string content)))))))
|
|
|
|
(defun ycmd-show-debug-info ()
|
|
"Show debug information."
|
|
(interactive)
|
|
(let ((data (make-ycmd-request-data :handler "debug_info"))
|
|
(buffer (current-buffer)))
|
|
(with-help-window (get-buffer-create " *ycmd-debug-info*")
|
|
(with-current-buffer standard-output
|
|
(princ "Ycmd debug information for buffer ")
|
|
(insert (propertize (buffer-name buffer) 'face 'bold))
|
|
(princ " in ")
|
|
(let ((mode (buffer-local-value 'major-mode buffer)))
|
|
(insert-button (symbol-name mode)
|
|
'type 'help-function
|
|
'help-args (list mode)))
|
|
(princ ":\n\n")
|
|
(--if-let (and (ycmd--server-alive-p)
|
|
(ycmd-deferred:sync!
|
|
(ycmd-with-handled-server-exceptions
|
|
(ycmd--request data))))
|
|
(pp it)
|
|
(princ "No debug info available from server"))
|
|
(princ "\n\n")
|
|
(princ "Server is ")
|
|
(let ((running (ycmd--server-alive-p)))
|
|
(insert (propertize (if running "running" "not running")
|
|
'face (if running 'success '(warning bold))))
|
|
(when running
|
|
(insert
|
|
(format " at: %s:%d" ycmd-host ycmd--server-actual-port))))
|
|
(princ "\n\n")
|
|
(princ "Ycmd Mode is ")
|
|
(let ((enabled (buffer-local-value 'ycmd-mode buffer)))
|
|
(insert (propertize (if enabled "enabled" "disabled")
|
|
'face (if enabled 'success '(warning bold)))))
|
|
(save-excursion
|
|
(let ((end (point)))
|
|
(backward-paragraph)
|
|
(fill-region-as-paragraph (point) end)))
|
|
|
|
(princ "\n\n--------------------\n\n")
|
|
(princ (format "Ycmd version: %s\n" (ignore-errors (ycmd-version))))
|
|
(princ (format "Emacs version: %s\n" emacs-version))
|
|
(princ (format "System: %s\n" system-configuration))
|
|
(princ (format "Window system: %S\n" window-system))))))
|
|
|
|
(defun ycmd-filter-and-sort-candidates (request-data)
|
|
"Use ycmd to filter and sort identifiers from REQUEST-DATA.
|
|
|
|
This request allows to use ycmd's filtering and sorting
|
|
mechanism on arbitrary sets of identifiers.
|
|
|
|
The request data should be something like:
|
|
|
|
\((candidates \"candidate1\" \"candidate2\")
|
|
(sort_property . \"\")
|
|
(query . \"cand\"))
|
|
|
|
If candidates is a list with identifiers, sort_property should be
|
|
and empty string, however when candidates is a more complex
|
|
structure it is used to specify the sort key."
|
|
(let ((data (make-ycmd-request-data
|
|
:handler "filter_and_sort_candidates"
|
|
:content request-data)))
|
|
(ycmd-deferred:sync!
|
|
(ycmd-with-handled-server-exceptions (ycmd--request data)))))
|
|
|
|
(defun ycmd--send-completer-available-request (&optional mode)
|
|
"Send request to check if a semantic completer exists for MODE.
|
|
Response is non-nil if semantic complettion is available."
|
|
(let ((data (make-ycmd-request-data
|
|
:handler "semantic_completion_available")))
|
|
(when mode
|
|
(let* ((buffer (current-buffer))
|
|
(full-path (ycmd--encode-string (or (buffer-file-name buffer) "")))
|
|
(content (ycmd-request-data-content data))
|
|
(file-types (assoc "filetypes"
|
|
(assoc full-path
|
|
(assoc "file_data" content)))))
|
|
(when (consp file-types)
|
|
(setcdr file-types (ycmd-major-mode-to-file-types mode)))))
|
|
(ycmd-deferred:sync!
|
|
(ycmd-with-handled-server-exceptions (ycmd--request data)))))
|
|
|
|
(defun ycmd-semantic-completer-available-p ()
|
|
"Return t if a semantic completer is available for current `major-mode'."
|
|
(let ((mode major-mode))
|
|
(or (gethash mode ycmd--available-completers)
|
|
(--when-let (ycmd--send-completer-available-request mode)
|
|
(puthash mode (or (eq it t) 'none) ycmd--available-completers)))))
|
|
|
|
(defun ycmd--get-request-hmac (method path body)
|
|
"Generate HMAC for request from METHOD, PATH and BODY."
|
|
(ycmd--hmac-function
|
|
(mapconcat (lambda (val)
|
|
(ycmd--hmac-function
|
|
(ycmd--encode-string val) ycmd--hmac-secret))
|
|
`(,method ,path ,(or body "")) "")
|
|
ycmd--hmac-secret))
|
|
|
|
(cl-defstruct ycmd-request-data
|
|
"Structure for storing the ycmd server request data.
|
|
|
|
Slots:
|
|
|
|
`handler'
|
|
Specifies the the path portion of the URL. For example, if
|
|
HANDLER is 'feed_llama', the request URL is
|
|
'http://host:port/feed_llama'.
|
|
|
|
`content'
|
|
An alist that will be JSON-encoded and sent over at the
|
|
content of the HTTP message."
|
|
handler
|
|
(content (ycmd--get-basic-request-data)))
|
|
|
|
(cl-defun ycmd--request (request-data
|
|
&key
|
|
(type "POST")
|
|
(params nil))
|
|
"Send an asynchronous HTTP request to the ycmd server.
|
|
|
|
This starts the server if necessary.
|
|
|
|
Returns a deferred object which resolves to the content of the
|
|
response message.
|
|
|
|
REQUEST-DATA is a `ycmd-request-data' structure.
|
|
|
|
PARSER specifies the function that will be used to parse the
|
|
response to the message. Typical values are buffer-string and
|
|
json-read. This function will be passed an the completely
|
|
unmodified contents of the response (i.e. not JSON-decoded or
|
|
anything like that)."
|
|
(unless (ycmd--server-alive-p)
|
|
(message "Ycmd server is not running. Can't send `%s' request!"
|
|
(ycmd-request-data-handler request-data))
|
|
(cl-return-from ycmd--request (deferred:next)))
|
|
|
|
(let* ((url-show-status (not ycmd-hide-url-status))
|
|
(url-proxy-services (unless ycmd-bypass-url-proxy-services
|
|
url-proxy-services))
|
|
(process-environment (ycmd--get-process-environment))
|
|
(path (concat "/" (ycmd-request-data-handler request-data)))
|
|
(content (json-encode (ycmd-request-data-content request-data)))
|
|
(hmac (ycmd--get-request-hmac type path content))
|
|
(encoded-hmac (base64-encode-string hmac 't))
|
|
(url (format "http://%s:%s%s"
|
|
ycmd-host ycmd--server-actual-port path))
|
|
(headers `(("Content-Type" . "application/json")
|
|
("X-Ycm-Hmac" . ,encoded-hmac)))
|
|
(parser (lambda ()
|
|
(let ((json-array-type 'list))
|
|
(json-read)))))
|
|
(ycmd--log-content "HTTP REQUEST CONTENT" content)
|
|
|
|
(deferred:$
|
|
(request-deferred url :type type :params params :data content
|
|
:parser parser :headers headers)
|
|
(deferred:nextc it
|
|
(lambda (response)
|
|
(let ((data (request-response-data response)))
|
|
(ycmd--log-content "HTTP RESPONSE CONTENT" data)
|
|
data))))))
|
|
|
|
(provide 'ycmd)
|
|
|
|
;;; ycmd.el ends here
|
|
|
|
;; Local Variables:
|
|
;; indent-tabs-mode: nil
|
|
;; End:
|