moving to official corfu module PR

This commit is contained in:
Matt Nish-Lapidus 2023-11-04 13:44:50 -04:00
parent e4f80a2bc7
commit f6aae022ff
4 changed files with 0 additions and 499 deletions

View file

@ -1,173 +0,0 @@
#+title: :completion corfu
#+subtitle: Complete with cap(f), cape and a flying feather
#+created: September 9, 2022
#+since: 3.0.0 (#7002)
* Description :unfold:
This module provides code completion, powered by [[doom-package:corfu]].
It is recommended to enable either this or [[doom-module::completion company]], in case you
desire pre-configured auto-completion. Corfu is much lighter weight and focused,
plus it's built on native Emacs functionality, whereas company is heavy and
highly non-native, but has some extra features and more maturity.
** Maintainers
- [[doom-user:][@LuigiPiucco]]
[[doom-contrib-maintainer:][Become a maintainer?]]
** Module flags
- +icons ::
Display icons beside completion suggestions.
- +tng ::
Invoke completion on [[kbd:][TAB]]. When corfu is active, [[kbd:][TAB]] and [[kbd:][S-TAB]] will navigate
the completion candidates. Arrow keys and evil-style movement are still
supported.
- +orderless ::
Pull in [[doom-package:orderless]] if necessary and apply multi-component
completion (still needed if [[doom-module::completion vertico]] is active).
** Packages
- [[doom-package:corfu]]
- [[doom-package:cape]]
- [[doom-package:nerd-icons-completion]] if [[doom-module::completion corfu +icons]]
- [[doom-package:nerd-icons-corfu]] if [[doom-module::completion corfu +icons]]
- [[doom-package:orderless]] if [[doom-module::completion corfu +orderless]]
- [[doom-package:corfu-terminal]] if [[doom-module::os tty]]
- [[doom-package:yasnippet-capf]] if [[doom-module::editor snippets]]
** Hacks
/No hacks documented for this module./
** TODO Changelog
# This section will be machine generated. Don't edit it by hand.
/This module does not have a changelog yet./
* Installation
Enable this module in your ~doom!~ block.
This module has no direct requirements, but some languages may have their own
requirements to fulfill before you get code completion in them (and some
languages may lack code completion support altogether). Run ~$ doom doctor~ to
find out if you're missing any dependencies. Note that corfu may have support
for completions in languages that have no development intelligence, since it
supports generic, context insensitive candidates such as file names or recurring
words. Snippets may also appear in the candidate list if available.
* TODO Usage
#+begin_quote
🔨 /This module's usage documentation is incomplete./ [[doom-contrib-module:][Complete it?]]
#+end_quote
** Code completion
By default, completion gets triggered after typing 2 non-space consecutive
characters, or by means of the [[kbd:][C-SPC]] keybinding at any moment. While the popup
is visible, the following relevant keys are available:
| Keybind | Description |
|----------+---------------------------------------------------------|
| [[kbd:][<down>]] | Go to next candidate |
| [[kbd:][<up>]] | Go to previous candidate |
| [[kbd:][C-n]] | Go to next candidate |
| [[kbd:][C-p]] | Go to previous candidate |
| [[kbd:][C-j]] | (evil) Go to next candidate |
| [[kbd:][C-k]] | (evil) Go to previous candidate |
| [[kbd:][C-<down>]] | Go to next doc line |
| [[kbd:][C-<up>]] | Go to previous doc line |
| [[kbd:][C-S-n]] | Go to next doc line |
| [[kbd:][C-S-p]] | Go to previous doc line |
| [[kbd:][C-S-j]] | (evil) Go to next doc line |
| [[kbd:][C-S-k]] | (evil) Go to previous doc line |
| [[kbd:][C-h]] | Toggle documentation (if available) |
| [[kbd:][M-m]] | Export to minibuffer (if [[doom-module::completion vertico]]) |
| [[kbd:][M-j]] | (evil) Export to minibuffer (if [[doom-module::completion vertico]]) |
| [[kbd:][RET]] | Insert candidate |
| [[kbd:][SPC]] | Quit autocompletion after a wildcard or pass-through |
| [[kbd:][C-SPC]] | (when completing) Insert separator (see below) |
| [[kbd:][C-SPC]] | Complete (unless [[doom-module::completion corfu +tng]]) |
If you prefer a [[kbd:][TAB]]-centric completion style, enable the [[doom-module::completion corfu +tng]]
flag so that, instead, you trigger completion with [[kbd:][TAB]], getting the following
additional binds:
| Keybind | Description |
|---------+-----------------------------------------------|
| [[kbd:][TAB]] | Complete |
| [[kbd:][TAB]] | (when completing) Go to next candidate |
| [[kbd:][S-TAB]] | (when completing) Go to previous candidate |
| [[kbd:][DEL]] | (when completing) Reset completion DWIM-style |
** Searching with multiple keywords
If the [[doom-module::completion corfu +orderless]] flag is enabled, users can perform code
completion with multiple search keywords by use of space as the separator. More
information can be found [[https://github.com/oantolin/orderless#company][here]]. Pressing [[kdb:][C-SPC]] again while completing inserts a
space as separator. This allows searching with space-separated terms; each piece
will match individually and in any order, with smart casing. Pressing just [[kbd:][SPC]]
acts as normal and restarts completion, so that when typing sentences it doesn't
try to complete the whole sentence instead of just the word.
Furthermore, if you also have [[var:+orderless-wildcard-character]] set (by default
it's the comma key), then that character acts as a wildcard when typed
mid-completion.
** Exporting to the minibuffer (requires [[doom-module::completion vertico]])
When using the [[doom-module::completion vertico]] module, which pulls in the
[[doom-package:consult]] package, the entries shown in the completion popup can be
exported to a consult minibuffer, giving access to all the manipulations the
vertico suite allows. For instance, one could use this to export with
[[doom-package:embark]] via [[kbd:][C-c C-l]] and get a buffer with all candidates.
* Configuration
A few variables may be set to change behavior of this module:
- [[var:corfu-auto-delay]] ::
Number of seconds till completion occurs automatically. Defaults to 0.1.
- [[var:corfu-auto-prefix]] ::
Number of characters till auto-completion starts to happen. Defaults to 2.
- [[var:corfu-on-exact-match]] ::
Configures behavior for exact matches. Its default is nil, and it's
recommended to leave it at that. Otherwise, single matches on snippet keys
expand immediately.
- [[var:+orderless-wildcard-character]] ::
Used for fuzzy-matching corfu invocations as an escapable alternative to
~corfu-separator~. Defaults to comma.
- [[var:+cape-buffer-scanning-size-limit:]] ::
Sets the maximum buffer size to be scanned by ~cape-dabbrev~ and
~cape-lines~. Defaults to 1 MB. Set this if you are having performance
problems using ~cape-dabbrev~.
** Adding CAPFs to a mode
To add other CAPFs on a mode-per-mode basis, put either of the following in your
~config.el~:
#+begin_src emacs-lisp
(add-hook! some-mode (add-hook 'completion-at-point-functions #'some-capf depth t))
;; OR, but note the different call signature
(add-hook 'some-mode-hook (lambda () (add-hook 'completion-at-point-functions #'some-capf depth t)))
#+end_src
DEPTH above is an integer between -100, 100, and defaults to 0 of ommited. Also
see ~add-hook!~'s documentation for additional ways to call it. ~add-hook~ only
accepts the quoted arguments form above.
* Troubleshooting
[[doom-report:][Report an issue?]]
If you have performance issues with ~cape-dabbrev~, the first thing I recommend
doing is looking at the list of buffers Dabbrev is scanning with:
#+begin_src emacs-lisp
(dabbrev--select-buffers) ; => (#<buffer README.org> #<buffer config.el<3>> #<buffer cape.el> ...)
(length (dabbrev--select-buffers)) ; => 37
#+end_src
and modifying ~dabbrev-ignored-buffer-regexps~ or ~dabbrev-ignored-buffer-modes~
accordingly.
* Frequently asked questions
/This module has no FAQs yet./ [[doom-suggest-faq:][Ask one?]]
* TODO Appendix
#+begin_quote
🔨 This module has no appendix yet. [[doom-contrib-module:][Write one?]]
#+end_quote

View file

@ -1,18 +0,0 @@
;;; completion/corfu/autoload/commands.el -*- lexical-binding: t; -*-
;;;###autoload
(defun corfu-move-to-minibuffer ()
;; Taken from corfu's README.
;; TODO: extend this to other completion front-ends.
(interactive)
(let ((completion-extra-properties corfu--extra)
(completion-cycle-threshold completion-cycling))
(apply #'consult-completion-in-region completion-in-region--data)))
;;;###autoload
(defun +corfu-insert-wildcard-separator ()
;; I had to rename this command so that it doesn't start with "corfu-".
;; Otherwise, it does not insert the completion when +tng is enabled.
(interactive)
(setq this-command #'corfu-insert-separator)
(call-interactively #'corfu-insert-separator))

View file

@ -1,294 +0,0 @@
;;; completion/corfu/config.el -*- lexical-binding: t; -*-
(defvar +cape-buffer-scanning-size-limit (* 1 1024 1024) ; 1 MB
"Size limit for a buffer to be scanned by `cape-line' or `cape-dabbrev'.
As an exception, `cape-line' will also scan buffers with the same
major mode regardless of size.")
(defvar +orderless-wildcard-character ?,
"A character used as a wildcard in Corfu for fuzzy autocompletion. If you
want to match the wildcard literally in completion, you can
escape it with forward slash. Do NOT set this to SPC.
This variable needs to be set at the top-level before any `after!' blocks.")
;;
;;; Packages
(use-package! corfu
:hook (doom-first-buffer . global-corfu-mode)
:hook (org-mode . corfu-mode)
:init
;; Auto-completion settings, must be set before calling `global-corfu-mode'.
;; Due to lazy-loading, overriding these in config.el works too.
(setq corfu-auto t
corfu-auto-delay 0.1
corfu-auto-prefix 2
corfu-excluded-modes '(erc-mode
circe-mode
help-mode
gud-mode
vterm-mode))
(map! (:unless (modulep! +tng)
:i "C-SPC" #'completion-at-point))
:config
(setq corfu-cycle t
corfu-preselect (if (modulep! :completion corfu +tng) 'prompt t)
corfu-count 16
corfu-max-width 120
corfu-preview-current 'insert
corfu-on-exact-match nil
corfu-quit-at-boundary (if (modulep! +orderless) 'separator t)
corfu-quit-no-match (if (modulep! +orderless) 'separator t)
;; In the case of +tng, TAB should be smart regarding completion;
;; However, it should otherwise behave like normal, whatever normal was.
tab-always-indent (if (modulep! +tng) 'complete tab-always-indent))
(defun corfu-disable-in-minibuffer-p ()
(or (bound-and-true-p mct--active)
(bound-and-true-p vertico--input)
(and (featurep 'helm-core) (helm--alive-p))
(eq (current-local-map) read-passwd-map)))
(defun corfu-enable-in-minibuffer ()
"Enable Corfu in the minibuffer if `completion-at-point' is bound."
(unless (corfu-disable-in-minibuffer-p)
(setq-local corfu-echo-delay nil ;; Disable automatic echo and popup
corfu-popupinfo-delay nil)
(corfu-mode 1)))
(add-hook 'minibuffer-setup-hook #'corfu-enable-in-minibuffer)
(defun corfu-visible-p ()
(or (and (frame-live-p corfu--frame)
(frame-visible-p corfu--frame))
(and (featurep 'corfu-terminal)
(popon-live-p corfu-terminal--popon))))
;; If you want to update the visual hints after completing minibuffer commands
;; with Corfu and exiting, you have to do it manually.
(defadvice! +corfu--insert-before-exit-minibuffer-a ()
:before #'exit-minibuffer
(when (corfu-visible-p)
(when (member isearch-lazy-highlight-timer timer-idle-list)
(apply (timer--function isearch-lazy-highlight-timer)
(timer--args isearch-lazy-highlight-timer)))
(when (member (bound-and-true-p anzu--update-timer) timer-idle-list)
;; Pending a PR I am making to expose `anzu--update-timer'.
(apply (timer--function anzu--update-timer)
(timer--args anzu--update-timer)))
(when (member (bound-and-true-p evil--ex-search-update-timer)
timer-idle-list)
(apply (timer--function evil--ex-search-update-timer)
(timer--args evil--ex-search-update-timer)))))
;; Do not make us type RET twice with Corfu.
(defun corfu--maybe-return-filter (cmd)
(if (eq corfu--index -1) (corfu-quit) cmd))
(keymap-set corfu-map "RET" `(menu-item "corfu-maybe-return" corfu-insert
:filter corfu--maybe-return-filter))
(keymap-set
corfu-map "<return>" `(menu-item "corfu-maybe-return" corfu-insert
:filter corfu--maybe-return-filter))
;; Allow completion after `:' in Lispy.
(add-to-list 'corfu-auto-commands #'lispy-colon)
(when (and (modulep! +orderless)
+orderless-wildcard-character)
(defmacro +orderless-escapable-split-fn (char)
(let ((char-string (string (if (symbolp char) (symbol-value char) char))))
`(defun +orderless-escapable-split-on-space-or-char (s)
(mapcar
(lambda (piece)
(replace-regexp-in-string
(string 1) ,char-string
(replace-regexp-in-string
(concat (string 0) "\\|" (string 1))
(lambda (x)
(pcase x
("\0" " ")
("\1" ,char-string)
(_ x)))
piece
;; These are arguments to `replace-regexp-in-string'.
'fixedcase 'literal)
'fixedcase 'literal))
(split-string (replace-regexp-in-string
(concat "\\\\\\\\\\|\\\\ \\|\\\\"
,char-string)
(lambda (x)
(pcase x
("\\ " "\0")
(,(concat "\\" char-string)
"\1")
(_ x)))
s 'fixedcase 'literal)
,(concat "[ " char-string "]+")
t)))))
(after! orderless
;; Orderless splits the string into components and then determines the
;; matching style for each component. This is all regexp stuff.
(setq orderless-component-separator
(+orderless-escapable-split-fn +orderless-wildcard-character))
(setq corfu-separator +orderless-wildcard-character)
(keymap-set corfu-map (char-to-string +orderless-wildcard-character)
#'+corfu-insert-wildcard-separator)
;; Quit completion after typing the wildcard followed by a space.
(keymap-set corfu-map "SPC"
`(menu-item "corfu-maybe-quit" nil
:filter
,(lambda (_)
(when (and (> (point) (point-min))
(eq (char-before)
+orderless-wildcard-character))
(corfu-quit)
nil))))))
(add-hook! 'evil-insert-state-exit-hook
(defun +corfu-quit-on-evil-insert-state-exit-h ()
;; This predicate a workaround for unexpected calls to `corfu-quit' in
;; :company-doc-buffer buffers. This was specifically happening when using
;; `yasnippet-capf' and `company-yasnippet'.
(when (eq (current-buffer) (window-buffer (selected-window)))
(corfu-quit))))
(when (modulep! +icons)
(add-to-list 'corfu-margin-formatters #'nerd-icons-corfu-formatter))
;; Reset completion DWIM-style with backspace.
(when (modulep! +tng)
(defun corfu--maybe-reset-backspace-filter (cmd)
(when (and (> corfu--index -1)
(eq corfu-preview-current 'insert))
cmd))
(keymap-set corfu-map "DEL" `(menu-item "corfu-maybe-reset" corfu-reset
:filter corfu--maybe-reset-backspace-filter))
(keymap-set
corfu-map "<backspace>" `(menu-item "corfu-maybe-reset" corfu-reset
:filter corfu--maybe-reset-backspace-filter)))
(map! (:map 'corfu-map
(:when (modulep! +orderless)
"C-SPC" #'corfu-insert-separator)
(:when (modulep! +tng)
[tab] #'corfu-next
[backtab] #'corfu-previous
"TAB" #'corfu-next
"S-TAB" #'corfu-previous)))
(after! evil-collection-corfu
(evil-collection-define-key 'insert 'corfu-map
(kbd "RET") #'corfu-insert
[return] #'corfu-insert))
(after! vertico
(map! :map 'corfu-map "M-m" #'corfu-move-to-minibuffer)
(after! evil-collection-corfu
(evil-collection-define-key 'insert 'corfu-map
(kbd "M-j") #'corfu-move-to-minibuffer))))
(use-package! cape
:defer t
:init
;; Set up `cape-dabbrev' and `cape-line' options.
(defun +cape-line-buffers ()
(cl-loop for buf in (buffer-list)
if (or (eq major-mode (buffer-local-value 'major-mode buf))
(< (buffer-size buf) +cape-buffer-scanning-size-limit))
collect buf))
(defun +dabbrev-friend-buffer-p (other-buffer)
(< (buffer-size other-buffer) +cape-buffer-scanning-size-limit))
(setq cape-dabbrev-check-other-buffers t
cape-line-buffer-function #'+cape-line-buffers
dabbrev-friend-buffer-function #'+dabbrev-friend-buffer-p
dabbrev-ignored-buffer-regexps
'("\\.\\(?:pdf\\|jpe?g\\|png\\|svg\\|eps\\)\\'"
"^ "
"\\(TAGS\\|tags\\|ETAGS\\|etags\\|GTAGS\\|GRTAGS\\|GPATH\\)\\(<[0-9]+>\\)?")
dabbrev-upcase-means-case-search t)
(add-hook! prog-mode
(add-hook 'completion-at-point-functions #'cape-file -10 t))
(add-hook! (org-mode markdown-mode)
(add-hook 'completion-at-point-functions #'cape-elisp-block 0 t))
;; Enable Dabbrev completion basically everywhere as a fallback.
(add-hook! (prog-mode text-mode conf-mode comint-mode minibuffer-setup
eshell-mode)
(add-hook 'completion-at-point-functions #'cape-dabbrev 20 t))
;; Complete emojis :).
(when (> emacs-major-version 28)
(add-hook! (prog-mode conf-mode)
(add-hook 'completion-at-point-functions
(cape-capf-inside-faces
(cape-capf-prefix-length #'cape-emoji 1)
;; Only call inside comments and docstrings.
'tree-sitter-hl-face:doc 'font-lock-doc-face
'font-lock-comment-face 'tree-sitter-hl-face:comment)
10 t))
(add-hook! text-mode
(add-hook 'completion-at-point-functions
(cape-capf-prefix-length #'cape-emoji 1) 10 t)))
;; Enable dictionary-based autocompletion.
(add-hook! text-mode
(add-hook 'completion-at-point-functions #'cape-dict 40 t))
(add-hook! (prog-mode conf-mode)
(add-hook 'completion-at-point-functions
(cape-capf-inside-faces
;; Only call inside comments and docstrings.
#'cape-dict 'tree-sitter-hl-face:doc 'font-lock-doc-face
'font-lock-comment-face 'tree-sitter-hl-face:comment)
40 t))
;; Make these capfs composable.
(advice-add #'comint-completion-at-point :around #'cape-wrap-nonexclusive)
(advice-add #'eglot-completion-at-point :around #'cape-wrap-nonexclusive)
(advice-add #'lsp-completion-at-point :around #'cape-wrap-nonexclusive)
(advice-add #'pcomplete-completions-at-point :around #'cape-wrap-nonexclusive)
;; From the `cape' readme. Without this, Eshell autocompletion is broken on
;; Emacs28.
(when (< emacs-major-version 29)
(advice-add 'pcomplete-completions-at-point :around #'cape-wrap-silent)
(advice-add 'pcomplete-completions-at-point :around #'cape-wrap-purify))
(advice-add #'lsp-completion-at-point :around #'cape-wrap-noninterruptible))
(use-package! yasnippet-capf
:when (modulep! :editor snippets)
:defer t
:init
(add-hook! yas-minor-mode
(add-hook 'completion-at-point-functions #'yasnippet-capf 30 t)))
(use-package! corfu-terminal
:when (not (display-graphic-p))
:hook (corfu-mode . corfu-terminal-mode))
;;
;;; Extensions
(use-package! corfu-history
:hook (corfu-mode . corfu-history-mode)
:config
(after! savehist (add-to-list 'savehist-additional-variables 'corfu-history)))
(use-package! corfu-popupinfo
:hook (corfu-mode . corfu-popupinfo-mode)
:config
(setq corfu-popupinfo-delay '(0.5 . 1.0))
(map! (:map 'corfu-map
"C-<up>" #'corfu-popupinfo-scroll-down
"C-<down>" #'corfu-popupinfo-scroll-up
"C-S-p" #'corfu-popupinfo-scroll-down
"C-S-n" #'corfu-popupinfo-scroll-up
"C-h" #'corfu-popupinfo-toggle)
(:map 'corfu-popupinfo-map
:when (modulep! :editor evil)
;; Reversed because popupinfo assumes opposite of what feels intuitive
;; with evil.
"C-S-k" #'corfu-popupinfo-scroll-down
"C-S-j" #'corfu-popupinfo-scroll-up)))

View file

@ -1,14 +0,0 @@
;; -*- no-byte-compile: t; -*-
;;; completion/corfu/packages.el
(package! corfu :recipe (:files ("*.el" "extensions/*.el")))
(package! cape)
(when (modulep! +icons)
(package! nerd-icons-completion :pin "c2db8557a3c1a9588d111f8c8e91cae96ee85010")
(package! nerd-icons-corfu :pin "5082a22dfbdea092fcc475db3484cb3ff812b730"))
(when (modulep! +orderless)
(package! orderless))
(when (modulep! :os tty)
(package! corfu-terminal))
(when (modulep! :editor snippets)
(package! yasnippet-capf))