Merge pull request from npostavs/string-packages

Re-add support for string package names
GitHub-reference: https://github.com/jwiegley/use-package/issues/225

lisp/use-package/use-package.el

@@ -153,6 +153,23 @@ then your byte-compiled init file is as minimal as possible."
 ;; Utility functions
 ;;
 
+(defun use-package-as-symbol (string-or-symbol)
+  "If STRING-OR-SYMBOL is already a symbol, return it.  Otherwise
+convert it to a symbol and return that."
+  (if (symbolp string-or-symbol) string-or-symbol
+    (intern string-or-symbol)))
+
+(defun use-package-as-string (string-or-symbol)
+  "If STRING-OR-SYMBOL is already a string, return it.  Otherwise
+convert it to a string and return that."
+  (if (stringp string-or-symbol) string-or-symbol
+    (symbol-name string-or-symbol)))
+
+(defun use-package-load-name (name &optional noerror)
+  "Return a form which will load or require NAME depending on
+whether it's a string or symbol."
+  (if (stringp name) `(load ,name 'noerror) `(require ',name nil 'noerror)))
+
 (defun use-package-expand (name label form)
   "FORM is a list of forms, so `((foo))' if only `foo' is being called."
   (declare (indent 1))
@@ -296,7 +313,7 @@ This is in contrast to merely setting it to 0."
 ;; Normalization functions
 ;;
 
-(defun use-package-normalize-plist (name-symbol input)
+(defun use-package-normalize-plist (name input)
   "Given a pseudo-plist, normalize it to a regular plist."
   (unless (null input)
     (let* ((keyword (car input))
@@ -308,19 +325,19 @@ This is in contrast to merely setting it to 0."
            (arg
             (cond
              ((eq keyword :disabled)
-              (use-package-normalize-plist name-symbol tail))
+              (use-package-normalize-plist name tail))
              ((functionp normalizer)
-              (funcall normalizer name-symbol keyword args))
+              (funcall normalizer name keyword args))
              ((= (length args) 1)
               (car args))
              (t
               args))))
       (if (memq keyword use-package-keywords)
           (cons keyword
-                (cons arg (use-package-normalize-plist name-symbol tail)))
+                (cons arg (use-package-normalize-plist name tail)))
         (use-package-error (format "Unrecognized keyword: %s" keyword))))))
 
-(defun use-package-process-keywords (name-symbol plist &optional state)
+(defun use-package-process-keywords (name plist &optional state)
   "Process the next keyword in the free-form property list PLIST.
 The values in the PLIST have each been normalized by the function
 use-package-normalize/KEYWORD (minus the colon).
@@ -342,7 +359,7 @@ next value for the STATE."
       (let* ((handler (concat "use-package-handler/" (symbol-name keyword)))
              (handler-sym (intern handler)))
         (if (functionp handler-sym)
-            (funcall handler-sym name-symbol keyword arg rest state)
+            (funcall handler-sym name keyword arg rest state)
           (use-package-error
            (format "Keyword handler not defined: %s" handler)))))))
 
@@ -366,7 +383,7 @@ next value for the STATE."
 
 (put 'use-package-only-one 'lisp-indent-function 'defun)
 
-(defun use-package-normalize/:pin (name-symbol keyword args)
+(defun use-package-normalize/:pin (name keyword args)
   (use-package-only-one (symbol-name keyword) args
     (lambda (label arg)
       (cond
@@ -405,16 +422,16 @@ manually updated package."
              archive-name package))
     (package-initialize t)))
 
-(defun use-package-handler/:pin (name-symbol keyword archive-name rest state)
+(defun use-package-handler/:pin (name keyword archive-name rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     ;; This happens at macro expansion time, not when the expanded code is
     ;; compiled or evaluated.
     (if (null archive-name)
         body
-      (use-package-pin-package name-symbol archive-name)
+      (use-package-pin-package name archive-name)
       (use-package-concat
        body
-       `((push '(,name-symbol . ,archive-name)
+       `((push '(,(use-package-as-symbol name) . ,archive-name)
                package-pinned-packages)
          t)))))
 
@@ -423,7 +440,7 @@ manually updated package."
 ;; :ensure
 ;;
 
-(defun use-package-normalize/:ensure (name-symbol keyword args)
+(defun use-package-normalize/:ensure (name keyword args)
   (if (null args)
       t
     (use-package-only-one (symbol-name keyword) args
@@ -443,11 +460,11 @@ manually updated package."
         (package-refresh-contents)
         (use-package-ensure-elpa package t)))))
 
-(defun use-package-handler/:ensure (name-symbol keyword ensure rest state)
+(defun use-package-handler/:ensure (name keyword ensure rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     ;; This happens at macro expansion time, not when the expanded code is
     ;; compiled or evaluated.
-    (let ((package-name (or (and (eq ensure t) name-symbol) ensure)))
+    (let ((package-name (or (and (eq ensure t) (use-package-as-symbol name)) ensure)))
       (when package-name
         (require 'package)
         (use-package-ensure-elpa package-name)))
@@ -466,25 +483,25 @@ manually updated package."
          `(funcall #',arg))
         (t arg)))
 
-(defun use-package-normalize-test (name-symbol keyword args)
+(defun use-package-normalize-test (name keyword args)
   (use-package-only-one (symbol-name keyword) args
     #'use-package-normalize-value))
 
 (defalias 'use-package-normalize/:if 'use-package-normalize-test)
 (defalias 'use-package-normalize/:when 'use-package-normalize-test)
 
-(defun use-package-normalize/:unless (name-symbol keyword args)
+(defun use-package-normalize/:unless (name keyword args)
   (not (use-package-only-one (symbol-name keyword) args
          #'use-package-normalize-value)))
 
-(defun use-package-handler/:if (name-symbol keyword pred rest state)
+(defun use-package-handler/:if (name keyword pred rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     `((when ,pred ,@body))))
 
 (defalias 'use-package-handler/:when 'use-package-handler/:if)
 
-(defun use-package-handler/:unless (name-symbol keyword pred rest state)
+(defun use-package-handler/:unless (name keyword pred rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     `((unless ,pred ,@body))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -515,14 +532,14 @@ manually updated package."
     (use-package-error
      (concat label " wants a symbol, or list of symbols")))))
 
-(defun use-package-normalize-symlist (name-symbol keyword args)
+(defun use-package-normalize-symlist (name keyword args)
   (use-package-as-one (symbol-name keyword) args
     #'use-package-normalize-symbols))
 
 (defalias 'use-package-normalize/:requires 'use-package-normalize-symlist)
 
-(defun use-package-handler/:requires (name-symbol keyword requires rest state)
+(defun use-package-handler/:requires (name keyword requires rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     (if (null requires)
         body
       `((when ,(if (listp requires)
@@ -553,12 +570,12 @@ manually updated package."
     (use-package-error
      (concat label " wants a directory path, or list of paths")))))
 
-(defun use-package-normalize/:load-path (name-symbol keyword args)
+(defun use-package-normalize/:load-path (name keyword args)
   (use-package-as-one (symbol-name keyword) args
     #'use-package-normalize-paths))
 
-(defun use-package-handler/:load-path (name-symbol keyword arg rest state)
+(defun use-package-handler/:load-path (name keyword arg rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     (use-package-concat
      (mapcar #'(lambda (path)
                  `(eval-and-compile (push ,path load-path))) arg)
@@ -569,7 +586,7 @@ manually updated package."
 ;; :no-require
 ;;
 
-(defun use-package-normalize-predicate (name-symbol keyword args)
+(defun use-package-normalize-predicate (name keyword args)
   (if (null args)
       t
     (use-package-only-one (symbol-name keyword) args
@@ -577,9 +594,9 @@ manually updated package."
 
 (defalias 'use-package-normalize/:no-require 'use-package-normalize-predicate)
 
-(defun use-package-handler/:no-require (name-symbol keyword arg rest state)
+(defun use-package-handler/:no-require (name keyword arg rest state)
   ;; This keyword has no functional meaning.
-  (use-package-process-keywords name-symbol rest state))
+  (use-package-process-keywords name rest state))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
@@ -596,13 +613,13 @@ manually updated package."
                   (macroexpand form)
                 form)) args))
 
-(defun use-package-normalize-forms (name-symbol keyword args)
+(defun use-package-normalize-forms (name keyword args)
   (use-package-normalize-form (symbol-name keyword) args))
 
 (defalias 'use-package-normalize/:preface 'use-package-normalize-forms)
 
-(defun use-package-handler/:preface (name-symbol keyword arg rest state)
+(defun use-package-handler/:preface (name keyword arg rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     (use-package-concat
      (unless (null arg)
        `((eval-and-compile ,@arg)))
@@ -621,45 +638,45 @@ manually updated package."
        (symbolp (cdr x))))
 
 (defun use-package-normalize-pairs
-    (name-symbol label arg &optional recursed allow-vector)
+    (name label arg &optional recursed allow-vector)
   "Normalize a list of string/symbol pairs."
   (cond
    ((or (stringp arg) (and allow-vector (vectorp arg)))
-    (list (cons arg name-symbol)))
+    (list (cons arg (use-package-as-symbol name))))
    ((use-package-is-sympair arg allow-vector)
     (list arg))
    ((and (not recursed) (listp arg) (listp (cdr arg)))
     (mapcar #'(lambda (x)
                 (let ((ret (use-package-normalize-pairs
-                            name-symbol label x t allow-vector)))
+                            name label x t allow-vector)))
                   (if (listp ret)
                       (car ret)
                     ret))) arg))
    (t arg)))
 
-(defun use-package-normalize-binder (name-symbol keyword args)
+(defun use-package-normalize-binder (name keyword args)
   (use-package-as-one (symbol-name keyword) args
     (lambda (label arg)
-      (use-package-normalize-pairs name-symbol label arg nil t))))
+      (use-package-normalize-pairs name label arg nil t))))
 
 (defalias 'use-package-normalize/:bind 'use-package-normalize-binder)
 (defalias 'use-package-normalize/:bind* 'use-package-normalize-binder)
 
 (defun use-package-handler/:bind
-    (name-symbol keyword arg rest state &optional override)
+    (name keyword arg rest state &optional override)
   (let ((commands (remq nil (mapcar #'(lambda (arg)
                                         (if (listp arg)
                                             (cdr arg)
                                           nil)) arg))))
     (use-package-concat
-     (use-package-process-keywords name-symbol
+     (use-package-process-keywords name
        (use-package-sort-keywords
         (use-package-plist-maybe-put rest :defer t))
        (use-package-plist-append state :commands commands))
      `((ignore (,(if override 'bind-keys* 'bind-keys) ,@arg))))))
 
-(defun use-package-handler/:bind* (name-symbol keyword arg rest state)
+(defun use-package-handler/:bind* (name keyword arg rest state)
-  (use-package-handler/:bind name-symbol keyword arg rest state t))
+  (use-package-handler/:bind name keyword arg rest state t))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
@@ -697,7 +714,7 @@ deferred until the prefix key sequence is pressed."
                package keymap-symbol)))))
 
 (defun use-package-handler/:bind-keymap
-    (name-symbol keyword arg rest state &optional override)
+    (name keyword arg rest state &optional override)
   (let ((form (mapcar
                #'(lambda (binding)
                    `(,(if override
@@ -707,35 +724,35 @@ deferred until the prefix key sequence is pressed."
                      #'(lambda ()
                          (interactive)
                          (use-package-autoload-keymap
-                          ',(cdr binding) ',name-symbol ,override)))) arg)))
+                          ',(cdr binding) ',(use-package-as-symbol name) ,override)))) arg)))
     (use-package-concat
-     (use-package-process-keywords name-symbol
+     (use-package-process-keywords name
        (use-package-sort-keywords
         (use-package-plist-maybe-put rest :defer t))
        state)
      `((ignore ,@form)))))
 
-(defun use-package-handler/:bind-keymap* (name-symbol keyword arg rest state)
+(defun use-package-handler/:bind-keymap* (name keyword arg rest state)
-  (use-package-handler/:bind-keymap name-symbol keyword arg rest state t))
+  (use-package-handler/:bind-keymap name keyword arg rest state t))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; :interpreter
 ;;
 
-(defun use-package-normalize-mode (name-symbol keyword args)
+(defun use-package-normalize-mode (name keyword args)
   (use-package-as-one (symbol-name keyword) args
-    (apply-partially #'use-package-normalize-pairs name-symbol)))
+    (apply-partially #'use-package-normalize-pairs name)))
 
 (defalias 'use-package-normalize/:interpreter 'use-package-normalize-mode)
 
-(defun use-package-handler/:interpreter (name-symbol keyword arg rest state)
+(defun use-package-handler/:interpreter (name keyword arg rest state)
   (let* (commands
          (form (mapcar #'(lambda (interpreter)
                            (push (cdr interpreter) commands)
                            `(push ',interpreter interpreter-mode-alist)) arg)))
     (use-package-concat
-     (use-package-process-keywords name-symbol
+     (use-package-process-keywords name
        (use-package-sort-keywords
         (use-package-plist-maybe-put rest :defer t))
        (use-package-plist-append state :commands commands))
@@ -748,13 +765,13 @@ deferred until the prefix key sequence is pressed."
 
 (defalias 'use-package-normalize/:mode 'use-package-normalize-mode)
 
-(defun use-package-handler/:mode (name-symbol keyword arg rest state)
+(defun use-package-handler/:mode (name keyword arg rest state)
   (let* (commands
          (form (mapcar #'(lambda (mode)
                            (push (cdr mode) commands)
                            `(push ',mode auto-mode-alist)) arg)))
     (use-package-concat
-     (use-package-process-keywords name-symbol
+     (use-package-process-keywords name
        (use-package-sort-keywords
         (use-package-plist-maybe-put rest :defer t))
        (use-package-plist-append state :commands commands))
@@ -767,9 +784,9 @@ deferred until the prefix key sequence is pressed."
 
 (defalias 'use-package-normalize/:commands 'use-package-normalize-symlist)
 
-(defun use-package-handler/:commands (name-symbol keyword arg rest state)
+(defun use-package-handler/:commands (name keyword arg rest state)
   ;; The actual processing for commands is done in :defer
-  (use-package-process-keywords name-symbol
+  (use-package-process-keywords name
     (use-package-sort-keywords
      (use-package-plist-maybe-put rest :defer t))
     (use-package-plist-append state :commands arg)))
@@ -781,8 +798,8 @@ deferred until the prefix key sequence is pressed."
 
 (defalias 'use-package-normalize/:defines 'use-package-normalize-symlist)
 
-(defun use-package-handler/:defines (name-symbol keyword arg rest state)
+(defun use-package-handler/:defines (name keyword arg rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     body))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -792,8 +809,8 @@ deferred until the prefix key sequence is pressed."
 
 (defalias 'use-package-normalize/:functions 'use-package-normalize-symlist)
 
-(defun use-package-handler/:functions (name-symbol keyword arg rest state)
+(defun use-package-handler/:functions (name keyword arg rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     (if (not (bound-and-true-p byte-compile-current-file))
         body
       (use-package-concat
@@ -801,7 +818,7 @@ deferred until the prefix key sequence is pressed."
          `((eval-when-compile
              ,@(mapcar
                 #'(lambda (fn)
-                    `(declare-function ,fn ,(symbol-name name-symbol))) arg))))
+                    `(declare-function ,fn ,(use-package-as-string name))) arg))))
        body))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -811,15 +828,15 @@ deferred until the prefix key sequence is pressed."
 
 (defalias 'use-package-normalize/:defer 'use-package-normalize-predicate)
 
-(defun use-package-handler/:defer (name-symbol keyword arg rest state)
+(defun use-package-handler/:defer (name keyword arg rest state)
-  (let ((body (use-package-process-keywords name-symbol rest
+  (let ((body (use-package-process-keywords name rest
                 (plist-put state :deferred t)))
-        (name-string (symbol-name name-symbol)))
+        (name-string (use-package-as-string name)))
     (use-package-concat
      ;; Load the package after a set amount of idle time, if the argument to
      ;; `:defer' was a number.
      (when (numberp arg)
-       `((run-with-idle-timer ,arg nil #'require ',name-symbol nil t)))
+       `((run-with-idle-timer ,arg nil #'require ',(use-package-as-symbol name) nil t)))
 
      ;; Since we deferring load, establish any necessary autoloads, and also
      ;; keep the byte-compiler happy.
@@ -843,8 +860,8 @@ deferred until the prefix key sequence is pressed."
 
 (defalias 'use-package-normalize/:demand 'use-package-normalize-predicate)
 
-(defun use-package-handler/:demand (name-symbol keyword arg rest state)
+(defun use-package-handler/:demand (name keyword arg rest state)
-  (use-package-process-keywords name-symbol rest
+  (use-package-process-keywords name rest
     (use-package-plist-delete state :deferred)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -854,11 +871,11 @@ deferred until the prefix key sequence is pressed."
 
 (defalias 'use-package-normalize/:init 'use-package-normalize-forms)
 
-(defun use-package-handler/:init (name-symbol keyword arg rest state)
+(defun use-package-handler/:init (name keyword arg rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     (use-package-concat
      ;; The user's initializations
-     (use-package-hook-injector (symbol-name name-symbol) :init arg)
+     (use-package-hook-injector (use-package-as-string name) :init arg)
      body)))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
@@ -868,8 +885,9 @@ deferred until the prefix key sequence is pressed."
 
 (defalias 'use-package-normalize/:config 'use-package-normalize-forms)
 
-(defun use-package-handler/:config (name-symbol keyword arg rest state)
+(defun use-package-handler/:config (name keyword arg rest state)
-  (let* ((body (use-package-process-keywords name-symbol rest state))
+  (let* ((body (use-package-process-keywords name rest state))
+         (name-symbol (use-package-as-symbol name))
          (config-body
           (if (equal arg '(t))
               body
@@ -882,24 +900,24 @@ deferred until the prefix key sequence is pressed."
                (list t))))))
     (if (plist-get state :deferred)
         (unless (or (null config-body) (equal config-body '(t)))
-          `((eval-after-load ',name-symbol
+          `((eval-after-load ,(if (symbolp name) `',name name)
               ',(macroexp-progn config-body))))
       (use-package--with-elapsed-timer
-          (format "Loading package %s" name-symbol)
+          (format "Loading package %s" name)
         (if use-package-expand-minimally
             (use-package-concat
-             (list `(require ',name-symbol))
+             (list (use-package-load-name name))
              config-body)
-          `((if (not (require ',name-symbol nil t))
+          `((if (not ,(use-package-load-name name t))
                 (ignore
-                 (message (format "Could not load %s" ',name-symbol)))
+                 (message (format "Could not load %s" name)))
               ,@config-body)))))))
 
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;;
 ;; :diminish
 
-(defun use-package-normalize-diminish (name-symbol label arg &optional recursed)
+(defun use-package-normalize-diminish (name label arg &optional recursed)
   "Normalize the arguments to diminish down to a list of one of two forms:
      SYMBOL
      (SYMBOL . STRING)"
@@ -907,23 +925,23 @@ deferred until the prefix key sequence is pressed."
    ((symbolp arg)
     (list arg))
    ((stringp arg)
-    (list (cons (intern (concat (symbol-name name-symbol) "-mode")) arg)))
+    (list (cons (intern (concat (use-package-as-string name) "-mode")) arg)))
    ((and (consp arg) (stringp (cdr arg)))
     (list arg))
    ((and (not recursed) (listp arg) (listp (cdr arg)))
     (mapcar #'(lambda (x) (car (use-package-normalize-diminish
-                                name-symbol label x t))) arg))
+                                name label x t))) arg))
    (t
     (use-package-error
      (concat label " wants a string, symbol, "
              "(symbol . string) or list of these")))))
 
-(defun use-package-normalize/:diminish (name-symbol keyword args)
+(defun use-package-normalize/:diminish (name keyword args)
   (use-package-as-one (symbol-name keyword) args
-    (apply-partially #'use-package-normalize-diminish name-symbol)))
+    (apply-partially #'use-package-normalize-diminish name)))
 
-(defun use-package-handler/:diminish (name-symbol keyword arg rest state)
+(defun use-package-handler/:diminish (name keyword arg rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     (use-package-concat
      (mapcar #'(lambda (var)
                  `(if (fboundp 'diminish)
@@ -938,23 +956,23 @@ deferred until the prefix key sequence is pressed."
 ;; :delight
 ;;
 
-(defun use-package-normalize/:delight (name-symbol keyword args)
+(defun use-package-normalize/:delight (name keyword args)
   "Normalize arguments to delight."
   (cond
    ((and (= (length args) 1)
          (symbolp (car args)))
-    (list (car args) nil name-symbol))
+    (list (car args) nil name))
    ((and (= (length args) 2)
          (symbolp (car args)))
-    (list (car args) (cadr args) name-symbol))
+    (list (car args) (cadr args) (use-package-as-symbol name)))
    ((and (= (length args) 3)
          (symbolp (car args)))
     args)
    (t
     (use-package-error ":delight expects same args as delight function"))))
 
-(defun use-package-handler/:delight (name-symbol keyword args rest state)
+(defun use-package-handler/:delight (name keyword args rest state)
-  (let ((body (use-package-process-keywords name-symbol rest state)))
+  (let ((body (use-package-process-keywords name rest state)))
     (use-package-concat
      body
      `((delight (quote ,(nth 0 args)) ,(nth 1 args) (quote ,(nth 2 args))) t))))
@@ -1014,7 +1032,7 @@ this file.  Usage:
   (unless (member :disabled args)
     (let* ((name-symbol (if (stringp name) (intern name) name))
            (args0 (use-package-plist-maybe-put
-                   (use-package-normalize-plist name-symbol args)
+                   (use-package-normalize-plist name args)
                    :config '(t)))
            (args* (use-package-sort-keywords
                    (if use-package-always-ensure
@@ -1032,15 +1050,15 @@ this file.  Usage:
                     ,@(mapcar #'(lambda (var) `(defvar ,var))
                               (plist-get args* :defines))
                     (with-demoted-errors
-                        ,(format "Cannot load %s: %%S" name-symbol)
+                        ,(format "Cannot load %s: %%S" name)
                       ,(if use-package-verbose
                            `(message "Compiling package %s" ',name-symbol))
                       ,(unless (plist-get args* :no-require)
-                         `(require ',name-symbol)))))))
+                         (use-package-load-name name)))))))
 
       (let ((body
              (macroexp-progn
-              (use-package-process-keywords name-symbol args*))))
+              (use-package-process-keywords name args*))))
         (if use-package-debug
             (display-buffer
              (save-current-buffer