;;; company.el --- Modular in-buffer completion framework -*- lexical-binding: t -*-
-;; Copyright (C) 2009-2013 Free Software Foundation, Inc.
+;; Copyright (C) 2009-2014 Free Software Foundation, Inc.
;; Author: Nikolaj Schumacher
;; Maintainer: Dmitry Gutov <dgutov@yandex.ru>
-;; Version: 0.6.8
+;; Version: 0.7.3
;; Keywords: abbrev, convenience, matching
-;; URL: http://company-mode.github.com/
-;; Compatibility: GNU Emacs 22.x, GNU Emacs 23.x, GNU Emacs 24.x
+;; URL: http://company-mode.github.io/
+;; Compatibility: GNU Emacs 23.x, GNU Emacs 24.x
;; This file is part of GNU Emacs.
;;; Code:
(eval-when-compile (require 'cl))
+(require 'newcomment)
+;; FIXME: Use `user-error'.
(add-to-list 'debug-ignored-errors "^.* frontend cannot be used twice$")
(add-to-list 'debug-ignored-errors "^Echo area cannot be used twice$")
(add-to-list 'debug-ignored-errors "^No \\(document\\|loc\\)ation available$")
:foreground "red"))
"Face used for the selected common completion in the tooltip.")
+(defface company-tooltip-annotation
+ '((default :inherit company-tooltip)
+ (((background light))
+ :foreground "firebrick4")
+ (((background dark))
+ :foreground "red4"))
+ "Face used for the 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
+ '((default :inherit company-tooltip)
+ (((background light))
+ :background "wheat")
+ (((background dark))
+ :background "gold"))
+ "Face used for the tooltip scrollbar background.")
+
(defface company-preview
- '((t :background "blue4"
- :foreground "wheat"))
+ '((((background light))
+ :inherit company-tooltip-selection)
+ (((background dark))
+ :background "blue4"
+ :foreground "wheat"))
"Face used for the completion preview.")
(defface company-preview-common
- '((t :inherit company-preview
- :foreground "red"))
+ '((((background light))
+ :inherit company-tooltip-selection)
+ (((background dark))
+ :inherit company-preview
+ :foreground "red"))
"Face used for the common part of the completion preview.")
(defface company-preview-search
- '((t :inherit company-preview
- :background "blue1"))
+ '((((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
Each front-end is a function that takes one argument. It is called with
one of the following arguments:
-'show: When the visualization should start.
+`show': When the visualization should start.
-'hide: When the visualization should end.
+`hide': When the visualization should end.
-'update: When the data has been updated.
+`update': When the data has been updated.
-'pre-command: Before every command that is executed while the
+`pre-command': Before every command that is executed while the
visualization is active.
-'post-command: After every command that is executed while the
+`post-command': After every command that is executed while the
visualization is active.
The visualized data is stored in `company-prefix', `company-candidates',
If this many lines are not available, prefer to display the tooltip above."
:type 'integer)
+(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)
+
(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")
(assq backend company-safe-backends))
(return t))))))
-(defun company-capf (command &optional arg &rest args)
- "`company-mode' back-end using `completion-at-point-functions'.
-Requires Emacs 24.1 or newer."
- (interactive (list 'interactive))
- (case command
- (interactive (company-begin-backend 'company-capf))
- (prefix
- (let ((res (run-hook-wrapped 'completion-at-point-functions
- ;; Ignore misbehaving functions.
- #'completion--capf-wrapper 'optimist)))
- (when (consp res)
- (if (> (nth 2 res) (point))
- 'stop
- (buffer-substring-no-properties (nth 1 res) (point))))))
- (candidates
- (let ((res (run-hook-wrapped 'completion-at-point-functions
- ;; Ignore misbehaving functions.
- #'completion--capf-wrapper 'optimist)))
- (when (consp res)
- (all-completions arg (nth 3 res)
- (plist-get (nthcdr 4 res) :predicate)))))))
-
-(defcustom company-backends '(company-elisp company-nxml company-css
- company-semantic company-clang company-eclim
- company-xcode company-ropemacs
- (company-gtags company-etags company-dabbrev-code
+(defvar company--include-capf (version< "24.3.50" emacs-version))
+
+(defcustom company-backends `(,@(unless company--include-capf
+ (list 'company-elisp))
+ company-bbdb
+ company-nxml company-css
+ company-eclim company-semantic company-clang
+ company-xcode company-ropemacs company-cmake
+ ,@(when company--include-capf
+ (list 'company-capf))
+ (company-dabbrev-code company-gtags company-etags
company-keywords)
company-oddmuse company-files company-dabbrev)
"The list of active back-ends (completion engines).
-Each list elements can itself be a list of back-ends. In that case their
-completions are merged. Otherwise only the first matching back-end returns
-results.
`company-begin-backend' can be used to start a specific back-end,
`company-other-backend' will skip to the next matching back-end in the list.
of the following:
`prefix': The back-end should return the text to be completed. It must be
-text immediately before `point'. Returning nil passes control to the next
-back-end. The function should return 'stop if it should complete but cannot
-\(e.g. if it is in the middle of a string\). If the returned value is only
-part of the prefix (e.g. the part after \"->\" in C), the back-end may return a
-cons of prefix and prefix length, which is then used in the
-`company-minimum-prefix-length' test.
+text immediately before point. Returning nil passes control to the next
+back-end. The function should return `stop' if it should complete but
+cannot \(e.g. if it is in the middle of a string\). Instead of a string,
+the back-end may return a cons where car is the prefix and cdr is used in
+`company-minimum-prefix-length' test. It must be either number or 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 start with the prefix.
+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 should also respond
+to `match'.
Optional commands:
-`sorted': The back-end may return t here to indicate that the candidates
-are sorted and will not need to be sorted again.
+`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.
progresses, unless the back-end returns t for this command. The second
argument is the latest prefix.
-`meta': The second argument is a completion candidate. The back-end should
-return a (short) documentation string for it.
+`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',
+
+`location': The second argument is a completion candidate. Return the cons
+of buffer and buffer location, or of file and line number where the
+completion candidate was defined.
-`doc-buffer': The second argument is a completion candidate.
-The back-end should create a buffer (preferably with `company-doc-buffer'),
-fill it with documentation and return it.
+`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.
-`location': The second argument is a completion candidate. The back-end can
-return the cons of buffer and buffer location, or of file and line
-number where the completion candidate was defined.
+`match': The second argument is a completion candidate. Backends that
+provide non-prefix completions should return the position of the end of
+text in the candidate that matches `prefix'. It will be used when
+rendering the popup.
-`require-match': If this value is t, the user is not allowed to enter anything
-not offered as a candidate. Use with care! The default value nil gives the
-user that choice with `company-require-match'. Return value 'never overrides
-that option the other way around.
+`require-match': If this returns t, the user is not allowed to enter
+anything not offered as a candidate. Use with care! 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 back-end 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.
+`init': Called once for each buffer. The back-end 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 back-end 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.
+`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 back-end 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."
+`company-begin-backend' to start itself in that case.
+
+Grouped back-ends:
+
+An element of `company-backends' can also itself be a list of back-ends,
+then it's considered to be a \"grouped\" back-end.
+
+When possible, commands taking a candidate as an argument are dispatched to
+the back-end it came from. In other cases, the first non-nil value among
+all the back-ends is returned.
+
+The latter is the case for the `prefix' command. But if the group contains
+the keyword `:with', the back-ends after it are ignored for this command.
+
+The completions from back-ends in a group are merged (but only from those
+that return the same `prefix')."
:type `(repeat
(choice
:tag "Back-end"
,@(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,
+after sorting and removal of duplicates (if appropriate).
+Each function gets called with the return value of the previous one."
+ :type '(choice
+ (const :tag "None" nil)
+ (const :tag "Sort by occurrence" (company-sort-by-occurrence))
+ (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
"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 back-end,
-consider using the `post-completion' command instead."
+If you indend to use it to post-process candidates from a specific
+back-end, consider using the `post-completion' command instead."
:type 'hook)
(defcustom company-minimum-prefix-length 3
- "The minimum prefix length for automatic completion."
+ "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)
+
(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 back-end, if it returns t or 'never to
-'require-match. `company-auto-complete' also takes precedence over this."
+This can be overridden by the back-end, 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"
(defcustom company-auto-complete nil
"Determines when to auto-complete.
-If this is enabled, all characters from `company-auto-complete-chars' complete
-the selected completion. This can also be a function."
+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"
(const :tag "On" t)))
(defcustom company-auto-complete-chars '(?\ ?\) ?.)
- "Determines which characters trigger an automatic completion.
-See `company-auto-complete'. If this is a string, each string character causes
-completion. If it is a list of syntax description characters (see
+ "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
(function :tag "Predicate function")))
(defcustom company-idle-delay .7
- "The idle delay in seconds until automatic completions starts.
-A value of nil means never complete automatically, t means complete
+ "The idle delay in seconds until completion starts automatically.
+A value of nil means no idle completion, t means show candidates
immediately when a prefix of `company-minimum-prefix-length' is reached."
:type '(choice (const :tag "never (nil)" nil)
(const :tag "immediate (t)" t)
(number :tag "seconds")))
-(defcustom company-begin-commands t
- "A list of commands following which company will start completing.
-If this is t, it will complete after any command. See `company-idle-delay'.
+(defcustom company-begin-commands '(self-insert-command org-self-insert-command)
+ "A list of commands after which idle completion is allowed.
+If this is t, it can show completions after any command. See
+`company-idle-delay'.
-Alternatively any command with a non-nil 'company-begin property is treated as
-if it was on this list."
+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)))
+(defcustom company-continue-commands '(not save-buffer save-some-buffers
+ save-buffers-kill-terminal
+ save-buffers-kill-emacs)
+ "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-end-of-buffer-workaround t
"Work around a visualization bug when completing at the end of the buffer.
The work-around consists of adding a newline.")
(and (symbolp backend)
(not (fboundp backend))
(ignore-errors (require backend nil t)))
-
- (if (or (symbolp backend)
- (functionp 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 back-end '%s' could not be initialized:\n%s"
- backend (error-message-string err)))
- (pushnew backend company--disabled-backends)
- nil))
- (mapc 'company-init-backend backend)))
+ (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 back-end '%s' could not be initialized:\n%s"
+ backend (error-message-string err)))
+ (pushnew backend company--disabled-backends)
+ nil)))
+ ;; No initialization for lambdas.
+ ((functionp backend) t)
+ (t ;; Must be a list.
+ (dolist (b backend)
+ (unless (keywordp b)
+ (company-init-backend b))))))
(defvar company-default-lighter " company")
`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 back-end, call it
-interactively or use `company-begin-backend'.
+The completion data is retrieved using `company-backends' and displayed
+using `company-frontends'. If you want to start a specific back-end, call
+it interactively or use `company-begin-backend'.
regular keymap (`company-mode-map'):
(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 ()
- (unless (or noninteractive (eq (aref (buffer-name) 0) ?\s))
+ (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 ()
;; 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: Seems not to be needed anymore in Emacs 24.4
(defun company-ignore ()
(interactive)
(setq this-command last-command))
(defun company-input-noop ()
(push 31415926 unread-command-events))
-;; Hack:
-;; posn-col-row is incorrect in older Emacsen when line-spacing is set
-(defun company--col-row (&optional pos)
- (let ((posn (posn-at-point pos)))
- (cons (car (posn-col-row posn)) (cdr (posn-actual-col-row posn)))))
-
-(defsubst company--column (&optional pos)
- (car (posn-col-row (posn-at-point pos))))
-
-(defsubst company--row (&optional pos)
- (cdr (posn-actual-col-row (posn-at-point pos))))
+(defun company--column (&optional pos)
+ (save-excursion
+ (when pos (goto-char pos))
+ (save-restriction
+ (+ (save-excursion
+ (vertical-motion 0)
+ (narrow-to-region (point) (point-max))
+ (let ((prefix (get-text-property (point) 'line-prefix)))
+ (if prefix (length prefix) 0)))
+ (current-column)))))
+
+(defun company--row (&optional pos)
+ (save-excursion
+ (when pos (goto-char pos))
+ (count-screen-lines (window-start)
+ (progn (vertical-motion 0) (point)))))
;;; backends ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
+(defvar company-backend nil)
+(make-variable-buffer-local 'company-backend)
+
(defun company-grab (regexp &optional expression limit)
(when (looking-back regexp limit)
(or (match-string-no-properties (or expression 0)) "")))
dir (file-name-directory (directory-file-name dir))))))))
(defun company-call-backend (&rest args)
- (if (functionp company-backend)
- (apply company-backend args)
- (apply 'company--multi-backend-adapter company-backend args)))
+ (condition-case err
+ (if (functionp company-backend)
+ (apply company-backend args)
+ (apply 'company--multi-backend-adapter company-backend args))
+ (error (error "Company: Back-end %s error \"%s\" with args %s"
+ company-backend (error-message-string err) args))))
(defun company--multi-backend-adapter (backends command &rest args)
(let ((backends (loop for b in backends
when (not (and (symbolp b)
(eq 'failed (get b 'company-init))))
collect b)))
+ (setq backends
+ (if (eq command 'prefix)
+ (butlast backends (length (member :with backends)))
+ (delq :with backends)))
(case command
(candidates
- (loop for backend in backends
- when (equal (funcall backend 'prefix)
- (car args))
- append (apply backend 'candidates args)))
+ ;; Small perf optimization: don't tag the candidates received
+ ;; from the first backend in the group.
+ (append (apply (car backends) 'candidates args)
+ (loop for backend in (cdr backends)
+ when (equal (funcall backend 'prefix)
+ (car args))
+ append (mapcar
+ (lambda (str)
+ (propertize str 'company-backend backend))
+ (apply backend 'candidates args)))))
(sorted nil)
(duplicates t)
- (otherwise
+ ((prefix ignore-case no-cache require-match)
(let (value)
(dolist (backend backends)
(when (setq value (apply backend command args))
- (return value))))))))
+ (return value)))))
+ (otherwise
+ (let ((arg (car args)))
+ (when (> (length arg) 0)
+ (let ((backend (or (get-text-property 0 'company-backend arg)
+ (car backends))))
+ (apply backend command args))))))))
;;; completion mechanism ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
-(defvar company-backend nil)
-(make-variable-buffer-local 'company-backend)
-
(defvar company-prefix nil)
(make-variable-buffer-local 'company-prefix)
(defvar company-selection-changed nil)
(make-variable-buffer-local 'company-selection-changed)
-(defvar company--explicit-action nil
- "Non-nil, if explicit completion took place.")
-(make-variable-buffer-local 'company--explicit-action)
+(defvar company--manual-action nil
+ "Non-nil, if manual completion took place.")
+(make-variable-buffer-local 'company--manual-action)
+
+(defvar company--manual-prefix nil)
+(make-variable-buffer-local 'company--manual-prefix)
(defvar company--auto-completion nil
- "Non-nil when current candidate is being completed automatically.
+ "Non-nil when current candidate is being inserted automatically.
Controlled by `company-auto-complete'.")
(defvar company--point-max nil)
(defsubst company-strip-prefix (str)
(substring str (length company-prefix)))
+(defun company--insert-candidate (candidate)
+ (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))
+ (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 back-ends that need candidates inserted before they
`(let ((inhibit-modification-hooks t)
(inhibit-point-motion-hooks t)
(modified-p (buffer-modified-p)))
- (insert (company-strip-prefix ,candidate))
+ (company--insert-candidate ,candidate)
(unwind-protect
(progn ,@body)
(delete-region company-point (point)))))
(defun company-explicit-action-p ()
"Return whether explicit completion action was taken by the user."
- (or company--explicit-action
+ (or company--manual-action
company-selection-changed))
-(defsubst company-reformat (candidate)
+(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.
- (concat company-prefix (substring candidate (length company-prefix))))
+ ;; 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 (not (or buffer-read-only overriding-terminal-local-map
- overriding-local-map
- (minibufferp)))
+ 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)))))
(and (symbolp this-command) (get this-command 'company-begin)))
(not (and transient-mark-mode mark-active))))
-(defsubst company-call-frontends (command)
+(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)
+ (string-match-p "\\`company-" (symbol-name this-command))))))
+
+(defun company-call-frontends (command)
(dolist (frontend company-frontends)
(condition-case err
(funcall frontend command)
(error (error "Company: Front-end %s error \"%s\" on command %s"
frontend (error-message-string err) command)))))
-(defsubst company-set-selection (selection &optional force-update)
- (setq selection (max 0 (min (1- company-candidates-length) selection)))
+(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)
(push (cons company-prefix company-candidates) company-candidates-cache)
;; Calculate common.
(let ((completion-ignore-case (company-call-backend 'ignore-case)))
- (setq company-common (company--safe-candidate
- (try-completion company-prefix company-candidates))))
- (when (eq company-common t)
- (setq company-candidates nil)))
+ ;; 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'.
+ (setq company-common
+ (if (cdr company-candidates)
+ (company--safe-candidate
+ (let ((common (try-completion company-prefix company-candidates)))
+ (if (eq common t)
+ ;; Mulple equal strings, probably with different
+ ;; annotations.
+ company-prefix
+ common)))
+ (car company-candidates)))))
(defun company--safe-candidate (str)
+ ;; XXX: This feature is deprecated.
(or (company-call-backend 'crop str)
str))
(unless (company-call-backend 'sorted)
(setq candidates (sort candidates 'string<)))
(when (company-call-backend 'duplicates)
- ;; strip duplicates
- (let ((c2 candidates))
- (while c2
- (setcdr c2 (progn (while (equal (pop c2) (car c2)))
- c2)))))))
+ (company--strip-duplicates candidates))))
+ (setq candidates (company--transform-candidates candidates))
(when candidates
(if (or (cdr candidates)
(not (eq t (compare-strings (car candidates) nil nil
;; Already completed and unique; don't start.
t))))
+(defun company--strip-duplicates (candidates)
+ (let ((c2 candidates))
+ (while c2
+ (setcdr c2
+ (let ((str (car c2))
+ (anno 'unk))
+ (pop c2)
+ (while (let ((str2 (car c2)))
+ (if (not (equal str str2))
+ nil
+ (when (eq anno 'unk)
+ (setq anno (company-call-backend
+ 'annotation str)))
+ (equal anno
+ (company-call-backend
+ 'annotation str2))))
+ (pop c2))
+ c2)))))
+
+(defun company--transform-candidates (candidates)
+ (let ((c candidates))
+ (dolist (tr company-transformers)
+ (setq c (funcall tr c)))
+ c))
+
+(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
+gives priority to the closest ones above point, then closest ones below
+point. The rest of the list is appended unchanged.
+Keywords and function definition names are ignored."
+ (let* (occurs
+ (noccurs
+ (delete-if
+ (lambda (candidate)
+ (when (or
+ (save-excursion
+ (progn (forward-line 0)
+ (search-backward candidate (window-start) t)))
+ (save-excursion
+ (search-forward candidate (window-end) t)))
+ (let ((beg (match-beginning 0))
+ (end (match-end 0)))
+ (when (save-excursion
+ (goto-char end)
+ (and (not (memq (get-text-property (point) 'face)
+ '(font-lock-function-name-face
+ font-lock-keyword-face)))
+ (let* ((prefix (company-call-backend 'prefix))
+ (prefix (or (car-safe prefix) prefix)))
+ (and (stringp prefix)
+ (= (length prefix) (- end beg))))))
+ (push (cons candidate (if (< beg (point))
+ (- (point) end)
+ (- beg (window-start))))
+ occurs)
+ t))))
+ candidates)))
+ (nconc
+ (mapcar #'car (sort occurs (lambda (e1 e2) (<= (cdr e1) (cdr e2)))))
+ noccurs)))
+
(defun company-idle-begin (buf win tick pos)
- (and company-mode
- (eq buf (current-buffer))
+ (and (eq buf (current-buffer))
(eq win (selected-window))
(eq tick (buffer-chars-modified-tick))
(eq pos (point))
- (not company-candidates)
(not (equal (point) company-point))
- (let ((company-idle-delay t)
- (company-begin-commands t))
- (company-begin)
- (when company-candidates
- (company-input-noop)
- (company-post-command)))))
+ (when (company-auto-begin)
+ (when (version< emacs-version "24.3.50")
+ (company-input-noop))
+ (company-post-command))))
(defun company-auto-begin ()
- (company-assert-enabled)
(and company-mode
(not company-candidates)
(let ((company-idle-delay t)
- (company-minimum-prefix-length 0)
(company-begin-commands t))
- (company-begin)))
+ (condition-case-no-debug err
+ (company-begin)
+ (error (message "Company: An error occurred in auto-begin")
+ (message "%s" (error-message-string err))
+ (company-cancel))
+ (quit (company-cancel)))))
+ (unless company-candidates
+ (setq company-backend nil))
;; Return non-nil if active.
company-candidates)
(defun company-manual-begin ()
(interactive)
- (setq company--explicit-action t)
+ (company-assert-enabled)
+ (setq company--manual-action t)
(unwind-protect
- (company-auto-begin)
+ (let ((company-minimum-prefix-length 0))
+ (company-auto-begin))
(unless company-candidates
- (setq company--explicit-action nil))))
+ (setq company--manual-action nil))))
(defun company-other-backend (&optional backward)
(interactive (list current-prefix-arg))
(defun company-require-match-p ()
(let ((backend-value (company-call-backend 'require-match)))
(or (eq backend-value t)
- (and (if (functionp company-require-match)
+ (and (not (eq backend-value 'never))
+ (if (functionp company-require-match)
(funcall company-require-match)
- (eq company-require-match t))
- (not (eq backend-value 'never))))))
+ (eq company-require-match t))))))
(defun company-auto-complete-p (input)
"Return non-nil, if input starts with punctuation or parentheses."
company-point)
company-prefix)))
-(defsubst company--string-incremental-p (old-prefix new-prefix)
- (and (> (length new-prefix) (length old-prefix))
- (equal old-prefix (substring new-prefix 0 (length old-prefix)))))
-
-(defun company--continue-failed (new-prefix)
- (when (company--incremental-p)
- (let ((input (buffer-substring-no-properties (point) company-point)))
- (cond
- ((company-auto-complete-p input)
- ;; auto-complete
- (save-excursion
- (goto-char company-point)
- (let ((company--auto-completion t))
- (company-complete-selection))
- nil))
- ((and (company--string-incremental-p company-prefix new-prefix)
- (company-require-match-p))
- ;; wrong incremental input, but required match
- (backward-delete-char (length input))
- (ding)
- (message "Matching input is required")
- company-candidates)
- ((equal company-prefix (car company-candidates))
- ;; last input was actually success
- (company-cancel company-prefix)
- nil)))))
+(defun company--continue-failed ()
+ (let ((input (buffer-substring-no-properties (point) company-point)))
+ (cond
+ ((company-auto-complete-p input)
+ ;; auto-complete
+ (save-excursion
+ (goto-char company-point)
+ (let ((company--auto-completion t))
+ (company-complete-selection))
+ nil))
+ ((company-require-match-p)
+ ;; wrong incremental input, but required match
+ (delete-char (- (length input)))
+ (ding)
+ (message "Matching input is required")
+ company-candidates)
+ ((equal company-prefix (car company-candidates))
+ ;; last input was actually success
+ (company-cancel company-prefix))
+ (t (company-cancel)))))
(defun company--good-prefix-p (prefix)
- (and (or (company-explicit-action-p)
- (unless (eq prefix 'stop)
- (>= (or (cdr-safe prefix) (length prefix))
- company-minimum-prefix-length)))
- (stringp (or (car-safe prefix) prefix))))
+ (and (stringp (or (car-safe prefix) 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)
(setq new-prefix (or (car-safe new-prefix) new-prefix))
(= (- (point) (length new-prefix))
(- company-point (length company-prefix))))
- (setq new-prefix (or (car-safe new-prefix) new-prefix))
(company-calculate-candidates new-prefix))))
- (or (cond
- ((eq c t)
- ;; t means complete/unique.
- (company-cancel new-prefix)
- nil)
- ((consp c)
- ;; incremental match
- (setq company-prefix new-prefix)
- (company-update-candidates c)
- c)
- (t (company--continue-failed new-prefix)))
- (company-cancel))))
+ (cond
+ ((eq c t)
+ ;; t means complete/unique.
+ (company-cancel new-prefix))
+ ((consp c)
+ ;; incremental match
+ (setq company-prefix new-prefix)
+ (company-update-candidates c)
+ c)
+ ((not (company--incremental-p))
+ (company-cancel))
+ (t (company--continue-failed)))))
(defun company--begin-new ()
(let (prefix c)
c (company-calculate-candidates prefix))
;; t means complete/unique. We don't start, so no hooks.
(if (not (consp c))
- (when company--explicit-action
+ (when company--manual-action
(message "No completion found"))
(setq company-prefix prefix)
+ (when company--manual-action
+ (setq company--manual-prefix prefix))
(when (symbolp backend)
(setq company-lighter (concat " " (symbol-name backend))))
(company-update-candidates c)
(or (and company-candidates (company--continue))
(and (company--should-complete) (company--begin-new)))
(when company-candidates
- (when (and company-end-of-buffer-workaround (eobp))
- (save-excursion (insert "\n"))
- (setq company-added-newline (buffer-chars-modified-tick)))
+ (let ((modified (buffer-modified-p)))
+ (when (and company-end-of-buffer-workaround (eobp))
+ (save-excursion (insert "\n"))
+ (setq company-added-newline
+ (or modified (buffer-chars-modified-tick)))))
(setq company-point (point)
company--point-max (point-max))
(company-ensure-emulation-alist)
(let ((tick (buffer-chars-modified-tick)))
(delete-region (1- (point-max)) (point-max))
(equal tick company-added-newline))
- ;; Only set unmodified when tick remained the same since insert.
+ ;; Only set unmodified when tick remained the same since insert,
+ ;; and the buffer wasn't modified before.
(set-buffer-modified-p nil))
(when company-prefix
(if (stringp result)
company-common nil
company-selection 0
company-selection-changed nil
- company--explicit-action nil
+ company--manual-action nil
+ company--manual-prefix nil
company-lighter company-default-lighter
company--point-max nil
company-point nil)
(cancel-timer company-timer))
(company-search-mode 0)
(company-call-frontends 'hide)
- (company-enable-overriding-keymap nil))
+ (company-enable-overriding-keymap nil)
+ ;; Make return value explicit.
+ nil)
(defun company-abort ()
(interactive)
(setq company-point (point)))
(defun company-finish (result)
- (insert (company-strip-prefix result))
+ (company--insert-candidate result)
(company-cancel result)
;; Don't start again, unless started manually.
(setq company-point (point)))
(unless (company-keep this-command)
(condition-case err
(when company-candidates
- (company-call-frontends 'pre-command))
+ (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))))
(kill-local-variable 'company-search-old-selection)
(company-enable-overriding-keymap company-active-map)))
-(defsubst company-search-assert-enabled ()
+(defun company-search-assert-enabled ()
(company-assert-enabled)
(unless company-search-mode
(company-uninstall-map)
Regular characters are appended to the search string.
-The command `company-search-kill-others' (\\[company-search-kill-others]) uses
- the search string to limit the completion candidates."
+The command `company-search-kill-others' (\\[company-search-kill-others])
+uses the search string to limit the completion candidates."
(interactive)
(company-search-mode 1)
(company-enable-overriding-keymap company-search-map))
(company-abort)
(company--unread-last-input)))
+(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)
+ (let* ((col-row (posn-actual-col-row (event-start event)))
+ (col (car col-row))
+ (row (cdr col-row)))
+ (incf col (window-hscroll))
+ (and header-line-format
+ (version< "24" emacs-version)
+ (decf row))
+ (cons col row)))
+
(defun company-select-mouse (event)
"Select the candidate picked by the mouse."
(interactive "e")
- (when (nth 4 (event-start event))
- (company-set-selection (- (cdr (posn-actual-col-row (event-start event)))
- (company--row)
- 1))
- t))
+ (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-last-input)
+ nil)))
(defun company-complete-mouse (event)
- "Complete the candidate picked by the mouse."
+ "Insert the candidate picked by the mouse."
(interactive "e")
(when (company-select-mouse event)
(company-complete-selection)))
(defun company-complete-selection ()
- "Complete the selected candidate."
+ "Insert the selected candidate."
(interactive)
(when (company-manual-begin)
(let ((result (nth company-selection company-candidates)))
(company-finish result))))
(defun company-complete-common ()
- "Complete the common part of all candidates."
+ "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)
- (insert (company-strip-prefix company-common)))))
+ (when company-common
+ (company--insert-candidate company-common)))))
(defun company-complete ()
- "Complete the common part of all candidates or the current selection.
-The first time this is called, the common part is completed, the second time, or
-when the selection has been changed, the selected candidate is completed."
+ "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
(setq this-command 'company-complete-common))))
(defun company-complete-number (n)
- "Complete the Nth candidate.
+ "Insert the Nth candidate.
To show the number next to the candidates in some back-ends, enable
`company-show-numbers'."
(when (company-manual-begin)
(push (make-string (- company-space-strings-limit 1 i) ?\ ) lst))
(apply 'vector lst)))
-(defsubst company-space-string (len)
+(defun company-space-string (len)
(if (< len company-space-strings-limit)
(aref company-space-strings len)
(make-string len ?\ )))
-(defsubst company-safe-substring (str from &optional to)
+(defun company-safe-substring (str from &optional to)
(if (> from (string-width str))
""
(with-temp-buffer
(defun company-fetch-metadata ()
(let ((selected (nth company-selection company-candidates)))
- (unless (equal selected (car company-last-metadata))
+ (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 meta-data*")
+ (with-current-buffer (get-buffer-create "*company-documentation*")
(erase-buffer)
+ (when string
+ (save-excursion
+ (insert string)))
(current-buffer)))
(defvar company--electric-commands
(setq unread-command-events (list last-input-event))))
(defun company-show-doc-buffer ()
- "Temporarily show a buffer with the complete documentation for the selection."
+ "Temporarily show the documentation buffer for the selection."
(interactive)
(company--electric-do
(let* ((selected (nth company-selection company-candidates))
(setq company-backend backend)
;; Return non-nil if active.
(or (company-manual-begin)
- (progn
- (setq company-backend nil)
- (error "Cannot complete at point"))))
+ (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.
+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.
+CALLBACK is a function called with the selected result if the user
+successfully completes the input.
-Example:
-\(company-begin-with '\(\"foo\" \"foobar\" \"foobarbaz\"\)\)"
+Example: \(company-begin-with '\(\"foo\" \"foobar\" \"foobarbaz\"\)\)"
+ ;; FIXME: When Emacs 23 is no longer a concern, replace
+ ;; `company-begin-with-marker' with a lexical variable; use a lexical closure.
(setq company-begin-with-marker (copy-marker (point) t))
(company-begin-backend
`(lambda (command &optional arg &rest ignored)
,require-match)))
callback))
+(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
+ (insert-file-contents (find-library-name "company"))
+ (require 'lisp-mnt)
+ (if show-version
+ (message "Company version: %s" (lm-version))
+ (lm-version))))
+
;;; pseudo-tooltip ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar company-pseudo-tooltip-overlay nil)
(defvar company-tooltip-offset 0)
(make-variable-buffer-local 'company-tooltip-offset)
-(defun company-pseudo-tooltip-update-offset (selection num-lines limit)
-
+(defun company-tooltip--lines-update-offset (selection num-lines limit)
(decf limit 2)
(setq company-tooltip-offset
(max (min selection company-tooltip-offset)
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-untabify (str)
+(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)
(pop copy))
(apply 'concat pieces)))
-(defun company-fill-propertize (line width selected)
- (setq line (company-safe-substring line 0 width))
- (add-text-properties 0 width '(face company-tooltip
- mouse-face company-tooltip-mouse)
- line)
- (add-text-properties 0 (length company-common)
- '(face company-tooltip-common
- mouse-face company-tooltip-mouse)
- line)
- (when selected
- (if (and company-search-string
- (string-match (regexp-quote company-search-string) line
- (length company-prefix)))
- (progn
- (add-text-properties (match-beginning 0) (match-end 0)
- '(face company-tooltip-selection)
- line)
- (when (< (match-beginning 0) (length company-common))
- (add-text-properties (match-beginning 0) (length company-common)
- '(face company-tooltip-common-selection)
- line)))
- (add-text-properties 0 width '(face company-tooltip-selection
- mouse-face company-tooltip-selection)
- line)
- (add-text-properties 0 (length company-common)
- '(face company-tooltip-common-selection
- mouse-face company-tooltip-selection)
- line)))
- line)
+(defun company-fill-propertize (value annotation width selected left right)
+ (let* ((margin (length left))
+ (common (+ (or (company-call-backend 'match value)
+ (length company-common)) margin))
+ (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)))
+
+ (add-text-properties 0 width '(face company-tooltip
+ mouse-face company-tooltip-mouse)
+ line)
+ (add-text-properties margin common
+ '(face company-tooltip-common
+ mouse-face company-tooltip-mouse)
+ line)
+ (when (< ann-start ann-end)
+ (add-text-properties ann-start ann-end
+ '(face company-tooltip-annotation
+ mouse-face company-tooltip-mouse)
+ line))
+ (when selected
+ (if (and company-search-string
+ (string-match (regexp-quote company-search-string) value
+ (length company-prefix)))
+ (let ((beg (+ margin (match-beginning 0)))
+ (end (+ margin (match-end 0))))
+ (add-text-properties beg end '(face company-tooltip-selection)
+ line)
+ (when (< beg common)
+ (add-text-properties beg common
+ '(face company-tooltip-common-selection)
+ line)))
+ (add-text-properties 0 width '(face company-tooltip-selection
+ mouse-face company-tooltip-selection)
+ line)
+ (add-text-properties margin common
+ '(face company-tooltip-common-selection
+ mouse-face company-tooltip-selection)
+ line)))
+ line))
;;; replace
(defun company-buffer-lines (beg end)
(goto-char beg)
(let (lines)
- (while (< (point) end)
- (let ((bol (point)))
+ (while (and (= 1 (vertical-motion 1))
+ (<= (point) end))
+ (let ((bound (min end (1- (point)))))
;; A visual line can contain several physical lines (e.g. with outline's
;; folding overlay). Take only the first one.
- (re-search-forward "$")
- (push (buffer-substring bol (min end (point))) lines))
- (vertical-motion 1))
+ (push (buffer-substring beg
+ (save-excursion
+ (goto-char beg)
+ (re-search-forward "$" bound 'move)
+ (point)))
+ lines))
+ (setq beg (point)))
+ (unless (eq beg end)
+ (push (buffer-substring beg end) lines))
(nreverse lines)))
-(defsubst company-modify-line (old new offset)
+(defun company-modify-line (old new offset)
(concat (company-safe-substring old 0 offset)
new
(company-safe-substring old (+ offset (length new)))))
(length lst)))
(defun company--replacement-string (lines old column nl &optional align-top)
+ (decf column company-tooltip-margin)
- (let ((width (length (car lines))))
- (when (> width (- (window-width) column))
- (setq column (max 0 (- (window-width) width)))))
+ (let ((width (length (car lines)))
+ (remaining-cols (- (+ (company--window-width) (window-hscroll))
+ column)))
+ (when (> width remaining-cols)
+ (decf column (- width remaining-cols))))
- (let (new)
+ (let ((offset (and (< column 0) (- column)))
+ new)
+ (when offset
+ (setq column 0))
(when align-top
;; untouched lines first
- (dotimes (i (- (length old) (length lines)))
+ (dotimes (_ (- (length old) (length lines)))
(push (pop old) new)))
;; length into old lines.
(while old
- (push (company-modify-line (pop old) (pop lines) column) new))
+ (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) (pop lines)) new))
+ (push (concat (company-space-string column)
+ (company--offset-line (pop lines) offset))
+ new))
(let ((str (concat (when nl "\n")
(mapconcat 'identity (nreverse new) "\n")
(font-lock-append-text-property 0 (length str) 'face 'default str)
str)))
-(defun company--create-lines (selection limit)
+(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)
(numbered 99999)
+ (window-width (company--window-width))
lines
width
lines-copy
+ items
previous
remainder
- new)
-
- ;; Scroll to offset.
- (setq limit (company-pseudo-tooltip-update-offset selection len limit))
+ scrollbar-bounds)
- (when (> company-tooltip-offset 0)
- (setq previous (format "...(%d)" company-tooltip-offset)))
+ ;; Maybe clear old offset.
+ (when (< len (+ company-tooltip-offset limit))
+ (setq company-tooltip-offset 0))
- (setq remainder (- len limit company-tooltip-offset)
- remainder (when (> remainder 0)
- (setq remainder (format "...(%d)" remainder))))
+ ;; 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))))))
(decf selection company-tooltip-offset)
(setq width (max (length previous) (length remainder))
len (min limit len)
lines-copy lines)
- (dotimes (i len)
- (setq width (max (length (pop lines-copy)) width)))
- (setq width (min width (window-width)))
-
- (setq lines-copy lines)
+ (decf window-width (* 2 company-tooltip-margin))
+ (when scrollbar-bounds (decf window-width))
+
+ (dotimes (_ len)
+ (let* ((value (pop lines-copy))
+ (annotation (company-call-backend 'annotation value)))
+ (when (and annotation 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
+ (if (and company-show-numbers
+ (< company-tooltip-offset 10))
+ (+ 2 width)
+ width)))
;; number can make tooltip too long
(when company-show-numbers
(setq numbered company-tooltip-offset))
- (when previous
- (push (propertize (company-safe-substring previous 0 width)
- 'face 'company-tooltip)
- new))
-
- (dotimes (i len)
- (push (company-fill-propertize
- (if (>= numbered 10)
- (company-reformat (pop lines))
- (incf numbered)
- (format "%s %d"
- (company-safe-substring (company-reformat (pop lines))
- 0 (- width 2))
- (mod numbered 10)))
- width (equal i selection))
- new))
-
- (when remainder
- (push (propertize (company-safe-substring remainder 0 width)
- 'face 'company-tooltip)
- new))
-
- (setq lines (nreverse new))))
+ (let ((items (nreverse items)) new)
+ (when previous
+ (push (company--scrollpos-line previous width) new))
+
+ (dotimes (i len)
+ (let* ((item (pop items))
+ (str (company-reformat (car item)))
+ (annotation (cdr item))
+ (right (company-space-string company-tooltip-margin))
+ (width width))
+ (when (< numbered 10)
+ (decf width 2)
+ (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
(defsubst company--window-inner-height ()
- (let ((edges (window-inside-edges (selected-window))))
+ (let ((edges (window-inside-edges)))
(- (nth 3 edges) (nth 1 edges))))
-(defsubst company--pseudo-tooltip-height ()
+(defsubst company--window-width ()
+ (- (window-width)
+ (cond
+ ((display-graphic-p) 0)
+ ;; Account for the line continuation column.
+ ((version< "24.3.1" emacs-version) 1)
+ ;; Emacs 24.3 and earlier included margins
+ ;; in window-width when in TTY.
+ (t (1+ (let ((margins (window-margins)))
+ (+ (or (car margins) 0)
+ (or (cdr margins) 0))))))))
+
+(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))
(company-pseudo-tooltip-hide)
(save-excursion
- (move-to-column 0)
-
(let* ((height (company--pseudo-tooltip-height))
above)
(move-to-window-line (+ row (abs height)))
(point)))
(ov (make-overlay beg end))
- (args (list (mapcar 'company-untabify
+ (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)
- (overlay-put ov 'company-before
- (apply 'company--replacement-string
- (company--create-lines selection (abs height))
- args))
+
+ (let ((lines (company--create-lines selection (abs height))))
+ (overlay-put ov 'company-after
+ (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)
- (let ((col-row (company--col-row pos)))
- (when col-row
- (company-pseudo-tooltip-show (1+ (cdr col-row)) (car col-row)
- company-selection))))
-
-(defun company-pseudo-tooltip-edit (lines selection)
- (let ((column (overlay-get company-pseudo-tooltip-overlay 'company-column))
- (height (overlay-get company-pseudo-tooltip-overlay 'company-height)))
- (overlay-put company-pseudo-tooltip-overlay 'company-before
+ (let ((row (company--row pos))
+ (col (company--column pos)))
+ (company-pseudo-tooltip-show (1+ row) col company-selection)))
+
+(defun company-pseudo-tooltip-edit (selection)
+ (let ((height (overlay-get company-pseudo-tooltip-overlay 'company-height)))
+ (overlay-put company-pseudo-tooltip-overlay 'company-after
(apply 'company--replacement-string
(company--create-lines selection (abs height))
(overlay-get company-pseudo-tooltip-overlay
(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 'before-string nil)))
+ (overlay-put company-pseudo-tooltip-overlay 'line-prefix nil)
+ (overlay-put company-pseudo-tooltip-overlay 'after-string nil)))
(defun company-pseudo-tooltip-unhide ()
(when company-pseudo-tooltip-overlay
(overlay-put company-pseudo-tooltip-overlay 'invisible t)
;; Beat outline's folding overlays, at least.
(overlay-put company-pseudo-tooltip-overlay 'priority 1)
- (overlay-put company-pseudo-tooltip-overlay 'before-string
- (overlay-get company-pseudo-tooltip-overlay 'company-before))
+ ;; No (extra) prefix for the first line.
+ (overlay-put company-pseudo-tooltip-overlay 'line-prefix "")
+ (overlay-put company-pseudo-tooltip-overlay 'after-string
+ (overlay-get company-pseudo-tooltip-overlay 'company-after))
(overlay-put company-pseudo-tooltip-overlay 'window (selected-window))))
(defun company-pseudo-tooltip-guard ()
(hide (company-pseudo-tooltip-hide)
(setq company-tooltip-offset 0))
(update (when (overlayp company-pseudo-tooltip-overlay)
- (company-pseudo-tooltip-edit company-candidates
- company-selection)))))
+ (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)
- (not (cdr company-candidates)))
+ (company--show-inline-p))
(company-pseudo-tooltip-frontend command)))
;;; overlay ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun company-preview-show-at-point (pos)
(company-preview-hide)
- (setq company-preview-overlay (make-overlay pos pos))
+ (setq company-preview-overlay (make-overlay pos (1+ pos)))
- (let ((completion(nth company-selection company-candidates)))
+ (let ((completion (nth company-selection company-candidates)))
(setq completion (propertize completion 'face 'company-preview))
(add-text-properties 0 (length company-common)
'(face company-preview-common) completion)
(not (equal completion ""))
(add-text-properties 0 1 '(cursor t) completion))
- (overlay-put company-preview-overlay 'after-string completion)
+ (overlay-put company-preview-overlay 'display
+ (concat completion (unless (eq pos (point-max))
+ (buffer-substring pos (1+ pos)))))
(overlay-put company-preview-overlay 'window (selected-window))))
(defun company-preview-hide ()
(defun company-preview-if-just-one-frontend (command)
"`company-preview-frontend', but only shown for single candidates."
- (unless (and (eq command 'post-command)
- (cdr company-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
+ (string-prefix-p company-prefix company-common
+ (company-call-backend 'ignore-case))))
+
;;; echo ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defvar company-echo-last-msg nil)
(message "%s" company-echo-last-msg)
(message ""))))
-(defsubst company-echo-show-soon (&optional getter)
+(defun company-echo-show-soon (&optional getter)
(when company-echo-timer
(cancel-timer company-echo-timer))
(setq company-echo-timer (run-with-timer 0 nil 'company-echo-show getter)))
(defsubst company-echo-show-when-idle (&optional getter)
- (when (sit-for .01)
- (company-echo-show getter)))
-
-(defsubst company-echo-show-when-not-busy (&optional getter)
- "Run `company-echo-show' with arg GETTER once Emacs isn't busy."
(when (sit-for company-echo-delay)
(company-echo-show getter)))