Make the expanded text for :after cleaner

2 files changed, 73 insertions, 90 deletions

diff --git a/lisp/use-package/use-package-core.el b/lisp/use-package/use-package-core.el
index 01b3ac3c149..cacd74b256f 100644
--- a/lisp/use-package/use-package-core.el
+++ b/lisp/use-package/use-package-core.el
@@ -643,14 +643,14 @@ no more than once."
   (let ((loaded (cl-gensym "use-package--loaded"))
         (result (cl-gensym "use-package--result"))
         (next (cl-gensym "use-package--next")))
-    `((defvar ,loaded nil)
-      (defvar ,result nil)
-      (defvar ,next #'(lambda ()
-                        (if ,loaded
-                            ,result
-                          (setq ,loaded t)
-                          (setq ,result ,arg))))
-      ,(funcall f `(funcall ,next)))))
+    `((defconst ,loaded nil)
+      (defconst ,result nil)
+      (defconst ,next #'(lambda ()
+                          (if ,loaded
+                              ,result
+                            (setq ,loaded t)
+                            (setq ,result ,arg))))
+      ,@(funcall f `((funcall ,next))))))
 
 (defsubst use-package-normalize-value (label arg)
   "Normalize the Lisp value given by ARG.
@@ -946,9 +946,8 @@ representing symbols (that may need to be autloaded)."
           #'(lambda (keyword err)
               (let ((msg (format "%s/%s: %s" ',name keyword
                                  (error-message-string err))))
-                ,(when (eq use-package-verbose 'debug)
-                   `(progn
-                      (with-current-buffer
+                ,@(when (eq use-package-verbose 'debug)
+                    `((with-current-buffer
                           (get-buffer-create "*use-package*")
                         (goto-char (point-max))
                         (insert "-----\n" msg ,use-package--form)
@@ -1134,15 +1133,11 @@ FEATURES is a list containing keywords `:and' and `:all', where
 no keyword implies `:all'."
   (cond
    ((use-package-non-nil-symbolp features)
-    `(eval-after-load ',features
-       ,(if (member (car body) '(quote backquote \' \`))
-            body
-          (list 'quote body))))
+    `((eval-after-load ',features ',(macroexp-progn body))))
    ((and (consp features)
          (memq (car features) '(:or :any)))
-    (macroexp-progn
-     (mapcar #'(lambda (x) (use-package-require-after-load x body))
-             (cdr features))))
+    (cl-mapcan #'(lambda (x) (use-package-require-after-load x body))
+               (cdr features)))
    ((and (consp features)
          (memq (car features) '(:and :all)))
     (cl-dolist (next (cdr features))
@@ -1157,8 +1152,7 @@ no keyword implies `:all'."
     (if (or (null uses) (null body))
         body
       (if (<= uses 1)
-          (list (use-package-require-after-load
-                 arg (list 'quote (macroexp-progn body))))
+          (use-package-require-after-load arg body)
         (use-package-memoize
          (apply-partially #'use-package-require-after-load arg)
          (macroexp-progn body))))))
diff --git a/test/lisp/use-package/use-package-tests.el b/test/lisp/use-package/use-package-tests.el
index cbfb98da0c0..4ce0cbc6eb4 100644
--- a/test/lisp/use-package/use-package-tests.el
+++ b/test/lisp/use-package/use-package-tests.el
@@ -1116,13 +1116,9 @@
    (use-package foo :catch t)
    `(progn
       (defvar ,_
-        #'(lambda
-            (keyword err)
-            (let
-                ((msg
-                  (format "%s/%s: %s" 'foo keyword
-                          (error-message-string err))))
-              nil
+        #'(lambda (keyword err)
+            (let ((msg (format "%s/%s: %s" 'foo keyword
+                               (error-message-string err))))
               (ignore
                (display-warning 'use-package msg :error)))))
       (condition-case-unless-debug err
@@ -1181,27 +1177,26 @@
   (match-expansion
    (use-package foo :after (:any bar quux))
    `(progn
-      (defvar ,_ nil)
-      (defvar ,_ nil)
-      (defvar ,_
+      (defconst ,_ nil)
+      (defconst ,_ nil)
+      (defconst ,_
         #'(lambda nil
             (if ,_ ,_
               (setq ,_ t)
               (setq ,_
                     (require 'foo nil nil)))))
-      (progn
-        (eval-after-load 'bar
-          '(funcall ,_))
-        (eval-after-load 'quux
-          '(funcall ,_))))))
+      (eval-after-load 'bar
+        '(funcall ,_))
+      (eval-after-load 'quux
+        '(funcall ,_)))))
 
 (ert-deftest use-package-test/:after-6 ()
   (match-expansion
    (use-package foo :after (:all (:any bar quux) bow))
    `(progn
-      (defvar ,_ nil)
-      (defvar ,_ nil)
-      (defvar ,_
+      (defconst ,_ nil)
+      (defconst ,_ nil)
+      (defconst ,_
         #'(lambda nil
             (if ,_ ,_
               (setq ,_ t)
@@ -1218,88 +1213,82 @@
   (match-expansion
    (use-package foo :after (:any (:all bar quux) bow))
    `(progn
-      (defvar ,_ nil)
-      (defvar ,_ nil)
-      (defvar ,_
+      (defconst ,_ nil)
+      (defconst ,_ nil)
+      (defconst ,_
         #'(lambda nil
             (if ,_ ,_
               (setq ,_ t)
               (setq ,_
                     (require 'foo nil nil)))))
-      (progn
-        (eval-after-load 'quux
-          '(eval-after-load 'bar
-             '(funcall ,_)))
-        (eval-after-load 'bow
-          '(funcall ,_))))))
+      (eval-after-load 'quux
+        '(eval-after-load 'bar
+           '(funcall ,_)))
+      (eval-after-load 'bow
+        '(funcall ,_)))))
 
 (ert-deftest use-package-test/:after-8 ()
   (match-expansion
    (use-package foo :after (:all (:any bar quux) (:any bow baz)))
    `(progn
-      (defvar ,_ nil)
-      (defvar ,_ nil)
-      (defvar ,_
+      (defconst ,_ nil)
+      (defconst ,_ nil)
+      (defconst ,_
         #'(lambda nil
             (if ,_ ,_
               (setq ,_ t)
               (setq ,_
                     (require 'foo nil nil)))))
-      (progn
-        (eval-after-load 'bow
-          '(progn
-             (eval-after-load 'bar
-               '(funcall ,_))
-             (eval-after-load 'quux
-               '(funcall ,_))))
-        (eval-after-load 'baz
-          '(progn
-             (eval-after-load 'bar
-               '(funcall ,_))
-             (eval-after-load 'quux
-               '(funcall ,_))))))))
+      (eval-after-load 'bow
+        '(progn
+           (eval-after-load 'bar
+             '(funcall ,_))
+           (eval-after-load 'quux
+             '(funcall ,_))))
+      (eval-after-load 'baz
+        '(progn
+           (eval-after-load 'bar
+             '(funcall ,_))
+           (eval-after-load 'quux
+             '(funcall ,_)))))))
 
 (ert-deftest use-package-test/:after-9 ()
   (match-expansion
    (use-package foo :after (:any (:all bar quux) (:all bow baz)))
    `(progn
-      (defvar ,_ nil)
-      (defvar ,_ nil)
-      (defvar ,_
+      (defconst ,_ nil)
+      (defconst ,_ nil)
+      (defconst ,_
         #'(lambda nil
             (if ,_ ,_
               (setq ,_ t)
               (setq ,_
                     (require 'foo nil nil)))))
-      (progn
-        (eval-after-load 'quux
-          '(eval-after-load 'bar
-             '(funcall ,_)))
-        (eval-after-load 'baz
-          '(eval-after-load 'bow
-             '(funcall ,_)))))))
+      (eval-after-load 'quux
+        '(eval-after-load 'bar
+           '(funcall ,_)))
+      (eval-after-load 'baz
+        '(eval-after-load 'bow
+           '(funcall ,_))))))
 
 (ert-deftest use-package-test/:after-10 ()
   (match-expansion
    (use-package foo :after (:any (:all bar quux) (:any bow baz)))
    `(progn
-      (defvar ,_ nil)
-      (defvar ,_ nil)
-      (defvar ,_
-        #'(lambda nil
-            (if ,_ ,_
-              (setq ,_ t)
-              (setq ,_
-                    (require 'foo nil nil)))))
-      (progn
-        (eval-after-load 'quux
-          '(eval-after-load 'bar
-             '(funcall ,_)))
-        (progn
-          (eval-after-load 'bow
-            '(funcall ,_))
-          (eval-after-load 'baz
-            '(funcall ,_)))))))
+      (defconst ,_ nil)
+      (defconst ,_ nil)
+      (defconst ,_
+        #'(lambda nil (if ,_ ,_
+                   (setq ,_ t)
+                   (setq ,_
+                         (require 'foo nil nil)))))
+      (eval-after-load 'quux
+        '(eval-after-load 'bar
+           '(funcall ,_)))
+      (eval-after-load 'bow
+        '(funcall ,_))
+      (eval-after-load 'baz
+        '(funcall ,_)))))
 
 (ert-deftest use-package-test/:demand-1 ()
   (match-expansion