diff --git a/modules/completion/corfu/README.org b/modules/completion/corfu/README.org index 1f071b638..e74332d16 100644 --- a/modules/completion/corfu/README.org +++ b/modules/completion/corfu/README.org @@ -64,46 +64,51 @@ 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:][]] | Go to next candidate | -| [[kbd:][]] | 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-]] | Go to next doc line | -| [[kbd:][C-]] | 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:][s-]] | Export to minibuffer (if [[doom-module::completion vertico]]) | -| [[kbd:][s-j]] | (evil) Export to minibuffer (if [[doom-module::completion vertico]]) | -| [[kbd:][RET]] | Insert candidate | -| [[kbd:][C-SPC]] | (when completing) Insert separator (see below) | -| [[kbd:][C-SPC]] | Complete (unless [[doom-module::completion corfu +tng]]) | +| Keybind | Description | +|----------+---------------------------------------------------------| +| [[kbd:][]] | Go to next candidate | +| [[kbd:][]] | 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-]] | Go to next doc line | +| [[kbd:][C-]] | 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 | +| 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 -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. +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 @@ -123,26 +128,42 @@ A few variables may be set to change behavior of this module: 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:+corfu-completion-styles]] :: - Used to override [[var:completion-styles]] for corfu invocations, such that it - can have a value separate from, say, [[doom-package:consult]]. +- [[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-to-list 'completion-at-point-functions #'some-capf)) +(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-to-list 'completion-at-point-functions #'some-capf))) +(add-hook 'some-mode-hook (lambda () (add-hook 'completion-at-point-functions #'some-capf depth t))) #+end_src -Also see ~add-hook!~'s documentation for additional ways to call it. -~add-hook~ only accepts the quoted arguments form above. +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) ; => (# #> # ...) +(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?]] diff --git a/modules/completion/corfu/autoload.el b/modules/completion/corfu/autoload.el new file mode 100644 index 000000000..215e5bd41 --- /dev/null +++ b/modules/completion/corfu/autoload.el @@ -0,0 +1,18 @@ +;;; 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)) diff --git a/modules/completion/corfu/config.el b/modules/completion/corfu/config.el index a36685ed9..d558f8e9e 100644 --- a/modules/completion/corfu/config.el +++ b/modules/completion/corfu/config.el @@ -1,10 +1,17 @@ ;;; completion/corfu/config.el -*- lexical-binding: t; -*- -(defvar +corfu-completion-styles '(basic partial-completion flex) - "Completion styles for corfu to use. +(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'. -If the user enables +orderless, `orderless' is automatically appended to this -list before fowarding to `completion-styles'.") +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 @@ -22,10 +29,12 @@ list before fowarding to `completion-styles'.") help-mode gud-mode vterm-mode)) + ;; `:g' is needed here to prevent `global-map' from overriding this with + ;; `set-mark-command'. + (map! :unless (modulep! +tng) :gi "C-SPC" #'completion-at-point) :config (setq corfu-cycle t - corfu-separator (when (modulep! +orderless) ?\s) - corfu-preselect t + corfu-preselect (if (modulep! :completion corfu +tng) 'prompt t) corfu-count 16 corfu-max-width 120 corfu-preview-current 'insert @@ -36,76 +45,224 @@ list before fowarding to `completion-styles'.") ;; However, it should otherwise behave like normal, whatever normal was. tab-always-indent (if (modulep! +tng) 'complete tab-always-indent)) - (when (modulep! +orderless) - (after! lsp-mode - (add-to-list 'completion-category-overrides - `(lsp-capf (styles ,@+corfu-completion-styles ,(when (modulep! +orderless) 'orderless))))) - (after! eglot - (add-to-list 'completion-category-overrides - `(eglot (styles ,@+corfu-completion-styles ,(when (modulep! +orderless) 'orderless)))))) + (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))) - (after! evil - (add-hook 'evil-insert-state-exit-hook #'corfu-quit)) + (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 (@LemonBreezes) 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 "" `(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)) - ;; This is to decouple the use of `completion-styles' in corfu from other - ;; completion packages, such as vertico. That way, the user can leave the - ;; global value of the variable alone, say, to be used by the default - ;; front-end or consult. The vertico module also does something similar with - ;; `+vertico-company-completion-styles'. - (defadvice! +corfu--completion-styles (orig &rest args) - "Try default completion styles before orderless. + ;; 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 "" `(menu-item "corfu-maybe-reset" corfu-reset + :filter corfu--maybe-reset-backspace-filter))) -Meant as :around advice for `corfu--recompute'." - :around #'corfu--recompute - (let ((completion-styles - (append +corfu-completion-styles (when (modulep! +orderless) - '(orderless)))) - completion-category-overrides completion-category-defaults) - (apply orig args))) - - (map! (:unless (modulep! +tng) - "C-SPC" #'completion-at-point) - (: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))) + (map! (:map 'corfu-map + (:when (modulep! +orderless) + :gi "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 - ;; Taken from corfu's README. - ;; TODO: extend this to other completion front-ends. - (defun corfu-move-to-minibuffer () - (interactive) - (let ((completion-extra-properties corfu--extra) - (completion-cycle-threshold completion-cycling)) - (apply #'consult-completion-in-region completion-in-region--data))) - (map! :map 'corfu-map "M-m" #'corfu-move-to-minibuffer - (:when (modulep! :editor evil) :i "M-j" #'corfu-move-to-minibuffer)))) + (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 - (add-hook! prog-mode (add-to-list 'completion-at-point-functions #'cape-file)) - (add-hook! (org-mode markdown-mode) (add-to-list 'completion-at-point-functions #'cape-elisp-block)) + ;; 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 - (after! yasnippet - (add-hook! yas-minor-mode - (add-to-list 'completion-at-point-functions #'yasnippet-capf)))) + (add-hook! yas-minor-mode + (add-hook 'completion-at-point-functions #'yasnippet-capf 30 t))) (use-package! corfu-terminal :when (not (display-graphic-p)) diff --git a/modules/completion/corfu/packages.el b/modules/completion/corfu/packages.el index 1d9f48f6c..b53626aab 100644 --- a/modules/completion/corfu/packages.el +++ b/modules/completion/corfu/packages.el @@ -2,7 +2,7 @@ ;;; completion/corfu/packages.el (package! corfu :recipe (:files ("*.el" "extensions/*.el")) :pin "b2b9a2312f58117514724e729fda43efc4433ecd") -(package! cape :pin "116063b9ee912cbaa7318dbe6597ade4a62b3f59") +(package! cape :pin "bee13e568d42ffec9010fbf795e8f942973da174") (when (modulep! +icons) (package! nerd-icons-completion :pin "c2db8557a3c1a9588d111f8c8e91cae96ee85010") (package! nerd-icons-corfu :pin "5082a22dfbdea092fcc475db3484cb3ff812b730"))