upstream

31 files changed, 1426 insertions, 883 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 7c51b139ec3..f53b58b0129 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,228 @@
+2012-11-12  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/nadvice.el: New package.
+        * subr.el (special-form-p): New function.
+        * emacs-lisp/elp.el: Use lexical-binding and advice-add.
+        (elp-all-instrumented-list): Remove var.
+        (elp-not-profilable): Remove elp-wrapper.
+        (elp-profilable-p): Use autoloadp and special-form-p.
+        (elp--advice-name): New const.
+        (elp-instrument-function): Use advice-add.
+        (elp--instrumented-p): New predicate.
+        (elp-restore-function): Use advice-remove.
+        (elp-restore-all, elp-reset-all): Use mapatoms.
+        (elp-set-master): Use elp--instrumented-p.
+        (elp--make-wrapper): Rename from elp-wrapper, return a function
+        suitable for advice-add.  Use cl-inf.
+        (elp-results): Use mapatoms+elp--instrumented-p.
+        * emacs-lisp/debug.el: Use lexical-binding and advice-add.
+        (debug-function-list): Remove var.
+        (debug): Rename arg, and then let-bind it explicitly inside.
+        (debugger-setup-buffer): Rename arg.
+        (debugger-setup-buffer): Adjust counts to new debug-on-entry setup.
+        (debugger-frame-number): Adjust to new debug-on-entry setup.
+        (debug--implement-debug-on-entry): Rename from
+        implement-debug-on-entry, add argument.
+        (debugger-special-form-p): Remove, use special-form-p instead.
+        (debug-on-entry): Use advice-add.
+        (debug--function-list): New function.
+        (cancel-debug-on-entry): Use it, along with advice-remove.
+        (debug-arglist, debug-convert-byte-code, debug-on-entry-1): Remove.
+        (debugger-list-functions): Use debug--function-list instead of
+        debug-function-list.
+        * emacs-lisp/advice.el (ad-save-real-definition): Remove, unused.
+        (ad-special-form-p): Remove, use special-form-p instead.
+        (ad-set-advice-info): Use add-function and remove-function.
+        (ad--defalias-fset): Adjust accordingly.
+
+2012-11-10  Glenn Morris  <rgm@gnu.org>
+
+        * mail/emacsbug.el (report-emacs-bug-tracker-url)
+        (report-emacs-bug-bug-alist, report-emacs-bug-choice-widget)
+        (report-emacs-bug-create-existing-bugs-buffer)
+        (report-emacs-bug-parse-query-results)
+        (report-emacs-bug-query-existing-bugs): Remove.  (Bug#7449)
+
+        * term.el (term-default-fg-color, term-default-bg-color):
+        Make obsolete, rather than just saying "deprecated" in the doc.
+
+        * term.el (term): Rename from `term-face'.
+        (term-current-face, ansi-term-color-vector)
+        (term-default-fg-color, term-default-bg-color, term-ansi-reset):
+        Update all users.
+
+2012-11-10  Jan Djärv  <jan.h.d@swipnet.se>
+
+        * server.el (server-create-window-system-frame): Handle Nextstep
+        specially (Bug#12780).
+
+2012-11-10  Glenn Morris  <rgm@gnu.org>
+
+        * mail/emacsbug.el (report-emacs-bug-query-existing-bugs):
+        Unautoload, and make obsolete.  (Bug#7449)
+
+2012-11-10  Chong Yidong  <cyd@gnu.org>
+
+        * vc/diff-mode.el (diff-delete-trailing-whitespace): Rewrite, and
+        rename from diff-remove-trailing-whitespace (Bug#12831).
+
+2012-11-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/advice.el: Require `cl-lib' at run-time to fix
+        miscompilation of trace.el.
+
+2012-11-10  Glenn Morris  <rgm@gnu.org>
+
+        * vc/diff-mode.el (diff-remove-trailing-whitespace): Doc fix.
+
+2012-11-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/gv.el (gv-define-simple-setter): Fix last change
+        (bug#12812).
+
+2012-11-10  Chong Yidong  <cyd@gnu.org>
+
+        * minibuf-eldef.el (minibuffer-eldef-shorten-default): Convert to
+        a defcustom with an appropriate :set function.
+        (minibuffer-default--in-prompt-regexps): New function.
+
+2012-11-10  Glenn Morris  <rgm@gnu.org>
+
+        * emacs-lisp/cl.el (define-setf-expander, defsetf)
+        (define-modify-macro): Doc fixes.
+
+        * emacs-lisp/gv.el (gv-letplace): Fix doc typo.
+        (gv-define-simple-setter): Update doc of `fix-return'.
+
+2012-11-10  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/gv.el (gv-define-simple-setter): Don't evaluate `val'
+        twice when `fix-return' is set (bug#12813).
+
+        * emacs-lisp/cl.el (defsetf): Pass the third arg to
+        gv-define-simple-setter (bug#12812).
+
+        * woman.el (woman-decode-region): Disable adaptive-fill when rendering
+        (bug#12756).
+
+2012-11-10  Glenn Morris  <rgm@gnu.org>
+
+        * emacs-lisp/gv.el (gv-define-setter): Fix doc typo.
+
+        * emacs-lisp/cl-extra.el (cl-prettyexpand):
+        * emacs-lisp/cl-lib.el (cl-proclaim, cl-declaim):
+        * emacs-lisp/cl-macs.el (cl-destructuring-bind, cl-locally)
+        (cl-the, cl-compiler-macroexpand): Add basic doc strings.
+
+        * emacs-lisp/cl-extra.el (cl-maplist, cl-mapcan): Doc fix.
+
+2012-11-10  Leo Liu  <sdl.web@gmail.com>
+
+        * ido.el (ido-set-matches-1): Improve flex matching performance by
+        removing backtracking in the regexp (suggested by Stefan).  (Bug#12796)
+
+2012-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/advice.el (ad-set-advice-info): Set defalias-fset-function.
+        (ad--defalias-fset): New function.
+        (ad-safe-fset): Remove.
+        (ad-make-freeze-definition): Use cl-letf*.
+
+2012-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * subr.el (dolist): Don't bind VAR in RESULT.
+
+        * emacs-lisp/advice.el: Miscellaneous cleanup.  Use lexical-binding.
+        (fset, documentation): Don't save real def since we don't advise.
+        (ad-do-advised-functions): Remove problematic `result-form'.
+        (ad-safe-fset): `ad-real-fset' => `fset'.
+        (ad-read-advised-function): Don't assume that ad-do-advised-functions
+        uses CL's dolist internally.
+        (ad-arglist): Remove unused arg `name'.
+        (ad-docstring, ad-make-advised-docstring):
+        `ad-real-documentation' => `documentation'.
+        (warning-suppress-types): Declare.
+        (ad-set-arguments): Simple CSE.
+        (ad-recover-normality): Sanity check.
+
+        * emacs-lisp/bytecomp.el (byte-compile-out-toplevel): Don't turn
+        (funcall '(lambda ..) ..) into ((lambda ..) ..).
+
+2012-11-09  Vincent Belaïche  <vincentb1@users.sourceforge.net>
+
+        * ses.el: symbol to coordinate mapping is made by symbol property
+        `ses-cell'.  This means that the same mapping is done for all SES
+        sheets.  That is good enough for cells with standard A1 names, but
+        not for named cell.  So a hash map is added for the latter.
+        (defconst ses-localvars): Add local variable ses--named-cell-hashmap
+        (ses-sym-rowcol): Use hashmap for named cell.
+        (ses-is-cell-sym-p): New defun.
+        (ses-decode-cell-symbol): New defun.
+        (ses-create-cell-variable): Add cell to hashmap when name is not
+        A1-like.
+        (ses-rename-cell): Check that cell new name is not already in
+        spreadsheet with the use of ses-is-cell-sym-p
+        (ses-rename-cell): Use hash map for named cells, but accept also
+        renaming back to A1-like.
+
+2012-11-09  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/advice.el: Use new dynamic docstrings.
+        (ad-make-advised-definition-docstring, ad-advised-definition-p):
+        Use dynamic-docstring-function instead of ad-advice-info.
+        (ad--make-advised-docstring): New function extracted from
+        ad-make-advised-docstring.
+        (ad-make-advised-docstring): Use it.
+        * progmodes/sql.el (sql--make-help-docstring): New function, extracted
+        from sql-help.
+        (sql-help): Use it with dynamic-docstring-function.
+
+        * env.el (env--substitute-vars-regexp): Don't use rx (for bootstrap).
+
+2012-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * files.el (hack-one-local-variable--obsolete): New function.
+        (hack-one-local-variable): Use it for obsolete settings.
+
+        * subr.el (locate-user-emacs-file): If both old and new name exist, use
+        the new name.
+
+        * progmodes/js.el (js--filling-paragraph): New var.
+        (c-forward-sws, c-backward-sws, c-beginning-of-macro): Advise.
+        (js-c-fill-paragraph): Prefer advice to cl-letf so the rebinding is
+        less sneaky.
+
+2012-11-08  Julien Danjou  <julien@danjou.info>
+
+        * progmodes/ruby-mode.el (auto-mode-alist): Add Rakefile in
+        `auto-mode-alist' (Bug#12835).
+
+2012-11-08  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * progmodes/perl-mode.el (perl-prettify-symbols): New defcustom.
+        (perl--prettify-symbols-alist): New const.
+        (perl--font-lock-compose-symbol, perl--font-lock-symbols-keywords):
+        New functions.
+        (perl-font-lock-keywords-2): Use them.
+        (perl-electric-noindent-p): New function.
+        (perl-mode): Use it to set up electric-indent-mode.
+        (perl-electric-terminator, perl-indent-command): Mark obsolete.
+        (perl-mode-map): Remove bindings for them.
+        (perl-imenu-generic-expression, perl-outline-level):
+        Match functions&packages in column>0.
+
+        * env.el (env--substitute-vars-regexp): New const.
+        (substitute-env-vars): Use it.  Add `only-defined' arg.
+        * net/tramp.el (tramp-replace-environment-variables): Use it.
+
+        * emacs-lisp/bytecomp.el (byte-compile-initial-macro-environment):
+        Byte-compile *before* eval in eval-and-compile.
+        (byte-compile-log-warning): Remove redundant inhibit-read-only.
+        (byte-compile-file-form-autoload): Don't hide actual definition.
+        (byte-compile-maybe-guarded): Accept `functionp' as well.
+
+        * emacs-lisp/gv.el (gv-ref, gv-deref): New function and macro.
+
 2012-11-07  Michael Albinus  <michael.albinus@gmx.de>
 
         * notifications.el (notifications-get-server-information-method):
@@ -45,8 +270,8 @@
 
 2012-11-05  Agustín Martín Domingo  <agustin.martin@hispalinux.es>
 
-        * textmodes/ispell.el (ispell-program-name): Update
-        spellchecker parameters when customized.
+        * textmodes/ispell.el (ispell-program-name):
+        Update spellchecker parameters when customized.
 
 2012-11-04  Glenn Morris  <rgm@gnu.org>
 
@@ -440,7 +665,7 @@
 2012-10-19  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * minibuffer.el (minibuffer-force-complete): Make the next completion use
-        the same completion-field (bug@12221).
+        the same completion-field (bug#12221).
 
 2012-10-19  Martin Rudalics  <rudalics@gmx.at>
 
diff --git a/lisp/emacs-lisp/advice.el b/lisp/emacs-lisp/advice.el
index bd85238e23e..16c12aad29b 100644
--- a/lisp/emacs-lisp/advice.el
+++ b/lisp/emacs-lisp/advice.el
@@ -1,4 +1,4 @@
-;;; advice.el --- An overloading mechanism for Emacs Lisp functions
+;;; advice.el --- An overloading mechanism for Emacs Lisp functions  -*- lexical-binding: t -*-
 
 ;; Copyright (C) 1993-1994, 2000-2012 Free Software Foundation, Inc.
 
@@ -1709,7 +1709,8 @@
 ;; During a normal load this is a noop:
 (require 'advice-preload "advice.el")
 (require 'macroexp)
-(eval-when-compile (require 'cl-lib))
+;; At run-time also, since ad-do-advised-functions returns code that uses it.
+(require 'cl-lib)
 
 ;; @@ Variable definitions:
 ;; ========================
@@ -1775,36 +1776,6 @@ generates a copy of TREE."
          (funcall fUnCtIoN tReE))
         (t tReE)))
 
-;; @@ Save real definitions of subrs used by Advice:
-;; =================================================
-;; Advice depends on the real, unmodified functionality of various subrs,
-;; we save them here so advised versions will not interfere (eventually,
-;; we will save all subrs used in code generated by Advice):
-
-(defmacro ad-save-real-definition (function)
-  (let ((saved-function (intern (format "ad-real-%s" function))))
-    ;; Make sure the compiler is loaded during macro expansion:
-    (require 'byte-compile "bytecomp")
-    `(if (not (fboundp ',saved-function))
-      (progn (fset ',saved-function (symbol-function ',function))
-             ;; Copy byte-compiler properties:
-             ,@(if (get function 'byte-compile)
-                   `((put ',saved-function 'byte-compile
-                      ',(get function 'byte-compile))))
-             ,@(if (get function 'byte-opcode)
-                   `((put ',saved-function 'byte-opcode
-                      ',(get function 'byte-opcode))))))))
-
-(defun ad-save-real-definitions ()
-  ;; Macro expansion will hardcode the values of the various byte-compiler
-  ;; properties into the compiled version of this function such that the
-  ;; proper values will be available at runtime without loading the compiler:
-  (ad-save-real-definition fset)
-  (ad-save-real-definition documentation))
-
-(ad-save-real-definitions)
-
-
 ;; @@ Advice info access fns:
 ;; ==========================
 
@@ -1839,15 +1810,13 @@ generates a copy of TREE."
      ad-advised-functions)))
 
 (defmacro ad-do-advised-functions (varform &rest body)
-  "`dolist'-style iterator that maps over `ad-advised-functions'.
-\(ad-do-advised-functions (VAR [RESULT-FORM])
+  "`dolist'-style iterator that maps over advised functions.
+\(ad-do-advised-functions (VAR)
    BODY-FORM...)
 On each iteration VAR will be bound to the name of an advised function
 \(a symbol)."
   (declare (indent 1))
-  `(cl-dolist (,(car varform)
-               ad-advised-functions
-               ,(car (cdr varform)))
+  `(cl-dolist (,(car varform) ad-advised-functions)
      (setq ,(car varform) (intern (car ,(car varform))))
      ,@body))
 
@@ -1857,8 +1826,15 @@ On each iteration VAR will be bound to the name of an advised function
 (defmacro ad-get-advice-info-macro (function)
   `(get ,function 'ad-advice-info))
 
-(defmacro ad-set-advice-info (function advice-info)
-  `(put ,function 'ad-advice-info ,advice-info))
+(defsubst ad-set-advice-info (function advice-info)
+  (cond
+   (advice-info
+    (add-function :around (get function 'defalias-fset-function)
+                  #'ad--defalias-fset))
+   ((get function 'defalias-fset-function)
+    (remove-function (get function 'defalias-fset-function)
+                     #'ad--defalias-fset)))
+  (put function 'ad-advice-info advice-info))
 
 (defmacro ad-copy-advice-info (function)
   `(copy-tree (get ,function 'ad-advice-info)))
@@ -1866,7 +1842,7 @@ On each iteration VAR will be bound to the name of an advised function
 (defmacro ad-is-advised (function)
   "Return non-nil if FUNCTION has any advice info associated with it.
 This does not mean that the advice is also active."
-  (list 'ad-get-advice-info-macro function))
+  `(ad-get-advice-info-macro ,function))
 
 (defun ad-initialize-advice-info (function)
   "Initialize the advice info for FUNCTION.
@@ -1949,7 +1925,7 @@ Redefining advices affect the construction of an advised definition."
 (defun ad-has-any-advice (function)
   "True if the advice info of FUNCTION defines at least one advice."
   (and (ad-is-advised function)
-       (cl-dolist (class ad-advice-classes nil)
+       (cl-dolist (class ad-advice-classes)
          (if (ad-get-advice-info-field function class)
              (cl-return t)))))
 
@@ -1965,18 +1941,10 @@ Redefining advices affect the construction of an advised definition."
 ;; @@ Dealing with automatic advice activation via `fset/defalias':
 ;; ================================================================
 
-;; Since Emacs 19.26 the built-in versions of `fset' and `defalias'
-;; take care of automatic advice activation, hence, we don't have to
-;; hack it anymore by advising `fset/defun/defmacro/byte-code/etc'.
+;; Automatic activation happens when a function gets defined via `defalias',
+;; which calls the `defalias-fset-function' (which we set to
+;; `ad--defalias-fset') instead of `fset', if non-nil.
 
-;; The functionality of the new `fset' is as follows:
-;;
-;;     fset(sym,newdef)
-;;       assign NEWDEF to SYM
-;;       if (get SYM 'ad-advice-info)
-;;          ad-activate-internal(SYM, nil)
-;;       return (symbol-function SYM)
-;;
 ;; Whether advised definitions created by automatic activations will be
 ;; compiled depends on the value of `ad-default-compilation-action'.
 
@@ -1988,13 +1956,17 @@ Redefining advices affect the construction of an advised definition."
 ;; to `ad-activate' by using `ad-with-auto-activation-disabled' where
 ;; appropriate, especially in a safe version of `fset'.
 
+(defun ad--defalias-fset (fsetfun function definition)
+  (funcall (or fsetfun #'fset) function definition)
+  (ad-activate-internal function nil))
+
 ;; For now define `ad-activate-internal' to the dummy definition:
-(defun ad-activate-internal (function &optional compile)
+(defun ad-activate-internal (_function &optional _compile)
   "Automatic advice activation is disabled. `ad-start-advice' enables it."
   nil)
 
 ;; This is just a copy of the above:
-(defun ad-activate-internal-off (function &optional compile)
+(defun ad-activate-internal-off (_function &optional _compile)
   "Automatic advice activation is disabled. `ad-start-advice' enables it."
   nil)
 
@@ -2005,12 +1977,6 @@ Redefining advices affect the construction of an advised definition."
   `(let ((ad-activate-on-top-level nil))
     ,@body))
 
-(defun ad-safe-fset (symbol definition)
-  "A safe `fset' which will never call `ad-activate-internal' recursively."
-  (ad-with-auto-activation-disabled
-   (ad-real-fset symbol definition)))
-
-
 ;; @@ Access functions for original definitions:
 ;; ============================================
 ;; The advice-info of an advised function contains its `origname' which is
@@ -2030,8 +1996,7 @@ Redefining advices affect the construction of an advised definition."
         (symbol-function origname))))
 
 (defmacro ad-set-orig-definition (function definition)
-  `(ad-safe-fset
-    (ad-get-advice-info-field ,function 'origname) ,definition))
+  `(fset (ad-get-advice-info-field ,function 'origname) ,definition))
 
 (defmacro ad-clear-orig-definition (function)
   `(fmakunbound (ad-get-advice-info-field ,function 'origname)))
@@ -2052,7 +2017,7 @@ function at point for which PREDICATE returns non-nil)."
       (error "ad-read-advised-function: There are no advised functions"))
   (setq default
         (or default
-            ;; Prefer func name at point, if it's in ad-advised-functions etc.
+            ;; Prefer func name at point, if it's an advised function etc.
             (let ((function (progn
                               (require 'help)
                               (function-called-at-point))))
@@ -2061,24 +2026,20 @@ function at point for which PREDICATE returns non-nil)."
                    (or (null predicate)
                        (funcall predicate function))
                    function))
-            (ad-do-advised-functions (function)
-              (if (or (null predicate)
-                      (funcall predicate function))
-                  (cl-return function)))
+            (cl-block nil
+              (ad-do-advised-functions (function)
+                (if (or (null predicate)
+                        (funcall predicate function))
+                    (cl-return function))))
             (error "ad-read-advised-function: %s"
                    "There are no qualifying advised functions")))
-  (let* ((ad-pReDiCaTe predicate)
-         (function
+  (let* ((function
           (completing-read
            (format "%s (default %s): " (or prompt "Function") default)
            ad-advised-functions
            (if predicate
-               (function
-                (lambda (function)
-                  ;; Oops, no closures - the joys of dynamic scoping:
-                  ;; `predicate' clashed with the `predicate' argument
-                  ;; of `completing-read'.....
-                  (funcall ad-pReDiCaTe (intern (car function))))))
+               (lambda (function)
+                 (funcall predicate (intern (car function)))))
            t)))
     (if (equal function "")
         (if (ad-is-advised default)
@@ -2331,12 +2292,6 @@ See Info node `(elisp)Computed Advice' for detailed documentation."
   "Take a macro function DEFINITION and make a lambda out of it."
   `(cdr ,definition))
 
-(defun ad-special-form-p (definition)
-  "Non-nil if and only if DEFINITION is a special form."
-  (if (and (symbolp definition) (fboundp definition))
-      (setq definition (indirect-function definition)))
-  (and (subrp definition) (eq (cdr (subr-arity definition)) 'unevalled)))
-
 (defmacro ad-subr-p (definition)
   ;;"non-nil if DEFINITION is a subr."
   (list 'subrp definition))
@@ -2376,10 +2331,8 @@ See Info node `(elisp)Computed Advice' for detailed documentation."
          (cdr definition))
         (t nil)))
 
-(defun ad-arglist (definition &optional name)
-  "Return the argument list of DEFINITION.
-If DEFINITION could be from a subr then its NAME should be
-supplied to make subr arglist lookup more efficient."
+(defun ad-arglist (definition)
+  "Return the argument list of DEFINITION."
   (require 'help-fns)
   (help-function-arglist
    (if (or (ad-macro-p definition) (ad-advice-p definition))
@@ -2391,7 +2344,7 @@ supplied to make subr arglist lookup more efficient."
   "Return the unexpanded docstring of DEFINITION."
   (let ((docstring
          (if (ad-compiled-p definition)
-             (ad-real-documentation definition t)
+             (documentation definition t)
            (car (cdr (cdr (ad-lambda-expression definition)))))))
     (if (or (stringp docstring)
             (natnump docstring))
@@ -2414,13 +2367,15 @@ Like `interactive-form', but also works on pieces of advice."
                     (if (ad-interactive-form definition) 1 0))
                  (cdr (cdr (ad-lambda-expression definition)))))))
 
-(defun ad-make-advised-definition-docstring (function)
+(defun ad-make-advised-definition-docstring (_function)
   "Make an identifying docstring for the advised definition of FUNCTION.
 Put function name into the documentation string so we can infer
 the name of the advised function from the docstring.  This is needed
 to generate a proper advised docstring even if we are just given a
 definition (see the code for `documentation')."
-  (propertize "Advice doc string" 'ad-advice-info function))
+  (eval-when-compile
+    (propertize "Advice doc string" 'dynamic-docstring-function
+                #'ad--make-advised-docstring)))
 
 (defun ad-advised-definition-p (definition)
   "Return non-nil if DEFINITION was generated from advice information."
@@ -2429,14 +2384,14 @@ definition (see the code for `documentation')."
           (ad-compiled-p definition))
       (let ((docstring (ad-docstring definition)))
         (and (stringp docstring)
-             (get-text-property 0 'ad-advice-info docstring)))))
+             (get-text-property 0 'dynamic-docstring-function docstring)))))
 
 (defun ad-definition-type (definition)
   "Return symbol that describes the type of DEFINITION."
   (cond
    ((ad-macro-p definition) 'macro)
    ((ad-subr-p definition)
-    (if (ad-special-form-p definition)
+    (if (special-form-p definition)
         'special-form
       'subr))
    ((or (ad-lambda-p definition)
@@ -2473,6 +2428,7 @@ For that it has to be fbound with a non-autoload definition."
            (ad-macro-p (symbol-function function)))
        (not (ad-compiled-p (symbol-function function)))))
 
+(defvar warning-suppress-types)         ;From warnings.el.
 (defun ad-compile-function (function)
   "Byte-compiles FUNCTION (or macro) if it is not yet compiled."
   (interactive "aByte-compile function: ")
@@ -2603,24 +2559,20 @@ The assignment starts at position INDEX."
   (let ((values-index 0)
         argument-access set-forms)
     (while (setq argument-access (ad-access-argument arglist index))
-      (if (symbolp argument-access)
-          (setq set-forms
-                (cons (ad-set-argument
-                       arglist index
-                       (ad-element-access values-index 'ad-vAlUeS))
-                      set-forms))
-          (setq set-forms
-                (cons (if (= (car argument-access) 0)
-                          (list 'setq
-                                (car (cdr argument-access))
-                                (ad-list-access values-index 'ad-vAlUeS))
-                          (list 'setcdr
-                                (ad-list-access (1- (car argument-access))
-                                                (car (cdr argument-access)))
-                                (ad-list-access values-index 'ad-vAlUeS)))
-                      set-forms))
-          ;; terminate loop
-          (setq arglist nil))
+      (push (if (symbolp argument-access)
+                (ad-set-argument
+                 arglist index
+                 (ad-element-access values-index 'ad-vAlUeS))
+              (setq arglist nil) ;; Terminate loop.
+              (if (= (car argument-access) 0)
+                  `(setq
+                    ,(car (cdr argument-access))
+                    ,(ad-list-access values-index 'ad-vAlUeS))
+                `(setcdr
+                  ,(ad-list-access (1- (car argument-access))
+                                   (car (cdr argument-access)))
+                  ,(ad-list-access values-index 'ad-vAlUeS))))
+            set-forms)
       (setq index (1+ index))
       (setq values-index (1+ values-index)))
     (if (null set-forms)
@@ -2629,8 +2581,8 @@ The assignment starts at position INDEX."
         (if (= (length set-forms) 1)
             ;; For exactly one set-form we can use values-form directly,...
             (ad-substitute-tree
-             (function (lambda (form) (eq form 'ad-vAlUeS)))
-             (function (lambda (form) values-form))
+             (lambda (form) (eq form 'ad-vAlUeS))
+             (lambda (_form) values-form)
              (car set-forms))
             ;; ...if we have more we have to bind it to a variable:
             `(let ((ad-vAlUeS ,values-form))
@@ -2700,11 +2652,10 @@ Example: `(ad-map-arglists '(a &rest args) '(w x y z))' will return
             (cond (need-apply
                    ;; `apply' can take care of that directly:
                    (append source-reqopt-args (list source-rest-arg)))
-                  (t (mapcar (function
-                              (lambda (arg)
-                                (setq target-arg-index (1+ target-arg-index))
-                                (ad-get-argument
-                                 source-arglist target-arg-index)))
+                  (t (mapcar (lambda (_arg)
+                               (setq target-arg-index (1+ target-arg-index))
+                               (ad-get-argument
+                                source-arglist target-arg-index))
                              (append target-reqopt-args
                                      (and target-rest-arg
                                           ;; If we have a rest arg gobble up
@@ -2752,6 +2703,13 @@ Example: `(ad-map-arglists '(a &rest args) '(w x y z))' will return
 (require 'help-fns)         ;For help-split-fundoc and help-add-fundoc-usage.
 
 (defun ad-make-advised-docstring (function &optional style)
+  (let* ((origdef (ad-real-orig-definition function))
+         (origdoc
+          ;; Retrieve raw doc, key substitution will be taken care of later:
+          (documentation origdef t)))
+    (ad--make-advised-docstring origdoc function style)))
+
+(defun ad--make-advised-docstring (origdoc function &optional style)
   "Construct a documentation string for the advised FUNCTION.
 It concatenates the original documentation with the documentation
 strings of the individual pieces of advice which will be formatted
@@ -2761,11 +2719,8 @@ strings corresponds to before/around/after and the individual ordering
 in any of these classes."
   (let* ((origdef (ad-real-orig-definition function))
          (origtype (symbol-name (ad-definition-type origdef)))
-         (origdoc
-          ;; Retrieve raw doc, key substitution will be taken care of later:
-          (ad-real-documentation origdef t))
          (usage (help-split-fundoc origdoc function))
-         paragraphs advice-docstring ad-usage)
+         paragraphs advice-docstring)
     (setq usage (if (null usage) t (setq origdoc (cdr usage)) (car usage)))
     (if origdoc (setq paragraphs (list origdoc)))
     (unless (eq style 'plain)
@@ -2780,7 +2735,9 @@ in any of these classes."
                       (propertize
                        ;; separate paragraphs with blank lines:
                        (mapconcat 'identity (nreverse paragraphs) "\n\n")
-                       'ad-advice-info function)))
+                       ;; FIXME: what is this for?
+                       'dynamic-docstring-function
+                       #'ad--make-advised-docstring)))
     (help-add-fundoc-usage origdoc usage)))
 
 (defun ad-make-plain-docstring (function)
@@ -2823,10 +2780,10 @@ in any of these classes."
              (origname (ad-get-advice-info-field function 'origname))
              (orig-interactive-p (commandp origdef))
              (orig-subr-p (ad-subr-p origdef))
-             (orig-special-form-p (ad-special-form-p origdef))
+             (orig-special-form-p (special-form-p origdef))
              (orig-macro-p (ad-macro-p origdef))
              ;; Construct the individual pieces that we need for assembly:
-             (orig-arglist (ad-arglist origdef function))
+             (orig-arglist (ad-arglist origdef))
              (advised-arglist (or (ad-advised-arglist function)
                                   orig-arglist))
              (advised-interactive-form (ad-advised-interactive-form function))
@@ -2921,8 +2878,8 @@ should be modified.  The assembled function will be returned."
           (setq around-form-protected t))
       (setq around-form
             (ad-substitute-tree
-             (function (lambda (form) (eq form 'ad-do-it)))
-             (function (lambda (form) around-form))
+             (lambda (form) (eq form 'ad-do-it))
+             (lambda (_form) around-form)
              (macroexp-progn (ad-body-forms (ad-advice-definition advice))))))
 
     (setq after-forms
@@ -3057,10 +3014,10 @@ advised definition from scratch."
           (mapcar (function (lambda (advice) (ad-advice-name advice)))
                   (ad-get-enabled-advices function 'after))
           (ad-definition-type original-definition)
-          (if (equal (ad-arglist original-definition function)
+          (if (equal (ad-arglist original-definition)
                      (ad-arglist cached-definition))
               t
-            (ad-arglist original-definition function))
+            (ad-arglist original-definition))
           (if (eq (ad-definition-type original-definition) 'function)
               (equal (interactive-form original-definition)
                      (interactive-form cached-definition))))))
@@ -3105,7 +3062,7 @@ advised definition from scratch."
            (and (eq (nth 3 cache-id) (ad-definition-type original-definition))
                 (setq code 'arglist-mismatch)
                 (equal (if (eq (nth 4 cache-id) t)
-                           (ad-arglist original-definition function)
+                           (ad-arglist original-definition)
                          (nth 4 cache-id) )
                        (ad-arglist cached-definition))
                 (setq code 'interactive-form-mismatch)
@@ -3164,7 +3121,7 @@ advised definition from scratch."
       (ad-set-advice-info function old-advice-info)
       ;; Don't `fset' function to nil if it was previously unbound:
       (if function-defined-p
-          (ad-safe-fset function old-definition)
+          (fset function old-definition)
         (fmakunbound function)))))
 
 
@@ -3195,61 +3152,54 @@ advised definition from scratch."
       (error
        "ad-make-freeze-definition: `%s' is not yet defined"
        function))
-  (let* ((name (ad-advice-name advice))
-         ;; With a unique origname we can have multiple freeze advices
-         ;; for the same function, each overloading the previous one:
-         (unique-origname
-          (intern (format "%s-%s-%s" (ad-make-origname function) class name)))
-         (orig-definition
-          ;; If FUNCTION is already advised, we'll use its current origdef
-          ;; as the original definition of the frozen advice:
-          (or (ad-get-orig-definition function)
-              (symbol-function function)))
-         (old-advice-info
-          (if (ad-is-advised function)
-              (ad-copy-advice-info function)))
-         (real-docstring-fn
-          (symbol-function 'ad-make-advised-definition-docstring))
-         (real-origname-fn
-          (symbol-function 'ad-make-origname))
-         (frozen-definition
-          (unwind-protect
-               (progn
-                 ;; Make sure we construct a proper docstring:
-                 (ad-safe-fset 'ad-make-advised-definition-docstring
-                               'ad-make-freeze-docstring)
-                 ;; Make sure `unique-origname' is used as the origname:
-                 (ad-safe-fset 'ad-make-origname (lambda (x) unique-origname))
-                 ;; No we reset all current advice information to nil and
-                 ;; generate an advised definition that's solely determined
-                 ;; by ADVICE and the current origdef of FUNCTION:
-                 (ad-set-advice-info function nil)
-                 (ad-add-advice function advice class position)
-                 ;; The following will provide proper real docstrings as
-                 ;; well as a definition that will make the compiler happy:
-                 (ad-set-orig-definition function orig-definition)
-                 (ad-make-advised-definition function))
-            ;; Restore the old advice state:
-            (ad-set-advice-info function old-advice-info)
-            ;; Restore functions:
-            (ad-safe-fset
-             'ad-make-advised-definition-docstring real-docstring-fn)
-            (ad-safe-fset 'ad-make-origname real-origname-fn))))
+  (cl-letf*
+      ((name (ad-advice-name advice))
+       ;; With a unique origname we can have multiple freeze advices
+       ;; for the same function, each overloading the previous one:
+       (unique-origname
+        (intern (format "%s-%s-%s" (ad-make-origname function) class name)))
+       (orig-definition
+        ;; If FUNCTION is already advised, we'll use its current origdef
+        ;; as the original definition of the frozen advice:
+        (or (ad-get-orig-definition function)
+            (symbol-function function)))
+       (old-advice-info
+        (if (ad-is-advised function)
+            (ad-copy-advice-info function)))
+       ;; Make sure we construct a proper docstring:
+       ((symbol-function 'ad-make-advised-definition-docstring)
+        #'ad-make-freeze-docstring)
+       ;; Make sure `unique-origname' is used as the origname:
+       ((symbol-function 'ad-make-origname) (lambda (_x) unique-origname))
+       (frozen-definition
+        (unwind-protect
+            (progn
+              ;; No we reset all current advice information to nil and
+              ;; generate an advised definition that's solely determined
+              ;; by ADVICE and the current origdef of FUNCTION:
+              (ad-set-advice-info function nil)
+              (ad-add-advice function advice class position)
+              ;; The following will provide proper real docstrings as
+              ;; well as a definition that will make the compiler happy:
+              (ad-set-orig-definition function orig-definition)
+              (ad-make-advised-definition function))
+          ;; Restore the old advice state:
+          (ad-set-advice-info function old-advice-info))))
     (if frozen-definition
         (let* ((macro-p (ad-macro-p frozen-definition))
                (body (cdr (if macro-p
                               (ad-lambdafy frozen-definition)
-                              frozen-definition))))
+                            frozen-definition))))
           `(progn
-            (if (not (fboundp ',unique-origname))
-                (fset ',unique-origname
-                      ;; avoid infinite recursion in case the function
-                      ;; we want to freeze is already advised:
-                      (or (ad-get-orig-definition ',function)
-                          (symbol-function ',function))))
-            (,(if macro-p 'defmacro 'defun)
-             ,function
-             ,@body))))))
+             (if (not (fboundp ',unique-origname))
+                 (fset ',unique-origname
+                       ;; avoid infinite recursion in case the function
+                       ;; we want to freeze is already advised:
+                       (or (ad-get-orig-definition ',function)
+                           (symbol-function ',function))))
+             (,(if macro-p 'defmacro 'defun)
+              ,function
+              ,@body))))))
 
 
 ;; @@ Activation and definition handling:
@@ -3282,7 +3232,7 @@ The current definition and its cache-id will be put into the cache."
   (let ((verified-cached-definition
          (if (ad-verify-cache-id function)
              (ad-get-cache-definition function))))
-    (ad-safe-fset function
+    (fset function
                   (or verified-cached-definition
                       (ad-make-advised-definition function)))
     (if (ad-should-compile function compile)
@@ -3324,7 +3274,7 @@ the value of `ad-redefinition-action' and de/activate again."
                     (error "ad-handle-definition (see its doc): `%s' %s"
                            function "invalidly redefined")
                   (if (eq ad-redefinition-action 'discard)
-                      (ad-safe-fset function original-definition)
+                      (fset function original-definition)
                     (ad-set-orig-definition function current-definition)
                     (if (eq ad-redefinition-action 'warn)
                         (message "ad-handle-definition: `%s' got redefined"
@@ -3399,7 +3349,7 @@ a call to `ad-activate'."
            (if (not (ad-get-orig-definition function))
                (error "ad-deactivate: `%s' has no original definition"
                       function)
-             (ad-safe-fset function (ad-get-orig-definition function))
+             (fset function (ad-get-orig-definition function))
              (ad-set-advice-info-field function 'active nil)
              (eval (ad-make-hook-form function 'deactivation))
              function)))))
@@ -3437,7 +3387,7 @@ Use in emergencies."
           (completing-read "Recover advised function: " obarray nil t))))
   (cond ((ad-is-advised function)
          (cond ((ad-get-orig-definition function)
-                (ad-safe-fset function (ad-get-orig-definition function))
+                (fset function (ad-get-orig-definition function))
                 (ad-clear-orig-definition function)))
          (ad-set-advice-info function nil)
          (ad-pop-advised-function function))))
@@ -3669,28 +3619,22 @@ undone on exit of this macro."
                 ;; Make forms to redefine functions to their
                 ;; original definitions if they are advised:
                 (setq index -1)
-                (mapcar
-                 (function
-                  (lambda (function)
-                   (setq index (1+ index))
-                   `(ad-safe-fset
-                     ',function
-                     (or (ad-get-orig-definition ',function)
-                      ,(car (nth index current-bindings))))))
-                 functions))
+                (mapcar (lambda (function)
+                          (setq index (1+ index))
+                           `(fset ',function
+                            (or (ad-get-orig-definition ',function)
+                                ,(car (nth index current-bindings)))))
+                        functions))
              ,@body)
         ,@(progn
            ;; Make forms to back-define functions to the definitions
            ;; they had outside this macro call:
            (setq index -1)
-           (mapcar
-            (function
-             (lambda (function)
-              (setq index (1+ index))
-              `(ad-safe-fset
-                ',function
-                ,(car (nth index current-bindings)))))
-            functions))))))
+           (mapcar (lambda (function)
+                     (setq index (1+ index))
+                       `(fset ',function
+                       ,(car (nth index current-bindings))))
+                   functions))))))
 
 
 ;; @@ Starting, stopping and recovering from the advice package magic:
@@ -3701,7 +3645,7 @@ undone on exit of this macro."
   (interactive)
   ;; Advising `ad-activate-internal' means death!!
   (ad-set-advice-info 'ad-activate-internal nil)
-  (ad-safe-fset 'ad-activate-internal 'ad-activate))
+  (fset 'ad-activate-internal 'ad-activate))
 
 (defun ad-stop-advice ()
   "Stop the automatic advice handling magic.
@@ -3709,7 +3653,7 @@ You should only need this in case of Advice-related emergencies."
   (interactive)
   ;; Advising `ad-activate-internal' means death!!
   (ad-set-advice-info 'ad-activate-internal nil)
-  (ad-safe-fset 'ad-activate-internal 'ad-activate-internal-off))
+  (fset 'ad-activate-internal 'ad-activate-internal-off))
 
 (defun ad-recover-normality ()
   "Undo all advice related redefinitions and unadvises everything.
@@ -3717,9 +3661,11 @@ Use only in REAL emergencies."
   (interactive)
   ;; Advising `ad-activate-internal' means death!!
   (ad-set-advice-info 'ad-activate-internal nil)
-  (ad-safe-fset 'ad-activate-internal 'ad-activate-internal-off)
+  (fset 'ad-activate-internal 'ad-activate-internal-off)
   (ad-recover-all)
-  (setq ad-advised-functions nil))
+  (ad-do-advised-functions (function)
+    (message "Oops! Left over advised function %S" function)
+    (ad-pop-advised-function function)))
 
 (ad-start-advice)
 
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index e776df4ef37..a325e0f3e44 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -419,8 +419,8 @@ This list lives partly on the stack.")
 
 (defconst byte-compile-initial-macro-environment
   '(
-;;     (byte-compiler-options . (lambda (&rest forms)
-;;                             (apply 'byte-compiler-options-handler forms)))
+    ;; (byte-compiler-options . (lambda (&rest forms)
+    ;;                         (apply 'byte-compiler-options-handler forms)))
     (declare-function . byte-compile-macroexpand-declare-function)
     (eval-when-compile . (lambda (&rest body)
                            (list
@@ -429,8 +429,19 @@ This list lives partly on the stack.")
                              (byte-compile-top-level
                               (byte-compile-preprocess (cons 'progn body)))))))
     (eval-and-compile . (lambda (&rest body)
-                          (byte-compile-eval-before-compile (cons 'progn body))
-                          (cons 'progn body))))
+                          ;; Byte compile before running it.  Do it piece by
+                          ;; piece, in case further expressions need earlier
+                          ;; ones to be evaluated already, as is the case in
+                          ;; eieio.el.
+                          `(progn
+                             ,@(mapcar (lambda (exp)
+                                         (let ((cexp
+                                                (byte-compile-top-level
+                                                 (byte-compile-preprocess
+                                                  exp))))
+                                           (eval cexp)
+                                           cexp))
+                                       body)))))
   "The default macro-environment passed to macroexpand by the compiler.
 Placing a macro here will cause a macro to have different semantics when
 expanded by the compiler as when expanded by the interpreter.")
@@ -731,9 +742,11 @@ otherwise pop it")
 ;; Also, this lets us notice references to free variables.
 
 (defmacro byte-compile-push-bytecodes (&rest args)
-  "Push BYTE... onto BYTES, and increment PC by the number of bytes pushed.
-ARGS is of the form (BYTE... BYTES PC), where BYTES and PC are variable names.
-BYTES and PC are updated after evaluating all the arguments."
+  "Push bytes onto BVAR, and increment CVAR by the number of bytes pushed.
+BVAR and CVAR are variables which are updated after evaluating
+all the arguments.
+
+\(fn BYTE1 BYTE2 ... BYTEn BVAR CVAR)"
   (let ((byte-exprs (butlast args 2))
         (bytes-var (car (last args 2)))
         (pc-var (car (last args))))
@@ -1097,8 +1110,7 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
 (defun byte-compile-log-warning (string &optional fill level)
   (let ((warning-prefix-function 'byte-compile-warning-prefix)
         (warning-type-format "")
-        (warning-fill-prefix (if fill "    "))
-        (inhibit-read-only t))
+        (warning-fill-prefix (if fill "    ")))
     (display-warning 'bytecomp string level byte-compile-log-buffer)))
 
 (defun byte-compile-warn (format &rest args)
@@ -2189,7 +2201,10 @@ list that represents a doc string reference.
   (when (and (consp (nth 1 form))
            (eq (car (nth 1 form)) 'quote)
            (consp (cdr (nth 1 form)))
-           (symbolp (nth 1 (nth 1 form))))
+             (symbolp (nth 1 (nth 1 form)))
+             ;; Don't add it if it's already defined.  Otherwise, it might
+             ;; hide the actual definition.
+             (not (fboundp (nth 1 (nth 1 form)))))
     (push (cons (nth 1 (nth 1 form))
                 (cons 'autoload (cdr (cdr form))))
           byte-compile-function-environment)
@@ -2808,7 +2823,8 @@ for symbols generated by the byte compiler itself."
                   (setq body (nreverse body))
                   (setq body (list
                               (if (and (eq tmp 'funcall)
-                                       (eq (car-safe (car body)) 'quote))
+                                       (eq (car-safe (car body)) 'quote)
+                                       (symbolp (nth 1 (car body))))
                                   (cons (nth 1 (car body)) (cdr body))
                                 (cons tmp body))))
                   (or (eq output-type 'file)
@@ -3689,10 +3705,10 @@ If CONDITION's value is (not (featurep 'emacs)) or (featurep 'xemacs),
 that suppresses all warnings during execution of BODY."
   (declare (indent 1) (debug t))
   `(let* ((fbound-list (byte-compile-find-bound-condition
-                        ,condition (list 'fboundp)
+                        ,condition '(fboundp functionp)
                         byte-compile-unresolved-functions))
           (bound-list (byte-compile-find-bound-condition
-                       ,condition (list 'boundp 'default-boundp)))
+                       ,condition '(boundp default-boundp)))
           ;; Maybe add to the bound list.
           (byte-compile-bound-variables
            (append bound-list byte-compile-bound-variables)))
diff --git a/lisp/emacs-lisp/cl-extra.el b/lisp/emacs-lisp/cl-extra.el
index a57de344cf3..7c25972835b 100644
--- a/lisp/emacs-lisp/cl-extra.el
+++ b/lisp/emacs-lisp/cl-extra.el
@@ -131,7 +131,7 @@ TYPE is the sequence type to return.
 ;;;###autoload
 (defun cl-maplist (cl-func cl-list &rest cl-rest)
   "Map FUNCTION to each sublist of LIST or LISTs.
-Like `mapcar', except applies to lists and their cdr's rather than to
+Like `cl-mapcar', except applies to lists and their cdr's rather than to
 the elements themselves.
 \n(fn FUNCTION LIST...)"
   (if cl-rest
@@ -170,7 +170,7 @@ the elements themselves.
 
 ;;;###autoload
 (defun cl-mapcan (cl-func cl-seq &rest cl-rest)
-  "Like `mapcar', but nconc's together the values returned by the function.
+  "Like `cl-mapcar', but nconc's together the values returned by the function.
 \n(fn FUNCTION SEQUENCE...)"
   (apply 'nconc (apply 'cl-mapcar cl-func cl-seq cl-rest)))
 
@@ -675,6 +675,9 @@ PROPLIST is a list of the sort returned by `symbol-plist'.
 
 ;;;###autoload
 (defun cl-prettyexpand (form &optional full)
+  "Expand macros in FORM and insert the pretty-printed result.
+Optional argument FULL non-nil means to expand all macros,
+including `cl-block' and `cl-eval-when'."
   (message "Expanding...")
   (let ((cl--compiling-file full)
         (byte-compile-macro-environment nil))
diff --git a/lisp/emacs-lisp/cl-lib.el b/lisp/emacs-lisp/cl-lib.el
index 034a5c7517e..a9be08b1383 100644
--- a/lisp/emacs-lisp/cl-lib.el
+++ b/lisp/emacs-lisp/cl-lib.el
@@ -251,12 +251,17 @@ one value.
 (defvar cl-proclaims-deferred nil)
 
 (defun cl-proclaim (spec)
+  "Record a global declaration specified by SPEC."
   (if (fboundp 'cl-do-proclaim) (cl-do-proclaim spec t)
     (push spec cl-proclaims-deferred))
   nil)
 
 (defmacro cl-declaim (&rest specs)
-  (let ((body (mapcar (function (lambda (x) (list 'cl-proclaim (list 'quote x))))
+  "Like `cl-proclaim', but takes any number of unevaluated, unquoted arguments.
+Puts `(cl-eval-when (compile load eval) ...)' around the declarations
+so that they are registered at compile-time as well as run-time."
+  (let ((body (mapcar (function (lambda (x)
+                                  (list 'cl-proclaim (list 'quote x))))
                       specs)))
     (if (cl--compiling-file) (cl-list* 'cl-eval-when '(compile load eval) body)
       (cons 'progn body))))   ; avoid loading cl-macs.el for cl-eval-when
diff --git a/lisp/emacs-lisp/cl-loaddefs.el b/lisp/emacs-lisp/cl-loaddefs.el
index 5687f92083f..bf99af2f7e6 100644
--- a/lisp/emacs-lisp/cl-loaddefs.el
+++ b/lisp/emacs-lisp/cl-loaddefs.el
@@ -11,7 +11,7 @@
 ;;;;;;  cl--map-overlays cl--map-intervals cl--map-keymap-recursively
 ;;;;;;  cl-notevery cl-notany cl-every cl-some cl-mapcon cl-mapcan
 ;;;;;;  cl-mapl cl-mapc cl-maplist cl-map cl--mapcar-many cl-equalp
-;;;;;;  cl-coerce) "cl-extra" "cl-extra.el" "0e9284b6492cc98eee7c85ae4e5322ee")
+;;;;;;  cl-coerce) "cl-extra" "cl-extra.el" "8e9fee941c465ac0fee9b92a92d64154")
 ;;; Generated autoloads from cl-extra.el
 
 (autoload 'cl-coerce "cl-extra" "\
@@ -41,7 +41,7 @@ TYPE is the sequence type to return.
 
 (autoload 'cl-maplist "cl-extra" "\
 Map FUNCTION to each sublist of LIST or LISTs.
-Like `mapcar', except applies to lists and their cdr's rather than to
+Like `cl-mapcar', except applies to lists and their cdr's rather than to
 the elements themselves.
 
 \(fn FUNCTION LIST...)" nil nil)
@@ -57,7 +57,7 @@ Like `cl-maplist', but does not accumulate values returned by the function.
 \(fn FUNCTION LIST...)" nil nil)
 
 (autoload 'cl-mapcan "cl-extra" "\
-Like `mapcar', but nconc's together the values returned by the function.
+Like `cl-mapcar', but nconc's together the values returned by the function.
 
 \(fn FUNCTION SEQUENCE...)" nil nil)
 
@@ -248,7 +248,9 @@ Remove from SYMBOL's plist the property PROPNAME and its value.
 \(fn SYMBOL PROPNAME)" nil nil)
 
 (autoload 'cl-prettyexpand "cl-extra" "\
-
+Expand macros in FORM and insert the pretty-printed result.
+Optional argument FULL non-nil means to expand all macros,
+including `cl-block' and `cl-eval-when'.
 
 \(fn FORM &optional FULL)" nil nil)
 
@@ -265,7 +267,7 @@ Remove from SYMBOL's plist the property PROPNAME and its value.
 ;;;;;;  cl-typecase cl-ecase cl-case cl-load-time-value cl-eval-when
 ;;;;;;  cl-destructuring-bind cl-function cl-defmacro cl-defun cl-gentemp
 ;;;;;;  cl-gensym cl--compiler-macro-cXXr cl--compiler-macro-list*)
-;;;;;;  "cl-macs" "cl-macs.el" "146e82321e05b9e3fe8c70d7dbbab8a6")
+;;;;;;  "cl-macs" "cl-macs.el" "a7228877484d2b39e1c2bee40b011734")
 ;;; Generated autoloads from cl-macs.el
 
 (autoload 'cl--compiler-macro-list* "cl-macs" "\
@@ -320,7 +322,7 @@ its argument list allows full Common Lisp conventions.
 \(fn FUNC)" nil t)
 
 (autoload 'cl-destructuring-bind "cl-macs" "\
-
+Bind the variables in ARGS to the result of EXPR and execute BODY.
 
 \(fn ARGS EXPR &rest BODY)" nil t)
 
@@ -564,12 +566,12 @@ values.  For compatibility, (cl-values A B C) is a synonym for (list A B C).
 (put 'cl-multiple-value-setq 'lisp-indent-function '1)
 
 (autoload 'cl-locally "cl-macs" "\
-
+Equivalent to `progn'.
 
 \(fn &rest BODY)" nil t)
 
 (autoload 'cl-the "cl-macs" "\
-
+At present this ignores _TYPE and is simply equivalent to FORM.
 
 \(fn TYPE FORM)" nil t)
 
@@ -721,7 +723,10 @@ and then returning foo.
 \(fn FUNC ARGS &rest BODY)" nil t)
 
 (autoload 'cl-compiler-macroexpand "cl-macs" "\
-
+Like `macroexpand', but for compiler macros.
+Expands FORM repeatedly until no further expansion is possible.
+Returns FORM unchanged if it has no compiler macro, or if it has a
+macro that returns its `&whole' argument.
 
 \(fn FORM)" nil nil)
 
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index cd537cd43d6..f3bf36de376 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -554,6 +554,7 @@ its argument list allows full Common Lisp conventions."
 
 ;;;###autoload
 (defmacro cl-destructuring-bind (args expr &rest body)
+  "Bind the variables in ARGS to the result of EXPR and execute BODY."
   (declare (indent 2)
            (debug (&define cl-macro-list def-form cl-declarations def-body)))
   (let* ((cl--bind-lets nil) (cl--bind-forms nil) (cl--bind-inits nil)
@@ -1886,10 +1887,12 @@ values.  For compatibility, (cl-values A B C) is a synonym for (list A B C).
 
 ;;;###autoload
 (defmacro cl-locally (&rest body)
+  "Equivalent to `progn'."
   (declare (debug t))
   (cons 'progn body))
 ;;;###autoload
 (defmacro cl-the (_type form)
+  "At present this ignores _TYPE and is simply equivalent to FORM."
   (declare (indent 1) (debug (cl-type-spec form)))
   form)
 
@@ -2537,6 +2540,10 @@ and then returning foo."
 
 ;;;###autoload
 (defun cl-compiler-macroexpand (form)
+  "Like `macroexpand', but for compiler macros.
+Expands FORM repeatedly until no further expansion is possible.
+Returns FORM unchanged if it has no compiler macro, or if it has a
+macro that returns its `&whole' argument."
   (while
       (let ((func (car-safe form)) (handler nil))
         (while (and (symbolp func)
diff --git a/lisp/emacs-lisp/cl.el b/lisp/emacs-lisp/cl.el
index c5d0edf2009..3fb5b227c73 100644
--- a/lisp/emacs-lisp/cl.el
+++ b/lisp/emacs-lisp/cl.el
@@ -547,13 +547,15 @@ deprecated usage of `symbol-function' in place forms)."  ; bug#12760
 
 (defmacro define-setf-expander (name arglist &rest body)
   "Define a `setf' method.
-This method shows how to handle `setf's to places of the form (NAME ARGS...).
-The argument forms ARGS are bound according to ARGLIST, as if NAME were
-going to be expanded as a macro, then the BODY forms are executed and must
-return a list of five elements: a temporary-variables list, a value-forms
-list, a store-variables list (of length one), a store-form, and an access-
-form.  See `gv-define-expander', `gv-define-setter', and `gv-define-expander'
-for a better and simpler ways to define setf-methods."
+This method shows how to handle `setf's to places of the form
+\(NAME ARGS...).  The argument forms ARGS are bound according to
+ARGLIST, as if NAME were going to be expanded as a macro, then
+the BODY forms are executed and must return a list of five elements:
+a temporary-variables list, a value-forms list, a store-variables list
+\(of length one), a store-form, and an access- form.
+
+See `gv-define-expander', and `gv-define-setter' for better and
+simpler ways to define setf-methods."
   (declare (debug
             (&define name cl-lambda-list cl-declarations-or-string def-body)))
   `(progn
@@ -566,23 +568,31 @@ for a better and simpler ways to define setf-methods."
 
 (defmacro defsetf (name arg1 &rest args)
   "Define a `setf' method.
-This macro is an easy-to-use substitute for `define-setf-expander' that works
-well for simple place forms.  In the simple `defsetf' form, `setf's of
-the form (setf (NAME ARGS...) VAL) are transformed to function or macro
-calls of the form (FUNC ARGS... VAL).  Example:
+This macro is an easy-to-use substitute for `define-setf-expander'
+that works well for simple place forms.
+
+In the simple `defsetf' form, `setf's of the form (setf (NAME
+ARGS...) VAL) are transformed to function or macro calls of the
+form (FUNC ARGS... VAL).  For example:
 
   (defsetf aref aset)
 
+You can replace this form with `gv-define-simple-setter'.
+
 Alternate form: (defsetf NAME ARGLIST (STORE) BODY...).
-Here, the above `setf' call is expanded by binding the argument forms ARGS
-according to ARGLIST, binding the value form VAL to STORE, then executing
-BODY, which must return a Lisp form that does the necessary `setf' operation.
-Actually, ARGLIST and STORE may be bound to temporary variables which are
-introduced automatically to preserve proper execution order of the arguments.
-Example:
+
+Here, the above `setf' call is expanded by binding the argument
+forms ARGS according to ARGLIST, binding the value form VAL to
+STORE, then executing BODY, which must return a Lisp form that
+does the necessary `setf' operation.  Actually, ARGLIST and STORE
+may be bound to temporary variables which are introduced
+automatically to preserve proper execution order of the arguments.
+For example:
 
   (defsetf nth (n x) (v) `(setcar (nthcdr ,n ,x) ,v))
 
+You can replace this form with `gv-define-setter'.
+
 \(fn NAME [FUNC | ARGLIST (STORE) BODY...])"
   (declare (debug
             (&define name
@@ -597,7 +607,7 @@ Example:
                           (cl-function
                            (lambda (,@(car args) ,@arg1) ,@(cdr args)))
                           do args)))
-    `(gv-define-simple-setter ,name ,arg1)))
+    `(gv-define-simple-setter ,name ,arg1 ,(car args))))
 
 ;; FIXME: CL used to provide a setf method for `apply', but I haven't been able
 ;; to find a case where it worked.  The code below tries to handle it as well.
@@ -639,8 +649,12 @@ Example:
 
 (defmacro define-modify-macro (name arglist func &optional doc)
   "Define a `setf'-like modify macro.
-If NAME is called, it combines its PLACE argument with the other arguments
-from ARGLIST using FUNC: (define-modify-macro incf (&optional (n 1)) +)"
+If NAME is called, it combines its PLACE argument with the other
+arguments from ARGLIST using FUNC.  For example:
+
+  (define-modify-macro incf (&optional (n 1)) +)
+
+You can replace this macro with `gv-letplace'."
   (declare (debug
             (&define name cl-lambda-list ;; should exclude &key
                      symbolp &optional stringp)))
diff --git a/lisp/emacs-lisp/debug.el b/lisp/emacs-lisp/debug.el
index c04e68c0cfa..3d4f41be8ee 100644
--- a/lisp/emacs-lisp/debug.el
+++ b/lisp/emacs-lisp/debug.el
@@ -1,4 +1,4 @@
-;;; debug.el --- debuggers and related commands for Emacs
+;;; debug.el --- debuggers and related commands for Emacs  -*- lexical-binding: t -*-
 
 ;; Copyright (C) 1985-1986, 1994, 2001-2012 Free Software Foundation, Inc.
 
@@ -81,9 +81,6 @@ The value used here is passed to `quit-restore-window'."
   :group 'debugger
   :version "24.2")
 
-(defvar debug-function-list nil
-  "List of functions currently set for debug on entry.")
-
 (defvar debugger-step-after-exit nil
   "Non-nil means \"single-step\" after the debugger exits.")
 
@@ -146,7 +143,7 @@ where CAUSE can be:
 ;;;###autoload
 (setq debugger 'debug)
 ;;;###autoload
-(defun debug (&rest debugger-args)
+(defun debug (&rest args)
   "Enter debugger.  \\<debugger-mode-map>`\\[debugger-continue]' returns from the debugger.
 Arguments are mainly for use when this is called from the internals
 of the evaluator.
@@ -165,6 +162,7 @@ first will be printed into the backtrace buffer."
            (if (get-buffer "*Backtrace*")
                (with-current-buffer (get-buffer "*Backtrace*")
                  (list major-mode (buffer-string)))))
+          (debugger-args args)
           (debugger-buffer (get-buffer-create "*Backtrace*"))
           (debugger-old-buffer (current-buffer))
           (debugger-window nil)
@@ -219,7 +217,7 @@ first will be printed into the backtrace buffer."
             (save-excursion
               (when (eq (car debugger-args) 'debug)
                 ;; Skip the frames for backtrace-debug, byte-code,
-                ;; and implement-debug-on-entry.
+                ;; debug--implement-debug-on-entry and the advice's `apply'.
                 (backtrace-debug 4 t)
                 ;; Place an extra debug-on-exit for macro's.
                 (when (eq 'lambda (car-safe (cadr (backtrace-frame 4))))
@@ -318,7 +316,7 @@ first will be printed into the backtrace buffer."
       (setq debug-on-next-call debugger-step-after-exit)
       debugger-value)))
 
-(defun debugger-setup-buffer (debugger-args)
+(defun debugger-setup-buffer (args)
   "Initialize the `*Backtrace*' buffer for entry to the debugger.
 That buffer should be current already."
   (setq buffer-read-only nil)
@@ -334,20 +332,22 @@ That buffer should be current already."
   (delete-region (point)
                  (progn
                    (search-forward "\n  debug(")
-                   (forward-line (if (eq (car debugger-args) 'debug)
-                                     2  ; Remove implement-debug-on-entry frame.
+                   (forward-line (if (eq (car args) 'debug)
+                                     ;; Remove debug--implement-debug-on-entry
+                                     ;; and the advice's `apply' frame.
+                                     3
                                    1))
                    (point)))
   (insert "Debugger entered")
   ;; lambda is for debug-on-call when a function call is next.
   ;; debug is for debug-on-entry function called.
-  (pcase (car debugger-args)
+  (pcase (car args)
     ((or `lambda `debug)
      (insert "--entering a function:\n"))
     ;; Exiting a function.
     (`exit
      (insert "--returning value: ")
-     (setq debugger-value (nth 1 debugger-args))
+     (setq debugger-value (nth 1 args))
      (prin1 debugger-value (current-buffer))
      (insert ?\n)
      (delete-char 1)
@@ -356,7 +356,7 @@ That buffer should be current already."
     ;; Debugger entered for an error.
     (`error
      (insert "--Lisp error: ")
-     (prin1 (nth 1 debugger-args) (current-buffer))
+     (prin1 (nth 1 args) (current-buffer))
      (insert ?\n))
     ;; debug-on-call, when the next thing is an eval.
     (`t
@@ -364,8 +364,8 @@ That buffer should be current already."
     ;; User calls debug directly.
     (_
      (insert ": ")
-     (prin1 (if (eq (car debugger-args) 'nil)
-                (cdr debugger-args) debugger-args)
+     (prin1 (if (eq (car args) 'nil)
+                (cdr args) args)
             (current-buffer))
      (insert ?\n)))
   ;; After any frame that uses eval-buffer,
@@ -525,9 +525,10 @@ removes itself from that hook."
           (count 0))
       (while (not (eq (cadr (backtrace-frame count)) 'debug))
         (setq count (1+ count)))
-      ;; Skip implement-debug-on-entry frame.
-      (when (eq 'implement-debug-on-entry (cadr (backtrace-frame (1+ count))))
-        (setq count (1+ count)))
+      ;; Skip debug--implement-debug-on-entry frame.
+      (when (eq 'debug--implement-debug-on-entry
+                (cadr (backtrace-frame (1+ count))))
+        (setq count (+ 2 count)))
       (goto-char (point-min))
       (when (looking-at "Debugger entered--\\(Lisp error\\|returning value\\):")
         (goto-char (match-end 0))
@@ -694,10 +695,10 @@ Applies to the frame whose line point is on in the backtrace."
                   :help "Continue to exit from this frame, with all debug-on-entry suspended"))
     (define-key menu-map [deb-cont]
       '(menu-item "Continue" debugger-continue
-                  :help "Continue, evaluating this expression without stopping"))
+        :help "Continue, evaluating this expression without stopping"))
     (define-key menu-map [deb-step]
       '(menu-item "Step through" debugger-step-through
-                  :help "Proceed, stepping through subexpressions of this expression"))
+        :help "Proceed, stepping through subexpressions of this expression"))
     map))
 
 (put 'debugger-mode 'mode-class 'special)
@@ -777,7 +778,7 @@ For the cross-reference format, see `help-make-xrefs'."
 
 ;; When you change this, you may also need to change the number of
 ;; frames that the debugger skips.
-(defun implement-debug-on-entry ()
+(defun debug--implement-debug-on-entry (&rest _ignore)
   "Conditionally call the debugger.
 A call to this function is inserted by `debug-on-entry' to cause
 functions to break on entry."
@@ -785,12 +786,6 @@ functions to break on entry."
       nil
     (funcall debugger 'debug)))
 
-(defun debugger-special-form-p (symbol)
-  "Return whether SYMBOL is a special form."
-  (and (fboundp symbol)
-       (subrp (symbol-function symbol))
-       (eq (cdr (subr-arity (symbol-function symbol))) 'unevalled)))
-
 ;;;###autoload
 (defun debug-on-entry (function)
   "Request FUNCTION to invoke debugger each time it is called.
@@ -808,7 +803,7 @@ Use \\[cancel-debug-on-entry] to cancel the effect of this command.
 Redefining FUNCTION also cancels it."
   (interactive
    (let ((fn (function-called-at-point)) val)
-     (when (debugger-special-form-p fn)
+     (when (special-form-p fn)
        (setq fn nil))
      (setq val (completing-read
                 (if fn
@@ -817,36 +812,21 @@ Redefining FUNCTION also cancels it."
                 obarray
                 #'(lambda (symbol)
                     (and (fboundp symbol)
-                         (not (debugger-special-form-p symbol))))
+                         (not (special-form-p symbol))))
                 t nil nil (symbol-name fn)))
      (list (if (equal val "") fn (intern val)))))
-  ;; FIXME: Use advice.el.
-  (when (debugger-special-form-p function)
-    (error "Function %s is a special form" function))
-  (if (or (symbolp (symbol-function function))
-          (subrp (symbol-function function)))
-      ;; The function is built-in or aliased to another function.
-      ;; Create a wrapper in which we can add the debug call.
-      (fset function `(lambda (&rest debug-on-entry-args)
-                        ,(interactive-form (symbol-function function))
-                        (apply ',(symbol-function function)
-                               debug-on-entry-args)))
-    (when (autoloadp (symbol-function function))
-      ;; The function is autoloaded.  Load its real definition.
-      (autoload-do-load (symbol-function function) function))
-    (when (or (not (consp (symbol-function function)))
-              (and (eq (car (symbol-function function)) 'macro)
-                   (not (consp (cdr (symbol-function function))))))
-      ;; The function is byte-compiled.  Create a wrapper in which
-      ;; we can add the debug call.
-      (debug-convert-byte-code function)))
-  (unless (consp (symbol-function function))
-    (error "Definition of %s is not a list" function))
-  (fset function (debug-on-entry-1 function t))
-  (unless (memq function debug-function-list)
-    (push function debug-function-list))
+  (advice-add function :before #'debug--implement-debug-on-entry)
   function)
 
+(defun debug--function-list ()
+  "List of functions currently set for debug on entry."
+  (let ((funs '()))
+    (mapatoms
+     (lambda (s)
+       (when (advice-member-p #'debug--implement-debug-on-entry s)
+         (push s funs))))
+    funs))
+
 ;;;###autoload
 (defun cancel-debug-on-entry (&optional function)
   "Undo effect of \\[debug-on-entry] on FUNCTION.
@@ -857,80 +837,16 @@ To specify a nil argument interactively, exit with an empty minibuffer."
    (list (let ((name
                 (completing-read
                  "Cancel debug on entry to function (default all functions): "
-                 (mapcar 'symbol-name debug-function-list) nil t)))
+                 (mapcar #'symbol-name (debug--function-list)) nil t)))
            (when name
              (unless (string= name "")
                (intern name))))))
-  (if (and function
-           (not (string= function ""))) ; Pre 22.1 compatibility test.
+  (if function
       (progn
-        (let ((defn (debug-on-entry-1 function nil)))
-          (condition-case nil
-              (when (and (equal (nth 1 defn) '(&rest debug-on-entry-args))
-                         (eq (car (nth 3 defn)) 'apply))
-                ;; `defn' is a wrapper introduced in debug-on-entry.
-                ;; Get rid of it since we don't need it any more.
-                (setq defn (nth 1 (nth 1 (nth 3 defn)))))
-            (error nil))
-          (fset function defn))
-        (setq debug-function-list (delq function debug-function-list))
+        (advice-remove function #'debug--implement-debug-on-entry)
         function)
     (message "Cancelling debug-on-entry for all functions")
-    (mapcar 'cancel-debug-on-entry debug-function-list)))
-
-(defun debug-arglist (definition)
-  ;; FIXME: copied from ad-arglist.
-  "Return the argument list of DEFINITION."
-  (require 'help-fns)
-  (help-function-arglist definition 'preserve-names))
-
-(defun debug-convert-byte-code (function)
-  (let* ((defn (symbol-function function))
-         (macro (eq (car-safe defn) 'macro)))
-    (when macro (setq defn (cdr defn)))
-    (when (byte-code-function-p defn)
-      (let* ((args (debug-arglist defn))
-             (body
-              `((,(if (memq '&rest args) #'apply #'funcall)
-                 ,defn
-                 ,@(remq '&rest (remq '&optional args))))))
-        (if (> (length defn) 5)
-            ;; The mere presence of field 5 is sufficient to make
-            ;; it interactive.
-            (push `(interactive ,(aref defn 5)) body))
-        (if (and (> (length defn) 4) (aref defn 4))
-            ;; Use `documentation' here, to get the actual string,
-            ;; in case the compiled function has a reference
-            ;; to the .elc file.
-            (setq body (cons (documentation function) body)))
-        (setq defn `(closure (t) ,args ,@body)))
-      (when macro (setq defn (cons 'macro defn)))
-      (fset function defn))))
-
-(defun debug-on-entry-1 (function flag)
-  (let* ((defn (symbol-function function))
-         (tail defn))
-    (when (eq (car-safe tail) 'macro)
-      (setq tail (cdr tail)))
-    (if (not (memq (car-safe tail) '(closure lambda)))
-        ;; Only signal an error when we try to set debug-on-entry.
-        ;; When we try to clear debug-on-entry, we are now done.
-        (when flag
-          (error "%s is not a user-defined Lisp function" function))
-      (if (eq (car tail) 'closure) (setq tail (cdr tail)))
-      (setq tail (cdr tail))
-      ;; Skip the docstring.
-      (when (and (stringp (cadr tail)) (cddr tail))
-        (setq tail (cdr tail)))
-      ;; Skip the interactive form.
-      (when (eq 'interactive (car-safe (cadr tail)))
-        (setq tail (cdr tail)))
-      (unless (eq flag (equal (cadr tail) '(implement-debug-on-entry)))
-        ;; Add/remove debug statement as needed.
-        (setcdr tail (if flag
-                         (cons '(implement-debug-on-entry) (cdr tail))
-                       (cddr tail)))))
-    defn))
+    (mapcar #'cancel-debug-on-entry (debug--function-list))))
 
 (defun debugger-list-functions ()
   "Display a list of all the functions now set to debug on entry."
@@ -940,17 +856,18 @@ To specify a nil argument interactively, exit with an empty minibuffer."
                    (called-interactively-p 'interactive))
   (with-output-to-temp-buffer (help-buffer)
     (with-current-buffer standard-output
-      (if (null debug-function-list)
-          (princ "No debug-on-entry functions now\n")
-        (princ "Functions set to debug on entry:\n\n")
-        (dolist (fun debug-function-list)
-          (make-text-button (point) (progn (prin1 fun) (point))
-                            'type 'help-function
-                            'help-args (list fun))
-          (terpri))
-        (terpri)
-        (princ "Note: if you have redefined a function, then it may no longer\n")
-        (princ "be set to debug on entry, even if it is in the list.")))))
+      (let ((funs (debug--function-list)))
+        (if (null funs)
+            (princ "No debug-on-entry functions now\n")
+          (princ "Functions set to debug on entry:\n\n")
+          (dolist (fun funs)
+            (make-text-button (point) (progn (prin1 fun) (point))
+                              'type 'help-function
+                              'help-args (list fun))
+            (terpri))
+          (terpri)
+          (princ "Note: if you have redefined a function, then it may no longer\n")
+          (princ "be set to debug on entry, even if it is in the list."))))))
 
 (provide 'debug)
 
diff --git a/lisp/emacs-lisp/elp.el b/lisp/emacs-lisp/elp.el
index b94817cdb02..067b45f5cd8 100644
--- a/lisp/emacs-lisp/elp.el
+++ b/lisp/emacs-lisp/elp.el
@@ -1,4 +1,4 @@
-;;; elp.el --- Emacs Lisp Profiler
+;;; elp.el --- Emacs Lisp Profiler  -*- lexical-binding: t -*-
 
 ;; Copyright (C) 1994-1995, 1997-1998, 2001-2012
 ;;   Free Software Foundation, Inc.
@@ -124,6 +124,7 @@
 
 ;;; Code:
 
+(eval-when-compile (require 'cl-lib))
 
 ;; start of user configuration variables
 ;; vvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvvv
@@ -148,9 +149,9 @@ Results are displayed with the `elp-results' command."
   "Non-nil specifies ELP results sorting function.
 These functions are currently available:
 
-  elp-sort-by-call-count   -- sort by the highest call count
-  elp-sort-by-total-time   -- sort by the highest total time
-  elp-sort-by-average-time -- sort by the highest average times
+  `elp-sort-by-call-count'   -- sort by the highest call count
+  `elp-sort-by-total-time'   -- sort by the highest total time
+  `elp-sort-by-average-time' -- sort by the highest average times
 
 You can write your own sort function.  It should adhere to the
 interface specified by the PREDICATE argument for `sort'.
@@ -167,7 +168,7 @@ If a number, no function that has been called fewer than that number
 of times will be displayed in the output buffer.  If nil, all
 functions will be displayed."
   :type '(choice integer
-                 (const :tag "Show All" nil))
+                 (const :tag "Show All" nil))
   :group 'elp)
 
 (defcustom elp-use-standard-output nil
@@ -193,9 +194,6 @@ In other words, a new unique buffer is create every time you run
 (defconst elp-timer-info-property 'elp-info
   "ELP information property name.")
 
-(defvar elp-all-instrumented-list nil
-  "List of all functions currently being instrumented.")
-
 (defvar elp-record-p t
   "Controls whether functions should record times or not.
 This variable is set by the master function.")
@@ -205,7 +203,7 @@ This variable is set by the master function.")
 
 (defvar elp-not-profilable
   ;; First, the functions used inside each instrumented function:
-  '(elp-wrapper called-interactively-p
+  '(called-interactively-p
     ;; Then the functions used by the above functions.  I used
     ;; (delq nil (mapcar (lambda (x) (and (symbolp x) (fboundp x) x))
     ;;                   (aref (symbol-function 'elp-wrapper) 2)))
@@ -223,60 +221,21 @@ them would thus lead to infinite recursion.")
        (fboundp fun)
        (not (or (memq fun elp-not-profilable)
                 (keymapp fun)
-                (memq (car-safe (symbol-function fun)) '(autoload macro))
-                (condition-case nil
-                    (when (subrp (indirect-function fun))
-                      (eq 'unevalled
-                          (cdr (subr-arity (indirect-function fun)))))
-                  (error nil))))))
+                (autoloadp (symbol-function fun)) ;FIXME: Why not just load it?
+                (special-form-p fun)))))
 
+(defconst elp--advice-name 'ELP-instrumentation\ )
 
 ;;;###autoload
 (defun elp-instrument-function (funsym)
   "Instrument FUNSYM for profiling.
 FUNSYM must be a symbol of a defined function."
   (interactive "aFunction to instrument: ")
-  ;; restore the function.  this is necessary to avoid infinite
-  ;; recursion of already instrumented functions (i.e. elp-wrapper
-  ;; calling elp-wrapper ad infinitum).  it is better to simply
-  ;; restore the function than to throw an error.  this will work
-  ;; properly in the face of eval-defun because if the function was
-  ;; redefined, only the timer info will be nil'd out since
-  ;; elp-restore-function is smart enough not to trash the new
-  ;; definition.
-  (elp-restore-function funsym)
-  (let* ((funguts (symbol-function funsym))
-         (infovec (vector 0 0 funguts))
-         (newguts '(lambda (&rest args))))
-    ;; we cannot profile macros
-    (and (eq (car-safe funguts) 'macro)
-         (error "ELP cannot profile macro: %s" funsym))
-    ;; TBD: at some point it might be better to load the autoloaded
-    ;; function instead of throwing an error.  if we do this, then we
-    ;; probably want elp-instrument-package to be updated with the
-    ;; newly loaded list of functions.  i'm not sure it's smart to do
-    ;; the autoload here, since that could have side effects, and
-    ;; elp-instrument-function is similar (in my mind) to defun-ish
-    ;; type functionality (i.e. it shouldn't execute the function).
-    (and (autoloadp funguts)
-         (error "ELP cannot profile autoloaded function: %s" funsym))
+  (let* ((infovec (vector 0 0)))
     ;; We cannot profile functions used internally during profiling.
     (unless (elp-profilable-p funsym)
       (error "ELP cannot profile the function: %s" funsym))
-    ;; put rest of newguts together
-    (if (commandp funsym)
-        (setq newguts (append newguts '((interactive)))))
-    (setq newguts (append newguts `((elp-wrapper
-                                     (quote ,funsym)
-                                     ,(when (commandp funsym)
-                                        '(called-interactively-p 'any))
-                                     args))))
-    ;; to record profiling times, we set the symbol's function
-    ;; definition so that it runs the elp-wrapper function with the
-    ;; function symbol as an argument.  We place the old function
-    ;; definition on the info vector.
-    ;;
-    ;; The info vector data structure is a 3 element vector.  The 0th
+    ;; The info vector data structure is a 2 element vector.  The 0th
     ;; element is the call-count, i.e. the total number of times this
     ;; function has been entered.  This value is bumped up on entry to
     ;; the function so that non-local exists are still recorded. TBD:
@@ -285,72 +244,45 @@ FUNSYM must be a symbol of a defined function."
     ;; The 1st element is the total amount of time in seconds that has
     ;; been spent inside this function.  This number is added to on
     ;; function exit.
-    ;;
-    ;; The 2nd element is the old function definition list.  This gets
-    ;; funcall'd in between start/end time retrievals. I believe that
-    ;; this lets us profile even byte-compiled functions.
 
-    ;; put the info vector on the property list
+    ;; Put the info vector on the property list.
     (put funsym elp-timer-info-property infovec)
 
     ;; Set the symbol's new profiling function definition to run
-    ;; elp-wrapper.
-    (let ((advice-info (get funsym 'ad-advice-info)))
-      (if advice-info
-          (progn
-            ;; If function is advised, don't let Advice change
-            ;; its definition from under us during the `fset'.
-            (put funsym 'ad-advice-info nil)
-            (fset funsym newguts)
-            (put funsym 'ad-advice-info advice-info))
-        (fset funsym newguts)))
-
-    ;; add this function to the instrumentation list
-    (unless (memq funsym elp-all-instrumented-list)
-      (push funsym elp-all-instrumented-list))))
+    ;; ELP wrapper.
+    (advice-add funsym :around (elp--make-wrapper funsym)
+                `((name . ,elp--advice-name)))))
+
+(defun elp--instrumented-p (sym)
+  (advice-member-p elp--advice-name sym))
 
 (defun elp-restore-function (funsym)
   "Restore an instrumented function to its original definition.
 Argument FUNSYM is the symbol of a defined function."
-  (interactive "aFunction to restore: ")
-  (let ((info (get funsym elp-timer-info-property)))
-    ;; delete the function from the all instrumented list
-    (setq elp-all-instrumented-list
-          (delq funsym elp-all-instrumented-list))
-
-    ;; if the function was the master, reset the master
-    (if (eq funsym elp-master)
-        (setq elp-master nil
-              elp-record-p t))
-
-    ;; zap the properties
-    (put funsym elp-timer-info-property nil)
-
-    ;; restore the original function definition, but if the function
-    ;; wasn't instrumented do nothing.  we do this after the above
-    ;; because its possible the function got un-instrumented due to
-    ;; circumstances beyond our control.  Also, check to make sure
-    ;; that the current function symbol points to elp-wrapper.  If
-    ;; not, then the user probably did an eval-defun, or loaded a
-    ;; byte-compiled version, while the function was instrumented and
-    ;; we don't want to destroy the new definition.  can it ever be
-    ;; the case that a lisp function can be compiled instrumented?
-    (and info
-         (functionp funsym)
-         (not (byte-code-function-p (symbol-function funsym)))
-         (assq 'elp-wrapper (symbol-function funsym))
-         (fset funsym (aref info 2)))))
+  (interactive
+   (list
+    (intern
+     (completing-read "Function to restore: " obarray
+                      #'elp--instrumented-p t))))
+  ;; If the function was the master, reset the master.
+  (if (eq funsym elp-master)
+      (setq elp-master nil
+            elp-record-p t))
+
+  ;; Zap the properties.
+  (put funsym elp-timer-info-property nil)
+
+  (advice-remove funsym elp--advice-name))
 
 ;;;###autoload
 (defun elp-instrument-list (&optional list)
   "Instrument, for profiling, all functions in `elp-function-list'.
 Use optional LIST if provided instead.
 If called interactively, read LIST using the minibuffer."
-  (interactive "PList of functions to instrument: ")
+  (interactive "PList of functions to instrument: ") ;FIXME: Doesn't work?!
   (unless (listp list)
     (signal 'wrong-type-argument (list 'listp list)))
-  (let ((list (or list elp-function-list)))
-    (mapcar 'elp-instrument-function list)))
+  (mapcar #'elp-instrument-function (or list elp-function-list)))
 
 ;;;###autoload
 (defun elp-instrument-package (prefix)
@@ -371,15 +303,13 @@ For example, to instrument all ELP functions, do the following:
 (defun elp-restore-list (&optional list)
   "Restore the original definitions for all functions in `elp-function-list'.
 Use optional LIST if provided instead."
-  (interactive "PList of functions to restore: ")
-  (let ((list (or list elp-function-list)))
-    (mapcar 'elp-restore-function list)))
+  (interactive "PList of functions to restore: ") ;FIXME: Doesn't work!?
+  (mapcar #'elp-restore-function (or list elp-function-list)))
 
 (defun elp-restore-all ()
   "Restore the original definitions of all functions being profiled."
   (interactive)
-  (elp-restore-list elp-all-instrumented-list))
-
+  (mapatoms #'elp-restore-function))
 
 (defun elp-reset-function (funsym)
   "Reset the profiling information for FUNSYM."
@@ -395,30 +325,36 @@ Use optional LIST if provided instead."
 (defun elp-reset-list (&optional list)
   "Reset the profiling information for all functions in `elp-function-list'.
 Use optional LIST if provided instead."
-  (interactive "PList of functions to reset: ")
+  (interactive "PList of functions to reset: ") ;FIXME: Doesn't work!?
   (let ((list (or list elp-function-list)))
     (mapcar 'elp-reset-function list)))
 
 (defun elp-reset-all ()
   "Reset the profiling information for all functions being profiled."
   (interactive)
-  (elp-reset-list elp-all-instrumented-list))
+  (mapatoms (lambda (sym)
+              (if (get sym elp-timer-info-property)
+                  (elp-reset-function sym)))))
 
 (defun elp-set-master (funsym)
   "Set the master function for profiling."
-  (interactive "aMaster function: ")
-  ;; when there's a master function, recording is turned off by
-  ;; default
+  (interactive
+   (list
+    (intern
+     (completing-read "Master function: " obarray
+                      #'elp--instrumented-p
+                      t nil nil (if elp-master (symbol-name elp-master))))))
+  ;; When there's a master function, recording is turned off by default.
   (setq elp-master funsym
         elp-record-p nil)
-  ;; make sure master function is instrumented
-  (or (memq funsym elp-all-instrumented-list)
+  ;; Make sure master function is instrumented.
+  (or (elp--instrumented-p funsym)
       (elp-instrument-function funsym)))
 
 (defun elp-unset-master ()
   "Unset the master function."
   (interactive)
-  ;; when there's no master function, recording is turned on by default.
+  ;; When there's no master function, recording is turned on by default.
   (setq elp-master nil
         elp-record-p t))
 
@@ -426,49 +362,40 @@ Use optional LIST if provided instead."
 (defsubst elp-elapsed-time (start end)
   (float-time (time-subtract end start)))
 
-(defun elp-wrapper (funsym interactive-p args)
-  "This function has been instrumented for profiling by the ELP.
+(defun elp--make-wrapper (funsym)
+  "Make the piece of advice that instruments FUNSYM."
+  (lambda (func &rest args)
+    "This function has been instrumented for profiling by the ELP.
 ELP is the Emacs Lisp Profiler.  To restore the function to its
 original definition, use \\[elp-restore-function] or \\[elp-restore-all]."
-  ;; turn on recording if this is the master function
-  (if (and elp-master
-           (eq funsym elp-master))
-      (setq elp-record-p t))
-  ;; get info vector and original function symbol
-  (let* ((info (get funsym elp-timer-info-property))
-         (func (aref info 2))
-         result)
-    (or func
-        (error "%s is not instrumented for profiling" funsym))
-    (if (not elp-record-p)
-        ;; when not recording, just call the original function symbol
-        ;; and return the results.
-        (setq result
-              (if interactive-p
-                  (call-interactively func)
-                (apply func args)))
-      ;; we are recording times
-      (let (enter-time exit-time)
-        ;; increment the call-counter
-        (aset info 0 (1+ (aref info 0)))
-        ;; now call the old symbol function, checking to see if it
-        ;; should be called interactively.  make sure we return the
-        ;; correct value
-        (if interactive-p
-            (setq enter-time (current-time)
-                  result (call-interactively func)
-                  exit-time (current-time))
+    ;; turn on recording if this is the master function
+    (if (and elp-master
+             (eq funsym elp-master))
+        (setq elp-record-p t))
+    ;; get info vector and original function symbol
+    (let* ((info (get funsym elp-timer-info-property))
+           result)
+      (or func
+          (error "%s is not instrumented for profiling" funsym))
+      (if (not elp-record-p)
+          ;; when not recording, just call the original function symbol
+          ;; and return the results.
+          (setq result (apply func args))
+        ;; we are recording times
+        (let (enter-time exit-time)
+          ;; increment the call-counter
+          (cl-incf (aref info 0))
           (setq enter-time (current-time)
                 result (apply func args)
-                exit-time (current-time)))
-        ;; calculate total time in function
-        (aset info 1 (+ (aref info 1) (elp-elapsed-time enter-time exit-time)))
-        ))
-    ;; turn off recording if this is the master function
-    (if (and elp-master
-             (eq funsym elp-master))
-        (setq elp-record-p nil))
-    result))
+                exit-time (current-time))
+          ;; calculate total time in function
+          (cl-incf (aref info 1) (elp-elapsed-time enter-time exit-time))
+          ))
+      ;; turn off recording if this is the master function
+      (if (and elp-master
+               (eq funsym elp-master))
+          (setq elp-record-p nil))
+      result)))
 
 
 ;; shut the byte-compiler up
@@ -582,57 +509,58 @@ displayed."
            (elp-et-len    (length et-header))
            (at-header "Average Time")
            (elp-at-len    (length at-header))
-           (resvec
-            (mapcar
-             (function
-              (lambda (funsym)
-                (let* ((info (get funsym elp-timer-info-property))
-                       (symname (format "%s" funsym))
-                       (cc (aref info 0))
-                       (tt (aref info 1)))
-                  (if (not info)
-                      (insert "No profiling information found for: "
-                              symname)
-                    (setq longest (max longest (length symname)))
-                    (vector cc tt (if (zerop cc)
-                                      0.0 ;avoid arithmetic div-by-zero errors
-                                    (/ (float tt) (float cc)))
-                            symname)))))
-             elp-all-instrumented-list))
+           (resvec '())
            )                            ; end let*
+      (mapatoms
+       (lambda (funsym)
+         (when (elp--instrumented-p funsym)
+           (let* ((info (get funsym elp-timer-info-property))
+                  (symname (format "%s" funsym))
+                  (cc (aref info 0))
+                  (tt (aref info 1)))
+             (if (not info)
+                 (insert "No profiling information found for: "
+                         symname)
+               (setq longest (max longest (length symname)))
+               (push
+                (vector cc tt (if (zerop cc)
+                                  0.0 ;avoid arithmetic div-by-zero errors
+                                (/ (float tt) (float cc)))
+                        symname)
+                resvec))))))
       ;; If printing to stdout, insert the header so it will print.
       ;; Otherwise use header-line-format.
       (setq elp-field-len (max titlelen longest))
       (if (or elp-use-standard-output noninteractive)
-         (progn
-           (insert title)
-           (if (> longest titlelen)
-               (progn
-                 (insert-char 32 (- longest titlelen))))
-           (insert "  " cc-header "  " et-header "  " at-header "\n")
-           (insert-char ?= elp-field-len)
-           (insert "  ")
-           (insert-char ?= elp-cc-len)
-           (insert "  ")
-           (insert-char ?= elp-et-len)
-           (insert "  ")
-           (insert-char ?= elp-at-len)
-           (insert "\n"))
-       (let ((column 0))
-         (setq header-line-format
-               (mapconcat
-                (lambda (title)
-                  (prog1
-                      (concat
-                       (propertize " "
-                                   'display (list 'space :align-to column)
-                                   'face 'fixed-pitch)
-                       title)
-                    (setq column (+ column 2
-                                    (if (= column 0)
-                                        elp-field-len
-                                      (length title))))))
-                (list title cc-header et-header at-header) ""))))
+          (progn
+            (insert title)
+            (if (> longest titlelen)
+                (progn
+                  (insert-char 32 (- longest titlelen))))
+            (insert "  " cc-header "  " et-header "  " at-header "\n")
+            (insert-char ?= elp-field-len)
+            (insert "  ")
+            (insert-char ?= elp-cc-len)
+            (insert "  ")
+            (insert-char ?= elp-et-len)
+            (insert "  ")
+            (insert-char ?= elp-at-len)
+            (insert "\n"))
+        (let ((column 0))
+          (setq header-line-format
+                (mapconcat
+                 (lambda (title)
+                   (prog1
+                       (concat
+                        (propertize " "
+                                    'display (list 'space :align-to column)
+                                    'face 'fixed-pitch)
+                        title)
+                     (setq column (+ column 2
+                                     (if (= column 0)
+                                         elp-field-len
+                                       (length title))))))
+                 (list title cc-header et-header at-header) ""))))
       ;; if sorting is enabled, then sort the results list. in either
       ;; case, call elp-output-result to output the result in the
       ;; buffer
@@ -644,7 +572,7 @@ displayed."
     (pop-to-buffer resultsbuf)
     ;; copy results to standard-output?
     (if (or elp-use-standard-output noninteractive)
-       (princ (buffer-substring (point-min) (point-max)))
+        (princ (buffer-substring (point-min) (point-max)))
       (goto-char (point-min)))
     ;; reset profiling info if desired
     (and elp-reset-after-results
diff --git a/lisp/emacs-lisp/gv.el b/lisp/emacs-lisp/gv.el
index d6c91539a90..58bfae5b503 100644
--- a/lisp/emacs-lisp/gv.el
+++ b/lisp/emacs-lisp/gv.el
@@ -111,7 +111,7 @@ DO must return an Elisp expression."
 GETTER will be bound to a copyable expression that returns the value
 of PLACE.
 SETTER will be bound to a function that takes an expression V and returns
-and new expression that sets PLACE to V.
+a new expression that sets PLACE to V.
 BODY should return some Elisp expression E manipulating PLACE via GETTER
 and SETTER.
 The returned value will then be an Elisp expression that first evaluates
@@ -194,7 +194,7 @@ well for simple place forms.
 Assignments of VAL to (NAME ARGS...) are expanded by binding the argument
 forms (VAL ARGS...) according to ARGLIST, then executing BODY, which must
 return a Lisp form that does the assignment.
-The first arg in ARLIST (the one that receives VAL) receives an expression
+The first arg in ARGLIST (the one that receives VAL) receives an expression
 which can do arbitrary things, whereas the other arguments are all guaranteed
 to be pure and copyable.  Example use:
   (gv-define-setter aref (v a i) `(aset ,a ,i ,v))"
@@ -209,13 +209,20 @@ to be pure and copyable.  Example use:
 This macro is an easy-to-use substitute for `gv-define-expander' that works
 well for simple place forms.  Assignments of VAL to (NAME ARGS...) are
 turned into calls of the form (SETTER ARGS... VAL).
+
 If FIX-RETURN is non-nil, then SETTER is not assumed to return VAL and
-instead the assignment is turned into (prog1 VAL (SETTER ARGS... VAL))
+instead the assignment is turned into something equivalent to
+  \(let ((temp VAL))
+    (SETTER ARGS... temp)
+    temp)
 so as to preserve the semantics of `setf'."
   (declare (debug (sexp (&or symbolp lambda-expr) &optional sexp)))
-  (let ((set-call `(cons ',setter (append args (list val)))))
   `(gv-define-setter ,name (val &rest args)
-     ,(if fix-return `(list 'prog1 val ,set-call) set-call))))
+     ,(if fix-return
+          `(macroexp-let2 nil v val
+             (cons ',setter (append args (list v)))
+             v)
+        `(cons ',setter (append args (list val))))))
 
 ;;; Typical operations on generalized variables.
 
@@ -433,6 +440,26 @@ The return value is the last VAL in the list.
                        `(logior (logand ,v ,mask)
                                 (logand ,getter (lognot ,mask))))))))))
 
+;;; References
+
+;;;###autoload
+(defmacro gv-ref (place)
+  "Return a reference to PLACE.
+This is like the `&' operator of the C language."
+  (gv-letplace (getter setter) place
+    `(cons (lambda () ,getter)
+           (lambda (gv--val) ,(funcall setter 'gv--val)))))
+
+(defsubst gv-deref (ref)
+  "Dereference REF, returning the referenced value.
+This is like the `*' operator of the C language.
+REF must have been previously obtained with `gv-ref'."
+  (funcall (car ref)))
+;; Don't use `declare' because it seems to introduce circularity problems:
+;; Warning: Eager macro-expansion skipped due to cycle:
+;;  … => (load "gv.el") => (macroexpand-all (defsubst gv-deref …)) => (macroexpand (defun …)) => (load "gv.el")
+(gv-define-setter gv-deref (v ref) `(funcall (cdr ,ref) ,v))
+
 ;;; Vaguely related definitions that should be moved elsewhere.
 
 ;; (defun alist-get (key alist)
diff --git a/lisp/emacs-lisp/nadvice.el b/lisp/emacs-lisp/nadvice.el
new file mode 100644
index 00000000000..020a2f89bdb
--- /dev/null
+++ b/lisp/emacs-lisp/nadvice.el
@@ -0,0 +1,348 @@
+;;; nadvice.el --- Light-weight advice primitives for Elisp functions  -*- lexical-binding: t -*-
+
+;; Copyright (C) 2012  Free Software Foundation, Inc.
+
+;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
+;; Keywords: extensions, lisp, tools
+;; Package: emacs
+
+;; This program is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation, either version 3 of the License, or
+;; (at your option) any later version.
+
+;; This program is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+
+;; You should have received a copy of the GNU General Public License
+;; along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; This package lets you add behavior (which we call "piece of advice") to
+;; existing functions, like the old `advice.el' package, but with much fewer
+;; bells ans whistles.  It comes in 2 parts:
+;;
+;; - The first part lets you add/remove functions, similarly to
+;;   add/remove-hook, from any "place" (i.e. as accepted by `setf') that
+;;   holds a function.
+;;   This part provides mainly 2 macros: `add-function' and `remove-function'.
+;;
+;; - The second part provides `add-advice' and `remove-advice' which are
+;;   refined version of the previous macros specially tailored for the case
+;;   where the place that we want to modify is a `symbol-function'.
+
+;;; Code:
+
+;;;; Lightweight advice/hook
+(defvar advice--where-alist
+  '((:around "\300\301\302\003#\207" 5)
+    (:before "\300\301\002\"\210\300\302\002\"\207" 4)
+    (:after "\300\302\002\"\300\301\003\"\210\207" 5)
+    (:after-until "\300\302\002\"\206\013\000\300\301\002\"\207" 4)
+    (:after-while "\300\302\002\"\205\013\000\300\301\002\"\207" 4)
+    (:before-until "\300\301\002\"\206\013\000\300\302\002\"\207" 4)
+    (:before-while "\300\301\002\"\205\013\000\300\302\002\"\207" 4))
+  "List of descriptions of how to add a function.
+Each element has the form (WHERE BYTECODE STACK) where:
+  WHERE is a keyword indicating where the function is added.
+  BYTECODE is the corresponding byte-code that will be used.
+  STACK is the amount of stack space needed by the byte-code.")
+
+(defvar advice--bytecodes (mapcar #'cadr advice--where-alist))
+
+(defun advice--p (object)
+  (and (byte-code-function-p object)
+       (eq 128 (aref object 0))
+       (memq (length object) '(5 6))
+       (memq (aref object 1) advice--bytecodes)
+       (eq #'apply (aref (aref object 2) 0))))
+
+(defsubst advice--car   (f) (aref (aref f 2) 1))
+(defsubst advice--cdr   (f) (aref (aref f 2) 2))
+(defsubst advice--props (f) (aref (aref f 2) 3))
+
+(defun advice--make-docstring (_string function)
+  "Build the raw doc-string of SYMBOL, presumably advised."
+  (let ((flist (indirect-function function))
+        (docstring nil))
+    (if (eq 'macro (car-safe flist)) (setq flist (cdr flist)))
+    (while (advice--p flist)
+      (let ((bytecode (aref flist 1))
+            (where nil))
+        (dolist (elem advice--where-alist)
+          (if (eq bytecode (cadr elem)) (setq where (car elem))))
+        (setq docstring
+              (concat
+               docstring
+               (propertize (format "%s advice: " where)
+                           'face 'warning)
+               (let ((fun (advice--car flist)))
+                 (if (symbolp fun) (format "`%S'" fun)
+                   (let* ((name (cdr (assq 'name (advice--props flist))))
+                          (doc (documentation fun t))
+                          (usage (help-split-fundoc doc function)))
+                     (if usage (setq doc (cdr usage)))
+                     (if name
+                         (if doc
+                             (format "%s\n%s" name doc)
+                           (format "%s" name))
+                       (or doc "No documentation")))))
+               "\n")))
+      (setq flist (advice--cdr flist)))
+    (if docstring (setq docstring (concat docstring "\n")))
+    (let* ((origdoc (unless (eq function flist) ;Avoid inf-loops.
+                      (documentation flist t)))
+           (usage (help-split-fundoc origdoc function)))
+      (setq usage (if (null usage)
+                      (let ((arglist (help-function-arglist flist)))
+                        (format "%S" (help-make-usage function arglist)))
+                    (setq origdoc (cdr usage)) (car usage)))
+      (help-add-fundoc-usage (concat docstring origdoc) usage))))
+
+(defvar advice--docstring
+  ;; Can't eval-when-compile nor use defconst because it then gets pure-copied,
+  ;; which drops the text-properties.
+  ;;(eval-when-compile
+  (propertize "Advised function"
+              'dynamic-docstring-function #'advice--make-docstring)) ;; )
+
+(defun advice--make-interactive-form (function main)
+  ;; TODO: Make it possible to do around-like advising on the
+  ;; interactive forms (bug#12844).
+  ;; TODO: make it so that interactive spec can be a constant which
+  ;; dynamically checks the advice--car/cdr to do its job.
+  ;; TODO: Implement interactive-read-args:
+  ;;(when (or (commandp function) (commandp main))
+  ;;  `(interactive-read-args
+  ;;    (cadr (or (interactive-form function) (interactive-form main)))))
+  ;; FIXME: This loads autoloaded functions too eagerly.
+  (cadr (or (interactive-form function)
+            (interactive-form main))))
+
+(defsubst advice--make-1 (byte-code stack-depth function main props)
+  "Build a function value that adds FUNCTION to MAIN."
+  (let ((adv-sig (gethash main advertised-signature-table))
+        (advice
+         (apply #'make-byte-code 128 byte-code
+                (vector #'apply function main props) stack-depth
+                advice--docstring
+                (when (or (commandp function) (commandp main))
+                  (list (advice--make-interactive-form
+                         function main))))))
+    (when adv-sig (puthash advice adv-sig advertised-signature-table))
+    advice))
+
+(defun advice--make (where function main props)
+  "Build a function value that adds FUNCTION to MAIN at WHERE.
+WHERE is a symbol to select an entry in `advice--where-alist'."
+  (let ((desc (assq where advice--where-alist)))
+    (unless desc (error "Unknown add-function location `%S'" where))
+    (advice--make-1 (nth 1 desc) (nth 2 desc)
+                    function main props)))
+
+(defun advice--member-p (function definition)
+  (let ((found nil))
+    (while (and (not found) (advice--p definition))
+      (if (or (equal function (advice--car definition))
+              (equal function (cdr (assq 'name (advice--props definition)))))
+          (setq found t)
+        (setq definition (advice--cdr definition))))
+    found))
+
+;;;###autoload
+(defun advice--remove-function (flist function)
+  (if (not (advice--p flist))
+      flist
+    (let ((first (advice--car flist))
+          (props (advice--props flist)))
+      (if (or (equal function first)
+              (equal function (cdr (assq 'name props))))
+          (advice--cdr flist)
+        (let* ((rest (advice--cdr flist))
+               (nrest (advice--remove-function rest function)))
+          (if (eq rest nrest) flist
+            (advice--make-1 (aref flist 1) (aref flist 3)
+                            first nrest props)))))))
+
+;;;###autoload
+(defmacro add-function (where place function &optional props)
+  ;; TODO:
+  ;; - provide something like `around' for interactive forms.
+  ;; - provide some kind of buffer-local functionality at least when `place'
+  ;;   is a variable.
+  ;; - obsolete with-wrapper-hook (mostly requires buffer-local support).
+  ;; - provide some kind of control over ordering.  E.g. debug-on-entry, ELP
+  ;;   and tracing want to stay first.
+  ;; - maybe also let `where' specify some kind of predicate and use it
+  ;;   to implement things like mode-local or eieio-defmethod.
+  ;; :before is like a normal add-hook on a normal hook.
+  ;; :before-while is like add-hook on run-hook-with-args-until-failure.
+  ;; :before-until is like add-hook on run-hook-with-args-until-success.
+  ;; Same with :after-* but for (add-hook ... 'append).
+  "Add a piece of advice on the function stored at PLACE.
+FUNCTION describes the code to add.  WHERE describes where to add it.
+WHERE can be explained by showing the resulting new function, as the
+result of combining FUNCTION and the previous value of PLACE, which we
+call OLDFUN here:
+`:before'       (lambda (&rest r) (apply FUNCTION r) (apply OLDFUN r))
+`:after'        (lambda (&rest r) (prog1 (apply OLDFUN r) (apply FUNCTION r)))
+`:around'       (lambda (&rest r) (apply FUNCTION OLDFUN r))
+`:before-while' (lambda (&rest r) (and (apply FUNCTION r) (apply OLDFUN r)))
+`:before-until' (lambda (&rest r) (or  (apply FUNCTION r) (apply OLDFUN r)))
+`:after-while'  (lambda (&rest r) (and (apply OLDFUN r) (apply FUNCTION r)))
+`:after-until'  (lambda (&rest r) (or  (apply OLDFUN r) (apply FUNCTION r)))
+If FUNCTION was already added, do nothing.
+PROPS is an alist of additional properties, among which the following have
+a special meaning:
+- `name': a string or symbol.  It can be used to refer to this piece of advice."
+  (declare (debug t)) ;;(indent 2)
+  `(advice--add-function ,where (gv-ref ,place) ,function ,props))
+
+;;;###autoload
+(defun advice--add-function (where ref function props)
+  (unless (advice--member-p function (gv-deref ref))
+    (setf (gv-deref ref)
+          (advice--make where function (gv-deref ref) props))))
+
+(defmacro remove-function (place function)
+  "Remove the FUNCTION piece of advice from PLACE.
+If FUNCTION was not added to PLACE, do nothing.
+Instead of FUNCTION being the actual function, it can also be the `name'
+of the piece of advice."
+  (declare (debug t))
+  (gv-letplace (getter setter) place
+    (macroexp-let2 nil new `(advice--remove-function ,getter ,function)
+      `(unless (eq ,new ,getter) ,(funcall setter new)))))
+
+;;;; Specific application of add-function to `symbol-function' for advice.
+
+(defun advice--subst-main (old new)
+  (if (not (advice--p old))
+      new
+    (let* ((first (advice--car old))
+           (rest (advice--cdr old))
+           (props (advice--props old))
+           (nrest (advice--subst-main rest new)))
+      (if (equal rest nrest) old
+        (advice--make-1 (aref old 1) (aref old 3)
+                        first nrest props)))))
+
+(defun advice--defalias-fset (fsetfun symbol newdef)
+  (let* ((olddef (if (fboundp symbol) (symbol-function symbol)))
+         (oldadv
+          (cond
+             ((null (get symbol 'advice--pending))
+              (or olddef
+                  (progn
+                    (message "Delayed advice activation failed for %s: no data"
+                             symbol)
+                    nil)))
+             ((or (not olddef) (autoloadp olddef))
+              (prog1 (get symbol 'advice--pending)
+                (put symbol 'advice--pending nil)))
+           (t (message "Dropping left-over advice--pending for %s" symbol)
+              (put symbol 'advice--pending nil)
+              olddef))))
+    (funcall (or fsetfun #'fset) symbol (advice--subst-main oldadv newdef))))
+    
+
+;;;###autoload
+(defun advice-add (symbol where function &optional props)
+  "Like `add-function' but for the function named SYMBOL.
+Contrary to `add-function', this will properly handle the cases where SYMBOL
+is defined as a macro, alias, command, ..."
+  ;; TODO:
+  ;; - record the advice location, to display in describe-function.
+  ;; - change all defadvice in lisp/**/*.el.
+  ;; - rewrite advice.el on top of this.
+  ;; - obsolete advice.el.
+  ;; To make advice.el and nadvice.el interoperate properly I see 2 different
+  ;; ways:
+  ;; - keep them separate: complete the defalias-fset-function setter with
+  ;;   a matching accessor which both nadvice.el and advice.el will have to use
+  ;;   in place of symbol-function.  This can probably be made to work, but
+  ;;   they have to agree on a "protocol".
+  ;; - layer advice.el on top of nadvice.el.  I prefer this approach.  the
+  ;;   simplest way is to make advice.el build one ad-Advice-foo function for
+  ;;   each advised function which is advice-added/removed whenever ad-activate
+  ;;   ad-deactivate is called.
+  (let ((f (and (fboundp symbol) (symbol-function symbol))))
+    (cond
+     ((special-form-p f)
+      ;; Not worth the trouble trying to handle this, I think.
+      (error "add-advice failure: %S is a special form" symbol))
+     ((and (symbolp f)
+           (eq 'macro (car-safe (ignore-errors (indirect-function f)))))
+      (let ((newval (cons 'macro (cdr (indirect-function f)))))
+        (put symbol 'advice--saved-rewrite (cons f newval))
+        (fset symbol newval)))
+     ;; `f' might be a pure (hence read-only) cons!
+     ((and (eq 'macro (car-safe f)) (not (ignore-errors (setcdr f (cdr f)) t)))
+      (fset symbol (cons 'macro (cdr f))))
+     ))
+  (let ((f (and (fboundp symbol) (symbol-function symbol))))
+    (add-function where (cond
+                         ((eq (car-safe f) 'macro) (cdr f))
+                         ;; If the function is not yet defined, we can't yet
+                         ;; install the advice.
+                         ;; FIXME: If it's an autoloaded command, we also
+                         ;; have a problem because we need to load the
+                         ;; command to build the interactive-form.
+                         ((or (not f) (and (autoloadp f))) ;; (commandp f)
+                          (get symbol 'advice--pending))
+                         (t (symbol-function symbol)))
+                  function props)
+    (add-function :around (get symbol 'defalias-fset-function)
+                  #'advice--defalias-fset))
+  nil)
+
+;;;###autoload
+(defun advice-remove (symbol function)
+  "Like `remove-function' but for the function named SYMBOL.
+Contrary to `remove-function', this will work also when SYMBOL is a macro
+and it will not signal an error if SYMBOL is not `fboundp'.
+Instead of the actual function to remove, FUNCTION can also be the `name'
+of the piece of advice."
+  (when (fboundp symbol)
+    (let ((f (symbol-function symbol)))
+      ;; Can't use the `if' place here, because the body is too large,
+      ;; resulting in use of code that only works with lexical-scoping.
+      (remove-function (if (eq (car-safe f) 'macro)
+                           (cdr f)
+                         (symbol-function symbol))
+                       function)
+      (unless (advice--p
+               (if (eq (car-safe f) 'macro) (cdr f) (symbol-function symbol)))
+        ;; Not adviced any more.
+        (remove-function (get symbol 'defalias-fset-function)
+                         #'advice--defalias-fset)
+        (if (eq (symbol-function symbol)
+                (cdr (get symbol 'advice--saved-rewrite)))
+            (fset symbol (car (get symbol 'advice--saved-rewrite))))))
+    nil))
+
+;; (defun advice-mapc (fun symbol)
+;;   "Apply FUN to every function added as advice to SYMBOL.
+;; FUN is called with a two arguments: the function that was added, and the
+;; properties alist that was specified when it was added."
+;;   (let ((def (or (get symbol 'advice--pending)
+;;                  (if (fboundp symbol) (symbol-function symbol)))))
+;;     (while (advice--p def)
+;;       (funcall fun (advice--car def) (advice--props def))
+;;       (setq def (advice--cdr def)))))
+
+;;;###autoload
+(defun advice-member-p (function symbol)
+  "Return non-nil if advice FUNCTION has been added to function SYMBOL.
+Instead of FUNCTION being the actual function, it can also be the `name'
+of the piece of advice."
+  (advice--member-p function
+                    (or (get symbol 'advice--pending)
+                        (if (fboundp symbol) (symbol-function symbol)))))
+
+
+(provide 'nadvice)
+;;; nadvice.el ends here
diff --git a/lisp/env.el b/lisp/env.el
index d0d8ed0b998..5f7c61b719a 100644
--- a/lisp/env.el
+++ b/lisp/env.el
@@ -57,31 +57,28 @@ If it is also not t, RET does not exit if it does non-null completion."
 ;; History list for VALUE argument to setenv.
 (defvar setenv-history nil)
 
+(defconst env--substitute-vars-regexp
+  "\\$\\(?:\\(?1:[[:alnum:]_]+\\)\\|{\\(?1:[^{}]+\\)}\\|\\$\\)")
 
-(defun substitute-env-vars (string)
+(defun substitute-env-vars (string &optional only-defined)
   "Substitute environment variables referred to in STRING.
 `$FOO' where FOO is an environment variable name means to substitute
 the value of that variable.  The variable name should be terminated
 with a character not a letter, digit or underscore; otherwise, enclose
 the entire variable name in braces.  For instance, in `ab$cd-x',
 `$cd' is treated as an environment variable.
+If ONLY-DEFINED is nil, references to undefined environment variables
+are replaced by the empty string; if it is non-nil, they are left unchanged.
 
 Use `$$' to insert a single dollar sign."
   (let ((start 0))
-    (while (string-match
-            (eval-when-compile
-              (rx (or (and "$" (submatch (1+ (regexp "[[:alnum:]_]"))))
-                      (and "${" (submatch (minimal-match (0+ anything))) "}")
-                      "$$")))
-            string start)
+    (while (string-match env--substitute-vars-regexp string start)
       (cond ((match-beginning 1)
              (let ((value (getenv (match-string 1 string))))
+               (if (and (null value) only-defined)
+                   (setq start (match-end 0))
                (setq string (replace-match (or value "") t t string)
-                     start (+ (match-beginning 0) (length value)))))
-            ((match-beginning 2)
-             (let ((value (getenv (match-string 2 string))))
-               (setq string (replace-match (or value "") t t string)
-                     start (+ (match-beginning 0) (length value)))))
+                       start (+ (match-beginning 0) (length value))))))
             (t
              (setq string (replace-match "$" t t string)
                    start (+ (match-beginning 0) 1)))))
@@ -185,7 +182,7 @@ VARIABLE should be a string.  Value is nil if VARIABLE is undefined in
 the environment.  Otherwise, value is a string.
 
 If optional parameter FRAME is non-nil, then it should be a
-frame.  This function will look up VARIABLE in its 'environment
+frame.  This function will look up VARIABLE in its `environment'
 parameter.
 
 Otherwise, this function searches `process-environment' for
diff --git a/lisp/files.el b/lisp/files.el
index 26c5c683b3d..8e8a178caab 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -3387,30 +3387,39 @@ It is dangerous if either of these conditions are met:
                                 (setq ok t)))
                           ok))))))))
 
+(defun hack-one-local-variable--obsolete (var)
+  (let ((o (get var 'byte-obsolete-variable)))
+    (when o
+      (let ((instead (nth 0 o))
+            (since (nth 2 o)))
+        (message "%s is obsolete%s; %s"
+                 var (if since (format " (since %s)" since))
+                 (if (stringp instead) instead
+                   (format "use `%s' instead" instead)))))))
+
 (defun hack-one-local-variable (var val)
   "Set local variable VAR with value VAL.
 If VAR is `mode', call `VAL-mode' as a function unless it's
 already the major mode."
-  (cond ((eq var 'mode)
-         (let ((mode (intern (concat (downcase (symbol-name val))
-                                     "-mode"))))
-           (unless (eq (indirect-function mode)
-                       (indirect-function major-mode))
-             (if (memq mode minor-mode-list)
-                 ;; A minor mode must be passed an argument.
-                 ;; Otherwise, if the user enables the minor mode in a
-                 ;; major mode hook, this would toggle it off.
-                 (funcall mode 1)
-               (funcall mode)))))
-        ((eq var 'eval)
-         (save-excursion (eval val)))
-        (t
-         ;; Make sure the string has no text properties.
-         ;; Some text properties can get evaluated in various ways,
-         ;; so it is risky to put them on with a local variable list.
-         (if (stringp val)
-             (set-text-properties 0 (length val) nil val))
-         (set (make-local-variable var) val))))
+  (pcase var
+    (`mode
+     (let ((mode (intern (concat (downcase (symbol-name val))
+                                 "-mode"))))
+       (unless (eq (indirect-function mode)
+                   (indirect-function major-mode))
+         (funcall mode))))
+    (`eval
+     (pcase val
+       (`(add-hook ',hook . ,_) (hack-one-local-variable--obsolete hook)))
+     (save-excursion (eval val)))
+    (_
+     (hack-one-local-variable--obsolete var)
+     ;; Make sure the string has no text properties.
+     ;; Some text properties can get evaluated in various ways,
+     ;; so it is risky to put them on with a local variable list.
+     (if (stringp val)
+         (set-text-properties 0 (length val) nil val))
+     (set (make-local-variable var) val))))
 
 ;;; Handling directory-local variables, aka project settings.
 
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 78204897cf1..5f635e59cdf 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,8 @@
+2012-11-08  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * gnus-art.el (gnus-article-browse-html-parts): Always replace charset
+        in meta tag with the one the part specifies in its header.
+
 2012-11-02  Stephen Eglen  <S.J.Eglen@damtp.cam.ac.uk>
 
         * gnus-dired.el (gnus-dired-attach): Attach to last used message buffer
diff --git a/lisp/gnus/gnus-art.el b/lisp/gnus/gnus-art.el
index 6c827e070cb..edcd7da2ddd 100644
--- a/lisp/gnus/gnus-art.el
+++ b/lisp/gnus/gnus-art.el
@@ -2877,7 +2877,7 @@ message header will be added to the bodies of the \"text/html\" parts."
              ;; Add a meta html tag to specify charset and a header.
              (cond
               (header
-               (let (title eheader body hcharset coding force-charset)
+               (let (title eheader body hcharset coding)
                  (with-temp-buffer
                    (mm-enable-multibyte)
                    (setq case-fold-search t)
@@ -2900,8 +2900,7 @@ message header will be added to the bodies of the \"text/html\" parts."
                                                               charset)
                              title (when title
                                      (mm-encode-coding-string title charset))
-                             body (mm-encode-coding-string content charset)
-                             force-charset t)
+                             body (mm-encode-coding-string content charset))
                      (setq hcharset (mm-find-mime-charset-region (point-min)
                                                                  (point-max)))
                      (cond ((= (length hcharset) 1)
@@ -2932,8 +2931,7 @@ message header will be added to the bodies of the \"text/html\" parts."
                                        body (mm-encode-coding-string
                                              (mm-decode-coding-string
                                               content body)
-                                             charset)
-                                       force-charset t)))
+                                             charset))))
                            (setq charset hcharset
                                  eheader (mm-encode-coding-string
                                           (buffer-string) coding)
@@ -2947,7 +2945,7 @@ message header will be added to the bodies of the \"text/html\" parts."
                    (mm-disable-multibyte)
                    (insert body)
                    (when charset
-                     (mm-add-meta-html-tag handle charset force-charset))
+                     (mm-add-meta-html-tag handle charset t))
                    (when title
                      (goto-char (point-min))
                      (unless (search-forward "<title>" nil t)
diff --git a/lisp/ido.el b/lisp/ido.el
index 4ab183b3207..f4f9c27c847 100644
--- a/lisp/ido.el
+++ b/lisp/ido.el
@@ -3764,7 +3764,11 @@ This is to make them appear as if they were \"virtual buffers\"."
                ido-enable-flex-matching
                (> (length ido-text) 1)
                (not ido-enable-regexp))
-      (setq re (mapconcat #'regexp-quote (split-string ido-text "") ".*"))
+      (setq re (concat (regexp-quote (string (aref ido-text 0)))
+                       (mapconcat (lambda (c)
+                                    (concat "[^" (string c) "]*"
+                                            (regexp-quote (string c))))
+                                  (substring ido-text 1) "")))
       (if ido-enable-prefix
           (setq re (concat "\\`" re)))
       (mapc
diff --git a/lisp/mail/emacsbug.el b/lisp/mail/emacsbug.el
index 0066847e995..1d9d098e71c 100644
--- a/lisp/mail/emacsbug.el
+++ b/lisp/mail/emacsbug.el
@@ -60,10 +60,6 @@
 
 ;; User options end here.
 
-(defvar report-emacs-bug-tracker-url "http://debbugs.gnu.org/cgi/"
-  "Base URL of the GNU bugtracker.
-Used for querying duplicates and linking to existing bugs.")
-
 (defvar report-emacs-bug-orig-text nil
   "The automatically-created initial text of the bug report.")
 
@@ -444,90 +440,6 @@ and send the mail again%s."
         (delete-region pos (field-end (1+ pos)))))))
 
 
-;; Querying the bug database
-
-(defvar report-emacs-bug-bug-alist nil)
-(make-variable-buffer-local 'report-emacs-bug-bug-alist)
-(defvar report-emacs-bug-choice-widget nil)
-(make-variable-buffer-local 'report-emacs-bug-choice-widget)
-
-(defun report-emacs-bug-create-existing-bugs-buffer (bugs keywords)
-  (switch-to-buffer (get-buffer-create "*Existing Emacs Bugs*"))
-  (setq buffer-read-only t)
-  (let ((inhibit-read-only t))
-    (erase-buffer)
-    (setq report-emacs-bug-bug-alist bugs)
-    (widget-insert (propertize (concat "Already known bugs ("
-                                       keywords "):\n\n")
-                               'face 'bold))
-    (if bugs
-        (setq report-emacs-bug-choice-widget
-              (apply 'widget-create 'radio-button-choice
-                     :value (caar bugs)
-                     (let (items)
-                       (dolist (bug bugs)
-                         (push (list
-                                'url-link
-                                :format (concat "Bug#" (number-to-string (nth 2 bug))
-                                                ": " (cadr bug) "\n    %[%v%]\n")
-                                ;; FIXME: Why is only the link of the
-                                ;; active item clickable?
-                                (car bug))
-                               items))
-                       (nreverse items))))
-      (widget-insert "No bugs matching your keywords found.\n"))
-    (widget-insert "\n")
-    (widget-create 'push-button
-                   :notify (lambda (&rest ignore)
-                             ;; TODO: Do something!
-                             (message "Reporting new bug!"))
-                   "Report new bug")
-    (when bugs
-      (widget-insert " ")
-      (widget-create 'push-button
-                     :notify (lambda (&rest ignore)
-                               (let ((val (widget-value report-emacs-bug-choice-widget)))
-                                 ;; TODO: Do something!
-                                 (message "Appending to bug %s!"
-                                          (nth 2 (assoc val report-emacs-bug-bug-alist)))))
-                     "Append to chosen bug"))
-    (widget-insert " ")
-    (widget-create 'push-button
-                   :notify (lambda (&rest ignore)
-                             (kill-buffer))
-                   "Quit reporting bug")
-    (widget-insert "\n"))
-  (use-local-map widget-keymap)
-  (widget-setup)
-  (goto-char (point-min)))
-
-(defun report-emacs-bug-parse-query-results (status keywords)
-  (goto-char (point-min))
-  (let (buglist)
-    (while (re-search-forward "<a href=\"bugreport\\.cgi\\?bug=\\([[:digit:]]+\\)\">\\([^<]+\\)</a>" nil t)
-      (let ((number (match-string 1))
-            (subject (match-string 2)))
-        (when (not (string-match "^#" subject))
-          (push (list
-                 ;; first the bug URL
-                 (concat report-emacs-bug-tracker-url
-                         "bugreport.cgi?bug=" number)
-                 ;; then the subject and number
-                 subject (string-to-number number))
-                buglist))))
-    (report-emacs-bug-create-existing-bugs-buffer (nreverse buglist) keywords)))
-
-;;;###autoload
-(defun report-emacs-bug-query-existing-bugs (keywords)
-  "Query for KEYWORDS at `report-emacs-bug-tracker-url', and return the result.
-The result is an alist with items of the form (URL SUBJECT NO)."
-  (interactive "sBug keywords (comma separated): ")
-  (url-retrieve (concat report-emacs-bug-tracker-url
-                        "pkgreport.cgi?include=subject%3A"
-                        (replace-regexp-in-string "[[:space:]]+" "+" keywords)
-                        ";package=emacs")
-                'report-emacs-bug-parse-query-results (list keywords)))
-
 (provide 'emacsbug)
 
 ;;; emacsbug.el ends here
diff --git a/lisp/minibuf-eldef.el b/lisp/minibuf-eldef.el
index 92d5ec821b0..950c28b227f 100644
--- a/lisp/minibuf-eldef.el
+++ b/lisp/minibuf-eldef.el
@@ -33,13 +33,25 @@
 
 ;;; Code:
 
-(defvar minibuffer-eldef-shorten-default nil
-  "If non-nil, shorten \"(default ...)\" to \"[...]\" in minibuffer prompts.")
+(defvar minibuffer-eldef-shorten-default)
 
-(defvar minibuffer-default-in-prompt-regexps
+(defun minibuffer-default--in-prompt-regexps ()
   `(("\\( (default\\(?: is\\)? \\(.*\\))\\):? \\'"
      1 ,(if minibuffer-eldef-shorten-default " [\\2]"))
-    ("\\( \\[.*\\]\\):? *\\'" 1))
+    ("\\( \\[.*\\]\\):? *\\'" 1)))
+
+(defcustom minibuffer-eldef-shorten-default nil
+  "If non-nil, shorten \"(default ...)\" to \"[...]\" in minibuffer prompts."
+  :set (lambda (symbol value)
+         (set-default symbol value)
+         (setq-default minibuffer-default-in-prompt-regexps
+                       (minibuffer-default--in-prompt-regexps)))
+  :type 'boolean
+  :group 'minibuffer
+  :version "24.3")
+
+(defvar minibuffer-default-in-prompt-regexps
+  (minibuffer-default--in-prompt-regexps)
   "A list of regexps matching the parts of minibuffer prompts showing defaults.
 When `minibuffer-electric-default-mode' is active, these regexps are
 used to identify the portions of prompts to elide.
diff --git a/lisp/minibuffer.el b/lisp/minibuffer.el
index 38347f23f7d..6e704fad807 100644
--- a/lisp/minibuffer.el
+++ b/lisp/minibuffer.el
@@ -51,6 +51,9 @@
 
 ;;; Todo:
 
+;; - Make *Completions* readable even if some of the completion
+;;   entries have LF chars or spaces in them (including at
+;;   beginning/end) or are very long.
 ;; - for M-x, cycle-sort commands that have no key binding first.
 ;; - Make things like icomplete-mode or lightning-completion work with
 ;;   completion-in-region-mode.
@@ -74,6 +77,9 @@
 ;;   - whether the user wants completion to pay attention to case.
 ;;   e.g. we may want to make it possible for the user to say "first try
 ;;   completion case-sensitively, and if that fails, try to ignore case".
+;;   Maybe the trick is that we should distinguish completion-ignore-case in
+;;   try/all-completions (obey user's preference) from its use in
+;;   test-completion (obey the underlying object's semantics).
 
 ;; - add support for ** to pcm.
 ;; - Add vc-file-name-completion-table to read-file-name-internal.
@@ -2048,6 +2054,8 @@ This is only used when the minibuffer area has no active minibuffer.")
           process-environment))
 
 (defconst completion--embedded-envvar-re
+  ;; We can't reuse env--substitute-vars-regexp because we need to match only
+  ;; potentially-unfinished envvars at end of string.
   (concat "\\(?:^\\|[^$]\\(?:\\$\\$\\)*\\)"
           "$\\([[:alnum:]_]*\\|{\\([^}]*\\)\\)\\'"))
 
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index 874c0aa7fef..caaae5d553e 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -1748,20 +1748,26 @@ value of `default-file-modes', without execute permissions."
   (or (file-modes filename)
       (logand (default-file-modes) (tramp-compat-octal-to-decimal "0666"))))
 
-(defun tramp-replace-environment-variables (filename)
-  "Replace environment variables in FILENAME.
+(defalias 'tramp-replace-environment-variables
+  (if (ignore-errors
+        (equal "${ tramp?}" (substitute-env-vars "${ tramp?}" 'only-defined)))
+      (lambda (filename)
+        "Like `substitute-env-vars' with `only-defined' non-nil."
+        (substitute-env-vars filename 'only-defined))
+    (lambda (filename)
+      "Replace environment variables in FILENAME.
 Return the string with the replaced variables."
-  (save-match-data
-    (let ((idx (string-match "$\\(\\w+\\)" filename)))
-      ;; `$' is coded as `$$'.
-      (when (and idx
-                 (or (zerop idx) (not (eq ?$ (aref filename (1- idx)))))
-                 (getenv (match-string 1 filename)))
-        (setq filename
-              (replace-match
-               (substitute-in-file-name (match-string 0 filename))
-               t nil filename)))
-      filename)))
+      (save-match-data
+        (let ((idx (string-match "$\\(\\w+\\)" filename)))
+          ;; `$' is coded as `$$'.
+          (when (and idx
+                     (or (zerop idx) (not (eq ?$ (aref filename (1- idx)))))
+                     (getenv (match-string 1 filename)))
+            (setq filename
+                  (replace-match
+                   (substitute-in-file-name (match-string 0 filename))
+                   t nil filename)))
+          filename)))))
 
 ;; In XEmacs, electricity is implemented via a key map for ?/ and ?~,
 ;; which calls corresponding functions (see minibuf.el).
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index d954cd53e0a..33ef7607671 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -1823,22 +1823,31 @@ nil."
 
 ;;; Filling
 
+(defvar js--filling-paragraph nil)
+
+;; FIXME: Such redefinitions are bad style.  We should try and use some other
+;; way to get the same result.
+(defadvice c-forward-sws (around js-fill-paragraph activate)
+  (if js--filling-paragraph
+      (setq ad-return-value (js--forward-syntactic-ws (ad-get-arg 0)))
+    ad-do-it))
+
+(defadvice c-backward-sws (around js-fill-paragraph activate)
+  (if js--filling-paragraph
+      (setq ad-return-value (js--backward-syntactic-ws (ad-get-arg 0)))
+    ad-do-it))
+
+(defadvice c-beginning-of-macro (around js-fill-paragraph activate)
+  (if js--filling-paragraph
+      (setq ad-return-value (js--beginning-of-macro (ad-get-arg 0)))
+    ad-do-it))
+
 (defun js-c-fill-paragraph (&optional justify)
   "Fill the paragraph with `c-fill-paragraph'."
   (interactive "*P")
-  ;; FIXME: Such redefinitions are bad style.  We should try and use some other
-  ;; way to get the same result.
-  (cl-letf (((symbol-function 'c-forward-sws)
-             (lambda (&optional limit)
-               (js--forward-syntactic-ws limit)))
-            ((symbol-function 'c-backward-sws)
-             (lambda (&optional limit)
-               (js--backward-syntactic-ws limit)))
-            ((symbol-function 'c-beginning-of-macro)
-             (lambda (&optional limit)
-               (js--beginning-of-macro limit))))
-    (let ((fill-paragraph-function 'c-fill-paragraph))
-      (c-fill-paragraph justify))))
+  (let ((js--filling-paragraph t)
+        (fill-paragraph-function 'c-fill-paragraph))
+    (c-fill-paragraph justify)))
 
 ;;; Type database and Imenu
 
diff --git a/lisp/progmodes/perl-mode.el b/lisp/progmodes/perl-mode.el
index 3dd9a48bb33..d2f7fc7a059 100644
--- a/lisp/progmodes/perl-mode.el
+++ b/lisp/progmodes/perl-mode.el
@@ -1,4 +1,4 @@
-;;; perl-mode.el --- Perl code editing commands for GNU Emacs
+;;; perl-mode.el --- Perl code editing commands for GNU Emacs  -*- coding: utf-8 -*-
 
 ;; Copyright (C) 1990, 1994, 2001-2012 Free Software Foundation, Inc.
 
@@ -102,11 +102,6 @@
 
 ;;; Code:
 
-
-(defvar font-lock-comment-face)
-(defvar font-lock-doc-face)
-(defvar font-lock-string-face)
-
 (defgroup perl nil
   "Major mode for editing Perl code."
   :link '(custom-group-link :tag "Font Lock Faces group" font-lock-faces)
@@ -119,16 +114,11 @@
 
 (defvar perl-mode-map
   (let ((map (make-sparse-keymap)))
-    (define-key map "{" 'perl-electric-terminator)
-    (define-key map "}" 'perl-electric-terminator)
-    (define-key map ";" 'perl-electric-terminator)
-    (define-key map ":" 'perl-electric-terminator)
     (define-key map "\e\C-a" 'perl-beginning-of-function)
     (define-key map "\e\C-e" 'perl-end-of-function)
     (define-key map "\e\C-h" 'perl-mark-function)
     (define-key map "\e\C-q" 'perl-indent-exp)
     (define-key map "\177" 'backward-delete-char-untabify)
-    (define-key map "\t" 'perl-indent-command)
     map)
   "Keymap used in Perl mode.")
 
@@ -158,16 +148,54 @@
 
 (defvar perl-imenu-generic-expression
   '(;; Functions
-    (nil "^sub\\s-+\\([-A-Za-z0-9+_:]+\\)" 1)
+    (nil "^[ \t]*sub\\s-+\\([-A-Za-z0-9+_:]+\\)" 1)
     ;;Variables
     ("Variables" "^\\(?:my\\|our\\)\\s-+\\([$@%][-A-Za-z0-9+_:]+\\)\\s-*=" 1)
-    ("Packages" "^package\\s-+\\([-A-Za-z0-9+_:]+\\);" 1)
+    ("Packages" "^[ \t]*package\\s-+\\([-A-Za-z0-9+_:]+\\);" 1)
     ("Doc sections" "^=head[0-9][ \t]+\\(.*\\)" 1))
   "Imenu generic expression for Perl mode.  See `imenu-generic-expression'.")
 
 ;; Regexps updated with help from Tom Tromey <tromey@cambric.colorado.edu> and
 ;; Jim Campbell <jec@murzim.ca.boeing.com>.
 
+(defcustom perl-prettify-symbols t
+  "If non-nil, some symbols will be displayed using Unicode chars."
+  :type 'boolean)
+
+(defconst perl--prettify-symbols-alist
+  '(;;("andalso" . ?∧) ("orelse"  . ?∨) ("as" . ?≡)("not" . ?¬)
+    ;;("div" . ?÷) ("*"   . ?×) ("o"   . ?○)
+    ("->"  . ?→)
+    ("=>"  . ?⇒)
+    ;;("<-"  . ?←) ("<>"  . ?≠) (">="  . ?≥) ("<="  . ?≤) ("..." . ?⋯)
+    ("::" . ?∷)
+    ))
+
+(defun perl--font-lock-compose-symbol ()
+  "Compose a sequence of ascii chars into a symbol.
+Regexp match data 0 points to the chars."
+  ;; Check that the chars should really be composed into a symbol.
+  (let* ((start (match-beginning 0))
+         (end (match-end 0))
+         (syntaxes (if (eq (char-syntax (char-after start)) ?w)
+                       '(?w) '(?. ?\\))))
+    (if (or (memq (char-syntax (or (char-before start) ?\ )) syntaxes)
+            (memq (char-syntax (or (char-after end) ?\ )) syntaxes)
+            (nth 8 (syntax-ppss)))
+        ;; No composition for you.  Let's actually remove any composition
+        ;; we may have added earlier and which is now incorrect.
+        (remove-text-properties start end '(composition))
+      ;; That's a symbol alright, so add the composition.
+      (compose-region start end (cdr (assoc (match-string 0)
+                                            perl--prettify-symbols-alist)))))
+  ;; Return nil because we're not adding any face property.
+  nil)
+
+(defun perl--font-lock-symbols-keywords ()
+  (when perl-prettify-symbols
+    `((,(regexp-opt (mapcar 'car perl--prettify-symbols-alist) t)
+       (0 (perl--font-lock-compose-symbol))))))
+
 (defconst perl-font-lock-keywords-1
   '(;; What is this for?
     ;;("\\(--- .* ---\\|=== .* ===\\)" . font-lock-string-face)
@@ -190,32 +218,32 @@
   "Subdued level highlighting for Perl mode.")
 
 (defconst perl-font-lock-keywords-2
-  (append perl-font-lock-keywords-1
-   (list
-    ;;
-    ;; Fontify keywords, except those fontified otherwise.
-    (concat "\\<"
-            (regexp-opt '("if" "until" "while" "elsif" "else" "unless"
-                          "do" "dump" "for" "foreach" "exit" "die"
-                          "BEGIN" "END" "return" "exec" "eval") t)
-            "\\>")
-    ;;
-    ;; Fontify local and my keywords as types.
-    '("\\<\\(local\\|my\\)\\>" . font-lock-type-face)
-    ;;
-    ;; Fontify function, variable and file name references.
-    '("&\\(\\sw+\\(::\\sw+\\)*\\)" 1 font-lock-function-name-face)
-    ;; Additionally underline non-scalar variables.  Maybe this is a bad idea.
-    ;;'("[$@%*][#{]?\\(\\sw+\\)" 1 font-lock-variable-name-face)
-    '("[$*]{?\\(\\sw+\\(::\\sw+\\)*\\)" 1 font-lock-variable-name-face)
-    '("\\([@%]\\|\\$#\\)\\(\\sw+\\(::\\sw+\\)*\\)"
+  (append
+   perl-font-lock-keywords-1
+   `( ;; Fontify keywords, except those fontified otherwise.
+     ,(concat "\\<"
+              (regexp-opt '("if" "until" "while" "elsif" "else" "unless"
+                            "do" "dump" "for" "foreach" "exit" "die"
+                            "BEGIN" "END" "return" "exec" "eval") t)
+              "\\>")
+     ;;
+     ;; Fontify local and my keywords as types.
+     ("\\<\\(local\\|my\\)\\>" . font-lock-type-face)
+     ;;
+     ;; Fontify function, variable and file name references.
+     ("&\\(\\sw+\\(::\\sw+\\)*\\)" 1 font-lock-function-name-face)
+     ;; Additionally underline non-scalar variables.  Maybe this is a bad idea.
+     ;;'("[$@%*][#{]?\\(\\sw+\\)" 1 font-lock-variable-name-face)
+     ("[$*]{?\\(\\sw+\\(::\\sw+\\)*\\)" 1 font-lock-variable-name-face)
+     ("\\([@%]\\|\\$#\\)\\(\\sw+\\(::\\sw+\\)*\\)"
       (2 (cons font-lock-variable-name-face '(underline))))
-    '("<\\(\\sw+\\)>" 1 font-lock-constant-face)
-    ;;
-    ;; Fontify keywords with/and labels as we do in `c++-font-lock-keywords'.
-    '("\\<\\(continue\\|goto\\|last\\|next\\|redo\\)\\>[ \t]*\\(\\sw+\\)?"
+     ("<\\(\\sw+\\)>" 1 font-lock-constant-face)
+     ;;
+     ;; Fontify keywords with/and labels as we do in `c++-font-lock-keywords'.
+     ("\\<\\(continue\\|goto\\|last\\|next\\|redo\\)\\>[ \t]*\\(\\sw+\\)?"
       (1 font-lock-keyword-face) (2 font-lock-constant-face nil t))
-    '("^[ \t]*\\(\\sw+\\)[ \t]*:[^:]" 1 font-lock-constant-face)))
+     ("^[ \t]*\\(\\sw+\\)[ \t]*:[^:]" 1 font-lock-constant-face)
+     ,@(perl--font-lock-symbols-keywords)))
   "Gaudy level highlighting for Perl mode.")
 
 (defvar perl-font-lock-keywords perl-font-lock-keywords-1
@@ -543,8 +571,10 @@ create a new comment."
 
 (defun perl-outline-level ()
   (cond
-   ((looking-at "package\\s-") 0)
-   ((looking-at "sub\\s-") 1)
+   ((looking-at "[ \t]*\\(package\\)\\s-")
+    (- (match-beginning 1) (match-beginning 0)))
+   ((looking-at "[ \t]*s\\(ub\\)\\s-")
+    (- (match-beginning 1) (match-beginning 0)))
    ((looking-at "=head[0-9]") (- (char-before (match-end 0)) ?0))
    ((looking-at "=cut") 1)
    (t 3)))
@@ -621,6 +651,11 @@ Turning on Perl mode runs the normal hook `perl-mode-hook'."
        #'perl-syntax-propertize-function)
   (add-hook 'syntax-propertize-extend-region-functions
             #'syntax-propertize-multiline 'append 'local)
+  ;; Electricity.
+  ;; FIXME: setup electric-layout-rules.
+  (set (make-local-variable 'electric-indent-chars)
+       (append '(?\{ ?\} ?\; ?\:) electric-indent-chars))
+  (add-hook 'electric-indent-functions #'perl-electric-noindent-p nil t)
   ;; Tell imenu how to handle Perl.
   (set (make-local-variable 'imenu-generic-expression)
        perl-imenu-generic-expression)
@@ -637,7 +672,11 @@ Turning on Perl mode runs the normal hook `perl-mode-hook'."
       0                                 ;Existing comment at bol stays there.
     comment-column))
 
-(defalias 'electric-perl-terminator 'perl-electric-terminator)
+(define-obsolete-function-alias 'electric-perl-terminator
+  'perl-electric-terminator "22.1")
+(defun perl-electric-noindent-p (char)
+  (unless (eolp) 'no-indent))
+
 (defun perl-electric-terminator (arg)
   "Insert character and maybe adjust indentation.
 If at end-of-line, and not in a comment or a quote, correct the indentation."
@@ -661,6 +700,7 @@ If at end-of-line, and not in a comment or a quote, correct the indentation."
            (perl-indent-line)
            (delete-char -1))))
   (self-insert-command (prefix-numeric-value arg)))
+(make-obsolete 'perl-electric-terminator 'electric-indent-mode "24.4")
 
 ;; not used anymore, but may be useful someday:
 ;;(defun perl-inside-parens-p ()
@@ -744,6 +784,7 @@ following list:
                         (t
                          (message "Use backslash to quote # characters.")
                          (ding t)))))))))
+(make-obsolete 'perl-indent-command 'indent-according-to-mode "24.4")
 
 (defun perl-indent-line (&optional nochange parse-start)
   "Indent current line as Perl code.
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index 84cf7308d75..c9bfcefb748 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -1638,6 +1638,8 @@ The variable `ruby-indent-level' controls the amount of indentation.
 
 ;;;###autoload
 (add-to-list 'auto-mode-alist (cons (purecopy "\\.rb\\'") 'ruby-mode))
+;;;###autoload
+(add-to-list 'auto-mode-alist '("Rakefile\\'" . ruby-mode))
 
 ;;;###autoload
 (dolist (name (list "ruby" "rbx" "jruby" "ruby1.9" "ruby1.8"))
diff --git a/lisp/progmodes/sql.el b/lisp/progmodes/sql.el
index 3d5abc4df62..64b87d9e436 100644
--- a/lisp/progmodes/sql.el
+++ b/lisp/progmodes/sql.el
@@ -2802,8 +2802,12 @@ each line with INDENT."
     doc))
 
 ;;;###autoload
-(defun sql-help ()
-  "Show short help for the SQL modes.
+(eval
+ ;; FIXME: This dynamic-docstring-function trick doesn't work for byte-compiled
+ ;; functions, because of the lazy-loading of docstrings, which strips away
+ ;; text properties.
+ '(defun sql-help ()
+  #("Show short help for the SQL modes.
 
 Use an entry function to open an interactive SQL buffer.  This buffer is
 usually named `*SQL*'.  The name of the major mode is SQLi.
@@ -2834,32 +2838,23 @@ anything.  The name of the major mode is SQL.
 In this SQL buffer (SQL mode), you can send the region or the entire
 buffer to the interactive SQL buffer (SQLi mode).  The results are
 appended to the SQLi buffer without disturbing your SQL buffer."
+    0 1 (dynamic-docstring-function sql--make-help-docstring))
   (interactive)
+  (describe-function 'sql-help)))
 
-  ;; Insert references to loaded products into the help buffer string
-  (let ((doc (documentation 'sql-help t))
-        changedp)
-    (setq changedp nil)
-
-    ;; Insert FREE software list
-    (when (string-match "^\\(\\s-*\\)[\\\\][\\\\]FREE\\s-*\n" doc 0)
-      (setq doc (replace-match (sql-help-list-products (match-string 1 doc) t)
-                               t t doc 0)
-            changedp t))
-
-    ;; Insert non-FREE software list
-    (when (string-match "^\\(\\s-*\\)[\\\\][\\\\]NONFREE\\s-*\n" doc 0)
-      (setq doc (replace-match (sql-help-list-products (match-string 1 doc) nil)
-                               t t doc 0)
-            changedp t))
-
-    ;; If we changed the help text, save the change so that the help
-    ;; sub-system will see it
-    (when changedp
-      (put 'sql-help 'function-documentation doc)))
-
-  ;; Call help on this function
-  (describe-function 'sql-help))
+(defun sql--make-help-docstring (doc _fun)
+  "Insert references to loaded products into the help buffer string."
+
+  ;; Insert FREE software list
+  (when (string-match "^\\(\\s-*\\)[\\\\][\\\\]FREE\\s-*\n" doc 0)
+    (setq doc (replace-match (sql-help-list-products (match-string 1 doc) t)
+                             t t doc 0)))
+
+  ;; Insert non-FREE software list
+  (when (string-match "^\\(\\s-*\\)[\\\\][\\\\]NONFREE\\s-*\n" doc 0)
+    (setq doc (replace-match (sql-help-list-products (match-string 1 doc) nil)
+                             t t doc 0)))
+  doc)
 
 (defun sql-read-passwd (prompt &optional default)
   "Read a password using PROMPT.  Optional DEFAULT is password to start with."
diff --git a/lisp/server.el b/lisp/server.el
index 7a356a90378..c78e3e376aa 100644
--- a/lisp/server.el
+++ b/lisp/server.el
@@ -842,6 +842,15 @@ This handles splitting the command if it would be bigger than
     (unless (assq w window-system-initialization-alist)
       (setq w nil))
 
+    ;; Special case for ns.  This is because DISPLAY may not be set at all
+    ;; which in the ns case isn't an error.  The variable display then becomes
+    ;; the fully qualified hostname, which make-frame-on-display below
+    ;; does not understand and throws an error.
+    ;; It may also be a valid X display, but if Emacs is compiled for ns, it
+    ;; can not make X frames.
+    (if (featurep 'ns-win)
+        (setq w 'ns display "ns"))
+
     (cond (w
            ;; Flag frame as client-created, but use a dummy client.
            ;; This will prevent the frame from being deleted when
diff --git a/lisp/ses.el b/lisp/ses.el
index 7cdac74e310..27b906d22e3 100644
--- a/lisp/ses.el
+++ b/lisp/ses.el
@@ -278,6 +278,7 @@ default printer and then modify its output.")
       ses--default-printer
       ses--deferred-narrow ses--deferred-recalc
       ses--deferred-write ses--file-format
+      ses--named-cell-hashmap
       (ses--header-hscroll . -1) ; Flag for "initial recalc needed"
       ses--header-row ses--header-string ses--linewidth
       ses--numcols ses--numrows ses--symbolic-formulas
@@ -511,9 +512,22 @@ PROPERTY-NAME."
   `(aref ses--col-printers ,col))
 
 (defmacro ses-sym-rowcol (sym)
-  "From a cell-symbol SYM, gets the cons (row . col).  A1 => (0 . 0).
-Result is nil if SYM is not a symbol that names a cell."
-  `(and (symbolp ,sym) (get ,sym 'ses-cell)))
+  "From a cell-symbol SYM, gets the cons (row . col).  A1 => (0 . 0).  Result
+is nil if SYM is not a symbol that names a cell."
+  `(let ((rc (and (symbolp ,sym) (get ,sym 'ses-cell))))
+     (if (eq rc :ses-named)
+         (gethash ,sym ses--named-cell-hashmap)
+       rc)))
+
+(defun ses-is-cell-sym-p (sym)
+  "Check whether SYM point at a cell of this spread sheet."
+  (let ((rowcol (get sym 'ses-cell)))
+    (and rowcol
+         (if (eq rowcol :ses-named)
+             (and ses--named-cell-hashmap (gethash sym ses--named-cell-hashmap))
+           (and (< (car rowcol) ses--numrows)
+                (< (cdr rowcol) ses--numcols)
+                (eq (ses-cell-symbol (car rowcol) (cdr rowcol)) sym))))))
 
 (defmacro ses-cell (sym value formula printer references)
   "Load a cell SYM from the spreadsheet file.  Does not recompute VALUE from
@@ -682,6 +696,28 @@ for this spreadsheet."
   "Produce a symbol that names the cell (ROW,COL).  (0,0) => 'A1."
   (intern (concat (ses-column-letter col) (number-to-string (1+ row)))))
 
+(defun ses-decode-cell-symbol (str)
+  "Decode a symbol \"A1\" => (0,0). Returns `nil' if STR is not a
+  canonical cell name. Does not save match data."
+  (let (case-fold-search)
+    (and (string-match "\\`\\([A-Z]+\\)\\([0-9]+\\)\\'" str)
+         (let* ((col-str (match-string-no-properties 1 str))
+               (col 0)
+               (col-offset 0)
+               (col-base 1)
+               (col-idx (1- (length col-str)))
+               (row (1- (string-to-number (match-string-no-properties 2 str)))))
+           (and (>= row 0)
+                (progn
+                  (while
+                      (progn
+                        (setq col (+ col (* (- (aref col-str col-idx) ?A) col-base))
+                              col-base (* col-base 26)
+                              col-idx (1- col-idx))
+                        (and (>= col-idx 0)
+                             (setq col (+ col col-base)))))
+                  (cons row col)))))))
+
 (defun ses-create-cell-variable-range (minrow maxrow mincol maxcol)
   "Create buffer-local variables for cells.  This is undoable."
   (push `(apply ses-destroy-cell-variable-range ,minrow ,maxrow ,mincol ,maxcol)
@@ -704,7 +740,11 @@ row and column of the cell, with numbering starting from 0.
 Return nil in case of failure."
   (unless (local-variable-p sym)
     (make-local-variable  sym)
-    (put sym 'ses-cell (cons row col))))
+    (if (let (case-fold-search) (string-match "\\`[A-Z]+[0-9]+\\'" (symbol-name sym)))
+        (put sym 'ses-cell (cons row col))
+      (put sym 'ses-cell :ses-named)
+      (setq ses--named-cell-hashmap (or ses--named-cell-hashmap (make-hash-table :test 'eq)))
+      (puthash sym (cons row col) ses--named-cell-hashmap))))
 
 ;; We do not delete the ses-cell properties for the cell-variables, in
 ;; case a formula that refers to this cell is in the kill-ring and is
@@ -3211,27 +3251,36 @@ highlighted range in the spreadsheet."
 (defun ses-rename-cell (new-name &optional cell)
   "Rename current cell."
   (interactive "*SEnter new name: ")
-  (and  (local-variable-p new-name)
-        (ses-sym-rowcol new-name)
-        ;; this test is needed because ses-cell property of deleted cells
-        ;; is not deleted in case of subsequent undo
-        (memq new-name ses--renamed-cell-symb-list)
-        (error "Already a cell name"))
-  (and (boundp new-name)
-       (null (yes-or-no-p (format "`%S' is already bound outside this buffer, continue? "
-                                  new-name)))
-       (error "Already a bound cell name"))
-  (let* ((sym (if (ses-cell-p cell)
+  (or
+   (and  (local-variable-p new-name)
+         (ses-is-cell-sym-p new-name)
+         (error "Already a cell name"))
+   (and (boundp new-name)
+        (null (yes-or-no-p (format "`%S' is already bound outside this buffer, continue? "
+                                   new-name)))
+        (error "Already a bound cell name")))
+  (let* (curcell
+         (sym (if (ses-cell-p cell)
                   (ses-cell-symbol cell)
-                (setq cell nil)
+                (setq cell nil
+                      curcell t)
                 (ses-check-curcell)
                 ses--curcell))
          (rowcol (ses-sym-rowcol sym))
          (row (car rowcol))
-         (col (cdr rowcol)))
-    (setq cell (or cell (ses-get-cell row col)))
-    (push `(ses-rename-cell ,(ses-cell-symbol cell) ,cell) buffer-undo-list)
-    (put new-name 'ses-cell rowcol)
+         (col (cdr rowcol))
+         new-rowcol old-name)
+    (setq cell (or cell (ses-get-cell row col))
+          old-name (ses-cell-symbol cell)
+          new-rowcol (ses-decode-cell-symbol (symbol-name new-name)))
+    (if new-rowcol
+        (if (equal new-rowcol rowcol)
+          (put new-name 'ses-cell rowcol)
+          (error "Not a valid name for this cell location"))
+      (setq ses--named-cell-hashmap (or ses--named-cell-hashmap (make-hash-table :test 'eq)))
+      (put new-name 'ses-cell :ses-named)
+      (puthash new-name rowcol ses--named-cell-hashmap))
+    (push `(ses-rename-cell ,old-name ,cell) buffer-undo-list)
     ;; replace name by new name in formula of cells refering to renamed cell
     (dolist (ref (ses-cell-references cell))
       (let* ((x (ses-sym-rowcol ref))
@@ -3251,9 +3300,8 @@ highlighted range in the spreadsheet."
     (push new-name ses--renamed-cell-symb-list)
     (set new-name (symbol-value sym))
     (aset cell 0 new-name)
-    (put sym 'ses-cell nil)
     (makunbound sym)
-    (setq sym new-name)
+    (and curcell (setq ses--curcell new-name))
     (let* ((pos (point))
            (inhibit-read-only t)
            (col (current-column))
diff --git a/lisp/subr.el b/lisp/subr.el
index d328b7cddf5..ebfcfbc0930 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -222,9 +222,7 @@ Then evaluate RESULT to get return value, default nil.
              (let ((,(car spec) (car ,temp)))
                ,@body
                (setq ,temp (cdr ,temp))))
-           ,@(if (cdr (cdr spec))
-                 ;; FIXME: This let often leads to "unused var" warnings.
-                 `((let ((,(car spec) nil)) ,@(cdr (cdr spec))))))
+           ,@(cdr (cdr spec)))
       `(let ((,temp ,(nth 1 spec))
              ,(car spec))
          (while ,temp
@@ -2657,13 +2655,17 @@ See also `locate-user-emacs-file'.")
 
 (defun locate-user-emacs-file (new-name &optional old-name)
   "Return an absolute per-user Emacs-specific file name.
-If OLD-NAME is non-nil and ~/OLD-NAME exists, return ~/OLD-NAME.
+If NEW-NAME exists in `user-emacs-directory', return it.
+Else If OLD-NAME is non-nil and ~/OLD-NAME exists, return ~/OLD-NAME.
 Else return NEW-NAME in `user-emacs-directory', creating the
 directory if it does not exist."
   (convert-standard-filename
    (let* ((home (concat "~" (or init-file-user "")))
-          (at-home (and old-name (expand-file-name old-name home))))
-     (if (and at-home (file-readable-p at-home))
+          (at-home (and old-name (expand-file-name old-name home)))
+          (bestname (abbreviate-file-name
+                     (expand-file-name new-name user-emacs-directory))))
+     (if (and at-home (not (file-readable-p bestname))
+              (file-readable-p at-home))
          at-home
        ;; Make sure `user-emacs-directory' exists,
        ;; unless we're in batch mode or dumping Emacs
@@ -2677,8 +2679,7 @@ directory if it does not exist."
                    (set-default-file-modes ?\700)
                    (make-directory user-emacs-directory))
                (set-default-file-modes umask))))
-       (abbreviate-file-name
-        (expand-file-name new-name user-emacs-directory))))))
+       bestname))))
 
 ;;;; Misc. useful functions.
 
@@ -2808,6 +2809,12 @@ Otherwise, return nil."
 Otherwise, return nil."
   (and (memq object '(nil t)) t))
 
+(defun special-form-p (object)
+  "Non-nil if and only if OBJECT is a special form."
+  (if (and (symbolp object) (fboundp object))
+      (setq object (indirect-function object)))
+  (and (subrp object) (eq (cdr (subr-arity object)) 'unevalled)))
+
 (defun field-at-pos (pos)
   "Return the field at position POS, taking stickiness etc into account."
   (let ((raw-field (get-char-property (field-beginning pos) 'field)))
diff --git a/lisp/term.el b/lisp/term.el
index 7567bd38f5a..e6466b8fa95 100644
--- a/lisp/term.el
+++ b/lisp/term.el
@@ -452,7 +452,7 @@ state 4: term-terminal-parameter contains pending output.")
   "A queue of strings whose echo we want suppressed.")
 (defvar term-terminal-parameter)
 (defvar term-terminal-previous-parameter)
-(defvar term-current-face 'term-face)
+(defvar term-current-face 'term)
 (defvar term-scroll-start 0 "Top-most line (inclusive) of scrolling region.")
 (defvar term-scroll-end) ; Number of line (zero-based) after scrolling region.
 (defvar term-pager-count nil
@@ -759,7 +759,7 @@ Buffer local variable.")
 
 ;;; Faces
 (defvar ansi-term-color-vector
-  [term-face
+  [term
    term-color-black
    term-color-red
    term-color-green
@@ -770,18 +770,20 @@ Buffer local variable.")
    term-color-white])
 
 (defcustom term-default-fg-color nil
-  "If non-nil, default color for foreground in Term mode.
-This is deprecated in favor of customizing the `term-face' face."
+  "If non-nil, default color for foreground in Term mode."
   :group 'term
   :type 'string)
+(make-obsolete-variable 'term-default-fg-color "use the face `term' instead."
+                        "24.3")
 
 (defcustom term-default-bg-color nil
-  "If non-nil, default color for foreground in Term mode.
-This is deprecated in favor of customizing the `term-face' face."
+  "If non-nil, default color for foreground in Term mode."
   :group 'term
   :type 'string)
+(make-obsolete-variable 'term-default-bg-color "use the face `term' instead."
+                        "24.3")
 
-(defface term-face
+(defface term
   `((t
      :foreground ,term-default-fg-color
      :background ,term-default-bg-color
@@ -988,7 +990,7 @@ is buffer-local."
     dt))
 
 (defun term-ansi-reset ()
-  (setq term-current-face 'term-face)
+  (setq term-current-face 'term)
   (setq term-ansi-current-underline nil)
   (setq term-ansi-current-bold nil)
   (setq term-ansi-current-reverse nil)
diff --git a/lisp/vc/diff-mode.el b/lisp/vc/diff-mode.el
index 49b76a8e3bc..26c64ce2ad3 100644
--- a/lisp/vc/diff-mode.el
+++ b/lisp/vc/diff-mode.el
@@ -178,7 +178,7 @@ when editing big diffs)."
     ["Unified -> Context"       diff-unified->context
      :help "Convert unified diffs to context diffs"]
     ;;["Fixup Headers"          diff-fixup-modifs       (not buffer-read-only)]
-    ["Remove trailing whitespace" diff-remove-trailing-whitespace
+    ["Remove trailing whitespace" diff-delete-trailing-whitespace
      :help "Remove trailing whitespace problems introduced by the diff"]
     ["Show trailing whitespace" whitespace-mode
      :style toggle :selected (bound-and-true-p whitespace-mode)
@@ -2048,35 +2048,71 @@ I.e. like `add-change-log-entry-other-window' but applied to all hunks."
       ;; When there's no more hunks, diff-hunk-next signals an error.
       (error nil))))
 
-(defun diff-remove-trailing-whitespace ()
-  "When on a buffer that contains a diff, inspects the
-differences and removes trailing whitespace (spaces, tabs) from
-the lines modified or introduced by this diff. Shows a message
-with the name of the altered buffers, which are unsaved.  If a
-file referenced on the diff has no buffer and needs to be fixed,
-a buffer visiting that file is created."
-  (interactive)
-  ;; We assume that the diff header has no trailing whitespace.
-  (let ((modified-buffers nil))
-    (save-excursion
-      (goto-char (point-min))
-      (while (re-search-forward "^[+!>].*[ \t]+$" (point-max) t)
-        (pcase-let ((`(,buf ,line-offset ,pos ,src ,_dst ,_switched)
-                     (diff-find-source-location t t)))
-          (when line-offset
-            (with-current-buffer buf
-              (save-excursion
-                (goto-char (+ (car pos) (cdr src)))
-                (beginning-of-line)
-                (when (re-search-forward "\\([ \t]+\\)$" (line-end-position) t)
-                  (unless (memq buf modified-buffers)
-                    (push buf modified-buffers))
-                  (replace-match ""))))))))
-    (if modified-buffers
-        (message "Deleted new trailing whitespace from: %s"
-                 (mapconcat (lambda (buf) (concat "`" (buffer-name buf) "'"))
-                            modified-buffers " "))
-      (message "No trailing whitespace fixes needed."))))
+(defun diff-delete-trailing-whitespace (&optional other-file)
+  "Remove trailing whitespace from lines modified in this diff.
+This edits both the current Diff mode buffer and the patched
+source file(s).  If `diff-jump-to-old-file' is non-nil, edit the
+original (unpatched) source file instead.  With a prefix argument
+OTHER-FILE, flip the choice of which source file to edit.
+
+If a file referenced in the diff has no buffer and needs to be
+fixed, visit it in a buffer."
+  (interactive "P")
+  (save-excursion
+    (goto-char (point-min))
+    (let* ((other (diff-xor other-file diff-jump-to-old-file))
+           (modified-buffers nil)
+           (style (save-excursion
+                    (when (re-search-forward diff-hunk-header-re nil t)
+                      (goto-char (match-beginning 0))
+                      (diff-hunk-style))))
+           (regexp (concat "^[" (if other "-<" "+>") "!]"
+                           (if (eq style 'context) " " "")
+                           ".*?\\([ \t]+\\)$"))
+           (inhibit-read-only t)
+           (end-marker (make-marker))
+           hunk-end)
+      ;; Move to the first hunk.
+      (re-search-forward diff-hunk-header-re nil 1)
+      (while (progn (save-excursion
+                      (re-search-forward diff-hunk-header-re nil 1)
+                      (setq hunk-end (point)))
+                    (< (point) hunk-end))
+        ;; For context diffs, search only in the appropriate half of
+        ;; the hunk.  For other diffs, search within the entire hunk.
+        (if (not (eq style 'context))
+            (set-marker end-marker hunk-end)
+          (let ((mid-hunk
+                 (save-excursion
+                   (re-search-forward diff-context-mid-hunk-header-re hunk-end)
+                   (point))))
+            (if other
+                (set-marker end-marker mid-hunk)
+              (goto-char mid-hunk)
+              (set-marker end-marker hunk-end))))
+        (while (re-search-forward regexp end-marker t)
+          (let ((match-data (match-data)))
+            (pcase-let ((`(,buf ,line-offset ,pos ,src ,_dst ,_switched)
+                         (diff-find-source-location other-file)))
+              (when line-offset
+                ;; Remove the whitespace in the Diff mode buffer.
+                (set-match-data match-data)
+                (replace-match "" t t nil 1)
+                ;; Remove the whitespace in the source buffer.
+                (with-current-buffer buf
+                  (save-excursion
+                    (goto-char (+ (car pos) (cdr src)))
+                    (beginning-of-line)
+                    (when (re-search-forward "\\([ \t]+\\)$" (line-end-position) t)
+                      (unless (memq buf modified-buffers)
+                        (push buf modified-buffers))
+                      (replace-match ""))))))))
+        (goto-char hunk-end))
+      (if modified-buffers
+          (message "Deleted trailing whitespace from %s."
+                   (mapconcat (lambda (buf) (concat "`" (buffer-name buf) "'"))
+                              modified-buffers ", "))
+        (message "No trailing whitespace to delete.")))))
 
 ;; provide the package
 (provide 'diff-mode)
diff --git a/lisp/woman.el b/lisp/woman.el
index e41c489dbfa..974a7d72465 100644
--- a/lisp/woman.el
+++ b/lisp/woman.el
@@ -2253,7 +2253,9 @@ Currently set only from '\" t in the first line of the source file.")
          (set-face-font 'woman-symbol woman-symbol-font
                         (and (frame-live-p woman-frame) woman-frame)))
 
-    ;; Set syntax and display tables:
+    (setq-local adaptive-fill-mode nil) ; No special "%" "#" etc filling.
+
+        ;; Set syntax and display tables:
     (set-syntax-table woman-syntax-table)
     (woman-set-buffer-display-table)