diff options
Diffstat (limited to 'configs/shared/emacs/.emacs.d/elpa/company-20180913.805/company.el')
| -rw-r--r-- | configs/shared/emacs/.emacs.d/elpa/company-20180913.805/company.el | 3182 |
1 files changed, 0 insertions, 3182 deletions
diff --git a/configs/shared/emacs/.emacs.d/elpa/company-20180913.805/company.el b/configs/shared/emacs/.emacs.d/elpa/company-20180913.805/company.el deleted file mode 100644 index 1259b6c72a..0000000000 --- a/configs/shared/emacs/.emacs.d/elpa/company-20180913.805/company.el +++ /dev/null @@ -1,3182 +0,0 @@ -;;; company.el --- Modular text completion framework -*- lexical-binding: t -*- - -;; Copyright (C) 2009-2018 Free Software Foundation, Inc. - -;; Author: Nikolaj Schumacher -;; Maintainer: Dmitry Gutov <dgutov@yandex.ru> -;; URL: http://company-mode.github.io/ -;; Version: 0.9.6 -;; Keywords: abbrev, convenience, matching -;; Package-Requires: ((emacs "24.3")) - -;; This file is part of GNU Emacs. - -;; GNU Emacs is free software: you can redistribute it and/or modify -;; it under the terms of the GNU General Public License as published by -;; the Free Software Foundation, either version 3 of the License, or -;; (at your option) any later version. - -;; GNU Emacs is distributed in the hope that it will be useful, -;; but WITHOUT ANY WARRANTY; without even the implied warranty of -;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the -;; GNU General Public License for more details. - -;; You should have received a copy of the GNU General Public License -;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. - -;;; Commentary: -;; -;; Company is a modular completion framework. Modules for retrieving completion -;; candidates are called backends, modules for displaying them are frontends. -;; -;; Company comes with many backends, e.g. `company-etags'. These are -;; distributed in separate files and can be used individually. -;; -;; Enable `company-mode' in all buffers with M-x global-company-mode. For -;; further information look at the documentation for `company-mode' (C-h f -;; company-mode RET). -;; -;; If you want to start a specific backend, call it interactively or use -;; `company-begin-backend'. For example: -;; M-x company-abbrev will prompt for and insert an abbrev. -;; -;; To write your own backend, look at the documentation for `company-backends'. -;; Here is a simple example completing "foo": -;; -;; (defun company-my-backend (command &optional arg &rest ignored) -;; (interactive (list 'interactive)) -;; (pcase command -;; (`interactive (company-begin-backend 'company-my-backend)) -;; (`prefix (company-grab-symbol)) -;; (`candidates (list "foobar" "foobaz" "foobarbaz")) -;; (`meta (format "This value is named %s" arg)))) -;; -;; Sometimes it is a good idea to mix several backends together, for example to -;; enrich gtags with dabbrev-code results (to emulate local variables). To do -;; this, add a list with both backends as an element in `company-backends'. -;; -;;; Change Log: -;; -;; See NEWS.md in the repository. - -;;; Code: - -(require 'cl-lib) -(require 'newcomment) -(require 'pcase) - -;;; Compatibility -(eval-and-compile - ;; Defined in Emacs 24.4 - (unless (fboundp 'string-suffix-p) - (defun string-suffix-p (suffix string &optional ignore-case) - "Return non-nil if SUFFIX is a suffix of STRING. -If IGNORE-CASE is non-nil, the comparison is done without paying -attention to case differences." - (let ((start-pos (- (length string) (length suffix)))) - (and (>= start-pos 0) - (eq t (compare-strings suffix nil nil - string start-pos nil ignore-case))))))) - -(defgroup company nil - "Extensible inline text completion mechanism" - :group 'abbrev - :group 'convenience - :group 'matching) - -(defface company-tooltip - '((default :foreground "black") - (((class color) (min-colors 88) (background light)) - (:background "cornsilk")) - (((class color) (min-colors 88) (background dark)) - (:background "yellow"))) - "Face used for the tooltip.") - -(defface company-tooltip-selection - '((((class color) (min-colors 88) (background light)) - (:background "light blue")) - (((class color) (min-colors 88) (background dark)) - (:background "orange1")) - (t (:background "green"))) - "Face used for the selection in the tooltip.") - -(defface company-tooltip-search - '((default :inherit highlight)) - "Face used for the search string in the tooltip.") - -(defface company-tooltip-search-selection - '((default :inherit highlight)) - "Face used for the search string inside the selection in the tooltip.") - -(defface company-tooltip-mouse - '((default :inherit highlight)) - "Face used for the tooltip item under the mouse.") - -(defface company-tooltip-common - '((((background light)) - :foreground "darkred") - (((background dark)) - :foreground "red")) - "Face used for the common completion in the tooltip.") - -(defface company-tooltip-common-selection - '((default :inherit company-tooltip-common)) - "Face used for the selected common completion in the tooltip.") - -(defface company-tooltip-annotation - '((((background light)) - :foreground "firebrick4") - (((background dark)) - :foreground "red4")) - "Face used for the completion annotation in the tooltip.") - -(defface company-tooltip-annotation-selection - '((default :inherit company-tooltip-annotation)) - "Face used for the selected completion annotation in the tooltip.") - -(defface company-scrollbar-fg - '((((background light)) - :background "darkred") - (((background dark)) - :background "red")) - "Face used for the tooltip scrollbar thumb.") - -(defface company-scrollbar-bg - '((((background light)) - :background "wheat") - (((background dark)) - :background "gold")) - "Face used for the tooltip scrollbar background.") - -(defface company-preview - '((((background light)) - :inherit (company-tooltip-selection company-tooltip)) - (((background dark)) - :background "blue4" - :foreground "wheat")) - "Face used for the completion preview.") - -(defface company-preview-common - '((((background light)) - :inherit company-tooltip-common-selection) - (((background dark)) - :inherit company-preview - :foreground "red")) - "Face used for the common part of the completion preview.") - -(defface company-preview-search - '((((background light)) - :inherit company-tooltip-common-selection) - (((background dark)) - :inherit company-preview - :background "blue1")) - "Face used for the search string in the completion preview.") - -(defface company-echo nil - "Face used for completions in the echo area.") - -(defface company-echo-common - '((((background dark)) (:foreground "firebrick1")) - (((background light)) (:background "firebrick4"))) - "Face used for the common part of completions in the echo area.") - -(defun company-frontends-set (variable value) - ;; Uniquify. - (let ((value (delete-dups (copy-sequence value)))) - (and (or (and (memq 'company-pseudo-tooltip-unless-just-one-frontend value) - (memq 'company-pseudo-tooltip-frontend value)) - (and (memq 'company-pseudo-tooltip-unless-just-one-frontend-with-delay value) - (memq 'company-pseudo-tooltip-frontend value)) - (and (memq 'company-pseudo-tooltip-unless-just-one-frontend-with-delay value) - (memq 'company-pseudo-tooltip-unless-just-one-frontend value))) - (user-error "Pseudo tooltip frontend cannot be used more than once")) - (and (or (and (memq 'company-preview-if-just-one-frontend value) - (memq 'company-preview-frontend value)) - (and (memq 'company-preview-if-just-one-frontend value) - (memq 'company-preview-common-frontend value)) - (and (memq 'company-preview-frontend value) - (memq 'company-preview-common-frontend value)) - ) - (user-error "Preview frontend cannot be used twice")) - (and (memq 'company-echo value) - (memq 'company-echo-metadata-frontend value) - (user-error "Echo area cannot be used twice")) - ;; Preview must come last. - (dolist (f '(company-preview-if-just-one-frontend company-preview-frontend company-preview-common-frontend)) - (when (cdr (memq f value)) - (setq value (append (delq f value) (list f))))) - (set variable value))) - -(defcustom company-frontends '(company-pseudo-tooltip-unless-just-one-frontend - company-preview-if-just-one-frontend - company-echo-metadata-frontend) - "The list of active frontends (visualizations). -Each frontend is a function that takes one argument. It is called with -one of the following arguments: - -`show': When the visualization should start. - -`hide': When the visualization should end. - -`update': When the data has been updated. - -`pre-command': Before every command that is executed while the -visualization is active. - -`post-command': After every command that is executed while the -visualization is active. - -The visualized data is stored in `company-prefix', `company-candidates', -`company-common', `company-selection', `company-point' and -`company-search-string'." - :set 'company-frontends-set - :type '(repeat (choice (const :tag "echo" company-echo-frontend) - (const :tag "echo, strip common" - company-echo-strip-common-frontend) - (const :tag "show echo meta-data in echo" - company-echo-metadata-frontend) - (const :tag "pseudo tooltip" - company-pseudo-tooltip-frontend) - (const :tag "pseudo tooltip, multiple only" - company-pseudo-tooltip-unless-just-one-frontend) - (const :tag "pseudo tooltip, multiple only, delayed" - company-pseudo-tooltip-unless-just-one-frontend-with-delay) - (const :tag "preview" company-preview-frontend) - (const :tag "preview, unique only" - company-preview-if-just-one-frontend) - (const :tag "preview, common" - company-preview-common-frontend) - (function :tag "custom function" nil)))) - -(defcustom company-tooltip-limit 10 - "The maximum number of candidates in the tooltip." - :type 'integer) - -(defcustom company-tooltip-minimum 6 - "The minimum height of the tooltip. -If this many lines are not available, prefer to display the tooltip above." - :type 'integer) - -(defcustom company-tooltip-minimum-width 0 - "The minimum width of the tooltip's inner area. -This doesn't include the margins and the scroll bar." - :type 'integer - :package-version '(company . "0.8.0")) - -(defcustom company-tooltip-maximum-width most-positive-fixnum - "The maximum width of the tooltip's inner area. -This doesn't include the margins and the scroll bar." - :type 'integer - :package-version '(company . "0.9.5")) - -(defcustom company-tooltip-margin 1 - "Width of margin columns to show around the toolip." - :type 'integer) - -(defcustom company-tooltip-offset-display 'scrollbar - "Method using which the tooltip displays scrolling position. -`scrollbar' means draw a scrollbar to the right of the items. -`lines' means wrap items in lines with \"before\" and \"after\" counters." - :type '(choice (const :tag "Scrollbar" scrollbar) - (const :tag "Two lines" lines))) - -(defcustom company-tooltip-align-annotations nil - "When non-nil, align annotations to the right tooltip border." - :type 'boolean - :package-version '(company . "0.7.1")) - -(defcustom company-tooltip-flip-when-above nil - "Whether to flip the tooltip when it's above the current line." - :type 'boolean - :package-version '(company . "0.8.1")) - -(defvar company-safe-backends - '((company-abbrev . "Abbrev") - (company-bbdb . "BBDB") - (company-capf . "completion-at-point-functions") - (company-clang . "Clang") - (company-cmake . "CMake") - (company-css . "CSS") - (company-dabbrev . "dabbrev for plain text") - (company-dabbrev-code . "dabbrev for code") - (company-eclim . "Eclim (an Eclipse interface)") - (company-elisp . "Emacs Lisp") - (company-etags . "etags") - (company-files . "Files") - (company-gtags . "GNU Global") - (company-ispell . "Ispell") - (company-keywords . "Programming language keywords") - (company-nxml . "nxml") - (company-oddmuse . "Oddmuse") - (company-semantic . "Semantic") - (company-tempo . "Tempo templates") - (company-xcode . "Xcode"))) -(put 'company-safe-backends 'risky-local-variable t) - -(defun company-safe-backends-p (backends) - (and (consp backends) - (not (cl-dolist (backend backends) - (unless (if (consp backend) - (company-safe-backends-p backend) - (assq backend company-safe-backends)) - (cl-return t)))))) - -(defcustom company-backends `(,@(unless (version< "24.3.51" emacs-version) - (list 'company-elisp)) - company-bbdb - ,@(unless (version<= "26" emacs-version) - (list 'company-nxml)) - ,@(unless (version<= "26" emacs-version) - (list 'company-css)) - company-eclim company-semantic company-clang - company-xcode company-cmake - company-capf - company-files - (company-dabbrev-code company-gtags company-etags - company-keywords) - company-oddmuse company-dabbrev) - "The list of active backends (completion engines). - -Only one backend is used at a time. The choice depends on the order of -the items in this list, and on the values they return in response to the -`prefix' command (see below). But a backend can also be a \"grouped\" -one (see below). - -`company-begin-backend' can be used to start a specific backend, -`company-other-backend' will skip to the next matching backend in the list. - -Each backend is a function that takes a variable number of arguments. -The first argument is the command requested from the backend. It is one -of the following: - -`prefix': The backend should return the text to be completed. It must be -text immediately before point. Returning nil from this command passes -control to the next backend. The function should return `stop' if it -should complete but cannot (e.g. when in the middle of a symbol). -Instead of a string, the backend may return a cons (PREFIX . LENGTH) -where LENGTH is a number used in place of PREFIX's length when -comparing against `company-minimum-prefix-length'. LENGTH can also -be just t, and in the latter case the test automatically succeeds. - -`candidates': The second argument is the prefix to be completed. The -return value should be a list of candidates that match the prefix. - -Non-prefix matches are also supported (candidates that don't start with the -prefix, but match it in some backend-defined way). Backends that use this -feature must disable cache (return t to `no-cache') and might also want to -respond to `match'. - -Optional commands -================= - -`sorted': Return t here to indicate that the candidates are sorted and will -not need to be sorted again. - -`duplicates': If non-nil, company will take care of removing duplicates -from the list. - -`no-cache': Usually company doesn't ask for candidates again as completion -progresses, unless the backend returns t for this command. The second -argument is the latest prefix. - -`ignore-case': Return t here if the backend returns case-insensitive -matches. This value is used to determine the longest common prefix (as -used in `company-complete-common'), and to filter completions when fetching -them from cache. - -`meta': The second argument is a completion candidate. Return a (short) -documentation string for it. - -`doc-buffer': The second argument is a completion candidate. Return a -buffer with documentation for it. Preferably use `company-doc-buffer'. If -not all buffer contents pertain to this candidate, return a cons of buffer -and window start position. - -`location': The second argument is a completion candidate. Return a cons -of buffer and buffer location, or of file and line number where the -completion candidate was defined. - -`annotation': The second argument is a completion candidate. Return a -string to be displayed inline with the candidate in the popup. If -duplicates are removed by company, candidates with equal string values will -be kept if they have different annotations. For that to work properly, -backends should store the related information on candidates using text -properties. - -`match': The second argument is a completion candidate. Return a positive -integer, the index after the end of text matching `prefix' within the -candidate string. Alternatively, return a list of (CHUNK-START -. CHUNK-END) elements, where CHUNK-START and CHUNK-END are indexes within -the candidate string. The corresponding regions are be used when rendering -the popup. This command only makes sense for backends that provide -non-prefix completion. - -`require-match': If this returns t, the user is not allowed to enter -anything not offered as a candidate. Please don't use that value in normal -backends. The default value nil gives the user that choice with -`company-require-match'. Return value `never' overrides that option the -other way around. - -`init': Called once for each buffer. The backend can check for external -programs and files and load any required libraries. Raising an error here -will show up in message log once, and the backend will not be used for -completion. - -`post-completion': Called after a completion candidate has been inserted -into the buffer. The second argument is the candidate. Can be used to -modify it, e.g. to expand a snippet. - -The backend should return nil for all commands it does not support or -does not know about. It should also be callable interactively and use -`company-begin-backend' to start itself in that case. - -Grouped backends -================ - -An element of `company-backends' can also be a list of backends. The -completions from backends in such groups are merged, but only from those -backends which return the same `prefix'. - -If a backend command takes a candidate as an argument (e.g. `meta'), the -call is dispatched to the backend the candidate came from. In other -cases (except for `duplicates' and `sorted'), the first non-nil value among -all the backends is returned. - -The group can also contain keywords. Currently, `:with' and `:separate' -keywords are defined. If the group contains keyword `:with', the backends -listed after this keyword are ignored for the purpose of the `prefix' -command. If the group contains keyword `:separate', the candidates that -come from different backends are sorted separately in the combined list. - -Asynchronous backends -===================== - -The return value of each command can also be a cons (:async . FETCHER) -where FETCHER is a function of one argument, CALLBACK. When the data -arrives, FETCHER must call CALLBACK and pass it the appropriate return -value, as described above. That call must happen in the same buffer as -where completion was initiated. - -True asynchronous operation is only supported for command `candidates', and -only during idle completion. Other commands will block the user interface, -even if the backend uses the asynchronous calling convention." - :type `(repeat - (choice - :tag "backend" - ,@(mapcar (lambda (b) `(const :tag ,(cdr b) ,(car b))) - company-safe-backends) - (symbol :tag "User defined") - (repeat :tag "Merged backends" - (choice :tag "backend" - ,@(mapcar (lambda (b) - `(const :tag ,(cdr b) ,(car b))) - company-safe-backends) - (const :tag "With" :with) - (symbol :tag "User defined")))))) - -(put 'company-backends 'safe-local-variable 'company-safe-backends-p) - -(defcustom company-transformers nil - "Functions to change the list of candidates received from backends. - -Each function gets called with the return value of the previous one. -The first one gets passed the list of candidates, already sorted and -without duplicates." - :type '(choice - (const :tag "None" nil) - (const :tag "Sort by occurrence" (company-sort-by-occurrence)) - (const :tag "Sort by backend importance" - (company-sort-by-backend-importance)) - (const :tag "Prefer case sensitive prefix" - (company-sort-prefer-same-case-prefix)) - (repeat :tag "User defined" (function)))) - -(defcustom company-completion-started-hook nil - "Hook run when company starts completing. -The hook is called with one argument that is non-nil if the completion was -started manually." - :type 'hook) - -(defcustom company-completion-cancelled-hook nil - "Hook run when company cancels completing. -The hook is called with one argument that is non-nil if the completion was -aborted manually." - :type 'hook) - -(defcustom company-completion-finished-hook nil - "Hook run when company successfully completes. -The hook is called with the selected candidate as an argument. - -If you indend to use it to post-process candidates from a specific -backend, consider using the `post-completion' command instead." - :type 'hook) - -(defcustom company-minimum-prefix-length 3 - "The minimum prefix length for idle completion." - :type '(integer :tag "prefix length")) - -(defcustom company-abort-manual-when-too-short nil - "If enabled, cancel a manually started completion when the prefix gets -shorter than both `company-minimum-prefix-length' and the length of the -prefix it was started from." - :type 'boolean - :package-version '(company . "0.8.0")) - -(defcustom company-require-match 'company-explicit-action-p - "If enabled, disallow non-matching input. -This can be a function do determine if a match is required. - -This can be overridden by the backend, if it returns t or `never' to -`require-match'. `company-auto-complete' also takes precedence over this." - :type '(choice (const :tag "Off" nil) - (function :tag "Predicate function") - (const :tag "On, if user interaction took place" - 'company-explicit-action-p) - (const :tag "On" t))) - -(defcustom company-auto-complete nil - "Determines when to auto-complete. -If this is enabled, all characters from `company-auto-complete-chars' -trigger insertion of the selected completion candidate. -This can also be a function." - :type '(choice (const :tag "Off" nil) - (function :tag "Predicate function") - (const :tag "On, if user interaction took place" - 'company-explicit-action-p) - (const :tag "On" t))) - -(defcustom company-auto-complete-chars '(?\ ?\) ?.) - "Determines which characters trigger auto-completion. -See `company-auto-complete'. If this is a string, each string character -tiggers auto-completion. If it is a list of syntax description characters (see -`modify-syntax-entry'), all characters with that syntax auto-complete. - -This can also be a function, which is called with the new input and should -return non-nil if company should auto-complete. - -A character that is part of a valid candidate never triggers auto-completion." - :type '(choice (string :tag "Characters") - (set :tag "Syntax" - (const :tag "Whitespace" ?\ ) - (const :tag "Symbol" ?_) - (const :tag "Opening parentheses" ?\() - (const :tag "Closing parentheses" ?\)) - (const :tag "Word constituent" ?w) - (const :tag "Punctuation." ?.) - (const :tag "String quote." ?\") - (const :tag "Paired delimiter." ?$) - (const :tag "Expression quote or prefix operator." ?\') - (const :tag "Comment starter." ?<) - (const :tag "Comment ender." ?>) - (const :tag "Character-quote." ?/) - (const :tag "Generic string fence." ?|) - (const :tag "Generic comment fence." ?!)) - (function :tag "Predicate function"))) - -(defcustom company-idle-delay .5 - "The idle delay in seconds until completion starts automatically. -The prefix still has to satisfy `company-minimum-prefix-length' before that -happens. The value of nil means no idle completion." - :type '(choice (const :tag "never (nil)" nil) - (const :tag "immediate (0)" 0) - (number :tag "seconds"))) - -(defcustom company-tooltip-idle-delay .5 - "The idle delay in seconds until tooltip is shown when using -`company-pseudo-tooltip-unless-just-one-frontend-with-delay'." - :type '(choice (const :tag "never (nil)" nil) - (const :tag "immediate (0)" 0) - (number :tag "seconds"))) - -(defcustom company-begin-commands '(self-insert-command - org-self-insert-command - orgtbl-self-insert-command - c-scope-operator - c-electric-colon - c-electric-lt-gt - c-electric-slash) - "A list of commands after which idle completion is allowed. -If this is t, it can show completions after any command except a few from a -pre-defined list. See `company-idle-delay'. - -Alternatively, any command with a non-nil `company-begin' property is -treated as if it was on this list." - :type '(choice (const :tag "Any command" t) - (const :tag "Self insert command" '(self-insert-command)) - (repeat :tag "Commands" function)) - :package-version '(company . "0.8.4")) - -(defcustom company-continue-commands '(not save-buffer save-some-buffers - save-buffers-kill-terminal - save-buffers-kill-emacs - completion-at-point) - "A list of commands that are allowed during completion. -If this is t, or if `company-begin-commands' is t, any command is allowed. -Otherwise, the value must be a list of symbols. If it starts with `not', -the cdr is the list of commands that abort completion. Otherwise, all -commands except those in that list, or in `company-begin-commands', or -commands in the `company-' namespace, abort completion." - :type '(choice (const :tag "Any command" t) - (cons :tag "Any except" - (const not) - (repeat :tag "Commands" function)) - (repeat :tag "Commands" function))) - -(defcustom company-show-numbers nil - "If enabled, show quick-access numbers for the first ten candidates." - :type '(choice (const :tag "off" nil) - (const :tag "on" t))) - -(defcustom company-selection-wrap-around nil - "If enabled, selecting item before first or after last wraps around." - :type '(choice (const :tag "off" nil) - (const :tag "on" t))) - -(defvar company-async-wait 0.03 - "Pause between checks to see if the value's been set when turning an -asynchronous call into synchronous.") - -(defvar company-async-timeout 2 - "Maximum wait time for a value to be set during asynchronous call.") - -;;; mode ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar company-mode-map (make-sparse-keymap) - "Keymap used by `company-mode'.") - -(defvar company-active-map - (let ((keymap (make-sparse-keymap))) - (define-key keymap "\e\e\e" 'company-abort) - (define-key keymap "\C-g" 'company-abort) - (define-key keymap (kbd "M-n") 'company-select-next) - (define-key keymap (kbd "M-p") 'company-select-previous) - (define-key keymap (kbd "<down>") 'company-select-next-or-abort) - (define-key keymap (kbd "<up>") 'company-select-previous-or-abort) - (define-key keymap [remap scroll-up-command] 'company-next-page) - (define-key keymap [remap scroll-down-command] 'company-previous-page) - (define-key keymap [down-mouse-1] 'ignore) - (define-key keymap [down-mouse-3] 'ignore) - (define-key keymap [mouse-1] 'company-complete-mouse) - (define-key keymap [mouse-3] 'company-select-mouse) - (define-key keymap [up-mouse-1] 'ignore) - (define-key keymap [up-mouse-3] 'ignore) - (define-key keymap [return] 'company-complete-selection) - (define-key keymap (kbd "RET") 'company-complete-selection) - (define-key keymap [tab] 'company-complete-common) - (define-key keymap (kbd "TAB") 'company-complete-common) - (define-key keymap (kbd "<f1>") 'company-show-doc-buffer) - (define-key keymap (kbd "C-h") 'company-show-doc-buffer) - (define-key keymap "\C-w" 'company-show-location) - (define-key keymap "\C-s" 'company-search-candidates) - (define-key keymap "\C-\M-s" 'company-filter-candidates) - (dotimes (i 10) - (define-key keymap (read-kbd-macro (format "M-%d" i)) 'company-complete-number)) - keymap) - "Keymap that is enabled during an active completion.") - -(defvar company--disabled-backends nil) - -(defun company-init-backend (backend) - (and (symbolp backend) - (not (fboundp backend)) - (ignore-errors (require backend nil t))) - (cond - ((symbolp backend) - (condition-case err - (progn - (funcall backend 'init) - (put backend 'company-init t)) - (error - (put backend 'company-init 'failed) - (unless (memq backend company--disabled-backends) - (message "Company backend '%s' could not be initialized:\n%s" - backend (error-message-string err))) - (cl-pushnew backend company--disabled-backends) - nil))) - ;; No initialization for lambdas. - ((functionp backend) t) - (t ;; Must be a list. - (cl-dolist (b backend) - (unless (keywordp b) - (company-init-backend b)))))) - -(defun company--maybe-init-backend (backend) - (or (not (symbolp backend)) - (eq t (get backend 'company-init)) - (unless (get backend 'company-init) - (company-init-backend backend)))) - -(defcustom company-lighter-base "company" - "Base string to use for the `company-mode' lighter." - :type 'string - :package-version '(company . "0.8.10")) - -(defvar company-lighter '(" " - (company-candidates - (:eval - (if (consp company-backend) - (company--group-lighter (nth company-selection - company-candidates) - company-lighter-base) - (symbol-name company-backend))) - company-lighter-base)) - "Mode line lighter for Company. - -The value of this variable is a mode line template as in -`mode-line-format'.") - -(put 'company-lighter 'risky-local-variable t) - -;;;###autoload -(define-minor-mode company-mode - "\"complete anything\"; is an in-buffer completion framework. -Completion starts automatically, depending on the values -`company-idle-delay' and `company-minimum-prefix-length'. - -Completion can be controlled with the commands: -`company-complete-common', `company-complete-selection', `company-complete', -`company-select-next', `company-select-previous'. If these commands are -called before `company-idle-delay', completion will also start. - -Completions can be searched with `company-search-candidates' or -`company-filter-candidates'. These can be used while completion is -inactive, as well. - -The completion data is retrieved using `company-backends' and displayed -using `company-frontends'. If you want to start a specific backend, call -it interactively or use `company-begin-backend'. - -By default, the completions list is sorted alphabetically, unless the -backend chooses otherwise, or `company-transformers' changes it later. - -regular keymap (`company-mode-map'): - -\\{company-mode-map} -keymap during active completions (`company-active-map'): - -\\{company-active-map}" - nil company-lighter company-mode-map - (if company-mode - (progn - (add-hook 'pre-command-hook 'company-pre-command nil t) - (add-hook 'post-command-hook 'company-post-command nil t) - (mapc 'company-init-backend company-backends)) - (remove-hook 'pre-command-hook 'company-pre-command t) - (remove-hook 'post-command-hook 'company-post-command t) - (company-cancel) - (kill-local-variable 'company-point))) - -(defcustom company-global-modes t - "Modes for which `company-mode' mode is turned on by `global-company-mode'. -If nil, means no modes. If t, then all major modes have it turned on. -If a list, it should be a list of `major-mode' symbol names for which -`company-mode' should be automatically turned on. The sense of the list is -negated if it begins with `not'. For example: - (c-mode c++-mode) -means that `company-mode' is turned on for buffers in C and C++ modes only. - (not message-mode) -means that `company-mode' is always turned on except in `message-mode' buffers." - :type '(choice (const :tag "none" nil) - (const :tag "all" t) - (set :menu-tag "mode specific" :tag "modes" - :value (not) - (const :tag "Except" not) - (repeat :inline t (symbol :tag "mode"))))) - -;;;###autoload -(define-globalized-minor-mode global-company-mode company-mode company-mode-on) - -(defun company-mode-on () - (when (and (not (or noninteractive (eq (aref (buffer-name) 0) ?\s))) - (cond ((eq company-global-modes t) - t) - ((eq (car-safe company-global-modes) 'not) - (not (memq major-mode (cdr company-global-modes)))) - (t (memq major-mode company-global-modes)))) - (company-mode 1))) - -(defsubst company-assert-enabled () - (unless company-mode - (company-uninstall-map) - (user-error "Company not enabled"))) - -;;; keymaps ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar-local company-my-keymap nil) - -(defvar company-emulation-alist '((t . nil))) - -(defsubst company-enable-overriding-keymap (keymap) - (company-uninstall-map) - (setq company-my-keymap keymap)) - -(defun company-ensure-emulation-alist () - (unless (eq 'company-emulation-alist (car emulation-mode-map-alists)) - (setq emulation-mode-map-alists - (cons 'company-emulation-alist - (delq 'company-emulation-alist emulation-mode-map-alists))))) - -(defun company-install-map () - (unless (or (cdar company-emulation-alist) - (null company-my-keymap)) - (setf (cdar company-emulation-alist) company-my-keymap))) - -(defun company-uninstall-map () - (setf (cdar company-emulation-alist) nil)) - -(defun company--company-command-p (keys) - "Checks if the keys are part of company's overriding keymap" - (or (equal [company-dummy-event] keys) - (lookup-key company-my-keymap keys))) - -;; Hack: -;; Emacs calculates the active keymaps before reading the event. That means we -;; cannot change the keymap from a timer. So we send a bogus command. -;; XXX: Even in Emacs 24.4, seems to be needed in the terminal. -(defun company-ignore () - (interactive) - (setq this-command last-command)) - -(global-set-key '[company-dummy-event] 'company-ignore) - -(defun company-input-noop () - (push 'company-dummy-event unread-command-events)) - -;; To avoid warnings in Emacs < 26. -(declare-function line-number-display-width "indent.c") - -(defun company--posn-col-row (posn) - (let ((col (car (posn-col-row posn))) - ;; `posn-col-row' doesn't work well with lines of different height. - ;; `posn-actual-col-row' doesn't handle multiple-width characters. - (row (cdr (or (posn-actual-col-row posn) - ;; When position is non-visible for some reason. - (posn-col-row posn))))) - (when (and header-line-format (version< emacs-version "24.3.93.3")) - ;; http://debbugs.gnu.org/18384 - (cl-decf row)) - (when (bound-and-true-p display-line-numbers) - (cl-decf col (+ 2 (line-number-display-width)))) - (cons (+ col (window-hscroll)) row))) - -(defun company--col-row (&optional pos) - (company--posn-col-row (posn-at-point pos))) - -(defun company--row (&optional pos) - (cdr (company--col-row pos))) - -;;; backends ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar-local company-backend nil) - -(defun company-grab (regexp &optional expression limit) - (when (looking-back regexp limit) - (or (match-string-no-properties (or expression 0)) ""))) - -(defun company-grab-line (regexp &optional expression) - "Return a match string for REGEXP if it matches text before point. -If EXPRESSION is non-nil, return the match string for the respective -parenthesized expression in REGEXP. -Matching is limited to the current line." - (let ((inhibit-field-text-motion t)) - (company-grab regexp expression (point-at-bol)))) - -(defun company-grab-symbol () - "If point is at the end of a symbol, return it. -Otherwise, if point is not inside a symbol, return an empty string." - (if (looking-at "\\_>") - (buffer-substring (point) (save-excursion (skip-syntax-backward "w_") - (point))) - (unless (and (char-after) (memq (char-syntax (char-after)) '(?w ?_))) - ""))) - -(defun company-grab-word () - "If point is at the end of a word, return it. -Otherwise, if point is not inside a symbol, return an empty string." - (if (looking-at "\\>") - (buffer-substring (point) (save-excursion (skip-syntax-backward "w") - (point))) - (unless (and (char-after) (eq (char-syntax (char-after)) ?w)) - ""))) - -(defun company-grab-symbol-cons (idle-begin-after-re &optional max-len) - "Return a string SYMBOL or a cons (SYMBOL . t). -SYMBOL is as returned by `company-grab-symbol'. If the text before point -matches IDLE-BEGIN-AFTER-RE, return it wrapped in a cons." - (let ((symbol (company-grab-symbol))) - (when symbol - (save-excursion - (forward-char (- (length symbol))) - (if (looking-back idle-begin-after-re (if max-len - (- (point) max-len) - (line-beginning-position))) - (cons symbol t) - symbol))))) - -(defun company-in-string-or-comment () - "Return non-nil if point is within a string or comment." - (let ((ppss (syntax-ppss))) - (or (car (setq ppss (nthcdr 3 ppss))) - (car (setq ppss (cdr ppss))) - (nth 3 ppss)))) - -(defun company-call-backend (&rest args) - (company--force-sync #'company-call-backend-raw args company-backend)) - -(defun company--force-sync (fun args backend) - (let ((value (apply fun args))) - (if (not (eq (car-safe value) :async)) - value - (let ((res 'trash) - (start (time-to-seconds))) - (funcall (cdr value) - (lambda (result) (setq res result))) - (while (eq res 'trash) - (if (> (- (time-to-seconds) start) company-async-timeout) - (error "Company: backend %s async timeout with args %s" - backend args) - ;; XXX: Reusing the trick from company--fetch-candidates here - ;; doesn't work well: sit-for isn't a good fit when we want to - ;; ignore pending input (results in too many calls). - ;; FIXME: We should deal with this by standardizing on a kind of - ;; Future object that knows how to sync itself. In most cases (but - ;; not all), by calling accept-process-output, probably. - (sleep-for company-async-wait))) - res)))) - -(defun company-call-backend-raw (&rest args) - (condition-case-unless-debug err - (if (functionp company-backend) - (apply company-backend args) - (apply #'company--multi-backend-adapter company-backend args)) - (user-error (user-error - "Company: backend %s user-error: %s" - company-backend (error-message-string err))) - (error (error "Company: backend %s error \"%s\" with args %s" - company-backend (error-message-string err) args)))) - -(defun company--multi-backend-adapter (backends command &rest args) - (let ((backends (cl-loop for b in backends - when (or (keywordp b) - (company--maybe-init-backend b)) - collect b)) - (separate (memq :separate backends))) - - (when (eq command 'prefix) - (setq backends (butlast backends (length (member :with backends))))) - - (setq backends (cl-delete-if #'keywordp backends)) - - (pcase command - (`candidates - (company--multi-backend-adapter-candidates backends (car args) separate)) - (`sorted separate) - (`duplicates (not separate)) - ((or `prefix `ignore-case `no-cache `require-match) - (let (value) - (cl-dolist (backend backends) - (when (setq value (company--force-sync - backend (cons command args) backend)) - (cl-return value))))) - (_ - (let ((arg (car args))) - (when (> (length arg) 0) - (let ((backend (or (get-text-property 0 'company-backend arg) - (car backends)))) - (apply backend command args)))))))) - -(defun company--multi-backend-adapter-candidates (backends prefix separate) - (let ((pairs (cl-loop for backend in backends - when (equal (company--prefix-str - (let ((company-backend backend)) - (company-call-backend 'prefix))) - prefix) - collect (cons (funcall backend 'candidates prefix) - (company--multi-candidates-mapper - backend - separate - ;; Small perf optimization: don't tag the - ;; candidates received from the first - ;; backend in the group. - (not (eq backend (car backends)))))))) - (company--merge-async pairs (lambda (values) (apply #'append values))))) - -(defun company--multi-candidates-mapper (backend separate tag) - (lambda (candidates) - (when separate - (let ((company-backend backend)) - (setq candidates - (company--preprocess-candidates candidates)))) - (when tag - (setq candidates - (mapcar - (lambda (str) - (propertize str 'company-backend backend)) - candidates))) - candidates)) - -(defun company--merge-async (pairs merger) - (let ((async (cl-loop for pair in pairs - thereis - (eq :async (car-safe (car pair)))))) - (if (not async) - (funcall merger (cl-loop for (val . mapper) in pairs - collect (funcall mapper val))) - (cons - :async - (lambda (callback) - (let* (lst - (pending (mapcar #'car pairs)) - (finisher (lambda () - (unless pending - (funcall callback - (funcall merger - (nreverse lst))))))) - (dolist (pair pairs) - (push nil lst) - (let* ((cell lst) - (val (car pair)) - (mapper (cdr pair)) - (this-finisher (lambda (res) - (setq pending (delq val pending)) - (setcar cell (funcall mapper res)) - (funcall finisher)))) - (if (not (eq :async (car-safe val))) - (funcall this-finisher val) - (let ((fetcher (cdr val))) - (funcall fetcher this-finisher))))))))))) - -(defun company--prefix-str (prefix) - (or (car-safe prefix) prefix)) - -;;; completion mechanism ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar-local company-prefix nil) - -(defvar-local company-candidates nil) - -(defvar-local company-candidates-length nil) - -(defvar-local company-candidates-cache nil) - -(defvar-local company-candidates-predicate nil) - -(defvar-local company-common nil) - -(defvar-local company-selection 0) - -(defvar-local company-selection-changed nil) - -(defvar-local company--manual-action nil - "Non-nil, if manual completion took place.") - -(defvar-local company--manual-prefix nil) - -(defvar company--auto-completion nil - "Non-nil when current candidate is being inserted automatically. -Controlled by `company-auto-complete'.") - -(defvar-local company--point-max nil) - -(defvar-local company-point nil) - -(defvar company-timer nil) -(defvar company-tooltip-timer nil) - -(defsubst company-strip-prefix (str) - (substring str (length company-prefix))) - -(defun company--insert-candidate (candidate) - (when (> (length candidate) 0) - (setq candidate (substring-no-properties candidate)) - ;; XXX: Return value we check here is subject to change. - (if (eq (company-call-backend 'ignore-case) 'keep-prefix) - (insert (company-strip-prefix candidate)) - (unless (equal company-prefix candidate) - (delete-region (- (point) (length company-prefix)) (point)) - (insert candidate))))) - -(defmacro company-with-candidate-inserted (candidate &rest body) - "Evaluate BODY with CANDIDATE temporarily inserted. -This is a tool for backends that need candidates inserted before they -can retrieve meta-data for them." - (declare (indent 1)) - `(let ((inhibit-modification-hooks t) - (inhibit-point-motion-hooks t) - (modified-p (buffer-modified-p))) - (company--insert-candidate ,candidate) - (unwind-protect - (progn ,@body) - (delete-region company-point (point)) - (set-buffer-modified-p modified-p)))) - -(defun company-explicit-action-p () - "Return whether explicit completion action was taken by the user." - (or company--manual-action - company-selection-changed)) - -(defun company-reformat (candidate) - ;; company-ispell needs this, because the results are always lower-case - ;; It's mory efficient to fix it only when they are displayed. - ;; FIXME: Adopt the current text's capitalization instead? - (if (eq (company-call-backend 'ignore-case) 'keep-prefix) - (concat company-prefix (substring candidate (length company-prefix))) - candidate)) - -(defun company--should-complete () - (and (eq company-idle-delay 'now) - (not (or buffer-read-only - overriding-local-map)) - ;; Check if in the middle of entering a key combination. - (or (equal (this-command-keys-vector) []) - (not (keymapp (key-binding (this-command-keys-vector))))) - (not (and transient-mark-mode mark-active)))) - -(defun company--should-continue () - (or (eq t company-begin-commands) - (eq t company-continue-commands) - (if (eq 'not (car company-continue-commands)) - (not (memq this-command (cdr company-continue-commands))) - (or (memq this-command company-begin-commands) - (memq this-command company-continue-commands) - (and (symbolp this-command) - (string-match-p "\\`company-" (symbol-name this-command))))))) - -(defun company-call-frontends (command) - (dolist (frontend company-frontends) - (condition-case-unless-debug err - (funcall frontend command) - (error (error "Company: frontend %s error \"%s\" on command %s" - frontend (error-message-string err) command))))) - -(defun company-set-selection (selection &optional force-update) - (setq selection - (if company-selection-wrap-around - (mod selection company-candidates-length) - (max 0 (min (1- company-candidates-length) selection)))) - (when (or force-update (not (equal selection company-selection))) - (setq company-selection selection - company-selection-changed t) - (company-call-frontends 'update))) - -(defun company--group-lighter (candidate base) - (let ((backend (or (get-text-property 0 'company-backend candidate) - (cl-some (lambda (x) (and (not (keywordp x)) x)) - company-backend)))) - (when (and backend (symbolp backend)) - (let ((name (replace-regexp-in-string "company-\\|-company" "" - (symbol-name backend)))) - (format "%s-<%s>" base name))))) - -(defun company-update-candidates (candidates) - (setq company-candidates-length (length candidates)) - (if company-selection-changed - ;; Try to restore the selection - (let ((selected (nth company-selection company-candidates))) - (setq company-selection 0 - company-candidates candidates) - (when selected - (catch 'found - (while candidates - (let ((candidate (pop candidates))) - (when (and (string= candidate selected) - (equal (company-call-backend 'annotation candidate) - (company-call-backend 'annotation selected))) - (throw 'found t))) - (cl-incf company-selection)) - (setq company-selection 0 - company-selection-changed nil)))) - (setq company-selection 0 - company-candidates candidates)) - ;; Calculate common. - (let ((completion-ignore-case (company-call-backend 'ignore-case))) - ;; We want to support non-prefix completion, so filtering is the - ;; responsibility of each respective backend, not ours. - ;; On the other hand, we don't want to replace non-prefix input in - ;; `company-complete-common', unless there's only one candidate. - (setq company-common - (if (cdr company-candidates) - (let ((common (try-completion "" company-candidates))) - (when (string-prefix-p company-prefix common - completion-ignore-case) - common)) - (car company-candidates))))) - -(defun company-calculate-candidates (prefix) - (let ((candidates (cdr (assoc prefix company-candidates-cache))) - (ignore-case (company-call-backend 'ignore-case))) - (or candidates - (when company-candidates-cache - (let ((len (length prefix)) - (completion-ignore-case ignore-case) - prev) - (cl-dotimes (i (1+ len)) - (when (setq prev (cdr (assoc (substring prefix 0 (- len i)) - company-candidates-cache))) - (setq candidates (all-completions prefix prev)) - (cl-return t))))) - (progn - ;; No cache match, call the backend. - (setq candidates (company--preprocess-candidates - (company--fetch-candidates prefix))) - ;; Save in cache. - (push (cons prefix candidates) company-candidates-cache))) - ;; Only now apply the predicate and transformers. - (setq candidates (company--postprocess-candidates candidates)) - (when candidates - (if (or (cdr candidates) - (not (eq t (compare-strings (car candidates) nil nil - prefix nil nil ignore-case)))) - candidates - ;; Already completed and unique; don't start. - t)))) - -(defun company--fetch-candidates (prefix) - (let* ((non-essential (not (company-explicit-action-p))) - (c (if (or company-selection-changed - ;; FIXME: This is not ideal, but we have not managed to deal - ;; with these situations in a better way yet. - (company-require-match-p)) - (company-call-backend 'candidates prefix) - (company-call-backend-raw 'candidates prefix)))) - (if (not (eq (car c) :async)) - c - (let ((res 'none) - (inhibit-redisplay t)) - (funcall - (cdr c) - (lambda (candidates) - (when (eq res 'none) - (push 'company-foo unread-command-events)) - (setq res candidates))) - (if (company--flyspell-workaround-p) - (while (and (eq res 'none) - (not (input-pending-p))) - (sleep-for company-async-wait)) - (while (and (eq res 'none) - (sit-for 0.5 t)))) - (while (member (car unread-command-events) - '(company-foo (t . company-foo))) - (pop unread-command-events)) - (prog1 - (and (consp res) res) - (setq res 'exited)))))) - -(defun company--flyspell-workaround-p () - ;; https://debbugs.gnu.org/23980 - (and (bound-and-true-p flyspell-mode) - (version< emacs-version "27"))) - -(defun company--preprocess-candidates (candidates) - (cl-assert (cl-every #'stringp candidates)) - (unless (company-call-backend 'sorted) - (setq candidates (sort candidates 'string<))) - (when (company-call-backend 'duplicates) - (company--strip-duplicates candidates)) - candidates) - -(defun company--postprocess-candidates (candidates) - (when (or company-candidates-predicate company-transformers) - (setq candidates (copy-sequence candidates))) - (when company-candidates-predicate - (setq candidates (cl-delete-if-not company-candidates-predicate candidates))) - (company--transform-candidates candidates)) - -(defun company--strip-duplicates (candidates) - (let ((c2 candidates) - (annos 'unk)) - (while c2 - (setcdr c2 - (let ((str (pop c2))) - (while (let ((str2 (car c2))) - (if (not (equal str str2)) - (progn - (setq annos 'unk) - nil) - (when (eq annos 'unk) - (setq annos (list (company-call-backend - 'annotation str)))) - (let ((anno2 (company-call-backend - 'annotation str2))) - (if (member anno2 annos) - t - (push anno2 annos) - nil)))) - (pop c2)) - c2))))) - -(defun company--transform-candidates (candidates) - (let ((c candidates)) - (dolist (tr company-transformers) - (setq c (funcall tr c))) - c)) - -(defcustom company-occurrence-weight-function - #'company-occurrence-prefer-closest-above - "Function to weigh matches in `company-sort-by-occurrence'. -It's called with three arguments: cursor position, the beginning and the -end of the match." - :type '(choice - (const :tag "First above point, then below point" - company-occurrence-prefer-closest-above) - (const :tag "Prefer closest in any direction" - company-occurrence-prefer-any-closest))) - -(defun company-occurrence-prefer-closest-above (pos match-beg match-end) - "Give priority to the matches above point, then those below point." - (if (< match-beg pos) - (- pos match-end) - (- match-beg (window-start)))) - -(defun company-occurrence-prefer-any-closest (pos _match-beg match-end) - "Give priority to the matches closest to the point." - (abs (- pos match-end))) - -(defun company-sort-by-occurrence (candidates) - "Sort CANDIDATES according to their occurrences. -Searches for each in the currently visible part of the current buffer and -prioritizes the matches according to `company-occurrence-weight-function'. -The rest of the list is appended unchanged. -Keywords and function definition names are ignored." - (let* ((w-start (window-start)) - (w-end (window-end)) - (start-point (point)) - occurs - (noccurs - (save-excursion - (cl-delete-if - (lambda (candidate) - (when (catch 'done - (goto-char w-start) - (while (search-forward candidate w-end t) - (when (and (not (eq (point) start-point)) - (save-match-data - (company--occurrence-predicate))) - (throw 'done t)))) - (push - (cons candidate - (funcall company-occurrence-weight-function - start-point - (match-beginning 0) - (match-end 0))) - occurs) - t)) - candidates)))) - (nconc - (mapcar #'car (sort occurs (lambda (e1 e2) (<= (cdr e1) (cdr e2))))) - noccurs))) - -(defun company--occurrence-predicate () - (defvar comint-last-prompt) - (let ((beg (match-beginning 0)) - (end (match-end 0)) - (comint-last-prompt (bound-and-true-p comint-last-prompt))) - (save-excursion - (goto-char end) - ;; Workaround for python-shell-completion-at-point's behavior: - ;; https://github.com/company-mode/company-mode/issues/759 - ;; https://github.com/company-mode/company-mode/issues/549 - (when (derived-mode-p 'inferior-python-mode) - (let ((lbp (line-beginning-position))) - (setq comint-last-prompt (cons lbp lbp)))) - (and (not (memq (get-text-property (1- (point)) 'face) - '(font-lock-function-name-face - font-lock-keyword-face))) - (let ((prefix (company--prefix-str - (company-call-backend 'prefix)))) - (and (stringp prefix) - (= (length prefix) (- end beg)))))))) - -(defun company-sort-by-backend-importance (candidates) - "Sort CANDIDATES as two priority groups. -If `company-backend' is a function, do nothing. If it's a list, move -candidates from backends before keyword `:with' to the front. Candidates -from the rest of the backends in the group, if any, will be left at the end." - (if (functionp company-backend) - candidates - (let ((low-priority (cdr (memq :with company-backend)))) - (if (null low-priority) - candidates - (sort candidates - (lambda (c1 c2) - (and - (let ((b2 (get-text-property 0 'company-backend c2))) - (and b2 (memq b2 low-priority))) - (let ((b1 (get-text-property 0 'company-backend c1))) - (or (not b1) (not (memq b1 low-priority))))))))))) - -(defun company-sort-prefer-same-case-prefix (candidates) - "Prefer CANDIDATES with the exact same prefix. -If a backend returns case insensitive matches, candidates with the an exact -prefix match (same case) will be prioritized." - (cl-loop for candidate in candidates - if (string-prefix-p company-prefix candidate) - collect candidate into same-case - else collect candidate into other-case - finally return (append same-case other-case))) - -(defun company-idle-begin (buf win tick pos) - (and (eq buf (current-buffer)) - (eq win (selected-window)) - (eq tick (buffer-chars-modified-tick)) - (eq pos (point)) - (when (company-auto-begin) - (company-input-noop) - (let ((this-command 'company-idle-begin)) - (company-post-command))))) - -(defun company-auto-begin () - (and company-mode - (not company-candidates) - (let ((company-idle-delay 'now)) - (condition-case-unless-debug err - (progn - (company--perform) - ;; Return non-nil if active. - company-candidates) - (error (message "Company: An error occurred in auto-begin") - (message "%s" (error-message-string err)) - (company-cancel)) - (quit (company-cancel)))))) - -;;;###autoload -(defun company-manual-begin () - (interactive) - (company-assert-enabled) - (setq company--manual-action t) - (unwind-protect - (let ((company-minimum-prefix-length 0)) - (or company-candidates - (company-auto-begin))) - (unless company-candidates - (setq company--manual-action nil)))) - -(defun company-other-backend (&optional backward) - (interactive (list current-prefix-arg)) - (company-assert-enabled) - (let* ((after (if company-backend - (cdr (member company-backend company-backends)) - company-backends)) - (before (cdr (member company-backend (reverse company-backends)))) - (next (if backward - (append before (reverse after)) - (append after (reverse before))))) - (company-cancel) - (cl-dolist (backend next) - (when (ignore-errors (company-begin-backend backend)) - (cl-return t)))) - (unless company-candidates - (user-error "No other backend"))) - -(defun company-require-match-p () - (let ((backend-value (company-call-backend 'require-match))) - (or (eq backend-value t) - (and (not (eq backend-value 'never)) - (if (functionp company-require-match) - (funcall company-require-match) - (eq company-require-match t)))))) - -(defun company-auto-complete-p (input) - "Return non-nil if INPUT should trigger auto-completion." - (and (if (functionp company-auto-complete) - (funcall company-auto-complete) - company-auto-complete) - (if (functionp company-auto-complete-chars) - (funcall company-auto-complete-chars input) - (if (consp company-auto-complete-chars) - (memq (char-syntax (string-to-char input)) - company-auto-complete-chars) - (string-match (regexp-quote (substring input 0 1)) - company-auto-complete-chars))))) - -(defun company--incremental-p () - (and (> (point) company-point) - (> (point-max) company--point-max) - (not (eq this-command 'backward-delete-char-untabify)) - (equal (buffer-substring (- company-point (length company-prefix)) - company-point) - company-prefix))) - -(defun company--continue-failed (new-prefix) - (cond - ((and (or (not (company-require-match-p)) - ;; Don't require match if the new prefix - ;; doesn't continue the old one, and the latter was a match. - (not (stringp new-prefix)) - (<= (length new-prefix) (length company-prefix))) - (member company-prefix company-candidates)) - ;; Last input was a success, - ;; but we're treating it as an abort + input anyway, - ;; like the `unique' case below. - (company-cancel 'non-unique)) - ((company-require-match-p) - ;; Wrong incremental input, but required match. - (delete-char (- company-point (point))) - (ding) - (message "Matching input is required") - company-candidates) - (t (company-cancel)))) - -(defun company--good-prefix-p (prefix) - (and (stringp (company--prefix-str prefix)) ;excludes 'stop - (or (eq (cdr-safe prefix) t) - (let ((len (or (cdr-safe prefix) (length prefix)))) - (if company--manual-prefix - (or (not company-abort-manual-when-too-short) - ;; Must not be less than minimum or initial length. - (>= len (min company-minimum-prefix-length - (length company--manual-prefix)))) - (>= len company-minimum-prefix-length)))))) - -(defun company--continue () - (when (company-call-backend 'no-cache company-prefix) - ;; Don't complete existing candidates, fetch new ones. - (setq company-candidates-cache nil)) - (let* ((new-prefix (company-call-backend 'prefix)) - (c (when (and (company--good-prefix-p new-prefix) - (setq new-prefix (company--prefix-str new-prefix)) - (= (- (point) (length new-prefix)) - (- company-point (length company-prefix)))) - (company-calculate-candidates new-prefix)))) - (cond - ((eq c t) - ;; t means complete/unique. - ;; Handle it like completion was aborted, to differentiate from user - ;; calling one of Company's commands to insert the candidate, - ;; not to trigger template expansion, etc. - (company-cancel 'unique)) - ((consp c) - ;; incremental match - (setq company-prefix new-prefix) - (company-update-candidates c) - c) - ((and (> (point) company-point) - (company-auto-complete-p (buffer-substring-no-properties - (point) company-point))) - ;; auto-complete - (save-excursion - (goto-char company-point) - (let ((company--auto-completion t)) - (company-complete-selection)) - nil)) - ((not (company--incremental-p)) - (company-cancel)) - (t (company--continue-failed new-prefix))))) - -(defun company--begin-new () - (let (prefix c) - (cl-dolist (backend (if company-backend - ;; prefer manual override - (list company-backend) - company-backends)) - (setq prefix - (if (or (symbolp backend) - (functionp backend)) - (when (company--maybe-init-backend backend) - (let ((company-backend backend)) - (company-call-backend 'prefix))) - (company--multi-backend-adapter backend 'prefix))) - (when prefix - (when (company--good-prefix-p prefix) - (setq company-prefix (company--prefix-str prefix) - company-backend backend - c (company-calculate-candidates company-prefix)) - (if (not (consp c)) - (progn - (when company--manual-action - (message "No completion found")) - (when (eq c t) - ;; t means complete/unique. - ;; Run the hooks anyway, to e.g. clear the cache. - (company-cancel 'unique))) - (when company--manual-action - (setq company--manual-prefix prefix)) - (company-update-candidates c) - (run-hook-with-args 'company-completion-started-hook - (company-explicit-action-p)) - (company-call-frontends 'show))) - (cl-return c))))) - -(defun company--perform () - (or (and company-candidates (company--continue)) - (and (company--should-complete) (company--begin-new))) - (if (not company-candidates) - (setq company-backend nil) - (setq company-point (point) - company--point-max (point-max)) - (company-ensure-emulation-alist) - (company-enable-overriding-keymap company-active-map) - (company-call-frontends 'update))) - -(defun company-cancel (&optional result) - (let ((prefix company-prefix) - (backend company-backend)) - (setq company-backend nil - company-prefix nil - company-candidates nil - company-candidates-length nil - company-candidates-cache nil - company-candidates-predicate nil - company-common nil - company-selection 0 - company-selection-changed nil - company--manual-action nil - company--manual-prefix nil - company--point-max nil - company-point nil) - (when company-timer - (cancel-timer company-timer)) - (company-echo-cancel t) - (company-search-mode 0) - (company-call-frontends 'hide) - (company-enable-overriding-keymap nil) - (when prefix - ;; FIXME: RESULT can also be e.g. `unique'. We should call - ;; `company-completion-finished-hook' in that case, with right argument. - (if (stringp result) - (let ((company-backend backend)) - (run-hook-with-args 'company-completion-finished-hook result) - (company-call-backend 'post-completion result)) - (run-hook-with-args 'company-completion-cancelled-hook result)))) - ;; Make return value explicit. - nil) - -(defun company-abort () - (interactive) - (company-cancel 'abort)) - -(defun company-finish (result) - (company--insert-candidate result) - (company-cancel result)) - -(defsubst company-keep (command) - (and (symbolp command) (get command 'company-keep))) - -(defun company-pre-command () - (company--electric-restore-window-configuration) - (unless (company-keep this-command) - (condition-case-unless-debug err - (when company-candidates - (company-call-frontends 'pre-command) - (unless (company--should-continue) - (company-abort))) - (error (message "Company: An error occurred in pre-command") - (message "%s" (error-message-string err)) - (company-cancel)))) - (when company-timer - (cancel-timer company-timer) - (setq company-timer nil)) - (company-echo-cancel t) - (company-uninstall-map)) - -(defun company-post-command () - (when (and company-candidates - (null this-command)) - ;; Happens when the user presses `C-g' while inside - ;; `flyspell-post-command-hook', for example. - ;; Or any other `post-command-hook' function that can call `sit-for', - ;; or any quittable timer function. - (company-abort) - (setq this-command 'company-abort)) - (unless (company-keep this-command) - (condition-case-unless-debug err - (progn - (unless (equal (point) company-point) - (let (company-idle-delay) ; Against misbehavior while debugging. - (company--perform))) - (if company-candidates - (company-call-frontends 'post-command) - (and (or (numberp company-idle-delay) - ;; Deprecated. - (eq company-idle-delay t)) - (not defining-kbd-macro) - (company--should-begin) - (setq company-timer - (run-with-timer (company--idle-delay) nil - 'company-idle-begin - (current-buffer) (selected-window) - (buffer-chars-modified-tick) (point)))))) - (error (message "Company: An error occurred in post-command") - (message "%s" (error-message-string err)) - (company-cancel)))) - (company-install-map)) - -(defun company--idle-delay () - (if (memql company-idle-delay '(t 0 0.0)) - 0.01 - company-idle-delay)) - -(defvar company--begin-inhibit-commands '(company-abort - company-complete-mouse - company-complete - company-complete-common - company-complete-selection - company-complete-number) - "List of commands after which idle completion is (still) disabled when -`company-begin-commands' is t.") - -(defun company--should-begin () - (if (eq t company-begin-commands) - (not (memq this-command company--begin-inhibit-commands)) - (or - (memq this-command company-begin-commands) - (and (symbolp this-command) (get this-command 'company-begin))))) - -;;; search ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defcustom company-search-regexp-function #'regexp-quote - "Function to construct the search regexp from input. -It's called with one argument, the current search input. It must return -either a regexp without groups, or one where groups don't intersect and -each one wraps a part of the input string." - :type '(choice - (const :tag "Exact match" regexp-quote) - (const :tag "Words separated with spaces" company-search-words-regexp) - (const :tag "Words separated with spaces, in any order" - company-search-words-in-any-order-regexp) - (const :tag "All characters in given order, with anything in between" - company-search-flex-regexp))) - -(defvar-local company-search-string "") - -(defvar company-search-lighter '(" " - (company-search-filtering "Filter" "Search") - ": \"" - company-search-string - "\"")) - -(defvar-local company-search-filtering nil - "Non-nil to filter the completion candidates by the search string") - -(defvar-local company--search-old-selection 0) - -(defvar-local company--search-old-changed nil) - -(defun company-search-words-regexp (input) - (mapconcat (lambda (word) (format "\\(%s\\)" (regexp-quote word))) - (split-string input " +" t) ".*")) - -(defun company-search-words-in-any-order-regexp (input) - (let* ((words (mapcar (lambda (word) (format "\\(%s\\)" (regexp-quote word))) - (split-string input " +" t))) - (permutations (company--permutations words))) - (mapconcat (lambda (words) - (mapconcat #'identity words ".*")) - permutations - "\\|"))) - -(defun company-search-flex-regexp (input) - (if (zerop (length input)) - "" - (concat (regexp-quote (string (aref input 0))) - (mapconcat (lambda (c) - (concat "[^" (string c) "]*" - (regexp-quote (string c)))) - (substring input 1) "")))) - -(defun company--permutations (lst) - (if (not lst) - '(nil) - (cl-mapcan - (lambda (e) - (mapcar (lambda (perm) (cons e perm)) - (company--permutations (cl-remove e lst :count 1)))) - lst))) - -(defun company--search (text lines) - (let ((re (funcall company-search-regexp-function text)) - (i 0)) - (cl-dolist (line lines) - (when (string-match-p re line (length company-prefix)) - (cl-return i)) - (cl-incf i)))) - -(defun company-search-keypad () - (interactive) - (let* ((name (symbol-name last-command-event)) - (last-command-event (aref name (1- (length name))))) - (company-search-printing-char))) - -(defun company-search-printing-char () - (interactive) - (company--search-assert-enabled) - (let ((ss (concat company-search-string (string last-command-event)))) - (when company-search-filtering - (company--search-update-predicate ss)) - (company--search-update-string ss))) - -(defun company--search-update-predicate (ss) - (let* ((re (funcall company-search-regexp-function ss)) - (company-candidates-predicate - (and (not (string= re "")) - company-search-filtering - (lambda (candidate) (string-match re candidate)))) - (cc (company-calculate-candidates company-prefix))) - (unless cc (user-error "No match")) - (company-update-candidates cc))) - -(defun company--search-update-string (new) - (let* ((pos (company--search new (nthcdr company-selection company-candidates)))) - (if (null pos) - (ding) - (setq company-search-string new) - (company-set-selection (+ company-selection pos) t)))) - -(defun company--search-assert-input () - (company--search-assert-enabled) - (when (string= company-search-string "") - (user-error "Empty search string"))) - -(defun company-search-repeat-forward () - "Repeat the incremental search in completion candidates forward." - (interactive) - (company--search-assert-input) - (let ((pos (company--search company-search-string - (cdr (nthcdr company-selection - company-candidates))))) - (if (null pos) - (ding) - (company-set-selection (+ company-selection pos 1) t)))) - -(defun company-search-repeat-backward () - "Repeat the incremental search in completion candidates backwards." - (interactive) - (company--search-assert-input) - (let ((pos (company--search company-search-string - (nthcdr (- company-candidates-length - company-selection) - (reverse company-candidates))))) - (if (null pos) - (ding) - (company-set-selection (- company-selection pos 1) t)))) - -(defun company-search-toggle-filtering () - "Toggle `company-search-filtering'." - (interactive) - (company--search-assert-enabled) - (setq company-search-filtering (not company-search-filtering)) - (let ((ss company-search-string)) - (company--search-update-predicate ss) - (company--search-update-string ss))) - -(defun company-search-abort () - "Abort searching the completion candidates." - (interactive) - (company--search-assert-enabled) - (company-search-mode 0) - (company-set-selection company--search-old-selection t) - (setq company-selection-changed company--search-old-changed)) - -(defun company-search-other-char () - (interactive) - (company--search-assert-enabled) - (company-search-mode 0) - (company--unread-this-command-keys)) - -(defun company-search-delete-char () - (interactive) - (company--search-assert-enabled) - (if (string= company-search-string "") - (ding) - (let ((ss (substring company-search-string 0 -1))) - (when company-search-filtering - (company--search-update-predicate ss)) - (company--search-update-string ss)))) - -(defvar company-search-map - (let ((i 0) - (keymap (make-keymap))) - (if (fboundp 'max-char) - (set-char-table-range (nth 1 keymap) (cons #x100 (max-char)) - 'company-search-printing-char) - (with-no-warnings - ;; obsolete in Emacs 23 - (let ((l (generic-character-list)) - (table (nth 1 keymap))) - (while l - (set-char-table-default table (car l) 'company-search-printing-char) - (setq l (cdr l)))))) - (define-key keymap [t] 'company-search-other-char) - (while (< i ?\s) - (define-key keymap (make-string 1 i) 'company-search-other-char) - (cl-incf i)) - (while (< i 256) - (define-key keymap (vector i) 'company-search-printing-char) - (cl-incf i)) - (dotimes (i 10) - (define-key keymap (read (format "[kp-%s]" i)) 'company-search-keypad)) - (let ((meta-map (make-sparse-keymap))) - (define-key keymap (char-to-string meta-prefix-char) meta-map) - (define-key keymap [escape] meta-map)) - (define-key keymap (vector meta-prefix-char t) 'company-search-other-char) - (define-key keymap (kbd "M-n") 'company-select-next) - (define-key keymap (kbd "M-p") 'company-select-previous) - (define-key keymap (kbd "<down>") 'company-select-next-or-abort) - (define-key keymap (kbd "<up>") 'company-select-previous-or-abort) - (define-key keymap "\e\e\e" 'company-search-other-char) - (define-key keymap [escape escape escape] 'company-search-other-char) - (define-key keymap (kbd "DEL") 'company-search-delete-char) - (define-key keymap [backspace] 'company-search-delete-char) - (define-key keymap "\C-g" 'company-search-abort) - (define-key keymap "\C-s" 'company-search-repeat-forward) - (define-key keymap "\C-r" 'company-search-repeat-backward) - (define-key keymap "\C-o" 'company-search-toggle-filtering) - (dotimes (i 10) - (define-key keymap (read-kbd-macro (format "M-%d" i)) 'company-complete-number)) - keymap) - "Keymap used for incrementally searching the completion candidates.") - -(define-minor-mode company-search-mode - "Search mode for completion candidates. -Don't start this directly, use `company-search-candidates' or -`company-filter-candidates'." - nil company-search-lighter nil - (if company-search-mode - (if (company-manual-begin) - (progn - (setq company--search-old-selection company-selection - company--search-old-changed company-selection-changed) - (company-call-frontends 'update) - (company-enable-overriding-keymap company-search-map)) - (setq company-search-mode nil)) - (kill-local-variable 'company-search-string) - (kill-local-variable 'company-search-filtering) - (kill-local-variable 'company--search-old-selection) - (kill-local-variable 'company--search-old-changed) - (when company-backend - (company--search-update-predicate "") - (company-call-frontends 'update)) - (company-enable-overriding-keymap company-active-map))) - -(defun company--search-assert-enabled () - (company-assert-enabled) - (unless company-search-mode - (company-uninstall-map) - (user-error "Company not in search mode"))) - -(defun company-search-candidates () - "Start searching the completion candidates incrementally. - -\\<company-search-map>Search can be controlled with the commands: -- `company-search-repeat-forward' (\\[company-search-repeat-forward]) -- `company-search-repeat-backward' (\\[company-search-repeat-backward]) -- `company-search-abort' (\\[company-search-abort]) -- `company-search-delete-char' (\\[company-search-delete-char]) - -Regular characters are appended to the search string. - -Customize `company-search-regexp-function' to change how the input -is interpreted when searching. - -The command `company-search-toggle-filtering' (\\[company-search-toggle-filtering]) -uses the search string to filter the completion candidates." - (interactive) - (company-search-mode 1)) - -(defvar company-filter-map - (let ((keymap (make-keymap))) - (define-key keymap [remap company-search-printing-char] - 'company-filter-printing-char) - (set-keymap-parent keymap company-search-map) - keymap) - "Keymap used for incrementally searching the completion candidates.") - -(defun company-filter-candidates () - "Start filtering the completion candidates incrementally. -This works the same way as `company-search-candidates' immediately -followed by `company-search-toggle-filtering'." - (interactive) - (company-search-mode 1) - (setq company-search-filtering t)) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defun company-select-next (&optional arg) - "Select the next candidate in the list. - -With ARG, move by that many elements." - (interactive "p") - (when (company-manual-begin) - (company-set-selection (+ (or arg 1) company-selection)))) - -(defun company-select-previous (&optional arg) - "Select the previous candidate in the list. - -With ARG, move by that many elements." - (interactive "p") - (company-select-next (if arg (- arg) -1))) - -(defun company-select-next-or-abort (&optional arg) - "Select the next candidate if more than one, else abort -and invoke the normal binding. - -With ARG, move by that many elements." - (interactive "p") - (if (> company-candidates-length 1) - (company-select-next arg) - (company-abort) - (company--unread-this-command-keys))) - -(defun company-select-previous-or-abort (&optional arg) - "Select the previous candidate if more than one, else abort -and invoke the normal binding. - -With ARG, move by that many elements." - (interactive "p") - (if (> company-candidates-length 1) - (company-select-previous arg) - (company-abort) - (company--unread-this-command-keys))) - -(defun company-next-page () - "Select the candidate one page further." - (interactive) - (when (company-manual-begin) - (if (and company-selection-wrap-around - (= company-selection (1- company-candidates-length))) - (company-set-selection 0) - (let (company-selection-wrap-around) - (company-set-selection (+ company-selection - company-tooltip-limit)))))) - -(defun company-previous-page () - "Select the candidate one page earlier." - (interactive) - (when (company-manual-begin) - (if (and company-selection-wrap-around - (zerop company-selection)) - (company-set-selection (1- company-candidates-length)) - (let (company-selection-wrap-around) - (company-set-selection (- company-selection - company-tooltip-limit)))))) - -(defvar company-pseudo-tooltip-overlay) - -(defvar company-tooltip-offset) - -(defun company--inside-tooltip-p (event-col-row row height) - (let* ((ovl company-pseudo-tooltip-overlay) - (column (overlay-get ovl 'company-column)) - (width (overlay-get ovl 'company-width)) - (evt-col (car event-col-row)) - (evt-row (cdr event-col-row))) - (and (>= evt-col column) - (< evt-col (+ column width)) - (if (> height 0) - (and (> evt-row row) - (<= evt-row (+ row height) )) - (and (< evt-row row) - (>= evt-row (+ row height))))))) - -(defun company--event-col-row (event) - (company--posn-col-row (event-start event))) - -(defun company-select-mouse (event) - "Select the candidate picked by the mouse." - (interactive "e") - (let ((event-col-row (company--event-col-row event)) - (ovl-row (company--row)) - (ovl-height (and company-pseudo-tooltip-overlay - (min (overlay-get company-pseudo-tooltip-overlay - 'company-height) - company-candidates-length)))) - (if (and ovl-height - (company--inside-tooltip-p event-col-row ovl-row ovl-height)) - (progn - (company-set-selection (+ (cdr event-col-row) - (1- company-tooltip-offset) - (if (and (eq company-tooltip-offset-display 'lines) - (not (zerop company-tooltip-offset))) - -1 0) - (- ovl-row) - (if (< ovl-height 0) - (- 1 ovl-height) - 0))) - t) - (company-abort) - (company--unread-this-command-keys) - nil))) - -(defun company-complete-mouse (event) - "Insert the candidate picked by the mouse." - (interactive "e") - (when (company-select-mouse event) - (company-complete-selection))) - -(defun company-complete-selection () - "Insert the selected candidate." - (interactive) - (when (company-manual-begin) - (let ((result (nth company-selection company-candidates))) - (company-finish result)))) - -(defun company-complete-common () - "Insert the common part of all candidates." - (interactive) - (when (company-manual-begin) - (if (and (not (cdr company-candidates)) - (equal company-common (car company-candidates))) - (company-complete-selection) - (company--insert-candidate company-common)))) - -(defun company-complete-common-or-cycle (&optional arg) - "Insert the common part of all candidates, or select the next one. - -With ARG, move by that many elements." - (interactive "p") - (when (company-manual-begin) - (let ((tick (buffer-chars-modified-tick))) - (call-interactively 'company-complete-common) - (when (eq tick (buffer-chars-modified-tick)) - (let ((company-selection-wrap-around t) - (current-prefix-arg arg)) - (call-interactively 'company-select-next)))))) - -(defun company-indent-or-complete-common () - "Indent the current line or region, or complete the common part." - (interactive) - (cond - ((use-region-p) - (indent-region (region-beginning) (region-end))) - ((memq indent-line-function - '(indent-relative indent-relative-maybe)) - (company-complete-common)) - ((let ((old-point (point)) - (old-tick (buffer-chars-modified-tick)) - (tab-always-indent t)) - (call-interactively #'indent-for-tab-command) - (when (and (eq old-point (point)) - (eq old-tick (buffer-chars-modified-tick))) - (company-complete-common)))))) - -(defun company-select-next-if-tooltip-visible-or-complete-selection () - "Insert selection if appropriate, or select the next candidate. -Insert selection if only preview is showing or only one candidate, -otherwise select the next candidate." - (interactive) - (if (and (company-tooltip-visible-p) (> company-candidates-length 1)) - (call-interactively 'company-select-next) - (call-interactively 'company-complete-selection))) - -;;;###autoload -(defun company-complete () - "Insert the common part of all candidates or the current selection. -The first time this is called, the common part is inserted, the second -time, or when the selection has been changed, the selected candidate is -inserted." - (interactive) - (when (company-manual-begin) - (if (or company-selection-changed - (eq last-command 'company-complete-common)) - (call-interactively 'company-complete-selection) - (call-interactively 'company-complete-common) - (setq this-command 'company-complete-common)))) - -(defun company-complete-number (n) - "Insert the Nth candidate visible in the tooltip. -To show the number next to the candidates in some backends, enable -`company-show-numbers'. When called interactively, uses the last typed -character, stripping the modifiers. That character must be a digit." - (interactive - (list (let* ((type (event-basic-type last-command-event)) - (char (if (characterp type) - ;; Number on the main row. - type - ;; Keypad number, if bound directly. - (car (last (string-to-list (symbol-name type)))))) - (n (- char ?0))) - (if (zerop n) 10 n)))) - (when (company-manual-begin) - (and (or (< n 1) (> n (- company-candidates-length - company-tooltip-offset))) - (user-error "No candidate number %d" n)) - (cl-decf n) - (company-finish (nth (+ n company-tooltip-offset) - company-candidates)))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defconst company-space-strings-limit 100) - -(defconst company-space-strings - (let (lst) - (dotimes (i company-space-strings-limit) - (push (make-string (- company-space-strings-limit 1 i) ?\ ) lst)) - (apply 'vector lst))) - -(defun company-space-string (len) - (if (< len company-space-strings-limit) - (aref company-space-strings len) - (make-string len ?\ ))) - -(defun company-safe-substring (str from &optional to) - (let ((bis buffer-invisibility-spec)) - (if (> from (string-width str)) - "" - (with-temp-buffer - (setq buffer-invisibility-spec bis) - (insert str) - (move-to-column from) - (let ((beg (point))) - (if to - (progn - (move-to-column to) - (concat (buffer-substring beg (point)) - (let ((padding (- to (current-column)))) - (when (> padding 0) - (company-space-string padding))))) - (buffer-substring beg (point-max)))))))) - -;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar-local company-last-metadata nil) - -(defun company-fetch-metadata () - (let ((selected (nth company-selection company-candidates))) - (unless (eq selected (car company-last-metadata)) - (setq company-last-metadata - (cons selected (company-call-backend 'meta selected)))) - (cdr company-last-metadata))) - -(defun company-doc-buffer (&optional string) - (with-current-buffer (get-buffer-create "*company-documentation*") - (erase-buffer) - (when string - (save-excursion - (insert string))) - (current-buffer))) - -(defvar company--electric-saved-window-configuration nil) - -(defvar company--electric-commands - '(scroll-other-window scroll-other-window-down mwheel-scroll) - "List of Commands that won't break out of electric commands.") - -(defun company--electric-restore-window-configuration () - "Restore window configuration (after electric commands)." - (when (and company--electric-saved-window-configuration - (not (memq this-command company--electric-commands))) - (set-window-configuration company--electric-saved-window-configuration) - (setq company--electric-saved-window-configuration nil))) - -(defmacro company--electric-do (&rest body) - (declare (indent 0) (debug t)) - `(when (company-manual-begin) - (cl-assert (null company--electric-saved-window-configuration)) - (setq company--electric-saved-window-configuration (current-window-configuration)) - (let ((height (window-height)) - (row (company--row))) - ,@body - (and (< (window-height) height) - (< (- (window-height) row 2) company-tooltip-limit) - (recenter (- (window-height) row 2)))))) - -(defun company--unread-this-command-keys () - (when (> (length (this-command-keys)) 0) - (setq unread-command-events (nconc - (listify-key-sequence (this-command-keys)) - unread-command-events)) - (clear-this-command-keys t))) - -(defun company-show-doc-buffer () - "Temporarily show the documentation buffer for the selection." - (interactive) - (let (other-window-scroll-buffer) - (company--electric-do - (let* ((selected (nth company-selection company-candidates)) - (doc-buffer (or (company-call-backend 'doc-buffer selected) - (user-error "No documentation available"))) - start) - (when (consp doc-buffer) - (setq start (cdr doc-buffer) - doc-buffer (car doc-buffer))) - (setq other-window-scroll-buffer (get-buffer doc-buffer)) - (let ((win (display-buffer doc-buffer t))) - (set-window-start win (if start start (point-min)))))))) -(put 'company-show-doc-buffer 'company-keep t) - -(defun company-show-location () - "Temporarily display a buffer showing the selected candidate in context." - (interactive) - (let (other-window-scroll-buffer) - (company--electric-do - (let* ((selected (nth company-selection company-candidates)) - (location (company-call-backend 'location selected)) - (pos (or (cdr location) (user-error "No location available"))) - (buffer (or (and (bufferp (car location)) (car location)) - (find-file-noselect (car location) t)))) - (setq other-window-scroll-buffer (get-buffer buffer)) - (with-selected-window (display-buffer buffer t) - (save-restriction - (widen) - (if (bufferp (car location)) - (goto-char pos) - (goto-char (point-min)) - (forward-line (1- pos)))) - (set-window-start nil (point))))))) -(put 'company-show-location 'company-keep t) - -;;; package functions ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar-local company-callback nil) - -(defun company-remove-callback (&optional ignored) - (remove-hook 'company-completion-finished-hook company-callback t) - (remove-hook 'company-completion-cancelled-hook 'company-remove-callback t) - (remove-hook 'company-completion-finished-hook 'company-remove-callback t)) - -(defun company-begin-backend (backend &optional callback) - "Start a completion at point using BACKEND." - (interactive (let ((val (completing-read "Company backend: " - obarray - 'functionp nil "company-"))) - (when val - (list (intern val))))) - (when (setq company-callback callback) - (add-hook 'company-completion-finished-hook company-callback nil t)) - (add-hook 'company-completion-cancelled-hook 'company-remove-callback nil t) - (add-hook 'company-completion-finished-hook 'company-remove-callback nil t) - (setq company-backend backend) - ;; Return non-nil if active. - (or (company-manual-begin) - (user-error "Cannot complete at point"))) - -(defun company-begin-with (candidates - &optional prefix-length require-match callback) - "Start a completion at point. -CANDIDATES is the list of candidates to use and PREFIX-LENGTH is the length -of the prefix that already is in the buffer before point. -It defaults to 0. - -CALLBACK is a function called with the selected result if the user -successfully completes the input. - -Example: \(company-begin-with '\(\"foo\" \"foobar\" \"foobarbaz\"\)\)" - (let ((begin-marker (copy-marker (point) t))) - (company-begin-backend - (lambda (command &optional arg &rest ignored) - (pcase command - (`prefix - (when (equal (point) (marker-position begin-marker)) - (buffer-substring (- (point) (or prefix-length 0)) (point)))) - (`candidates - (all-completions arg candidates)) - (`require-match - require-match))) - callback))) - -(declare-function find-library-name "find-func") -(declare-function lm-version "lisp-mnt") - -(defun company-version (&optional show-version) - "Get the Company version as string. - -If SHOW-VERSION is non-nil, show the version in the echo area." - (interactive (list t)) - (with-temp-buffer - (require 'find-func) - (insert-file-contents (find-library-name "company")) - (require 'lisp-mnt) - (if show-version - (message "Company version: %s" (lm-version)) - (lm-version)))) - -(defun company-diag () - "Pop a buffer with information about completions at point." - (interactive) - (let* ((bb company-backends) - (mode (symbol-name major-mode)) - backend - (prefix (cl-loop for b in bb - thereis (let ((company-backend b)) - (setq backend b) - (company-call-backend 'prefix)))) - cc annotations) - (when (or (stringp prefix) (consp prefix)) - (let ((company-backend backend)) - (condition-case nil - (setq cc (company-call-backend 'candidates (company--prefix-str prefix)) - annotations - (mapcar - (lambda (c) (cons c (company-call-backend 'annotation c))) - cc)) - (error (setq annotations 'error))))) - (pop-to-buffer (get-buffer-create "*company-diag*")) - (setq buffer-read-only nil) - (erase-buffer) - (insert (format "Emacs %s (%s) of %s on %s" - emacs-version system-configuration - (format-time-string "%Y-%m-%d" emacs-build-time) - emacs-build-system)) - (insert "\nCompany " (company-version) "\n\n") - (insert "company-backends: " (pp-to-string bb)) - (insert "\n") - (insert "Used backend: " (pp-to-string backend)) - (insert "\n") - (insert "Major mode: " mode) - (insert "\n") - (insert "Prefix: " (pp-to-string prefix)) - (insert "\n") - (insert (message "Completions:")) - (unless cc (insert " none")) - (if (eq annotations 'error) - (insert "(error fetching)") - (save-excursion - (dolist (c annotations) - (insert "\n " (prin1-to-string (car c))) - (when (cdr c) - (insert " " (prin1-to-string (cdr c))))))) - (special-mode))) - -;;; pseudo-tooltip ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar-local company-pseudo-tooltip-overlay nil) - -(defvar-local company-tooltip-offset 0) - -(defun company-tooltip--lines-update-offset (selection num-lines limit) - (cl-decf limit 2) - (setq company-tooltip-offset - (max (min selection company-tooltip-offset) - (- selection -1 limit))) - - (when (<= company-tooltip-offset 1) - (cl-incf limit) - (setq company-tooltip-offset 0)) - - (when (>= company-tooltip-offset (- num-lines limit 1)) - (cl-incf limit) - (when (= selection (1- num-lines)) - (cl-decf company-tooltip-offset) - (when (<= company-tooltip-offset 1) - (setq company-tooltip-offset 0) - (cl-incf limit)))) - - limit) - -(defun company-tooltip--simple-update-offset (selection _num-lines limit) - (setq company-tooltip-offset - (if (< selection company-tooltip-offset) - selection - (max company-tooltip-offset - (- selection limit -1))))) - -;;; propertize - -(defsubst company-round-tab (arg) - (* (/ (+ arg tab-width) tab-width) tab-width)) - -(defun company-plainify (str) - (let ((prefix (get-text-property 0 'line-prefix str))) - (when prefix ; Keep the original value unmodified, for no special reason. - (setq str (concat prefix str)) - (remove-text-properties 0 (length str) '(line-prefix) str))) - (let* ((pieces (split-string str "\t")) - (copy pieces)) - (while (cdr copy) - (setcar copy (company-safe-substring - (car copy) 0 (company-round-tab (string-width (car copy))))) - (pop copy)) - (apply 'concat pieces))) - -(defun company-fill-propertize (value annotation width selected left right) - (let* ((margin (length left)) - (common (or (company-call-backend 'match value) - (if company-common - (string-width company-common) - 0))) - (_ (setq value (company--pre-render value) - annotation (and annotation (company--pre-render annotation t)))) - (ann-ralign company-tooltip-align-annotations) - (ann-truncate (< width - (+ (length value) (length annotation) - (if ann-ralign 1 0)))) - (ann-start (+ margin - (if ann-ralign - (if ann-truncate - (1+ (length value)) - (- width (length annotation))) - (length value)))) - (ann-end (min (+ ann-start (length annotation)) (+ margin width))) - (line (concat left - (if (or ann-truncate (not ann-ralign)) - (company-safe-substring - (concat value - (when (and annotation ann-ralign) " ") - annotation) - 0 width) - (concat - (company-safe-substring value 0 - (- width (length annotation))) - annotation)) - right))) - (setq width (+ width margin (length right))) - - (font-lock-append-text-property 0 width 'mouse-face - 'company-tooltip-mouse - line) - (when (< ann-start ann-end) - (font-lock-append-text-property ann-start ann-end 'face - (if selected - 'company-tooltip-annotation-selection - 'company-tooltip-annotation) - line)) - (cl-loop - with width = (- width (length right)) - for (comp-beg . comp-end) in (if (integerp common) `((0 . ,common)) common) - for inline-beg = (+ margin comp-beg) - for inline-end = (min (+ margin comp-end) width) - when (< inline-beg width) - do (font-lock-prepend-text-property inline-beg inline-end 'face - (if selected - 'company-tooltip-common-selection - 'company-tooltip-common) - line)) - (when (let ((re (funcall company-search-regexp-function - company-search-string))) - (and (not (string= re "")) - (string-match re value (length company-prefix)))) - (pcase-dolist (`(,mbeg . ,mend) (company--search-chunks)) - (let ((beg (+ margin mbeg)) - (end (+ margin mend)) - (width (- width (length right)))) - (when (< beg width) - (font-lock-prepend-text-property beg (min end width) 'face - (if selected - 'company-tooltip-search-selection - 'company-tooltip-search) - line))))) - (when selected - (font-lock-append-text-property 0 width 'face - 'company-tooltip-selection - line)) - (font-lock-append-text-property 0 width 'face - 'company-tooltip - line) - line)) - -(defun company--search-chunks () - (let ((md (match-data t)) - res) - (if (<= (length md) 2) - (push (cons (nth 0 md) (nth 1 md)) res) - (while (setq md (nthcdr 2 md)) - (when (car md) - (push (cons (car md) (cadr md)) res)))) - res)) - -(defun company--pre-render (str &optional annotation-p) - (or (company-call-backend 'pre-render str annotation-p) - (progn - (when (or (text-property-not-all 0 (length str) 'face nil str) - (text-property-not-all 0 (length str) 'mouse-face nil str)) - (setq str (copy-sequence str)) - (remove-text-properties 0 (length str) - '(face nil font-lock-face nil mouse-face nil) - str)) - str))) - -(defun company--clean-string (str) - (replace-regexp-in-string - "\\([^[:graph:] ]\\)\\|\\(\ufeff\\)\\|[[:multibyte:]]" - (lambda (match) - (cond - ((match-beginning 1) - ;; FIXME: Better char for 'non-printable'? - ;; We shouldn't get any of these, but sometimes we might. - "\u2017") - ((match-beginning 2) - ;; Zero-width non-breakable space. - "") - ((> (string-width match) 1) - (concat - (make-string (1- (string-width match)) ?\ufeff) - match)) - (t match))) - str)) - -;;; replace - -(defun company-buffer-lines (beg end) - (goto-char beg) - (let (lines lines-moved) - (while (and (not (eobp)) ; http://debbugs.gnu.org/19553 - (> (setq lines-moved (vertical-motion 1)) 0) - (<= (point) end)) - (let ((bound (min end (point)))) - ;; A visual line can contain several physical lines (e.g. with outline's - ;; folding overlay). Take only the first one. - (push (buffer-substring beg - (save-excursion - (goto-char beg) - (re-search-forward "$" bound 'move) - (point))) - lines)) - ;; One physical line can be displayed as several visual ones as well: - ;; add empty strings to the list, to even the count. - (dotimes (_ (1- lines-moved)) - (push "" lines)) - (setq beg (point))) - (unless (eq beg end) - (push (buffer-substring beg end) lines)) - (nreverse lines))) - -(defun company-modify-line (old new offset) - (concat (company-safe-substring old 0 offset) - new - (company-safe-substring old (+ offset (length new))))) - -(defsubst company--window-height () - (if (fboundp 'window-screen-lines) - (floor (window-screen-lines)) - (window-body-height))) - -(defun company--window-width () - (let ((ww (window-body-width))) - ;; Account for the line continuation column. - (when (zerop (cadr (window-fringes))) - (cl-decf ww)) - (when (bound-and-true-p display-line-numbers) - (cl-decf ww (+ 2 (line-number-display-width)))) - (unless (or (display-graphic-p) - (version< "24.3.1" emacs-version)) - ;; Emacs 24.3 and earlier included margins - ;; in window-width when in TTY. - (cl-decf ww - (let ((margins (window-margins))) - (+ (or (car margins) 0) - (or (cdr margins) 0))))) - (when (and word-wrap - (version< emacs-version "24.4.51.5")) - ;; http://debbugs.gnu.org/19300 - (cl-decf ww)) - ;; whitespace-mode with newline-mark - (when (and buffer-display-table - (aref buffer-display-table ?\n)) - (cl-decf ww (1- (length (aref buffer-display-table ?\n))))) - ww)) - -(defun company--replacement-string (lines old column nl &optional align-top) - (cl-decf column company-tooltip-margin) - - (when (and align-top company-tooltip-flip-when-above) - (setq lines (reverse lines))) - - (let ((width (length (car lines))) - (remaining-cols (- (+ (company--window-width) (window-hscroll)) - column))) - (when (> width remaining-cols) - (cl-decf column (- width remaining-cols)))) - - (let ((offset (and (< column 0) (- column))) - new) - (when offset - (setq column 0)) - (when align-top - ;; untouched lines first - (dotimes (_ (- (length old) (length lines))) - (push (pop old) new))) - ;; length into old lines. - (while old - (push (company-modify-line (pop old) - (company--offset-line (pop lines) offset) - column) - new)) - ;; Append whole new lines. - (while lines - (push (concat (company-space-string column) - (company--offset-line (pop lines) offset)) - new)) - - (let ((str (concat (when nl " \n") - (mapconcat 'identity (nreverse new) "\n") - "\n"))) - (font-lock-append-text-property 0 (length str) 'face 'default str) - (when nl (put-text-property 0 1 'cursor t str)) - str))) - -(defun company--offset-line (line offset) - (if (and offset line) - (substring line offset) - line)) - -(defun company--create-lines (selection limit) - (let ((len company-candidates-length) - (window-width (company--window-width)) - lines - width - lines-copy - items - previous - remainder - scrollbar-bounds) - - ;; Maybe clear old offset. - (when (< len (+ company-tooltip-offset limit)) - (setq company-tooltip-offset 0)) - - ;; Scroll to offset. - (if (eq company-tooltip-offset-display 'lines) - (setq limit (company-tooltip--lines-update-offset selection len limit)) - (company-tooltip--simple-update-offset selection len limit)) - - (cond - ((eq company-tooltip-offset-display 'scrollbar) - (setq scrollbar-bounds (company--scrollbar-bounds company-tooltip-offset - limit len))) - ((eq company-tooltip-offset-display 'lines) - (when (> company-tooltip-offset 0) - (setq previous (format "...(%d)" company-tooltip-offset))) - (setq remainder (- len limit company-tooltip-offset) - remainder (when (> remainder 0) - (setq remainder (format "...(%d)" remainder)))))) - - (cl-decf selection company-tooltip-offset) - (setq width (max (length previous) (length remainder)) - lines (nthcdr company-tooltip-offset company-candidates) - len (min limit len) - lines-copy lines) - - (cl-decf window-width (* 2 company-tooltip-margin)) - (when scrollbar-bounds (cl-decf window-width)) - - (dotimes (_ len) - (let* ((value (pop lines-copy)) - (annotation (company-call-backend 'annotation value))) - (setq value (company--clean-string (company-reformat value))) - (when annotation - (setq annotation (company--clean-string annotation)) - (when company-tooltip-align-annotations - ;; `lisp-completion-at-point' adds a space. - (setq annotation (comment-string-strip annotation t nil)))) - (push (cons value annotation) items) - (setq width (max (+ (length value) - (if (and annotation company-tooltip-align-annotations) - (1+ (length annotation)) - (length annotation))) - width)))) - - (setq width (min window-width - company-tooltip-maximum-width - (max company-tooltip-minimum-width - (if company-show-numbers - (+ 2 width) - width)))) - - (let ((items (nreverse items)) - (numbered (if company-show-numbers 0 99999)) - new) - (when previous - (push (company--scrollpos-line previous width) new)) - - (dotimes (i len) - (let* ((item (pop items)) - (str (car item)) - (annotation (cdr item)) - (right (company-space-string company-tooltip-margin)) - (width width)) - (when (< numbered 10) - (cl-decf width 2) - (cl-incf numbered) - (setq right (concat (format " %d" (mod numbered 10)) right))) - (push (concat - (company-fill-propertize str annotation - width (equal i selection) - (company-space-string - company-tooltip-margin) - right) - (when scrollbar-bounds - (company--scrollbar i scrollbar-bounds))) - new))) - - (when remainder - (push (company--scrollpos-line remainder width) new)) - - (nreverse new)))) - -(defun company--scrollbar-bounds (offset limit length) - (when (> length limit) - (let* ((size (ceiling (* limit (float limit)) length)) - (lower (floor (* limit (float offset)) length)) - (upper (+ lower size -1))) - (cons lower upper)))) - -(defun company--scrollbar (i bounds) - (propertize " " 'face - (if (and (>= i (car bounds)) (<= i (cdr bounds))) - 'company-scrollbar-fg - 'company-scrollbar-bg))) - -(defun company--scrollpos-line (text width) - (propertize (concat (company-space-string company-tooltip-margin) - (company-safe-substring text 0 width) - (company-space-string company-tooltip-margin)) - 'face 'company-tooltip)) - -;; show - -(defun company--pseudo-tooltip-height () - "Calculate the appropriate tooltip height. -Returns a negative number if the tooltip should be displayed above point." - (let* ((lines (company--row)) - (below (- (company--window-height) 1 lines))) - (if (and (< below (min company-tooltip-minimum company-candidates-length)) - (> lines below)) - (- (max 3 (min company-tooltip-limit lines))) - (max 3 (min company-tooltip-limit below))))) - -(defun company-pseudo-tooltip-show (row column selection) - (company-pseudo-tooltip-hide) - (save-excursion - - (let* ((height (company--pseudo-tooltip-height)) - above) - - (when (< height 0) - (setq row (+ row height -1) - above t)) - - (let* ((nl (< (move-to-window-line row) row)) - (beg (point)) - (end (save-excursion - (move-to-window-line (+ row (abs height))) - (point))) - (ov (make-overlay beg end nil t)) - (args (list (mapcar 'company-plainify - (company-buffer-lines beg end)) - column nl above))) - - (setq company-pseudo-tooltip-overlay ov) - (overlay-put ov 'company-replacement-args args) - - (let ((lines (company--create-lines selection (abs height)))) - (overlay-put ov 'company-display - (apply 'company--replacement-string lines args)) - (overlay-put ov 'company-width (string-width (car lines)))) - - (overlay-put ov 'company-column column) - (overlay-put ov 'company-height height))))) - -(defun company-pseudo-tooltip-show-at-point (pos column-offset) - (let* ((col-row (company--col-row pos)) - (col (- (car col-row) column-offset))) - (when (< col 0) (setq col 0)) - (company-pseudo-tooltip-show (1+ (cdr col-row)) col company-selection))) - -(defun company-pseudo-tooltip-edit (selection) - (let* ((height (overlay-get company-pseudo-tooltip-overlay 'company-height)) - (lines (company--create-lines selection (abs height)))) - (overlay-put company-pseudo-tooltip-overlay 'company-width - (string-width (car lines))) - (overlay-put company-pseudo-tooltip-overlay 'company-display - (apply 'company--replacement-string - lines - (overlay-get company-pseudo-tooltip-overlay - 'company-replacement-args))))) - -(defun company-pseudo-tooltip-hide () - (when company-pseudo-tooltip-overlay - (delete-overlay company-pseudo-tooltip-overlay) - (setq company-pseudo-tooltip-overlay nil))) - -(defun company-pseudo-tooltip-hide-temporarily () - (when (overlayp company-pseudo-tooltip-overlay) - (overlay-put company-pseudo-tooltip-overlay 'invisible nil) - (overlay-put company-pseudo-tooltip-overlay 'line-prefix nil) - (overlay-put company-pseudo-tooltip-overlay 'after-string nil) - (overlay-put company-pseudo-tooltip-overlay 'display nil))) - -(defun company-pseudo-tooltip-unhide () - (when company-pseudo-tooltip-overlay - (let* ((ov company-pseudo-tooltip-overlay) - (disp (overlay-get ov 'company-display))) - ;; Beat outline's folding overlays, at least. - (overlay-put ov 'priority 1) - ;; No (extra) prefix for the first line. - (overlay-put ov 'line-prefix "") - ;; `display' is better - ;; (http://debbugs.gnu.org/18285, http://debbugs.gnu.org/20847), - ;; but it doesn't work on 0-length overlays. - (if (< (overlay-start ov) (overlay-end ov)) - (overlay-put ov 'display disp) - (overlay-put ov 'after-string disp) - (overlay-put ov 'invisible t)) - (overlay-put ov 'window (selected-window))))) - -(defun company-pseudo-tooltip-guard () - (list - (save-excursion (beginning-of-visual-line)) - (window-width) - (let ((ov company-pseudo-tooltip-overlay) - (overhang (save-excursion (end-of-visual-line) - (- (line-end-position) (point))))) - (when (>= (overlay-get ov 'company-height) 0) - (cons - (buffer-substring-no-properties (point) (overlay-start ov)) - (when (>= overhang 0) overhang)))))) - -(defun company-pseudo-tooltip-frontend (command) - "`company-mode' frontend similar to a tooltip but based on overlays." - (cl-case command - (pre-command (company-pseudo-tooltip-hide-temporarily)) - (post-command - (unless (when (overlayp company-pseudo-tooltip-overlay) - (let* ((ov company-pseudo-tooltip-overlay) - (old-height (overlay-get ov 'company-height)) - (new-height (company--pseudo-tooltip-height))) - (and - (>= (* old-height new-height) 0) - (>= (abs old-height) (abs new-height)) - (equal (company-pseudo-tooltip-guard) - (overlay-get ov 'company-guard))))) - ;; Redraw needed. - (company-pseudo-tooltip-show-at-point (point) (length company-prefix)) - (overlay-put company-pseudo-tooltip-overlay - 'company-guard (company-pseudo-tooltip-guard))) - (company-pseudo-tooltip-unhide)) - (hide (company-pseudo-tooltip-hide) - (setq company-tooltip-offset 0)) - (update (when (overlayp company-pseudo-tooltip-overlay) - (company-pseudo-tooltip-edit company-selection))))) - -(defun company-pseudo-tooltip-unless-just-one-frontend (command) - "`company-pseudo-tooltip-frontend', but not shown for single candidates." - (unless (and (eq command 'post-command) - (company--show-inline-p)) - (company-pseudo-tooltip-frontend command))) - -(defun company-pseudo-tooltip-unless-just-one-frontend-with-delay (command) - "`compandy-pseudo-tooltip-frontend', but shown after a delay. -Delay is determined by `company-tooltip-idle-delay'." - (defvar company-preview-overlay) - (when (and (memq command '(pre-command hide)) - company-tooltip-timer) - (cancel-timer company-tooltip-timer) - (setq company-tooltip-timer nil)) - (cl-case command - (post-command - (if (or company-tooltip-timer - (overlayp company-pseudo-tooltip-overlay)) - (if (not (overlayp company-preview-overlay)) - (company-pseudo-tooltip-unless-just-one-frontend command) - (let (company-tooltip-timer) - (company-call-frontends 'pre-command)) - (company-call-frontends 'post-command)) - (setq company-tooltip-timer - (run-with-timer company-tooltip-idle-delay nil - 'company-pseudo-tooltip-unless-just-one-frontend-with-delay - 'post-command)))) - (t - (company-pseudo-tooltip-unless-just-one-frontend command)))) - -;;; overlay ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar-local company-preview-overlay nil) - -(defun company-preview-show-at-point (pos completion) - (company-preview-hide) - - (setq completion (copy-sequence (company--pre-render completion))) - (font-lock-append-text-property 0 (length completion) - 'face 'company-preview - completion) - (font-lock-prepend-text-property 0 (length company-common) - 'face 'company-preview-common - completion) - - ;; Add search string - (and (string-match (funcall company-search-regexp-function - company-search-string) - completion) - (pcase-dolist (`(,mbeg . ,mend) (company--search-chunks)) - (font-lock-prepend-text-property mbeg mend - 'face 'company-preview-search - completion))) - - (setq completion (company-strip-prefix completion)) - - (and (equal pos (point)) - (not (equal completion "")) - (add-text-properties 0 1 '(cursor 1) completion)) - - (let* ((beg pos) - (pto company-pseudo-tooltip-overlay) - (ptf-workaround (and - pto - (char-before pos) - (eq pos (overlay-start pto))))) - ;; Try to accomodate for the pseudo-tooltip overlay, - ;; which may start at the same position if it's at eol. - (when ptf-workaround - (cl-decf beg) - (setq completion (concat (buffer-substring beg pos) completion))) - - (setq company-preview-overlay (make-overlay beg pos)) - - (let ((ov company-preview-overlay)) - (overlay-put ov (if ptf-workaround 'display 'after-string) - completion) - (overlay-put ov 'window (selected-window))))) - -(defun company-preview-hide () - (when company-preview-overlay - (delete-overlay company-preview-overlay) - (setq company-preview-overlay nil))) - -(defun company-preview-frontend (command) - "`company-mode' frontend showing the selection as if it had been inserted." - (pcase command - (`pre-command (company-preview-hide)) - (`post-command (company-preview-show-at-point (point) - (nth company-selection company-candidates))) - (`hide (company-preview-hide)))) - -(defun company-preview-if-just-one-frontend (command) - "`company-preview-frontend', but only shown for single candidates." - (when (or (not (eq command 'post-command)) - (company--show-inline-p)) - (company-preview-frontend command))) - -(defun company--show-inline-p () - (and (not (cdr company-candidates)) - company-common - (or (eq (company-call-backend 'ignore-case) 'keep-prefix) - (string-prefix-p company-prefix company-common)))) - -(defun company-tooltip-visible-p () - "Returns whether the tooltip is visible." - (when (overlayp company-pseudo-tooltip-overlay) - (not (overlay-get company-pseudo-tooltip-overlay 'invisible)))) - -(defun company-preview-common--show-p () - "Returns whether the preview of common can be showed or not" - (and company-common - (or (eq (company-call-backend 'ignore-case) 'keep-prefix) - (string-prefix-p company-prefix company-common)))) - -(defun company-preview-common-frontend (command) - "`company-mode' frontend preview the common part of candidates." - (when (or (not (eq command 'post-command)) - (company-preview-common--show-p)) - (pcase command - (`pre-command (company-preview-hide)) - (`post-command (company-preview-show-at-point (point) company-common)) - (`hide (company-preview-hide))))) - -;;; echo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;; - -(defvar-local company-echo-last-msg nil) - -(defvar company-echo-timer nil) - -(defvar company-echo-delay .01) - -(defcustom company-echo-truncate-lines t - "Whether frontend messages written to the echo area should be truncated." - :type 'boolean - :package-version '(company . "0.9.3")) - -(defun company-echo-show (&optional getter) - (when getter - (setq company-echo-last-msg (funcall getter))) - (let ((message-log-max nil) - (message-truncate-lines company-echo-truncate-lines)) - (if company-echo-last-msg - (message "%s" company-echo-last-msg) - (message "")))) - -(defun company-echo-show-soon (&optional getter) - (company-echo-cancel) - (setq company-echo-timer (run-with-timer 0 nil 'company-echo-show getter))) - -(defun company-echo-cancel (&optional unset) - (when company-echo-timer - (cancel-timer company-echo-timer)) - (when unset - (setq company-echo-timer nil))) - -(defun company-echo-show-when-idle (&optional getter) - (company-echo-cancel) - (setq company-echo-timer - (run-with-idle-timer company-echo-delay nil 'company-echo-show getter))) - -(defun company-echo-format () - - (let ((limit (window-body-width (minibuffer-window))) - (len -1) - ;; Roll to selection. - (candidates (nthcdr company-selection company-candidates)) - (i (if company-show-numbers company-selection 99999)) - comp msg) - - (while candidates - (setq comp (company-reformat (pop candidates)) - len (+ len 1 (length comp))) - (if (< i 10) - ;; Add number. - (progn - (setq comp (propertize (format "%d: %s" i comp) - 'face 'company-echo)) - (cl-incf len 3) - (cl-incf i) - (add-text-properties 3 (+ 3 (length company-common)) - '(face company-echo-common) comp)) - (setq comp (propertize comp 'face 'company-echo)) - (add-text-properties 0 (length company-common) - '(face company-echo-common) comp)) - (if (>= len limit) - (setq candidates nil) - (push comp msg))) - - (mapconcat 'identity (nreverse msg) " "))) - -(defun company-echo-strip-common-format () - - (let ((limit (window-body-width (minibuffer-window))) - (len (+ (length company-prefix) 2)) - ;; Roll to selection. - (candidates (nthcdr company-selection company-candidates)) - (i (if company-show-numbers company-selection 99999)) - msg comp) - - (while candidates - (setq comp (company-strip-prefix (pop candidates)) - len (+ len 2 (length comp))) - (when (< i 10) - ;; Add number. - (setq comp (format "%s (%d)" comp i)) - (cl-incf len 4) - (cl-incf i)) - (if (>= len limit) - (setq candidates nil) - (push (propertize comp 'face 'company-echo) msg))) - - (concat (propertize company-prefix 'face 'company-echo-common) "{" - (mapconcat 'identity (nreverse msg) ", ") - "}"))) - -(defun company-echo-hide () - (unless (equal company-echo-last-msg "") - (setq company-echo-last-msg "") - (company-echo-show))) - -(defun company-echo-frontend (command) - "`company-mode' frontend showing the candidates in the echo area." - (pcase command - (`post-command (company-echo-show-soon 'company-echo-format)) - (`hide (company-echo-hide)))) - -(defun company-echo-strip-common-frontend (command) - "`company-mode' frontend showing the candidates in the echo area." - (pcase command - (`post-command (company-echo-show-soon 'company-echo-strip-common-format)) - (`hide (company-echo-hide)))) - -(defun company-echo-metadata-frontend (command) - "`company-mode' frontend showing the documentation in the echo area." - (pcase command - (`post-command (company-echo-show-when-idle 'company-fetch-metadata)) - (`hide (company-echo-hide)))) - -(provide 'company) -;;; company.el ends here |