Allow the expansion of :after (:or foo bar) to be byte-compiled

diff --git a/lisp/use-package/use-package-core.el b/lisp/use-package/use-package-core.el
index cacd74b256f74686f555cda2b6771e472c1b5524..7ed5b7482e14e9e3463eb5030f7bc586b9605a61 100644 (file)
--- a/lisp/use-package/use-package-core.el
+++ b/lisp/use-package/use-package-core.el
@@ -643,14 +643,11 @@ no more than once."
   (let ((loaded (cl-gensym "use-package--loaded"))
         (result (cl-gensym "use-package--result"))
         (next (cl-gensym "use-package--next")))
-    `((defconst ,loaded nil)
-      (defconst ,result nil)
-      (defconst ,next #'(lambda ()
-                          (if ,loaded
-                              ,result
-                            (setq ,loaded t)
-                            (setq ,result ,arg))))
-      ,@(funcall f `((funcall ,next))))))
+    `((lexical-let (,loaded ,result)
+        ,@(funcall f `((if ,loaded
+                           ,result
+                         (setq ,loaded t)
+                         (setq ,result ,arg))))))))
 
 (defsubst use-package-normalize-value (label arg)
   "Normalize the Lisp value given by ARG.

diff --git a/test/lisp/use-package/use-package-tests.el b/test/lisp/use-package/use-package-tests.el
index 4ce0cbc6eb496ea50580064cf88c05b1b2285a44..73c269abf14608246df8966d7133188cddba76d5 100644 (file)
--- a/test/lisp/use-package/use-package-tests.el
+++ b/test/lisp/use-package/use-package-tests.el
@@ -1176,119 +1176,107 @@
 (ert-deftest use-package-test/:after-5 ()
   (match-expansion
    (use-package foo :after (:any bar quux))
-   `(progn
-      (defconst ,_ nil)
-      (defconst ,_ nil)
-      (defconst ,_
-        #'(lambda nil
-            (if ,_ ,_
-              (setq ,_ t)
-              (setq ,_
-                    (require 'foo nil nil)))))
+   `(lexical-let (,_ ,_)
       (eval-after-load 'bar
-        '(funcall ,_))
+        '(if ,_ ,_
+           (setq ,_ t)
+           (setq ,_ (require 'foo nil nil))))
       (eval-after-load 'quux
-        '(funcall ,_)))))
+        '(if ,_ ,_
+           (setq ,_ t)
+           (setq ,_ (require 'foo nil nil)))))))
 
 (ert-deftest use-package-test/:after-6 ()
   (match-expansion
    (use-package foo :after (:all (:any bar quux) bow))
-   `(progn
-      (defconst ,_ nil)
-      (defconst ,_ nil)
-      (defconst ,_
-        #'(lambda nil
-            (if ,_ ,_
-              (setq ,_ t)
-              (setq ,_
-                    (require 'foo nil nil)))))
+   `(lexical-let (,_ ,_)
       (eval-after-load 'bow
         '(progn
            (eval-after-load 'bar
-             '(funcall ,_))
+             '(if ,_ ,_
+                (setq ,_ t)
+                (setq ,_ (require 'foo nil nil))))
            (eval-after-load 'quux
-             '(funcall ,_)))))))
+             '(if ,_ ,_
+                (setq ,_ t)
+                (setq ,_ (require 'foo nil nil)))))))
+   ))
 
 (ert-deftest use-package-test/:after-7 ()
   (match-expansion
    (use-package foo :after (:any (:all bar quux) bow))
-   `(progn
-      (defconst ,_ nil)
-      (defconst ,_ nil)
-      (defconst ,_
-        #'(lambda nil
-            (if ,_ ,_
-              (setq ,_ t)
-              (setq ,_
-                    (require 'foo nil nil)))))
+   `(lexical-let (,_ ,_)
       (eval-after-load 'quux
         '(eval-after-load 'bar
-           '(funcall ,_)))
+           '(if ,_ ,_
+              (setq ,_ t)
+              (setq ,_ (require 'foo nil nil)))))
       (eval-after-load 'bow
-        '(funcall ,_)))))
+        '(if ,_ ,_
+           (setq ,_ t)
+           (setq ,_ (require 'foo nil nil)))))
+   ))
 
 (ert-deftest use-package-test/:after-8 ()
   (match-expansion
    (use-package foo :after (:all (:any bar quux) (:any bow baz)))
-   `(progn
-      (defconst ,_ nil)
-      (defconst ,_ nil)
-      (defconst ,_
-        #'(lambda nil
-            (if ,_ ,_
-              (setq ,_ t)
-              (setq ,_
-                    (require 'foo nil nil)))))
+   `(lexical-let (,_ ,_)
       (eval-after-load 'bow
         '(progn
            (eval-after-load 'bar
-             '(funcall ,_))
+             '(if ,_ ,_
+                (setq ,_ t)
+                (setq ,_ (require 'foo nil nil))))
            (eval-after-load 'quux
-             '(funcall ,_))))
+             '(if ,_ ,_
+                (setq ,_ t)
+                (setq ,_ (require 'foo nil nil))))))
       (eval-after-load 'baz
         '(progn
            (eval-after-load 'bar
-             '(funcall ,_))
+             '(if ,_ ,_
+                (setq ,_ t)
+                (setq ,_ (require 'foo nil nil))))
            (eval-after-load 'quux
-             '(funcall ,_)))))))
+             '(if ,_ ,_
+                (setq ,_ t)
+                (setq ,_ (require 'foo nil nil)))))))
+   ))
 
 (ert-deftest use-package-test/:after-9 ()
   (match-expansion
    (use-package foo :after (:any (:all bar quux) (:all bow baz)))
-   `(progn
-      (defconst ,_ nil)
-      (defconst ,_ nil)
-      (defconst ,_
-        #'(lambda nil
-            (if ,_ ,_
-              (setq ,_ t)
-              (setq ,_
-                    (require 'foo nil nil)))))
+   `(lexical-let (,_ ,_)
       (eval-after-load 'quux
         '(eval-after-load 'bar
-           '(funcall ,_)))
+           '(if ,_ ,_
+              (setq ,_ t)
+              (setq ,_ (require 'foo nil nil)))))
       (eval-after-load 'baz
         '(eval-after-load 'bow
-           '(funcall ,_))))))
+           '(if ,_ ,_
+              (setq ,_ t)
+              (setq ,_ (require 'foo nil nil))))))
+   ))
 
 (ert-deftest use-package-test/:after-10 ()
   (match-expansion
    (use-package foo :after (:any (:all bar quux) (:any bow baz)))
-   `(progn
-      (defconst ,_ nil)
-      (defconst ,_ nil)
-      (defconst ,_
-        #'(lambda nil (if ,_ ,_
-                   (setq ,_ t)
-                   (setq ,_
-                         (require 'foo nil nil)))))
+   `(lexical-let (,_ ,_)
       (eval-after-load 'quux
         '(eval-after-load 'bar
-           '(funcall ,_)))
+           '(if ,_ ,_
+              (setq ,_ t)
+              (setq ,_ (require 'foo nil nil)))))
       (eval-after-load 'bow
-        '(funcall ,_))
+        '(if ,_ ,_
+           (setq ,_ t)
+           (setq ,_ (require 'foo nil nil))))
       (eval-after-load 'baz
-        '(funcall ,_)))))
+        '(if ,_ ,_
+           (setq ,_ t)
+           (setq ,_ (require 'foo nil nil)))))
+   ))
 
 (ert-deftest use-package-test/:demand-1 ()
   (match-expansion