Move delete-backward-char & newline-and-indent advice

To config/default; the only place it is used.

core/autoload/editor.el

@@ -115,104 +115,6 @@ afterwards, kill line to beginning of line."
     (unless empty-line-p
       (indent-according-to-mode))))
 
-;;;###autoload
-(defun doom/backward-delete-whitespace-to-column ()
-  "Delete back to the previous column of whitespace, or as much whitespace as
-possible, or just one char if that's not possible."
-  (interactive)
-  (let* ((context (ignore-errors (sp-get-thing)))
-         (op (plist-get context :op))
-         (cl (plist-get context :cl))
-         open-len close-len)
-    (cond ;; When in strings (sp acts weird with quotes; this is the fix)
-          ;; Also, skip closing delimiters
-          ((and op cl
-                (string= op cl)
-                (and (string= (char-to-string (or (char-before) 0)) op)
-                     (setq open-len (length op)))
-                (and (string= (char-to-string (or (char-after) 0)) cl)
-                     (setq close-len (length cl))))
-           (delete-char (- open-len))
-           (delete-char close-len))
-
-          ;; Delete up to the nearest tab column IF only whitespace between
-          ;; point and bol.
-          ((and (not indent-tabs-mode)
-                (not (bolp))
-                (not (sp-point-in-string))
-                (save-excursion (>= (- (skip-chars-backward " \t")) tab-width)))
-           (let ((movement (% (current-column) tab-width)))
-             (when (= movement 0)
-               (setq movement tab-width))
-             (delete-char (- movement)))
-           (unless (memq (char-before) (list ?\n ?\ ))
-             (insert " ")))
-
-          ;; Otherwise do a regular delete
-          (t (delete-char -1)))))
-
-;;;###autoload
-(defun doom/delete-backward-char (n &optional killflag)
-  "Same as `delete-backward-char', but preforms these additional checks:
-
-+ If point is surrounded by (balanced) whitespace and a brace delimiter ({} []
-  ()), delete a space on either side of the cursor.
-+ If point is at BOL and surrounded by braces on adjacent lines, collapse
-  newlines:
-  {
-  |
-  } => {|}
-+ Otherwise, resort to `doom/backward-delete-whitespace-to-column'.
-+ Resorts to `delete-char' if n > 1"
-  (interactive "p\nP")
-  (or (integerp n)
-      (signal 'wrong-type-argument (list 'integerp n)))
-  (cond ((and (use-region-p)
-              delete-active-region
-              (= n 1))
-         ;; If a region is active, kill or delete it.
-         (if (eq delete-active-region 'kill)
-             (kill-region (region-beginning) (region-end) 'region)
-           (funcall region-extract-function 'delete-only)))
-        ;; In Overwrite mode, maybe untabify while deleting
-        ((null (or (null overwrite-mode)
-                   (<= n 0)
-                   (memq (char-before) '(?\t ?\n))
-                   (eobp)
-                   (eq (char-after) ?\n)))
-         (let ((ocol (current-column)))
-           (delete-char (- n) killflag)
-           (save-excursion
-             (insert-char ?\s (- ocol (current-column)) nil))))
-        ;;
-        ((and (= n 1) (bound-and-true-p smartparens-mode))
-         (cond ((and (memq (char-before) (list ?\  ?\t))
-                     (save-excursion
-                       (and (> (- (skip-chars-backward " \t" (line-beginning-position))) 0)
-                            (bolp))))
-                (doom/backward-delete-whitespace-to-column))
-               ((let* ((pair (ignore-errors (sp-get-thing)))
-                       (op   (plist-get pair :op))
-                       (cl   (plist-get pair :cl))
-                       (beg  (plist-get pair :beg))
-                       (end  (plist-get pair :end)))
-                  (cond ((and end beg (= end (+ beg (length op) (length cl))))
-                         (sp-backward-delete-char 1))
-                        ((doom-surrounded-p pair 'inline 'balanced)
-                         (delete-char -1 killflag)
-                         (delete-char 1)
-                         (when (= (point) (+ (length cl) beg))
-                           (sp-backward-delete-char 1)
-                           (sp-insert-pair op)))
-                        ((and (bolp) (doom-surrounded-p pair nil 'balanced))
-                         (delete-region beg end)
-                         (sp-insert-pair op)
-                         t)
-                        ((run-hook-with-args-until-success 'doom-delete-backward-functions))
-                        ((doom/backward-delete-whitespace-to-column)))))))
-        ;; Otherwise, do simple deletion.
-        ((delete-char (- n) killflag))))
-
 ;;;###autoload
 (defun doom/retab (arg &optional beg end)
   "Converts tabs-to-spaces or spaces-to-tabs within BEG and END (defaults to
@@ -283,24 +185,6 @@ Respects `require-final-newline'."
   (set-buffer-file-coding-system 'undecided-dos nil))
 
 
-;;
-;; Advice
-
-;;;###autoload
-(defun doom*newline-indent-and-continue-comments (_orig-fn)
-  "Inserts a newline and possibly indents it. Also continues comments if
-executed from a commented line; handling special cases for certain languages
-with weak native support."
-  (interactive)
-  (cond ((sp-point-in-string) (newline))
-        ((and (sp-point-in-comment)
-              comment-line-break-function)
-         (funcall comment-line-break-function))
-        (t
-         (newline nil t)
-         (indent-according-to-mode))))
-
-
 ;;
 ;; Hooks
 

modules/config/default/autoload/default.el

@@ -119,3 +119,114 @@ If ARG (universal argument), runs `compile' from the current directory."
    (cond ((fboundp 'counsel-yank-pop)    #'counsel-yank-pop)
          ((fboundp 'helm-show-kill-ring) #'helm-show-kill-ring)
          ((error "No kill-ring search backend available. Enable ivy or helm!")))))
+
+;;;###autoload
+(defun +default*newline-indent-and-continue-comments (_orig-fn)
+  "Inserts a newline and possibly indents it. Also continues comments if
+executed from a commented line; handling special cases for certain languages
+with weak native support."
+  (interactive)
+  (cond ((sp-point-in-string) (newline))
+        ((and (sp-point-in-comment)
+              comment-line-break-function)
+         (funcall comment-line-break-function))
+        (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
+possible, or just one char if that's not possible."
+  (interactive)
+  (let* ((context (ignore-errors (sp-get-thing)))
+         (op (plist-get context :op))
+         (cl (plist-get context :cl))
+         open-len close-len)
+    (cond ;; When in strings (sp acts weird with quotes; this is the fix)
+          ;; Also, skip closing delimiters
+          ((and op cl
+                (string= op cl)
+                (and (string= (char-to-string (or (char-before) 0)) op)
+                     (setq open-len (length op)))
+                (and (string= (char-to-string (or (char-after) 0)) cl)
+                     (setq close-len (length cl))))
+           (delete-char (- open-len))
+           (delete-char close-len))
+
+          ;; Delete up to the nearest tab column IF only whitespace between
+          ;; point and bol.
+          ((and (not indent-tabs-mode)
+                (not (bolp))
+                (not (sp-point-in-string))
+                (save-excursion (>= (- (skip-chars-backward " \t")) tab-width)))
+           (let ((movement (% (current-column) tab-width)))
+             (when (= movement 0)
+               (setq movement tab-width))
+             (delete-char (- movement)))
+           (unless (memq (char-before) (list ?\n ?\ ))
+             (insert " ")))
+
+          ;; Otherwise do a regular delete
+          ((delete-char -1)))))
+
+;;;###autoload
+(defun +default*delete-backward-char (n &optional killflag)
+  "Same as `delete-backward-char', but preforms these additional checks:
+
++ If point is surrounded by (balanced) whitespace and a brace delimiter ({} []
+  ()), delete a space on either side of the cursor.
++ If point is at BOL and surrounded by braces on adjacent lines, collapse
+  newlines:
+  {
+  |
+  } => {|}
++ Otherwise, resort to `doom--backward-delete-whitespace-to-column'.
++ Resorts to `delete-char' if n > 1"
+  (interactive "p\nP")
+  (or (integerp n)
+      (signal 'wrong-type-argument (list 'integerp n)))
+  (cond ((and (use-region-p)
+              delete-active-region
+              (= n 1))
+         ;; If a region is active, kill or delete it.
+         (if (eq delete-active-region 'kill)
+             (kill-region (region-beginning) (region-end) 'region)
+           (funcall region-extract-function 'delete-only)))
+        ;; In Overwrite mode, maybe untabify while deleting
+        ((null (or (null overwrite-mode)
+                   (<= n 0)
+                   (memq (char-before) '(?\t ?\n))
+                   (eobp)
+                   (eq (char-after) ?\n)))
+         (let ((ocol (current-column)))
+           (delete-char (- n) killflag)
+           (save-excursion
+             (insert-char ?\s (- ocol (current-column)) nil))))
+        ;;
+        ((and (= n 1) (bound-and-true-p smartparens-mode))
+         (cond ((and (memq (char-before) (list ?\  ?\t))
+                     (save-excursion
+                       (and (/= (skip-chars-backward " \t" (line-beginning-position)) 0)
+                            (bolp))))
+                (doom--backward-delete-whitespace-to-column))
+               ((let* ((pair (ignore-errors (sp-get-thing)))
+                       (op   (plist-get pair :op))
+                       (cl   (plist-get pair :cl))
+                       (beg  (plist-get pair :beg))
+                       (end  (plist-get pair :end)))
+                  (cond ((and end beg (= end (+ beg (length op) (length cl))))
+                         (sp-backward-delete-char 1))
+                        ((doom-surrounded-p pair 'inline 'balanced)
+                         (delete-char -1 killflag)
+                         (delete-char 1)
+                         (when (= (point) (+ (length cl) beg))
+                           (sp-backward-delete-char 1)
+                           (sp-insert-pair op)))
+                        ((and (bolp) (doom-surrounded-p pair nil 'balanced))
+                         (delete-region beg end)
+                         (sp-insert-pair op)
+                         t)
+                        ((run-hook-with-args-until-success 'doom-delete-backward-functions))
+                        ((doom--backward-delete-whitespace-to-column)))))))
+        ;; Otherwise, do simple deletion.
+        ((delete-char (- n) killflag))))

modules/config/default/config.el

@@ -105,10 +105,10 @@
     ;;  e) properly delete smartparen pairs when they are encountered, without
     ;;     the need for strict mode.
     ;;  f) do none of this when inside a string
-    (advice-add #'delete-backward-char :override #'doom/delete-backward-char)
+    (advice-add #'delete-backward-char :override #'+default*delete-backward-char)
 
     ;; Makes `newline-and-indent' continue comments (and more reliably)
-    (advice-add #'newline-and-indent :around #'doom*newline-indent-and-continue-comments)))
+    (advice-add #'newline-and-indent :around #'+default*newline-indent-and-continue-comments)))
 
 
 ;;