Merge branch 'develop' into eshell-improvements

.github/PULL_REQUEST_TEMPLATE/bump.md

@@ -15,12 +15,13 @@ labels: is:update re:packages
 >
 >    OR, if multiple packages are bumped in one commit:
 >
->      Bump package1, package2 & package 3
+>      Bump :tools lsp
 >
 >      emacs-lsp/lsp-mode@91e37a6 -> emacs-lsp/lsp-mode@c8188ef
 >      emacs-lsp/lsp-ui@cf6906c -> emacs-lsp/lsp-ui@582e153
 >
->    (Commit hashes should be limited to 7 characters)
+>    Commit hashes should be limited to 7 characters. Include additional
+>    commentary after the list of commit changes.
 >
 > 4. You've included links to relevant issues, if any
 > 5. You've deleted this template

bin/doom

@@ -6,7 +6,7 @@
 :; DOOMBASE="$(dirname "$0")/.."
 :; [ "$1" = -d ] || [ "$1" = --debug ] && { shift; export DEBUG=1; }
 :; [ "$1" = run ] && { cd "$DOOMBASE"; shift; exec $EMACS -q --no-splash -l bin/doom "$@"; exit 0; }
-:; exec $EMACS --script "$0" -- "$@"
+:; exec $EMACS --no-site-file --script "$0" -- "$@"
 :; exit 0
 
 (let* ((load-prefer-newer t)
@@ -15,6 +15,13 @@
        (user-emacs-directory
         (abbreviate-file-name (or emacsdir (expand-file-name "../" loaddir)))))
 
+  ;; HACK Load `cl' and site files manually so we can stop them from polluting
+  ;;      CLI logs with deprecation and file load messages.
+  (let ((inhibit-message t))
+    (when (> emacs-major-version 26)
+      (require 'cl))
+    (load "site-start" t t))
+
   (push (expand-file-name "core" user-emacs-directory) load-path)
   (require 'core)
   (require 'core-cli)

core/autoload/cache.el

@@ -1,95 +0,0 @@
-;;; core/autoload/cache.el -*- lexical-binding: t; -*-
-
-;; This little library thinly wraps around persistent-soft (which is a pcache
-;; wrapper, how about that). It has three purposes:
-;;
-;; + To encapsulate the cache backend (persistent-soft/pcache in this case), in
-;;   case it needs to change.
-;; + To provide `doom-cache-persist': a mechanism for easily persisting
-;;   variables across Emacs sessions.
-;; + To lazy-load persistent-soft until it is really needed.
-;;
-;; Like persistent-soft, caches assume a 2-tier structure, where all caches are
-;; namespaced by location.
-
-(defvar doom-cache-alists '(t)
-  "An alist of alists, containing lists of variables for the doom cache library
-to persist across Emacs sessions.")
-
-(defvar doom-cache-location 'doom
-  "The default location for cache files. This symbol is translated into a file
-name under `pcache-directory' (by default a subdirectory under
-`doom-cache-dir'). One file may contain multiple cache entries.")
-
-(defun doom-save-persistent-cache-h ()
-  "Hook to run when an Emacs session is killed. Saves all persisted variables
-listed in `doom-cache-alists' to files."
-  (dolist (alist (butlast doom-cache-alists 1))
-    (cl-loop with key = (car alist)
-             for var in (cdr alist)
-             if (symbol-value var)
-             do (doom-cache-set var it nil key))))
-(add-hook 'kill-emacs-hook #'doom-save-persistent-cache-h)
-
-
-;;
-;; Library
-
-;;;###autoload
-(defmacro with-cache! (location &rest body)
-  "Runs BODY with a different default `doom-cache-location'."
-  (declare (indent defun))
-  `(let ((doom-cache-location ',location))
-     ,@body))
-
-;;;###autoload
-(defun doom-cache-persist (location variables)
-  "Persist VARIABLES (list of symbols) in LOCATION (symbol).
-
-This populates these variables with cached values, if one exists, and saves them
-to file when Emacs quits.
-
-Warning: this is incompatible with buffer-local variables."
-  (dolist (var variables)
-    (when (doom-cache-exists var location)
-      (set var (doom-cache-get var location))))
-  (setf (alist-get location doom-cache-alists)
-        (append variables (cdr (assq location doom-cache-alists)))))
-
-;;;###autoload
-(defun doom-cache-desist (location &optional variables)
-  "Unregisters VARIABLES (list of symbols) in LOCATION (symbol) from
-`doom-cache-alists', thus preventing them from being saved between sessions.
-Does not affect the actual variables themselves or their values."
-  (if variables
-      (setf (alist-get location doom-cache-alists)
-            (cl-set-difference (cdr (assq location doom-cache-alists))
-                               variables))
-    (delq (assq location doom-cache-alists)
-          doom-cache-alists)))
-
-;;;###autoload
-(defun doom-cache-get (key &optional location)
-  "Retrieve KEY from LOCATION (defaults to `doom-cache-location'), if it exists
-and hasn't expired."
-  (persistent-soft-fetch
-   key (symbol-name (or location doom-cache-location))))
-
-;;;###autoload
-(defun doom-cache-set (key value &optional ttl location)
-  "Set KEY to VALUE in the cache. TTL is the time (in seconds) until this cache
-entry expires. LOCATION is the super-key to store this cache item under; the
-default is `doom-cache-location'. "
-  (persistent-soft-store
-   key value
-   (symbol-name (or location doom-cache-location)) ttl))
-
-;;;###autoload
-(defun doom-cache-exists (key &optional location)
-  "Returns t if KEY exists at LOCATION (defaults to `doom-cache-location')."
-  (persistent-soft-exists-p key (or location doom-cache-location)))
-
-;;;###autoload
-(defun doom-cache-clear (&optional location)
-  "Clear a cache LOCATION (defaults to `doom-cache-location')."
-  (persistent-soft-flush (or location doom-cache-location)))

core/autoload/debug.el

@@ -46,10 +46,7 @@ ready to be pasted in a bug report on github."
   (require 'core-packages)
   (let ((default-directory doom-emacs-dir)
         (doom-modules (doom-modules)))
-    (cl-letf
+    (letf! (defun sh (&rest args) (cdr (apply #'doom-call-process args)))
-        (((symbol-function 'sh)
-          (lambda (&rest args)
-            (cdr (apply #'doom-call-process args)))))
       `((emacs
          (version . ,emacs-version)
          (features ,@system-configuration-features)

core/autoload/help.el

@@ -38,6 +38,7 @@
     (LaTeX-mode      :lang latex)
     (ledger-mode     :lang ledger)
     (lua-mode        :lang lua)
+    (moonscript-mode :lang lua)
     (markdown-mode   :lang markdown)
     (gfm-mode        :lang markdown)
     (nim-mode        :lang nim)
@@ -45,6 +46,7 @@
     (taureg-mode     :lang ocaml)
     (org-mode        :lang org)
     (perl-mode       :lang perl)
+    (raku-mode       :lang perl)
     (php-mode        :lang php)
     (hack-mode       :lang php)
     (plantuml-mode   :lang plantuml)
@@ -53,7 +55,9 @@
     (restclient-mode :lang rest)
     (ruby-mode       :lang ruby)
     (rust-mode       :lang rust)
+    (rustic-mode     :lang rust)
     (scala-mode      :lang scala)
+    (scheme-mode     :lang scheme)
     (sh-mode         :lang sh)
     (swift-mode      :lang swift)
     (web-mode        :lang web)
@@ -131,7 +135,8 @@ selection of all minor-modes, active or not."
                                           (list (or (+org-get-global-property "TITLE")
                                                     (file-relative-name (buffer-file-name)))))
                                         path
-                                        (list (replace-regexp-in-string org-link-any-re "\\4" text)))
+                                        (when text
+                                          (list (replace-regexp-in-string org-link-any-re "\\4" text))))
                                 " > ")
                                tags)
                          " ")

core/autoload/projects.el

@@ -101,11 +101,10 @@ If DIR is not a project, it will be indexed (but not cached)."
   (unless (file-readable-p dir)
     (error "Directory %S isn't readable" dir))
   (let* ((default-directory (file-truename (expand-file-name dir)))
-         (project-root (doom-project-root default-directory))
+         (projectile-project-root (doom-project-root default-directory))
-         (projectile-project-root default-directory)
          (projectile-enable-caching projectile-enable-caching))
-    (cond ((and project-root (file-equal-p project-root projectile-project-root))
+    (cond ((and projectile-project-root (file-equal-p projectile-project-root default-directory))
-           (unless (doom-project-p projectile-project-root)
+           (unless (doom-project-p default-directory)
              ;; Disable caching if this is not a real project; caching
              ;; non-projects easily has the potential to inflate the projectile
              ;; cache beyond reason.

core/autoload/sessions.el

@@ -130,8 +130,11 @@
   (interactive "P")
   (setq doom-autosave-session nil)
   (doom/quicksave-session)
-  (restart-emacs
+  (save-some-buffers nil t)
-   (append (if debug (list "--debug-init"))
+  (letf! ((#'save-buffers-kill-emacs #'kill-emacs)
-           (when (boundp 'chemacs-current-emacs-profile)
+          (confirm-kill-emacs))
-             (list "--with-profile" chemacs-current-emacs-profile))
+    (restart-emacs
-           (list "--restore"))))
+     (append (if debug (list "--debug-init"))
+             (when (boundp 'chemacs-current-emacs-profile)
+               (list "--with-profile" chemacs-current-emacs-profile))
+             (list "--restore")))))

core/autoload/store.el

@@ -0,0 +1,142 @@
+;;; core/autoload/cache.el -*- lexical-binding: t; -*-
+
+;; This little library abstracts the process of writing arbitrary elisp values
+;; to a 2-tiered file store (in `doom-store-dir'/`doom-store-location').
+
+(defvar doom-store-dir (concat doom-etc-dir "store/")
+  "Directory to look for and store data accessed through this API.")
+
+(defvar doom-store-persist-alist '(t)
+  "An alist of alists, containing lists of variables for the doom cache library
+to persist across Emacs sessions.")
+
+(defvar doom-store-location "default"
+  "The default location for cache files. This symbol is translated into a file
+name under `pcache-directory' (by default a subdirectory under
+`doom-store-dir'). One file may contain multiple cache entries.")
+
+(defvar doom--store-table (make-hash-table :test 'equal))
+(defvar doom--inhibit-flush nil)
+
+(defun doom-save-persistent-store-h ()
+  "Hook to run when an Emacs session is killed. Saves all persisted variables
+listed in `doom-store-persist-alist' to files."
+  (let (locations)
+    (let ((doom--inhibit-flush t))
+      (dolist (alist (butlast doom-store-persist-alist 1))
+        (cl-loop with location = (car alist)
+                 for var in (cdr alist)
+                 do (doom-store-put var (symbol-value var) nil location)
+                 and do (cl-pushnew location locations))))
+    (mapc #'doom--store-flush locations)))
+(add-hook 'kill-emacs-hook #'doom-save-persistent-store-h)
+
+
+;;
+;; Library
+
+;;;###autoload
+(defun doom-store-persist (location variables)
+  "Persist VARIABLES (list of symbols) in LOCATION (symbol).
+This populates these variables with cached values, if one exists, and saves them
+to file when Emacs quits. This cannot persist buffer-local variables."
+  (dolist (var variables)
+    (when (doom-store-member-p var location)
+      (set var (doom-store-get var location))))
+  (setf (alist-get location doom-store-persist-alist)
+        (append variables (alist-get location doom-store-persist-alist))))
+
+;;;###autoload
+(defun doom-store-desist (location &optional variables)
+  "Unregisters VARIABLES (list of symbols) in LOCATION (symbol).
+Variables to persist are recorded in `doom-store-persist-alist'. Does not affect
+the actual variables themselves or their values."
+  (if variables
+      (setf (alist-get location doom-store-persist-alist)
+            (cl-set-difference (cdr (assq location doom-store-persist-alist))
+                               variables))
+    (delq! location doom-store-persist-alist 'assoc)))
+
+(defun doom--store-init (location)
+  (or (gethash location doom--store-table)
+      (let* ((file-name-handler-alist nil)
+             (location-path (expand-file-name location doom-store-dir)))
+        (if (file-exists-p location-path)
+            (puthash location
+                     (with-temp-buffer
+                       (set-buffer-multibyte nil)
+                       (setq buffer-file-coding-system 'binary)
+                       (insert-file-contents-literally location-path)
+                       (read (current-buffer)))
+                     doom--store-table)
+          (puthash location (make-hash-table :test 'equal)
+                   doom--store-table)))))
+
+(defun doom--store-get (key location &optional default-value)
+  (let* ((location-data (doom--store-init location))
+         (data (gethash key location-data default-value)))
+    (if (and (not (eq data default-value))
+             (or (null (car data))
+                 (not (time-less-p (car data) (current-time)))))
+        (cdr data)
+      default-value)))
+
+(defun doom--store-put (key value location &optional ttl)
+  (puthash key (cons (if ttl (time-add (current-time) ttl)) value)
+           (doom--store-init location))
+  (doom--store-flush location))
+
+(defun doom--store-flush (location)
+  (unless doom--inhibit-flush
+    (let ((file-name-handler-alist nil)
+          (coding-system-for-write 'binary)
+          (write-region-annotate-functions nil)
+          (write-region-post-annotation-function nil)
+          (data (doom--store-init location)))
+      (make-directory doom-store-dir 'parents)
+      (with-temp-file (expand-file-name location doom-store-dir)
+        (prin1 data (current-buffer)))
+      data)))
+
+
+;;;###autoload
+(defun doom-store-get (key &optional location default-value)
+  "Retrieve KEY from LOCATION (defaults to `doom-store-location').
+If it doesn't exist or has expired, DEFAULT_VALUE is returned."
+  (doom--store-get key (or location doom-store-location) default-value))
+
+;;;###autoload
+(defun doom-store-put (key value &optional ttl location)
+  "Set KEY to VALUE in the store at LOCATION.
+KEY can be any lisp object that is comparable with `equal'. TTL is the time (in
+seconds) until this cache entry expires. LOCATION is the super-key to store this
+cache item under. It defaults to `doom-store-location'."
+  (doom--store-put key value (or location doom-store-location) ttl))
+
+;;;###autoload
+(defun doom-store-rem (key &optional location)
+  "Clear a cache LOCATION (defaults to `doom-store-location')."
+  (let ((location (or location doom-store-location)))
+    (remhash key (doom--store-init location))
+    (let ((table (doom--store-init "default")))
+      (remhash 'test table)
+      table)
+    (doom--store-flush location)))
+
+;;;###autoload
+(defun doom-store-member-p (key &optional location)
+  "Return t if KEY in LOCATION exists.
+LOCATION defaults to `doom-store-location'."
+  (let ((nil-value (format "--nilvalue%s--" (current-time))))
+    (not (equal (doom-store-get key location nil-value)
+                nil-value))))
+
+;;;###autoload
+(defun doom-store-clear (&optional location)
+  "Clear the store at LOCATION (defaults to `doom-store-location')."
+  (let* ((location (or location doom-store-location))
+         (path (expand-file-name location doom-store-dir)))
+    (remhash location doom--store-table)
+    (when (file-exists-p path)
+      (delete-file path)
+      t)))

core/cli/autoloads.el

@@ -32,14 +32,16 @@ one wants that.")
      (cl-check-type file string)
      (and (print! (start "Generating core autoloads..."))
           (doom-cli--write-autoloads
-           file (doom-cli--generate-autoloads
+           file
-                 (cl-loop for dir
+           (doom-cli--generate-emacs-version-check)
-                          in (append (list doom-core-dir)
+           (doom-cli--generate-autoloads
-                                     (cdr (doom-module-load-path 'all-p))
+            (cl-loop for dir
-                                     (list doom-private-dir))
+                     in (append (list doom-core-dir)
-                          if (doom-glob dir "autoload.el") collect it
+                                (cdr (doom-module-load-path 'all-p))
-                          if (doom-glob dir "autoload/*.el") append it)
+                                (list doom-private-dir))
-                 'scan))
+                     if (doom-glob dir "autoload.el") collect it
+                     if (doom-glob dir "autoload/*.el") append it)
+            'scan))
           (print! (start "Byte-compiling core autoloads file..."))
           (doom-cli--byte-compile-file file)
           (print! (success "Generated %s")
@@ -105,6 +107,12 @@ one wants that.")
                 (print! "M-x doom/restart")
                 (print! "M-x doom/reload")))
 
+(defun doom-cli--generate-emacs-version-check ()
+  `((unless (equal emacs-major-version (eval-when-compile emacs-major-version))
+      (signal 'doom-error
+              (list "Your installed (major) version of Emacs has changed"
+                    "Run 'doom sync && doom build' to bring Doom up to speed")))))
+
 (defun doom-cli--generate-var-cache (vars)
   `((setq ,@(cl-loop for var in vars
                      append `(,var ',(symbol-value var))))))

core/cli/env.el

@@ -113,10 +113,11 @@ default, on Linux, this is '$SHELL -ic /usr/bin/env'. Variables in
                          "# run 'doom sync'. To create a safe-to-edit envvar file use:\n#\n"
                          "#   doom env -o ~/.doom.d/myenv\n#\n"
                          "# And load it with (doom-load-envvars-file \"~/.doom.d/myenv\").\n")
-               (concat "# This file is safe to edit by hand, but needs to be loaded manually with:\n#\n"
+               (concat "# This file is safe to edit by hand, but remember to preserve the null bytes at\n"
+                       "# the end of each line! needs to be loaded manually with:\n#\n"
                        "#   (doom-load-envvars-file \"path/to/this/file\")\n#\n"
                        "# Use 'doom env -o path/to/this/file' to regenerate it."))
-             "# ---------------------------------------------------------------------------\n\n"))
+             "# ---------------------------------------------------------------------------\n\0\n"))
            ;; We assume that this noninteractive session was spawned from the
            ;; user's interactive shell, therefore we just dump
            ;; `process-environment' to a file.
@@ -124,7 +125,7 @@ default, on Linux, this is '$SHELL -ic /usr/bin/env'. Variables in
              (if (cl-find-if (doom-rpartial #'string-match-p (car (split-string env "=")))
                              doom-env-ignored-vars)
                  (print! (info "Ignoring %s") env)
-               (insert env "\n")))
+               (insert env "\0\n")))
            (print! (success "Successfully generated %S")
                    (path env-file))
            t))))))

core/core-cli.el

@@ -258,7 +258,7 @@ BODY will be run when this dispatcher is called."
                    (print! "%2s) %s" (1+ (length options))
                            (if (cl-find-if (doom-rpartial #'string-match-p desc)
                                            doom--cli-straight-discard-options)
-                               (concat desc " (Recommended)")
+                               (green (concat desc " (Recommended)"))
                              desc))))
          (terpri)
          (let* ((options

core/core-editor.el

@@ -293,10 +293,7 @@ possible."
 `pp' can be expensive for longer lists, and there's no reason to prettify cache
 files, so we replace calls to `pp' with the much faster `prin1'."
     :around #'save-place-alist-to-file
-    (cl-letf (((symbol-function #'pp) #'prin1))
+    (letf! ((#'pp #'prin1)) (funcall orig-fn))))
-      (funcall orig-fn)))
-
-  (save-place-mode +1))
 
 
 (use-package! server
@@ -394,18 +391,14 @@ files, so we replace calls to `pp' with the much faster `prin1'."
 `nim-mode'. This prevents them from leaving Emacs in a broken state."
     :around #'dtrt-indent-mode
     (let ((dtrt-indent-run-after-smie dtrt-indent-run-after-smie))
-      (cl-letf* ((old-smie-config-guess (symbol-function 'smie-config-guess))
+      (letf! ((defun symbol-config--guess (beg end)
-                 (old-smie-config--guess (symbol-function 'symbol-config--guess))
+                (funcall symbol-config--guess beg (min end 10000)))
-                 ((symbol-function 'symbol-config--guess)
+              (defun smie-config-guess ()
-                  (lambda (beg end)
+                (condition-case e (funcall smie-config-guess)
-                    (funcall old-smie-config--guess beg (min end 10000))))
+                  (error (setq dtrt-indent-run-after-smie t)
-                 ((symbol-function 'smie-config-guess)
+                         (message "[WARNING] Indent detection: %s"
-                  (lambda ()
+                                  (error-message-string e))
-                    (condition-case e (funcall old-smie-config-guess)
+                         (message ""))))) ; warn silently
-                      (error (setq dtrt-indent-run-after-smie t)
-                             (message "[WARNING] Indent detection: %s"
-                                      (error-message-string e))
-                             (message "")))))) ; warn silently
         (funcall orig-fn arg)))))
 
 
@@ -421,8 +414,8 @@ files, so we replace calls to `pp' with the much faster `prin1'."
 
   (defun doom-use-helpful-a (orig-fn &rest args)
     "Force ORIG-FN to use helpful instead of the old describe-* commands."
-    (cl-letf (((symbol-function #'describe-function) #'helpful-function)
+    (letf! ((#'describe-function #'helpful-function)
-              ((symbol-function #'describe-variable) #'helpful-variable))
+            (#'describe-variable #'helpful-variable))
       (apply orig-fn args)))
 
   (after! apropos
@@ -486,8 +479,9 @@ files, so we replace calls to `pp' with the much faster `prin1'."
     (defun doom-init-smartparens-in-minibuffer-maybe-h ()
       "Enable `smartparens-mode' in the minibuffer, during `eval-expression',
 `pp-eval-expression' or `evil-ex'."
-      (when (memq this-command '(eval-expression pp-eval-expression evil-ex))
+      (and (memq this-command '(eval-expression pp-eval-expression evil-ex))
-        (smartparens-mode))))
+           smartparens-global-mode
+           (smartparens-mode))))
 
   ;; You're likely writing lisp in the minibuffer, therefore, disable these
   ;; quote pairs, which lisps doesn't use for strings:

core/core-keybinds.el

@@ -221,16 +221,6 @@ For example, :nvi will map to (list 'normal 'visual 'insert). See
            else do (error "not a valid state: %s" l)))
 
 
-;; Register keywords for proper indentation (see `map!')
-(put :after        'lisp-indent-function 'defun)
-(put :desc         'lisp-indent-function 'defun)
-(put :leader       'lisp-indent-function 'defun)
-(put :localleader  'lisp-indent-function 'defun)
-(put :map          'lisp-indent-function 'defun)
-(put :mode         'lisp-indent-function 'defun)
-(put :prefix       'lisp-indent-function 'defun)
-(put :prefix-map   'lisp-indent-function 'defun)
-
 ;; specials
 (defvar doom--map-forms nil)
 (defvar doom--map-fn nil)

core/core-lib.el

@@ -1,8 +1,5 @@
 ;;; core-lib.el -*- lexical-binding: t; -*-
 
-(require 'cl-lib)
-(require 'subr-x)
-
 ;;
 ;;; Helpers
 
@@ -85,6 +82,60 @@ Accepts the same arguments as `message'."
                  format-string)
         ,@args))))
 
+(defun doom-try-run-hook (hook)
+  "Run HOOK (a hook function) with better error handling.
+Meant to be used with `run-hook-wrapped'."
+  (doom-log "Running doom hook: %s" hook)
+  (condition-case e
+      (funcall hook)
+    ((debug error)
+     (signal 'doom-hook-error (list hook e))))
+  ;; return nil so `run-hook-wrapped' won't short circuit
+  nil)
+
+(defun doom-load-autoloads-file (file &optional noerror)
+  "Tries to load FILE (an autoloads file).
+Return t on success, nil otherwise (but logs a warning)."
+  (condition-case e
+      ;; Avoid `file-name-sans-extension' for premature optimization reasons.
+      ;; `string-remove-suffix' is much cheaper (because it does no file sanity
+      ;; checks during or after; just plain ol' string manipulation).
+      (load (string-remove-suffix ".el" file) noerror 'nomessage)
+    (doom-error
+     (signal (car e) (cdr e)))
+    ((debug error)
+     (message "Autoload file error: %s -> %s" (file-name-nondirectory file) e)
+     nil)))
+
+(defun doom-load-envvars-file (file &optional noerror)
+  "Read and set envvars from FILE.
+If NOERROR is non-nil, don't throw an error if the file doesn't exist or is
+unreadable. Returns the names of envvars that were changed."
+  (if (null (file-exists-p file))
+      (unless noerror
+        (signal 'file-error (list "No envvar file exists" file)))
+    (when-let
+        (env
+         (with-temp-buffer
+           (save-excursion
+             (insert "\0\n") ; to prevent off-by-one
+             (insert-file-contents file))
+           (save-match-data
+             (when (re-search-forward "\0\n *\\([^#= \n]*\\)=" nil t)
+               (setq
+                env (split-string (buffer-substring (match-beginning 1) (point-max))
+                                  "\0\n"
+                                  'omit-nulls))))))
+      (setq process-environment (append (nreverse env) process-environment)
+            exec-path (append (split-string (getenv "PATH") path-separator t)
+                              (list exec-directory))
+            shell-file-name (or (getenv "SHELL") shell-file-name))
+      env)))
+
+
+;;
+;;; Functional library
+
 (defalias 'doom-partial #'apply-partially)
 
 (defun doom-rpartial (fn &rest args)
@@ -119,6 +170,11 @@ aliases."
        (call-interactively command))))
 (defalias 'lambda!! 'λ!!)
 
+(defun dir! ()
+  "Returns the directory of the emacs lisp file this macro is called from."
+  (when-let (path (file!))
+    (directory-file-name (file-name-directory path))))
+
 (defun file! ()
   "Return the emacs lisp file this macro is called from."
   (cond ((bound-and-true-p byte-compile-current-file))
@@ -128,10 +184,129 @@ aliases."
         (buffer-file-name)
         ((error "Cannot get this file-path"))))
 
-(defun dir! ()
+(defmacro letenv! (envvars &rest body)
-  "Returns the directory of the emacs lisp file this macro is called from."
+  "Lexically bind ENVVARS in BODY, like `let' but for `process-environment'."
-  (when-let (path (file!))
+  (declare (indent 1))
-    (directory-file-name (file-name-directory path))))
+  `(let ((process-environment (copy-sequence process-environment)))
+     (dolist (var (list ,@(cl-loop for (var val) in envvars
+                                   collect `(cons ,var ,val))))
+       (setenv (car var) (cdr var)))
+     ,@body))
+
+(defmacro letf! (bindings &rest body)
+  "Temporarily rebind function and macros in BODY.
+
+BINDINGS is either a) a list of, or a single, `defun' or `defmacro'-ish form, or
+b) a list of (PLACE VALUE) bindings as `cl-letf*' would accept.
+
+TYPE is either `defun' or `defmacro'. NAME is the name of the function. If an
+original definition for NAME exists, it can be accessed as a lexical variable by
+the same name, for use with `funcall' or `apply'. ARGLIST and BODY are as in
+`defun'.
+
+\(fn ((TYPE NAME ARGLIST &rest BODY) ...) BODY...)"
+  (declare (indent defun))
+  (setq body (macroexp-progn body))
+  (when (memq (car bindings) '(defun defmacro))
+    (setq bindings (list bindings)))
+  (dolist (binding (nreverse bindings) body)
+    (let ((type (car binding))
+          (rest (cdr binding)))
+      (setq
+       body (pcase type
+              (`defmacro `(cl-macrolet ((,(car rest) ,(cadr rest) ,@(cddr rest))) ,body))
+              (`defun `(cl-letf* ((,(car rest) (symbol-function #',(car rest)))
+                                   ((symbol-function #',(car rest))
+                                    (lambda ,(cadr rest) ,@(cddr rest))))
+                          ,body))
+              (_
+               (when (eq (car-safe type) 'function)
+                 (setq type `(symbol-function ,type)))
+               `(cl-letf ((,type ,@rest)) ,body)))))))
+
+(defmacro quiet! (&rest forms)
+  "Run FORMS without generating any output.
+
+This silences calls to `message', `load-file', `write-region' and anything that
+writes to `standard-output'."
+  `(cond (doom-debug-mode ,@forms)
+         ((not doom-interactive-mode)
+          (letf! ((standard-output (lambda (&rest _)))
+                  (defun load-file (file) (load-file nil t))
+                  (defun message (&rest _))
+                  (defun write-region (start end filename &optional append visit lockname mustbenew)
+                    (unless visit (setq visit 'no-message))
+                    (funcall write-region start end filename append visit lockname mustbenew)))
+            ,@forms))
+         ((let ((inhibit-message t)
+                (save-silently t))
+            (prog1 ,@forms (message ""))))))
+
+(defmacro if! (cond then &rest body)
+  "Expands to THEN if COND is non-nil, to BODY otherwise.
+COND is checked at compile/expansion time, allowing BODY to be omitted
+entirely when the elisp is byte-compiled. Use this for forms that contain
+expensive macros that could safely be removed at compile time."
+  (declare (indent 2))
+  (if (eval cond)
+      then
+    (macroexp-progn body)))
+
+(defmacro when! (cond &rest body)
+  "Expands to BODY if CONDITION is non-nil at compile/expansion time.
+See `if!' for details on this macro's purpose."
+  (declare (indent 1))
+  (when (eval cond)
+    (macroexp-progn body)))
+
+
+;;; Mutation
+(defmacro appendq! (sym &rest lists)
+  "Append LISTS to SYM in place."
+  `(setq ,sym (append ,sym ,@lists)))
+
+(defmacro setq! (&rest settings)
+  "A stripped-down `customize-set-variable' with the syntax of `setq'.
+
+Use this instead of `setq' when you know a variable has a custom setter (a :set
+property in its `defcustom' declaration). This trigger setters. `setq' does
+not."
+  (macroexp-progn
+   (cl-loop for (var val) on settings by 'cddr
+            collect (list (or (get var 'custom-set) #'set)
+                          (list 'quote var)
+                          val))))
+
+(defmacro delq! (elt list &optional fetcher)
+  "`delq' ELT from LIST in-place.
+
+If FETCHER is a function, ELT is used as the key in LIST (an alist)."
+  `(setq ,list
+         (delq ,(if fetcher
+                    `(funcall ,fetcher ,elt ,list)
+                  elt)
+               ,list)))
+
+(defmacro pushnew! (place &rest values)
+  "Push VALUES sequentially into PLACE, if they aren't already present.
+This is a variadic `cl-pushnew'."
+  (let ((var (make-symbol "result")))
+    `(dolist (,var (list ,@values) (with-no-warnings ,place))
+       (cl-pushnew ,var ,place :test #'equal))))
+
+(defmacro prependq! (sym &rest lists)
+  "Prepend LISTS to SYM in place."
+  `(setq ,sym (append ,@lists ,sym)))
+
+
+;;; Loading
+(defmacro add-load-path! (&rest dirs)
+  "Add DIRS to `load-path', relative to the current file.
+The current file is the file from which `add-to-load-path!' is used."
+  `(let ((default-directory ,(dir!))
+         file-name-handler-alist)
+     (dolist (dir (list ,@dirs))
+       (cl-pushnew (expand-file-name dir) load-path))))
 
 (defmacro after! (package &rest body)
   "Evaluate BODY after PACKAGE have loaded.
@@ -183,58 +358,84 @@ This is a wrapper around `eval-after-load' that:
                (setq body `((after! ,next ,@body))))
              (car body))))))
 
-(defmacro setq! (&rest settings)
+(defun doom--handle-load-error (e target path)
-  "A stripped-down `customize-set-variable' with the syntax of `setq'.
+  (let* ((source (file-name-sans-extension target))
+         (err (cond ((not (featurep 'core))
+                     (cons 'error (file-name-directory path)))
+                    ((file-in-directory-p source doom-core-dir)
+                     (cons 'doom-error doom-core-dir))
+                    ((file-in-directory-p source doom-private-dir)
+                     (cons 'doom-private-error doom-private-dir))
+                    ((cons 'doom-module-error doom-emacs-dir)))))
+    (signal (car err)
+            (list (file-relative-name
+                    (concat source ".el")
+                    (cdr err))
+                  e))))
 
-Use this instead of `setq' when you know a variable has a custom setter (a :set
+(defmacro load! (filename &optional path noerror)
-property in its `defcustom' declaration). This trigger setters. `setq' does
+  "Load a file relative to the current executing file (`load-file-name').
-not."
-  (macroexp-progn
-   (cl-loop for (var val) on settings by 'cddr
-            collect `(funcall (or (get ',var 'custom-set) #'set)
-                              ',var ,val))))
 
-(defmacro pushnew! (place &rest values)
+FILENAME is either a file path string or a form that should evaluate to such a
-  "Push VALUES sequentially into PLACE, if they aren't already present.
+string at run time. PATH is where to look for the file (a string representing a
-This is a variadic `cl-pushnew'."
+directory path). If omitted, the lookup is relative to either `load-file-name',
-  (let ((var (make-symbol "result")))
+`byte-compile-current-file' or `buffer-file-name' (checked in that order).
-    `(dolist (,var (list ,@values) (with-no-warnings ,place))
-       (cl-pushnew ,var ,place :test #'equal))))
 
-(defmacro prependq! (sym &rest lists)
+If NOERROR is non-nil, don't throw an error if the file doesn't exist."
-  "Prepend LISTS to SYM in place."
+  (let* ((path (or path
-  `(setq ,sym (append ,@lists ,sym)))
+                   (dir!)
+                   (error "Could not detect path to look for '%s' in"
+                          filename)))
+         (file (if path
+                  `(expand-file-name ,filename ,path)
+                filename)))
+    `(condition-case-unless-debug e
+         (let (file-name-handler-alist)
+           (load ,file ,noerror 'nomessage))
+       (doom-error (signal (car e) (cdr e)))
+       (error (doom--handle-load-error e ,file ,path)))))
 
-(defmacro appendq! (sym &rest lists)
+(defmacro defer-until! (condition &rest body)
-  "Append LISTS to SYM in place."
+  "Run BODY when CONDITION is true (checks on `after-load-functions'). Meant to
-  `(setq ,sym (append ,sym ,@lists)))
+serve as a predicated alternative to `after!'."
+  (declare (indent defun) (debug t))
+  `(if ,condition
+       (progn ,@body)
+     ,(let ((fn (intern (format "doom--delay-form-%s-h" (sxhash (cons condition body))))))
+        `(progn
+           (fset ',fn (lambda (&rest args)
+                        (when ,(or condition t)
+                          (remove-hook 'after-load-functions #',fn)
+                          (unintern ',fn nil)
+                          (ignore args)
+                          ,@body)))
+           (put ',fn 'permanent-local-hook t)
+           (add-hook 'after-load-functions #',fn)))))
 
-(defmacro delq! (elt list &optional fetcher)
+(defmacro defer-feature! (feature &optional fn)
-  "`delq' ELT from LIST in-place.
+  "Pretend FEATURE hasn't been loaded yet, until FEATURE-hook or FN runs.
 
-If FETCHER is a function, ELT is used as the key in LIST (an alist)."
+Some packages (like `elisp-mode' and `lisp-mode') are loaded immediately at
-  `(setq ,list
+startup, which will prematurely trigger `after!' (and `with-eval-after-load')
-         (delq ,(if fetcher
+blocks. To get around this we make Emacs believe FEATURE hasn't been loaded yet,
-                    `(funcall ,fetcher ,elt ,list)
+then wait until FEATURE-hook (or MODE-hook, if FN is provided) is triggered to
-                  elt)
+reverse this and trigger `after!' blocks at a more reasonable time."
-               ,list)))
+  (let ((advice-fn (intern (format "doom--defer-feature-%s-a" feature)))
+        (fn (or fn feature)))
+    `(progn
+       (setq features (delq ',feature features))
+       (advice-add #',fn :before #',advice-fn)
+       (defun ,advice-fn (&rest _)
+         ;; Some plugins (like yasnippet) will invoke a fn early to parse
+         ;; code, which would prematurely trigger this. In those cases, well
+         ;; behaved plugins will use `delay-mode-hooks', which we can check for:
+         (when (and ,(intern (format "%s-hook" fn))
+                    (not delay-mode-hooks))
+           ;; ...Otherwise, announce to the world this package has been loaded,
+           ;; so `after!' handlers can react.
+           (provide ',feature)
+           (advice-remove #',fn #',advice-fn))))))
 
-(defmacro letenv! (envvars &rest body)
-  "Lexically bind ENVVARS in BODY, like `let' but for `process-environment'."
-  (declare (indent 1))
-  `(let ((process-environment (copy-sequence process-environment)))
-     (dolist (var (list ,@(cl-loop for (var val) in envvars
-                                   collect `(cons ,var ,val))))
-       (setenv (car var) (cdr var)))
-     ,@body))
-
-(defmacro add-load-path! (&rest dirs)
-  "Add DIRS to `load-path', relative to the current file.
-The current file is the file from which `add-to-load-path!' is used."
-  `(let ((default-directory ,(dir!))
-         file-name-handler-alist)
-     (dolist (dir (list ,@dirs))
-       (cl-pushnew (expand-file-name dir) load-path))))
 
 ;;; Hooks
 (defvar doom--transient-counter 0)
@@ -360,106 +561,8 @@ If N and M = 1, there's no benefit to using this macro over `remove-hook'.
             in (doom--setq-hook-fns hooks vars 'singles)
             collect `(remove-hook ',hook #',fn))))
 
-(defmacro load! (filename &optional path noerror)
-  "Load a file relative to the current executing file (`load-file-name').
 
-FILENAME is either a file path string or a form that should evaluate to such a
-string at run time. PATH is where to look for the file (a string representing a
-directory path). If omitted, the lookup is relative to either `load-file-name',
-`byte-compile-current-file' or `buffer-file-name' (checked in that order).
-
-If NOERROR is non-nil, don't throw an error if the file doesn't exist."
-  (let* ((path (or path
-                   (dir!)
-                   (error "Could not detect path to look for '%s' in"
-                          filename)))
-         (file (if path
-                  `(expand-file-name ,filename ,path)
-                filename)))
-    `(condition-case-unless-debug e
-         (let (file-name-handler-alist)
-           (load ,file ,noerror 'nomessage))
-       (doom-error (signal (car e) (cdr e)))
-       (error
-        (let* ((source (file-name-sans-extension ,file))
-               (err (cond ((not (featurep 'core))
-                           (cons 'error (file-name-directory path)))
-                          ((file-in-directory-p source doom-core-dir)
-                           (cons 'doom-error doom-core-dir))
-                          ((file-in-directory-p source doom-private-dir)
-                           (cons 'doom-private-error doom-private-dir))
-                          ((cons 'doom-module-error doom-emacs-dir)))))
-          (signal (car err)
-                  (list (file-relative-name
-                         (concat source ".el")
-                         (cdr err))
-                        e)))))))
-
-(defmacro defer-until! (condition &rest body)
-  "Run BODY when CONDITION is true (checks on `after-load-functions'). Meant to
-serve as a predicated alternative to `after!'."
-  (declare (indent defun) (debug t))
-  `(if ,condition
-       (progn ,@body)
-     ,(let ((fn (intern (format "doom--delay-form-%s-h" (sxhash (cons condition body))))))
-        `(progn
-           (fset ',fn (lambda (&rest args)
-                        (when ,(or condition t)
-                          (remove-hook 'after-load-functions #',fn)
-                          (unintern ',fn nil)
-                          (ignore args)
-                          ,@body)))
-           (put ',fn 'permanent-local-hook t)
-           (add-hook 'after-load-functions #',fn)))))
-
-(defmacro defer-feature! (feature &optional fn)
-  "Pretend FEATURE hasn't been loaded yet, until FEATURE-hook or FN runs.
-
-Some packages (like `elisp-mode' and `lisp-mode') are loaded immediately at
-startup, which will prematurely trigger `after!' (and `with-eval-after-load')
-blocks. To get around this we make Emacs believe FEATURE hasn't been loaded yet,
-then wait until FEATURE-hook (or MODE-hook, if FN is provided) is triggered to
-reverse this and trigger `after!' blocks at a more reasonable time."
-  (let ((advice-fn (intern (format "doom--defer-feature-%s-a" feature)))
-        (fn (or fn feature)))
-    `(progn
-       (setq features (delq ',feature features))
-       (advice-add #',fn :before #',advice-fn)
-       (defun ,advice-fn (&rest _)
-         ;; Some plugins (like yasnippet) will invoke a fn early to parse
-         ;; code, which would prematurely trigger this. In those cases, well
-         ;; behaved plugins will use `delay-mode-hooks', which we can check for:
-         (when (and ,(intern (format "%s-hook" fn))
-                    (not delay-mode-hooks))
-           ;; ...Otherwise, announce to the world this package has been loaded,
-           ;; so `after!' handlers can react.
-           (provide ',feature)
-           (advice-remove #',fn #',advice-fn))))))
-
-(defmacro quiet! (&rest forms)
-  "Run FORMS without generating any output.
-
-This silences calls to `message', `load-file', `write-region' and anything that
-writes to `standard-output'."
-  `(cond (doom-debug-mode ,@forms)
-         ((not doom-interactive-mode)
-          (let ((old-fn (symbol-function 'write-region)))
-            (cl-letf ((standard-output (lambda (&rest _)))
-                      ((symbol-function 'load-file) (lambda (file) (load file nil t)))
-                      ((symbol-function 'message) (lambda (&rest _)))
-                      ((symbol-function 'write-region)
-                       (lambda (start end filename &optional append visit lockname mustbenew)
-                         (unless visit (setq visit 'no-message))
-                         (funcall old-fn start end filename append visit lockname mustbenew))))
-              ,@forms)))
-         ((let ((inhibit-message t)
-                (save-silently t))
-            (prog1 ,@forms (message ""))))))
-
-
-;;
 ;;; Definers
-
 (defmacro defadvice! (symbol arglist &optional docstring &rest body)
   "Define an advice called SYMBOL and add it to PLACES.
 

core/core-modules.el

@@ -211,13 +211,15 @@ those directories. The first returned path is always `doom-private-dir'."
   (declare (pure t) (side-effect-free t))
   (append (list doom-private-dir)
           (if module-dirs
-              (doom-files-in (if (listp module-dirs)
+              (mapcar (lambda (m) (doom-module-locate-path (car m) (cdr m)))
-                                 module-dirs
+                      (doom-files-in (if (listp module-dirs)
-                               doom-modules-dirs)
+                                         module-dirs
-                             :type 'dirs
+                                       doom-modules-dirs)
-                             :mindepth 1
+                                     :map #'doom-module-from-path
-                             :depth 1)
+                                     :type 'dirs
-            (cl-loop for plist being the hash-values of (doom-modules)
+                                     :mindepth 1
+                                     :depth 1))
+            (cl-loop for plist being the hash-values of doom-modules
                      collect (plist-get plist :path)))
           nil))
 

core/core-packages.el

@@ -269,9 +269,13 @@ elsewhere."
                recipe
              ;; Expand :local-repo from current directory
              (when local-repo
-               (plist-put! plist :recipe
+               (plist-put!
-                           (plist-put recipe :local-repo
+                plist :recipe
-                                      (expand-file-name local-repo ,(dir!)))))))
+                (plist-put recipe :local-repo
+                           (let ((local-path (expand-file-name local-repo ,(dir!))))
+                             (if (file-directory-p local-path)
+                                 local-path
+                               local-repo)))))))
        (error
         (signal 'doom-package-error
                 (cons ,(symbol-name name)

core/core-projects.el

@@ -43,7 +43,7 @@ Emacs.")
   ;; REVIEW Resolve the project root once, when the file/buffer is opened. This
   ;;        speeds up projectile's project root resolution by leaps, but does
   ;;        put you at risk of having a stale project root.
-  (setq-hook! '(after-change-major-mode-hook
+  (setq-hook! '(change-major-mode-after-body-hook
                 ;; In case the user saves the file to a new location
                 after-save-hook
                 ;; ...or makes external changes then returns to Emacs
@@ -146,7 +146,7 @@ c) are not valid projectile projects."
    ;; .gitignore. This is recommended in the projectile docs.
    ((executable-find doom-projectile-fd-binary)
     (setq projectile-generic-command
-          (format "%s . --color=never --type f -0 -H -E .git"
+          (format "%s . -0 -H -E .git --color=never --type file --type symlink --follow"
                   doom-projectile-fd-binary)
           projectile-git-command projectile-generic-command
           projectile-git-submodule-command nil
@@ -156,9 +156,11 @@ c) are not valid projectile projects."
    ;; Otherwise, resort to ripgrep, which is also faster than find
    ((executable-find "rg")
     (setq projectile-generic-command
-          (concat "rg -0 --files --color=never --hidden"
+          (concat "rg -0 --files --follow --color=never --hidden"
                   (cl-loop for dir in projectile-globally-ignored-directories
-                           concat (format " --glob '!%s'" dir)))
+                           concat " --glob "
+                           concat (shell-quote-argument (concat "!" dir)))
+                  (if IS-WINDOWS " --path-separator /"))
           projectile-git-command projectile-generic-command
           projectile-git-submodule-command nil
           ;; ensure Windows users get rg's benefits

core/core-ui.el

@@ -54,6 +54,9 @@ examples.
 It is recommended you don't set specify a font-size, as to inherit `doom-font's
 size.")
 
+(defvar doom-unicode-extra-fonts nil
+  "Fonts to inject into the unicode charset before `doom-unicode-font'.")
+
 
 ;;
 ;;; Custom hooks
@@ -85,48 +88,51 @@ size.")
 (defvar doom--last-frame nil)
 
 (defun doom-run-switch-window-hooks-h ()
-  (let ((gc-cons-threshold most-positive-fixnum))
+  (unless (or doom-inhibit-switch-window-hooks
-    (unless (or doom-inhibit-switch-window-hooks
+              (eq doom--last-window (selected-window))
-                (eq doom--last-window (selected-window))
+              (minibufferp))
-                (minibufferp))
+    (let ((gc-cons-threshold most-positive-fixnum)
-      (let ((doom-inhibit-switch-window-hooks t)
+          (doom-inhibit-switch-window-hooks t)
-            (inhibit-redisplay t))
+          (inhibit-redisplay t))
-        (run-hooks 'doom-switch-window-hook)
+      (run-hooks 'doom-switch-window-hook)
-        (setq doom--last-window (selected-window))))))
+      (setq doom--last-window (selected-window)))))
 
 (defun doom-run-switch-frame-hooks-h (&rest _)
   (unless (or doom-inhibit-switch-frame-hooks
               (eq doom--last-frame (selected-frame))
               (frame-parameter nil 'parent-frame))
-    (let ((doom-inhibit-switch-frame-hooks t))
+    (let ((gc-cons-threshold most-positive-fixnum)
+          (doom-inhibit-switch-frame-hooks t))
       (run-hooks 'doom-switch-frame-hook)
       (setq doom--last-frame (selected-frame)))))
 
 (defun doom-run-switch-buffer-hooks-a (orig-fn buffer-or-name &rest args)
-  (let ((gc-cons-threshold most-positive-fixnum))
+  (if (or doom-inhibit-switch-buffer-hooks
-    (if (or doom-inhibit-switch-buffer-hooks
+          (and buffer-or-name
-            (eq (current-buffer) (get-buffer buffer-or-name))
+               (eq (current-buffer)
-            (and (eq orig-fn #'switch-to-buffer) (car args)))
+                   (get-buffer buffer-or-name)))
-        (apply orig-fn buffer-or-name args)
+          (and (eq orig-fn #'switch-to-buffer) (car args)))
-      (let ((doom-inhibit-switch-buffer-hooks t)
+      (apply orig-fn buffer-or-name args)
-            (inhibit-redisplay t))
+    (let ((gc-cons-threshold most-positive-fixnum)
-        (when-let (buffer (apply orig-fn buffer-or-name args))
+          (doom-inhibit-switch-buffer-hooks t)
-          (with-current-buffer (if (windowp buffer)
+          (inhibit-redisplay t))
-                                   (window-buffer buffer)
+      (when-let (buffer (apply orig-fn buffer-or-name args))
-                                 buffer)
+        (with-current-buffer (if (windowp buffer)
-            (run-hooks 'doom-switch-buffer-hook))
+                                 (window-buffer buffer)
-          buffer)))))
+                               buffer)
+          (run-hooks 'doom-switch-buffer-hook))
+        buffer))))
 
 (defun doom-run-switch-to-next-prev-buffer-hooks-a (orig-fn &rest args)
-  (let ((gc-cons-threshold most-positive-fixnum))
+  (if doom-inhibit-switch-buffer-hooks
-    (if doom-inhibit-switch-buffer-hooks
+      (apply orig-fn args)
-        (apply orig-fn args)
+    (let ((gc-cons-threshold most-positive-fixnum)
-      (let ((doom-inhibit-switch-buffer-hooks t)
+          (doom-inhibit-switch-buffer-hooks t)
-            (inhibit-redisplay t))
+          (inhibit-redisplay t))
-        (when-let (buffer (apply orig-fn args))
+      (when-let (buffer (apply orig-fn args))
-          (with-current-buffer buffer
+        (with-current-buffer buffer
-            (run-hooks 'doom-switch-buffer-hook))
+          (run-hooks 'doom-switch-buffer-hook))
-          buffer)))))
+        buffer))))
 
 (defun doom-protect-fallback-buffer-h ()
   "Don't kill the scratch buffer. Meant for `kill-buffer-query-functions'."
@@ -300,7 +306,7 @@ windows, switch to `doom-fallback-buffer'. Otherwise, delegate to original
   (add-to-list 'default-frame-alist '(tool-bar-lines . 0))
   (add-to-list 'default-frame-alist '(vertical-scroll-bars)))
 
-(when IS-MAC
+(when! IS-MAC
   ;; Curse Lion and its sudden but inevitable fullscreen mode!
   ;; NOTE Meaningless to railwaycat's emacs-mac build
   (setq ns-use-native-fullscreen nil)
@@ -410,13 +416,6 @@ windows, switch to `doom-fallback-buffer'. Otherwise, delegate to original
         (set-window-configuration doom--ediff-saved-wconf)))))
 
 
-(use-package! goto-addr
-  :hook (text-mode . goto-address-mode)
-  :hook (prog-mode . goto-address-prog-mode)
-  :config
-  (define-key goto-address-highlight-keymap (kbd "RET") #'goto-address-at-point))
-
-
 (use-package! hl-line
   ;; Highlights the current line
   :hook ((prog-mode text-mode conf-mode special-mode) . hl-line-mode)
@@ -485,6 +484,14 @@ windows, switch to `doom-fallback-buffer'. Otherwise, delegate to original
              all-the-icons-wicon
              all-the-icons-material
              all-the-icons-alltheicon)
+  :preface
+  (setq doom-unicode-extra-fonts
+        (list "Weather Icons"
+              "github-octicons"
+              "FontAwesome"
+              "all-the-icons"
+              "file-icons"
+              "Material Icons"))
   :config
   (cond ((daemonp)
          (defadvice! doom--disable-all-the-icons-in-tty-a (orig-fn &rest args)
@@ -579,8 +586,9 @@ behavior). Do not set this directly, this is let-bound in `doom-init-theme-h'.")
           (set-face-attribute 'fixed-pitch-serif nil :font doom-serif-font))
         (when doom-variable-pitch-font
           (set-face-attribute 'variable-pitch nil :font doom-variable-pitch-font))
-        (when (and doom-unicode-font (fboundp 'set-fontset-font))
+        (when (fboundp 'set-fontset-font)
-          (set-fontset-font t 'unicode doom-unicode-font nil 'prepend)))
+          (dolist (font (append doom-unicode-extra-fonts (doom-enlist doom-unicode-font)))
+            (set-fontset-font t 'unicode font nil 'prepend))))
     ((debug error)
      (if (string-prefix-p "Font not available: " (error-message-string e))
          (lwarn 'doom-ui :warning
@@ -611,11 +619,14 @@ behavior). Do not set this directly, this is let-bound in `doom-init-theme-h'.")
       (unless no-enable
         (setq doom-theme theme
               doom-init-theme-p t)
+        ;; `load-theme' doesn't disable previously enabled themes, which seems
+        ;; like what you'd want. You could always use `enable-theme' to activate
+        ;; multiple themes instead.
         (mapc #'disable-theme (remq theme custom-enabled-themes))
         (run-hooks 'doom-load-theme-hook))
       result)))
 
-(unless EMACS27+
+(when! (not EMACS27+)
   ;; DEPRECATED Not needed in Emacs 27
   (defadvice! doom--prefer-compiled-theme-a (orig-fn &rest args)
     "Have `load-theme' prioritize the byte-compiled theme.
@@ -624,10 +635,8 @@ This offers a moderate boost in startup (or theme switch) time, so long as
     :around #'load-theme
     (if (or (null after-init-time)
             doom--prefer-theme-elc)
-        (cl-letf* ((old-locate-file (symbol-function 'locate-file))
+        (letf! (defun locate-file (filename path &optional _suffixes predicate)
-                   ((symbol-function 'locate-file)
+                 (funcall locate-file filename path '("c" "") predicate))
-                    (lambda (filename path &optional _suffixes predicate)
-                      (funcall old-locate-file filename path '("c" "") predicate))))
           (apply orig-fn args))
       (apply orig-fn args))))
 

core/core.el

@@ -14,6 +14,10 @@
 (defconst IS-WINDOWS (memq system-type '(cygwin windows-nt ms-dos)))
 (defconst IS-BSD     (or IS-MAC (eq system-type 'berkeley-unix)))
 
+;; Unix tools looks for HOME, but this is normally not defined on Windows.
+(when (and IS-WINDOWS (null (getenv "HOME")))
+  (setenv "HOME" (getenv "USERPROFILE")))
+
 ;; Ensure `doom-core-dir' is in `load-path'
 (add-to-list 'load-path (file-name-directory load-file-name))
 
@@ -40,6 +44,8 @@
   (add-hook 'emacs-startup-hook #'doom-reset-file-handler-alist-h))
 
 ;; Just the bare necessities
+(require 'subr-x)
+(require 'cl-lib)
 (require 'core-lib)
 
 
@@ -207,27 +213,22 @@ users).")
       ;; https://www.keylength.com/en/4/
       gnutls-min-prime-bits 3072
       tls-checktrust gnutls-verify-error
-      ;; Emacs is built with `gnutls' by default, so `tls-program' would not
+      ;; Emacs is built with `gnutls' by default, so `tls-program' would not be
-      ;; be used in that case. Otherwiese, people have reasons to not go with
+      ;; used in that case. Otherwise, people have reasons to not go with
-      ;; `gnutls', we use `openssl' instead.
+      ;; `gnutls', we use `openssl' instead. For more details, see
-      ;; For more details, see https://redd.it/8sykl1
+      ;; https://redd.it/8sykl1
       tls-program '("openssl s_client -connect %h:%p -CAfile %t -nbio -no_ssl3 -no_tls1 -no_tls1_1 -ign_eof"
                     "gnutls-cli -p %p --dh-bits=3072 --ocsp --x509cafile=%t \
 --strict-tofu --priority='SECURE192:+SECURE128:-VERS-ALL:+VERS-TLS1.2:+VERS-TLS1.3' %h"
                     ;; compatibility fallbacks
                     "gnutls-cli -p %p %h"))
 
-;; Emacs stores authinfo in $HOME and in plaintext. Let's not do that, mkay?
+;; Emacs stores `authinfo' in $HOME and in plain-text. Let's not do that, mkay?
 ;; This file stores usernames, passwords, and other such treasures for the
 ;; aspiring malicious third party.
-(setq auth-sources (list (expand-file-name "authinfo.gpg" doom-etc-dir)
+(setq auth-sources (list (concat doom-etc-dir "authinfo.gpg")
                          "~/.authinfo.gpg"))
 
-;; Emacs on Windows frequently confuses HOME (C:\Users\<NAME>) and %APPDATA%,
-;; causing `abbreviate-home-dir' to produce incorrect paths.
-(when IS-WINDOWS
-  (setq abbreviated-home-dir "\\`'"))
-
 ;; Don't litter `doom-emacs-dir'. We don't use `no-littering' because it's a
 ;; mote too opinionated for our needs.
 (setq abbrev-file-name             (concat doom-local-dir "abbrev.el")
@@ -274,11 +275,6 @@ users).")
 ;; quickly self-correct.
 (setq fast-but-imprecise-scrolling t)
 
-;; Font locking is the source of much slowness in Emacs. jit-lock-mode tries to
-;; defer fontification until the user is idle. This should help... in theory.
-(setq jit-lock-defer-time 0    ; only defer while processing input
-      jit-lock-stealth-time 2) ; fontify the rest of the buffer after a delay
-
 ;; Resizing the Emacs frame can be a terribly expensive part of changing the
 ;; font. By inhibiting this, we halve startup times, particularly when we use
 ;; fonts that are larger than the system default (which would resize the frame).
@@ -288,7 +284,7 @@ users).")
 (setq ffap-machine-p-known 'reject)
 
 ;; Font compacting can be terribly expensive, especially for rendering icon
-;; fonts on Windows. Whether it has a noteable affect on Linux and Mac hasn't
+;; fonts on Windows. Whether it has a notable affect on Linux and Mac hasn't
 ;; been determined, but we inhibit it there anyway.
 (setq inhibit-compacting-font-caches t)
 
@@ -432,17 +428,6 @@ If this is a daemon session, load them all immediately instead."
 ;;
 ;;; Bootstrap helpers
 
-(defun doom-try-run-hook (hook)
-  "Run HOOK (a hook function) with better error handling.
-Meant to be used with `run-hook-wrapped'."
-  (doom-log "Running doom hook: %s" hook)
-  (condition-case e
-      (funcall hook)
-    ((debug error)
-     (signal 'doom-hook-error (list hook e))))
-  ;; return nil so `run-hook-wrapped' won't short circuit
-  nil)
-
 (defun doom-display-benchmark-h (&optional return-p)
   "Display a benchmark including number of packages and modules loaded.
 
@@ -455,50 +440,6 @@ If RETURN-P, return the message as a string instead of displaying it."
                (setq doom-init-time
                      (float-time (time-subtract (current-time) before-init-time))))))
 
-(defun doom-load-autoloads-file (file &optional noerror)
-  "Tries to load FILE (an autoloads file).
-Return t on success, nil otherwise (but logs a warning)."
-  (condition-case e
-      (load (substring file 0 -3) noerror 'nomessage)
-    ((debug error)
-     (message "Autoload file error: %s -> %s" (file-name-nondirectory file) e)
-     nil)))
-
-(defun doom-load-envvars-file (file &optional noerror)
-  "Read and set envvars from FILE.
-If NOERROR is non-nil, don't throw an error if the file doesn't exist or is
-unreadable. Returns the names of envvars that were changed."
-  (if (not (file-readable-p file))
-      (unless noerror
-        (signal 'file-error (list "Couldn't read envvar file" file)))
-    (let (envvars environment)
-      (with-temp-buffer
-        (save-excursion
-          (insert "\n")
-          (insert-file-contents file))
-        (while (re-search-forward "\n *\\([^#= \n]*\\)=" nil t)
-          (push (match-string 1) envvars)
-          (push (buffer-substring
-                 (match-beginning 1)
-                 (1- (or (save-excursion
-                           (when (re-search-forward "^\\([^= ]+\\)=" nil t)
-                             (line-beginning-position)))
-                         (point-max))))
-                environment)))
-      (when environment
-        (setq process-environment
-              (append (nreverse environment) process-environment)
-              exec-path
-              (if (member "PATH" envvars)
-                  (append (split-string (getenv "PATH") path-separator t)
-                          (list exec-directory))
-                exec-path)
-              shell-file-name
-              (if (member "SHELL" envvars)
-                  (or (getenv "SHELL") shell-file-name)
-                shell-file-name))
-        envvars))))
-
 (defun doom-initialize (&optional force-p noerror)
   "Bootstrap Doom, if it hasn't already (or if FORCE-P is non-nil).
 
@@ -517,7 +458,7 @@ The overall load order of Doom is as follows:
   Module config.el files
   ~/.doom.d/config.el
   `doom-init-modules-hook'
-  `doom-after-init-hook' (`after-init-hook')
+  `doom-after-init-modules-hook' (`after-init-hook')
   `emacs-startup-hook'
   `doom-init-ui-hook'
   `window-setup-hook'

core/packages.el

@@ -2,47 +2,44 @@
 ;;; core/packages.el
 
 ;; core.el
-(package! auto-minor-mode :pin "17cfa1b548")
+(package! auto-minor-mode :pin "17cfa1b54800fdef2975c0c0531dad34846a5065")
-(package! gcmh :pin "b1bde50891")
+(package! gcmh :pin "b1bde5089169a74f62033d027e06e98cbeedd43f")
 
 ;; core-ui.el
-(package! all-the-icons :pin "0b74fc3618")
+(package! all-the-icons :pin "0b74fc361817e885580c3f3408079f949f5830e1")
-(package! hide-mode-line :pin "88888825b5")
+(package! hide-mode-line :pin "88888825b5b27b300683e662fa3be88d954b1cea")
-(package! highlight-numbers :pin "8b4744c7f4")
+(package! highlight-numbers :pin "8b4744c7f46c72b1d3d599d4fb75ef8183dee307")
-(package! rainbow-delimiters :pin "5125f4e476")
+(package! rainbow-delimiters :pin "5125f4e47604ad36c3eb4706310fcafac729ca8c")
-(package! restart-emacs :pin "9aa90d3df9")
+(package! restart-emacs :pin "9aa90d3df9e08bc420e1c9845ee3ff568e911bd9")
 
 ;; core-editor.el
-(package! better-jumper :pin "6d240032ca")
+(package! better-jumper :pin "6d240032ca213ccb3347e25f26c29b6822bf03a7")
-(package! dtrt-indent :pin "9163cd990f")
+(package! dtrt-indent :pin "9163cd990fb1f43dafed3948c6e406c13a45a6be")
-(package! helpful :pin "c54e9ddbd6")
+(package! helpful :pin "c54e9ddbd6a77858048c1a4c4b549de98af8f88e")
 (when IS-MAC
-  (package! ns-auto-titlebar :pin "1efc30d385"))
+  (package! ns-auto-titlebar :pin "1efc30d38509647b417f05587fd7003457719256"))
-(package! pcre2el :pin "0b5b2a2c17")
+(package! pcre2el :pin "0b5b2a2c173aab3fd14aac6cf5e90ad3bf58fa7d")
-(package! smartparens :pin "555626a43f")
+(package! smartparens :pin "555626a43f9bb1985aa9a0eb675f2b88b29702c8")
 (package! so-long
   :built-in 'prefer ; included in Emacs 27+
   ;; REVIEW so-long is slated to be published to ELPA eventually, but until then
   ;;        I've created my own mirror for it because git.savannah.gnu.org runs
   ;;        on a potato.
   :recipe (:host github :repo "hlissner/emacs-so-long")
-  :pin "ed666b0716")
+  :pin "ed666b0716f60e8988c455804de24b55919e71ca")
 (package! ws-butler
   ;; Use my fork of ws-butler, which has a few choice improvements and
   ;; optimizations (the original has been abandoned).
   :recipe (:host github :repo "hlissner/ws-butler")
-  :pin "2bb49d3ee7")
+  :pin "2bb49d3ee7d2cba133bc7e9cdac416cd1c5e4fe0")
 (unless IS-WINDOWS
   (package! clipetty
     :recipe (:host github :repo "spudlyo/clipetty")
-    :pin "7ee3f9c52f"))
+    :pin "01b39044b9b65fa4ea7d3166f8b1ffab6f740362"))
 
 ;; core-projects.el
-(package! projectile :pin "eec569dc32")
+(package! projectile :pin "5cd261dd75f4d711c0016617621349e2a98b43aa")
 
 ;; core-keybinds.el
-(package! general :pin "14ad4c888b")
+(package! general :pin "42e38034cd2305fa7432866323c923979d8f9b06")
-(package! which-key :pin "8b49ae978c")
+(package! which-key :pin "8b49ae978cceca65967f3544c236f32964ddbed0")
-
-;; autoload/cache.el
-(package! persistent-soft :pin "a1e0ddf2a1")

docs/api.org

@@ -535,7 +535,7 @@ These are side-by-side comparisons, showing how to bind keys with and without
 ** Persist Emacs' initial frame position, dimensions and/or full-screen state across sessions
 #+BEGIN_SRC elisp
 ;; add to ~/.doom.d/config.el
-(when-let (dims (doom-cache-get 'last-frame-size))
+(when-let (dims (doom-store-get 'last-frame-size))
   (cl-destructuring-bind ((left . top) width height fullscreen) dims
     (setq initial-frame-alist
           (append initial-frame-alist
@@ -546,7 +546,7 @@ These are side-by-side comparisons, showing how to bind keys with and without
                     (fullscreen . ,fullscreen))))))
 
 (defun save-frame-dimensions ()
-  (doom-cache-set 'last-frame-size
+  (doom-store-set 'last-frame-size
                   (list (frame-position)
                         (frame-width)
                         (frame-height)

docs/getting_started.org

@@ -17,6 +17,7 @@ us know!
     - [[#on-linux][On Linux]]
       - [[#arch-linux][Arch Linux:]]
       - [[#ubuntu][Ubuntu:]]
+      - [[#fedora][Fedora:]]
       - [[#nixos][NixOS]]
     - [[#on-macos][On macOS]]
       - [[#with-homebrew][With Homebrew]]
@@ -143,6 +144,14 @@ apt-get update
 apt-get install emacs26
 #+END_SRC
 
+**** Fedora:
+#+BEGIN_SRC bash
+# required dependencies
+sudo dnf install emacs git ripgrep
+# optional dependencies
+sudo dnf install tar fd-find clang multimarkdown ShellCheck
+#+END_SRC
+
 **** NixOS
 On NixOS Emacs 26.3 can be installed via ~nix-env -Ai nixos.emacs~, or
 permanently with the following added to ~etc/nixos/configuration.nix~:
@@ -343,9 +352,7 @@ provides, and ~bin/doom help COMMAND~ to display documentation for a particular
 #+begin_quote
 I recommend you add =~/.emacs.d/bin= to your ~PATH~ so you can call =doom=
 directly and from anywhere. Accomplish this by adding this to your .bashrc or
-.zshrc file:
+.zshrc file: ~export PATH=~/.emacs.d/bin:$PATH~
-
-~export PATH="$HOME/.emacs.d/bin:$PATH"~
 #+end_quote
 
 *** Install Doom Manually

modules/app/calendar/config.el

@@ -42,10 +42,10 @@
              org-gcal-fetch
              org-gcal-post-at-point
              org-gcal-delete-at-point)
+  :init
+  (defvar org-gcal-dir (concat doom-cache-dir "org-gcal/"))
+  (defvar org-gcal-token-file (concat org-gcal-dir "token.gpg"))
   :config
   ;; hack to avoid the deferred.el error
   (defun org-gcal--notify (title mes)
     (message "org-gcal::%s - %s" title mes)))
-
-
-;; (use-package! alert)

modules/app/calendar/packages.el

@@ -1,6 +1,6 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; app/calendar/packages.el
 
-(package! calfw :pin "03abce9762")
+(package! calfw :pin "03abce97620a4a7f7ec5f911e669da9031ab9088")
-(package! calfw-org :pin "03abce9762")
+(package! calfw-org :pin "03abce97620a4a7f7ec5f911e669da9031ab9088")
-(package! org-gcal :pin "6821e34967")
+(package! org-gcal :pin "2ee2b31547e6f4e33db70fb812d552e55d612fd6")

modules/app/irc/packages.el

@@ -1,5 +1,5 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; app/irc/packages.el
 
-(package! circe :pin "e5bf5f8974")
+(package! circe :pin "e5bf5f89741a9c43aa406491e94dd8d58c302fb4")
-(package! circe-notifications :pin "291149ac12")
+(package! circe-notifications :pin "291149ac12877bbd062da993479d3533a26862b0")

modules/app/rss/autoload.el

@@ -101,10 +101,9 @@
 ;;;###autoload
 (defun +rss-put-sliced-image-fn (spec alt &optional flags)
   "TODO"
-  (cl-letf (((symbol-function #'insert-image)
+  (letf! (defun insert-image (image &optional alt _area _slice)
-             (lambda (image &optional alt _area _slice)
+           (let ((height (cdr (image-size image t))))
-               (let ((height (cdr (image-size image t))))
+             (insert-sliced-image image alt nil (max 1 (/ height 20.0)) 1)))
-                 (insert-sliced-image image alt nil (max 1 (/ height 20.0)) 1)))))
     (shr-put-image spec alt flags)))
 
 ;;;###autoload

modules/app/rss/packages.el

@@ -1,5 +1,5 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; app/rss/packages.el
 
-(package! elfeed :pin "d0405e6386")
+(package! elfeed :pin "d0405e63863e54a01200740a6717ac875eceabc1")
-(package! elfeed-org :pin "77b6bbf222")
+(package! elfeed-org :pin "77b6bbf222487809813de260447d31c4c59902c9")

modules/app/twitter/packages.el

@@ -1,5 +1,5 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; app/twitter/packages.el
 
-(package! twittering-mode :pin "114891e8fd")
+(package! twittering-mode :pin "114891e8fdb4f06b1326a6cf795e49c205cf9e29")
-(package! avy :pin "3bf83140fa")
+(package! avy :pin "509471bad0e8094b8639729ec39ca141fae7d4bd")

modules/checkers/grammar/config.el

@@ -8,15 +8,16 @@
   :init (setq langtool-default-language "en-US")
   :config
   (unless (or langtool-bin
-              langtool-language-tool-jar)
+              langtool-language-tool-jar
-    (setq langtool-language-tool-jar
+              langtool-java-classpath)
-          (cond (IS-MAC
+    (cond (IS-MAC
+           (setq langtool-language-tool-jar
                  (locate-file "libexec/languagetool-commandline.jar"
                               (doom-files-in "/usr/local/Cellar/languagetool"
                                              :type 'dirs
-                                             :depth 2)))
+                                             :depth 2))))
-                (IS-LINUX
+          (IS-LINUX
-                 "/usr/share/java/languagetool/languagetool-commandline.jar")))))
+           (setq langtool-java-classpath "/usr/share/languagetool:/usr/share/java/languagetool/*")))))
 
 
 ;; Detects weasel words, passive voice and duplicates. Proselint would be a

modules/checkers/grammar/packages.el

@@ -1,5 +1,5 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; checkers/grammar/packages.el
 
-(package! langtool :pin "a71ed02ce0")
+(package! langtool :pin "a71ed02ce06920ae3cafd6708de1c21811ce14c3")
-(package! writegood-mode :pin "b71757ec33")
+(package! writegood-mode :pin "b71757ec337e226909fb0422f0224e31acc71733")

modules/checkers/spell/packages.el

@@ -1,11 +1,11 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; checkers/spell/packages.el
 
-(package! flyspell-correct :pin "e765d1a3d9")
+(package! flyspell-correct :pin "fd8ac7a4f922ce5ea1cc5d4583a7d584847cb6b5")
 (cond ((featurep! :completion ivy)
-       (package! flyspell-correct-ivy :pin "e765d1a3d9"))
+       (package! flyspell-correct-ivy))
       ((featurep! :completion helm)
-       (package! flyspell-correct-helm :pin "e765d1a3d9"))
+       (package! flyspell-correct-helm))
-      ((package! flyspell-correct-popup :pin "e765d1a3d9")))
+      ((package! flyspell-correct-popup)))
 
-(package! flyspell-lazy :pin "3ebf68cc9e")
+(package! flyspell-lazy :pin "3ebf68cc9eb10c972a2de8d7861cbabbbce69570")

modules/checkers/syntax/packages.el

@@ -1,9 +1,9 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; checkers/syntax/packages.el
 
-(package! flycheck :pin "f19a51c0f1")
+(package! flycheck :pin "246e1d4380721ca03962464f11d02dd1372860ce")
-(package! flycheck-popup-tip :pin "ef86aad907")
+(package! flycheck-popup-tip :pin "ef86aad907f27ca076859d8d9416f4f7727619c6")
 (when (featurep! +childframe)
-  (package! flycheck-posframe :pin "2b3e94c2e4"))
+  (package! flycheck-posframe :pin "2b3e94c2e427ec9831c513007460c5ea9e2225a3"))
 
 ;; TODO flymake?

modules/completion/company/config.el

@@ -11,9 +11,26 @@
         company-require-match 'never
         company-global-modes
         '(not erc-mode message-mode help-mode gud-mode)
-        company-backends  '(company-capf)
         company-frontends '(company-pseudo-tooltip-frontend
-                            company-echo-metadata-frontend))
+                            company-echo-metadata-frontend)
+
+        ;; Buffer-local backends will be computed when loading a major mode, so
+        ;; only specify a global default here.
+        company-backends  '(company-capf)
+
+        ;; Company overrides `company-active-map' based on
+        ;; `company-auto-complete-chars'; no magic please!
+        company-auto-complete-chars nil
+
+        ;; Only search the current buffer for `company-dabbrev' (a backend that
+        ;; suggests text your open buffers). This prevents Company from causing
+        ;; lag once you have a lot of buffers open.
+        company-dabbrev-other-buffers nil
+        ;; Make `company-dabbrev' fully case-sensitive, to improve UX with
+        ;; domain-specific words with particular casing.
+        company-dabbrev-ignore-case nil
+        company-dabbrev-downcase nil)
+
   :config
   (when (featurep! :editor evil)
     (add-hook 'company-mode-hook #'evil-normalize-keymaps)
@@ -106,6 +123,8 @@
             (ElispFeature  . ,(all-the-icons-material "stars"                    :face 'all-the-icons-orange))
             (ElispFace     . ,(all-the-icons-material "format_paint"             :face 'all-the-icons-pink)))))
 
+  (delq! 'company-echo-metadata-frontend company-frontends)
+
   (defun +company-box-icons--elisp-fn (candidate)
     (when (derived-mode-p 'emacs-lisp-mode)
       (let ((sym (intern candidate)))

modules/completion/company/packages.el

@@ -1,8 +1,8 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; completion/company/packages.el
 
-(package! company :pin "61ddd9afb5")
+(package! company :pin "6333fc4ebbbf4d28e834de8715561e984f149ecb")
-(package! company-dict :pin "cd7b8394f6")
+(package! company-dict :pin "cd7b8394f6014c57897f65d335d6b2bd65dab1f4")
-(package! company-prescient :pin "53307731f3")
+(package! company-prescient :pin "0f4a89bdec61395138d968a38d375e63ccfbed63")
 (when (featurep! +childframe)
-  (package! company-box :pin "8fc6168f2d"))
+  (package! company-box :pin "3814fcb14e92f4b85b19e664e216a7c8d5c7144d"))

modules/completion/helm/packages.el

@@ -1,19 +1,19 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; completion/helm/packages.el
 
-(package! helm :pin "d978f20f4c")
+(package! helm :pin "b6db9fb47a8900704394e63b795f4a54cb4701a8")
-(package! helm-rg :pin "785a80fe5c")
+(package! helm-rg :pin "785a80fe5cc87e27c5ea3d00a70049028d9e2847")
-(package! helm-c-yasnippet :pin "65ca732b51")
+(package! helm-c-yasnippet :pin "65ca732b510bfc31636708aebcfe4d2d845b59b0")
-(package! helm-company :pin "6eb5c2d730")
+(package! helm-company :pin "6eb5c2d730a60e394e005b47c1db018697094dde")
 (package! helm-describe-modes
   :recipe (:host github :repo "emacs-helm/helm-describe-modes")
-  :pin "11fb36af11")
+  :pin "11fb36af119b784539d31c6160002de1957408aa")
-(package! helm-projectile :pin "5328b74ddd")
+(package! helm-projectile :pin "5328b74dddcee8d1913803ca8167868831a07463")
-(package! swiper-helm :pin "93fb6db87b")
+(package! swiper-helm :pin "93fb6db87bc6a5967898b5fd3286954cc72a0008")
 (when (featurep! +fuzzy)
-  (package! helm-flx :pin "6640fac5cb"))
+  (package! helm-flx :pin "6640fac5cb16bee73c95b8ed1248a4e5e113690e"))
 (when (featurep! +childframe)
-  (package! posframe :pin "e62e584268"))
+  (package! posframe :pin "093b29a53cbeda6d637ccc9ef4dfc47123e79b9e"))
 (when (featurep! :lang org)
-  (package! helm-org :pin "b7a18dfc17"))
+  (package! helm-org :pin "b7a18dfc17e8b933956d61d68c435eee03a96c24"))
-(package! helm-descbinds :pin "b725159823")
+(package! helm-descbinds :pin "b72515982396b6e336ad7beb6767e95a80fca192")

modules/completion/ido/config.el

@@ -33,7 +33,7 @@
 
   (map! :map (ido-common-completion-map ido-file-completion-map)
         "C-w"  #'ido-delete-backward-word-updir
-        :map ido-common-completion-map
+        :map (ido-common-completion-map ido-file-dir-completion-map)
         "C-n"  #'ido-next-match
         "C-p"  #'ido-prev-match
         [down] #'ido-next-match

modules/completion/ido/packages.el

@@ -1,8 +1,8 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; completion/ido/packages.el
 
-(package! flx-ido :pin "17f5c9cb2a")
+(package! flx-ido :pin "17f5c9cb2af18aa6f52910ff4a5a63591261ced5")
-(package! ido-completing-read+ :pin "98d3a6e56b")
+(package! ido-completing-read+ :pin "98d3a6e56b1d3652da7b47f49f76d77f82ea80ba")
-(package! ido-sort-mtime :pin "f638ff0c92")
+(package! ido-sort-mtime :pin "f638ff0c922af862f5211779f2311a27fde428eb")
-(package! ido-vertical-mode :pin "16c4c1a112")
+(package! ido-vertical-mode :pin "16c4c1a112796ee0bcf401ea39d3e2643a89feaf")
-(package! crm-custom :pin "f1aaccf643")
+(package! crm-custom :pin "f1aaccf64306a5f99d9bf7ba815d7ea41c15518d")

modules/completion/ivy/config.el

@@ -129,7 +129,11 @@ evil-ex-specific constructs, so we disable it solely in evil-ex."
                  (ivy-rich-counsel-function-docstring (:face font-lock-doc-face))))
               ;; Apply switch buffer transformers to `counsel-projectile-switch-to-buffer' as well
               'counsel-projectile-switch-to-buffer
-              (plist-get ivy-rich-display-transformers-list 'ivy-switch-buffer))
+              (plist-get ivy-rich-display-transformers-list 'ivy-switch-buffer)
+              'counsel-bookmark
+              '(:columns
+                ((ivy-rich-candidate (:width 0.5))
+                 (ivy-rich-bookmark-filename (:width 60)))))
 
   ;; Remove built-in coloring of buffer list; we do our own
   (setq ivy-switch-buffer-faces-alist nil)
@@ -260,11 +264,14 @@ evil-ex-specific constructs, so we disable it solely in evil-ex."
     :override #'counsel--find-return-list
     (cl-destructuring-bind (find-program . args)
         (cond ((executable-find doom-projectile-fd-binary)
-               (cons doom-projectile-fd-binary (list "-t" "f" "-E" ".git")))
+               (cons doom-projectile-fd-binary
+                     (list "--color=never" "-E" ".git"
+                           "--type" "file" "--type" "symlink" "--follow")))
               ((executable-find "rg")
-               (append (list "rg" "--files" "--color=never" "--hidden" "--no-messages")
+               (append (list "rg" "--files" "--follow" "--color=never" "--hidden" "--no-messages")
                        (cl-loop for dir in projectile-globally-ignored-directories
-                                collect "--glob" and collect (concat "!" dir))
+                                collect "--glob"
+                                collect (concat "!" dir))
                        (if IS-WINDOWS (list "--path-separator" "/"))))
               ((cons find-program args)))
       (unless (listp args)

modules/completion/ivy/packages.el

@@ -1,23 +1,23 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; completion/ivy/packages.el
 
-(package! swiper :pin "64f05f4735")
+(package! swiper :pin "9e0803cdb5b47e4e1844e8281516b46589ef26c7")
 (package! ivy)
 (package! ivy-hydra)
 (package! counsel)
 
-(package! amx :pin "e512e74e83")
+(package! amx :pin "7fb7b874291e0cdeb1f0acb18564a686ec86788d")
-(package! counsel-projectile :pin "b556ed8995")
+(package! counsel-projectile :pin "b556ed8995f375e57496f3482aef4b0def565de8")
-(package! ivy-rich :pin "596874d146")
+(package! ivy-rich :pin "3f818b201769bc13cc75aa73645217e374136aca")
-(package! wgrep :pin "5977b8e000")
+(package! wgrep :pin "5977b8e00051c9003ca96e9d35133e0dea68db2c")
 
 (if (featurep! +prescient)
-    (package! ivy-prescient :pin "53307731f3")
+    (package! ivy-prescient :pin "0f4a89bdec61395138d968a38d375e63ccfbed63")
   (when (featurep! +fuzzy)
-    (package! flx :pin "17f5c9cb2a")))
+    (package! flx :pin "17f5c9cb2af18aa6f52910ff4a5a63591261ced5")))
 
 (when (featurep! +childframe)
-  (package! ivy-posframe :pin "ae9bafe94f"))
+  (package! ivy-posframe :pin "ae9bafe94fe6b77b6fe45766ae6172646f6a5d50"))
 
 (when (featurep! +icons)
-  (package! all-the-icons-ivy :pin "a70cbfa1ef"))
+  (package! all-the-icons-ivy :pin "a70cbfa1effe36efc946a823a580cec686d5e88d"))

modules/config/default/+emacs-bindings.el

@@ -27,362 +27,363 @@
 
       ;;; <leader> c --- code
       (:prefix-map ("c" . "code")
-        :desc "Compile"                               "c"   #'compile
+       :desc "Compile"                               "c"   #'compile
-        :desc "Recompile"                             "C"   #'recompile
+       :desc "Recompile"                             "C"   #'recompile
-        :desc "Jump to definition"                    "d"   #'+lookup/definition
+       :desc "Jump to definition"                    "d"   #'+lookup/definition
-        :desc "Jump to references"                    "D"   #'+lookup/references
+       :desc "Jump to references"                    "D"   #'+lookup/references
-        :desc "Evaluate buffer/region"                "e"   #'+eval/buffer-or-region
+       :desc "Evaluate buffer/region"                "e"   #'+eval/buffer-or-region
-        :desc "Evaluate & replace region"             "E"   #'+eval/region-and-replace
+       :desc "Evaluate & replace region"             "E"   #'+eval/region-and-replace
-        :desc "Format buffer/region"                  "f"   #'+format/region-or-buffer
+       :desc "Format buffer/region"                  "f"   #'+format/region-or-buffer
-        :desc "Jump to documentation"                 "k"   #'+lookup/documentation
+       :desc "Jump to documentation"                 "k"   #'+lookup/documentation
-        :desc "Send to repl"                          "s"   #'+eval/send-region-to-repl
+       :desc "Send to repl"                          "s"   #'+eval/send-region-to-repl
-        :desc "Delete trailing whitespace"            "w"   #'delete-trailing-whitespace
+       :desc "Delete trailing whitespace"            "w"   #'delete-trailing-whitespace
-        :desc "Delete trailing newlines"              "W"   #'doom/delete-trailing-newlines
+       :desc "Delete trailing newlines"              "W"   #'doom/delete-trailing-newlines
-        :desc "List errors"                           "x"   #'flymake-show-diagnostics-buffer
+       :desc "List errors"                           "x"   #'flymake-show-diagnostics-buffer
-        (:when (featurep! :tools flycheck)
+       (:when (featurep! :checkers syntax)
-          :desc "List errors"                         "x"   #'flycheck-list-errors)
+        :desc "List errors"                         "x"   #'flycheck-list-errors)
-        (:when (featurep! :tools lsp)
+       (:when (featurep! :tools lsp)
         :desc "LSP Code actions"                      "a"   #'lsp-execute-code-action
-        :desc "LSP Format buffer/region"              "F"   #'+default/lsp-format-region-or-buffer
         :desc "LSP Organize imports"                  "i"   #'lsp-organize-imports
         :desc "LSP Rename"                            "r"   #'lsp-rename
+        (:after lsp-mode
+         :desc "LSP"                                   "l"   lsp-command-map)
         (:when (featurep! :completion ivy)
-          :desc "Jump to symbol in current workspace" "j"   #'lsp-ivy-workspace-symbol
+         :desc "Jump to symbol in current workspace" "j"   #'lsp-ivy-workspace-symbol
-          :desc "Jump to symbol in any workspace"     "J"   #'lsp-ivy-global-workspace-symbol)
+         :desc "Jump to symbol in any workspace"     "J"   #'lsp-ivy-global-workspace-symbol)
         (:when (featurep! :completion helm)
-          :desc "Jump to symbol in current workspace" "j"   #'helm-lsp-workspace-symbol
+         :desc "Jump to symbol in current workspace" "j"   #'helm-lsp-workspace-symbol
-          :desc "Jump to symbol in any workspace"     "J"   #'helm-lsp-global-workspace-symbol)))
+         :desc "Jump to symbol in any workspace"     "J"   #'helm-lsp-global-workspace-symbol)))
 
       ;;; <leader> f --- file
       (:prefix-map ("f" . "file")
-        :desc "Copy this file"              "C"   #'doom/copy-this-file
+       :desc "Copy this file"              "C"   #'doom/copy-this-file
-        :desc "Find file in private config" "C"   #'doom/find-file-in-private-config
+       :desc "Find file in private config" "C"   #'doom/find-file-in-private-config
-        :desc "Delete this file"            "D"   #'doom/delete-this-file
+       :desc "Delete this file"            "D"   #'doom/delete-this-file
-        :desc "Find file in emacs.d"        "e"   #'+default/find-in-emacsd
+       :desc "Find file in emacs.d"        "e"   #'+default/find-in-emacsd
-        :desc "Browse emacs.d"              "E"   #'+default/browse-emacsd
+       :desc "Browse emacs.d"              "E"   #'+default/browse-emacsd
-        :desc "Find file from here"         "f"   #'+default/find-file-under-here
+       :desc "Find file from here"         "f"   #'+default/find-file-under-here
-        :desc "Rename/move this file"       "m"   #'doom/move-this-file
+       :desc "Rename/move this file"       "m"   #'doom/move-this-file
-        :desc "Browse private config"       "p"   #'doom/open-private-config
+       :desc "Browse private config"       "p"   #'doom/open-private-config
-        :desc "Browse private config"       "P"   #'doom/open-private-config
+       :desc "Browse private config"       "P"   #'doom/open-private-config
-        :desc "Recent files"                "r"   #'recentf-open-files
+       :desc "Recent files"                "r"   #'recentf-open-files
-        :desc "Recent project files"        "R"   #'projectile-recentf
+       :desc "Recent project files"        "R"   #'projectile-recentf
-        :desc "Sudo this file"              "s"   #'doom/sudo-this-file
+       :desc "Sudo this file"              "s"   #'doom/sudo-this-file
-        :desc "Sudo find file"              "S"   #'doom/sudo-find-file
+       :desc "Sudo find file"              "S"   #'doom/sudo-find-file
-        :desc "Yank filename"               "y"   #'+default/yank-buffer-filename
+       :desc "Yank filename"               "y"   #'+default/yank-buffer-filename
-        :desc "Open scratch buffer"         "x"   #'doom/open-scratch-buffer
+       :desc "Open scratch buffer"         "x"   #'doom/open-scratch-buffer
-        :desc "Switch to scratch buffer"    "X"   #'doom/switch-to-scratch-buffer
+       :desc "Switch to scratch buffer"    "X"   #'doom/switch-to-scratch-buffer
-        (:when (featurep! :tools editorconfig)
+       (:when (featurep! :tools editorconfig)
-          :desc "Open project editorconfig"   "."   #'editorconfig-find-current-editorconfig))
+        :desc "Open project editorconfig"   "."   #'editorconfig-find-current-editorconfig))
 
       ;;; <leader> r --- remote
       (:when (featurep! :tools upload)
-        (:prefix-map ("r" . "remote")
+       (:prefix-map ("r" . "remote")
-          :desc "Upload local"               "u" #'ssh-deploy-upload-handler
+        :desc "Upload local"               "u" #'ssh-deploy-upload-handler
-          :desc "Upload local (force)"       "U" #'ssh-deploy-upload-handler-forced
+        :desc "Upload local (force)"       "U" #'ssh-deploy-upload-handler-forced
-          :desc "Download remote"            "d" #'ssh-deploy-download-handler
+        :desc "Download remote"            "d" #'ssh-deploy-download-handler
-          :desc "Diff local & remote"        "D" #'ssh-deploy-diff-handler
+        :desc "Diff local & remote"        "D" #'ssh-deploy-diff-handler
-          :desc "Browse remote files"        "." #'ssh-deploy-browse-remote-handler
+        :desc "Browse remote files"        "." #'ssh-deploy-browse-remote-handler
-          :desc "Detect remote changes"      ">" #'ssh-deploy-remote-changes-handler))
+        :desc "Detect remote changes"      ">" #'ssh-deploy-remote-changes-handler))
 
       ;;; <leader> s --- search
       (:prefix-map ("s" . "search")
-        :desc "Search project for symbol"    "." #'+default/search-project-for-symbol-at-point
+       :desc "Search project for symbol"    "." #'+default/search-project-for-symbol-at-point
-        :desc "Search buffer"                "b" #'swiper
+       :desc "Search buffer"                "b" #'swiper
-        :desc "Search current directory"     "d" #'+default/search-cwd
+       :desc "Search current directory"     "d" #'+default/search-cwd
-        :desc "Search other directory"       "D" #'+default/search-other-cwd
+       :desc "Search other directory"       "D" #'+default/search-other-cwd
-        :desc "Locate file"                  "f" #'locate
+       :desc "Locate file"                  "f" #'locate
-        :desc "Jump to symbol"               "i" #'imenu
+       :desc "Jump to symbol"               "i" #'imenu
-        :desc "Jump to visible link"         "l" #'link-hint-open-link
+       :desc "Jump to visible link"         "l" #'link-hint-open-link
-        :desc "Jump to link"                 "L" #'ffap-menu
+       :desc "Jump to link"                 "L" #'ffap-menu
-        :desc "Jump list"                    "j" #'evil-show-jumps
+       :desc "Jump list"                    "j" #'evil-show-jumps
-        :desc "Jump to mark"                 "m" #'evil-show-marks
+       :desc "Jump to mark"                 "m" #'evil-show-marks
-        :desc "Search project"               "p" #'+default/search-project
+       :desc "Search project"               "p" #'+default/search-project
-        :desc "Search other project"         "P" #'+default/search-other-project
+       :desc "Search other project"         "P" #'+default/search-other-project
-        :desc "Search buffer"                "s" #'swiper-isearch
+       :desc "Search buffer"                "s" #'swiper-isearch
-        :desc "Search buffer for thing at point" "S" #'swiper-isearch-thing-at-point)
+       :desc "Search buffer for thing at point" "S" #'swiper-isearch-thing-at-point)
 
       ;;; <leader> g --- lookup
       (:when (featurep! :tools lookup)
-        (:prefix-map ("g" . "lookup")
+       (:prefix-map ("g" . "lookup")
-          "k" #'+lookup/documentation
+        "k" #'+lookup/documentation
-          "d" #'+lookup/definition
+        "d" #'+lookup/definition
-          "D" #'+lookup/references
+        "D" #'+lookup/references
-          "f" #'+lookup/file
+        "f" #'+lookup/file
-          "o" #'+lookup/online-select
+        "o" #'+lookup/online-select
-          "i" #'+lookup/in-docsets
+        "i" #'+lookup/in-docsets
-          "I" #'+lookup/in-all-docsets))
+        "I" #'+lookup/in-all-docsets))
 
       ;;; <leader> i --- insert
       (:prefix-map ("i" . "insert")
-        :desc "Current file name"             "f"   #'+default/insert-file-path
+       :desc "Current file name"             "f"   #'+default/insert-file-path
-        :desc "Current file path"             "F"   (λ!! #'+default/insert-file-path t)
+       :desc "Current file path"             "F"   (λ!! #'+default/insert-file-path t)
-        :desc "Snippet"                       "s"   #'yas-insert-snippet
+       :desc "Snippet"                       "s"   #'yas-insert-snippet
-        :desc "Unicode"                       "u"   #'unicode-chars-list-chars
+       :desc "Unicode"                       "u"   #'unicode-chars-list-chars
-        :desc "From clipboard"                "y"   #'+default/yank-pop)
+       :desc "From clipboard"                "y"   #'+default/yank-pop)
 
       ;;; <leader> n --- notes
       (:prefix-map ("n" . "notes")
-        :desc "Search notes for symbol"        "." #'+default/search-notes-for-symbol-at-point
+       :desc "Search notes for symbol"        "." #'+default/search-notes-for-symbol-at-point
-        :desc "Org agenda"                     "a" #'org-agenda
+       :desc "Org agenda"                     "a" #'org-agenda
-        (:when (featurep! :tools biblio)
+       (:when (featurep! :tools biblio)
-          :desc "Bibliographic entries"        "b"
+        :desc "Bibliographic entries"        "b"
-          (cond ((featurep! :completion ivy)   #'ivy-bibtex)
+        (cond ((featurep! :completion ivy)   #'ivy-bibtex)
-                ((featurep! :completion helm)  #'helm-bibtex)))
+              ((featurep! :completion helm)  #'helm-bibtex)))
 
-        :desc "Toggle org-clock"               "c" #'+org/toggle-clock
+       :desc "Toggle org-clock"               "c" #'+org/toggle-clock
-        :desc "Cancel org-clock"               "C" #'org-clock-cancel
+       :desc "Cancel org-clock"               "C" #'org-clock-cancel
-        :desc "Open deft"                      "d" #'deft
+       :desc "Open deft"                      "d" #'deft
-        (:when (featurep! :lang org +noter)
+       (:when (featurep! :lang org +noter)
-          :desc "Org noter"                    "e" #'org-noter)
+        :desc "Org noter"                    "e" #'org-noter)
-      
+
-        :desc "Find file in notes"             "f" #'+default/find-in-notes
+       :desc "Find file in notes"             "f" #'+default/find-in-notes
-        :desc "Browse notes"                   "F" #'+default/browse-notes
+       :desc "Browse notes"                   "F" #'+default/browse-notes
-        :desc "Org store link"                 "l" #'org-store-link
+       :desc "Org store link"                 "l" #'org-store-link
-        :desc "Tags search"                    "m" #'org-tags-view
+       :desc "Tags search"                    "m" #'org-tags-view
-        :desc "Org capture"                    "n" #'org-capture
+       :desc "Org capture"                    "n" #'org-capture
-        :desc "Goto capture"                   "N" #'org-capture-goto-target
+       :desc "Goto capture"                   "N" #'org-capture-goto-target
-        :desc "Active org-clock"               "o" #'org-clock-goto
+       :desc "Active org-clock"               "o" #'org-clock-goto
-        :desc "Todo list"                      "t" #'org-todo-list
+       :desc "Todo list"                      "t" #'org-todo-list
-        :desc "Search notes"                   "s" #'+default/org-notes-search
+       :desc "Search notes"                   "s" #'+default/org-notes-search
-        :desc "Search org agenda headlines"    "S" #'+default/org-notes-headlines
+       :desc "Search org agenda headlines"    "S" #'+default/org-notes-headlines
-        :desc "View search"                    "v" #'org-search-view
+       :desc "View search"                    "v" #'org-search-view
-        :desc "Org export to clipboard"        "y" #'+org/export-to-clipboard
+       :desc "Org export to clipboard"        "y" #'+org/export-to-clipboard
-        :desc "Org export to clipboard as RTF" "Y" #'+org/export-to-clipboard-as-rich-text
+       :desc "Org export to clipboard as RTF" "Y" #'+org/export-to-clipboard-as-rich-text
-        (:when (featurep! :lang org +journal)
+       (:when (featurep! :lang org +journal)
-          (:prefix ("j" . "journal")
+        (:prefix ("j" . "journal")
-            :desc "New Entry"      "j" #'org-journal-new-entry
+         :desc "New Entry"      "j" #'org-journal-new-entry
-            :desc "Search Forever" "s" #'org-journal-search-forever))
+         :desc "Search Forever" "s" #'org-journal-search-forever))
-        (:when (featurep! :lang org +roam)
+       (:when (featurep! :lang org +roam)
-          (:prefix ("r" . "roam")
+        (:prefix ("r" . "roam")
-            :desc "Switch to buffer" "b" #'org-roam-switch-to-buffer
+         :desc "Switch to buffer" "b" #'org-roam-switch-to-buffer
-            :desc "Org Roam Capture" "c" #'org-roam-capture
+         :desc "Org Roam Capture" "c" #'org-roam-capture
-            :desc "Find file"        "f" #'org-roam-find-file
+         :desc "Find file"        "f" #'org-roam-find-file
-            :desc "Show graph"       "g" #'org-roam-graph
+         :desc "Show graph"       "g" #'org-roam-graph
-            :desc "Insert"           "i" #'org-roam-insert
+         :desc "Insert"           "i" #'org-roam-insert
-            :desc "Org Roam"         "r" #'org-roam
+         :desc "Org Roam"         "r" #'org-roam
-            (:prefix ("d" . "by date")
+         (:prefix ("d" . "by date")
-              :desc "Arbitrary date" "d" #'org-roam-dailies-date
+          :desc "Arbitrary date" "d" #'org-roam-dailies-date
-              :desc "Today"          "t" #'org-roam-dailies-today
+          :desc "Today"          "t" #'org-roam-dailies-today
-              :desc "Tomorrow"       "m" #'org-roam-dailies-tomorrow
+          :desc "Tomorrow"       "m" #'org-roam-dailies-tomorrow
-              :desc "Yesterday"      "y" #'org-roam-dailies-yesterday))))
+          :desc "Yesterday"      "y" #'org-roam-dailies-yesterday))))
 
       ;;; <leader> o --- open
       "o" nil ; we need to unbind it first as Org claims this prefix
       (:prefix-map ("o" . "open")
-        :desc "Browser"            "b"  #'browse-url-of-file
+       :desc "Browser"            "b"  #'browse-url-of-file
-        :desc "Debugger"           "d"  #'+debugger/start
+       :desc "Debugger"           "d"  #'+debugger/start
-        :desc "New frame"          "f"  #'make-frame
+       :desc "New frame"          "f"  #'make-frame
-        :desc "REPL"               "r"  #'+eval/open-repl-other-window
+       :desc "REPL"               "r"  #'+eval/open-repl-other-window
-        :desc "REPL (same window)" "R"  #'+eval/open-repl-same-window
+       :desc "REPL (same window)" "R"  #'+eval/open-repl-same-window
-        :desc "Dired"              "-"  #'dired-jump
+       :desc "Dired"              "-"  #'dired-jump
-        (:when (featurep! :ui neotree)
+       (:when (featurep! :ui neotree)
-          :desc "Project sidebar"               "p" #'+neotree/open
+        :desc "Project sidebar"               "p" #'+neotree/open
-          :desc "Find file in project sidebar"  "P" #'+neotree/find-this-file)
+        :desc "Find file in project sidebar"  "P" #'+neotree/find-this-file)
-        (:when (featurep! :ui treemacs)
+       (:when (featurep! :ui treemacs)
-          :desc "Project sidebar"               "p" #'+treemacs/toggle
+        :desc "Project sidebar"               "p" #'+treemacs/toggle
-          :desc "Find file in project rsidebar" "P" #'+treemacs/find-file)
+        :desc "Find file in project rsidebar" "P" #'treemacs-find-file)
-        (:when (featurep! :term shell)
+       (:when (featurep! :term shell)
-          :desc "Toggle shell popup"            "t" #'+shell/toggle
+        :desc "Toggle shell popup"            "t" #'+shell/toggle
-          :desc "Open shell here"               "T" #'+shell/here)
+        :desc "Open shell here"               "T" #'+shell/here)
-        (:when (featurep! :term term)
+       (:when (featurep! :term term)
-          :desc "Toggle terminal popup"         "t" #'+term/toggle
+        :desc "Toggle terminal popup"         "t" #'+term/toggle
-          :desc "Open terminal here"            "T" #'+term/here)
+        :desc "Open terminal here"            "T" #'+term/here)
-        (:when (featurep! :term vterm)
+       (:when (featurep! :term vterm)
-          :desc "Toggle vterm popup"            "t" #'+vterm/toggle
+        :desc "Toggle vterm popup"            "t" #'+vterm/toggle
-          :desc "Open vterm here"               "T" #'+vterm/here)
+        :desc "Open vterm here"               "T" #'+vterm/here)
-        (:when (featurep! :term eshell)
+       (:when (featurep! :term eshell)
-          :desc "Toggle eshell popup"           "e" #'+eshell/toggle
+        :desc "Toggle eshell popup"           "e" #'+eshell/toggle
-          :desc "Open eshell here"              "E" #'+eshell/here)
+        :desc "Open eshell here"              "E" #'+eshell/here)
-        (:when (featurep! :tools macos)
+       (:when (featurep! :tools macos)
-          :desc "Reveal in Finder"           "o" #'+macos/reveal-in-finder
+        :desc "Reveal in Finder"           "o" #'+macos/reveal-in-finder
-          :desc "Reveal project in Finder"   "O" #'+macos/reveal-project-in-finder
+        :desc "Reveal project in Finder"   "O" #'+macos/reveal-project-in-finder
-          :desc "Send to Transmit"           "u" #'+macos/send-to-transmit
+        :desc "Send to Transmit"           "u" #'+macos/send-to-transmit
-          :desc "Send project to Transmit"   "U" #'+macos/send-project-to-transmit
+        :desc "Send project to Transmit"   "U" #'+macos/send-project-to-transmit
-          :desc "Send to Launchbar"          "l" #'+macos/send-to-launchbar
+        :desc "Send to Launchbar"          "l" #'+macos/send-to-launchbar
-          :desc "Send project to Launchbar"  "L" #'+macos/send-project-to-launchbar)
+        :desc "Send project to Launchbar"  "L" #'+macos/send-project-to-launchbar)
-        (:when (featurep! :tools docker)
+       (:when (featurep! :tools docker)
-          :desc "Docker" "D" #'docker))
+        :desc "Docker" "D" #'docker))
 
       ;;; <leader> p --- project
       (:prefix ("p" . "project")
-        :desc "Search project for symbol"   "." #'+default/search-project-for-symbol-at-point
+       :desc "Search project for symbol"   "." #'+default/search-project-for-symbol-at-point
-        :desc "Find file in other project"  "F" #'doom/find-file-in-other-project
+       :desc "Find file in other project"  "F" #'doom/find-file-in-other-project
-        :desc "Search project"              "s" #'+default/search-project
+       :desc "Search project"              "s" #'+default/search-project
-        :desc "List project tasks"          "t" #'magit-todos-list
+       :desc "List project tasks"          "t" #'magit-todos-list
-        :desc "Open project scratch buffer" "x" #'doom/open-project-scratch-buffer
+       :desc "Open project scratch buffer" "x" #'doom/open-project-scratch-buffer
-        :desc "Switch to project scratch buffer" "X" #'doom/switch-to-project-scratch-buffer
+       :desc "Switch to project scratch buffer" "X" #'doom/switch-to-project-scratch-buffer
-        ;; later expanded by projectile
+       ;; later expanded by projectile
-        (:prefix ("4" . "in other window"))
+       (:prefix ("4" . "in other window"))
-        (:prefix ("5" . "in other frame")))
+       (:prefix ("5" . "in other frame")))
 
       ;;; <leader> q --- quit/restart
       (:prefix-map ("q" . "quit/restart")
-        :desc "Restart emacs server"         "d" #'+default/restart-server
+       :desc "Restart emacs server"         "d" #'+default/restart-server
-        :desc "Delete frame"                 "f" #'delete-frame
+       :desc "Delete frame"                 "f" #'delete-frame
-        :desc "Clear current frame"          "F" #'doom/kill-all-buffers
+       :desc "Clear current frame"          "F" #'doom/kill-all-buffers
-        :desc "Kill Emacs (and daemon)"      "K" #'save-buffers-kill-emacs
+       :desc "Kill Emacs (and daemon)"      "K" #'save-buffers-kill-emacs
-        :desc "Quit Emacs"                   "q" #'kill-emacs
+       :desc "Quit Emacs"                   "q" #'kill-emacs
-        :desc "Save and quit Emacs"          "Q" #'save-buffers-kill-terminal
+       :desc "Save and quit Emacs"          "Q" #'save-buffers-kill-terminal
-        :desc "Quick save current session"   "s" #'doom/quicksave-session
+       :desc "Quick save current session"   "s" #'doom/quicksave-session
-        :desc "Restore last session"         "l" #'doom/quickload-session
+       :desc "Restore last session"         "l" #'doom/quickload-session
-        :desc "Save session to file"         "S" #'doom/save-session
+       :desc "Save session to file"         "S" #'doom/save-session
-        :desc "Restore session from file"    "L" #'doom/load-session
+       :desc "Restore session from file"    "L" #'doom/load-session
-        :desc "Restart & restore Emacs"      "r" #'doom/restart-and-restore
+       :desc "Restart & restore Emacs"      "r" #'doom/restart-and-restore
-        :desc "Restart Emacs"                "R" #'doom/restart)
+       :desc "Restart Emacs"                "R" #'doom/restart)
 
       ;;; <leader> & --- snippets
       (:prefix-map ("&" . "snippets")
-        :desc "New snippet"           "n" #'yas-new-snippet
+       :desc "New snippet"           "n" #'yas-new-snippet
-        :desc "Insert snippet"        "i" #'yas-insert-snippet
+       :desc "Insert snippet"        "i" #'yas-insert-snippet
-        :desc "Find global snippet"   "/" #'yas-visit-snippet-file
+       :desc "Find global snippet"   "/" #'yas-visit-snippet-file
-        :desc "Reload snippets"       "r" #'yas-reload-all
+       :desc "Reload snippets"       "r" #'yas-reload-all
-        :desc "Create Temp Template"  "c" #'aya-create
+       :desc "Create Temp Template"  "c" #'aya-create
-        :desc "Use Temp Template"     "e" #'aya-expand)
+       :desc "Use Temp Template"     "e" #'aya-expand)
 
       ;;; <leader> t --- toggle
       (:prefix-map ("t" . "toggle")
-        :desc "Big mode"                     "b" #'doom-big-font-mode
+       :desc "Big mode"                     "b" #'doom-big-font-mode
-        :desc "Flymake"                      "f" #'flymake-mode
+       :desc "Flymake"                      "f" #'flymake-mode
-        :desc "Frame fullscreen"             "F" #'toggle-frame-fullscreen
+       :desc "Frame fullscreen"             "F" #'toggle-frame-fullscreen
-        :desc "Indent style"                 "I" #'doom/toggle-indent-style
+       :desc "Indent style"                 "I" #'doom/toggle-indent-style
-        :desc "Line numbers"                 "l" #'doom/toggle-line-numbers
+       :desc "Line numbers"                 "l" #'doom/toggle-line-numbers
-        :desc "Word-wrap mode"               "w" #'+word-wrap-mode
+       :desc "Word-wrap mode"               "w" #'+word-wrap-mode
-        (:when (featurep! :tools flycheck)
+       (:when (featurep! :checkers syntax)
-          :desc "Flycheck"                   "f" #'flycheck-mode)
+        :desc "Flycheck"                   "f" #'flycheck-mode)
-        (:when (featurep! :ui indent-guides)
+       (:when (featurep! :ui indent-guides)
-          :desc "Indent guides"              "i" #'highlight-indent-guides-mode)
+        :desc "Indent guides"              "i" #'highlight-indent-guides-mode)
-        (:when (featurep! :lang org +present)
+       (:when (featurep! :lang org +present)
-          :desc "org-tree-slide mode"        "p" #'+org-present/start)
+        :desc "org-tree-slide mode"        "p" #'+org-present/start)
-        :desc "Read-only mode"               "r" #'read-only-mode
+       :desc "Read-only mode"               "r" #'read-only-mode
-        (:when (featurep! :tools flyspell)
+       (:when (featurep! :checkers spell)
-          :desc "Flyspell"                   "s" #'flyspell-mode)
+        :desc "Flyspell"                   "s" #'flyspell-mode)
-        (:when (featurep! :lang org +pomodoro)
+       (:when (featurep! :lang org +pomodoro)
-          :desc "Pomodoro timer"             "t" #'org-pomodoro)
+        :desc "Pomodoro timer"             "t" #'org-pomodoro)
-        (:when (featurep! :ui zen)
+       (:when (featurep! :ui zen)
-          :desc "Zen mode"                   "z" #'writeroom-mode))
+        :desc "Zen mode"                   "z" #'writeroom-mode))
 
       ;;; <leader> v --- versioning
       (:prefix-map ("v" . "versioning")
-        :desc "Git revert file"             "R"   #'vc-revert
+       :desc "Git revert file"             "R"   #'vc-revert
-        :desc "Kill link to remote"         "y"   #'browse-at-remote-kill
+       :desc "Kill link to remote"         "y"   #'browse-at-remote-kill
-        :desc "Kill link to homepage"       "Y"   #'+vc/browse-at-remote-kill-homepage
+       :desc "Kill link to homepage"       "Y"   #'+vc/browse-at-remote-kill-homepage
-        (:when (featurep! :ui vc-gutter)
+       (:when (featurep! :ui vc-gutter)
-          :desc "Git revert hunk"           "r"   #'git-gutter:revert-hunk
+        :desc "Git revert hunk"           "r"   #'git-gutter:revert-hunk
-          :desc "Git stage hunk"            "s"   #'git-gutter:stage-hunk
+        :desc "Git stage hunk"            "s"   #'git-gutter:stage-hunk
-          :desc "Git time machine"          "t"   #'git-timemachine-toggle
+        :desc "Git time machine"          "t"   #'git-timemachine-toggle
-          :desc "Jump to next hunk"         "n"   #'git-gutter:next-hunk
+        :desc "Jump to next hunk"         "n"   #'git-gutter:next-hunk
-          :desc "Jump to previous hunk"     "p"   #'git-gutter:previous-hunk)
+        :desc "Jump to previous hunk"     "p"   #'git-gutter:previous-hunk)
-        (:when (featurep! :tools magit)
+       (:when (featurep! :tools magit)
-          :desc "Magit dispatch"            "/"   #'magit-dispatch
+        :desc "Magit dispatch"            "/"   #'magit-dispatch
-          :desc "Forge dispatch"            "'"   #'forge-dispatch
+        :desc "Forge dispatch"            "'"   #'forge-dispatch
-          :desc "Magit status"              "g"   #'magit-status
+        :desc "Magit status"              "g"   #'magit-status
-          :desc "Magit file delete"         "x"   #'magit-file-delete
+        :desc "Magit file delete"         "x"   #'magit-file-delete
-          :desc "Magit blame"               "B"   #'magit-blame-addition
+        :desc "Magit blame"               "B"   #'magit-blame-addition
-          :desc "Magit clone"               "C"   #'magit-clone
+        :desc "Magit clone"               "C"   #'magit-clone
-          :desc "Magit fetch"               "F"   #'magit-fetch
+        :desc "Magit fetch"               "F"   #'magit-fetch
-          :desc "Magit buffer log"          "L"   #'magit-log
+        :desc "Magit buffer log"          "L"   #'magit-log
-          :desc "Git stage file"            "S"   #'magit-stage-file
+        :desc "Git stage file"            "S"   #'magit-stage-file
-          :desc "Git unstage file"          "U"   #'magit-unstage-file
+        :desc "Git unstage file"          "U"   #'magit-unstage-file
-          (:prefix ("f" . "find")
+        (:prefix ("f" . "find")
-            :desc "Find file"                 "f"   #'magit-find-file
+         :desc "Find file"                 "f"   #'magit-find-file
-            :desc "Find gitconfig file"       "g"   #'magit-find-git-config-file
+         :desc "Find gitconfig file"       "g"   #'magit-find-git-config-file
-            :desc "Find commit"               "c"   #'magit-show-commit
+         :desc "Find commit"               "c"   #'magit-show-commit
-            :desc "Find issue"                "i"   #'forge-visit-issue
+         :desc "Find issue"                "i"   #'forge-visit-issue
-            :desc "Find pull request"         "p"   #'forge-visit-pullreq)
+         :desc "Find pull request"         "p"   #'forge-visit-pullreq)
-          (:prefix ("o" . "open in browser")
+        (:prefix ("o" . "open in browser")
-            :desc "Browse file or region"     "."   #'browse-at-remote
+         :desc "Browse file or region"     "."   #'browse-at-remote
-            :desc "Browse homepage"           "h"   #'+vc/browse-at-remote-homepage
+         :desc "Browse homepage"           "h"   #'+vc/browse-at-remote-homepage
-            :desc "Browse remote"             "r"   #'forge-browse-remote
+         :desc "Browse remote"             "r"   #'forge-browse-remote
-            :desc "Browse commit"             "c"   #'forge-browse-commit
+         :desc "Browse commit"             "c"   #'forge-browse-commit
-            :desc "Browse an issue"           "i"   #'forge-browse-issue
+         :desc "Browse an issue"           "i"   #'forge-browse-issue
-            :desc "Browse a pull request"     "p"   #'forge-browse-pullreq
+         :desc "Browse a pull request"     "p"   #'forge-browse-pullreq
-            :desc "Browse issues"             "I"   #'forge-browse-issues
+         :desc "Browse issues"             "I"   #'forge-browse-issues
-            :desc "Browse pull requests"      "P"   #'forge-browse-pullreqs)
+         :desc "Browse pull requests"      "P"   #'forge-browse-pullreqs)
-          (:prefix ("l" . "list")
+        (:prefix ("l" . "list")
-            (:when (featurep! :tools gist)
+         (:when (featurep! :tools gist)
-              :desc "List gists"              "g"   #'+gist:list)
+          :desc "List gists"              "g"   #'+gist:list)
-            :desc "List repositories"         "r"   #'magit-list-repositories
+         :desc "List repositories"         "r"   #'magit-list-repositories
-            :desc "List submodules"           "s"   #'magit-list-submodules
+         :desc "List submodules"           "s"   #'magit-list-submodules
-            :desc "List issues"               "i"   #'forge-list-issues
+         :desc "List issues"               "i"   #'forge-list-issues
-            :desc "List pull requests"        "p"   #'forge-list-pullreqs
+         :desc "List pull requests"        "p"   #'forge-list-pullreqs
-            :desc "List notifications"        "n"   #'forge-list-notifications)
+         :desc "List notifications"        "n"   #'forge-list-notifications)
-          (:prefix ("c" . "create")
+        (:prefix ("c" . "create")
-            :desc "Initialize repo"           "r"   #'magit-init
+         :desc "Initialize repo"           "r"   #'magit-init
-            :desc "Clone repo"                "R"   #'magit-clone
+         :desc "Clone repo"                "R"   #'magit-clone
-            :desc "Commit"                    "c"   #'magit-commit-create
+         :desc "Commit"                    "c"   #'magit-commit-create
-            :desc "Fixup"                     "f"   #'magit-commit-fixup
+         :desc "Fixup"                     "f"   #'magit-commit-fixup
-            :desc "Issue"                     "i"   #'forge-create-issue
+         :desc "Issue"                     "i"   #'forge-create-issue
-            :desc "Pull request"              "p"   #'forge-create-pullreq)))
+         :desc "Pull request"              "p"   #'forge-create-pullreq)))
 
       ;;; <leader> w --- workspaces/windows
       (:prefix-map ("w" . "workspaces/windows")
-        :desc "Autosave session"             "a" #'doom/quicksave-session
+       :desc "Autosave session"             "a" #'doom/quicksave-session
-        :desc "Display workspaces"           "d" #'+workspace/display
+       :desc "Display workspaces"           "d" #'+workspace/display
-        :desc "Rename workspace"             "r" #'+workspace/rename
+       :desc "Rename workspace"             "r" #'+workspace/rename
-        :desc "Create workspace"             "c" #'+workspace/new
+       :desc "Create workspace"             "c" #'+workspace/new
-        :desc "Delete workspace"             "k" #'+workspace/delete
+       :desc "Delete workspace"             "k" #'+workspace/delete
-        :desc "Save session"                 "s" #'doom/save-session
+       :desc "Save session"                 "s" #'doom/save-session
-        :desc "Save workspace"               "S" #'+workspace/save
+       :desc "Save workspace"               "S" #'+workspace/save
-        :desc "Load session"                 "l" #'doom/load-session
+       :desc "Load session"                 "l" #'doom/load-session
-        :desc "Load last autosaved session"  "L" #'doom/quickload-session
+       :desc "Load last autosaved session"  "L" #'doom/quickload-session
-        :desc "Switch to other workspace"    "o" #'+workspace/other
+       :desc "Switch to other workspace"    "o" #'+workspace/other
-        :desc "Undo window config"           "u" #'winner-undo
+       :desc "Undo window config"           "u" #'winner-undo
-        :desc "Redo window config"           "U" #'winner-redo
+       :desc "Redo window config"           "U" #'winner-redo
-        :desc "Switch to left workspace"     "p" #'+workspace/switch-left
+       :desc "Switch to left workspace"     "p" #'+workspace/switch-left
-        :desc "Switch to right workspace"    "n" #'+workspace/switch-right
+       :desc "Switch to right workspace"    "n" #'+workspace/switch-right
-        :desc "Switch to"                    "w" #'+workspace/switch-to
+       :desc "Switch to"                    "w" #'+workspace/switch-to
-        :desc "Switch to workspace 1"        "1" #'+workspace/switch-to-0
+       :desc "Switch to workspace 1"        "1" #'+workspace/switch-to-0
-        :desc "Switch to workspace 2"        "2" #'+workspace/switch-to-1
+       :desc "Switch to workspace 2"        "2" #'+workspace/switch-to-1
-        :desc "Switch to workspace 3"        "3" #'+workspace/switch-to-2
+       :desc "Switch to workspace 3"        "3" #'+workspace/switch-to-2
-        :desc "Switch to workspace 4"        "4" #'+workspace/switch-to-3
+       :desc "Switch to workspace 4"        "4" #'+workspace/switch-to-3
-        :desc "Switch to workspace 5"        "5" #'+workspace/switch-to-4
+       :desc "Switch to workspace 5"        "5" #'+workspace/switch-to-4
-        :desc "Switch to workspace 6"        "6" #'+workspace/switch-to-5
+       :desc "Switch to workspace 6"        "6" #'+workspace/switch-to-5
-        :desc "Switch to workspace 7"        "7" #'+workspace/switch-to-6
+       :desc "Switch to workspace 7"        "7" #'+workspace/switch-to-6
-        :desc "Switch to workspace 8"        "8" #'+workspace/switch-to-7
+       :desc "Switch to workspace 8"        "8" #'+workspace/switch-to-7
-        :desc "Switch to workspace 9"        "9" #'+workspace/switch-to-8
+       :desc "Switch to workspace 9"        "9" #'+workspace/switch-to-8
-        :desc "Switch to last workspace"     "0" #'+workspace/switch-to-final)
+       :desc "Switch to last workspace"     "0" #'+workspace/switch-to-final)
 
       ;;; <leader> m --- multiple cursors
       (:when (featurep! :editor multiple-cursors)
-        (:prefix-map ("m" . "multiple cursors")
+       (:prefix-map ("m" . "multiple cursors")
-          :desc "Edit lines"         "l"         #'mc/edit-lines
+        :desc "Edit lines"         "l"         #'mc/edit-lines
-          :desc "Mark next"          "n"         #'mc/mark-next-like-this
+        :desc "Mark next"          "n"         #'mc/mark-next-like-this
-          :desc "Unmark next"        "N"         #'mc/unmark-next-like-this
+        :desc "Unmark next"        "N"         #'mc/unmark-next-like-this
-          :desc "Mark previous"      "p"         #'mc/mark-previous-like-this
+        :desc "Mark previous"      "p"         #'mc/mark-previous-like-this
-          :desc "Unmark previous"    "P"         #'mc/unmark-previous-like-this
+        :desc "Unmark previous"    "P"         #'mc/unmark-previous-like-this
-          :desc "Mark all"           "t"         #'mc/mark-all-like-this
+        :desc "Mark all"           "t"         #'mc/mark-all-like-this
-          :desc "Mark all DWIM"      "m"         #'mc/mark-all-like-this-dwim
+        :desc "Mark all DWIM"      "m"         #'mc/mark-all-like-this-dwim
-          :desc "Edit line endings"  "e"         #'mc/edit-ends-of-lines
+        :desc "Edit line endings"  "e"         #'mc/edit-ends-of-lines
-          :desc "Edit line starts"   "a"         #'mc/edit-beginnings-of-lines
+        :desc "Edit line starts"   "a"         #'mc/edit-beginnings-of-lines
-          :desc "Mark tag"           "s"         #'mc/mark-sgml-tag-pair
+        :desc "Mark tag"           "s"         #'mc/mark-sgml-tag-pair
-          :desc "Mark in defun"      "d"         #'mc/mark-all-like-this-in-defun
+        :desc "Mark in defun"      "d"         #'mc/mark-all-like-this-in-defun
-          :desc "Add cursor w/mouse" "<mouse-1>" #'mc/add-cursor-on-click))
+        :desc "Add cursor w/mouse" "<mouse-1>" #'mc/add-cursor-on-click))
 
       ;; APPs
       ;;; <leader> M --- mu4e
       (:when (featurep! :email mu4e)
-        (:prefix-map ("M" . "mu4e")
+       (:prefix-map ("M" . "mu4e")
-          :desc "Open email app" "M" #'=mu4e
+        :desc "Open email app" "M" #'=mu4e
-          :desc "Compose email"  "c" #'+mu4e/compose))
+        :desc "Compose email"  "c" #'+mu4e/compose))
 
       ;;; <leader> I --- IRC
       (:when (featurep! :app irc)
-        (:prefix-map ("I" . "irc")
+       (:prefix-map ("I" . "irc")
-          :desc "Open irc app"       "I" #'=irc
+        :desc "Open irc app"       "I" #'=irc
-          :desc "Next unread buffer" "a" #'tracking-next-buffer
+        :desc "Next unread buffer" "a" #'tracking-next-buffer
-          :desc "Quit irc"           "q" #'+irc/quit
+        :desc "Quit irc"           "q" #'+irc/quit
-          :desc "Reconnect all"      "r" #'circe-reconnect-all
+        :desc "Reconnect all"      "r" #'circe-reconnect-all
-          :desc "Send message"       "s" #'+irc/send-message
+        :desc "Send message"       "s" #'+irc/send-message
-          (:when (featurep! :completion ivy)
+        (:when (featurep! :completion ivy)
-            :desc "Jump to channel"  "j" #'irc/ivy-jump-to-channel)))
+         :desc "Jump to channel"  "j" #'irc/ivy-jump-to-channel)))
 
       ;;; <leader> T --- twitter
       (:when (featurep! :app twitter)
-        (:prefix-map ("T" . "twitter")
+       (:prefix-map ("T" . "twitter")
-          :desc "Open twitter app" "T" #'=twitter
+        :desc "Open twitter app" "T" #'=twitter
-          :desc "Quit twitter"     "q" #'+twitter/quit
+        :desc "Quit twitter"     "q" #'+twitter/quit
-          :desc "Rerender twits"   "r" #'+twitter/rerender-all
+        :desc "Rerender twits"   "r" #'+twitter/rerender-all
-          :desc "Ace link"         "l" #'+twitter/ace-link)))
+        :desc "Ace link"         "l" #'+twitter/ace-link)))
 
 
 ;;
@@ -541,4 +542,4 @@
       ;;; treemacs
       (:when (featurep! :ui treemacs)
         "<f9>"   #'+treemacs/toggle
-        "<C-f9>" #'+treemacs/find-file))
+        "<C-f9>" #'treemacs-find-file))

modules/config/default/+evil-bindings.el

@@ -26,6 +26,9 @@
       "C-k"    #'previous-line
       "C-S-j"  #'scroll-up-command
       "C-S-k"  #'scroll-down-command)
+    (define-key! :states 'insert :keymaps +default-minibuffer-maps
+      "C-j"    #'next-line
+      "C-k"    #'previous-line)
     (define-key! read-expression-map
       "C-j" #'next-line-or-history-element
       "C-k" #'previous-line-or-history-element)))
@@ -54,42 +57,42 @@
       :i "C-j"           #'+default/newline    ; default behavior
 
       (:after help :map help-mode-map
-        :n "o"       #'link-hint-open-link)
+       :n "o"       #'link-hint-open-link)
       (:after helpful :map helpful-mode-map
-        :n "o"       #'link-hint-open-link)
+       :n "o"       #'link-hint-open-link)
       (:after info :map Info-mode-map
-        :n "o"       #'link-hint-open-link)
+       :n "o"       #'link-hint-open-link)
       (:after apropos :map apropos-mode-map
-        :n "o"       #'link-hint-open-link
+       :n "o"       #'link-hint-open-link
-        :n "TAB"     #'forward-button
+       :n "TAB"     #'forward-button
-        :n [tab]     #'forward-button
+       :n [tab]     #'forward-button
-        :n [backtab] #'backward-button)
+       :n [backtab] #'backward-button)
       (:after view :map view-mode-map
-        [escape]  #'View-quit-all)
+       [escape]  #'View-quit-all)
       (:after man :map Man-mode-map
-        :n "q"    #'kill-current-buffer)
+       :n "q"    #'kill-current-buffer)
 
       (:after (evil-org evil-easymotion)
-        :map evil-org-mode-map
+       :map evil-org-mode-map
-        :m "gsh" #'+org/goto-visible)
+       :m "gsh" #'+org/goto-visible)
 
       (:when (featurep! :editor multiple-cursors)
-        :prefix "gz"
+       :prefix "gz"
-        :nv "d" #'evil-mc-make-and-goto-next-match
+       :nv "d" #'evil-mc-make-and-goto-next-match
-        :nv "D" #'evil-mc-make-and-goto-prev-match
+       :nv "D" #'evil-mc-make-and-goto-prev-match
-        :nv "j" #'evil-mc-make-cursor-move-next-line
+       :nv "j" #'evil-mc-make-cursor-move-next-line
-        :nv "k" #'evil-mc-make-cursor-move-prev-line
+       :nv "k" #'evil-mc-make-cursor-move-prev-line
-        :nv "m" #'evil-mc-make-all-cursors
+       :nv "m" #'evil-mc-make-all-cursors
-        :nv "n" #'evil-mc-make-and-goto-next-cursor
+       :nv "n" #'evil-mc-make-and-goto-next-cursor
-        :nv "N" #'evil-mc-make-and-goto-last-cursor
+       :nv "N" #'evil-mc-make-and-goto-last-cursor
-        :nv "p" #'evil-mc-make-and-goto-prev-cursor
+       :nv "p" #'evil-mc-make-and-goto-prev-cursor
-        :nv "P" #'evil-mc-make-and-goto-first-cursor
+       :nv "P" #'evil-mc-make-and-goto-first-cursor
-        :nv "q" #'evil-mc-undo-all-cursors
+       :nv "q" #'evil-mc-undo-all-cursors
-        :nv "t" #'+multiple-cursors/evil-mc-toggle-cursors
+       :nv "t" #'+multiple-cursors/evil-mc-toggle-cursors
-        :nv "u" #'evil-mc-undo-last-added-cursor
+       :nv "u" #'evil-mc-undo-last-added-cursor
-        :nv "z" #'+multiple-cursors/evil-mc-make-cursor-here
+       :nv "z" #'+multiple-cursors/evil-mc-make-cursor-here
-        :v  "I" #'evil-mc-make-cursor-in-visual-selection-beg
+       :v  "I" #'evil-mc-make-cursor-in-visual-selection-beg
-        :v  "A" #'evil-mc-make-cursor-in-visual-selection-end)
+       :v  "A" #'evil-mc-make-cursor-in-visual-selection-end)
 
       ;; misc
       :n "C-S-f"  #'toggle-frame-fullscreen
@@ -107,119 +110,119 @@
 
 ;;; :completion
 (map! (:when (featurep! :completion company)
-        :i "C-@"      #'+company/complete
+       :i "C-@"      #'+company/complete
-        :i "C-SPC"    #'+company/complete
+       :i "C-SPC"    #'+company/complete
-        (:after company
+       (:after company
-          (:map company-active-map
+        (:map company-active-map
-            "C-w"     nil  ; don't interfere with `evil-delete-backward-word'
+         "C-w"     nil  ; don't interfere with `evil-delete-backward-word'
-            "C-n"     #'company-select-next
+         "C-n"     #'company-select-next
-            "C-p"     #'company-select-previous
+         "C-p"     #'company-select-previous
-            "C-j"     #'company-select-next
+         "C-j"     #'company-select-next
-            "C-k"     #'company-select-previous
+         "C-k"     #'company-select-previous
-            "C-h"     #'company-show-doc-buffer
+         "C-h"     #'company-show-doc-buffer
-            "C-u"     #'company-previous-page
+         "C-u"     #'company-previous-page
-            "C-d"     #'company-next-page
+         "C-d"     #'company-next-page
-            "C-s"     #'company-filter-candidates
+         "C-s"     #'company-filter-candidates
-            "C-S-s"   (cond ((featurep! :completion helm) #'helm-company)
+         "C-S-s"   (cond ((featurep! :completion helm) #'helm-company)
-                            ((featurep! :completion ivy)  #'counsel-company))
+                         ((featurep! :completion ivy)  #'counsel-company))
-            "C-SPC"   #'company-complete-common
+         "C-SPC"   #'company-complete-common
-            "TAB"     #'company-complete-common-or-cycle
+         "TAB"     #'company-complete-common-or-cycle
-            [tab]     #'company-complete-common-or-cycle
+         [tab]     #'company-complete-common-or-cycle
-            [backtab] #'company-select-previous
+         [backtab] #'company-select-previous
-            [f1]      nil)
+         [f1]      nil)
-          (:map company-search-map  ; applies to `company-filter-map' too
+        (:map company-search-map  ; applies to `company-filter-map' too
-            "C-n"     #'company-select-next-or-abort
+         "C-n"     #'company-select-next-or-abort
-            "C-p"     #'company-select-previous-or-abort
+         "C-p"     #'company-select-previous-or-abort
-            "C-j"     #'company-select-next-or-abort
+         "C-j"     #'company-select-next-or-abort
-            "C-k"     #'company-select-previous-or-abort
+         "C-k"     #'company-select-previous-or-abort
-            "C-s"     (λ! (company-search-abort) (company-filter-candidates))
+         "C-s"     (λ! (company-search-abort) (company-filter-candidates))
-            [escape]  #'company-search-abort))
+         [escape]  #'company-search-abort))
-        ;; TAB auto-completion in term buffers
+       ;; TAB auto-completion in term buffers
-        (:after comint :map comint-mode-map
+       (:after comint :map comint-mode-map
-          "TAB" #'company-complete
+        "TAB" #'company-complete
-          [tab] #'company-complete))
+        [tab] #'company-complete))
 
       (:when (featurep! :completion ivy)
-        (:after ivy
+       (:after ivy
-          :map ivy-minibuffer-map
+        :map ivy-minibuffer-map
-          "C-SPC" #'ivy-call-and-recenter  ; preview file
+        "C-SPC" #'ivy-call-and-recenter  ; preview file
-          "C-l"   #'ivy-alt-done
+        "C-l"   #'ivy-alt-done
-          "C-v"   #'yank)
+        "C-v"   #'yank)
-        (:after counsel
+       (:after counsel
-          :map counsel-ag-map
+        :map counsel-ag-map
-          "C-SPC"    #'ivy-call-and-recenter ; preview
+        "C-SPC"    #'ivy-call-and-recenter ; preview
-          "C-l"      #'ivy-done
+        "C-l"      #'ivy-done
-          [C-return] #'+ivy/git-grep-other-window-action))
+        [C-return] #'+ivy/git-grep-other-window-action))
 
       (:when (featurep! :completion helm)
-        (:after helm :map helm-map
+       (:after helm :map helm-map
-          [remap next-line]     #'helm-next-line
+        [remap next-line]     #'helm-next-line
-          [remap previous-line] #'helm-previous-line
+        [remap previous-line] #'helm-previous-line
-          [left]     #'left-char
+        [left]     #'left-char
-          [right]    #'right-char
+        [right]    #'right-char
-          "C-S-f"    #'helm-previous-page
+        "C-S-f"    #'helm-previous-page
-          "C-S-n"    #'helm-next-source
+        "C-S-n"    #'helm-next-source
-          "C-S-p"    #'helm-previous-source
+        "C-S-p"    #'helm-previous-source
-          (:when (featurep! :editor evil +everywhere)
+        (:when (featurep! :editor evil +everywhere)
-            "C-j"    #'helm-next-line
+         "C-j"    #'helm-next-line
-            "C-k"    #'helm-previous-line
+         "C-k"    #'helm-previous-line
-            "C-S-j"  #'helm-next-source
+         "C-S-j"  #'helm-next-source
-            "C-S-k"  #'helm-previous-source)
+         "C-S-k"  #'helm-previous-source)
-          "C-u"      #'helm-delete-minibuffer-contents
+        "C-u"      #'helm-delete-minibuffer-contents
-          "C-s"      #'helm-minibuffer-history
+        "C-s"      #'helm-minibuffer-history
-          ;; Swap TAB and C-z
+        ;; Swap TAB and C-z
-          "TAB"      #'helm-execute-persistent-action
+        "TAB"      #'helm-execute-persistent-action
-          [tab]      #'helm-execute-persistent-action
+        [tab]      #'helm-execute-persistent-action
-          "C-z"      #'helm-select-action)
+        "C-z"      #'helm-select-action)
-        (:after helm-ag :map helm-ag-map
+       (:after helm-ag :map helm-ag-map
-          "C--"      #'+helm-do-ag-decrease-context
+        "C--"      #'+helm-do-ag-decrease-context
-          "C-="      #'+helm-do-ag-increase-context
+        "C-="      #'+helm-do-ag-increase-context
-          [left]     nil
+        [left]     nil
-          [right]    nil)
+        [right]    nil)
-        (:after helm-files :map (helm-find-files-map helm-read-file-map)
+       (:after helm-files :map (helm-find-files-map helm-read-file-map)
-          [C-return] #'helm-ff-run-switch-other-window
+        [C-return] #'helm-ff-run-switch-other-window
-          "C-w"      #'helm-find-files-up-one-level)
+        "C-w"      #'helm-find-files-up-one-level)
-        (:after helm-locate :map helm-generic-files-map
+       (:after helm-locate :map helm-generic-files-map
-          [C-return] #'helm-ff-run-switch-other-window)
+        [C-return] #'helm-ff-run-switch-other-window)
-        (:after helm-buffers :map helm-buffer-map
+       (:after helm-buffers :map helm-buffer-map
-          [C-return] #'helm-buffer-switch-other-window)
+        [C-return] #'helm-buffer-switch-other-window)
-        (:after helm-occur :map helm-occur-map
+       (:after helm-occur :map helm-occur-map
-          [C-return] #'helm-occur-run-goto-line-ow)
+        [C-return] #'helm-occur-run-goto-line-ow)
-        (:after helm-grep :map helm-grep-map
+       (:after helm-grep :map helm-grep-map
-          [C-return] #'helm-grep-run-other-window-action)))
+        [C-return] #'helm-grep-run-other-window-action)))
 
 ;;; :ui
 (map! (:when (featurep! :ui popup)
-        "C-`"   #'+popup/toggle
+       "C-`"   #'+popup/toggle
-        "C-~"   #'+popup/raise
+       "C-~"   #'+popup/raise
-        "C-x p" #'+popup/other)
+       "C-x p" #'+popup/other)
 
       (:when (featurep! :ui workspaces)
-        :n "C-t"   #'+workspace/new
+       :n "C-t"   #'+workspace/new
-        :n "C-S-t" #'+workspace/display
+       :n "C-S-t" #'+workspace/display
-        :g "M-1"   #'+workspace/switch-to-0
+       :g "M-1"   #'+workspace/switch-to-0
-        :g "M-2"   #'+workspace/switch-to-1
+       :g "M-2"   #'+workspace/switch-to-1
-        :g "M-3"   #'+workspace/switch-to-2
+       :g "M-3"   #'+workspace/switch-to-2
-        :g "M-4"   #'+workspace/switch-to-3
+       :g "M-4"   #'+workspace/switch-to-3
-        :g "M-5"   #'+workspace/switch-to-4
+       :g "M-5"   #'+workspace/switch-to-4
-        :g "M-6"   #'+workspace/switch-to-5
+       :g "M-6"   #'+workspace/switch-to-5
-        :g "M-7"   #'+workspace/switch-to-6
+       :g "M-7"   #'+workspace/switch-to-6
-        :g "M-8"   #'+workspace/switch-to-7
+       :g "M-8"   #'+workspace/switch-to-7
-        :g "M-9"   #'+workspace/switch-to-8
+       :g "M-9"   #'+workspace/switch-to-8
-        :g "M-0"   #'+workspace/switch-to-final
+       :g "M-0"   #'+workspace/switch-to-final
-        (:when IS-MAC
+       (:when IS-MAC
-          :g "s-t"   #'+workspace/new
+        :g "s-t"   #'+workspace/new
-          :g "s-T"   #'+workspace/display
+        :g "s-T"   #'+workspace/display
-          :n "s-1"   #'+workspace/switch-to-0
+        :n "s-1"   #'+workspace/switch-to-0
-          :n "s-2"   #'+workspace/switch-to-1
+        :n "s-2"   #'+workspace/switch-to-1
-          :n "s-3"   #'+workspace/switch-to-2
+        :n "s-3"   #'+workspace/switch-to-2
-          :n "s-4"   #'+workspace/switch-to-3
+        :n "s-4"   #'+workspace/switch-to-3
-          :n "s-5"   #'+workspace/switch-to-4
+        :n "s-5"   #'+workspace/switch-to-4
-          :n "s-6"   #'+workspace/switch-to-5
+        :n "s-6"   #'+workspace/switch-to-5
-          :n "s-7"   #'+workspace/switch-to-6
+        :n "s-7"   #'+workspace/switch-to-6
-          :n "s-8"   #'+workspace/switch-to-7
+        :n "s-8"   #'+workspace/switch-to-7
-          :n "s-9"   #'+workspace/switch-to-8
+        :n "s-9"   #'+workspace/switch-to-8
-          :n "s-0"   #'+workspace/switch-to-final)))
+        :n "s-0"   #'+workspace/switch-to-final)))
 
 ;;; :editor
 (map! (:when (featurep! :editor format)
@@ -267,12 +270,12 @@
       :desc "help"                  "h"    help-map
 
       (:when (featurep! :ui popup)
-        :desc "Toggle last popup"     "~"    #'+popup/toggle)
+       :desc "Toggle last popup"     "~"    #'+popup/toggle)
       :desc "Find file"             "."    #'find-file
       :desc "Switch buffer"         ","    #'switch-to-buffer
       (:when (featurep! :ui workspaces)
-        :desc "Switch workspace buffer" "," #'persp-switch-to-buffer
+       :desc "Switch workspace buffer" "," #'persp-switch-to-buffer
-        :desc "Switch buffer"           "<" #'switch-to-buffer)
+       :desc "Switch buffer"           "<" #'switch-to-buffer)
       :desc "Switch to last buffer" "`"    #'evil-switch-to-windows-last-buffer
       :desc "Resume last search"    "'"
       (cond ((featurep! :completion ivy)   #'ivy-resume)
@@ -285,365 +288,367 @@
 
       ;;; <leader> TAB --- workspace
       (:when (featurep! :ui workspaces)
-        (:prefix-map ("TAB" . "workspace")
+       (:prefix-map ("TAB" . "workspace")
-          :desc "Display tab bar"           "TAB" #'+workspace/display
+        :desc "Display tab bar"           "TAB" #'+workspace/display
-          :desc "Switch workspace"          "."   #'+workspace/switch-to
+        :desc "Switch workspace"          "."   #'+workspace/switch-to
-          :desc "Switch to last workspace"  "`"   #'+workspace/other
+        :desc "Switch to last workspace"  "`"   #'+workspace/other
-          :desc "New workspace"             "n"   #'+workspace/new
+        :desc "New workspace"             "n"   #'+workspace/new
-          :desc "Load workspace from file"  "l"   #'+workspace/load
+        :desc "Load workspace from file"  "l"   #'+workspace/load
-          :desc "Save workspace to file"    "s"   #'+workspace/save
+        :desc "Save workspace to file"    "s"   #'+workspace/save
-          :desc "Delete session"            "x"   #'+workspace/kill-session
+        :desc "Delete session"            "x"   #'+workspace/kill-session
-          :desc "Delete this workspace"     "d"   #'+workspace/delete
+        :desc "Delete this workspace"     "d"   #'+workspace/delete
-          :desc "Rename workspace"          "r"   #'+workspace/rename
+        :desc "Rename workspace"          "r"   #'+workspace/rename
-          :desc "Restore last session"      "R"   #'+workspace/restore-last-session
+        :desc "Restore last session"      "R"   #'+workspace/restore-last-session
-          :desc "Next workspace"            "]"   #'+workspace/switch-right
+        :desc "Next workspace"            "]"   #'+workspace/switch-right
-          :desc "Previous workspace"        "["   #'+workspace/switch-left
+        :desc "Previous workspace"        "["   #'+workspace/switch-left
-          :desc "Switch to 1st workspace"   "1"   #'+workspace/switch-to-0
+        :desc "Switch to 1st workspace"   "1"   #'+workspace/switch-to-0
-          :desc "Switch to 2nd workspace"   "2"   #'+workspace/switch-to-1
+        :desc "Switch to 2nd workspace"   "2"   #'+workspace/switch-to-1
-          :desc "Switch to 3rd workspace"   "3"   #'+workspace/switch-to-2
+        :desc "Switch to 3rd workspace"   "3"   #'+workspace/switch-to-2
-          :desc "Switch to 4th workspace"   "4"   #'+workspace/switch-to-3
+        :desc "Switch to 4th workspace"   "4"   #'+workspace/switch-to-3
-          :desc "Switch to 5th workspace"   "5"   #'+workspace/switch-to-4
+        :desc "Switch to 5th workspace"   "5"   #'+workspace/switch-to-4
-          :desc "Switch to 6th workspace"   "6"   #'+workspace/switch-to-5
+        :desc "Switch to 6th workspace"   "6"   #'+workspace/switch-to-5
-          :desc "Switch to 7th workspace"   "7"   #'+workspace/switch-to-6
+        :desc "Switch to 7th workspace"   "7"   #'+workspace/switch-to-6
-          :desc "Switch to 8th workspace"   "8"   #'+workspace/switch-to-7
+        :desc "Switch to 8th workspace"   "8"   #'+workspace/switch-to-7
-          :desc "Switch to 9th workspace"   "9"   #'+workspace/switch-to-8
+        :desc "Switch to 9th workspace"   "9"   #'+workspace/switch-to-8
-          :desc "Switch to final workspace" "0"   #'+workspace/switch-to-final))
+        :desc "Switch to final workspace" "0"   #'+workspace/switch-to-final))
 
       ;;; <leader> b --- buffer
       (:prefix-map ("b" . "buffer")
-        :desc "Toggle narrowing"            "-"   #'doom/toggle-narrow-buffer
+       :desc "Toggle narrowing"            "-"   #'doom/toggle-narrow-buffer
-        :desc "Previous buffer"             "["   #'previous-buffer
+       :desc "Previous buffer"             "["   #'previous-buffer
-        :desc "Next buffer"                 "]"   #'next-buffer
+       :desc "Next buffer"                 "]"   #'next-buffer
-        (:when (featurep! :ui workspaces)
+       (:when (featurep! :ui workspaces)
-          :desc "Switch workspace buffer" "b" #'persp-switch-to-buffer
+        :desc "Switch workspace buffer" "b" #'persp-switch-to-buffer
-          :desc "Switch buffer"           "B" #'switch-to-buffer)
+        :desc "Switch buffer"           "B" #'switch-to-buffer)
-        (:unless (featurep! :ui workspaces)
+       (:unless (featurep! :ui workspaces)
-          :desc "Switch buffer"           "b" #'switch-to-buffer)
+        :desc "Switch buffer"           "b" #'switch-to-buffer)
-        :desc "Kill buffer"                 "d"   #'kill-current-buffer
+       :desc "Kill buffer"                 "d"   #'kill-current-buffer
-        :desc "ibuffer"                     "i"   #'ibuffer
+       :desc "ibuffer"                     "i"   #'ibuffer
-        :desc "Kill buffer"                 "k"   #'kill-current-buffer
+       :desc "Kill buffer"                 "k"   #'kill-current-buffer
-        :desc "Kill all buffers"            "K"   #'doom/kill-all-buffers
+       :desc "Kill all buffers"            "K"   #'doom/kill-all-buffers
-        :desc "Switch to last buffer"       "l"   #'evil-switch-to-windows-last-buffer
+       :desc "Switch to last buffer"       "l"   #'evil-switch-to-windows-last-buffer
-        :desc "Set bookmark"                "m"   #'bookmark-set
+       :desc "Set bookmark"                "m"   #'bookmark-set
-        :desc "Delete bookmark"             "M"   #'bookmark-delete
+       :desc "Delete bookmark"             "M"   #'bookmark-delete
-        :desc "Next buffer"                 "n"   #'next-buffer
+       :desc "Next buffer"                 "n"   #'next-buffer
-        :desc "New empty buffer"            "N"   #'evil-buffer-new
+       :desc "New empty buffer"            "N"   #'evil-buffer-new
-        :desc "Kill other buffers"          "O"   #'doom/kill-other-buffers
+       :desc "Kill other buffers"          "O"   #'doom/kill-other-buffers
-        :desc "Previous buffer"             "p"   #'previous-buffer
+       :desc "Previous buffer"             "p"   #'previous-buffer
-        :desc "Revert buffer"               "r"   #'revert-buffer
+       :desc "Revert buffer"               "r"   #'revert-buffer
-        :desc "Save buffer"                 "s"   #'basic-save-buffer
+       :desc "Save buffer"                 "s"   #'basic-save-buffer
-        :desc "Save all buffers"            "S"   #'evil-write-all
+       :desc "Save all buffers"            "S"   #'evil-write-all
-        :desc "Save buffer as root"         "u"   #'doom/sudo-save-buffer
+       :desc "Save buffer as root"         "u"   #'doom/sudo-save-buffer
-        :desc "Pop up scratch buffer"       "x"   #'doom/open-scratch-buffer
+       :desc "Pop up scratch buffer"       "x"   #'doom/open-scratch-buffer
-        :desc "Switch to scratch buffer"    "X"   #'doom/switch-to-scratch-buffer
+       :desc "Switch to scratch buffer"    "X"   #'doom/switch-to-scratch-buffer
-        :desc "Bury buffer"                 "z"   #'bury-buffer
+       :desc "Bury buffer"                 "z"   #'bury-buffer
-        :desc "Kill buried buffers"         "Z"   #'doom/kill-buried-buffers)
+       :desc "Kill buried buffers"         "Z"   #'doom/kill-buried-buffers)
 
       ;;; <leader> c --- code
       (:prefix-map ("c" . "code")
+       :desc "Compile"                               "c"   #'compile
+       :desc "Recompile"                             "C"   #'recompile
+       :desc "Jump to definition"                    "d"   #'+lookup/definition
+       :desc "Jump to references"                    "D"   #'+lookup/references
+       :desc "Evaluate buffer/region"                "e"   #'+eval/buffer-or-region
+       :desc "Evaluate & replace region"             "E"   #'+eval:replace-region
+       :desc "Format buffer/region"                  "f"   #'+format/region-or-buffer
+       (:when (featurep! :completion ivy)
+        :desc "Jump to symbol in current workspace" "j"   #'lsp-ivy-workspace-symbol
+        :desc "Jump to symbol in any workspace"     "J"   #'lsp-ivy-global-workspace-symbol)
+       (:when (featurep! :completion helm)
+        :desc "Jump to symbol in current workspace" "j"   #'helm-lsp-workspace-symbol
+        :desc "Jump to symbol in any workspace"     "J"   #'helm-lsp-global-workspace-symbol)
+       :desc "Jump to documentation"                 "k"   #'+lookup/documentation
+       (:when (featurep! :tools lsp)
         :desc "LSP Execute code action"               "a"   #'lsp-execute-code-action
-        :desc "Compile"                               "c"   #'compile
-        :desc "Recompile"                             "C"   #'recompile
-        :desc "Jump to definition"                    "d"   #'+lookup/definition
-        :desc "Jump to references"                    "D"   #'+lookup/references
-        :desc "Evaluate buffer/region"                "e"   #'+eval/buffer-or-region
-        :desc "Evaluate & replace region"             "E"   #'+eval:replace-region
-        :desc "Format buffer/region"                  "f"   #'+format/region-or-buffer
-        :desc "LSP Format buffer/region"              "F"   #'+default/lsp-format-region-or-buffer
         :desc "LSP Organize imports"                  "i"   #'lsp-organize-imports
-        (:when (featurep! :completion ivy)
-          :desc "Jump to symbol in current workspace" "j"   #'lsp-ivy-workspace-symbol
-          :desc "Jump to symbol in any workspace"     "J"   #'lsp-ivy-global-workspace-symbol)
-        (:when (featurep! :completion helm)
-          :desc "Jump to symbol in current workspace" "j"   #'helm-lsp-workspace-symbol
-          :desc "Jump to symbol in any workspace"     "J"   #'helm-lsp-global-workspace-symbol)
-        :desc "Jump to documentation"                 "k"   #'+lookup/documentation
         :desc "LSP Rename"                            "r"   #'lsp-rename
-        :desc "Send to repl"                          "s"   #'+eval/send-region-to-repl
+        (:after lsp-mode
-        :desc "Delete trailing whitespace"            "w"   #'delete-trailing-whitespace
+         :desc "LSP"                                   "l"   lsp-command-map))
-        :desc "Delete trailing newlines"              "W"   #'doom/delete-trailing-newlines
+       :desc "Send to repl"                          "s"   #'+eval/send-region-to-repl
-        :desc "List errors"                           "x"   #'flymake-show-diagnostics-buffer
+       :desc "Delete trailing whitespace"            "w"   #'delete-trailing-whitespace
-        (:when (featurep! :checkers syntax)
+       :desc "Delete trailing newlines"              "W"   #'doom/delete-trailing-newlines
-          :desc "List errors"                         "x"   #'flycheck-list-errors))
+       :desc "List errors"                           "x"   #'flymake-show-diagnostics-buffer
+       (:when (featurep! :checkers syntax)
+        :desc "List errors"                         "x"   #'flycheck-list-errors))
 
       ;;; <leader> f --- file
       (:prefix-map ("f" . "file")
-        :desc "Open project editorconfig"   "c"   #'editorconfig-find-current-editorconfig
+       :desc "Open project editorconfig"   "c"   #'editorconfig-find-current-editorconfig
-        :desc "Copy this file"              "C"   #'doom/copy-this-file
+       :desc "Copy this file"              "C"   #'doom/copy-this-file
-        :desc "Find directory"              "d"   #'dired
+       :desc "Find directory"              "d"   #'dired
-        :desc "Delete this file"            "D"   #'doom/delete-this-file
+       :desc "Delete this file"            "D"   #'doom/delete-this-file
-        :desc "Find file in emacs.d"        "e"   #'+default/find-in-emacsd
+       :desc "Find file in emacs.d"        "e"   #'+default/find-in-emacsd
-        :desc "Browse emacs.d"              "E"   #'+default/browse-emacsd
+       :desc "Browse emacs.d"              "E"   #'+default/browse-emacsd
-        :desc "Find file"                   "f"   #'find-file
+       :desc "Find file"                   "f"   #'find-file
-        :desc "Find file from here"         "F"   #'+default/find-file-under-here
+       :desc "Find file from here"         "F"   #'+default/find-file-under-here
-        :desc "Locate file"                 "l"   #'locate
+       :desc "Locate file"                 "l"   #'locate
-        :desc "Find file in private config" "p"   #'doom/find-file-in-private-config
+       :desc "Find file in private config" "p"   #'doom/find-file-in-private-config
-        :desc "Browse private config"       "P"   #'doom/open-private-config
+       :desc "Browse private config"       "P"   #'doom/open-private-config
-        :desc "Recent files"                "r"   #'recentf-open-files
+       :desc "Recent files"                "r"   #'recentf-open-files
-        :desc "Rename/move file"            "R"   #'doom/move-this-file
+       :desc "Rename/move file"            "R"   #'doom/move-this-file
-        :desc "Save file"                   "s"   #'save-buffer
+       :desc "Save file"                   "s"   #'save-buffer
-        :desc "Save file as..."             "S"   #'write-file
+       :desc "Save file as..."             "S"   #'write-file
-        :desc "Sudo find file"              "u"   #'doom/sudo-find-file
+       :desc "Sudo find file"              "u"   #'doom/sudo-find-file
-        :desc "Sudo this file"              "U"   #'doom/sudo-this-file
+       :desc "Sudo this file"              "U"   #'doom/sudo-this-file
-        :desc "Yank filename"               "y"   #'+default/yank-buffer-filename)
+       :desc "Yank filename"               "y"   #'+default/yank-buffer-filename)
 
       ;;; <leader> g --- git/version control
       (:prefix-map ("g" . "git")
-        :desc "Revert file"                 "R"   #'vc-revert
+       :desc "Revert file"                 "R"   #'vc-revert
-        :desc "Copy link to remote"         "y"   #'browse-at-remote-kill
+       :desc "Copy link to remote"         "y"   #'browse-at-remote-kill
-        :desc "Copy link to homepage"       "Y"   #'+vc/browse-at-remote-kill-homepage
+       :desc "Copy link to homepage"       "Y"   #'+vc/browse-at-remote-kill-homepage
+       (:when (featurep! :ui hydra)
+        :desc "SMerge"                    "m"   #'+vc/smerge-hydra/body)
+       (:when (featurep! :ui vc-gutter)
         (:when (featurep! :ui hydra)
-          :desc "SMerge"                    "m"   #'+vc/smerge-hydra/body)
+         :desc "VCGutter"                "."   #'+vc/gutter-hydra/body)
-        (:when (featurep! :ui vc-gutter)
+        :desc "Revert hunk"               "r"   #'git-gutter:revert-hunk
-          (:when (featurep! :ui hydra)
+        :desc "Git stage hunk"            "s"   #'git-gutter:stage-hunk
-            :desc "VCGutter"                "."   #'+vc/gutter-hydra/body)
+        :desc "Git time machine"          "t"   #'git-timemachine-toggle
-          :desc "Revert hunk"               "r"   #'git-gutter:revert-hunk
+        :desc "Jump to next hunk"         "]"   #'git-gutter:next-hunk
-          :desc "Git stage hunk"            "s"   #'git-gutter:stage-hunk
+        :desc "Jump to previous hunk"     "["   #'git-gutter:previous-hunk)
-          :desc "Git time machine"          "t"   #'git-timemachine-toggle
+       (:when (featurep! :tools magit)
-          :desc "Jump to next hunk"         "]"   #'git-gutter:next-hunk
+        :desc "Magit dispatch"            "/"   #'magit-dispatch
-          :desc "Jump to previous hunk"     "["   #'git-gutter:previous-hunk)
+        :desc "Forge dispatch"            "'"   #'forge-dispatch
-        (:when (featurep! :tools magit)
+        :desc "Magit switch branch"       "b"   #'magit-branch-checkout
-          :desc "Magit dispatch"            "/"   #'magit-dispatch
+        :desc "Magit status"              "g"   #'magit-status
-          :desc "Forge dispatch"            "'"   #'forge-dispatch
+        :desc "Magit file delete"         "D"   #'magit-file-delete
-          :desc "Magit switch branch"       "b"   #'magit-branch-checkout
+        :desc "Magit blame"               "B"   #'magit-blame-addition
-          :desc "Magit status"              "g"   #'magit-status
+        :desc "Magit clone"               "C"   #'magit-clone
-          :desc "Magit file delete"         "D"   #'magit-file-delete
+        :desc "Magit fetch"               "F"   #'magit-fetch
-          :desc "Magit blame"               "B"   #'magit-blame-addition
+        :desc "Magit buffer log"          "L"   #'magit-log
-          :desc "Magit clone"               "C"   #'magit-clone
+        :desc "Git stage file"            "S"   #'magit-stage-file
-          :desc "Magit fetch"               "F"   #'magit-fetch
+        :desc "Git unstage file"          "U"   #'magit-unstage-file
-          :desc "Magit buffer log"          "L"   #'magit-log
+        (:prefix ("f" . "find")
-          :desc "Git stage file"            "S"   #'magit-stage-file
+         :desc "Find file"                 "f"   #'magit-find-file
-          :desc "Git unstage file"          "U"   #'magit-unstage-file
+         :desc "Find gitconfig file"       "g"   #'magit-find-git-config-file
-          (:prefix ("f" . "find")
+         :desc "Find commit"               "c"   #'magit-show-commit
-            :desc "Find file"                 "f"   #'magit-find-file
+         :desc "Find issue"                "i"   #'forge-visit-issue
-            :desc "Find gitconfig file"       "g"   #'magit-find-git-config-file
+         :desc "Find pull request"         "p"   #'forge-visit-pullreq)
-            :desc "Find commit"               "c"   #'magit-show-commit
+        (:prefix ("o" . "open in browser")
-            :desc "Find issue"                "i"   #'forge-visit-issue
+         :desc "Browse file or region"     "o"   #'browse-at-remote
-            :desc "Find pull request"         "p"   #'forge-visit-pullreq)
+         :desc "Browse homepage"           "h"   #'+vc/browse-at-remote-homepage
-          (:prefix ("o" . "open in browser")
+         :desc "Browse remote"             "r"   #'forge-browse-remote
-            :desc "Browse file or region"     "o"   #'browse-at-remote
+         :desc "Browse commit"             "c"   #'forge-browse-commit
-            :desc "Browse homepage"           "h"   #'+vc/browse-at-remote-homepage
+         :desc "Browse an issue"           "i"   #'forge-browse-issue
-            :desc "Browse remote"             "r"   #'forge-browse-remote
+         :desc "Browse a pull request"     "p"   #'forge-browse-pullreq
-            :desc "Browse commit"             "c"   #'forge-browse-commit
+         :desc "Browse issues"             "I"   #'forge-browse-issues
-            :desc "Browse an issue"           "i"   #'forge-browse-issue
+         :desc "Browse pull requests"      "P"   #'forge-browse-pullreqs)
-            :desc "Browse a pull request"     "p"   #'forge-browse-pullreq
+        (:prefix ("l" . "list")
-            :desc "Browse issues"             "I"   #'forge-browse-issues
+         (:when (featurep! :tools gist)
-            :desc "Browse pull requests"      "P"   #'forge-browse-pullreqs)
+          :desc "List gists"              "g"   #'+gist:list)
-          (:prefix ("l" . "list")
+         :desc "List repositories"         "r"   #'magit-list-repositories
-            (:when (featurep! :tools gist)
+         :desc "List submodules"           "s"   #'magit-list-submodules
-              :desc "List gists"              "g"   #'+gist:list)
+         :desc "List issues"               "i"   #'forge-list-issues
-            :desc "List repositories"         "r"   #'magit-list-repositories
+         :desc "List pull requests"        "p"   #'forge-list-pullreqs
-            :desc "List submodules"           "s"   #'magit-list-submodules
+         :desc "List notifications"        "n"   #'forge-list-notifications)
-            :desc "List issues"               "i"   #'forge-list-issues
+        (:prefix ("c" . "create")
-            :desc "List pull requests"        "p"   #'forge-list-pullreqs
+         :desc "Initialize repo"           "r"   #'magit-init
-            :desc "List notifications"        "n"   #'forge-list-notifications)
+         :desc "Clone repo"                "R"   #'magit-clone
-          (:prefix ("c" . "create")
+         :desc "Commit"                    "c"   #'magit-commit-create
-            :desc "Initialize repo"           "r"   #'magit-init
+         :desc "Fixup"                     "f"   #'magit-commit-fixup
-            :desc "Clone repo"                "R"   #'magit-clone
+         :desc "Branch"                    "b"   #'magit-branch-and-checkout
-            :desc "Commit"                    "c"   #'magit-commit-create
+         :desc "Issue"                     "i"   #'forge-create-issue
-            :desc "Fixup"                     "f"   #'magit-commit-fixup
+         :desc "Pull request"              "p"   #'forge-create-pullreq)))
-            :desc "Branch"                    "b"   #'magit-branch-and-checkout
-            :desc "Issue"                     "i"   #'forge-create-issue
-            :desc "Pull request"              "p"   #'forge-create-pullreq)))
 
       ;;; <leader> i --- insert
       (:prefix-map ("i" . "insert")
-        :desc "Current file name"             "f"   #'+default/insert-file-path
+       :desc "Current file name"             "f"   #'+default/insert-file-path
-        :desc "Current file path"             "F"   (λ!! #'+default/insert-file-path t)
+       :desc "Current file path"             "F"   (λ!! #'+default/insert-file-path t)
-        :desc "Evil ex path"                  "p"   (λ! (evil-ex "R!echo "))
+       :desc "Evil ex path"                  "p"   (λ! (evil-ex "R!echo "))
-        :desc "From evil register"            "r"   #'evil-ex-registers
+       :desc "From evil register"            "r"   #'evil-ex-registers
-        :desc "Snippet"                       "s"   #'yas-insert-snippet
+       :desc "Snippet"                       "s"   #'yas-insert-snippet
-        :desc "Unicode"                       "u"   #'unicode-chars-list-chars
+       :desc "Unicode"                       "u"   #'unicode-chars-list-chars
-        :desc "From clipboard"                "y"   #'+default/yank-pop)
+       :desc "From clipboard"                "y"   #'+default/yank-pop)
 
       ;;; <leader> n --- notes
       (:prefix-map ("n" . "notes")
-        :desc "Search notes for symbol"      "*" #'+default/search-notes-for-symbol-at-point
+       :desc "Search notes for symbol"      "*" #'+default/search-notes-for-symbol-at-point
-        :desc "Org agenda"                   "a" #'org-agenda
+       :desc "Org agenda"                   "a" #'org-agenda
-        (:when (featurep! :tools biblio)
+       (:when (featurep! :tools biblio)
-          :desc "Bibliographic entries"        "b"
+        :desc "Bibliographic entries"        "b"
-          (cond ((featurep! :completion ivy)   #'ivy-bibtex)
+        (cond ((featurep! :completion ivy)   #'ivy-bibtex)
-                ((featurep! :completion helm)  #'helm-bibtex)))
+              ((featurep! :completion helm)  #'helm-bibtex)))
 
-        :desc "Toggle org-clock"             "c" #'+org/toggle-clock
+       :desc "Toggle org-clock"             "c" #'+org/toggle-clock
-        :desc "Cancel org-clock"             "C" #'org-clock-cancel
+       :desc "Cancel org-clock"             "C" #'org-clock-cancel
-        :desc "Open deft"                    "d" #'deft
+       :desc "Open deft"                    "d" #'deft
-        (:when (featurep! :lang org +noter)
+       (:when (featurep! :lang org +noter)
-          :desc "Org noter"                  "e" #'org-noter)
+        :desc "Org noter"                  "e" #'org-noter)
 
-        :desc "Find file in notes"           "f" #'+default/find-in-notes
+       :desc "Find file in notes"           "f" #'+default/find-in-notes
-        :desc "Browse notes"                 "F" #'+default/browse-notes
+       :desc "Browse notes"                 "F" #'+default/browse-notes
-        :desc "Org store link"               "l" #'org-store-link
+       :desc "Org store link"               "l" #'org-store-link
-        :desc "Tags search"                  "m" #'org-tags-view
+       :desc "Tags search"                  "m" #'org-tags-view
-        :desc "Org capture"                  "n" #'org-capture
+       :desc "Org capture"                  "n" #'org-capture
-        :desc "Goto capture"                 "N" #'org-capture-goto-target
+       :desc "Goto capture"                 "N" #'org-capture-goto-target
-        :desc "Active org-clock"             "o" #'org-clock-goto
+       :desc "Active org-clock"             "o" #'org-clock-goto
-        :desc "Todo list"                    "t" #'org-todo-list
+       :desc "Todo list"                    "t" #'org-todo-list
-        :desc "Search notes"                 "s" #'+default/org-notes-search
+       :desc "Search notes"                 "s" #'+default/org-notes-search
-        :desc "Search org agenda headlines"  "S" #'+default/org-notes-headlines
+       :desc "Search org agenda headlines"  "S" #'+default/org-notes-headlines
-        :desc "View search"                  "v" #'org-search-view
+       :desc "View search"                  "v" #'org-search-view
-        :desc "Org export to clipboard"        "y" #'+org/export-to-clipboard
+       :desc "Org export to clipboard"        "y" #'+org/export-to-clipboard
-        :desc "Org export to clipboard as RTF" "Y" #'+org/export-to-clipboard-as-rich-text
+       :desc "Org export to clipboard as RTF" "Y" #'+org/export-to-clipboard-as-rich-text
 
-        (:when (featurep! :lang org +roam)
+       (:when (featurep! :lang org +roam)
-          (:prefix ("r" . "roam")
+        (:prefix ("r" . "roam")
-            :desc "Switch to buffer" "b" #'org-roam-switch-to-buffer
+         :desc "Switch to buffer" "b" #'org-roam-switch-to-buffer
-            :desc "Org Roam Capture" "c" #'org-roam-capture
+         :desc "Org Roam Capture" "c" #'org-roam-capture
-            :desc "Find file"        "f" #'org-roam-find-file
+         :desc "Find file"        "f" #'org-roam-find-file
-            :desc "Show graph"       "g" #'org-roam-graph
+         :desc "Show graph"       "g" #'org-roam-graph
-            :desc "Insert"           "i" #'org-roam-insert
+         :desc "Insert"           "i" #'org-roam-insert
-            :desc "Org Roam"         "r" #'org-roam
+         :desc "Org Roam"         "r" #'org-roam
-            (:prefix ("d" . "by date")
+         (:prefix ("d" . "by date")
-              :desc "Arbitrary date" "d" #'org-roam-dailies-date
+          :desc "Arbitrary date" "d" #'org-roam-dailies-date
-              :desc "Today"          "t" #'org-roam-dailies-today
+          :desc "Today"          "t" #'org-roam-dailies-today
-              :desc "Tomorrow"       "m" #'org-roam-dailies-tomorrow
+          :desc "Tomorrow"       "m" #'org-roam-dailies-tomorrow
-              :desc "Yesterday"      "y" #'org-roam-dailies-yesterday)))
+          :desc "Yesterday"      "y" #'org-roam-dailies-yesterday)))
 
-        (:when (featurep! :lang org +journal)
+       (:when (featurep! :lang org +journal)
-          (:prefix ("j" . "journal")
+        (:prefix ("j" . "journal")
-            :desc "New Entry"      "j" #'org-journal-new-entry
+         :desc "New Entry"      "j" #'org-journal-new-entry
-            :desc "Search Forever" "s" #'org-journal-search-forever)))
+         :desc "Search Forever" "s" #'org-journal-search-forever)))
 
       ;;; <leader> o --- open
       (:prefix-map ("o" . "open")
-        :desc "Org agenda"       "A"  #'org-agenda
+       :desc "Org agenda"       "A"  #'org-agenda
-        (:prefix ("a" . "org agenda")
+       (:prefix ("a" . "org agenda")
-          :desc "Agenda"         "a"  #'org-agenda
+        :desc "Agenda"         "a"  #'org-agenda
-          :desc "Todo list"      "t"  #'org-todo-list
+        :desc "Todo list"      "t"  #'org-todo-list
-          :desc "Tags search"    "m"  #'org-tags-view
+        :desc "Tags search"    "m"  #'org-tags-view
-          :desc "View search"    "v"  #'org-search-view)
+        :desc "View search"    "v"  #'org-search-view)
-        :desc "Default browser"    "b"  #'browse-url-of-file
+       :desc "Default browser"    "b"  #'browse-url-of-file
-        :desc "Start debugger"     "d"  #'+debugger/start
+       :desc "Start debugger"     "d"  #'+debugger/start
-        :desc "New frame"          "f"  #'make-frame
+       :desc "New frame"          "f"  #'make-frame
-        :desc "REPL"               "r"  #'+eval/open-repl-other-window
+       :desc "REPL"               "r"  #'+eval/open-repl-other-window
-        :desc "REPL (same window)" "R"  #'+eval/open-repl-same-window
+       :desc "REPL (same window)" "R"  #'+eval/open-repl-same-window
-        :desc "Dired"              "-"  #'dired-jump
+       :desc "Dired"              "-"  #'dired-jump
-        (:when (featurep! :ui neotree)
+       (:when (featurep! :ui neotree)
-          :desc "Project sidebar"              "p" #'+neotree/open
+        :desc "Project sidebar"              "p" #'+neotree/open
-          :desc "Find file in project sidebar" "P" #'+neotree/find-this-file)
+        :desc "Find file in project sidebar" "P" #'+neotree/find-this-file)
-        (:when (featurep! :ui treemacs)
+       (:when (featurep! :ui treemacs)
-          :desc "Project sidebar" "p" #'+treemacs/toggle
+        :desc "Project sidebar" "p" #'+treemacs/toggle
-          :desc "Find file in project sidebar" "P" #'+treemacs/find-file)
+        :desc "Find file in project sidebar" "P" #'treemacs-find-file)
-        (:when (featurep! :term shell)
+       (:when (featurep! :term shell)
-          :desc "Toggle shell popup"    "t" #'+shell/toggle
+        :desc "Toggle shell popup"    "t" #'+shell/toggle
-          :desc "Open shell here"       "T" #'+shell/here)
+        :desc "Open shell here"       "T" #'+shell/here)
-        (:when (featurep! :term term)
+       (:when (featurep! :term term)
-          :desc "Toggle terminal popup" "t" #'+term/toggle
+        :desc "Toggle terminal popup" "t" #'+term/toggle
-          :desc "Open terminal here"    "T" #'+term/here)
+        :desc "Open terminal here"    "T" #'+term/here)
-        (:when (featurep! :term vterm)
+       (:when (featurep! :term vterm)
-          :desc "Toggle vterm popup"    "t" #'+vterm/toggle
+        :desc "Toggle vterm popup"    "t" #'+vterm/toggle
-          :desc "Open vterm here"       "T" #'+vterm/here)
+        :desc "Open vterm here"       "T" #'+vterm/here)
-        (:when (featurep! :term eshell)
+       (:when (featurep! :term eshell)
-          :desc "Toggle eshell popup"   "e" #'+eshell/toggle
+        :desc "Toggle eshell popup"   "e" #'+eshell/toggle
-          :desc "Open eshell here"      "E" #'+eshell/here)
+        :desc "Open eshell here"      "E" #'+eshell/here)
-        (:when (featurep! :tools macos)
+       (:when (featurep! :tools macos)
-          :desc "Reveal in Finder"           "o" #'+macos/reveal-in-finder
+        :desc "Reveal in Finder"           "o" #'+macos/reveal-in-finder
-          :desc "Reveal project in Finder"   "O" #'+macos/reveal-project-in-finder
+        :desc "Reveal project in Finder"   "O" #'+macos/reveal-project-in-finder
-          :desc "Send to Transmit"           "u" #'+macos/send-to-transmit
+        :desc "Send to Transmit"           "u" #'+macos/send-to-transmit
-          :desc "Send project to Transmit"   "U" #'+macos/send-project-to-transmit
+        :desc "Send project to Transmit"   "U" #'+macos/send-project-to-transmit
-          :desc "Send to Launchbar"          "l" #'+macos/send-to-launchbar
+        :desc "Send to Launchbar"          "l" #'+macos/send-to-launchbar
-          :desc "Send project to Launchbar"  "L" #'+macos/send-project-to-launchbar)
+        :desc "Send project to Launchbar"  "L" #'+macos/send-project-to-launchbar)
-        (:when (featurep! :tools docker)
+       (:when (featurep! :tools docker)
-          :desc "Docker" "D" #'docker))
+        :desc "Docker" "D" #'docker))
 
       ;;; <leader> p --- project
       (:prefix-map ("p" . "project")
-        :desc "Browse project"               "." #'+default/browse-project
+       :desc "Browse project"               "." #'+default/browse-project
-        :desc "Browse other project"         ">" #'doom/browse-in-other-project
+       :desc "Browse other project"         ">" #'doom/browse-in-other-project
-        :desc "Run cmd in project root"      "!" #'projectile-run-shell-command-in-root
+       :desc "Run cmd in project root"      "!" #'projectile-run-shell-command-in-root
-        :desc "Add new project"              "a" #'projectile-add-known-project
+       :desc "Add new project"              "a" #'projectile-add-known-project
-        :desc "Switch to project buffer"     "b" #'projectile-switch-to-buffer
+       :desc "Switch to project buffer"     "b" #'projectile-switch-to-buffer
-        :desc "Compile in project"           "c" #'projectile-compile-project
+       :desc "Compile in project"           "c" #'projectile-compile-project
-        :desc "Repeat last command"          "C" #'projectile-repeat-last-command
+       :desc "Repeat last command"          "C" #'projectile-repeat-last-command
-        :desc "Remove known project"         "d" #'projectile-remove-known-project
+       :desc "Remove known project"         "d" #'projectile-remove-known-project
-        :desc "Discover projects in folder"  "D" #'+default/discover-projects
+       :desc "Discover projects in folder"  "D" #'+default/discover-projects
-        :desc "Edit project .dir-locals"     "e" #'projectile-edit-dir-locals
+       :desc "Edit project .dir-locals"     "e" #'projectile-edit-dir-locals
-        :desc "Find file in project"         "f" #'projectile-find-file
+       :desc "Find file in project"         "f" #'projectile-find-file
-        :desc "Find file in other project"   "F" #'doom/find-file-in-other-project
+       :desc "Find file in other project"   "F" #'doom/find-file-in-other-project
-        :desc "Configure project"            "g" #'projectile-configure-project
+       :desc "Configure project"            "g" #'projectile-configure-project
-        :desc "Invalidate project cache"     "i" #'projectile-invalidate-cache
+       :desc "Invalidate project cache"     "i" #'projectile-invalidate-cache
-        :desc "Kill project buffers"         "k" #'projectile-kill-buffers
+       :desc "Kill project buffers"         "k" #'projectile-kill-buffers
-        :desc "Find other file"              "o" #'projectile-find-other-file
+       :desc "Find other file"              "o" #'projectile-find-other-file
-        :desc "Switch project"               "p" #'projectile-switch-project
+       :desc "Switch project"               "p" #'projectile-switch-project
-        :desc "Find recent project files"    "r" #'projectile-recentf
+       :desc "Find recent project files"    "r" #'projectile-recentf
-        :desc "Run project"                  "R" #'projectile-run-project
+       :desc "Run project"                  "R" #'projectile-run-project
-        :desc "Save project files"           "s" #'projectile-save-project-buffers
+       :desc "Save project files"           "s" #'projectile-save-project-buffers
-        :desc "List project tasks"           "t" #'magit-todos-list
+       :desc "List project tasks"           "t" #'magit-todos-list
-        :desc "Test project"                 "T" #'projectile-test-project
+       :desc "Test project"                 "T" #'projectile-test-project
-        :desc "Pop up scratch buffer"        "x" #'doom/open-project-scratch-buffer
+       :desc "Pop up scratch buffer"        "x" #'doom/open-project-scratch-buffer
-        :desc "Switch to scratch buffer"     "X" #'doom/switch-to-project-scratch-buffer)
+       :desc "Switch to scratch buffer"     "X" #'doom/switch-to-project-scratch-buffer)
 
       ;;; <leader> q --- quit/session
       (:prefix-map ("q" . "quit/session")
-        :desc "Restart emacs server"         "d" #'+default/restart-server
+       :desc "Restart emacs server"         "d" #'+default/restart-server
-        :desc "Delete frame"                 "f" #'delete-frame
+       :desc "Delete frame"                 "f" #'delete-frame
-        :desc "Clear current frame"          "F" #'doom/kill-all-buffers
+       :desc "Clear current frame"          "F" #'doom/kill-all-buffers
-        :desc "Kill Emacs (and daemon)"      "K" #'save-buffers-kill-emacs
+       :desc "Kill Emacs (and daemon)"      "K" #'save-buffers-kill-emacs
-        :desc "Quit Emacs"                   "q" #'save-buffers-kill-terminal
+       :desc "Quit Emacs"                   "q" #'save-buffers-kill-terminal
-        :desc "Quit Emacs without saving"    "Q" #'evil-quit-all-with-error-code
+       :desc "Quit Emacs without saving"    "Q" #'evil-quit-all-with-error-code
-        :desc "Quick save current session"   "s" #'doom/quicksave-session
+       :desc "Quick save current session"   "s" #'doom/quicksave-session
-        :desc "Restore last session"         "l" #'doom/quickload-session
+       :desc "Restore last session"         "l" #'doom/quickload-session
-        :desc "Save session to file"         "S" #'doom/save-session
+       :desc "Save session to file"         "S" #'doom/save-session
-        :desc "Restore session from file"    "L" #'doom/load-session
+       :desc "Restore session from file"    "L" #'doom/load-session
-        :desc "Restart & restore Emacs"      "r" #'doom/restart-and-restore
+       :desc "Restart & restore Emacs"      "r" #'doom/restart-and-restore
-        :desc "Restart Emacs"                "R" #'doom/restart)
+       :desc "Restart Emacs"                "R" #'doom/restart)
 
       ;;; <leader> r --- remote
       (:when (featurep! :tools upload)
-        (:prefix-map ("r" . "remote")
+       (:prefix-map ("r" . "remote")
-          :desc "Upload local"               "u" #'ssh-deploy-upload-handler
+        :desc "Upload local"               "u" #'ssh-deploy-upload-handler
-          :desc "Upload local (force)"       "U" #'ssh-deploy-upload-handler-forced
+        :desc "Upload local (force)"       "U" #'ssh-deploy-upload-handler-forced
-          :desc "Download remote"            "d" #'ssh-deploy-download-handler
+        :desc "Download remote"            "d" #'ssh-deploy-download-handler
-          :desc "Diff local & remote"        "D" #'ssh-deploy-diff-handler
+        :desc "Diff local & remote"        "D" #'ssh-deploy-diff-handler
-          :desc "Browse remote files"        "." #'ssh-deploy-browse-remote-handler
+        :desc "Browse remote files"        "." #'ssh-deploy-browse-remote-handler
-          :desc "Detect remote changes"      ">" #'ssh-deploy-remote-changes-handler))
+        :desc "Detect remote changes"      ">" #'ssh-deploy-remote-changes-handler))
 
       ;;; <leader> s --- search
       (:prefix-map ("s" . "search")
-        :desc "Search buffer"                "b" #'swiper
+       :desc "Search buffer"                "b" #'swiper
-        :desc "Search current directory"     "d" #'+default/search-cwd
+       :desc "Search current directory"     "d" #'+default/search-cwd
-        :desc "Search other directory"       "D" #'+default/search-other-cwd
+       :desc "Search other directory"       "D" #'+default/search-other-cwd
-        :desc "Locate file"                  "f" #'locate
+       :desc "Locate file"                  "f" #'locate
-        :desc "Jump to symbol"               "i" #'imenu
+       :desc "Jump to symbol"               "i" #'imenu
-        :desc "Jump to visible link"         "l" #'link-hint-open-link
+       :desc "Jump to visible link"         "l" #'link-hint-open-link
-        :desc "Jump to link"                 "L" #'ffap-menu
+       :desc "Jump to link"                 "L" #'ffap-menu
-        :desc "Jump list"                    "j" #'evil-show-jumps
+       :desc "Jump list"                    "j" #'evil-show-jumps
-        :desc "Jump to bookmark"             "m" #'bookmark-jump
+       :desc "Jump to bookmark"             "m" #'bookmark-jump
-        :desc "Look up online"               "o" #'+lookup/online
+       :desc "Look up online"               "o" #'+lookup/online
-        :desc "Look up online (w/ prompt)"   "O" #'+lookup/online-select
+       :desc "Look up online (w/ prompt)"   "O" #'+lookup/online-select
-        :desc "Look up in local docsets"     "k" #'+lookup/in-docsets
+       :desc "Look up in local docsets"     "k" #'+lookup/in-docsets
-        :desc "Look up in all docsets"       "K" #'+lookup/in-all-docsets
+       :desc "Look up in all docsets"       "K" #'+lookup/in-all-docsets
-        :desc "Search project"               "p" #'+default/search-project
+       :desc "Search project"               "p" #'+default/search-project
-        :desc "Search other project"         "P" #'+default/search-other-project
+       :desc "Search other project"         "P" #'+default/search-other-project
-        :desc "Jump to mark"                 "r" #'evil-show-marks
+       :desc "Jump to mark"                 "r" #'evil-show-marks
-        :desc "Search buffer"                "s" #'swiper-isearch
+       :desc "Search buffer"                "s" #'swiper-isearch
-        :desc "Search buffer for thing at point" "S" #'swiper-isearch-thing-at-point
+       :desc "Search buffer for thing at point" "S" #'swiper-isearch-thing-at-point
-        :desc "Dictionary"                   "t" #'+lookup/dictionary-definition
+       :desc "Dictionary"                   "t" #'+lookup/dictionary-definition
-        :desc "Thesaurus"                    "T" #'+lookup/synonyms)
+       :desc "Thesaurus"                    "T" #'+lookup/synonyms)
 
       ;;; <leader> t --- toggle
       (:prefix-map ("t" . "toggle")
-        :desc "Big mode"                     "b" #'doom-big-font-mode
+       :desc "Big mode"                     "b" #'doom-big-font-mode
-        :desc "Flymake"                      "f" #'flymake-mode
+       :desc "Flymake"                      "f" #'flymake-mode
-        (:when (featurep! :checkers syntax)
+       (:when (featurep! :checkers syntax)
-          :desc "Flycheck"                   "f" #'flycheck-mode)
+        :desc "Flycheck"                   "f" #'flycheck-mode)
-        :desc "Frame fullscreen"             "F" #'toggle-frame-fullscreen
+       :desc "Frame fullscreen"             "F" #'toggle-frame-fullscreen
-        :desc "Evil goggles"                 "g" #'evil-goggles-mode
+       :desc "Evil goggles"                 "g" #'evil-goggles-mode
-        (:when (featurep! :ui indent-guides)
+       (:when (featurep! :ui indent-guides)
-          :desc "Indent guides"              "i" #'highlight-indent-guides-mode)
+        :desc "Indent guides"              "i" #'highlight-indent-guides-mode)
-        :desc "Indent style"                 "I" #'doom/toggle-indent-style
+       :desc "Indent style"                 "I" #'doom/toggle-indent-style
-        :desc "Line numbers"                 "l" #'doom/toggle-line-numbers
+       :desc "Line numbers"                 "l" #'doom/toggle-line-numbers
-        (:when (featurep! :lang org +present)
+       (:when (featurep! :lang org +present)
-          :desc "org-tree-slide mode"        "p" #'org-tree-slide-mode)
+        :desc "org-tree-slide mode"        "p" #'org-tree-slide-mode)
-        :desc "Read-only mode"               "r" #'read-only-mode
+       :desc "Read-only mode"               "r" #'read-only-mode
-        (:when (featurep! :checkers spell)
+       (:when (featurep! :checkers spell)
-          :desc "Flyspell"                   "s" #'flyspell-mode)
+        :desc "Flyspell"                   "s" #'flyspell-mode)
-        (:when (featurep! :lang org +pomodoro)
+       (:when (featurep! :lang org +pomodoro)
-          :desc "Pomodoro timer"             "t" #'org-pomodoro)
+        :desc "Pomodoro timer"             "t" #'org-pomodoro)
-        :desc "Soft line wrapping"           "w" #'visual-line-mode
+       :desc "Soft line wrapping"           "w" #'visual-line-mode
-        (:when (featurep! :editor word-wrap)
+       (:when (featurep! :editor word-wrap)
-          :desc "Soft line wrapping"         "w" #'+word-wrap-mode)
+        :desc "Soft line wrapping"         "w" #'+word-wrap-mode)
-        :desc "Zen mode"                     "z" #'writeroom-mode))
+       :desc "Zen mode"                     "z" #'writeroom-mode))
 
 (after! which-key
   (let ((prefix-re (regexp-opt (list doom-leader-key doom-leader-alt-key))))

modules/config/default/autoload/search.el

@@ -25,7 +25,8 @@ If prefix ARG is set, prompt for a directory to search from."
   "Conduct a text search in the current project root.
 If prefix ARG is set, prompt for a known project to search from."
   (interactive "P")
-  (let* ((disabled-command-function nil)
+  (let* ((projectile-project-root nil)
+         (disabled-command-function nil)
          (default-directory
            (if arg
                (if-let (projects (projectile-relevant-known-projects))
@@ -51,13 +52,14 @@ If prefix ARG is set, prompt for a known project to search from."
   (interactive
    (list (rxt-quote-pcre (or (doom-thing-at-point-or-region) ""))
          current-prefix-arg))
-  (let ((default-directory
+  (let* ((projectile-project-root nil)
-          (if arg
+         (default-directory
-              (if-let (projects (projectile-relevant-known-projects))
+           (if arg
-                  (completing-read "Switch to project: " projects
+               (if-let (projects (projectile-relevant-known-projects))
-                                   nil t nil nil (doom-project-root))
+                   (completing-read "Switch to project: " projects
-                (user-error "There are no known projects"))
+                                    nil t nil nil (doom-project-root))
-            default-directory)))
+                 (user-error "There are no known projects"))
+             default-directory)))
     (cond ((featurep! :completion ivy)
            (+ivy/project-search nil symbol))
           ((featurep! :completion helm)

modules/config/default/autoload/text.el

@@ -50,21 +50,6 @@ If `buffer-file-name' isn't set, uses `default-directory'."
          (abbreviate-file-name path)
        (file-name-nondirectory path)))))
 
-;;;###autoload
-(defun +default--newline-indent-and-continue-comments-a ()
-  "A replacement for `newline-and-indent'.
-
-Continues comments if executed from a commented line, with special support for
-languages with weak native comment continuation support (like C-family
-languages)."
-  (interactive)
-  (if (and (sp-point-in-comment)
-           comment-line-break-function)
-      (funcall comment-line-break-function nil)
-    (delete-horizontal-space t)
-    (newline nil t)
-    (indent-according-to-mode)))
-
 
 (defun doom--backward-delete-whitespace-to-column ()
   "Delete back to the previous column of whitespace, or as much whitespace as

modules/config/default/config.el

@@ -1,5 +1,8 @@
 ;;; config/default/config.el -*- lexical-binding: t; -*-
 
+(defvar +default-want-RET-continue-comments t
+  "If non-nil, RET will continue commented lines.")
+
 (defvar +default-minibuffer-maps
   (append '(minibuffer-local-map
             minibuffer-local-ns-map
@@ -220,8 +223,28 @@
     ;;  f) do none of this when inside a string
     (advice-add #'delete-backward-char :override #'+default--delete-backward-char-a))
 
-  ;; Makes `newline-and-indent' continue comments (and more reliably)
+  ;; HACK Makes `newline-and-indent' continue comments (and more reliably).
-  (advice-add #'newline-and-indent :override #'+default--newline-indent-and-continue-comments-a))
+  ;;      Consults `doom-point-in-comment-functions' to detect a commented
+  ;;      region and uses that mode's `comment-line-break-function' to continue
+  ;;      comments. If neither exists, it will fall back to the normal behavior
+  ;;      of `newline-and-indent'.
+  ;;
+  ;;      We use an advice here instead of a remapping because many modes define
+  ;;      and remap to their own newline-and-indent commands, and tackling all
+  ;;      those cases was judged to be more work than dealing with the edge
+  ;;      cases on a case by case basis.
+  (defadvice! +default--newline-indent-and-continue-comments-a (&rest _)
+    "A replacement for `newline-and-indent'.
+
+Continues comments if executed from a commented line. Consults
+`doom-point-in-comment-functions' to determine if in a comment."
+    :before-until #'newline-and-indent
+    (interactive "*")
+    (when (and +default-want-RET-continue-comments
+               (doom-point-in-comment-p)
+               (fboundp comment-line-break-function))
+      (funcall comment-line-break-function nil)
+      t)))
 
 
 ;;

modules/config/default/packages.el

@@ -1,9 +1,9 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; config/default/packages.el
 
-(package! avy :pin "3bf83140fa")
+(package! avy :pin "509471bad0e8094b8639729ec39ca141fae7d4bd")
-(package! drag-stuff :pin "6d06d846cd")
+(package! drag-stuff :pin "6d06d846cd37c052d79acd0f372c13006aa7e7c8")
-(package! link-hint :pin "0d9cabcdb7")
+(package! link-hint :pin "7440704cacb5c0fab35fff8ec59d30fbea17f44a")
 
 (unless (featurep! :editor evil)
-  (package! expand-region :pin "ea6b4cbb99"))
+  (package! expand-region :pin "ea6b4cbb9985ddae532bd2faf9bb00570c9f2781"))

modules/editor/evil/autoload/advice.el

@@ -123,8 +123,7 @@ more information on modifiers."
           (not (eq this-command 'evil-open-below))
           (evil-insert-state-p))
       (funcall orig-fn count)
-    (cl-letf (((symbol-function 'evil-insert-newline-below)
+    (letf! (defun evil-insert-newline-below () (+evil--insert-newline))
-               (lambda () (+evil--insert-newline))))
       (let ((evil-auto-indent evil-auto-indent))
         (funcall orig-fn count)))))
 
@@ -134,8 +133,7 @@ more information on modifiers."
           (not (eq this-command 'evil-open-above))
           (evil-insert-state-p))
       (funcall orig-fn count)
-    (cl-letf (((symbol-function 'evil-insert-newline-above)
+    (letf! (defun evil-insert-newline-above () (+evil--insert-newline 'above))
-               (lambda () (+evil--insert-newline 'above))))
       (let ((evil-auto-indent evil-auto-indent))
         (funcall orig-fn count)))))
 

modules/editor/evil/config.el

@@ -280,8 +280,13 @@ directives. By default, this only recognizes C directives.")
         evil-escape-delay 0.15)
   (evil-define-key* '(insert replace visual operator) 'global "\C-g" #'evil-escape)
   :config
-  ;; no `evil-escape' in minibuffer
+  ;; no `evil-escape' in minibuffer, unless `evil-collection-setup-minibuffer'
-  (add-hook 'evil-escape-inhibit-functions #'minibufferp)
+  ;; is enabled, where we could be in insert mode in the minibuffer.
+  (add-hook! 'evil-escape-inhibit-functions
+    (defun +evil-inhibit-escape-in-minibuffer-fn ()
+      (and (minibufferp)
+           (or (not (bound-and-true-p evil-collection-setup-minibuffer))
+               (evil-normal-state-p)))))
   ;; so that evil-escape-mode-hook runs, and can be toggled by evil-mc
   (evil-escape-mode +1))
 
@@ -422,22 +427,22 @@ To change these keys see `+evil-repeat-keys'."
       :m  "]y"    #'+evil:c-string-encode
       :m  "[y"    #'+evil:c-string-decode
       (:when (featurep! :lang web)
-        :m "]x"   #'+web:encode-html-entities
+       :m "]x"   #'+web:encode-html-entities
-        :m "[x"   #'+web:decode-html-entities)
+       :m "[x"   #'+web:decode-html-entities)
       (:when (featurep! :ui vc-gutter)
-        :m "]d"   #'git-gutter:next-hunk
+       :m "]d"   #'git-gutter:next-hunk
-        :m "[d"   #'git-gutter:previous-hunk)
+       :m "[d"   #'git-gutter:previous-hunk)
       (:when (featurep! :ui hl-todo)
-        :m "]t"   #'hl-todo-next
+       :m "]t"   #'hl-todo-next
-        :m "[t"   #'hl-todo-previous)
+       :m "[t"   #'hl-todo-previous)
       (:when (featurep! :ui workspaces)
-        :n "gt"   #'+workspace:switch-next
+       :n "gt"   #'+workspace:switch-next
-        :n "gT"   #'+workspace:switch-previous
+       :n "gT"   #'+workspace:switch-previous
-        :n "]w"   #'+workspace/switch-right
+       :n "]w"   #'+workspace/switch-right
-        :n "[w"   #'+workspace/switch-left)
+       :n "[w"   #'+workspace/switch-left)
       (:when (featurep! :ui tabs)
-        :n "gt"   #'centaur-tabs-forward
+       :n "gt"   #'centaur-tabs-forward
-        :n "gT"   #'centaur-tabs-backward)
+       :n "gT"   #'centaur-tabs-backward)
 
       ;; custom vim-unmpaired-esque keys
       :m  "]#"    #'+evil/next-preproc-directive
@@ -470,27 +475,27 @@ To change these keys see `+evil-repeat-keys'."
       :v  "g-"    #'evil-numbers/dec-at-pt-incremental
       :v  "g+"    #'evil-numbers/inc-at-pt
       (:when (featurep! :tools lookup)
-        :nv "K"   #'+lookup/documentation
+       :nv "K"   #'+lookup/documentation
-        :nv "gd"  #'+lookup/definition
+       :nv "gd"  #'+lookup/definition
-        :nv "gD"  #'+lookup/references
+       :nv "gD"  #'+lookup/references
-        :nv "gf"  #'+lookup/file)
+       :nv "gf"  #'+lookup/file)
       (:when (featurep! :tools eval)
-        :nv "gr"  #'+eval:region
+       :nv "gr"  #'+eval:region
-        :n  "gR"  #'+eval/buffer
+       :n  "gR"  #'+eval/buffer
-        :v  "gR"  #'+eval:replace-region
+       :v  "gR"  #'+eval:replace-region
-        ;; Restore these keybinds, since the blacklisted/overwritten gr/gR will
+       ;; Restore these keybinds, since the blacklisted/overwritten gr/gR will
-        ;; undo them:
+       ;; undo them:
-        (:after dired
+       (:after dired
-          :map dired-mode-map
+        :map dired-mode-map
-          :n "gr" #'revert-buffer)
+        :n "gr" #'revert-buffer)
-        (:after notmuch
+       (:after notmuch
-          :map notmuch-common-keymap
+        :map notmuch-common-keymap
-          :n "gr" #'notmuch-refresh-this-buffer
+        :n "gr" #'notmuch-refresh-this-buffer
-          :n "gR" #'notmuch-poll-and-refresh-this-buffer)
+        :n "gR" #'notmuch-poll-and-refresh-this-buffer)
-        (:after elfeed
+       (:after elfeed
-          :map elfeed-search-update--force
+        :map elfeed-search-mode-map
-          :n "gr" #'elfeed-search-update--force
+        :n "gr" #'elfeed-search-update--force
-          :n "gR" #'elfeed-search-fetch))
+        :n "gR" #'elfeed-search-fetch))
 
       :nv "z="    #'flyspell-correct-at-point
       ;; custom evil keybinds
@@ -504,30 +509,30 @@ To change these keys see `+evil-repeat-keys'."
 
       ;; window management (prefix "C-w")
       (:map evil-window-map
-        ;; Navigation
+       ;; Navigation
-        "C-h"     #'evil-window-left
+       "C-h"     #'evil-window-left
-        "C-j"     #'evil-window-down
+       "C-j"     #'evil-window-down
-        "C-k"     #'evil-window-up
+       "C-k"     #'evil-window-up
-        "C-l"     #'evil-window-right
+       "C-l"     #'evil-window-right
-        "C-w"     #'other-window
+       "C-w"     #'other-window
-        ;; Swapping windows
+       ;; Swapping windows
-        "H"       #'+evil/window-move-left
+       "H"       #'+evil/window-move-left
-        "J"       #'+evil/window-move-down
+       "J"       #'+evil/window-move-down
-        "K"       #'+evil/window-move-up
+       "K"       #'+evil/window-move-up
-        "L"       #'+evil/window-move-right
+       "L"       #'+evil/window-move-right
-        "C-S-w"   #'ace-swap-window
+       "C-S-w"   #'ace-swap-window
-        ;; Window undo/redo
+       ;; Window undo/redo
-        (:prefix "m"
+       (:prefix "m"
-          "m"       #'doom/window-maximize-buffer
+        "m"       #'doom/window-maximize-buffer
-          "v"       #'doom/window-maximize-vertically
+        "v"       #'doom/window-maximize-vertically
-          "s"       #'doom/window-maximize-horizontally)
+        "s"       #'doom/window-maximize-horizontally)
-        "u"       #'winner-undo
+       "u"       #'winner-undo
-        "C-u"     #'winner-undo
+       "C-u"     #'winner-undo
-        "C-r"     #'winner-redo
+       "C-r"     #'winner-redo
-        "o"       #'doom/window-enlargen
+       "o"       #'doom/window-enlargen
-        ;; Delete window
+       ;; Delete window
-        "d"       #'evil-window-delete
+       "d"       #'evil-window-delete
-        "C-C"     #'ace-delete-window)
+       "C-C"     #'ace-delete-window)
 
       ;; text objects
       :textobj "a" #'evil-inner-arg                    #'evil-outer-arg
@@ -543,23 +548,23 @@ To change these keys see `+evil-repeat-keys'."
 
       ;; evil-easymotion (see `+evil/easymotion')
       (:after evil-easymotion
-        :m "gs" evilem-map
+       :m "gs" evilem-map
-        (:map evilem-map
+       (:map evilem-map
-          "a" (evilem-create #'evil-forward-arg)
+        "a" (evilem-create #'evil-forward-arg)
-          "A" (evilem-create #'evil-backward-arg)
+        "A" (evilem-create #'evil-backward-arg)
-          "s" #'evil-avy-goto-char-2
+        "s" #'evil-avy-goto-char-2
-          "SPC" (λ!! #'evil-avy-goto-char-timer t)
+        "SPC" (λ!! #'evil-avy-goto-char-timer t)
-          "/" #'evil-avy-goto-char-timer))
+        "/" #'evil-avy-goto-char-timer))
 
-        ;; evil-snipe
+      ;; evil-snipe
       (:after evil-snipe
-        :map evil-snipe-parent-transient-map
+       :map evil-snipe-parent-transient-map
-        "C-;" (λ! (require 'evil-easymotion)
+       "C-;" (λ! (require 'evil-easymotion)
-                  (call-interactively
+                 (call-interactively
-                   (evilem-create #'evil-snipe-repeat
+                  (evilem-create #'evil-snipe-repeat
-                                  :bind ((evil-snipe-scope 'whole-buffer)
+                                 :bind ((evil-snipe-scope 'whole-buffer)
-                                         (evil-snipe-enable-highlight)
+                                        (evil-snipe-enable-highlight)
-                                         (evil-snipe-enable-incremental-highlight))))))
+                                        (evil-snipe-enable-incremental-highlight))))))
 
       ;; evil-surround
       :v "S" #'evil-surround-region
@@ -574,13 +579,13 @@ To change these keys see `+evil-repeat-keys'."
 
       ;; Omni-completion
       (:when (featurep! :completion company)
-        (:prefix "C-x"
+       (:prefix "C-x"
-          :i "C-l"    #'+company/whole-lines
+        :i "C-l"    #'+company/whole-lines
-          :i "C-k"    #'+company/dict-or-keywords
+        :i "C-k"    #'+company/dict-or-keywords
-          :i "C-f"    #'company-files
+        :i "C-f"    #'company-files
-          :i "C-]"    #'company-etags
+        :i "C-]"    #'company-etags
-          :i "s"      #'company-ispell
+        :i "s"      #'company-ispell
-          :i "C-s"    #'company-yasnippet
+        :i "C-s"    #'company-yasnippet
-          :i "C-o"    #'company-capf
+        :i "C-o"    #'company-capf
-          :i "C-n"    #'+company/dabbrev
+        :i "C-n"    #'+company/dabbrev
-          :i "C-p"    #'+company/dabbrev-code-previous)))
+        :i "C-p"    #'+company/dabbrev-code-previous)))

modules/editor/evil/init.el

@@ -260,7 +260,8 @@ and complains if a module is loaded too early (during startup)."
     (+evil-collection-init '(occur replace)))
   (add-transient-hook! 'minibuffer-setup-hook
     (when evil-collection-setup-minibuffer
-      (+evil-collection-init 'minibuffer)))
+      (+evil-collection-init 'minibuffer)
+      (evil-collection-minibuffer-insert)))
 
   ;; HACK Do this ourselves because evil-collection break's `eval-after-load'
   ;;      load order by loading their target plugin before applying keys. This

modules/editor/evil/packages.el

@@ -1,27 +1,29 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; editor/evil/packages.el
 
-(package! evil :pin "8aa6337fa8")
+(package! evil :pin "d243eae8649272799ec3864fde14c1164f036940")
-(package! evil-args :pin "758ad5ae54")
+(package! evil-args :pin "758ad5ae54ad34202064fec192c88151c08cb387")
-(package! evil-easymotion :pin "79c13ed3bc")
+(package! evil-easymotion :pin "f96c2ed38ddc07908db7c3c11bcd6285a3e8c2e9")
-(package! evil-embrace :pin "4379adea03")
+(package! evil-embrace :pin "4379adea032b25e359d01a36301b4a5afdd0d1b7")
-(package! evil-escape :pin "f4e9116bfb")
+(package! evil-escape
-(package! evil-exchange :pin "3030e21ee1")
+  :recipe (:host github :repo "hlissner/evil-escape")
-(package! evil-indent-plus :pin "0c7501e6ef")
+  :pin "819f1ee1cf3f69a1ae920e6004f2c0baeebbe077")
-(package! evil-lion :pin "6b03593f5d")
+(package! evil-exchange :pin "3030e21ee16a42dfce7f7cf86147b778b3f5d8c1")
-(package! evil-nerd-commenter :pin "747e346f11")
+(package! evil-indent-plus :pin "0c7501e6efed661242c3a20e0a6c79a6455c2c40")
+(package! evil-lion :pin "6b03593f5dd6e7c9ca02207f9a73615cf94c93ab")
+(package! evil-nerd-commenter :pin "1bd2de52011c39777a3e8779b14cee2790dc873b")
 (package! evil-numbers
   :recipe (:host github :repo "janpath/evil-numbers")
-  :pin "c2cfdd1eb1")
+  :pin "c2cfdd1eb1f193bea28ee79b191b78309677058a")
-(package! evil-snipe :pin "3ec8adfd49")
+(package! evil-snipe :pin "2ba6353bb9253dbbc4193f1d35403e7dcc1317b1")
-(package! evil-surround :pin "9b0b17f06c")
+(package! evil-surround :pin "9b0b17f06cef9bac81ee4800d121265e54718a17")
-(package! evil-textobj-anyblock :pin "ff00980f06")
+(package! evil-textobj-anyblock :pin "ff00980f0634f95bf2ad9956b615a155ea8743be")
-(package! evil-traces :pin "bc25cae9fa")
+(package! evil-traces :pin "bc25cae9fa5ab0ba1507827f0944f52ce0ca7462")
-(package! evil-visualstar :pin "06c053d8f7")
+(package! evil-visualstar :pin "06c053d8f7381f91c53311b1234872ca96ced752")
-(package! exato :pin "d5daea3017")
+(package! exato :pin "d5daea30176d48e74c9d063ac9bfc240ebeb97d0")
 (package! evil-quick-diff
   :recipe (:host github :repo "rgrinberg/evil-quick-diff")
-  :pin "69c883720b")
+  :pin "69c883720b30a892c63bc89f49d4f0e8b8028908")
 
 ;;
 (when (featurep! +everywhere)
@@ -31,4 +33,4 @@
     (package! neotree)
     (autoload 'neotree-make-executor "neotree" nil nil 'macro))
 
-  (package! evil-collection :pin "493d523c9b"))
+  (package! evil-collection :pin "ba3630476b3927d9d2e3ec75308a28e3a5bd54a8"))

modules/editor/file-templates/packages.el

@@ -1,4 +1,4 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; editor/file-templates/packages.el
 
-(package! yasnippet :pin "ac03c2f192")
+(package! yasnippet :pin "5b1217ab085fab4abeb1118dccb260691b446703")

modules/editor/fold/packages.el

@@ -3,6 +3,6 @@
 
 (package! hideshow :built-in t)
 
-(package! vimish-fold :pin "d3248a41a7")
+(package! vimish-fold :pin "63685239655a151181b9152e45478dad587f86f2")
 (when (featurep! :editor evil)
-  (package! evil-vimish-fold :pin "b6e0e6b91b"))
+  (package! evil-vimish-fold :pin "b6e0e6b91b8cd047e80debef1a536d9d49eef31a"))

modules/editor/format/autoload/format.el

@@ -219,9 +219,11 @@ snippets or single lines."
 is selected)."
   (interactive)
   (call-interactively
-   (if (use-region-p)
+   (if (bound-and-true-p lsp-mode)
-       #'+format/region
+       #'+default/lsp-format-region-or-buffer
-     #'+format/buffer)))
+     (if (use-region-p)
+         #'+format/region
+       #'+format/buffer))))
 
 
 ;;

modules/editor/god/packages.el

@@ -1,4 +1,4 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; editor/god/packages.el
 
-(package! god-mode :pin "1eb6ef3a4f")
+(package! god-mode :pin "1eb6ef3a4f67a805c5d6deb1e3895b6c853707d7")

modules/editor/lispy/packages.el

@@ -1,6 +1,6 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; editor/lispyville/packages.el
 
-(package! lispy :pin "c7e282ae06")
+(package! lispy :pin "cdaa9c70ca39a880163cbbce924bb46cc56b9fa4")
 (when (featurep! :editor evil)
-  (package! lispyville :pin "25a70126ea"))
+  (package! lispyville :pin "25a70126ea807653e0a8c512d4128c90ed673d7a"))

modules/editor/multiple-cursors/packages.el

@@ -3,7 +3,7 @@
 
 (cond
  ((featurep! :editor evil)
-  (package! evil-multiedit :pin "9f271e0e60")
+  (package! evil-multiedit :pin "9f271e0e6048297692f80ed6c5ae8994ac523abc")
-  (package! evil-mc :pin "4d4c0172e4"))
+  (package! evil-mc :pin "4d4c0172e4c7f80acc1d0e73d5fb3e536929b262"))
 
- ((package! multiple-cursors :pin "b880554d04")))
+ ((package! multiple-cursors :pin "b880554d04b8f61165afba7d4de19ac9e39bb7ab")))

modules/editor/objed/packages.el

@@ -1,4 +1,4 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; editor/objed/packages.el
 
-(package! objed :pin "8dc17701d1")
+(package! objed :pin "e89d8dae3b2d4331a4455d2a7b203500537d184d")

modules/editor/parinfer/packages.el

@@ -11,4 +11,4 @@
   ;; separate session:
   (autoload 'evil-define-key "evil-core" nil nil 'macro))
 
-(package! parinfer :pin "eaad857ae4")
+(package! parinfer :pin "eaad857ae4351f72a561ee3dec8943713510003f")

modules/editor/rotate-text/packages.el

@@ -3,4 +3,4 @@
 
 (package! rotate-text
   :recipe (:host github :repo "debug-ito/rotate-text.el")
-  :pin "48f193697d")
+  :pin "48f193697db996855aee1ad2bc99b38c6646fe76")

modules/editor/snippets/config.el

@@ -102,6 +102,6 @@
 us who use yas-minor-mode and enable yasnippet more selectively. This advice
 swaps `yas-global-mode' with `yas-minor-mode'."
     :around '(aya-expand aya-open-line)
-    (cl-letf (((symbol-function #'yas-global-mode) #'yas-minor-mode)
+    (letf! ((#'yas-global-mode #'yas-minor-mode)
-              (yas-global-mode yas-minor-mode))
+            (yas-global-mode yas-minor-mode))
       (apply orig-fn args))))

modules/editor/snippets/packages.el

@@ -1,10 +1,10 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; editor/snippets/packages.el
 
-(package! yasnippet :pin "5b1217ab08")
+(package! yasnippet :pin "5b1217ab085fab4abeb1118dccb260691b446703")
-(package! auto-yasnippet :pin "db9e0dd433")
+(package! auto-yasnippet :pin "db9e0dd4335b2202cd5dac95bbbc87a1032d9bbe")
 (package! doom-snippets
   :recipe (:host github
            :repo "hlissner/doom-snippets"
            :files ("*.el" "*"))
-  :pin "feaedeb550")
+  :pin "422f683adfbec1b01fe00524690b64dc9e702ae0")

modules/editor/word-wrap/config.el

@@ -24,3 +24,7 @@ Otherwise no extra indentation will be used.")
   '(text-mode markdown-mode markdown-view-mode gfm-mode gfm-view-mode rst-mode
     latex-mode LaTeX-mode)
   "Major-modes where `+word-wrap-mode' should not provide extra indentation.")
+
+(when (memq 'visual-line-mode text-mode-hook)
+  (remove-hook 'text-mode-hook #'visual-line-mode)
+  (add-hook 'text-mode-hook #'+word-wrap-mode))

modules/editor/word-wrap/packages.el

@@ -1,4 +1,4 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; editor/word-wrap/packages.el
 
-(package! adaptive-wrap :pin "1810c0ee8d")
+(package! adaptive-wrap :pin "1810c0ee8d827dd502ddeaae5bd759d4811fcbce")

modules/emacs/dired/config.el

@@ -31,20 +31,16 @@
           (setq insert-directory-program gls)
         ;; BSD ls doesn't support --group-directories-first
         (setq args (delete "--group-directories-first" args))))
-    (setq dired-listing-switches (string-join args " ")))
+    (setq dired-listing-switches (string-join args " "))
 
-  (add-hook! 'dired-mode-hook
+    (add-hook! 'dired-mode-hook
-    (defun +dired-disable-gnu-ls-flags-in-tramp-buffers-h ()
+      (defun +dired-disable-gnu-ls-flags-in-tramp-buffers-h ()
-      "Fix #1703: dired over TRAMP displays a blank screen.
+        "Fix #1703: dired over TRAMP displays a blank screen.
 
 This is because there's no guarantee the remote system has GNU ls, which is the
 only variant that supports --group-directories-first."
-      (when (file-remote-p default-directory)
+        (when (file-remote-p default-directory)
-        (setq-local dired-listing-switches
+          (setq-local dired-listing-switches (car args))))))
-                    (string-join
-                     (split-string dired-listing-switches
-                                   "--group-directories-first")
-                     " ")))))
 
   ;; Don't complain about this command being disabled when we use it
   (put 'dired-find-alternate-file 'disabled nil)

modules/emacs/dired/packages.el

@@ -1,12 +1,12 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; emacs/dired/packages.el
 
-(package! diredfl :pin "83567d00af")
+(package! diredfl :pin "83567d00affce66a4e501563eddd0bd436ac48d0")
-(package! dired-git-info :pin "b47f2b0c3a")
+(package! dired-git-info :pin "b47f2b0c3a6cb9b7a62a4ee2605a492e512d40a9")
-(package! diff-hl :pin "2cf8b489f3")
+(package! diff-hl :pin "a625033fb1dde83f6e4c2fc21f632b22ec34b609")
-(package! dired-rsync :pin "bfd5c155be")
+(package! dired-rsync :pin "bfd5c155be1cb6b71c83e5f41116c81b6532b6d5")
 (when (featurep! +ranger)
-  (package! ranger :pin "af6f781a60"))
+  (package! ranger :pin "ae9b3816a6da927cca5beb62c45400103797a2da"))
 (when (featurep! +icons)
-  (package! all-the-icons-dired :pin "816987d339"))
+  (package! all-the-icons-dired :pin "fc2dfa1e9eb8bf1c402a675e7089638d702a27a5"))
-(package! fd-dired :pin "fd4c3f490b")
+(package! fd-dired :pin "001cc95effdd5c4d9974b3f2c40b2ddf1f0e3de2")

modules/emacs/ibuffer/packages.el

@@ -1,5 +1,5 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; emacs/ibuffer/packages.el
 
-(package! ibuffer-projectile :pin "504b0edaa0")
+(package! ibuffer-projectile :pin "504b0edaa0d937ce60ccc8fdf09f2dae0a90fbaf")
-(package! ibuffer-vc :pin "1249c1e30c")
+(package! ibuffer-vc :pin "1249c1e30cf11badfe032ac3b1058f24ba510ace")

modules/emacs/undo/packages.el

@@ -2,6 +2,6 @@
 ;;; emacs/undo/packages.el
 
 (if (featurep! +tree)
-    (package! undo-tree :pin "5b6df03781")
+    (package! undo-tree :pin "5b6df03781495d8a25695d846b0cce496d3d3058")
-  (package! undo-fu :pin "0c34b6747e")
+  (package! undo-fu :pin "0ce9ac36144e80316fff50bfe1bc5dd7e5e7ded6")
-  (package! undo-fu-session :pin "b808ef0cdc"))
+  (package! undo-fu-session :pin "b808ef0cdcdd2eef221c67eda567eed7fcb3d4af"))

modules/emacs/vc/packages.el

@@ -5,7 +5,7 @@
 (package! vc-annotate :built-in t)
 (package! smerge-mode :built-in t)
 
-(package! browse-at-remote :pin "6aecae4b5d")
+(package! browse-at-remote :pin "6aecae4b5d202e582425fc8aa2c9c2b6a4779f25")
-(package! git-timemachine :pin "391eb61050")
+(package! git-timemachine :pin "391eb61050de321101e631fcf373fc70ec6e7700")
-(package! gitconfig-mode :pin "55468314a5")
+(package! gitconfig-mode :pin "55468314a5f6b77d2c96be62c7005ac94545e217")
-(package! gitignore-mode :pin "55468314a5")
+(package! gitignore-mode :pin "55468314a5f6b77d2c96be62c7005ac94545e217")

modules/email/mu4e/config.el

@@ -92,6 +92,9 @@
   ;; Wrap text in messages
   (setq-hook! 'mu4e-view-mode-hook truncate-lines nil)
 
+  ;; Html mails might be better rendered in a browser
+  (add-to-list 'mu4e-view-actions '("View in browser" . mu4e-action-view-in-browser))
+
   (when (fboundp 'imagemagick-register-types)
     (imagemagick-register-types))
 

modules/email/notmuch/packages.el

@@ -1,9 +1,9 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; email/notmuch/packages.el
 
-(package! notmuch :pin "aba7fb375b")
+(package! notmuch :pin "ad9c2e91a012920bebfe70bc472d44678abc3259")
-(package! org-mime :pin "b189976217")
+(package! org-mime :pin "9f8444603806e6baa94b2b67a23aab0ea52fef97")
 (when (featurep! :completion ivy)
-  (package! counsel-notmuch :pin "a4a1562935"))
+  (package! counsel-notmuch :pin "a4a1562935e4180c42524c51609d1283e9be0688"))
 (when (featurep! :completion helm)
-  (package! helm-notmuch :pin "97a01497e0"))
+  (package! helm-notmuch :pin "97a01497e079a7b6505987e9feba6b603bbec288"))

modules/email/wanderlust/packages.el

@@ -4,8 +4,8 @@
 ;; HACK These are wanderlust's dependencies (wanderlust depends on semi, semi
 ;;      depends on flim, flim on apel), but they all have non-standard default
 ;;      branches which straight cannot detect without our help.
-(package! apel :recipe (:branch "apel-wl") :pin "d146ddbf88")
+(package! apel :recipe (:branch "apel-wl") :pin "d146ddbf8818e81d3577d5eee7825d377bec0c73")
-(package! flim :recipe (:branch "flim-1_14-wl") :pin "e4bd54fd7d")
+(package! flim :recipe (:branch "flim-1_14-wl") :pin "f303f2f6c124bc8635add96d3326a2209749437b")
-(package! semi :recipe (:branch "semi-1_14-wl") :pin "16228dc2d1")
+(package! semi :recipe (:branch "semi-1_14-wl") :pin "57a948c5f07e57e78ab3c0e6fd76ffcd591bb4ac")
 
-(package! wanderlust :pin "7a919e422a")
+(package! wanderlust :pin "7af0d582cd48a37469e0606ea35887740d78c8b5")

modules/input/chinese/packages.el

@@ -1,7 +1,7 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; input/chinese/packages.el
 
-(package! pyim :pin "77170724fa")
+(package! pyim :pin "b934273bb33d6be6aea6e20e68930bc5aaf4a48a")
-(package! fcitx :pin "12dc2638dd")
+(package! fcitx :pin "12dc2638ddd15c8f6cfaecb20e1f428ab2bb5624")
-(package! ace-pinyin :pin "8b2e9335b0")
+(package! ace-pinyin :pin "8b2e9335b02486730ea4ceee790130cc5328f9ea")
-(package! pangu-spacing :pin "f92898949b")
+(package! pangu-spacing :pin "f92898949ba3bf991fd229416f3bbb54e9c6c223")

modules/input/japanese/packages.el

@@ -1,7 +1,7 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; input/japanese/packages.el
 
-(package! migemo :pin "f42832c8ac")
+(package! migemo :pin "f42832c8ac462ecbec9a16eb781194f876fba64a")
-(package! avy-migemo :pin "922a6dd82c")
+(package! avy-migemo :pin "922a6dd82c0bfa316b0fbb56a9d4dd4ffa5707e7")
-(package! ddskk :pin "f9a2333ec3")
+(package! ddskk :pin "11d91b4cce988e15d7c5fc4345535c9d7a92d53b")
-(package! pangu-spacing :pin "f92898949b")
+(package! pangu-spacing :pin "f92898949ba3bf991fd229416f3bbb54e9c6c223")

modules/lang/common-lisp/config.el

@@ -73,26 +73,36 @@
             ((message "WARNING: Couldn't find `inferior-lisp-program' (%s)"
                       inferior-lisp-program)))))
 
-  (map! :localleader
+  (map! (:map sly-db-mode-map
-        :map lisp-mode-map
+         :n "gr" #'sly-db-restart-frame)
-        :desc "Sly"          "'" #'sly
+        (:map sly-inspector-mode-map
-        :desc "Sly (ask)"    ";" (λ!! #'sly '-)
+         :n "gr" #'sly-inspector-reinspect
-        :desc "Expand macro" "m" #'macrostep-expand
+         :n "gR" #'sly-inspector-fetch-all
-        (:prefix ("c" . "compile")
+         :n "K"  #'sly-inspector-describe-inspectee)
+        (:map sly-xref-mode-map
+         :n "gr" #'sly-recompile-xref
+         :n "gR" #'sly-recompile-all-xrefs)
+
+        (:localleader
+         :map lisp-mode-map
+         :desc "Sly"          "'" #'sly
+         :desc "Sly (ask)"    ";" (λ!! #'sly '-)
+         :desc "Expand macro" "m" #'macrostep-expand
+         (:prefix ("c" . "compile")
           :desc "Compile file"          "c" #'sly-compile-file
           :desc "Compile/load file"     "C" #'sly-compile-and-load-file
           :desc "Compile toplevel form" "f" #'sly-compile-defun
           :desc "Load file"             "l" #'sly-load-file
           :desc "Remove notes"          "n" #'sly-remove-notes
           :desc "Compile region"        "r" #'sly-compile-region)
-        (:prefix ("e" . "evaluate")
+         (:prefix ("e" . "evaluate")
           :desc "Evaulate buffer"     "b" #'sly-eval-buffer
           :desc "Evaluate last"       "e" #'sly-eval-last-expression
           :desc "Evaluate/print last" "E" #'sly-eval-print-last-expression
           :desc "Evaluate defun"      "f" #'sly-eval-defun
           :desc "Undefine function"   "F" #'sly-undefine-function
           :desc "Evaluate region"     "r" #'sly-eval-region)
-        (:prefix ("g" . "goto")
+         (:prefix ("g" . "goto")
           :desc "Go back"              "b" #'sly-pop-find-definition-stack
           :desc "Go to"                "d" #'sly-edit-definition
           :desc "Go to (other window)" "D" #'sly-edit-definition-other-window
@@ -100,7 +110,7 @@
           :desc "Previous note"        "N" #'sly-previous-note
           :desc "Next sticker"         "s" #'sly-stickers-next-sticker
           :desc "Previous sticker"     "S" #'sly-stickers-prev-sticker)
-        (:prefix ("h" . "help")
+         (:prefix ("h" . "help")
           :desc "Who calls"               "<" #'sly-who-calls
           :desc "Calls who"               ">" #'sly-calls-who
           :desc "Lookup format directive" "~" #'hyperspec-lookup-format
@@ -115,22 +125,22 @@
           :desc "Who references"          "r" #'sly-who-references
           :desc "Who specializes"         "s" #'sly-who-specializes
           :desc "Who sets"                "S" #'sly-who-sets)
-        (:prefix ("r" . "repl")
+         (:prefix ("r" . "repl")
           :desc "Clear REPL"         "c" #'sly-mrepl-clear-repl
           :desc "Quit connection"    "q" #'sly-quit-lisp
           :desc "Restart connection" "r" #'sly-restart-inferior-lisp
           :desc "Sync REPL"          "s" #'sly-mrepl-sync)
-        (:prefix ("s" . "stickers")
+         (:prefix ("s" . "stickers")
           :desc "Toggle breaking stickers" "b" #'sly-stickers-toggle-break-on-stickers
           :desc "Clear defun stickers"     "c" #'sly-stickers-clear-defun-stickers
           :desc "Clear buffer stickers"    "C" #'sly-stickers-clear-buffer-stickers
           :desc "Fetch stickers"           "f" #'sly-stickers-fetch
           :desc "Replay stickers"          "r" #'sly-stickers-replay
           :desc "Add/remove sticker"       "s" #'sly-stickers-dwim)
-        (:prefix ("t" . "trace")
+         (:prefix ("t" . "trace")
           :desc "Toggle"         "t" #'sly-toggle-trace-fdefinition
           :desc "Toggle (fancy)" "T" #'sly-toggle-fancy-trace
-          :desc "Untrace all"    "u" #'sly-untrace-all))
+          :desc "Untrace all"    "u" #'sly-untrace-all)))
 
   (when (featurep! :editor evil +everywhere)
     (add-hook 'sly-mode-hook #'evil-normalize-keymaps)))

modules/lang/dart/packages.el

@@ -4,7 +4,7 @@
 (package! dart-mode :pin "04fcd649f1")
 
 (when (featurep! +lsp)
-  (package! lsp-dart :pin "4cd73b77f4"))
+  (package! lsp-dart :pin "80f8ecaf62"))
 
 (when (featurep! +flutter)
   (package! flutter :pin "293b7225b9")

modules/lang/emacs-lisp/autoload.el

@@ -221,6 +221,67 @@ verbosity when editing a file in `doom-private-dir' or `doom-emacs-dir'."
                  (default-value 'flycheck-emacs-lisp-check-form)
                  ")"))))
 
+;;;###autoload
+(defun +emacs-lisp-truncate-pin ()
+  "Truncates long SHA1 hashes in `package!' :pin's."
+  (save-excursion
+    (goto-char (match-beginning 0))
+    (and (stringp (plist-get (sexp-at-point) :pin))
+         (search-forward ":pin" nil t)
+         (let ((start (re-search-forward "\"[^\"]\\{10\\}" nil t))
+               (finish (and (re-search-forward "\"" (line-end-position) t)
+                            (match-beginning 0))))
+           (when (and start finish)
+             (put-text-property start finish 'display "...")))))
+  nil)
+
+;;;###autoload
+(defun +emacs-lisp-indent-function (indent-point state)
+  "A replacement for `lisp-indent-function'.
+
+Indents plists more sensibly. Adapted from
+https://emacs.stackexchange.com/questions/10230/how-to-indent-keywords-aligned"
+  (let ((normal-indent (current-column))
+        (orig-point (point))
+        ;; TODO Refactor `target' usage (ew!)
+        target)
+    (goto-char (1+ (elt state 1)))
+    (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t)
+    (cond ((and (elt state 2)
+                (or (not (looking-at-p "\\sw\\|\\s_"))
+                    (eq (char-after) ?:)))
+           (unless (> (save-excursion (forward-line 1) (point))
+                      calculate-lisp-indent-last-sexp)
+             (goto-char calculate-lisp-indent-last-sexp)
+             (beginning-of-line)
+             (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t))
+           (backward-prefix-chars)
+           (current-column))
+          ((and (save-excursion
+                  (goto-char indent-point)
+                  (skip-syntax-forward " ")
+                  (not (eq (char-after) ?:)))
+                (save-excursion
+                  (goto-char orig-point)
+                  (and (eq (char-after) ?:)
+                       (eq (char-before) ?\()
+                       (setq target (current-column)))))
+           (save-excursion
+             (move-to-column target t)
+             target))
+          ((let* ((function (buffer-substring (point) (progn (forward-sexp 1) (point))))
+                  (method (or (function-get (intern-soft function) 'lisp-indent-function)
+                              (get (intern-soft function) 'lisp-indent-hook))))
+             (cond ((or (eq method 'defun)
+                        (and (null method)
+                             (> (length function) 3)
+                             (string-match-p "\\`def" function)))
+                    (lisp-indent-defform state indent-point))
+                   ((integerp method)
+                    (lisp-indent-specform method state indent-point normal-indent))
+                   (method
+                    (funcall method indent-point state))))))))
+
 ;;;###autoload
 (defun +emacs-lisp/edebug-instrument-defun-on ()
   "Toggle on instrumentalisation for the function under `defun'."

modules/lang/emacs-lisp/config.el

@@ -43,7 +43,9 @@ This marks a foldable marker for `outline-minor-mode' in elisp buffers.")
     mode-name "Elisp"
     ;; Don't treat autoloads or sexp openers as outline headers, we have
     ;; hideshow for that.
-    outline-regexp +emacs-lisp-outline-regexp)
+    outline-regexp +emacs-lisp-outline-regexp
+    ;; Fixed indenter that intends plists sensibly.
+    lisp-indent-function #'+emacs-lisp-indent-function)
 
   ;; variable-width indentation is superior in elisp
   (add-to-list 'doom-detect-indentation-excluded-modes 'emacs-lisp-mode nil #'eq)
@@ -75,7 +77,9 @@ This marks a foldable marker for `outline-minor-mode' in elisp buffers.")
              ("^;;;###\\(autodef\\|if\\|package\\)[ \n]" (1 font-lock-warning-face t)))
            ;; highlight defined, special variables & functions
            (when +emacs-lisp-enable-extra-fontification
-             `((+emacs-lisp-highlight-vars-and-faces . +emacs-lisp--face)))))
+             `((+emacs-lisp-highlight-vars-and-faces . +emacs-lisp--face)))
+
+           `(("(package!\\_>" (0 (+emacs-lisp-truncate-pin))))))
 
   ;; Recenter window after following definition
   (advice-add #'elisp-def :after #'doom-recenter-a)

modules/lang/java/+lsp.el

@@ -3,11 +3,11 @@
 
 (use-package! lsp-java
   :after lsp-clients
-  :hook (java-mode-local-vars . lsp!)
   :preface
   (setq lsp-java-server-install-dir (concat doom-etc-dir "eclipse.jdt.ls/server/")
-        lsp-java-workspace-dir (concat doom-etc-dir "java-workspace"))
+        lsp-java-workspace-dir (concat doom-etc-dir "java-workspace")
+        lsp-jt-root (concat doom-etc-dir "eclipse.jdt.ls/server/java-test/server/"))
+  (add-hook! java-mode-local-vars #'lsp!)
   :config
   ;; TODO keybinds
-  ;; TODO treemacs integration (?)
   )

modules/lang/java/README.org

@@ -0,0 +1,114 @@
+#+TITLE:   lang/java
+#+DATE:    January 16, 2017
+#+SINCE:   v1.3
+#+STARTUP: inlineimages
+
+* Table of Contents :TOC_3:noexport:
+- [[#description][Description]]
+  - [[#module-flags][Module Flags]]
+- [[#prerequisites][Prerequisites]]
+  - [[#openjdk-11][OpenJDK 11]]
+    - [[#ubuntu][Ubuntu]]
+    - [[#fedora][Fedora]]
+  - [[#oracle-jdk-11][Oracle JDK 11]]
+    - [[#ubuntu-1][Ubuntu]]
+    - [[#fedora-1][Fedora]]
+- [[#features][Features]]
+  - [[#lsp-features][=+lsp= features]]
+  - [[#meghanada-features][=+meghanada= features]]
+- [[#configuration][Configuration]]
+
+* Description
+This module adds [[https://www.java.com][java]] support to Doom Emacs, including =android-mode= and
+=groovy-mode=.
+
+** Module Flags
++ =+lsp= Enables integration for the eclipse.jdt.ls LSP server.
++ =+meghanada= Enables the [[https://github.com/mopemope/meghanada-emacs/tree/master][meghanada-mode]]
+
+The =+lsp= and =+meghanada= packages are mutually exclusive and do not work
+together. At the time of writing the =+meghanada= is already configured whereas
+=+lsp= needs to manual configuring.
+
+* Prerequisites
+This module requires the Java SDK.
+
+** OpenJDK 11
+*** Ubuntu
+#+BEGIN_SRC sh
+sudo apt-get install openjdk-11-jdk-headless
+#+END_SRC
+*** Fedora
+#+BEGIN_SRC sh
+sudo dnf install java-11-openjdk
+#+END_SRC
+
+** Oracle JDK 11
+*** Ubuntu
+#+BEGIN_SRC sh
+sudo add-apt-repository ppa:linuxuprising/java
+sudo apt update
+sudo apt install oracle-java11-installer
+sudo apt install oracle-java11-set-default
+#+END_SRC
+*** Fedora
+#+BEGIN_SRC sh
+curl -O https://download.java.net/java/GA/jdk11/9/GPL/openjdk-11.0.2_linux-x64_bin.tar.gz
+tar zxvf openjdk-11.0.2_linux-x64_bin.tar.gz
+sudo mv jdk-11.0.2/ /usr/local/
+#+END_SRC
+
+Open =/etc/profile.d/jdk11.sh= as root and add
+
+#+BEGIN_SRC sh
+export JAVA_HOME=/usr/local/jdk-11.0.2
+export PATH=$PATH:$JAVA_HOME/bin
+#+END_SRC
+
+Save the file and source the file
+
+#+BEGIN_SRC sh
+source /etc/profile.d/jdk11.sh
+java -version
+#+END_SRC
+
+* Features
+** =+lsp= features
+According to [[https://github.com/emacs-lsp/lsp-java]] it adds
+
++ As you type reporting of parsing and compilation errors (via flycheck/[[https://github.com/emacs-lsp/lsp-ui][lsp-ui]])
++ Code completion - using [[https://github.com/tigersoldier/company-lsp][company-lsp]] or builtin complete-at-point
++ Javadoc hovers - using [[https://github.com/emacs-lsp/lsp-ui][lsp-ui]]
++ Code actions - using [[https://github.com/emacs-lsp/lsp-ui][lsp-ui]]
++ Code outline - using builtin [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Imenu.html][imenu]]
++ Code navigation - using builtin [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Xref.html][xref]]
++ Code lens (references/implementations) - using builtin [[https://www.gnu.org/software/emacs/manual/html_node/emacs/Xref.html][xref]]
++ Highlights
++ Code formatting
++ Maven pom.xml project support
++ Limited Gradle support
++ Visual debugger - [[https://github.com/yyoncho/dap-mode/][dap-mode]]
++ Test runner - [[https://github.com/yyoncho/dap-mode/][dap-mode]]
++ Project explorer integration - [[https://github.com/Alexander-Miller/treemacs][treemacs]]
++ Integration with [[https://start.spring.io/][Spring Initializr]]
+
+** =+meghanada= features
+According to [[https://github.com/mopemope/meghanada-emacs/]] it adds
+
++ Auto-update server module
++ [[https://gradle.org/][Gradle]] and [[http://maven.apache.org/][Maven]] and Eclipse project support
++ No need build tool's plugin
++ Run build tool task
++ Compile your project
++ Syntax check and analyze java source (=flycheck-meghanada=)
++ Support =Generic Types=
++ Code completion with [[http://company-mode.github.io/][company-mode]] (=company-meghanada=)
++ Optimize import and sort
++ Jump declaration
++ Run [[http://www.junit.org/][JUnit]] test (include test runner)
++ Diagnostic reporting with [[http://flycheck.org/][flycheck]] (=flycheck-meghanada=)
++ Show symbol's type info with =el-doc=
++ Search references
++ Full-featured text search
+
+* TODO Configuration

modules/lang/javascript/config.el

@@ -135,7 +135,8 @@
 
 (add-hook! '(js2-mode-local-vars-hook
              typescript-mode-local-vars-hook
-             web-mode-local-vars-hook)
+             web-mode-local-vars-hook
+             rjsx-mode-local-vars-hook)
   (defun +javascript-init-lsp-or-tide-maybe-h ()
     "Start `lsp' or `tide' in the current buffer.
 
@@ -152,7 +153,7 @@ to tide."
         (if (not buffer-file-name)
             ;; necessary because `tide-setup' and `lsp' will error if not a
             ;; file-visiting buffer
-            (add-hook 'after-save-hook #'+javascript-init-tide-or-lsp-maybe-h nil 'local)
+            (add-hook 'after-save-hook #'+javascript-init-lsp-or-tide-maybe-h nil 'local)
           (or (and (featurep! +lsp) (lsp!))
               ;; fall back to tide
               (if (executable-find "node")
@@ -160,7 +161,7 @@ to tide."
                        (progn (tide-setup) tide-mode))
                 (ignore
                  (doom-log "Couldn't start tide because 'node' is missing"))))
-          (remove-hook 'after-save-hook #'+javascript-init-tide-or-lsp-maybe-h 'local))))))
+          (remove-hook 'after-save-hook #'+javascript-init-lsp-or-tide-maybe-h 'local))))))
 
 
 (use-package! tide

modules/lang/javascript/packages.el

@@ -2,21 +2,21 @@
 ;;; lang/javascript/packages.el
 
 ;; Major modes
-(package! coffee-mode :pin "35a41c7d82")
+(package! coffee-mode :pin "35a41c7d8233eac0b267d9593e67fb8b6235e134")
-(package! js2-mode :pin "fe53814dc2")
+(package! js2-mode :pin "fe53814dc2a0db2e95ac06083362e43923bf83fc")
-(package! rjsx-mode :pin "0061587a06")
+(package! rjsx-mode :pin "0061587a06cdc2579a8d0e90863498d96bf982d8")
-(package! typescript-mode :pin "102587e458")
+(package! typescript-mode :pin "102587e458d48ece6335cd708300647f22ec8b8d")
 
 ;; Tools
-(package! js2-refactor :pin "d4c40b5fc8")
+(package! js2-refactor :pin "d4c40b5fc86d3edd7c6a7d83ac86483ee1cb7a28")
-(package! npm-mode :pin "3ee7c0bad5")
+(package! npm-mode :pin "3ee7c0bad5b7a041d4739ef3aaa06a3dc764e5eb")
-(package! add-node-modules-path :pin "f31e69ccb6")
+(package! add-node-modules-path :pin "f31e69ccb681f882aebb806ce6e9478e3ac39708")
 
 ;; Eval
-(package! nodejs-repl :pin "6fad7d764f")
+(package! nodejs-repl :pin "6fad7d764fa0d818ba497450bd722ae10cb8efed")
-(package! skewer-mode :pin "e5bed35193")
+(package! skewer-mode :pin "e5bed351939c92a1f788f78398583c2f83f1bb3c")
 
 ;; Programming environment
-(package! tide :pin "3b45610faa")
+(package! tide :pin "3b45610faaab33bc53ae2d44e1e573f19f35a74a")
 (when (featurep! :tools lookup)
-  (package! xref-js2 :pin "6f1ed5dae0"))
+  (package! xref-js2 :pin "6f1ed5dae0c2485416196a51f2fa92f32e4b8262"))

modules/lang/markdown/config.el

@@ -27,11 +27,17 @@ capture, the end position, and the output buffer.")
         markdown-gfm-additional-languages '("sh")
         markdown-make-gfm-checkboxes-buttons t
 
-        ;; Preview/compilation defaults
+        ;; `+markdown-compile' offers support for many transpilers (see
+        ;; `+markdown-compile-functions'), which it tries until one succeeds.
         markdown-command #'+markdown-compile
+        ;; This is set to `nil' by default, which causes a wrong-type-arg error
+        ;; when you use `markdown-open'. These are more sensible defaults.
         markdown-open-command
         (cond (IS-MAC "open")
               (IS-LINUX "xdg-open"))
+
+        ;; A sensible and simple default preamble for markdown exports that
+        ;; takes after the github asthetic (plus highlightjs syntax coloring).
         markdown-content-type "application/xhtml+xml"
         markdown-css-paths
         '("https://cdn.jsdelivr.net/npm/github-markdown-css/github-markdown.min.css"
@@ -57,6 +63,7 @@ capture, the end position, and the output buffer.")
   (sp-local-pair '(markdown-mode gfm-mode) "`" "`"
                  :unless '(:add sp-point-before-word-p sp-point-before-same-p))
 
+  ;; Don't trigger autofill in code blocks (see `auto-fill-mode')
   (setq-hook! 'markdown-mode-hook
     fill-nobreak-predicate (cons #'markdown-code-block-at-point-p
                                  fill-nobreak-predicate))

modules/lang/markdown/packages.el

@@ -1,13 +1,14 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; lang/markdown/packages.el
 
-(package! markdown-mode :pin "e9dff50d57")
+(package! markdown-mode :pin "c927a114b1b23cf7538181d62fd14679cce7fa25")
-(package! markdown-toc :pin "7038f4f6d5")
+(package! markdown-toc :pin "eda9650a1bf0015e52e9678bd92b0a8beb1d7d71")
-(package! edit-indirect :pin "935ded353b")
+(package! edit-indirect :pin "935ded353b9ed3da67bc61abf245c21b58d88864")
 
 (when (featurep! +grip)
-  (package! grip-mode :pin "9615c47747"))
+  (package! grip-mode :pin "9615c4774727a719d38313a679d70f2a2c6aca68"))
 
 (when (featurep! :editor evil +everywhere)
   (package! evil-markdown
-    :recipe (:host github :repo "Somelauw/evil-markdown") :pin "46cd81b379"))
+    :recipe (:host github :repo "Somelauw/evil-markdown")
+    :pin "46cd81b37991c4325fc24015a610f832b0ff995d"))

modules/lang/nix/packages.el

@@ -1,11 +1,11 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; lang/nix/packages.el
 
-(package! nix-mode :pin "5b5961780f")
+(package! nix-mode :pin "5b5961780f3b1c1b62453d2087f775298980f10d")
-(package! nix-update :pin "fc6c39c2da")
+(package! nix-update :pin "fc6c39c2da3fcfa62f4796816c084a6389c8b6e7")
 
 (when (featurep! :completion company)
-  (package! company-nixos-options :pin "977b9a505f"))
+  (package! company-nixos-options :pin "977b9a505ffc8b33b70ec7742f90e469b3168297"))
 
 (when (featurep! :completion helm)
-  (package! helm-nixos-options :pin "977b9a505f"))
+  (package! helm-nixos-options :pin "977b9a505ffc8b33b70ec7742f90e469b3168297"))

modules/lang/org/autoload/org-capture.el

@@ -50,7 +50,7 @@ you're done. This can be called from an external shell script."
     (with-selected-frame frame
       (require 'org-capture)
       (condition-case ex
-          (cl-letf (((symbol-function #'pop-to-buffer) #'switch-to-buffer))
+          (letf! ((#'pop-to-buffer #'switch-to-buffer))
             (switch-to-buffer (doom-fallback-buffer))
             (let ((org-capture-initial initial-input)
                   org-capture-entry)

modules/lang/org/config.el

@@ -4,6 +4,7 @@
   '((cpp . C)
     (C++ . C)
     (D . C)
+    (elisp . emacs-lisp)
     (sh . shell)
     (bash . shell)
     (matlab . octave)
@@ -94,14 +95,11 @@ Is relative to `org-directory', unless it is absolute. Is used in Doom's default
         org-entities-user
         '(("flat"  "\\flat" nil "" "" "266D" "♭")
           ("sharp" "\\sharp" nil "" "" "266F" "♯"))
-        org-fontify-done-headline t
         org-fontify-quote-and-verse-blocks t
         org-fontify-whole-heading-line t
         org-footnote-auto-label 'plain
         org-hide-leading-stars t
-        org-hide-leading-stars-before-indent-mode t
         org-image-actual-width nil
-        org-list-description-max-indent 4
         org-priority-faces
         '((?A . error)
           (?B . warning)
@@ -120,9 +118,6 @@ Is relative to `org-directory', unless it is absolute. Is used in Doom's default
         org-refile-use-outline-path 'file
         org-outline-path-complete-in-steps nil)
 
-  ;; Fontify latex blocks and entities, but not natively -- that's too slow
-  (setq org-highlight-latex-and-related '(latex script entities))
-
   (plist-put org-format-latex-options :scale 1.5) ; larger previews
   (add-hook! 'doom-load-theme-hook
     (defun +org-refresh-latex-background-h ()
@@ -168,12 +163,6 @@ This forces it to read the background before rendering."
           ("HOLD" . +org-todo-onhold)
           ("PROJ" . +org-todo-project)))
 
-  (after! org-eldoc
-    ;; HACK Fix #2972: infinite recursion when eldoc kicks in in an 'org' src
-    ;;      block.
-    ;; TODO Should be reported upstream!
-    (puthash "org" "ignore" org-eldoc-local-functions-cache))
-
   (defadvice! +org-display-link-in-eldoc-a (&rest args)
     "Display full link in minibuffer when cursor/mouse is over it."
     :before-until #'org-eldoc-documentation-function
@@ -501,6 +490,13 @@ eldoc string."
                           nil 'face `(:foreground ,(face-foreground face nil t) :weight bold)))
              width prefix separator))
 
+  (after! org-eldoc
+    ;; HACK Fix #2972: infinite recursion when eldoc kicks in in 'org' or
+    ;;      'python' src blocks.
+    ;; TODO Should be reported upstream!
+    (puthash "org" #'ignore org-eldoc-local-functions-cache)
+    (puthash "python" #'python-eldoc-function org-eldoc-local-functions-cache))
+
   (defun +org--restart-mode-h ()
     "Restart `org-mode', but only once."
     (quiet! (org-mode-restart))
@@ -541,11 +537,9 @@ current workspace (and clean them up)."
   ;;      upstream (if ever).
   (defadvice! +org--fix-inline-images-for-imagemagick-users-a (orig-fn &rest args)
     :around #'org-display-inline-images
-    (cl-letf* ((old-create-image (symbol-function #'create-image))
+    (letf! (defun create-image (file-or-data &optional type data-p &rest props)
-               ((symbol-function #'create-image)
+             (let ((type (if (plist-get props :width) type)))
-                (lambda (file-or-data &optional type data-p &rest props)
+               (apply create-image file-or-data type data-p props)))
-                  (let ((type (if (plist-get props :width) type)))
-                    (apply old-create-image file-or-data type data-p props)))))
       (apply orig-fn args)))
 
   (defadvice! +org--fix-inconsistent-uuidgen-case-a (uuid)
@@ -797,6 +791,7 @@ compelling reason, so..."
   :config
   ;; Make leading stars truly invisible, by rendering them as spaces!
   (setq org-superstar-leading-bullet ?\s
+        org-superstar-leading-fallback ?\s
         org-hide-leading-stars nil)
   ;; Don't do anything special for item bullets or TODOs by default; these slow
   ;; down larger org buffers.
@@ -813,11 +808,14 @@ compelling reason, so..."
 (use-package! org-crypt ; built-in
   :commands org-encrypt-entries org-encrypt-entry org-decrypt-entries org-decrypt-entry
   :hook (org-reveal-start . org-decrypt-entry)
-  :config
+  :preface
-  (add-hook! 'org-mode-hook
+  ;; org-crypt falls back to CRYPTKEY property then `epa-file-encrypt-to', which
-    (add-hook 'before-save-hook 'org-encrypt-entries nil t))
+  ;; is a better default than the empty string `org-crypt-key' defaults to.
-  (add-to-list 'org-tags-exclude-from-inheritance "crypt")
+  (defvar org-crypt-key nil)
-  (setq org-crypt-key user-mail-address))
+  (after! org
+    (add-to-list 'org-tags-exclude-from-inheritance "crypt")
+    (add-hook! 'org-mode-hook
+      (add-hook 'before-save-hook 'org-encrypt-entries nil t))))
 
 
 (use-package! org-clock ; built-in

modules/lang/org/contrib/present.el

@@ -41,20 +41,19 @@
   (defadvice! +org-present--narrow-to-subtree-a (orig-fn &rest args)
     "Narrow to the target subtree when you start the presentation."
     :around #'org-tree-slide--display-tree-with-narrow
-    (cl-letf (((symbol-function #'org-narrow-to-subtree)
+    (letf! ((defun org-narrow-to-subtree ()
-               (lambda ()
+              (save-excursion
-                 (save-excursion
+                (save-match-data
-                   (save-match-data
+                  (org-with-limited-levels
-                     (org-with-limited-levels
+                   (narrow-to-region
-                      (narrow-to-region
+                    (progn
-                       (progn
+                      (when (org-before-first-heading-p)
-                         (when (org-before-first-heading-p)
+                        (org-next-visible-heading 1))
-                           (org-next-visible-heading 1))
+                      (ignore-errors (org-up-heading-all 99))
-                         (ignore-errors (org-up-heading-all 99))
+                      (forward-line 1)
-                         (forward-line 1)
+                      (point))
-                         (point))
+                    (progn (org-end-of-subtree t t)
-                       (progn (org-end-of-subtree t t)
+                           (when (and (org-at-heading-p) (not (eobp)))
-                              (when (and (org-at-heading-p) (not (eobp)))
+                             (backward-char 1))
-                                (backward-char 1))
+                           (point))))))))
-                              (point)))))))))
       (apply orig-fn args))))

modules/lang/org/contrib/roam.el

@@ -48,20 +48,7 @@
         (cond ((featurep! :completion helm) 'helm)
               ((featurep! :completion ivy) 'ivy)
               ((featurep! :completion ido) 'ido)
-              ('default))
+              ('default)))
-        org-roam-completion-fuzzy-match
-        (or (featurep! :completion helm +fuzzy)
-            (featurep! :completion ivy +fuzzy)))
-
-  ;; HACK On first invocation, `org-roam-db-build-cache' builds the cache with a
-  ;;      list of unresolved file paths. If those are symlinks, you will later
-  ;;      end up with duplicate entries in your roam DB (e.g. after
-  ;;      `org-roam-capture'ing to an existing file).
-  ;; REVIEW When jethrokuan/org-roam#518 is merged
-  (defadvice! +org-roam-resolve-symlinks-a (args)
-    :filter-args #'org-roam--list-files
-    (setcar args (file-truename (car args)))
-    args)
 
   ;; Normally, the org-roam buffer doesn't open until you explicitly call
   ;; `org-roam'. If `+org-roam-open-buffer-on-find-file' is non-nil, the

modules/lang/org/packages.el

@@ -27,84 +27,84 @@
   :recipe (:host github
            :repo "emacs-straight/org-mode"
            :files ("*.el" "lisp/*.el" "contrib/lisp/*.el"))
-  :pin "31068373dc")
+  :pin "e5eda0beeb3b6b0666550091bcc0df066d52c008")
 ;; ...And prevent other packages from pulling org; org-plus-contrib satisfies
 ;; the dependency already: https://github.com/raxod502/straight.el/issues/352
 (package! org :recipe (:local-repo nil))
 
 (package! avy)
-(package! htmlize :pin "86f22f211e")
+(package! htmlize :pin "86f22f211e9230857197c42a9823d3f05381deed")
-(package! org-superstar :pin "09ddc28383")
+(package! org-superstar :pin "09ddc28383d363a4b353348a433e24535b4af0e3")
 (package! org-yt
   :recipe (:host github :repo "TobiasZawada/org-yt")
-  :pin "40cc1ac76d")
+  :pin "40cc1ac76d741055cbefa13860d9f070a7ade001")
-(package! ox-clip :pin "bd36f9fb4e")
+(package! ox-clip :pin "bd36f9fb4e3b1b9e8686b993b02ccd780ff75a96")
-(package! toc-org :pin "5deaec41ed")
+(package! toc-org :pin "5deaec41ed0e5c51715737d7f74c5ae1b3c00387")
-(package! org-cliplink :pin "82402cae7e")
+(package! org-cliplink :pin "82402cae7e118d67de7328417fd018a18f95fac2")
 
 (when (featurep! :editor evil +everywhere)
   (package! evil-org
     :recipe (:host github :repo "hlissner/evil-org-mode")
-    :pin "9cf661af8f"))
+    :pin "9cf661af8ff8ea768ef1e55045be14d0468a90f5"))
 (when (featurep! :tools pdf)
-  (package! org-pdftools :pin "8cc15bb801"))
+  (package! org-pdftools :pin "8cc15bb8014ed1f047eecc0abd8bf447f86c0505"))
 (when (featurep! :tools magit)
-  (package! orgit :pin "e147f05577"))
+  (package! orgit :pin "e147f055772cc934fe1f1d8619059badeb647c93"))
 (when (featurep! +brain)
-  (package! org-brain :pin "7ffbf6816a"))
+  (package! org-brain :pin "ae7fe0f628bd093526786ece6917f7a4310e5e4d"))
 (when (featurep! +dragndrop)
-  (package! org-download :pin "46417e2bd3"))
+  (package! org-download :pin "48d3952ad8ebc5ef5a6a77b8c6a4a0da61653036"))
 (when (featurep! +gnuplot)
-  (package! gnuplot :pin "f0001c3001")
+  (package! gnuplot :pin "f0001c30010b2899e36d7d89046322467e923088")
-  (package! gnuplot-mode :pin "601f639298"))
+  (package! gnuplot-mode :pin "601f6392986f0cba332c87678d31ae0d0a496ce7"))
 (when (featurep! +ipython) ; DEPRECATED
-  (package! ob-ipython :pin "7147455230"))
+  (package! ob-ipython :pin "7147455230841744fb5b95dcbe03320313a77124"))
 (when (featurep! +jupyter)
-  (package! jupyter :pin "785edbbff6"))
+  (package! jupyter :pin "785edbbff65abb0c929dc2fbd8b8305c77fd529e"))
 (when (featurep! +journal)
-  (package! org-journal :pin "8bf06b28d6"))
+  (package! org-journal :pin "8bf06b28d6f14f52d4968123e2b4b91930c8f947"))
 (when (featurep! +noter)
-  (package! org-noter :pin "9ead81d42d"))
+  (package! org-noter :pin "9ead81d42dd4dd5074782d239b2efddf9b8b7b3d"))
 (when (featurep! +pomodoro)
-  (package! org-pomodoro :pin "aa07c11318"))
+  (package! org-pomodoro :pin "aa07c11318f91219336197e62c47bc7a3d090479"))
 (when (featurep! +present)
   (package! centered-window
     :recipe (:host github :repo "anler/centered-window-mode")
-    :pin "24f7c5be9d")
+    :pin "f50859941ab5c7cbeaee410f2d38716252b552ac")
-  (package! org-tree-slide :pin "7bf09a02bd")
+  (package! org-tree-slide :pin "7bf09a02bd2d8f1ccfcb5209bfb18fbe02d1f44e")
-  (package! org-re-reveal :pin "61549f4c00"))
+  (package! org-re-reveal :pin "61549f4c00284a30e34caa3d76001b233ea5d2ad"))
 (when (featurep! +roam)
-  (package! org-roam :pin "963692f353")
+  (package! org-roam :pin "e698ed7f5378106da8a8fec4537658392157657c")
   (when (featurep! :completion company)
-    (package! company-org-roam :pin "0913d86f16")))
+    (package! company-org-roam :pin "0913d86f167164e18831206e611f44bb8e7297e3")))
 
 ;;; Babel
-(package! ob-async :pin "80a30b96a0")
+(package! ob-async :pin "80a30b96a007d419ece12c976a81804ede340311")
 (when (featurep! :lang crystal)
-  (package! ob-crystal :pin "d84c1adee4"))
+  (package! ob-crystal :pin "d84c1adee4b269cdba06a97caedb8071561a09af"))
 (when (featurep! :lang go)
-  (package! ob-go :pin "2067ed55f4"))
+  (package! ob-go :pin "2067ed55f4c1d33a43cb3f6948609d240a8915f5"))
 (when (featurep! :lang hy)
-  (package! ob-hy :pin "a42ecaf440"))
+  (package! ob-hy :pin "a42ecaf440adc03e279afe43ee5ef6093ddd542a"))
 (when (featurep! :lang nim)
-  (package! ob-nim :pin "bf1642cb93"))
+  (package! ob-nim :pin "bf1642cb93f0a898804dc13fd9408d2964403bd2"))
 (when (featurep! :lang racket)
   (package! ob-racket
     :recipe (:host github :repo "DEADB17/ob-racket")
-    :pin "d8fd51bddb"))
+    :pin "d8fd51bddb019b0eb68755255f88fc800cfe03cb"))
 (when (featurep! :lang rest)
-  (package! ob-restclient :pin "f7449b2068"))
+  (package! ob-restclient :pin "f7449b2068498fe9d8ab9589e0a638148861533f"))
 (when (featurep! :lang rust)
-  (package! ob-rust :pin "6a82587598"))
+  (package! ob-rust :pin "6a82587598cd097e9642be916243c31f1231b24a"))
 (when (featurep! :lang scala)
-  (package! ob-ammonite :pin "39937dff39"))
+  (package! ob-ammonite :pin "39937dff395e70aff76a4224fa49cf2ec6c57cca"))
 
 ;;; Export
 (when (featurep! +pandoc)
-  (package! ox-pandoc :pin "aa37dc7e94"))
+  (package! ox-pandoc :pin "aa37dc7e94213d4ebedb85c384c1ba35007da18e"))
 (when (featurep! +hugo)
   (package! ox-hugo
     :recipe (:host github :repo "kaushalmodi/ox-hugo" :nonrecursive t)
-    :pin "5106b430a1"))
+    :pin "8f36181977377383cb54803651d93b24e370122d"))
 (when (featurep! :lang rst)
-  (package! ox-rst :pin "9158bfd180"))
+  (package! ox-rst :pin "9158bfd18096c559e0a225ae62ab683f1c98a547"))

modules/lang/perl/config.el

@@ -2,9 +2,15 @@
 
 ;; There's also `perl-mode' for perl < 6, which is already set up.
 
-(use-package! perl6-detect)
+
+(use-package! raku-mode
+  :defer t
+  :init
+  (defalias 'perl6-mode #'raku-mode)
+  :config
+  (set-repl-handler! 'raku-mode #'run-raku))
 
 
-(use-package! flycheck-perl6
+(use-package! flycheck-raku
   :when (featurep! :checkers syntax)
-  :after perl6-mode)
+  :after raku-mode)

modules/lang/perl/packages.el

@@ -1,7 +1,9 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; lang/perl/packages.el
 
-(package! perl6-mode :pin "88de065795")
+(package! raku-mode :pin "d474216840251dc0efe4f4aa4f5c5f66ac26fa74")
 
 (when (featurep! :checkers syntax)
-  (package! flycheck-perl6 :pin "b804702305"))
+  (package! flycheck-raku
+    :recipe (:host github :repo "widefox/flycheck-raku")
+    :pin "046f35abe0c61967157e151126e4dd7ec5d1c004"))

modules/lang/racket/packages.el

@@ -1,4 +1,4 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; lang/racket/packages.el
 
-(package! racket-mode :pin "202cc1b784")
+(package! racket-mode :pin "8f3b214a5ea06e6a2a9492e7d20b19badd0c3bdf")

modules/lang/ruby/config.el

@@ -22,6 +22,7 @@
     (add-hook 'ruby-mode-local-vars-hook #'lsp!))
 
   (after! inf-ruby
+    (add-hook 'inf-ruby-mode-hook #'doom-mark-buffer-as-real-h)
     ;; switch to inf-ruby from compile if we detect a breakpoint has been hit
     (add-hook 'compilation-filter-hook #'inf-ruby-auto-enter))
 
@@ -173,6 +174,7 @@
 (use-package! projectile-rails
   :when (featurep! +rails)
   :hook ((ruby-mode inf-ruby-mode projectile-rails-server-mode) . projectile-rails-mode)
+  :hook (projectile-rails-server-mode . doom-mark-buffer-as-real-h)
   :init
   (setq inf-ruby-console-environment "development")
   (when (featurep! :lang web)

modules/lang/rust/packages.el

@@ -1,6 +1,6 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; lang/rust/packages.el
 
-(package! rustic :pin "61032eacf0")
+(package! rustic :pin "32a962ab2d3f87bde0e12c4e8975fe73d8ba8579")
 (unless (featurep! +lsp)
-  (package! racer :pin "a0bdf778f0"))
+  (package! racer :pin "a0bdf778f01e8c4b8a92591447257422ac0b455b"))

modules/lang/scheme/autoload.el

@@ -15,15 +15,18 @@ lists properly and names starting with 'default'."
     (if (and (elt state 2)
              ;; NOTE looking-at -> looking-at-p
              (not (looking-at-p "\\sw\\|\\s_")))
-        (unless (> (save-excursion (forward-line 1) (point))
+        (progn
-                   calculate-lisp-indent-last-sexp)
+          ;; NOTE (if (not ...) (progn ...)) -> (unless ... ...)
-          (goto-char calculate-lisp-indent-last-sexp)
+          (unless (> (save-excursion (forward-line 1) (point))
-          (beginning-of-line)
+                     calculate-lisp-indent-last-sexp)
-          (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t))
+            (goto-char calculate-lisp-indent-last-sexp)
-      (backward-prefix-chars)
+            (beginning-of-line)
-      (current-column)
+            (parse-partial-sexp (point) calculate-lisp-indent-last-sexp 0 t))
+          (backward-prefix-chars)
+          (current-column))
       (let* ((function (buffer-substring
                         (point) (progn (forward-sexp 1) (point))))
+             ;; NOTE let -> let* & moved `method' def into let bindings
              (method (or (get (intern-soft function) 'scheme-indent-function)
                          (get (intern-soft function) 'scheme-indent-hook))))
         (cond ((or (eq method 'defun)
@@ -32,11 +35,12 @@ lists properly and names starting with 'default'."
                         ;; NOTE string-match -> string-match-p
                         ;; NOTE The original regexp is "\\`def" but it will mess
                         ;;      indentation with such names as 'default-...'.
-                        (string-match-p "\\`define" function)))
+                        (string-match-p "\\`def" function)))
                (lisp-indent-defform state indent-point))
               ;; NOTE Added this clause to handle alignment of keyword symbols
               ((and (null method)
                     (> (length function) 1)
+                    ;; NOTE string-match -> string-match-p
                     (string-match-p "\\`:" function))
                (let ((lisp-body-indent 1))
                  (lisp-indent-defform state indent-point)))

modules/lang/sh/packages.el

@@ -2,7 +2,7 @@
 ;;; lang/sh/packages.el
 
 (when (featurep! :completion company)
-  (package! company-shell :pin "52f3bf26b7"))
+  (package! company-shell :pin "52f3bf26b74adc30a275f5f4290a1fc72a6876ff"))
 
 (when (featurep! +fish)
-  (package! fish-mode :pin "db257db810"))
+  (package! fish-mode :pin "db257db81058b0b12f788c324c264cc59b9a5bf4"))

modules/lang/solidity/packages.el

@@ -1,6 +1,6 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; lang/solidity/packages.el
 
-(package! solidity-mode :pin "b190993dcb")
+(package! solidity-mode :pin "022b3159832384a7dcdc2168809e698600826047")
-(package! company-solidity :pin "b190993dcb")
+(package! company-solidity)
-(package! solidity-flycheck :pin "b190993dcb")
+(package! solidity-flycheck)

modules/lang/swift/packages.el

@@ -1,11 +1,11 @@
 ;; -*- no-byte-compile: t; -*-
 ;;; lang/swift/packages.el
 
-(package! swift-mode :pin "1268425311")
+(package! swift-mode :pin "2ab9ea1784a12a482ed9e3fb284b7a7658f40fff")
 
 (if (featurep! +lsp)
-    (package! lsp-sourcekit :pin "04d75b6a0b")
+    (package! lsp-sourcekit :pin "04d75b6a0be5894fea4a55fec0b2ccedf5b3be58")
   (when (featurep! :completion company)
-    (package! company-sourcekit :pin "abf9bc5a01"))
+    (package! company-sourcekit :pin "abf9bc5a0102eb666d3aa6d6bf22f6efcc852781"))
   (when (featurep! :checkers syntax)
-    (package! flycheck-swift :pin "4c5ad40125")))
+    (package! flycheck-swift :pin "4c5ad401252400a78da395fd56a71e67ff8c2761")))

modules/lang/web/+html.el

@@ -162,4 +162,6 @@
 
 
 (when (featurep! +lsp)
-  (add-hook! '(html-mode-hook web-mode-hook) #'lsp!))
+  (add-hook! '(html-mode-local-vars-hook
+               web-mode-local-vars-hook)
+             #'lsp!))

modules/lang/web/packages.el

@@ -2,23 +2,23 @@
 ;;; lang/web/packages.el
 
 ;; +html.el
-(package! emmet-mode :pin "1acb821e01")
+(package! emmet-mode :pin "1acb821e0142136344ccf40c1e5fb664d7db2e70")
-(package! haml-mode :pin "bf5b6c11b1")
+(package! haml-mode :pin "bf5b6c11b1206759d2b28af48765e04882dd1fc4")
-(package! pug-mode :pin "685fd3414d")
+(package! pug-mode :pin "685fd3414d89736bf232f5d1a6bed9e0353b98fe")
-(package! slim-mode :pin "3636d18ab1")
+(package! slim-mode :pin "3636d18ab1c8b316eea71c4732eb44743e2ded87")
-(when (package! web-mode :pin "b0bb4ab82b")
+(when (package! web-mode :pin "6774c596a9b3988989d3bc96b6194e6f0df1d1b6")
   (when (featurep! :completion company)
-    (package! company-web :pin "f0cc9187c9")))
+    (package! company-web :pin "f0cc9187c9c34f72ad71f5649a69c74f996bae9a")))
 
 ;; +css.el
 (package! css-mode :built-in t)
-(package! less-css-mode :built-in t :pin "c7fa3d56d8")
+(package! less-css-mode :built-in t :pin "c7fa3d56d83206b28657f2e56439dc62280a2bf2")
 
-(package! sass-mode :pin "247a0d4b50")
+(package! sass-mode :pin "247a0d4b509f10b28e4687cd8763492bca03599b")
-(package! stylus-mode :pin "4dbde92542")
+(package! stylus-mode :pin "4dbde92542fc7ad61df38776980905a4721d642e")
-(package! sws-mode :pin "4dbde92542")
+(package! sws-mode :pin "4dbde92542fc7ad61df38776980905a4721d642e")
-(package! rainbow-mode :pin "3ef813d637")
+(package! rainbow-mode :pin "f780ddb18c2a73a666d093f606df92058e5601ea")
 (when (featurep! :completion ivy)
-  (package! counsel-css :pin "61a38c9d50"))
+  (package! counsel-css :pin "6427dfcbda0d2bbd81db03f9d6b56b06c260ac02"))
 (when (featurep! :completion helm)
-  (package! helm-css-scss :pin "48b996f73a"))
+  (package! helm-css-scss :pin "48b996f73af1fef8d6e88a1c545d98f8c50b0cf3"))