Massive refactoring and some new modules.

Author: h0cheung

init.el

@@ -20,12 +20,14 @@
 ;;      directory (for easy access to its source code).
 
 (doom! :input
+       ;;bidi              ; (tfel ot) thgir etirw uoy gnipleh
        ;;chinese
        ;;japanese
        ;;layout            ; auie,ctsrnm is the superior home row
 
        :completion
-       (company +childframe)          ; the ultimate code completion backend
+       ;;(company +childframe)          ; the ultimate code completion backend
+       ;;(corfu +icons +orderless)
        ;;helm              ; the *other* search engine for love and life
        ;;ido               ; the other *other* search engine...
        ;;ivy               ; a search engine for love and life
@@ -59,7 +61,7 @@
        zen               ; distraction-free coding or writing
 
        :editor
-       (evil +everywhere); come to the dark side, we have cookies
+       ;;(evil +everywhere); come to the dark side, we have cookies
        file-templates    ; auto-snippets for empty files
        fold              ; (nigh) universal code folding
        format            ; automated prettiness
@@ -101,7 +103,7 @@
        (eval +overlay)     ; run code, run (also, repls)
        gist              ; interacting with github gists
        (lookup +dictionary +docsets)             ; navigate your code and its documentation
-       (lsp +peek)               ; M-x vscode
+       ;;(lsp +peek)               ; M-x vscode
        (magit +forge)             ; a git porcelain for Emacs
        make              ; run make tasks from Emacs
        pass              ; password manager for nerds
@@ -112,6 +114,7 @@
        ;;terraform         ; infrastructure as code
        ;;tmux              ; an API for interacting with tmux
        upload            ; map local to remote projects via ssh/ftp
+       tree-sitter
 
        :os
        (:if IS-MAC macos)  ; improve compatibility with macOS
@@ -120,7 +123,7 @@
        :lang
        ;;agda              ; types of types of types of types...
        ;;beancount         ; mind the GAAP
-       (cc +lsp)                ; C > C++ == 1
+       (cc +lsp +tree-sitter)                ; C > C++ == 1
        ;;clojure           ; java with a lisp
        ;;common-lisp       ; if you've seen one lisp, you've seen them all
        ;;coq               ; proofs-as-programs
@@ -140,11 +143,11 @@
        ;;fsharp            ; ML stands for Microsoft's Language
        ;;fstar             ; (dependent) types and (monadic) effects and Z3
        ;;gdscript          ; the language you waited for
-       ;;(go +lsp)         ; the hipster dialect
+       (go +lsp +tree-sitter)         ; the hipster dialect
        ;;(haskell +lsp)    ; a language that's lazier than I am
        ;;hy                ; readability of scheme w/ speed of python
        ;;idris             ; a language you can depend on
-       (json +lsp)              ; At least it ain't XML
+       (json +lsp +tree-sitter)              ; At least it ain't XML
        ;;(java +lsp)       ; the poster child for carpal tunnel syndrome
        ;;javascript        ; all(hope(abandon(ye(who(enter(here))))))
        ;;julia             ; a better, faster MATLAB
@@ -181,7 +184,7 @@
        ;;rust              ; Fe2O3.unwrap().unwrap().unwrap().unwrap()
        ;;scala             ; java, but good
        ;;(scheme +guile)   ; a fully conniving family of lisps
-       (sh +lsp)               ; she sells {ba,z,fi}sh shells on the C xor
+       (sh +lsp +tree-sitter)               ; she sells {ba,z,fi}sh shells on the C xor
        ;;sml
        ;;solidity          ; do you need a blockchain? No.
        ;;swift             ; who asked for emoji variables?
@@ -209,14 +212,23 @@
 
        :h-cheung
        chinese
-       (telega             ; telegram
-        +auto-im)      ; auto toggle input method
+       ;;(telega             ; telegram
+       ;; +auto-im)      ; auto toggle input method
        tools
        ui
        (:if (featurep! :lang cc) cc-extra)
+       (:if (featurep! :lang go) go-extra)
        ;;(:if (featurep! :lang python) python-extra)
        systemd
+       rpmspec
        pkgbuild
        (:if (featurep! :term eshell) eshell-extra)
        fish
-       (:if (featurep! :editor evil) evil-hybird))
+       (:if (featurep! :editor evil) evil-hybird)
+       ement
+       copilot
+       ;;tabnine
+       lsp-bridge
+       ;;lspce
+       eaf
+       netease-music)

modules/completion/corfu/autoload/corfu.el

@@ -0,0 +1,13 @@
+;;; completion/corfu/autoload/corfu.el -*- lexical-binding: t; -*-
+;;;###if (featurep! :completion corfu +minibuffer)
+
+;;;###autoload
+(defun +corfu--enable-in-minibuffer ()
+  (unless (or (bound-and-true-p mct--active)
+              (bound-and-true-p vertico--input)
+              (memq this-command '(evil-ex
+                                   evil-ex-search-forward
+                                   evil-ex-search-backward))
+              (and (featurep! :completion helm)
+                   (helm--alive-p))
+              (corfu-mode +1))))

modules/completion/corfu/autoload/extra.el

@@ -0,0 +1,39 @@
+;;; completion/corfu/autoload/extra.el -*- lexical-binding: t; -*-
+
+;;;###autoload
+(defun +corfu-complete-file-at-point ()
+  "Complete a file path from scratch at point"
+  (interactive)
+  (completion-in-region (point) (point) #'read-file-name-internal))
+
+;;;###autoload
+(defun +corfu-files ()
+  "Complete using files source"
+  (interactive)
+  (let ((completion-at-point-functions (list #'+file-completion-at-point-function)))
+    (completion-at-point)))
+
+;;;###autoload
+(defun +corfu-dabbrev ()
+  "Complete using dabbrev source"
+  (interactive)
+  (let ((completion-at-point-functions (list #'+dabbrev-completion-at-point-function)))
+    (completion-at-point)))
+
+;;;###autoload
+(defun +corfu-ispell ()
+  "Complete using ispell source.
+
+See `ispell-lookup-words' for more info"
+  (interactive)
+  (let ((completion-at-point-functions (list #'+ispell-completion-at-point-function)))
+    (completion-at-point)))
+
+;;;###autoload
+(defun +corfu-dict ()
+  "Complete using dict source.
+
+See `+dict--words' for extra words, and `+dict-file' for a wordslist source "
+  (interactive)
+  (let ((completion-at-point-functions (list #'+dict-completion-at-point-function)))
+    (completion-at-point)))

modules/completion/corfu/autoload/minad-capfs.el

@@ -0,0 +1,75 @@
+;; Daniel "minad" Mendler extra capfs -*- lexical-binding: t -*-
+;; Source : https://github.com/minad/corfu/issues/9#issuecomment-945090516
+
+(require 'dabbrev)
+
+;;;###autoload
+(defun +file-completion-at-point-function ()
+  "File name completion-at-point-function."
+  (when-let (bounds (bounds-of-thing-at-point 'filename))
+    (list (car bounds) (cdr bounds)
+          'read-file-name-internal
+          :exclusive 'no
+          :annotation-function (lambda (_) " (File)"))))
+
+;;;###autoload
+(defun +dabbrev-completion-at-point-function ()
+  (let ((dabbrev-check-all-buffers nil)
+        (dabbrev-check-other-buffers nil))
+    (dabbrev--reset-global-variables))
+  (let ((abbrev (ignore-errors (dabbrev--abbrev-at-point))))
+    (when (and abbrev (not (string-match-p "[ \t]" abbrev)))
+      (pcase ;; Interruptible scanning
+          (while-no-input
+            (let ((inhibit-message t)
+                  (message-log-max nil))
+              (or (dabbrev--find-all-expansions
+                   abbrev (dabbrev--ignore-case-p abbrev))
+                  t)))
+        ('nil (keyboard-quit))
+        ('t nil)
+        (words
+         ;; Ignore completions which are too short
+         (let ((min-len (+ 4 (length abbrev))))
+           (setq words (seq-remove (lambda (x) (< (length x) min-len)) words)))
+         (when words
+           (let ((beg (progn (search-backward abbrev) (point)))
+                 (end (progn (search-forward abbrev) (point))))
+             (unless (string-match-p "\n" (buffer-substring beg end))
+               (list beg end words
+                     :exclusive 'no
+                     :annotation-function (lambda (_) " (Dabbrev)"))))))))))
+
+(autoload 'ispell-lookup-words "ispell")
+
+;;;###autoload
+(defun +ispell-completion-at-point-function ()
+  (when-let* ((bounds (bounds-of-thing-at-point 'word))
+              (table (with-demoted-errors
+                         (let ((message-log-max nil)
+                               (inhibit-message t))
+                           (ispell-lookup-words
+                            (format "*%s*"
+                                    (buffer-substring-no-properties (car bounds) (cdr bounds))))))))
+    (list (car bounds) (cdr bounds) table
+          :exclusive 'no
+          :annotation-function (lambda (_) " (Ispell)"))))
+
+(defun +word-completion-at-point-function (words)
+  (when-let (bounds (bounds-of-thing-at-point 'word))
+    (list (car bounds) (cdr bounds) words
+          :exclusive 'no
+          :annotation-function (lambda (_) " (Words)"))))
+
+(defvar +dict--words nil)
+(defvar +dict-file "/etc/dictionaries-common/words")
+
+;;;###autoload
+(defun +dict-completion-at-point-function ()
+  (+word-completion-at-point-function
+   (or +dict--words
+       (setq +dict--words
+             (split-string (with-temp-buffer
+                             (insert-file-contents-literally +dict-file)
+                             (buffer-string))
+                           "\n")))))

modules/completion/corfu/config.el

@@ -0,0 +1,162 @@
+;;; completion/corfu/config.el -*- lexical-binding: t; -*-
+
+(use-package! corfu
+  :custom
+  (corfu-separator ?\s)
+  (corfu-auto t)
+  (corfu-auto-delay 0.0)
+  (corfu-on-exact-match nil)
+  (corfu-quit-no-match t)
+  (corfu-cycle t)
+  (corfu-auto-prefix 2)
+  (completion-cycle-threshold 1)
+  (tab-always-indent 'complete)
+  :hook
+  (doom-first-buffer . global-corfu-mode)
+  :config
+  (when (featurep! +minibuffer)
+    (add-hook 'minibuffer-setup-hook #'+corfu--enable-in-minibuffer))
+
+  ;; Dirty hack to get c completion running
+  ;; Discussion in https://github.com/minad/corfu/issues/34
+  (when (and (featurep! :lang cc)
+             (equal tab-always-indent 'complete))
+    (map! :map c-mode-base-map
+          :i [remap c-indent-line-or-region] #'completion-at-point))
+
+  ;; Reset lsp-completion provider
+  (add-hook 'doom-init-modules-hook
+            (lambda ()
+              (after! lsp-mode
+                (setq lsp-completion-provider :none))))
+
+  ;; Set orderless filtering for LSP-mode completions
+  (add-hook 'lsp-completion-mode-hook
+            (lambda ()
+              (setf (alist-get 'lsp-capf completion-category-defaults) '((styles . (orderless flex))))))
+
+  (map! :map corfu-map
+        "C-SPC"    #'corfu-insert-separator
+        "C-n"      #'corfu-next
+        "C-p"      #'corfu-previous
+        (:prefix "C-x"
+         "C-k"     #'cape-dict
+         "C-f"     #'cape-file))
+  (after! evil
+    (advice-add 'corfu--setup :after 'evil-normalize-keymaps)
+    (advice-add 'corfu--teardown :after 'evil-normalize-keymaps)
+    (evil-make-overriding-map corfu-map))
+
+  (defadvice! +corfu--org-return (orig) :around '+org/return
+    (if (and (featurep! :completion corfu)
+             corfu-mode
+             (>= corfu--index 0))
+        (corfu-insert)
+      (funcall orig)))
+
+  (unless (display-graphic-p)
+    (corfu-doc-terminal-mode)
+    (corfu-terminal-mode)))
+
+
+(use-package! corfu-doc
+  :hook (corfu-mode . corfu-doc-mode)
+  :custom
+  (corfu-doc-delay 0)
+  :bind (:map corfu-map
+         ("M-n" . corfu-doc-scroll-down)
+         ("M-p" . corfu-doc-scroll-up)
+         ("M-d" . corfu-doc-toggle)))
+
+
+(use-package! orderless
+  :when (featurep! +orderless)
+  :init
+  (setq completion-styles '(orderless partial-completion)
+        completion-category-defaults nil
+        completion-category-overrides '((file (styles . (partial-completion))))))
+
+
+(use-package! kind-icon
+  :after corfu
+  :when (featurep! +icons)
+  :custom
+  (kind-icon-default-face 'corfu-default)
+  :config
+  (setq kind-icon-use-icons t
+        svg-lib-icons-dir (expand-file-name "svg-lib" doom-cache-dir)
+        kind-icon-mapping
+        '((array "a" :icon "code-brackets" :face font-lock-variable-name-face)
+          (boolean "b" :icon "circle-half-full" :face font-lock-builtin-face)
+          (class "c" :icon "view-grid-plus-outline" :face font-lock-type-face)
+          (color "#" :icon "palette" :face success)
+          (constant "co" :icon "pause-circle" :face font-lock-constant-face)
+          (constructor "cn" :icon "table-column-plus-after" :face font-lock-function-name-face)
+          (enum "e" :icon "format-list-bulleted-square" :face font-lock-builtin-face)
+          (enum-member "em" :icon "format-list-checks" :face font-lock-builtin-face)
+          (event "ev" :icon "lightning-bolt-outline" :face font-lock-warning-face)
+          (field "fd" :icon "application-braces-outline" :face font-lock-variable-name-face)
+          (file "f" :icon "file" :face font-lock-string-face)
+          (folder "d" :icon "folder" :face font-lock-doc-face)
+          (function "f" :icon "sigma" :face font-lock-function-name-face)
+          (interface "if" :icon "video-input-component" :face font-lock-type-face)
+          (keyword "kw" :icon "image-filter-center-focus" :face font-lock-keyword-face)
+          (macro "mc" :icon "lambda" :face font-lock-keyword-face)
+          (method "m" :icon "sigma" :face font-lock-function-name-face)
+          (module "{" :icon "view-module" :face font-lock-preprocessor-face)
+          (numeric "nu" :icon "numeric" :face font-lock-builtin-face)
+          (operator "op" :icon "plus-circle-outline" :face font-lock-comment-delimiter-face)
+          (param "pa" :icon "cog" :face default)
+          (property "pr" :icon "tune-vertical" :face font-lock-variable-name-face)
+          (reference "rf" :icon "bookmark-box-multiple" :face font-lock-variable-name-face)
+          (snippet "S" :icon "text-short" :face font-lock-string-face)
+          (string "s" :icon "sticker-text-outline" :face font-lock-string-face)
+          (struct "%" :icon "code-braces" :face font-lock-variable-name-face)
+          (t "." :icon "crosshairs-question" :face shadow)
+          (text "tx" :icon "script-text-outline" :face shadow)
+          (type-parameter "tp" :icon "format-list-bulleted-type" :face font-lock-type-face)
+          (unit "u" :icon "ruler-square" :face shadow)
+          (value "v" :icon "numeric-1-box-multiple-outline" :face font-lock-builtin-face)
+          (variable "va" :icon "adjust" :face font-lock-variable-name-face))
+        kind-icon-default-style '(:padding 0 :stroke 0 :margin 0 :radius 0 :height 0.95 :scale 0.95))
+  (add-hook 'doom-load-theme-hook #'kind-icon-reset-cache)
+  (add-to-list 'corfu-margin-formatters #'kind-icon-margin-formatter))
+
+
+(use-package! cape
+  :defer t
+  :init
+  (map!
+   [remap dabbrev-expand] 'cape-dabbrev)
+  (add-hook! 'latex-mode-hook (defun +corfu--latex-set-capfs ()
+                                (add-to-list 'completion-at-point-functions #'cape-tex)))
+  (when (featurep! :checkers spell)
+    (add-to-list 'completion-at-point-functions #'cape-dict)
+    (add-to-list 'completion-at-point-functions #'cape-ispell))
+  (add-to-list 'completion-at-point-functions #'cape-file)
+  (add-to-list 'completion-at-point-functions #'cape-keyword t)
+  (add-to-list 'completion-at-point-functions #'cape-dabbrev t))
+
+
+(use-package! corfu-history
+  :after corfu
+  :hook (corfu-mode . (lambda ()
+                        (corfu-history-mode 1)
+                        (savehist-mode 1)
+                        (add-to-list 'savehist-additional-variables 'corfu-history))))
+
+
+(use-package! corfu-quick
+  :after corfu
+  :bind (:map corfu-map
+         ("M-q" . corfu-quick-complete)
+         ("C-q" . corfu-quick-insert)))
+
+
+;; TODO This doesn't _quite_ work
+(use-package! evil-collection-corfu
+  :when (featurep! :editor evil +everywhere)
+  :defer t
+  :init (setq evil-collection-corfu-key-themes '(default magic-return))
+  :config
+  (evil-collection-corfu-setup))