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