Merge remote-tracking branch 'origin/master' into scratch/split-package.el

lisp/emacs-lisp/byte-run.el

@@ -286,6 +286,12 @@ This is used by `declare'.")
 	    (list 'put (list 'quote name)
 		  ''edebug-form-spec (list 'quote spec)))))
 
+(defalias 'byte-run--set-autoload-macro
+  #'(lambda (name _args spec)
+      (list 'function-put (list 'quote name)
+	    ''autoload-macro (list 'quote spec)))
+  "Handle autoload-macro declarations")
+
 (defalias 'byte-run--set-no-font-lock-keyword
   #'(lambda (name _args val)
       (list 'function-put (list 'quote name)
@@ -365,8 +371,13 @@ This is used by `declare'.")
   (cons
    (list 'debug #'byte-run--set-debug)
    (cons
-    (list 'no-font-lock-keyword #'byte-run--set-no-font-lock-keyword)
-    defun-declarations-alist))
+    ;; macros can declare (autoload-macro expand) to request expansion
+    ;; during autoload generation of forms calling them.  See
+    ;; `loaddefs-generate--make-autoload'.
+    (list 'autoload-macro #'byte-run--set-autoload-macro)
+    (cons
+     (list 'no-font-lock-keyword #'byte-run--set-no-font-lock-keyword)
+     defun-declarations-alist)))
   "List associating properties of macros to their macro expansion.
 Each element of the list takes the form (PROP FUN) where FUN is a function.
 For each (PROP . VALUES) in a macro's declaration, the FUN corresponding
@@ -412,6 +423,8 @@ The return value is undefined.
            (if declarations
 	       (cons 'prog1 (cons def (car declarations)))
 	     def))))))
+;; Expand to defalias and related forms on autoload gen
+(function-put 'defmacro 'autoload-macro 'expand) ; Since we cannot `declare' it
 
 ;; Now that we defined defmacro we can use it!
 (defmacro defun (name arglist &rest body)
@@ -424,7 +437,9 @@ INTERACTIVE is an optional `interactive' specification.
 The return value is undefined.
 
 \(fn NAME ARGLIST [DOCSTRING] [DECL] [INTERACTIVE] BODY...)"
-  (declare (doc-string 3) (indent 2))
+  (declare (doc-string 3) (indent 2)
+           ;; Expand to defalias on autoload gen
+           (autoload-macro expand))
   (or name (error "Cannot define '%s' as a function" name))
   (if (null
        (and (listp arglist)

lisp/emacs-lisp/cl-generic.el

@@ -230,9 +230,11 @@ SPECIALIZERS-FUNCTION takes as first argument a tag value TAG
 (defmacro cl-defgeneric (name args &rest options-and-methods)
   "Create a generic function NAME.
 DOC-STRING is the base documentation for this class.  A generic
-function has no body, as its purpose is to decide which method body
-is appropriate to use.  Specific methods are defined with `cl-defmethod'.
-With this implementation the ARGS are currently ignored.
+function usually has no body, as its purpose is to decide which
+method body is appropriate to use; ARGS are currently ignored if
+there's no body.  If BODY is present, it provides the default
+implementation.
+Specific implementation methods are defined with `cl-defmethod'.
 OPTIONS-AND-METHODS currently understands:
 - (:documentation DOCSTRING)
 - (declare DECLARATIONS)
@@ -258,7 +260,9 @@ DEFAULT-BODY, if present, is used as the body of a default method.
                                cl--generic-edebug-make-name in:method]
                               lambda-doc
                               def-body)]]
-             def-body)))
+             def-body))
+           ;; Expand to defun and related forms on autoload definition
+           (autoload-macro expand))
   (let* ((doc (if (stringp (car-safe options-and-methods))
                   (pop options-and-methods)))
          (declarations nil)

lisp/emacs-lisp/cl-macs.el

@@ -396,7 +396,9 @@ more details.
                      [&optional ("interactive" interactive)]
                      def-body))
            (doc-string 3)
-           (indent 2))
+           (indent 2)
+           ;; expand to function definition on autoload gen
+           (autoload-macro expand))
   `(defun ,name ,@(cl--transform-lambda (cons args body) name)))
 
 ;;;###autoload
@@ -414,7 +416,9 @@ and BODY is implicitly surrounded by (cl-block NAME ...).
                      [&optional ("interactive" interactive)]
                      def-body))
            (doc-string 3)
-           (indent 2))
+           (indent 2)
+           ;; expand (eventually) to function definition on autoload gen
+           (autoload-macro expand))
   (require 'generator)
   `(iter-defun ,name ,@(cl--transform-lambda (cons args body) name)))
 
@@ -473,7 +477,8 @@ more details.
   (declare (debug
             (&define name cl-macro-list cl-declarations-or-string def-body))
            (doc-string 3)
-           (indent 2))
+           (indent 2)
+           (autoload-macro expand))   ; expand to defmacro on autoload gen
   `(defmacro ,name ,@(cl--transform-lambda (cons args body) name)))
 
 (def-edebug-elem-spec 'cl-lambda-expr
@@ -3087,7 +3092,9 @@ To see the documentation for a defined struct type, use
                         sexp])]
              [&optional stringp]
              ;; All the above is for the following def-form.
-             &rest &or symbolp (symbolp &optional def-form &rest sexp))))
+             &rest &or symbolp (symbolp &optional def-form &rest sexp)))
+           ;; expand to function definitions and related forms on autoload gen
+           (autoload-macro expand))
   (let* ((name (if (consp struct) (car struct) struct))
 	 (warning nil)
 	 (opts (cdr-safe struct))

lisp/emacs-lisp/easy-mmode.el

@@ -222,10 +222,12 @@ INIT-VALUE LIGHTER KEYMAP.
            (indent defun)
            (debug (&define name string-or-null-p
 			   [&optional [&not keywordp] sexp
-			    &optional [&not keywordp] sexp
-			    &optional [&not keywordp] sexp]
+			              &optional [&not keywordp] sexp
+			              &optional [&not keywordp] sexp]
 			   [&rest [keywordp sexp]]
-			   def-body)))
+			   def-body))
+           ;; expand to the command definition on autoload gen
+           (autoload-macro expand))
 
   (let* ((last-message (make-symbol "last-message"))
          (mode-name (symbol-name mode))
@@ -488,7 +490,9 @@ after running the major mode's hook.  However, MODE is not turned
 on if the hook has explicitly disabled it.
 
 \(fn GLOBAL-MODE MODE TURN-ON [KEY VALUE]... BODY...)"
-  (declare (doc-string 2) (indent defun))
+  (declare (doc-string 2) (indent defun)
+           ;; expand to the minor-mode definition on autoload gen
+           (autoload-macro expand))
   (let* ((global-mode-name (symbol-name global-mode))
 	 (mode-name (symbol-name mode))
 	 (pretty-name (easy-mmode-pretty-mode-name mode))
@@ -499,8 +503,8 @@ on if the hook has explicitly disabled it.
 	 (MODE-enable-in-buffer
 	  (intern (concat global-mode-name "-enable-in-buffer")))
 	 (minor-MODE-hook (intern (concat mode-name "-hook")))
-	 (MODE-set-explicitly (intern (concat mode-name "-set-explicitly")))
-	 (MODE-major-mode (intern (concat (symbol-name mode) "-major-mode")))
+	 (MODE-set-explicitly (intern (concat mode-name "--set-explicitly")))
+	 (MODE-major-mode (intern (concat global-mode-name "--major-mode")))
          (MODE-predicate (intern (concat (replace-regexp-in-string
                                           "-mode\\'" "" global-mode-name)
                                          "-modes")))

lisp/emacs-lisp/generator.el

@@ -675,7 +675,8 @@ encapsulates the state of a computation that produces a sequence
 of values.  Callers can retrieve each value using `iter-next'."
   (declare (indent defun)
            (debug (&define name lambda-list lambda-doc &rest sexp))
-           (doc-string 3))
+           (doc-string 3)
+           (autoload-macro expand)) ; expand to the defun on autoload gen
   (cl-assert lexical-binding)
   (let* ((parsed-body (macroexp-parse-body body))
          (declarations (car parsed-body))

lisp/emacs-lisp/inline.el

@@ -135,7 +135,8 @@ After VARS is handled, BODY is evaluated in the new environment."
 This is like `defmacro', but has several advantages.
 See Info node `(elisp)Defining Functions' for more details."
   ;; FIXME: How can this work with CL arglists?
-  (declare (indent defun) (debug defun) (doc-string 3))
+  (declare (indent defun) (debug defun) (doc-string 3)
+           (autoload-macro expand))     ; expand to the defun on autoload gen
   (let ((doc (if (stringp (car-safe body)) (list (pop body))))
         (declares (if (eq (car-safe (car-safe body)) 'declare) (pop body)))
         (cm-name (intern (format "%s--inliner" name)))

lisp/emacs-lisp/loaddefs-gen.el

@@ -143,12 +143,37 @@ scanning for autoloads and will be in the `load-path'."
              3)
         form))
 
+;; The following macros are known to define functions, and are treated
+;; specially when encountered during autoload generation, translating
+;; calls to them directly into appropriate (autoload function ...)
+;; forms.
+;;
+;; An alternative to appearing on this list is for a macro to declare
+;; (autoload-macro expand), so calls to it get expanded into more basic
+;; forms during generation.  Macros may be removed from this list once
+;; they request such expansion and produce suitable output (e.g. by
+;; employing :autoload-end to omit unneeded forms).
+(defconst loaddefs--defining-macros
+  '( define-skeleton define-derived-mode define-compilation-mode
+     define-generic-mode define-globalized-minor-mode define-minor-mode
+     cl-defun defun* cl-defmacro defmacro* define-overloadable-function
+     transient-define-prefix transient-define-suffix transient-define-infix
+     transient-define-argument transient-define-group
+     ;; Obsolete; keep until the alias is removed.
+     easy-mmode-define-global-mode
+     easy-mmode-define-minor-mode
+     define-global-minor-mode))
+
+(defvar loaddefs--load-error-files nil)
 (defun loaddefs-generate--make-autoload (form file &optional expansion)
   "Turn FORM into an autoload or defvar for source file FILE.
 Returns nil if FORM is not a special autoload form (i.e. a function definition
 or macro definition or a defcustom).
 If EXPANSION is non-nil, we're processing the macro expansion of an
-expression, in which case we want to handle forms differently."
+expression, in which case we want to handle forms differently.
+
+Note that macros can request expansion by including `(autoload-macro
+expand)' among their `declare' forms."
   (let ((car (car-safe form)) expand)
     (cond
      ((and expansion (eq car 'defalias))
@@ -192,42 +217,58 @@ expression, in which case we want to handle forms differently."
           (setq form (copy-sequence form))
           (setcdr (memq :autoload-end form) nil))
         (let ((exps (delq nil (mapcar (lambda (form)
-                                        (loaddefs-generate--make-autoload
-                                         form file expansion))
+                                        (unless (eq form :autoload-end)
+                                          (loaddefs-generate--make-autoload
+                                           form file expansion)))
                                       (cdr form)))))
           (when exps (cons 'progn exps)))))
 
-     ;; For complex cases, try again on the macro-expansion.
-     ((and (memq car '( define-globalized-minor-mode defun defmacro
-                        define-minor-mode define-inline
-                        cl-defun cl-defmacro cl-defgeneric
-                        cl-defstruct pcase-defmacro iter-defun cl-iter-defun
-                        ;; Obsolete; keep until the alias is removed.
-                        easy-mmode-define-global-mode
-                        easy-mmode-define-minor-mode
-                        define-global-minor-mode))
-           (macrop car)
-	   (setq expand (let ((load-true-file-name file)
-                              (load-file-name file))
-                          (macroexpand form)))
-	   (memq (car expand) '(progn prog1 defalias)))
+     ;; For macros which request it, try again on their expansion.
+     ((progn
+        ;; If the car is an unknown symbol, we load the file first to
+        ;; give packages a chance to define their macros.
+        (unless (or (not (symbolp car)) (fboundp car)
+                    ;; Special cases handled below
+                    (memq car loaddefs--defining-macros)
+                    (memq car '(defclass defcustom deftheme defgroup nil))
+                    (assoc file load-history)
+                    (member file loaddefs--load-error-files))
+          (let ((load-path (cons (file-name-directory file) load-path)))
+            (message "loaddefs-gen: loading file %s (for %s)" file car)
+            (condition-case e (load file)
+              (error
+               (push file loaddefs--load-error-files) ; do not attempt again
+               (warn "loaddefs-gen: load error\n\t%s" e)))))
+        (and (macrop car)
+	     (eq 'expand (function-get car 'autoload-macro))
+	     (setq expand (let ((load-true-file-name file)
+				(load-file-name file))
+			    (macroexpand form)))
+	     (or (and
+                  ;; Previously, macros defined in this list would not
+                  ;; see their expansions processed in place of
+                  ;; themselves if such an expansion did not yield a
+                  ;; `progn', `prog1' or `defalias' form.  Not
+                  ;; reproducing these conditions results in the
+                  ;; omission of minor mode variables and suchlike in
+                  ;; loaddefs.el when only the defuns in the
+                  ;; macroexpansions are autoloaded.
+                  (not (memq car '( define-globalized-minor-mode defun defmacro
+                                    define-minor-mode define-inline
+                                    cl-defun cl-defmacro cl-defgeneric
+                                    cl-defstruct pcase-defmacro iter-defun cl-iter-defun
+                                    ;; Obsolete; keep until the alias is removed.
+                                    easy-mmode-define-global-mode
+                                    easy-mmode-define-minor-mode
+                                    define-global-minor-mode)))
+                  (not (eq car (car expand))))
+                 (memq (car expand) '(progn prog1 defalias)))))
       ;; Recurse on the expansion.
       (loaddefs-generate--make-autoload expand file 'expansion))
 
-     ;; For special function-like operators, use the `autoload' function.
-     ((memq car '( define-skeleton define-derived-mode
-                   define-compilation-mode define-generic-mode
-                   define-globalized-minor-mode
-                   define-minor-mode
-		   cl-defun defun* cl-defmacro defmacro*
-                   define-overloadable-function
-                   transient-define-prefix transient-define-suffix
-                   transient-define-infix transient-define-argument
-                   transient-define-group
-                   ;; Obsolete; keep until the alias is removed.
-                   easy-mmode-define-global-mode
-                   easy-mmode-define-minor-mode
-                   define-global-minor-mode))
+     ;; For known special macros which define functions, use `autoload'
+     ;; directly.
+     ((memq car loaddefs--defining-macros)
       (let* ((macrop (memq car '(defmacro cl-defmacro defmacro*)))
 	     (name (nth 1 form))
 	     (args (pcase car
@@ -268,8 +309,8 @@ expression, in which case we want to handle forms differently."
                       t)
                  (and (eq (car-safe (car body)) 'interactive)
                       ;; List of modes or just t.
-                      (or (if (nthcdr 1 (car body))
-                              (list 'quote (nthcdr 1 (car body)))
+                      (or (if (nthcdr 2 (car body))
+                              (list 'quote (nthcdr 2 (car body)))
                             t))))
             ,(if macrop ''macro nil)))))
 

lisp/emacs-lisp/pcase.el

@@ -544,7 +544,9 @@ to this macro.
 By convention, DOC should use \"EXPVAL\" to stand
 for the result of evaluating EXP (first arg to `pcase').
 \n(fn NAME ARGS [DOC] &rest BODY...)"
-  (declare (indent 2) (debug defun) (doc-string 3))
+  (declare (indent 2) (debug defun) (doc-string 3)
+           ;; Expand to defun and related forms on autoload gen
+           (autoload-macro expand))
   ;; Add the function via `fsym', so that an autoload cookie placed
   ;; on a pcase-defmacro will cause the macro to be loaded on demand.
   (let ((fsym (intern (format "%s--pcase-macroexpander" name)))

lisp/emacs-lisp/timer.el

@@ -356,7 +356,7 @@ This function is called, by name, directly by the C code."
 (defun run-at-time (time repeat function &rest args)
   "Perform an action at time TIME.
 Repeat the action every REPEAT seconds, if REPEAT is non-nil.
-REPEAT may be an integer or floating point number.
+REPEAT may be a non-negative integer or floating point number.
 TIME should be one of:
 
 - a string giving today's time like \"11:23pm\"
@@ -386,10 +386,10 @@ This function returns a timer object which you can use in
 `cancel-timer'."
   (interactive "sRun at time: \nNRepeat interval: \naFunction: ")
 
-  (when (and repeat
-             (numberp repeat)
-             (< repeat 0))
-    (error "Invalid repetition interval"))
+  (unless (or (null repeat)
+              (and (numberp repeat)
+                   (>= repeat 0)))
+    (error "Invalid repetition interval: %s" repeat))
 
   (let ((timer (timer-create)))
     ;; Special case: nil means "now" and is useful when repeating.
@@ -433,6 +433,7 @@ This function returns a timer object which you can use in
   "Perform an action after a delay of SECS seconds.
 Repeat the action every REPEAT seconds, if REPEAT is non-nil.
 SECS and REPEAT may be integers or floating point numbers.
+REPEAT, if non-nil, must be a non-negative number.
 The action is to call FUNCTION with arguments ARGS.
 
 This function returns a timer object which you can use in `cancel-timer'."