Merge branch 'master' into feature/named-lambdas

diff --cc lisp/emacs-lisp/byte-run.el
Simple merge

diff --cc lisp/emacs-lisp/bytecomp.el
index 30c2480018a615e1da9a6e0f0019eddded5e51b6,72697fb73e19ad17f664635b00a991e529f765f4..2579d691bdc789d8508e24a0a51b759e5a559c3d
--- 1/lisp/emacs-lisp/bytecomp.el
--- 2/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@@ -1798,19 -1753,13 +1753,19 @@@ It is too wide if it has any lines long
           (setq docs (nth 3 form)))
          ('lambda
            (setq kind "")          ; can't be "function", unfortunately
 -          (setq docs (nth 2 form))))
 +          (let* ((definer (and (cadr form) (symbolp (cadr form))))
 +                 (docstring (nth (if definer 3 2) form)))
 +            (setq docs (and (stringp docstring)
 +                            docstring)))))
 +      (when (and (consp name) (eq (car name) 'quote))
 +        (setq name (cadr name)))
 +      (setq name (if name (format " `%s' " name) ""))
        (when (and kind docs (stringp docs))
-         (when (byte-compile--wide-docstring-p docs col)
-           (byte-compile-warn-x
-            name
-            "%s%sdocstring wider than %s characters"
-            kind name col))
+         (let ((col (max byte-compile-docstring-max-column fill-column)))
+           (when (byte-compile--wide-docstring-p docs col)
+             (byte-compile-warn-x
+              name
+              "%sdocstring wider than %s characters" (funcall prefix) col)))
          ;; There's a "naked" ' character before a symbol/list, so it
          ;; should probably be quoted with \=.
          (when (string-match-p (rx (| (in " \t") bol)

diff --cc lisp/emacs-lisp/cl-macs.el
Simple merge

diff --cc lisp/emacs-lisp/cl-print.el
Simple merge

diff --cc lisp/emacs-lisp/comp.el
Simple merge

diff --cc lisp/emacs-lisp/ert.el
Simple merge

diff --cc lisp/emacs-lisp/macroexp.el
index 8e35d1c205ea90f55eb35ae4da93be5f4b268c41,3ef924a5c736c75d54c7bd164c6de98934ccb115..242c71e65ad9e23ed2112b05605a95807b616546
--- 1/lisp/emacs-lisp/macroexp.el
--- 2/lisp/emacs-lisp/macroexp.el
+++ b/lisp/emacs-lisp/macroexp.el
@@@ -329,18 -329,35 +329,45 @@@ Assumes the caller has bound `macroexpa
          ;; I tried it, it broke the bootstrap :-(
          (let ((fn (car-safe form)))
            (pcase form
 +            (`(defalias ,(and `(quote ,def)
 +                              (pred (lambda (e) (and e (symbolp e)))))
 +                . ,_rest)
 +             (let ((defining-symbol def))
 +               (macroexp--all-forms form 2)))
 +            (`(,(or `defvar `defconst)
 +               ,(and def (pred (lambda (e) (and e (symbolp e)))))
 +               . ,(and _rest (pred (not null))))
 +             (let ((defining-symbol def))
 +               (macroexp--all-forms form 2)))
              (`(cond . ,clauses)
-              (macroexp--cons fn (macroexp--all-clauses clauses) form))
+              ;; Check for rubbish clauses at the end before macro-expansion,
+              ;; to avoid nuisance warnings from clauses that become
+              ;; unconditional through that process.
+              ;; FIXME: this strategy is defeated by forced `macroexpand-all',
+              ;; such as in `cl-flet'.  Haven't seen that in the wild, though.
+              (let ((default-tail nil)
+                    (n 0)
+                    (rest clauses))
+                (while rest
+                  (let ((c (car-safe (car rest))))
+                    (when (cond ((consp c) (and (memq (car c) '(quote function))
+                                                (cadr c)))
+                                ((symbolp c) (or (eq c t) (keywordp c)))
+                                (t t))
+                      ;; This is unquestionably a default clause.
+                      (setq default-tail (cdr rest))
+                      (setq clauses (take (1+ n) clauses))  ; trim the tail
+                      (setq rest nil)))
+                  (setq n (1+ n))
+                  (setq rest (cdr rest)))
+                (let ((expanded-form
+                       (macroexp--cons fn (macroexp--all-clauses clauses) form)))
+                  (if default-tail
+                      (macroexp-warn-and-return
+                       (format-message
+                        "Useless clause following default `cond' clause")
+                       expanded-form '(suspicious cond) t default-tail)
+                    expanded-form))))
              (`(condition-case . ,(or `(,err ,body . ,handlers) pcase--dontcare))
               (let ((exp-body (macroexp--expand-all body)))
                 (if handlers

diff --cc lisp/emacs-lisp/oclosure.el
Simple merge

diff --cc lisp/help.el
Simple merge

diff --cc lisp/progmodes/elisp-mode.el
Simple merge

diff --cc lisp/simple.el
Simple merge

diff --cc lisp/subr.el
Simple merge

diff --cc src/data.c
Simple merge

diff --cc src/lisp.h
Simple merge

diff --cc test/lisp/emacs-lisp/bytecomp-tests.el
Simple merge