rc

;; Copyright (C) 2009-2024  Free Software Foundation, Inc.

;; FIXED by Maarten Vangeneugden on 2024/11/21 (L2516)

;; Author: Nikolaj Schumacher

;; Maintainer: Dmitry Gutov <dmitry@gutov.dev>

;; URL: http://company-mode.github.io/

;; Package-Version: 20241106.2000

;; Package-Revision: 0ae7c2931122

;; Keywords: abbrev, convenience, matching

;; Package-Requires: ((emacs "26.1"))

;; 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 <https://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 'subr-x)

(require 'pcase)

(defgroup company nil

  "Extensible inline text completion mechanism."

  :group 'abbrev

  :group 'convenience

  :group 'matching

  :link '(custom-manual "(company) Top"))

(defgroup company-faces nil

  "Faces used by Company."

  :group 'company

  :group 'faces)

(defface company-tooltip

  '((((class color) (min-colors 88) (background light))

     (:foreground "black" :background "cornsilk"))

    (((class color) (min-colors 88) (background dark))

     (:background "gray26"))

    (t (:foreground "black" :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 "gray31"))

    (t (:background "green")))

  "Face used for the selection in the tooltip.")

(defface company-tooltip-deprecated

  '((t (:strike-through t)))

  "Face used for the deprecated items.")

(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 "pale turquoise"))

  "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 "LightCyan3"))

  "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-tooltip-quick-access

  '((default :inherit company-tooltip-annotation))

  "Face used for the quick-access hints shown in the tooltip."

  :package-version '(company . "0.10.0"))

(defface company-tooltip-quick-access-selection

  '((default :inherit company-tooltip-annotation-selection))

  "Face used for the selected quick-access hints shown in the tooltip."

  :package-version '(company . "0.10.0"))

(define-obsolete-face-alias

 'company-scrollbar-fg

 'company-tooltip-scrollbar-thumb

 "0.10.0")

(defface company-tooltip-scrollbar-thumb

  '((((background light))

     :background "indian red")

    (((background dark))

     :background "gray33"))

  "Face used for the tooltip scrollbar thumb (bar).")

(define-obsolete-face-alias

 'company-scrollbar-bg

 'company-tooltip-scrollbar-track

 "0.10.0")

(defface company-tooltip-scrollbar-track

  '((((background light))

     :background "wheat")

    (((background dark))

     :background "gray28"))

  "Face used for the tooltip scrollbar track (trough).")

(defface company-preview

  '((default :inherit (company-tooltip-selection company-tooltip)))

  "Face used for the completion preview.")

(defface company-preview-common

  '((default :inherit company-tooltip-common-selection))

  "Face used for the common part of the completion preview.")

(defface company-preview-search

  '((default :inherit company-tooltip-common-selection))

  "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 light)) (:foreground "firebrick4"))

    (((background dark)) (:foreground "firebrick1")))

  "Face used for the common part of completions in the echo area.")

;; Too lazy to re-add :group to all defcustoms down below.

(setcdr (assoc load-file-name custom-current-group-alist)

        'company)

(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.

`unhide': When an asynchronous backend is waiting for its completions.

Only needed in frontends which hide their visualizations in `pre-command'

for technical reasons.

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

  "Ensure visibility of this number of candidates.

When that many lines are not available between point and the bottom of the

window, display the tooltip above point."

  :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-width-grow-only nil

  "When non-nil, the tooltip width is not allowed to decrease."

  :type 'boolean

  :package-version '(company . "0.10.0"))

(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-scrollbar-width 0.4

  "Width of the scrollbar thumb, in columns."

  :type 'number

  :package-version '(company . "1.0.0"))

(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"))

(defcustom company-tooltip-annotation-padding nil

  "Non-nil to specify the padding before annotation.

Depending on the value of `company-tooltip-align-annotations', the default

padding is either 0 or 1 space.  This variable allows to override that

value to increase the padding.  When annotations are right-aligned, it sets

the minimum padding, and otherwise just the constant one."

  :type 'number

  :package-version '(company "0.10.0"))

(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 (obsolete backend)")

    (company-dabbrev . "dabbrev for plain text")

    (company-dabbrev-code . "dabbrev for code")

    (company-elisp . "Emacs Lisp (obsolete backend)")

    (company-etags . "etags")

    (company-files . "Files")

    (company-gtags . "GNU Global")

    (company-ispell . "Ispell")

    (company-keywords . "Programming language keywords")

    (company-nxml . "nxml (obsolete backend)")

    (company-oddmuse . "Oddmuse")

    (company-semantic . "Semantic")

    (company-tempo . "Tempo templates")))

(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 `(company-bbdb

                              ,@(unless (version<= "26" emacs-version)

                                  (list 'company-nxml))

                              ,@(unless (version<= "26" emacs-version)

                                  (list 'company-css))

                              company-semantic

                              company-cmake

                              company-capf

                              company-clang

                              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.

To debug which backend is currently in use, try `M-x company-diag'.

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.  Returning

nil from this command passes control to the next backend.

The expected return value looks like (PREFIX SUFFIX &optional PREFIX-LEN).

Where PREFIX is the text to be completed before point, SUFFIX - the

remainder after point (when e.g. inside a symbol), and PREFIX-LEN, when

non-nil, is the number to use in place of PREFIX's length when comparing

against `company-minimum-prefix-length'.  PREFIX-LEN can also be just t,

and in the latter case the test automatically succeeds.

The return value can also be just PREFIX, in which case SUFFIX is taken to

be an empty string.

`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 in response to `no-cache') and might

also want to handle `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.

`deprecated': The second argument is a completion candidate.  Return

non-nil if the completion candidate is deprecated.

`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 (using that value will indicate that the returned set of

completions is often incomplete, so this behavior will not be useful).

`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.

`kind': The second argument is a completion candidate.  Return a symbol

describing the kind of the candidate.  Refer to `company-vscode-icons-mapping'

for the possible values.

`adjust-boundaries': The second argument is prefix and the third argument

is suffix (previously returned by the `prefix' command).  Return a

cons (NEW-PREFIX . NEW-SUFFIX) where both parts correspond to the

completion candidate.

`expand-common': The first argument is prefix and the second argument is

suffix.  Return a cons (NEW-PREFIX . NEW-SUFFIX) that denote an edit in the

current buffer which would be performed by `company-complete-common'.  It

should try to make the combined length of the prefix and suffix longer,

while ensuring that the completions for the new inputs are the same.

Othewise return the original inputs.  If there are no matching completions,

return the symbol `no-match'.

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-after-completion-hook nil

  "Hook run at the end of completion, successful or not.

The hook is called with one argument which is either a string or a symbol."

  :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-abort-on-unique-match t

  "If non-nil, typing a full unique match aborts completion.

You can still invoke `company-complete' manually to run the

`post-completion' handler, though.

If it's nil, completion will remain active until you type a prefix that

doesn't match anything or finish it manually, e.g. with RET."

  :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 backend, if it returns t or `never' to

`require-match'.  `company-insertion-on-trigger' 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)))

(define-obsolete-variable-alias

  'company-auto-complete

  'company-insertion-on-trigger

  "0.10.0")

(define-obsolete-variable-alias

  'company-auto-commit

  'company-insertion-on-trigger

  "0.10.0")

(defcustom company-insertion-on-trigger nil

  "If enabled, allow triggering insertion of the selected candidate.

This can also be a predicate function, for example,

`company-explicit-action-p'.

See `company-insertion-triggers' for more details on how to define

triggers."

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

  :package-version '(company . "0.10.0"))

(define-obsolete-variable-alias

  'company-auto-complete-chars

  'company-insertion-triggers

  "0.10.0")

(define-obsolete-variable-alias

  'company-auto-commit-chars

  'company-insertion-triggers

  "0.10.0")

(defcustom company-insertion-triggers '(?\  ?\) ?.)

  "Determine triggers for `company-insertion-on-trigger'.

If this is a string, then each character in it can trigger insertion of the

selected candidate.  If it is a list of syntax description characters (see

`modify-syntax-entry'), then characters with any of those syntaxes can act

as triggers.

This can also be a function, which is called with the new input.  To

trigger insertion, the function should return a non-nil value.

Note that a character that is part of a valid completion never triggers

insertion."

  :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"))

  :package-version '(company . "0.10.0"))

(defcustom company-idle-delay .2

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

                 (function :tag "Predicate function")

                 (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-inhibit-inside-symbols nil

  "Non-nil to inhibit idle completion when typing in the middle of a symbol.

The symbol is in a generalized sense, indicated by the `prefix' backend

action returning a non-empty SUFFIX element.  When this variable is

non-nil, completion inside symbol will onlytriggered by an explicit command

invocation, such as \\[company-complete-common]."

  :type 'boolean

  :package-version '(company . "1.0.0"))

(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

                                           complete-symbol

                                           completion-help-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)))

(defun company-custom--set-quick-access (option value)

  "Re-bind quick-access key sequences on OPTION VALUE change."

  ;; When upgrading from an earlier version of company, might not be.