Merge branch 'master' into xwidget

37 files changed, 1638 insertions, 1168 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 80dfeef3750..0a3c7c95929 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,15 +1,233 @@
+2015-01-31  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/eieio.el (defclass): Use new eieio-make-class-predicate
+        and eieio-make-child-predicate.
+        (eieio-class-parents): Use eieio--class-object.
+        (slot-boundp, find-class, eieio-override-prin1): Avoid class-p.
+        (slot-exists-p): Use find-class.
+
+        * emacs-lisp/eieio-opt.el (eieio-help-class, eieio-help-constructor):
+        Use find-lisp-object-file-name, help-fns-short-filename and new calling
+        convention for eieio-class-def.
+        (eieio-build-class-list): Remove function, unused.
+        (eieio-method-def): Remove button type, unused.
+        (eieio-class-def): Inherit from help-function-def.
+        (eieio--defclass-regexp): New constant.
+        (find-function-regexp-alist): Use it.
+        (eieio--specializers-apply-to-class-p): Handle eieio--static as well.
+        (eieio-help-find-method-definition, eieio-help-find-class-definition):
+        Remove functions.
+
+        * emacs-lisp/eieio-core.el (eieio--check-type): Remove.
+        Use cl-check-type everywhere instead.
+        (eieio-class-object): Remove, use find-class instead when needed.
+        (class-p): Don't inline.
+        (eieio-object-p): Check more thoroughly, so we don't treat cl-structs,
+        such as eieio classes, as objects.  Don't inline.
+        (object-p): Mark as obsolete.
+        (eieio-defclass-autoload, eieio-defclass-internal, eieio-oref)
+        (eieio--generic-tagcode): Avoid `class-p'.
+        (eieio-make-class-predicate, eieio-make-child-predicate): New functions.
+        (eieio-defclass-internal): Use current-load-list rather than
+        `class-location'.
+
+        * emacs-lisp/cl-generic.el (cl--generic-search-method): Fix regexp.
+
+2015-01-30  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/backquote.el (backquote-delay-process): Don't reuse `s'
+        since it may be "equivalent" in some sense, yet different (bug#19734).
+
+2015-01-30  Oleh Krehel  <ohwoeowho@gmail.com>
+
+        * outline.el (outline-font-lock-face): Add docstring.
+        (outline-invisible-p): Improve docstring.
+        (outline-invent-heading): Add docstring.
+        (outline-promote): Improve docstring.
+        (outline-demote): Improve docstring.
+        (outline-head-from-level): Improve docstring.
+        (outline-end-of-heading): Add docstring.
+        (outline-next-visible-heading): Improve docstring.
+        (outline-previous-visible-heading): Improve docstring.
+        (outline-hide-region-body): Improve docstring.
+        (outline-flag-subtree): Add docstring.
+        (outline-end-of-subtree): Add docstring.
+        (outline-headers-as-kill): Improve docstring.
+
+2015-01-30  Oleh Krehel  <ohwoeowho@gmail.com>
+
+        * outline.el (outline-hide-entry): Rename from `hide-entry'.
+        (hide-entry): Declare as obsolete.
+        (outline-show-entry): Rename from `show-entry'.
+        (show-entry): Declare as obsolete.
+        (outline-hide-body): Rename from `hide-body'.
+        (hide-body): Declare as obsolete.
+        (outline-hide-region-body): Rename from `hide-region-body'.
+        (hide-region-body): Declare as obsolete.
+        (outline-show-all): Rename from `show-all'.
+        (show-all): Declare as obsolete.
+        (outline-hide-subtree): Rename from `hide-subtree'.
+        (hide-subtree): Declare as obsolete.
+        (outline-hide-leaves): Rename from `hide-leaves'.
+        (hide-leaves): Declare as obsolete.
+        (outline-show-subtree): Rename from `show-subtree'.
+        (show-subtree): Declare as obsolete.
+        (outline-hide-sublevels): Rename from `hide-sublevels'.
+        (hide-sublevels): Declare as obsolete.
+        (outline-hide-other): Rename from `hide-other'.
+        (hide-other): Declare as obsolete.
+        (outline-show-children): Rename from `show-children'.
+        (show-children): Declare as obsolete.
+        (outline-show-branches): Rename from `show-branches'.
+        (show-branches): Declare as obsolete.
+
+2015-01-30  Oleh Krehel  <ohwoeowho@gmail.com>
+
+        * outline.el (outline-mode): Clean up docstring.
+        (font-lock-warning-face): Remove obsolete declaration.
+        (outline-font-lock-face): Remove obsolete comment.
+
+2015-01-30  Oleh Krehel  <ohwoeowho@gmail.com>
+
+        * lisp/custom.el (defface): Set `indent' to 1.
+
+2015-01-30  Oleh Krehel  <ohwoeowho@gmail.com>
+
+        * emacs-lisp/easy-mmode.el (define-minor-mode): Set `indent' to 1.
+
+2015-01-30  Michal Nazarewicz  <mina86@mina86.com>
+
+        * lisp/files.el (save-buffers-kill-emacs): If `confirm-kill-emacs'
+        is set, but user has just been asked whether they really want to
+        kill Emacs (for example with a ‘Modified buffers exist; exit
+        anyway?’ prompt), do not ask them for another confirmation.
+
+2015-01-29  Jay Belanger  <jay.p.belanger@gmail.com>
+
+        * lisp/calc/calc-units.el (calc-convert-exact-units): New function.
+        (calc-convert-units): Check for missing units.
+        (math-consistent-units-p): Strengthen the test for consistent units.
+
+        * lisp/calc/calc-ext.el (calc-init-extensions):  Autoload
+        `calc-convert-exact-units' and assign it a keybinding.
+
+        * lisp/calc/calc-help (calc-u-prefix-help): Add help for the
+        "un" keybinding.
+
+2015-01-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/cl.el (cl--function-convert): Simplify.
+
+2015-01-28  Tassilo Horn  <tsdh@gnu.org>
+
+        * textmodes/reftex.el (reftex-syntax-table-for-bib): Give ( and )
+        punctuation syntax since to allow bibtex fields with values such
+        as {Test 1) and 2)} (bug#19205, bug#19707).
+        (reftex--prepare-syntax-tables): New function.
+        (reftex-mode): Use it.
+
+2015-01-28  Fabián Ezequiel Gallina  <fgallina@gnu.org>
+
+        python.el: New non-global state dependent indentation engine.
+        (Bug#18319, Bug#19595)
+        * progmodes/python.el (python-syntax-comment-or-string-p):
+        Accept PPSS as argument.
+        (python-syntax-closing-paren-p): New function.
+        (python-indent-current-level)
+        (python-indent-levels): Mark obsolete.
+        (python-indent-context): Return more context cases.
+        (python-indent--calculate-indentation)
+        (python-indent--calculate-levels): New functions.
+        (python-indent-calculate-levels): Use them.
+        (python-indent-calculate-indentation, python-indent-line):
+        (python-indent-line-function): Rewritten to use new API.
+        (python-indent-dedent-line): Simplify logic.
+        (python-indent-dedent-line-backspace): Use `unless`.
+        (python-indent-toggle-levels): Delete function.
+
+2015-01-28  Daniel Koning  <dk@danielkoning.com>  (tiny change)
+
+        * subr.el (posnp): Correct docstring of `posnp'.
+        (posn-col-row): Make it work with all mouse position objects.
+        * textmodes/artist.el (artist-mouse-draw-continously):
+        Cancel timers if an error occurs during continuous drawing.  (Bug#6130)
+
+2015-01-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * button.el (button-activate, push-button): Doc fix.  (Bug#19628)
+
+2015-01-28  Michael Albinus  <michael.albinus@gmx.de>
+
+        * filenotify.el (file-notify-descriptors, file-notify-handle-event):
+        Adapt docstring.
+        (file-notify--descriptor): New defun.
+        (file-notify-callback, file-notify-add-watch, file-notify-rm-watch):
+        Adapt docstring.  Handle multiple values for
+        `file-notify-descriptors' entries.  (Bug#18880)
+
+        * net/tramp.el (tramp-handle-file-notify-rm-watch): Do not check
+        `file-notify-descriptors', the implementation has been changed.
+
+2015-01-28  Eli Zaretskii  <eliz@gnu.org>
+
+        * net/net-utils.el (net-utils-run-program, net-utils-run-simple):
+        On MS-Windows, bind coding-system-for-read to the console output
+        codepage.  (Bug#19458)
+
+2015-01-28  Dmitry Gutov  <dgutov@yandex.ru>
+
+        Unbreak `mouse-action' property in text buttons.
+        * button.el (push-button): Fix regression from 2012-12-06.
+
+2015-01-28  Glenn Morris  <rgm@gnu.org>
+
+        * progmodes/sh-script.el (sh-mode): Doc fix.
+        (sh-basic-indent-line): Handle electric newline.  (Bug#18756)
+
+2015-01-28  Paul Eggert  <eggert@cs.ucla.edu>
+
+        Fix dired quoting bug with "Hit`N`Hide".  Fixes Bug#19498.
+        * files.el (shell-quote-wildcard-pattern): Also quote "`".
+
+2015-01-28  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        Tighten up the tagcode used for eieio and cl-struct objects.
+        * loadup.el: Load cl-preloaded.
+        * emacs-lisp/eieio-core.el (eieio-defclass-internal): Set the function
+        slot of the tag symbol to :quick-object-witness-check.
+        (eieio-object-p): Use :quick-object-witness-check.
+        (eieio--generic-tagcode): Use cl--generic-struct-tag.
+        * emacs-lisp/cl-preloaded.el: New file.
+        * emacs-lisp/cl-macs.el (cl--bind-inits): Remove, unused.
+        (cl--transform-lambda, cl-destructuring-bind): Remove cl--bind-inits.
+        (cl--make-usage-args): Strip away &aux args.
+        (cl-case, cl-typecase, cl--parse-loop-clause): Use macroexp-let2.
+        (cl-the, cl-check-type): Use macroexp-let2 and cl-typep.
+        (cl-defstruct): Use `declare' and cl-struct-define.
+        * emacs-lisp/cl-generic.el (cl--generic-struct-tag): New function.
+        (cl--generic-struct-tagcode): Use it to tighten the tagcode.
+
+2015-01-27  Katsumi Yamaoka  <yamaoka@jpl.org>
+
+        * emacs-lisp/cl.el (cl--function-convert):
+        Merge cache that cl--labels-convert adds (bug#19699).
+
+2015-01-27  Ivan Shmakov  <ivan@siamics.net>
+
+        * tar-mode.el: Allow for adding new archive members.  (Bug#19274)
+        (tar-new-regular-file-header, tar--pad-to, tar--put-at)
+        (tar-header-serialize): New functions.
+        (tar-current-position): Split from tar-current-descriptor.
+        (tar-current-descriptor): Use it.
+        (tar-new-entry): New command.
+        (tar-mode-map): Bind it.
+
 2015-01-27  Sam Steingold  <sds@gnu.org>
 
         * progmodes/python.el (python-check-custom-command): Buffer local
         because it usually includes the buffer name.
         (python-check-command): Set to epylint when pyflakes is not available.
 
-2015-01-27  Thomas Fitzsimmons  <fitzsim@fitzsim.org>
-
-        * net/eudcb-bbdb.el, net/eudcb-ldap.el, net/eudcb-mab.el,
-        net/eudc-bob.el, net/eudcb-ph.el, net/eudc.el, net/eudc-export.el,
-        net/eudc-hotlist.el, net/eudc-vars.el: New maintainer.
-
 2015-01-27  Artur Malabarba  <bruce.connor.am@gmail.com>
 
         * isearch.el (isearch-process-search-char): Add docstring.
@@ -70,6 +288,8 @@
 2015-01-26  Lars Ingebrigtsen  <larsi@gnus.org>
 
         * net/shr.el (shr-make-table-1): Fix colspan typo.
+        (shr-make-table-1): Add comments.
+        (shr-make-table-1): Make colspan display more sensibly.
 
         * net/eww.el (eww-add-bookmark): Fix prompt and clean up the code
         slightly.
@@ -1742,8 +1962,7 @@
 2014-12-14  Steve Purcell  <steve@sanityinc.com>  (tiny change)
 
         * emacs-lisp/package.el (package-menu-mode): Use an extra column
-        for the "Version" column, to accomodate date-and-time-based
-        versions.
+        for the "Version" column, to accomodate date-and-time-based versions.
 
 2014-12-14  Cameron Desautels  <camdez@gmail.com>
 
diff --git a/lisp/button.el b/lisp/button.el
index 189a1c23a4d..e7602dd7050 100644
--- a/lisp/button.el
+++ b/lisp/button.el
@@ -224,10 +224,10 @@ changes to a supertype are not reflected in its subtypes)."
           prop val))))
 
 (defun button-activate (button &optional use-mouse-action)
-  "Call BUTTON's action property.
-If USE-MOUSE-ACTION is non-nil, invoke the button's mouse-action
-instead of its normal action; if the button has no mouse-action,
-the normal action is used instead.
+  "Call BUTTON's `action' property.
+If USE-MOUSE-ACTION is non-nil, invoke the button's `mouse-action'
+property instead of `action'; if the button has no `mouse-action',
+the value of `action' is used instead.
 
 The action can either be a marker or a function.  If it's a
 marker then goto it.  Otherwise it it is a function then it is
@@ -429,11 +429,13 @@ instead of starting at the next button."
 (defun push-button (&optional pos use-mouse-action)
   "Perform the action specified by a button at location POS.
 POS may be either a buffer position or a mouse-event.  If
-USE-MOUSE-ACTION is non-nil, invoke the button's mouse-action
-instead of its normal action; if the button has no mouse-action,
-the normal action is used instead.  The action may be either a
-function to call or a marker to display and is invoked using
-`button-activate' (which see).
+USE-MOUSE-ACTION is non-nil, invoke the button's `mouse-action'
+property instead of its `action' property; if the button has no
+`mouse-action', the value of `action' is used instead.
+
+The action in both cases may be either a function to call or a
+marker to display and is invoked using `button-activate' (which
+see).
 
 POS defaults to point, except when `push-button' is invoked
 interactively as the result of a mouse-event, in which case, the
diff --git a/lisp/calc/calc-ext.el b/lisp/calc/calc-ext.el
index c3acb89e417..67d0c2701d2 100644
--- a/lisp/calc/calc-ext.el
+++ b/lisp/calc/calc-ext.el
@@ -561,6 +561,7 @@
   (define-key calc-mode-map "ud" 'calc-define-unit)
   (define-key calc-mode-map "ue" 'calc-explain-units)
   (define-key calc-mode-map "ug" 'calc-get-unit-definition)
+  (define-key calc-mode-map "un" 'calc-convert-exact-units)
   (define-key calc-mode-map "up" 'calc-permanent-units)
   (define-key calc-mode-map "ur" 'calc-remove-units)
   (define-key calc-mode-map "us" 'calc-simplify-units)
@@ -1176,7 +1177,8 @@ calc-trail-scroll-right calc-trail-yank)
  ("calc-undo" calc-last-args calc-redo)
 
  ("calc-units" calc-autorange-units calc-base-units
-calc-convert-temperature calc-convert-units calc-define-unit
+calc-convert-temperature calc-convert-units 
+calc-convert-exact-units calc-define-unit
 calc-enter-units-table calc-explain-units calc-extract-units
 calc-get-unit-definition calc-permanent-units calc-quick-units
 calc-remove-units calc-simplify-units calc-undefine-unit
diff --git a/lisp/calc/calc-help.el b/lisp/calc/calc-help.el
index 511e208ddea..17e5b0fdead 100644
--- a/lisp/calc/calc-help.el
+++ b/lisp/calc/calc-help.el
@@ -647,7 +647,7 @@ C-w  Describe how there is no warranty for Calc."
 (defun calc-u-prefix-help ()
   (interactive)
   (calc-do-prefix-help
-   '("Simplify, Convert, Temperature-convert, Base-units"
+   '("Simplify, Convert, coNvert exact, Temperature-convert, Base-units"
      "Autorange; Remove, eXtract; Explain; View-table; 0-9"
      "Define, Undefine, Get-defn, Permanent"
      "SHIFT + View-table-other-window"
diff --git a/lisp/calc/calc-units.el b/lisp/calc/calc-units.el
index 05950864a52..f3d02340fe3 100644
--- a/lisp/calc/calc-units.el
+++ b/lisp/calc/calc-units.el
@@ -470,6 +470,8 @@ If COMP or STD is non-nil, put that in the units table instead."
                            (if (string-match "\\` */" uoldname)
                                (setq uoldname (concat "1" uoldname)))
                            (math-read-expr uoldname))))))
+         (unless (math-units-in-expr-p uold t)
+           (error "No units specified"))
          (when (eq (car-safe uold) 'error)
            (error "Bad format in units expression: %s" (nth 1 uold)))
          (setq expr (math-mul expr uold))))
@@ -514,6 +516,38 @@ If COMP or STD is non-nil, put that in the units table instead."
            (math-put-default-units (if noold units res) (if comp units)))
          (calc-enter-result 1 "cvun" res))))))
 
+(defun calc-convert-exact-units ()
+  (interactive)
+  (calc-slow-wrapper
+   (let* ((expr (calc-top-n 1)))
+     (unless (math-units-in-expr-p expr t)
+       (error "No units in expression."))
+     (let* ((old-units (math-extract-units expr))
+            (defunits (math-get-default-units expr))
+            units
+            (new-units
+             (read-string (concat "New units"
+                                  (if defunits
+                                     (concat
+                                      " (default "
+                                      defunits
+                                      "): ")
+                                   ": ")))))
+       (if (and
+            (string= new-units "")
+            defunits)
+           (setq new-units defunits))
+       (setq units (math-read-expr new-units))
+       (when (eq (car-safe units) 'error)
+         (error "Bad format in units expression: %s" (nth 2 units)))
+       (math-check-unit-consistency old-units units)
+       (let ((res
+              (list '* (math-mul (math-remove-units expr)
+                                 (math-simplify-units
+                                  (math-to-standard-units (list '/ old-units units) nil)))
+                    units)))
+         (calc-enter-result 1 "cvxu" res))))))
+
 (defun calc-autorange-units (arg)
   (interactive "P")
   (calc-wrapper
@@ -945,7 +979,7 @@ If COMP or STD is non-nil, put that in the units table instead."
   (or
    (and (eq (car-safe newunits) 'var)
         (assq (nth 1 newunits) math-standard-units-systems))
-   (math-numberp (math-get-units (list '/ expr newunits)))))
+   (math-numberp (math-get-units (math-to-standard-units (list '/ expr newunits) nil)))))
 
 (defun math-check-unit-consistency (expr units)
   "Give an error if EXPR and UNITS do not have consistent units."
diff --git a/lisp/custom.el b/lisp/custom.el
index 779e585c04f..e5fe0ebaedd 100644
--- a/lisp/custom.el
+++ b/lisp/custom.el
@@ -411,7 +411,8 @@ In the ATTS property list, possible attributes are `:family',
 
 See Info node `(elisp) Faces' in the Emacs Lisp manual for more
 information."
-  (declare (doc-string 3))
+  (declare (doc-string 3)
+           (indent 1))
   ;; It is better not to use backquote in this file,
   ;; because that makes a bootstrapping problem
   ;; if you need to recompile all the Lisp files using interpreted code.
diff --git a/lisp/emacs-lisp/backquote.el b/lisp/emacs-lisp/backquote.el
index 082955e0823..d5cdca2b1b5 100644
--- a/lisp/emacs-lisp/backquote.el
+++ b/lisp/emacs-lisp/backquote.el
@@ -120,9 +120,7 @@ Vectors work just like lists.  Nested backquotes are permitted."
 This simply recurses through the body."
   (let ((exp (backquote-listify (list (cons 0 (list 'quote (car s))))
                                 (backquote-process (cdr s) level))))
-    (if (eq (car-safe exp) 'quote)
-        (cons 0 (list 'quote s))
-      (cons 1 exp))))
+    (cons (if (eq (car-safe exp) 'quote) 0 1) exp)))
 
 (defun backquote-process (s &optional level)
   "Process the body of a backquote.
diff --git a/lisp/emacs-lisp/cl-generic.el b/lisp/emacs-lisp/cl-generic.el
index 1bb70963a57..72ec8ec1801 100644
--- a/lisp/emacs-lisp/cl-generic.el
+++ b/lisp/emacs-lisp/cl-generic.el
@@ -635,7 +635,8 @@ Can only be used from within the lexical body of a primary or around method."
 
 (defun cl--generic-search-method (met-name)
   (let ((base-re (concat "(\\(?:cl-\\)?defmethod[ \t]+"
-                         (regexp-quote (format "%s\\_>" (car met-name))))))
+                         (regexp-quote (format "%s" (car met-name)))
+                         "\\_>")))
     (or
      (re-search-forward
       (concat base-re "[^&\"\n]*"
@@ -724,6 +725,14 @@ Can only be used from within the lexical body of a primary or around method."
 
 (add-function :before-until cl-generic-tagcode-function
               #'cl--generic-struct-tagcode)
+
+(defun cl--generic-struct-tag (name)
+  `(and (vectorp ,name)
+        (> (length ,name) 0)
+        (let ((tag (aref ,name 0)))
+          (if (eq (symbol-function tag) :quick-object-witness-check)
+              tag))))
+
 (defun cl--generic-struct-tagcode (type name)
   (and (symbolp type)
        (get type 'cl-struct-type)
@@ -733,12 +742,19 @@ Can only be used from within the lexical body of a primary or around method."
        (or (equal '(cl-tag-slot) (car (get type 'cl-struct-slots)))
            (error "Can't dispatch on cl-struct %S: no tag in slot 0"
                   type))
-       ;; We could/should check the vector has length >0,
-       ;; but really, mixing vectors and structs is a bad idea,
-       ;; so let's not waste time trying to handle the case
-       ;; of an empty vector.
-       ;; BEWARE: this returns a bogus tag for non-struct vectors.
-       `(50 . (and (vectorp ,name) (aref ,name 0)))))
+       ;; It's tempting to use (and (vectorp ,name) (aref ,name 0))
+       ;; but that would suffer from some problems:
+       ;; - the vector may have size 0.
+       ;; - when called on an actual vector (rather than an object), we'd
+       ;;   end up returning an arbitrary value, possibly colliding with
+       ;;   other tagcode's values.
+       ;; - it can also result in returning all kinds of irrelevant
+       ;;   values which would end up filling up the method-cache with
+       ;;   lots of irrelevant/redundant entries.
+       ;; FIXME: We could speed this up by introducing a dedicated
+       ;; vector type at the C level, so we could do something like
+       ;; (and (vector-objectp ,name) (aref ,name 0))
+       `(50 . ,(cl--generic-struct-tag name))))
 
 (add-function :before-until cl-generic-tag-types-function
               #'cl--generic-struct-tag-types)
diff --git a/lisp/emacs-lisp/cl-macs.el b/lisp/emacs-lisp/cl-macs.el
index 38f15b89b0e..eaec2c5263c 100644
--- a/lisp/emacs-lisp/cl-macs.el
+++ b/lisp/emacs-lisp/cl-macs.el
@@ -221,7 +221,7 @@ The name is made by appending a number to PREFIX, default \"G\"."
   '(&optional &rest &key &allow-other-keys &aux &whole &body &environment))
 
 (defvar cl--bind-block) (defvar cl--bind-defs) (defvar cl--bind-enquote)
-(defvar cl--bind-inits) (defvar cl--bind-lets) (defvar cl--bind-forms)
+(defvar cl--bind-lets) (defvar cl--bind-forms)
 
 (defun cl--transform-lambda (form bind-block)
   "Transform a function form FORM of name BIND-BLOCK.
@@ -229,9 +229,11 @@ BIND-BLOCK is the name of the symbol to which the function will be bound,
 and which will be used for the name of the `cl-block' surrounding the
 function's body.
 FORM is of the form (ARGS . BODY)."
+  ;; FIXME: (lambda (a &aux b) 1) expands to (lambda (a &rest --cl-rest--) ...)
+  ;; where the --cl-rest-- is clearly undesired.
   (let* ((args (car form)) (body (cdr form)) (orig-args args)
          (cl--bind-block bind-block) (cl--bind-defs nil) (cl--bind-enquote nil)
-         (cl--bind-inits nil) (cl--bind-lets nil) (cl--bind-forms nil)
+         (cl--bind-lets nil) (cl--bind-forms nil)
          (header nil) (simple-args nil))
     (while (or (stringp (car body))
                (memq (car-safe (car body)) '(interactive declare cl-declare)))
@@ -244,10 +246,10 @@ FORM is of the form (ARGS . BODY)."
     (if (setq cl--bind-enquote (memq '&cl-quote args))
         (setq args (delq '&cl-quote args)))
     (if (memq '&whole args) (error "&whole not currently implemented"))
-    (let* ((p (memq '&environment args)) (v (cadr p))
-           (env-exp 'macroexpand-all-environment))
+    (let* ((p (memq '&environment args))
+           (v (cadr p)))
       (if p (setq args (nconc (delq (car p) (delq v args))
-                              (list '&aux (list v env-exp))))))
+                              `(&aux (,v macroexpand-all-environment))))))
     (while (and args (symbolp (car args))
                 (not (memq (car args) '(nil &rest &body &key &aux)))
                 (not (and (eq (car args) '&optional)
@@ -261,8 +263,7 @@ FORM is of the form (ARGS . BODY)."
       (cl--do-arglist args nil (- (length simple-args)
                                   (if (memq '&optional simple-args) 1 0)))
       (setq cl--bind-lets (nreverse cl--bind-lets))
-      (cl-list* (and cl--bind-inits `(cl-eval-when (compile load eval)
-                                ,@(nreverse cl--bind-inits)))
+      (cl-list* nil
              (nconc (nreverse simple-args)
                     (list '&rest (car (pop cl--bind-lets))))
              (nconc (let ((hdr (nreverse header)))
@@ -390,6 +391,11 @@ its argument list allows full Common Lisp conventions."
    (t x)))
 
 (defun cl--make-usage-args (arglist)
+  (let ((aux (ignore-errors (cl-position '&aux arglist))))
+    (when aux
+      ;; `&aux' args aren't arguments, so let's just drop them from the
+      ;; usage info.
+      (setq arglist (cl-subseq arglist 0 aux))))
   (if (cdr-safe (last arglist))         ;Not a proper list.
       (let* ((last (last arglist))
              (tail (cdr last)))
@@ -426,7 +432,7 @@ its argument list allows full Common Lisp conventions."
                    ))))
               arglist))))
 
-(defun cl--do-arglist (args expr &optional num)   ; uses bind-*
+(defun cl--do-arglist (args expr &optional num)   ; uses cl--bind-*
   (if (nlistp args)
       (if (or (memq args cl--lambda-list-keywords) (not (symbolp args)))
           (error "Invalid argument name: %s" args)
@@ -441,9 +447,9 @@ its argument list allows full Common Lisp conventions."
           (keys nil)
           (laterarg nil) (exactarg nil) minarg)
       (or num (setq num 0))
-      (if (listp (cadr restarg))
-          (setq restarg (make-symbol "--cl-rest--"))
-        (setq restarg (cadr restarg)))
+      (setq restarg (if (listp (cadr restarg))
+                        (make-symbol "--cl-rest--")
+                      (cadr restarg)))
       (push (list restarg expr) cl--bind-lets)
       (if (eq (car args) '&whole)
           (push (list (cl--pop2 args) restarg) cl--bind-lets))
@@ -570,12 +576,11 @@ its argument list allows full Common Lisp conventions."
   "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)
+  (let* ((cl--bind-lets nil) (cl--bind-forms nil)
          (cl--bind-defs nil) (cl--bind-block 'cl-none) (cl--bind-enquote nil))
     (cl--do-arglist (or args '(&aux)) expr)
-    (append '(progn) cl--bind-inits
-            (list `(let* ,(nreverse cl--bind-lets)
-                     ,@(nreverse cl--bind-forms) ,@body)))))
+    (macroexp-let* (nreverse cl--bind-lets)
+                   (macroexp-progn (append (nreverse cl--bind-forms) body)))))
 
 
 ;;; The `cl-eval-when' form.
@@ -655,30 +660,26 @@ allowed only in the final clause, and matches if no other keys match.
 Key values are compared by `eql'.
 \n(fn EXPR (KEYLIST BODY...)...)"
   (declare (indent 1) (debug (form &rest (sexp body))))
-  (let* ((temp (if (cl--simple-expr-p expr 3) expr (make-symbol "--cl-var--")))
-         (head-list nil)
-         (body (cons
-                'cond
-                (mapcar
-                 (function
-                  (lambda (c)
-                    (cons (cond ((memq (car c) '(t otherwise)) t)
-                                ((eq (car c) 'cl--ecase-error-flag)
-                                 `(error "cl-ecase failed: %s, %s"
-                                         ,temp ',(reverse head-list)))
-                                ((listp (car c))
-                                 (setq head-list (append (car c) head-list))
-                                 `(cl-member ,temp ',(car c)))
-                                (t
-                                 (if (memq (car c) head-list)
-                                     (error "Duplicate key in case: %s"
-                                            (car c)))
-                                 (push (car c) head-list)
-                                 `(eql ,temp ',(car c))))
-                          (or (cdr c) '(nil)))))
-                 clauses))))
-    (if (eq temp expr) body
-      `(let ((,temp ,expr)) ,body))))
+  (macroexp-let2 macroexp-copyable-p temp expr
+    (let* ((head-list nil))
+      `(cond
+        ,@(mapcar
+           (lambda (c)
+             (cons (cond ((memq (car c) '(t otherwise)) t)
+                         ((eq (car c) 'cl--ecase-error-flag)
+                          `(error "cl-ecase failed: %s, %s"
+                                  ,temp ',(reverse head-list)))
+                         ((listp (car c))
+                          (setq head-list (append (car c) head-list))
+                          `(cl-member ,temp ',(car c)))
+                         (t
+                          (if (memq (car c) head-list)
+                              (error "Duplicate key in case: %s"
+                                     (car c)))
+                          (push (car c) head-list)
+                          `(eql ,temp ',(car c))))
+                   (or (cdr c) '(nil))))
+           clauses)))))
 
 ;;;###autoload
 (defmacro cl-ecase (expr &rest clauses)
@@ -698,24 +699,22 @@ final clause, and matches if no other keys match.
 \n(fn EXPR (TYPE BODY...)...)"
   (declare (indent 1)
            (debug (form &rest ([&or cl-type-spec "otherwise"] body))))
-  (let* ((temp (if (cl--simple-expr-p expr 3) expr (make-symbol "--cl-var--")))
-         (type-list nil)
-         (body (cons
-                'cond
-                (mapcar
-                 (function
-                  (lambda (c)
-                    (cons (cond ((eq (car c) 'otherwise) t)
-                                ((eq (car c) 'cl--ecase-error-flag)
-                                 `(error "cl-etypecase failed: %s, %s"
-                                         ,temp ',(reverse type-list)))
-                                (t
-                                 (push (car c) type-list)
-                                 (cl--make-type-test temp (car c))))
-                          (or (cdr c) '(nil)))))
-                 clauses))))
-    (if (eq temp expr) body
-      `(let ((,temp ,expr)) ,body))))
+  (macroexp-let2 macroexp-copyable-p temp expr
+    (let* ((type-list nil))
+      (cons
+       'cond
+       (mapcar
+        (function
+         (lambda (c)
+           (cons (cond ((eq (car c) 'otherwise) t)
+                       ((eq (car c) 'cl--ecase-error-flag)
+                        `(error "cl-etypecase failed: %s, %s"
+                                ,temp ',(reverse type-list)))
+                       (t
+                        (push (car c) type-list)
+                        `(cl-typep ,temp ',(car c))))
+                 (or (cdr c) '(nil)))))
+        clauses)))))
 
 ;;;###autoload
 (defmacro cl-etypecase (expr &rest clauses)
@@ -1439,16 +1438,14 @@ For more details, see Info node `(cl)Loop Facility'.
         (push `(progn (if ,what (cl-incf ,var)) t) cl--loop-body)))
 
      ((memq word '(minimize minimizing maximize maximizing))
-      (let* ((what (pop cl--loop-args))
-             (temp (if (cl--simple-expr-p what) what
-                     (make-symbol "--cl-var--")))
-             (var (cl--loop-handle-accum nil))
-             (func (intern (substring (symbol-name word) 0 3)))
-             (set `(setq ,var (if ,var (,func ,var ,temp) ,temp))))
-        (push `(progn ,(if (eq temp what) set
-                         `(let ((,temp ,what)) ,set))
-                      t)
-              cl--loop-body)))
+      (push `(progn ,(macroexp-let2 macroexp-copyable-p temp
+                                    (pop cl--loop-args)
+                       (let* ((var (cl--loop-handle-accum nil))
+                              (func (intern (substring (symbol-name word)
+                                                       0 3))))
+                         `(setq ,var (if ,var (,func ,var ,temp) ,temp))))
+                    t)
+            cl--loop-body))
 
      ((eq word 'with)
       (let ((bindings nil))
@@ -2104,14 +2101,11 @@ values.  For compatibility, (cl-values A B C) is a synonym for (list A B C).
                (< cl--optimize-speed 3)
                (= cl--optimize-safety 3)))
       form
-    (let* ((temp (if (cl--simple-expr-p form 3)
-                     form (make-symbol "--cl-var--")))
-           (body `(progn (unless ,(cl--make-type-test temp type)
-                           (signal 'wrong-type-argument
-                                   (list ',type ,temp ',form)))
-                         ,temp)))
-      (if (eq temp form) body
-        `(let ((,temp ,form)) ,body)))))
+    (macroexp-let2 macroexp-copyable-p temp form
+      `(progn (unless (cl-typep ,temp ',type)
+                (signal 'wrong-type-argument
+                        (list ',type ,temp ',form)))
+              ,temp))))
 
 (defvar cl--proclaim-history t)    ; for future compilers
 (defvar cl--declare-stack t)       ; for future compilers
@@ -2425,15 +2419,11 @@ non-nil value, that slot cannot be set via `setf'.
          (tag (intern (format "cl-struct-%s" name)))
          (tag-symbol (intern (format "cl-struct-%s-tags" name)))
          (include-descs nil)
-         (side-eff nil)
          (type nil)
          (named nil)
          (forms nil)
+         (docstring (if (stringp (car descs)) (pop descs)))
          pred-form pred-check)
-    (if (stringp (car descs))
-        (push `(put ',name 'structure-documentation
-                    ,(pop descs))
-              forms))
     (setq descs (cons '(cl-tag-slot)
                       (mapcar (function (lambda (x) (if (consp x) x (list x))))
                               descs)))
@@ -2458,6 +2448,7 @@ non-nil value, that slot cannot be set via `setf'.
               ((eq opt :predicate)
                (if args (setq predicate (car args))))
               ((eq opt :include)
+               (when include (error "Can't :include more than once"))
                (setq include (car args)
                      include-descs (mapcar (function
                                             (lambda (x)
@@ -2511,20 +2502,19 @@ non-nil value, that slot cannot be set via `setf'.
             (if named (setq tag name)))
         (setq type 'vector named 'true)))
     (or named (setq descs (delq (assq 'cl-tag-slot descs) descs)))
-    (push `(defvar ,tag-symbol) forms)
     (when (and (null predicate) named)
       (setq predicate (intern (format "cl--struct-%s-p" name))))
     (setq pred-form (and named
                          (let ((pos (- (length descs)
                                        (length (memq (assq 'cl-tag-slot descs)
                                                      descs)))))
-                           (if (eq type 'vector)
-                               `(and (vectorp cl-x)
-                                     (>= (length cl-x) ,(length descs))
-                                     (memq (aref cl-x ,pos) ,tag-symbol))
-                             (if (= pos 0)
-                                 `(memq (car-safe cl-x) ,tag-symbol)
-                               `(and (consp cl-x)
+                           (cond
+                            ((eq type 'vector)
+                             `(and (vectorp cl-x)
+                                   (>= (length cl-x) ,(length descs))
+                                   (memq (aref cl-x ,pos) ,tag-symbol)))
+                            ((= pos 0) `(memq (car-safe cl-x) ,tag-symbol))
+                            (t `(and (consp cl-x)
                                      (memq (nth ,pos cl-x) ,tag-symbol))))))
           pred-check (and pred-form (> safety 0)
                           (if (and (eq (cl-caadr pred-form) 'vectorp)
@@ -2546,6 +2536,7 @@ non-nil value, that slot cannot be set via `setf'.
               (push slot slots)
               (push (nth 1 desc) defaults)
               (push `(cl-defsubst ,accessor (cl-x)
+                       (declare (side-effect-free t))
                        ,@(and pred-check
                               (list `(or ,pred-check
                                          (error "%s accessing a non-%s"
@@ -2554,7 +2545,6 @@ non-nil value, that slot cannot be set via `setf'.
                           (if (= pos 0) '(car cl-x)
                             `(nth ,pos cl-x))))
                     forms)
-              (push (cons accessor t) side-eff)
               (if (cadr (memq :read-only (cddr desc)))
                   (push `(gv-define-expander ,accessor
                            (lambda (_cl-do _cl-x)
@@ -2587,15 +2577,14 @@ non-nil value, that slot cannot be set via `setf'.
           defaults (nreverse defaults))
     (when pred-form
       (push `(cl-defsubst ,predicate (cl-x)
+               (declare (side-effect-free error-free))
                ,(if (eq (car pred-form) 'and)
                     (append pred-form '(t))
                   `(and ,pred-form t)))
             forms)
-      (push `(put ',name 'cl-deftype-satisfies ',predicate) forms)
-      (push (cons predicate 'error-free) side-eff))
+      (push `(put ',name 'cl-deftype-satisfies ',predicate) forms))
     (and copier
-         (progn (push `(defun ,copier (x) (copy-sequence x)) forms)
-                (push (cons copier t) side-eff)))
+         (push `(defalias ',copier #'copy-sequence) forms))
     (if constructor
         (push (list constructor
                        (cons '&key (delq nil (copy-sequence slots))))
@@ -2607,11 +2596,11 @@ non-nil value, that slot cannot be set via `setf'.
              (make (cl-mapcar (function (lambda (s d) (if (memq s anames) s d)))
                             slots defaults)))
         (push `(cl-defsubst ,name
-                 (&cl-defs '(nil ,@descs) ,@args)
+                   (&cl-defs '(nil ,@descs) ,@args)
+                 ,@(if (cl--safe-expr-p `(progn ,@(mapcar #'cl-second descs)))
+                       '((declare (side-effect-free t))))
                  (,type ,@make))
-              forms)
-        (if (cl--safe-expr-p `(progn ,@(mapcar #'cl-second descs)))
-            (push (cons name t) side-eff))))
+              forms)))
     (if print-auto (nconc print-func (list '(princ ")" cl-s) t)))
     ;; Don't bother adding to cl-custom-print-functions since it's not used
     ;; by anything anyway!
@@ -2624,17 +2613,14 @@ non-nil value, that slot cannot be set via `setf'.
     ;;                  (and ,pred-form ,print-func))
     ;;                cl-custom-print-functions))
     ;;          forms))
-    (push `(setq ,tag-symbol (list ',tag)) forms)
-    (push `(cl-eval-when (compile load eval)
-             (put ',name 'cl-struct-slots ',descs)
-             (put ',name 'cl-struct-type ',(list type (eq named t)))
-             (put ',name 'cl-struct-include ',include)
-             (put ',name 'cl-struct-print ,print-auto)
-             ,@(mapcar (lambda (x)
-                         `(function-put ',(car x) 'side-effect-free ',(cdr x)))
-                       side-eff))
-          forms)
-    `(progn ,@(nreverse (cons `',name forms)))))
+    `(progn
+       (defvar ,tag-symbol)
+       ,@(nreverse forms)
+       (eval-and-compile
+         (cl-struct-define ',name ,docstring ',include
+                           ',type ,(eq named t) ',descs ',tag-symbol ',tag
+                           ',print-auto))
+       ',name)))
 
 (defun cl-struct-sequence-type (struct-type)
   "Return the sequence used to build STRUCT-TYPE.
@@ -2741,14 +2727,11 @@ STRING is an optional description of the desired type."
   (declare (debug (place cl-type-spec &optional stringp)))
   (and (or (not (cl--compiling-file))
            (< cl--optimize-speed 3) (= cl--optimize-safety 3))
-       (let* ((temp (if (cl--simple-expr-p form 3)
-                        form (make-symbol "--cl-var--")))
-              (body `(or ,(cl--make-type-test temp type)
-                         (signal 'wrong-type-argument
-                                 (list ,(or string `',type)
-                                       ,temp ',form)))))
-         (if (eq temp form) `(progn ,body nil)
-           `(let ((,temp ,form)) ,body nil)))))
+       (macroexp-let2 macroexp-copyable-p temp form
+         `(progn (or (cl-typep ,temp ',type)
+                     (signal 'wrong-type-argument
+                             (list ,(or string `',type) ,temp ',form)))
+                 nil))))
 
 ;;;###autoload
 (defmacro cl-assert (form &optional show-args string &rest args)
diff --git a/lisp/emacs-lisp/cl-preloaded.el b/lisp/emacs-lisp/cl-preloaded.el
new file mode 100644
index 00000000000..c9867b412a1
--- /dev/null
+++ b/lisp/emacs-lisp/cl-preloaded.el
@@ -0,0 +1,48 @@
+;;; cl-preloaded.el --- Preloaded part of the CL library  -*- lexical-binding: t; -*-
+
+;; Copyright (C) 2015  Free Software Foundation, Inc
+
+;; Author: Stefan Monnier <monnier@iro.umontreal.ca>
+
+;; This file is part of GNU Emacs.
+
+;; GNU Emacs 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.
+
+;; GNU Emacs 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 GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.
+
+;;; Commentary:
+
+;; The expectation is that structs defined with cl-defstruct do not
+;; need cl-lib at run-time, but we'd like to hide the details of the
+;; cl-struct metadata behind the cl-struct-define function, so we put
+;; it in this pre-loaded file.
+
+;;; Code:
+
+(defun cl-struct-define (name docstring parent type named slots children-sym
+                              tag print-auto)
+  (if (boundp children-sym)
+      (add-to-list children-sym tag)
+    (set children-sym (list tag)))
+  ;; If the cl-generic support, we need to be able to check
+  ;; if a vector is a cl-struct object, without knowing its particular type.
+  ;; So we use the (otherwise) unused function slots of the tag symbol
+  ;; to put a special witness value, to make the check easy and reliable.
+  (unless named (fset tag :quick-object-witness-check))
+  (put name 'cl-struct-slots slots)
+  (put name 'cl-struct-type (list type named))
+  (if parent (put name 'cl-struct-include parent))
+  (if print-auto (put name 'cl-struct-print print-auto))
+  (if docstring (put name 'structure-documentation docstring)))
+
+(provide 'cl-preloaded)
+;;; cl-preloaded.el ends here
diff --git a/lisp/emacs-lisp/cl.el b/lisp/emacs-lisp/cl.el
index 1cd7bd76b0e..5da1cea6bb3 100644
--- a/lisp/emacs-lisp/cl.el
+++ b/lisp/emacs-lisp/cl.el
@@ -376,7 +376,6 @@ The two cases that are handled are:
           (setq cl--function-convert-cache (cons newf res))
           res))))
    (t
-    (setq cl--labels-convert-cache cl--function-convert-cache)
     (cl--labels-convert f))))
 
 (defmacro lexical-let (bindings &rest body)
diff --git a/lisp/emacs-lisp/easy-mmode.el b/lisp/emacs-lisp/easy-mmode.el
index 7e6f56518a2..f7e8619948a 100644
--- a/lisp/emacs-lisp/easy-mmode.el
+++ b/lisp/emacs-lisp/easy-mmode.el
@@ -149,11 +149,12 @@ For example, you could write
     ...BODY CODE...)"
   (declare (doc-string 2)
            (debug (&define name string-or-null-p
-                           [&optional [&not keywordp] sexp
-                            &optional [&not keywordp] sexp
-                            &optional [&not keywordp] sexp]
-                           [&rest [keywordp sexp]]
-                           def-body)))
+                           [&optional [&not keywordp] sexp
+                            &optional [&not keywordp] sexp
+                            &optional [&not keywordp] sexp]
+                           [&rest [keywordp sexp]]
+                           def-body))
+           (indent 1))
 
   ;; Allow skipping the first three args.
   (cond
diff --git a/lisp/emacs-lisp/eieio-base.el b/lisp/emacs-lisp/eieio-base.el
index feb06711cb3..46585ee76c6 100644
--- a/lisp/emacs-lisp/eieio-base.el
+++ b/lisp/emacs-lisp/eieio-base.el
@@ -219,7 +219,7 @@ for CLASS.  Optional ALLOW-SUBCLASS says that it is ok for
 being pedantic."
   (unless class
     (message "Unsafe call to `eieio-persistent-read'."))
-  (when class (eieio--check-type class-p class))
+  (when class (cl-check-type class class))
   (let ((ret nil)
         (buffstr nil))
     (unwind-protect
@@ -481,7 +481,7 @@ instance."
 
 (cl-defmethod eieio-object-set-name-string ((obj eieio-named) name)
   "Set the string which is OBJ's NAME."
-  (eieio--check-type stringp name)
+  (cl-check-type name string)
   (eieio-oset obj 'object-name name))
 
 (cl-defmethod clone ((obj eieio-named) &rest params)
diff --git a/lisp/emacs-lisp/eieio-core.el b/lisp/emacs-lisp/eieio-core.el
index 7492f0522ab..77d8c01388b 100644
--- a/lisp/emacs-lisp/eieio-core.el
+++ b/lisp/emacs-lisp/eieio-core.el
@@ -40,6 +40,8 @@
 (declare-function slot-unbound "eieio")
 (declare-function slot-missing "eieio")
 (declare-function child-of-class-p "eieio")
+(declare-function same-class-p "eieio")
+(declare-function object-of-class-p "eieio")
 
 
 ;;;
@@ -154,15 +156,6 @@ Currently under control of this var:
 
 
 ;;; Important macros used internally in eieio.
-;;
-(defmacro eieio--check-type (type obj)
-  (unless (symbolp obj)
-    (error "eieio--check-type wants OBJ to be a variable"))
-  `(if (not ,(cond
-              ((eq 'or (car-safe type))
-               `(or ,@(mapcar (lambda (type) `(,type ,obj)) (cdr type))))
-              (t `(,type ,obj))))
-       (signal 'wrong-type-argument (list ',type ,obj))))
 
 (defmacro eieio--class-v (class)        ;Use a macro, so it acts as a GV place.
   "Internal: Return the class vector from the CLASS symbol."
@@ -183,27 +176,17 @@ Currently under control of this var:
       (eq (aref class 0) 'defclass)
     (error nil)))
 
-(defsubst eieio-class-object (class)
-  "Check that CLASS is a class and return the corresponding object."
-  (let ((c (eieio--class-object class)))
-    (eieio--check-type eieio--class-p c)
-    c))
-
-(defsubst class-p (class)
+(defun class-p (class)
   "Return non-nil if CLASS is a valid class vector.
 CLASS is a symbol."                     ;FIXME: Is it a vector or a symbol?
-  ;; this new method is faster since it doesn't waste time checking lots of
-  ;; things.
-  (condition-case nil
-      (eq (aref (eieio--class-v class) 0) 'defclass)
-    (error nil)))
+  (and (symbolp class) (eieio--class-p (eieio--class-v class))))
 
 (defun eieio-class-name (class)
   "Return a Lisp like symbol name for CLASS."
   ;; FIXME: What's a "Lisp like symbol name"?
   ;; FIXME: CLOS returns a symbol, but the code returns a string.
   (if (eieio--class-p class) (setq class (eieio--class-symbol class)))
-  (eieio--check-type class-p class)
+  (cl-check-type class class)
   ;; I think this is supposed to return a symbol, but to me CLASS is a symbol,
   ;; and I wanted a string.  Arg!
   (format "#<class %s>" (symbol-name class)))
@@ -221,14 +204,17 @@ CLASS is a symbol."                     ;FIXME: Is it a vector or a symbol?
 Return nil if that option doesn't exist."
   (eieio--class-option-assoc (eieio--class-options class) option))
 
-(defsubst eieio-object-p (obj)
+(defun eieio-object-p (obj)
   "Return non-nil if OBJ is an EIEIO object."
   (and (vectorp obj)
-       (condition-case nil
-           (eq (aref (eieio--object-class-object obj) 0) 'defclass)
-         (error nil))))
+       (> (length obj) 0)
+       (let ((tag (eieio--object-class-tag obj)))
+         (and (symbolp tag)
+              ;; (eq (symbol-function tag) :quick-object-witness-check)
+              (boundp tag)
+              (eieio--class-p (symbol-value tag))))))
 
-(defalias 'object-p 'eieio-object-p)
+(define-obsolete-function-alias 'object-p 'eieio-object-p "25.1")
 
 (defsubst class-abstract-p (class)
   "Return non-nil if CLASS is abstract.
@@ -266,10 +252,9 @@ It creates an autoload function for CNAME's constructor."
   ;; simply not exist yet.  So instead we just don't store the list of parents
   ;; here in eieio-defclass-autoload at all, since it seems that they're just
   ;; not needed before the class is actually loaded.
-  (let* ((oldc (when (class-p cname) (eieio--class-v cname)))
-         (newc (eieio--class-make cname))
-         )
-    (if oldc
+  (let* ((oldc (eieio--class-v cname))
+         (newc (eieio--class-make cname)))
+    (if (eieio--class-p oldc)
         nil ;; Do nothing if we already have this class.
 
       ;; turn this into a usable self-pointing symbol
@@ -300,7 +285,21 @@ It creates an autoload function for CNAME's constructor."
                      (cl-every (lambda (elem) (cl-typep elem ',elem-type))
                                list)))))
 
-(declare-function eieio--defmethod "eieio-generic" (method kind argclass code))
+
+(defun eieio-make-class-predicate (class)
+  (lambda (obj)
+    ;; (:docstring (format "Test OBJ to see if it's an object of type %S."
+    ;;                     class))
+    (and (eieio-object-p obj)
+         (same-class-p obj class))))
+
+(defun eieio-make-child-predicate (class)
+  (lambda (obj)
+    ;; (:docstring (format
+    ;;              "Test OBJ to see if it's an object is a child of type %S."
+    ;;              class))
+    (and (eieio-object-p obj)
+         (object-of-class-p obj class))))
 
 (defun eieio-defclass-internal (cname superclasses slots options)
   "Define CNAME as a new subclass of SUPERCLASSES.
@@ -314,7 +313,7 @@ See `defclass' for more information."
   (setq eieio-hook nil)
 
   (let* ((pname superclasses)
-         (oldc (when (class-p cname) (eieio--class-v cname)))
+         (oldc (let ((c (eieio--class-v cname))) (if (eieio--class-p c) c)))
          (newc (if (and oldc (not (eieio--class-default-object-cache oldc)))
                    ;; The oldc class is a stub setup by eieio-defclass-autoload.
                    ;; Reuse it instead of creating a new one, so that existing
@@ -342,19 +341,20 @@ See `defclass' for more information."
     (if pname
         (progn
           (dolist (p pname)
-            (if (and p (symbolp p))
-                (if (not (class-p p))
+            (if (not (and p (symbolp p)))
+                (error "Invalid parent class %S" p)
+              (let ((c (eieio--class-v p)))
+                (if (not (eieio--class-p c))
                     ;; bad class
                     (error "Given parent class %S is not a class" p)
                   ;; good parent class...
                   ;; save new child in parent
-                  (cl-pushnew cname (eieio--class-children (eieio--class-v p)))
+                  (cl-pushnew cname (eieio--class-children c))
                   ;; Get custom groups, and store them into our local copy.
                   (mapc (lambda (g) (cl-pushnew g groups :test #'equal))
-                        (eieio--class-option (eieio--class-v p) :custom-groups))
-                  ;; save parent in child
-                  (push (eieio--class-v p) (eieio--class-parent newc)))
-              (error "Invalid parent class %S" p)))
+                        (eieio--class-option c :custom-groups))
+                  ;; Save parent in child.
+                  (push c (eieio--class-parent newc))))))
           ;; Reverse the list of our parents so that they are prioritized in
           ;; the same order as specified in the code.
           (cl-callf nreverse (eieio--class-parent newc)))
@@ -506,13 +506,7 @@ See `defclass' for more information."
          (eieio--class-option-assoc options :documentation))
 
     ;; Save the file location where this class is defined.
-    (let ((fname (if load-in-progress
-                     load-file-name
-                   buffer-file-name)))
-      (when fname
-        (when (string-match "\\.elc\\'" fname)
-          (setq fname (substring fname 0 (1- (length fname)))))
-        (put cname 'class-location fname)))
+    (add-to-list 'current-load-list `(eieio-defclass . ,cname))
 
     ;; We have a list of custom groups.  Store them into the options.
     (let ((g (eieio--class-option-assoc options :custom-groups)))
@@ -539,6 +533,7 @@ See `defclass' for more information."
           ;; objects readable.
           (tag (intern (format "eieio-class-tag--%s" cname))))
       (set tag newc)
+      (fset tag :quick-object-witness-check)
       (setf (eieio--object-class-tag cache) tag)
       (let ((eieio-skip-typecheck t))
         ;; All type-checking has been done to our satisfaction
@@ -908,12 +903,13 @@ Argument FN is the function calling this verifier."
 ;;
 (defun eieio-oref (obj slot)
   "Return the value in OBJ at SLOT in the object vector."
-  (eieio--check-type (or eieio-object-p class-p) obj)
-  (eieio--check-type symbolp slot)
-  (if (class-p obj) (eieio-class-un-autoload obj))
+  (cl-check-type slot symbol)
+  (cl-check-type obj (or eieio-object class))
   (let* ((class (cond ((symbolp obj)
                        (error "eieio-oref called on a class!")
-                       (eieio--class-v obj))
+                       (let ((c (eieio--class-v obj)))
+                         (if (eieio--class-p c) (eieio-class-un-autoload obj))
+                         c))
                       (t (eieio--object-class-object obj))))
          (c (eieio--slot-name-index class obj slot)))
     (if (not c)
@@ -928,15 +924,15 @@ Argument FN is the function calling this verifier."
           (slot-missing obj slot 'oref)
           ;;(signal 'invalid-slot-name (list (eieio-object-name obj) slot))
           )
-      (eieio--check-type eieio-object-p obj)
+      (cl-check-type obj eieio-object)
       (eieio-barf-if-slot-unbound (aref obj c) obj slot 'oref))))
 
 
 (defun eieio-oref-default (obj slot)
   "Do the work for the macro `oref-default' with similar parameters.
 Fills in OBJ's SLOT with its default value."
-  (eieio--check-type (or eieio-object-p class-p) obj)
-  (eieio--check-type symbolp slot)
+  (cl-check-type obj (or eieio-object class))
+  (cl-check-type slot symbol)
   (let* ((cl (cond ((symbolp obj) (eieio--class-v obj))
                    (t (eieio--object-class-object obj))))
          (c (eieio--slot-name-index cl obj slot)))
@@ -974,8 +970,8 @@ Fills in OBJ's SLOT with its default value."
 (defun eieio-oset (obj slot value)
   "Do the work for the macro `oset'.
 Fills in OBJ's SLOT with VALUE."
-  (eieio--check-type eieio-object-p obj)
-  (eieio--check-type symbolp slot)
+  (cl-check-type obj eieio-object)
+  (cl-check-type slot symbol)
   (let* ((class (eieio--object-class-object obj))
          (c (eieio--slot-name-index class obj slot)))
     (if (not c)
@@ -999,8 +995,8 @@ Fills in OBJ's SLOT with VALUE."
   "Do the work for the macro `oset-default'.
 Fills in the default value in CLASS' in SLOT with VALUE."
   (setq class (eieio--class-object class))
-  (eieio--check-type eieio--class-p class)
-  (eieio--check-type symbolp slot)
+  (cl-check-type class eieio--class)
+  (cl-check-type slot symbol)
   (let* ((c (eieio--slot-name-index class nil slot)))
     (if (not c)
         ;; It might be missing because it is a :class allocated slot.
@@ -1222,10 +1218,11 @@ method invocation orders of the involved classes."
   ;;    A class must be defined before it can be used as a parameter
   ;;    specializer in a defmethod form.
   ;; So we can ignore types that are not known to denote classes.
-  (and (class-p type)
-       ;; Prefer (aref ,name 0) over (eieio--class-tag ,name) so that
-       ;; the tagcode is identical to the tagcode used for cl-struct.
-       `(50 . (and (vectorp ,name) (aref ,name 0)))))
+  (and (eieio--class-p (eieio--class-object type))
+       ;; Use the exact same code as for cl-struct, so that methods
+       ;; that dispatch on both kinds of objects get to share this
+       ;; part of the dispatch code.
+       `(50 . ,(cl--generic-struct-tag name))))
 
 (add-function :before-until cl-generic-tag-types-function
               #'eieio--generic-tag-types)
diff --git a/lisp/emacs-lisp/eieio-datadebug.el b/lisp/emacs-lisp/eieio-datadebug.el
index 119f7cce038..82349192e5e 100644
--- a/lisp/emacs-lisp/eieio-datadebug.el
+++ b/lisp/emacs-lisp/eieio-datadebug.el
@@ -117,7 +117,7 @@ PREBUTTONTEXT is some text between PREFIX and the object button."
           (setq publa (cdr publa)))))))
 
 ;;; Augment the Data debug thing display list.
-(data-debug-add-specialized-thing (lambda (thing) (object-p thing))
+(data-debug-add-specialized-thing (lambda (thing) (eieio-object-p thing))
                                   #'data-debug-insert-object-button)
 
 ;;; DEBUG METHODS
diff --git a/lisp/emacs-lisp/eieio-opt.el b/lisp/emacs-lisp/eieio-opt.el
index 8d40edf5624..304ee364dc8 100644
--- a/lisp/emacs-lisp/eieio-opt.el
+++ b/lisp/emacs-lisp/eieio-opt.el
@@ -45,7 +45,7 @@ variable `eieio-default-superclass'."
                                                 nil t)))
                  nil))
   (if (not root-class) (setq root-class 'eieio-default-superclass))
-  (eieio--check-type class-p root-class)
+  (cl-check-type root-class class)
   (display-buffer (get-buffer-create "*EIEIO OBJECT BROWSE*") t)
   (with-current-buffer (get-buffer "*EIEIO OBJECT BROWSE*")
     (erase-buffer)
@@ -58,7 +58,7 @@ variable `eieio-default-superclass'."
 Argument THIS-ROOT is the local root of the tree.
 Argument PREFIX is the character prefix to use.
 Argument CH-PREFIX is another character prefix to display."
-  (eieio--check-type class-p this-root)
+  (cl-check-type this-root class)
   (let ((myname (symbol-name this-root))
         (chl (eieio--class-children (eieio--class-v this-root)))
         (fprefix (concat ch-prefix "  +--"))
@@ -85,12 +85,12 @@ If CLASS is actually an object, then also display current values of that object.
               "n abstract"
             "")
           " class")
-  (let ((location (get class 'class-location)))
+  (let ((location (find-lisp-object-file-name class 'eieio-defclass)))
     (when location
       (insert " in `")
       (help-insert-xref-button
-       (file-name-nondirectory location)
-       'eieio-class-def class location)
+       (help-fns-short-filename location)
+       'eieio-class-def class location 'eieio-defclass)
       (insert "'")))
   (insert ".\n")
   ;; Parents
@@ -204,15 +204,6 @@ Outputs to the current buffer."
             prot (cdr prot)
             i (1+ i)))))
 
-(defun eieio-build-class-list (class)
-  "Return a list of all classes that inherit from CLASS."
-  (if (class-p class)
-      (cl-mapcan
-       (lambda (c)
-         (append (list c) (eieio-build-class-list c)))
-       (eieio--class-children (eieio--class-v class)))
-    (list class)))
-
 (defun eieio-build-class-alist (&optional class instantiable-only buildlist)
   "Return an alist of all currently active classes for completion purposes.
 Optional argument CLASS is the class to start with.
@@ -256,24 +247,22 @@ are not abstract."
 
 ;;; METHOD COMPLETION / DOC
 
-(define-button-type 'eieio-method-def
-  :supertype 'help-xref
-  'help-function (lambda (class method file)
-                   (eieio-help-find-method-definition class method file))
-  'help-echo (purecopy "mouse-2, RET: find method's definition"))
-
 (define-button-type 'eieio-class-def
-  :supertype 'help-xref
-  'help-function (lambda (class file)
-                   (eieio-help-find-class-definition class file))
+  :supertype 'help-function-def
   'help-echo (purecopy "mouse-2, RET: find class definition"))
 
+(defconst eieio--defclass-regexp "(defclass[ \t\r\n]+%s[ \t\r\n]+")
+(with-eval-after-load 'find-func
+  (defvar find-function-regexp-alist)
+  (add-to-list 'find-function-regexp-alist
+               `(eieio-defclass . eieio--defclass-regexp)))
+
 ;;;###autoload
 (defun eieio-help-constructor (ctr)
   "Describe CTR if it is a class constructor."
   (when (class-p ctr)
     (erase-buffer)
-    (let ((location (get ctr 'class-location))
+    (let ((location (find-lisp-object-file-name ctr 'eieio-defclass))
           (def (symbol-function ctr)))
       (goto-char (point-min))
       (prin1 ctr)
@@ -288,8 +277,8 @@ are not abstract."
       (when location
         (insert " in `")
         (help-insert-xref-button
-         (file-name-nondirectory location)
-         'eieio-class-def ctr location)
+         (help-fns-short-filename location)
+         'eieio-class-def ctr location 'eieio-defclass)
         (insert "'"))
       (insert ".\nCreates an object of class " (symbol-name ctr) ".")
       (goto-char (point-max))
@@ -304,7 +293,7 @@ are not abstract."
   "Return non-nil if a method with SPECIALIZERS applies to CLASS."
   (let ((applies nil))
     (dolist (specializer specializers)
-      (if (eq 'subclass (car-safe specializer))
+      (if (memq (car-safe specializer) '(subclass eieio--static))
           (setq specializer (nth 1 specializer)))
       ;; Don't include the methods that are "too generic", such as those
       ;; applying to `eieio-default-superclass'.
@@ -443,60 +432,6 @@ The value returned is a list of elements of the form
     (terpri)
     ))
 
-;;; HELP AUGMENTATION
-;;
-(defun eieio-help-find-method-definition (class method file)
-  (let ((filename (find-library-name file))
-        location buf)
-    (when (symbolp class)
-      (setq class (symbol-name class)))
-    (when (symbolp method)
-      (setq method (symbol-name method)))
-    (when (null filename)
-      (error "Cannot find library %s" file))
-    (setq buf (find-file-noselect filename))
-    (with-current-buffer buf
-      (goto-char (point-min))
-      (when
-          (re-search-forward
-           ;; Regexp for searching methods.
-           (concat "(defmethod[ \t\r\n]+" method
-                   "\\([ \t\r\n]+:[a-zA-Z]+\\)?"
-                   "[ \t\r\n]+(\\s-*(\\(\\sw\\|\\s_\\)+\\s-+"
-                   class
-                   "\\s-*)")
-           nil t)
-        (setq location (match-beginning 0))))
-    (if (null location)
-        (message "Unable to find location in file")
-      (pop-to-buffer buf)
-      (goto-char location)
-      (recenter)
-      (beginning-of-line))))
-
-(defun eieio-help-find-class-definition (class file)
-  (when (symbolp class)
-    (setq class (symbol-name class)))
-  (let ((filename (find-library-name file))
-        location buf)
-    (when (null filename)
-      (error "Cannot find library %s" file))
-    (setq buf (find-file-noselect filename))
-    (with-current-buffer buf
-      (goto-char (point-min))
-      (when
-          (re-search-forward
-           ;; Regexp for searching a class.
-           (concat "(defclass[ \t\r\n]+" class "[ \t\r\n]+")
-           nil t)
-        (setq location (match-beginning 0))))
-    (if (null location)
-        (message "Unable to find location in file")
-      (pop-to-buffer buf)
-      (goto-char location)
-      (recenter)
-      (beginning-of-line))))
-
 ;;; SPEEDBAR SUPPORT
 ;;
 
@@ -546,7 +481,7 @@ current expansion depth."
 
 (defun eieio-class-button (class depth)
   "Draw a speedbar button at the current point for CLASS at DEPTH."
-  (eieio--check-type class-p class)
+  (cl-check-type class class)
   (let ((subclasses (eieio--class-children (eieio--class-v class))))
     (if subclasses
         (speedbar-make-tag-line 'angle ?+
diff --git a/lisp/emacs-lisp/eieio.el b/lisp/emacs-lisp/eieio.el
index 91469b4b96c..526090954a9 100644
--- a/lisp/emacs-lisp/eieio.el
+++ b/lisp/emacs-lisp/eieio.el
@@ -110,7 +110,7 @@ Options in CLOS not supported in EIEIO:
 Due to the way class options are set up, you can add any tags you wish,
 and reference them using the function `class-option'."
   (declare (doc-string 4))
-  (eieio--check-type listp superclasses)
+  (cl-check-type superclasses list)
 
   (cond ((and (stringp (car options-and-doc))
               (/= 1 (% (length options-and-doc) 2)))
@@ -223,18 +223,9 @@ This method is obsolete."
        ;; referencing classes.  ei, a class whose slot can contain only
        ;; pointers to itself.
 
-       ;; Create the test function.
-       (defun ,testsym1 (obj)
-         ,(format "Test OBJ to see if it an object of type %S." name)
-         (and (eieio-object-p obj)
-              (same-class-p obj ',name)))
-
-       (defun ,testsym2 (obj)
-         ,(format
-           "Test OBJ to see if it an object is a child of type %S."
-           name)
-         (and (eieio-object-p obj)
-              (object-of-class-p obj ',name)))
+       ;; Create the test functions.
+       (defalias ',testsym1 (eieio-make-class-predicate ',name))
+       (defalias ',testsym2 (eieio-make-child-predicate ',name))
 
        ,@(when eieio-backward-compatibility
            (let ((f (intern (format "%s-child-p" name))))
@@ -374,7 +365,7 @@ variable name of the same name as the slot."
 (defun eieio-object-name (obj &optional extra)
   "Return a Lisp like symbol string for object OBJ.
 If EXTRA, include that in the string returned to represent the symbol."
-  (eieio--check-type eieio-object-p obj)
+  (cl-check-type obj eieio-object)
   (format "#<%s %s%s>" (eieio--object-class-name obj)
           (eieio-object-name-string obj) (or extra "")))
 (define-obsolete-function-alias 'object-name #'eieio-object-name "24.4")
@@ -394,7 +385,7 @@ If EXTRA, include that in the string returned to represent the symbol."
 (cl-defmethod eieio-object-set-name-string (obj name)
   "Set the string which is OBJ's NAME."
   (declare (obsolete eieio-named "25.1"))
-  (eieio--check-type stringp name)
+  (cl-check-type name string)
   (setf (gethash obj eieio--object-names) name))
 (define-obsolete-function-alias
   'object-set-name-string 'eieio-object-set-name-string "24.4")
@@ -402,7 +393,7 @@ If EXTRA, include that in the string returned to represent the symbol."
 (defun eieio-object-class (obj)
   "Return the class struct defining OBJ."
   ;; FIXME: We say we return a "struct" but we return a symbol instead!
-  (eieio--check-type eieio-object-p obj)
+  (cl-check-type obj eieio-object)
   (eieio--object-class-name obj))
 (define-obsolete-function-alias 'object-class #'eieio-object-class "24.4")
 ;; CLOS name, maybe?
@@ -410,7 +401,7 @@ If EXTRA, include that in the string returned to represent the symbol."
 
 (defun eieio-object-class-name (obj)
   "Return a Lisp like symbol name for OBJ's class."
-  (eieio--check-type eieio-object-p obj)
+  (cl-check-type obj eieio-object)
   (eieio-class-name (eieio--object-class-name obj)))
 (define-obsolete-function-alias
   'object-class-name 'eieio-object-class-name "24.4")
@@ -419,15 +410,14 @@ If EXTRA, include that in the string returned to represent the symbol."
   "Return parent classes to CLASS.  (overload of variable).
 
 The CLOS function `class-direct-superclasses' is aliased to this function."
-  (let ((c (eieio-class-object class)))
-    (eieio--class-parent c)))
+  (eieio--class-parent (eieio--class-object class)))
 
 (define-obsolete-function-alias 'class-parents #'eieio-class-parents "24.4")
 
 (defun eieio-class-children (class)
   "Return child classes to CLASS.
 The CLOS function `class-direct-subclasses' is aliased to this function."
-  (eieio--check-type class-p class)
+  (cl-check-type class class)
   (eieio--class-children (eieio--class-v class)))
 (define-obsolete-function-alias
   'class-children #'eieio-class-children "24.4")
@@ -446,13 +436,13 @@ The CLOS function `class-direct-subclasses' is aliased to this function."
 (defun same-class-p (obj class)
   "Return t if OBJ is of class-type CLASS."
   (setq class (eieio--class-object class))
-  (eieio--check-type eieio--class-p class)
-  (eieio--check-type eieio-object-p obj)
+  (cl-check-type class eieio--class)
+  (cl-check-type obj eieio-object)
   (eq (eieio--object-class-object obj) class))
 
 (defun object-of-class-p (obj class)
   "Return non-nil if OBJ is an instance of CLASS or CLASS' subclasses."
-  (eieio--check-type eieio-object-p obj)
+  (cl-check-type obj eieio-object)
   ;; class will be checked one layer down
   (child-of-class-p (eieio--object-class-object obj) class))
 ;; Backwards compatibility
@@ -461,13 +451,13 @@ The CLOS function `class-direct-subclasses' is aliased to this function."
 (defun child-of-class-p (child class)
   "Return non-nil if CHILD class is a subclass of CLASS."
   (setq child (eieio--class-object child))
-  (eieio--check-type eieio--class-p child)
+  (cl-check-type child eieio--class)
   ;; `eieio-default-superclass' is never mentioned in eieio--class-parent,
   ;; so we have to special case it here.
   (or (eq class 'eieio-default-superclass)
       (let ((p nil))
         (setq class (eieio--class-object class))
-        (eieio--check-type eieio--class-p class)
+        (cl-check-type class eieio--class)
         (while (and child (not (eq child class)))
           (setq p (append p (eieio--class-parent child))
                 child (pop p)))
@@ -475,11 +465,11 @@ The CLOS function `class-direct-subclasses' is aliased to this function."
 
 (defun object-slots (obj)
   "Return list of slots available in OBJ."
-  (eieio--check-type eieio-object-p obj)
+  (cl-check-type obj eieio-object)
   (eieio--class-public-a (eieio--object-class-object obj)))
 
 (defun eieio--class-slot-initarg (class slot) "Fetch from CLASS, SLOT's :initarg."
-  (eieio--check-type eieio--class-p class)
+  (cl-check-type class eieio--class)
   (let ((ia (eieio--class-initarg-tuples class))
         (f nil))
     (while (and ia (not f))
@@ -517,7 +507,7 @@ OBJECT can be an instance or a class."
     ;; Return nil if the magic symbol is in there.
     (not (eq (cond
               ((eieio-object-p object) (eieio-oref object slot))
-              ((class-p object)        (eieio-oref-default object slot))
+              ((symbolp object)        (eieio-oref-default object slot))
               (t (signal 'wrong-type-argument (list 'eieio-object-p object))))
              eieio-unbound))))
 
@@ -529,7 +519,8 @@ OBJECT can be an instance or a class."
   "Return non-nil if OBJECT-OR-CLASS has SLOT."
   (let ((cv (cond ((eieio-object-p object-or-class)
                    (eieio--object-class-object object-or-class))
-                  (t (eieio-class-object object-or-class)))))
+                  ((eieio--class-p object-or-class) object-or-class)
+                  (t (find-class object-or-class 'error)))))
     (or (memq slot (eieio--class-public-a cv))
         (memq slot (eieio--class-class-allocation-a cv)))
     ))
@@ -538,10 +529,10 @@ OBJECT can be an instance or a class."
   "Return the class that SYMBOL represents.
 If there is no class, nil is returned if ERRORP is nil.
 If ERRORP is non-nil, `wrong-argument-type' is signaled."
-  (if (not (class-p symbol))
-      (if errorp (signal 'wrong-type-argument (list 'class-p symbol))
-        nil)
-    (eieio--class-v symbol)))
+  (let ((class (eieio--class-v symbol)))
+    (cond
+     ((eieio--class-p class) class)
+     (errorp (signal 'wrong-type-argument (list 'class-p symbol))))))
 
 ;;; Slightly more complex utility functions for objects
 ;;
@@ -551,7 +542,7 @@ LIST is a list of objects whose slots are searched.
 Objects in LIST do not need to have a slot named SLOT, nor does
 SLOT need to be bound.  If these errors occur, those objects will
 be ignored."
-  (eieio--check-type listp list)
+  (cl-check-type list list)
   (while (and list (not (condition-case nil
                             ;; This prevents errors for missing slots.
                             (equal key (eieio-oref (car list) slot))
@@ -563,7 +554,7 @@ be ignored."
   "Return an association list with the contents of SLOT as the key element.
 LIST must be a list of objects with SLOT in it.
 This is useful when you need to do completing read on an object group."
-  (eieio--check-type listp list)
+  (cl-check-type list list)
   (let ((assoclist nil))
     (while list
       (setq assoclist (cons (cons (eieio-oref (car list) slot)
@@ -577,7 +568,7 @@ This is useful when you need to do completing read on an object group."
 LIST must be a list of objects, but those objects do not need to have
 SLOT in it.  If it does not, then that element is left out of the association
 list."
-  (eieio--check-type listp list)
+  (cl-check-type list list)
   (let ((assoclist nil))
     (while list
       (if (slot-exists-p (car list) slot)
@@ -869,12 +860,8 @@ this object."
          (object-write thing))
         ((consp thing)
          (eieio-list-prin1 thing))
-        ((class-p thing)
+        ((eieio--class-p thing)
          (princ (eieio-class-name thing)))
-        ((or (keywordp thing) (booleanp thing))
-         (prin1 thing))
-        ((symbolp thing)
-         (princ (concat "'" (symbol-name thing))))
         (t (prin1 thing))))
 
 (defun eieio-list-prin1 (list)
@@ -942,7 +929,7 @@ Optional argument GROUP is the sub-group of slots to display.
 
 ;;;***
 
-;;;### (autoloads nil "eieio-opt" "eieio-opt.el" "b849f8bf1312d5ef57e53d02173e4b5a")
+;;;### (autoloads nil "eieio-opt" "eieio-opt.el" "ff1097f185bc2c253276a7d19fe2f54a")
 ;;; Generated autoloads from eieio-opt.el
 
 (autoload 'eieio-browse "eieio-opt" "\
diff --git a/lisp/erc/ChangeLog b/lisp/erc/ChangeLog
index 28ac7d38b96..44971cc16fc 100644
--- a/lisp/erc/ChangeLog
+++ b/lisp/erc/ChangeLog
@@ -1,3 +1,8 @@
+2015-01-28  Dima Kogan  <dima@secretsauce.net>
+
+        * erc-backend.el (define-erc-response-handler): Give hook-name
+        default value of nil and add-to-list (bug#19363).
+
 2015-01-22  Paul Eggert  <eggert@cs.ucla.edu>
 
         Don't downcase system diagnostics' first letters
diff --git a/lisp/erc/erc-backend.el b/lisp/erc/erc-backend.el
index b8c67860e20..8ce199fbcbb 100644
--- a/lisp/erc/erc-backend.el
+++ b/lisp/erc/erc-backend.el
@@ -1162,8 +1162,11 @@ add things to `%s' instead."
           (cl-loop for alias in aliases
                    collect (intern (format "erc-server-%s-functions" alias)))))
     `(prog2
-         ;; Normal hook variable.
-         (defvar ,hook-name ',fn-name ,(format hook-doc name))
+         ;; Normal hook variable.  The variable may already have a
+         ;; value at this point, so I default to nil, and (add-hook)
+         ;; unconditionally
+         (defvar ,hook-name nil ,(format hook-doc name))
+         (add-to-list ',hook-name ',fn-name)
          ;; Handler function
          (defun ,fn-name (proc parsed)
            ,fn-doc
diff --git a/lisp/filenotify.el b/lisp/filenotify.el
index 35181b63f3a..c94f631dde8 100644
--- a/lisp/filenotify.el
+++ b/lisp/filenotify.el
@@ -41,13 +41,21 @@ could use another implementation.")
   "Hash table for registered file notification descriptors.
 A key in this hash table is the descriptor as returned from
 `gfilenotify', `inotify', `w32notify' or a file name handler.
-The value in the hash table is the cons cell (DIR FILE CALLBACK).")
+The value in the hash table is a list
+
+  \(DIR (FILE . CALLBACK) (FILE . CALLBACK) ...)
+
+Several values for a given DIR happen only for `inotify', when
+different files from the same directory are watched.")
 
 ;; This function is used by `gfilenotify', `inotify' and `w32notify' events.
 ;;;###autoload
 (defun file-notify-handle-event (event)
   "Handle file system monitoring event.
-If EVENT is a filewatch event, call its callback.
+If EVENT is a filewatch event, call its callback.  It has the format
+
+  \(file-notify (DESCRIPTOR ACTIONS FILE COOKIE) CALLBACK)
+
 Otherwise, signal a `file-notify-error'."
   (interactive "e")
   (if (and (eq (car event) 'file-notify)
@@ -81,12 +89,23 @@ This is available in case a file has been moved."
 This is available in case a file has been moved."
   (nth 3 event))
 
+;; `inotify' returns the same descriptor when the file (directory)
+;; uses the same inode.  We want to distinguish, and apply a virtual
+;; descriptor which make the difference.
+(defun file-notify--descriptor (descriptor file)
+  "Return the descriptor to be used in `file-notify-*-watch'.
+For `gfilenotify' and `w32notify' it is the same descriptor as
+used in the low-level file notification package."
+  (if (and (natnump descriptor) (eq file-notify--library 'inotify))
+      (cons descriptor file)
+    descriptor))
+
 ;; The callback function used to map between specific flags of the
 ;; respective file notifications, and the ones we return.
 (defun file-notify-callback (event)
   "Handle an EVENT returned from file notification.
-EVENT is the same one as in `file-notify-handle-event' except the
-car of that event, which is the symbol `file-notify'."
+EVENT is the cdr of the event in `file-notify-handle-event'
+\(DESCRIPTOR ACTIONS FILE COOKIE)."
   (let* ((desc (car event))
          (registered (gethash desc file-notify-descriptors))
          (pending-event (assoc desc file-notify--pending-events))
@@ -97,99 +116,113 @@ car of that event, which is the symbol `file-notify'."
     ;; Make actions a list.
     (unless (consp actions) (setq actions (cons actions nil)))
 
-    ;; Check, that event is meant for us.
-    (unless (setq callback (nth 2 registered))
-      (setq actions nil))
-
-    ;; Loop over actions.  In fact, more than one action happens only
-    ;; for `inotify'.
-    (dolist (action actions)
-
-      ;; Send pending event, if it doesn't match.
-      (when (and pending-event
-                 ;; The cookie doesn't match.
-                 (not (eq (file-notify--event-cookie pending-event)
-                          (file-notify--event-cookie event)))
-                 (or
-                  ;; inotify.
-                  (and (eq (nth 1 pending-event) 'moved-from)
-                       (not (eq action 'moved-to)))
-                  ;; w32notify.
-                  (and (eq (nth 1 pending-event) 'renamed-from)
-                       (not (eq action 'renamed-to)))))
-        (funcall callback
-                 (list desc 'deleted
-                       (file-notify--event-file-name pending-event)))
-        (setq file-notify--pending-events
-              (delete pending-event file-notify--pending-events)))
-
-      ;; Map action.  We ignore all events which cannot be mapped.
-      (setq action
-            (cond
-             ;; gfilenotify.
-             ((memq action '(attribute-changed changed created deleted)) action)
-             ((eq action 'moved)
-              (setq file1 (file-notify--event-file1-name event))
-              'renamed)
-
-             ;; inotify.
-             ((eq action 'attrib) 'attribute-changed)
-             ((eq action 'create) 'created)
-             ((eq action 'modify) 'changed)
-             ((memq action '(delete 'delete-self move-self)) 'deleted)
-             ;; Make the event pending.
-             ((eq action 'moved-from)
-              (add-to-list 'file-notify--pending-events
-                           (list desc action file
-                                 (file-notify--event-cookie event)))
-              nil)
-             ;; Look for pending event.
-             ((eq action 'moved-to)
-              (if (null pending-event)
-                  'created
-                (setq file1 file
-                      file (file-notify--event-file-name pending-event)
-                      file-notify--pending-events
-                      (delete pending-event file-notify--pending-events))
-                'renamed))
-
-             ;; w32notify.
-             ((eq action 'added) 'created)
-             ((eq action 'modified) 'changed)
-             ((eq action 'removed) 'deleted)
-             ;; Make the event pending.
-             ((eq 'renamed-from action)
-              (add-to-list 'file-notify--pending-events
-                           (list desc action file
-                                 (file-notify--event-cookie event)))
-              nil)
-             ;; Look for pending event.
-             ((eq 'renamed-to action)
-              (if (null pending-event)
-                  'created
-                (setq file1 file
-                      file (file-notify--event-file-name pending-event)
-                      file-notify--pending-events
-                      (delete pending-event file-notify--pending-events))
-                'renamed))))
-
-      ;; Apply callback.
-      (when (and action
-                 (or
-                  ;; If there is no relative file name for that watch,
-                  ;; we watch the whole directory.
-                  (null (nth 1 registered))
-                  ;; File matches.
-                  (string-equal
-                   (nth 1 registered) (file-name-nondirectory file))
-                  ;; File1 matches.
-                  (and (stringp file1)
-                       (string-equal
-                        (nth 1 registered) (file-name-nondirectory file1)))))
-        (if file1
-            (funcall callback (list desc action file file1))
-          (funcall callback (list desc action file)))))))
-
+    ;; Loop over registered entries.  In fact, more than one entry
+    ;; happens only for `inotify'.
+    (dolist (entry (cdr registered))
+
+      ;; Check, that event is meant for us.
+      (unless (setq callback (cdr entry))
+        (setq actions nil))
+
+      ;; Loop over actions.  In fact, more than one action happens only
+      ;; for `inotify'.
+      (dolist (action actions)
+
+        ;; Send pending event, if it doesn't match.
+        (when (and pending-event
+                   ;; The cookie doesn't match.
+                   (not (eq (file-notify--event-cookie pending-event)
+                            (file-notify--event-cookie event)))
+                   (or
+                    ;; inotify.
+                    (and (eq (nth 1 pending-event) 'moved-from)
+                         (not (eq action 'moved-to)))
+                    ;; w32notify.
+                    (and (eq (nth 1 pending-event) 'renamed-from)
+                         (not (eq action 'renamed-to)))))
+          (funcall callback
+                   (list desc 'deleted
+                         (file-notify--event-file-name pending-event)))
+          (setq file-notify--pending-events
+                (delete pending-event file-notify--pending-events)))
+
+        ;; Map action.  We ignore all events which cannot be mapped.
+        (setq action
+              (cond
+               ;; gfilenotify.
+               ((memq action '(attribute-changed changed created deleted))
+                action)
+               ((eq action 'moved)
+                (setq file1 (file-notify--event-file1-name event))
+                'renamed)
+
+               ;; inotify.
+               ((eq action 'attrib) 'attribute-changed)
+               ((eq action 'create) 'created)
+               ((eq action 'modify) 'changed)
+               ((memq action '(delete 'delete-self move-self)) 'deleted)
+               ;; Make the event pending.
+               ((eq action 'moved-from)
+                (add-to-list 'file-notify--pending-events
+                             (list desc action file
+                                   (file-notify--event-cookie event)))
+                nil)
+               ;; Look for pending event.
+               ((eq action 'moved-to)
+                (if (null pending-event)
+                    'created
+                  (setq file1 file
+                        file (file-notify--event-file-name pending-event)
+                        file-notify--pending-events
+                        (delete pending-event file-notify--pending-events))
+                  'renamed))
+
+               ;; w32notify.
+               ((eq action 'added) 'created)
+               ((eq action 'modified) 'changed)
+               ((eq action 'removed) 'deleted)
+               ;; Make the event pending.
+               ((eq action 'renamed-from)
+                (add-to-list 'file-notify--pending-events
+                             (list desc action file
+                                   (file-notify--event-cookie event)))
+                nil)
+               ;; Look for pending event.
+               ((eq action 'renamed-to)
+                (if (null pending-event)
+                    'created
+                  (setq file1 file
+                        file (file-notify--event-file-name pending-event)
+                        file-notify--pending-events
+                        (delete pending-event file-notify--pending-events))
+                  'renamed))))
+
+        ;; Apply callback.
+        (when (and action
+                   (or
+                    ;; If there is no relative file name for that watch,
+                    ;; we watch the whole directory.
+                    (null (nth 0 entry))
+                    ;; File matches.
+                    (string-equal
+                     (nth 0 entry) (file-name-nondirectory file))
+                    ;; File1 matches.
+                    (and (stringp file1)
+                         (string-equal
+                          (nth 0 entry) (file-name-nondirectory file1)))))
+          (if file1
+              (funcall
+               callback
+               `(,(file-notify--descriptor desc (nth 0 entry))
+                 ,action ,file ,file1))
+            (funcall
+             callback
+             `(,(file-notify--descriptor desc (nth 0 entry))
+               ,action ,file))))))))
+
+;; `gfilenotify' and `w32notify' return a unique descriptor for every
+;; `file-notify-add-watch', while `inotify' returns a unique
+;; descriptor per inode only.
 (defun file-notify-add-watch (file flags callback)
   "Add a watch for filesystem events pertaining to FILE.
 This arranges for filesystem events pertaining to FILE to be reported
@@ -206,7 +239,7 @@ include the following symbols:
   `attribute-change' -- watch for file attributes changes, like
                         permissions or modification time
 
-If FILE is a directory, 'change' watches for file creation or
+If FILE is a directory, `change' watches for file creation or
 deletion in that directory.  This does not work recursively.
 
 When any event happens, Emacs will call the CALLBACK function passing
@@ -240,82 +273,96 @@ FILE is the name of the file whose event is being reported."
                (if (file-directory-p file)
                    file
                  (file-name-directory file))))
-        desc func l-flags)
-
-    ;; Check, whether this has been registered already.
-;    (maphash
-;     (lambda (key value)
-;       (when (equal (cons file callback) value) (setq desc key)))
-;     file-notify-descriptors)
-
-    (unless desc
-      (if handler
-          ;; A file name handler could exist even if there is no local
-          ;; file notification support.
-          (setq desc (funcall
-                      handler 'file-notify-add-watch dir flags callback))
-
-        ;; Check, whether Emacs has been compiled with file
-        ;; notification support.
-        (unless file-notify--library
-          (signal 'file-notify-error
-                  '("No file notification package available")))
-
-        ;; Determine low-level function to be called.
-        (setq func
-              (cond
-               ((eq file-notify--library 'gfilenotify) 'gfile-add-watch)
-               ((eq file-notify--library 'inotify) 'inotify-add-watch)
-               ((eq file-notify--library 'w32notify) 'w32notify-add-watch)))
-
-        ;; Determine respective flags.
-        (if (eq file-notify--library 'gfilenotify)
-            (setq l-flags '(watch-mounts send-moved))
-          (when (memq 'change flags)
-            (setq
-             l-flags
-             (cond
-              ((eq file-notify--library 'inotify) '(create modify move delete))
-              ((eq file-notify--library 'w32notify)
-               '(file-name directory-name size last-write-time)))))
-          (when (memq 'attribute-change flags)
-            (add-to-list
-             'l-flags
-             (cond
-              ((eq file-notify--library 'inotify) 'attrib)
-              ((eq file-notify--library 'w32notify) 'attributes)))))
-
-        ;; Call low-level function.
-        (setq desc (funcall func dir l-flags 'file-notify-callback))))
+        desc func l-flags registered)
+
+    (if handler
+        ;; A file name handler could exist even if there is no local
+        ;; file notification support.
+        (setq desc (funcall
+                    handler 'file-notify-add-watch dir flags callback))
+
+      ;; Check, whether Emacs has been compiled with file
+      ;; notification support.
+      (unless file-notify--library
+        (signal 'file-notify-error
+                '("No file notification package available")))
+
+      ;; Determine low-level function to be called.
+      (setq func
+            (cond
+             ((eq file-notify--library 'gfilenotify) 'gfile-add-watch)
+             ((eq file-notify--library 'inotify) 'inotify-add-watch)
+             ((eq file-notify--library 'w32notify) 'w32notify-add-watch)))
+
+      ;; Determine respective flags.
+      (if (eq file-notify--library 'gfilenotify)
+          (setq l-flags '(watch-mounts send-moved))
+        (when (memq 'change flags)
+          (setq
+           l-flags
+           (cond
+            ((eq file-notify--library 'inotify) '(create modify move delete))
+            ((eq file-notify--library 'w32notify)
+             '(file-name directory-name size last-write-time)))))
+        (when (memq 'attribute-change flags)
+          (add-to-list
+           'l-flags
+           (cond
+            ((eq file-notify--library 'inotify) 'attrib)
+            ((eq file-notify--library 'w32notify) 'attributes)))))
+
+      ;; Call low-level function.
+      (setq desc (funcall func dir l-flags 'file-notify-callback)))
+
+    ;; Modify `file-notify-descriptors'.
+    (setq registered (gethash desc file-notify-descriptors))
+    (puthash
+     desc
+     `(,dir
+       (,(unless (file-directory-p file) (file-name-nondirectory file))
+        . ,callback)
+       . ,(cdr registered))
+     file-notify-descriptors)
 
     ;; Return descriptor.
-    (puthash desc
-             (list (directory-file-name
-                    (if (file-directory-p dir) dir (file-name-directory dir)))
-                   (unless (file-directory-p file)
-                     (file-name-nondirectory file))
-                   callback)
-             file-notify-descriptors)
-    desc))
+    (file-notify--descriptor
+     desc (unless (file-directory-p file) (file-name-nondirectory file)))))
 
 (defun file-notify-rm-watch (descriptor)
   "Remove an existing watch specified by its DESCRIPTOR.
 DESCRIPTOR should be an object returned by `file-notify-add-watch'."
-  (let ((file (car (gethash descriptor file-notify-descriptors)))
-        handler)
-
-    (when (stringp file)
-      (setq handler (find-file-name-handler file 'file-notify-rm-watch))
-      (if handler
-          (funcall handler 'file-notify-rm-watch descriptor)
-        (funcall
-         (cond
-          ((eq file-notify--library 'gfilenotify) 'gfile-rm-watch)
-          ((eq file-notify--library 'inotify) 'inotify-rm-watch)
-          ((eq file-notify--library 'w32notify) 'w32notify-rm-watch))
-         descriptor)))
-
-    (remhash descriptor file-notify-descriptors)))
+  (let* ((desc (if (consp descriptor) (car descriptor) descriptor))
+         (file (if (consp descriptor) (cdr descriptor)))
+         (dir (car (gethash desc file-notify-descriptors)))
+         handler registered)
+
+    (when (stringp dir)
+      (setq handler (find-file-name-handler dir 'file-notify-rm-watch))
+
+      ;; Modify `file-notify-descriptors'.
+      (if (not file)
+          (remhash desc file-notify-descriptors)
+
+        (setq registered (gethash desc file-notify-descriptors))
+        (setcdr registered
+                (delete (assoc file (cdr registered)) (cdr registered)))
+        (if (null (cdr registered))
+            (remhash desc file-notify-descriptors)
+          (puthash desc registered file-notify-descriptors)))
+
+      ;; Call low-level function.
+      (when (null (cdr registered))
+        (if handler
+            ;; A file name handler could exist even if there is no local
+            ;; file notification support.
+            (funcall handler 'file-notify-rm-watch desc)
+
+          (funcall
+           (cond
+            ((eq file-notify--library 'gfilenotify) 'gfile-rm-watch)
+            ((eq file-notify--library 'inotify) 'inotify-rm-watch)
+            ((eq file-notify--library 'w32notify) 'w32notify-rm-watch))
+           desc))))))
 
 ;; The end:
 (provide 'filenotify)
diff --git a/lisp/files.el b/lisp/files.el
index ed1943dfc28..5e80cb76599 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -6094,7 +6094,7 @@ and `list-directory-verbose-switches'."
 
 PATTERN is assumed to represent a file-name wildcard suitable for the
 underlying filesystem.  For Unix and GNU/Linux, each character from the
-set [ \\t\\n;<>&|()'\"#$] is quoted with a backslash; for DOS/Windows, all
+set [ \\t\\n;<>&|()`'\"#$] is quoted with a backslash; for DOS/Windows, all
 the parts of the pattern which don't include wildcard characters are
 quoted with double quotes.
 
@@ -6108,12 +6108,12 @@ need to be passed verbatim to shell commands."
       ;; argument has quotes, we can safely assume it is already
       ;; quoted by the caller.
       (if (or (string-match "[\"]" pattern)
-              ;; We quote [&()#$'] in case their shell is a port of a
+              ;; We quote [&()#$`'] in case their shell is a port of a
               ;; Unixy shell.  We quote [,=+] because stock DOS and
               ;; Windows shells require that in some cases, such as
               ;; passing arguments to batch files that use positional
               ;; arguments like %1.
-              (not (string-match "[ \t;&()#$',=+]" pattern)))
+              (not (string-match "[ \t;&()#$`',=+]" pattern)))
           pattern
         (let ((result "\"")
               (beg 0)
@@ -6128,7 +6128,7 @@ need to be passed verbatim to shell commands."
           (concat result (substring pattern beg) "\""))))
      (t
       (let ((beg 0))
-        (while (string-match "[ \t\n;<>&|()'\"#$]" pattern beg)
+        (while (string-match "[ \t\n;<>&|()`'\"#$]" pattern beg)
           (setq pattern
                 (concat (substring pattern 0 (match-beginning 0))
                         "\\"
@@ -6590,35 +6590,40 @@ Runs the members of `kill-emacs-query-functions' in turn and stops
 if any returns nil.  If `confirm-kill-emacs' is non-nil, calls it."
   (interactive "P")
   (save-some-buffers arg t)
-  (and (or (not (memq t (mapcar (function
-                                  (lambda (buf) (and (buffer-file-name buf)
-                                                     (buffer-modified-p buf))))
-                                (buffer-list))))
-           (yes-or-no-p "Modified buffers exist; exit anyway? "))
-       (or (not (fboundp 'process-list))
-           ;; process-list is not defined on MSDOS.
-           (let ((processes (process-list))
-                 active)
-             (while processes
-               (and (memq (process-status (car processes)) '(run stop open listen))
-                    (process-query-on-exit-flag (car processes))
-                    (setq active t))
-               (setq processes (cdr processes)))
-             (or (not active)
-                 (with-current-buffer-window
-                  (get-buffer-create "*Process List*") nil
-                  #'(lambda (window _value)
-                      (with-selected-window window
-                        (unwind-protect
-                            (yes-or-no-p "Active processes exist; kill them and exit anyway? ")
-                          (when (window-live-p window)
-                            (quit-restore-window window 'kill)))))
-                  (list-processes t)))))
-       ;; Query the user for other things, perhaps.
-       (run-hook-with-args-until-failure 'kill-emacs-query-functions)
-       (or (null confirm-kill-emacs)
-           (funcall confirm-kill-emacs "Really exit Emacs? "))
-       (kill-emacs)))
+  (let ((confirm confirm-kill-emacs))
+    (and
+     (or (not (memq t (mapcar (function
+                               (lambda (buf) (and (buffer-file-name buf)
+                                                  (buffer-modified-p buf))))
+                              (buffer-list))))
+         (progn (setq confirm nil)
+                (yes-or-no-p "Modified buffers exist; exit anyway? ")))
+     (or (not (fboundp 'process-list))
+         ;; process-list is not defined on MSDOS.
+         (let ((processes (process-list))
+               active)
+           (while processes
+             (and (memq (process-status (car processes)) '(run stop open listen))
+                  (process-query-on-exit-flag (car processes))
+                  (setq active t))
+             (setq processes (cdr processes)))
+           (or (not active)
+               (with-current-buffer-window
+                (get-buffer-create "*Process List*") nil
+                #'(lambda (window _value)
+                    (with-selected-window window
+                      (unwind-protect
+                          (progn
+                            (setq confirm nil)
+                            (yes-or-no-p "Active processes exist; kill them and exit anyway? "))
+                        (when (window-live-p window)
+                          (quit-restore-window window 'kill)))))
+                (list-processes t)))))
+     ;; Query the user for other things, perhaps.
+     (run-hook-with-args-until-failure 'kill-emacs-query-functions)
+     (or (null confirm)
+         (funcall confirm "Really exit Emacs? "))
+     (kill-emacs))))
 
 (defun save-buffers-kill-terminal (&optional arg)
   "Offer to save each buffer, then kill the current connection.
diff --git a/lisp/gnus/ChangeLog b/lisp/gnus/ChangeLog
index 7bf4a6e01d6..76683310b3e 100644
--- a/lisp/gnus/ChangeLog
+++ b/lisp/gnus/ChangeLog
@@ -1,3 +1,30 @@
+2015-01-30  Glenn Morris  <rgm@gnu.org>
+
+        * gnus-registry.el (gnus-registry-max-pruned-entries)
+        (gnus-registry-prune-factor, gnus-registry-default-sort-function):
+        Fix :version.
+        (gnus-registry-default-sort-function): Improve :type.
+
+2015-01-29  Lars Ingebrigtsen  <larsi@gnus.org>
+
+        * nnimap.el (nnimap-request-group): Allow running this function on
+        groups that don't exist in Gnus yet.
+        (nnimap-request-group): Revert previous patch since that made it
+        impossible to enter nnimap groups.
+
+        * message.el (message-smtpmail-send-it): Remove the mail header
+        separator before sending.
+
+2015-01-28  Elias Oltmanns  <eo@nebensachen.de>
+
+        * nnimap.el (nnimap-find-expired-articles): Fix handling of
+        (expiry-wait . never).
+
+2015-01-28  Lars Ingebrigtsen  <larsi@gnus.org>
+
+        * nnimap.el (nnimap-request-group): Clear the buffer before returning
+        the data.
+
 2015-01-27  Lars Ingebrigtsen  <larsi@gnus.org>
 
         * nnir.el (nnir-imap-expr-to-imap): Check for literal+ capability in
diff --git a/lisp/gnus/gnus-registry.el b/lisp/gnus/gnus-registry.el
index 9cfca1290c5..2017ea2f826 100644
--- a/lisp/gnus/gnus-registry.el
+++ b/lisp/gnus/gnus-registry.el
@@ -176,7 +176,8 @@ nnmairix groups are specifically excluded because they are ephemeral."
 (make-obsolete-variable 'gnus-registry-max-track-groups nil "23.4")
 (make-obsolete-variable 'gnus-registry-entry-caching nil "23.4")
 (make-obsolete-variable 'gnus-registry-trim-articles-without-groups nil "23.4")
-(make-obsolete-variable 'gnus-registry-max-pruned-entries nil "24.4")
+;; FIXME it was simply deleted.
+(make-obsolete-variable 'gnus-registry-max-pruned-entries nil "25.1")
 
 (defcustom gnus-registry-track-extra '(subject sender recipient)
   "Whether the registry should track extra data about a message.
@@ -253,21 +254,18 @@ exactly how much less.  For example, given a maximum size of
 cut the registry back to \(- 50000 \(* 50000 0.1\)\) -> 45000
 entries.  The pruning process is constrained by the presence of
 \"precious\" entries."
-  :version "24.4"
+  :version "25.1"
   :group 'gnus-registry
   :type 'float)
 
 (defcustom gnus-registry-default-sort-function
   #'gnus-registry-sort-by-creation-time
   "Sort function to use when pruning the registry.
-
-Entries which sort to the front of the list will be pruned
-first.
-
+Entries that sort to the front of the list are pruned first.
 This can slow pruning down.  Set to nil to perform no sorting."
-  :version "24.4"
+  :version "25.1"
   :group 'gnus-registry
-  :type 'symbol)
+  :type '(choice (const :tag "No sorting" nil) function))
 
 (defun gnus-registry-sort-by-creation-time (l r)
   "Sort older entries to front of list."
diff --git a/lisp/gnus/message.el b/lisp/gnus/message.el
index de7e9bab8ec..a06de2a6414 100644
--- a/lisp/gnus/message.el
+++ b/lisp/gnus/message.el
@@ -4906,6 +4906,11 @@ evaluates `message-send-mail-hook' just before sending a message.
 It is useful if your ISP requires the POP-before-SMTP
 authentication.  See the Gnus manual for details."
   (run-hooks 'message-send-mail-hook)
+  ;; Change header-delimiter to be what smtpmail expects.
+  (goto-char (point-min))
+  (when (re-search-forward
+         (concat "^" (regexp-quote mail-header-separator) "\n"))
+    (replace-match "\n"))
   (smtpmail-send-it))
 
 (defun message-send-mail-with-mailclient ()
diff --git a/lisp/gnus/mm-decode.el b/lisp/gnus/mm-decode.el
index f03b9c9b484..311ea7cffff 100644
--- a/lisp/gnus/mm-decode.el
+++ b/lisp/gnus/mm-decode.el
@@ -889,7 +889,7 @@ external if displayed external."
                         (when (and (boundp 'gnus-summary-buffer)
                                    (bufferp gnus-summary-buffer)
                                    (buffer-name gnus-summary-buffer))
-                          ;; So that we pop back to the right place, sortof.
+                          ;; So that we pop back to the right place, sort of.
                           (switch-to-buffer gnus-summary-buffer)
                           (switch-to-buffer mm))
                         (delete-other-windows)
diff --git a/lisp/gnus/nnimap.el b/lisp/gnus/nnimap.el
index 8e81abcf9c0..e619c0f13c2 100644
--- a/lisp/gnus/nnimap.el
+++ b/lisp/gnus/nnimap.el
@@ -812,6 +812,7 @@ textual parts.")
             (nnimap-finish-retrieve-group-infos server (list info) sequences
                                                 t)
             (setq active (nth 2 (assoc group nnimap-current-infos)))))
+        (erase-buffer)
         (insert (format "211 %d %d %d %S\n"
                         (- (cdr active) (car active))
                         (car active)
@@ -1020,20 +1021,20 @@ textual parts.")
 
 (defun nnimap-find-expired-articles (group)
   (let ((cutoff (nnmail-expired-article-p group nil nil)))
-    (with-current-buffer (nnimap-buffer)
-      (let ((result
-             (nnimap-command
-              "UID SEARCH SENTBEFORE %s"
-              (format-time-string
-               (format "%%d-%s-%%Y"
-                       (upcase
-                        (car (rassoc (nth 4 (decode-time cutoff))
-                                     parse-time-months))))
-               cutoff))))
-        (and (car result)
-             (delete 0 (mapcar #'string-to-number
-                               (cdr (assoc "SEARCH" (cdr result))))))))))
-
+    (when cutoff
+      (with-current-buffer (nnimap-buffer)
+        (let ((result
+               (nnimap-command
+                "UID SEARCH SENTBEFORE %s"
+                (format-time-string
+                 (format "%%d-%s-%%Y"
+                         (upcase
+                          (car (rassoc (nth 4 (decode-time cutoff))
+                                       parse-time-months))))
+                 cutoff))))
+          (and (car result)
+               (delete 0 (mapcar #'string-to-number
+                                 (cdr (assoc "SEARCH" (cdr result)))))))))))
 
 (defun nnimap-find-article-by-message-id (group server message-id
                                                 &optional limit)
diff --git a/lisp/loadup.el b/lisp/loadup.el
index 96641c8a268..003b0db4abd 100644
--- a/lisp/loadup.el
+++ b/lisp/loadup.el
@@ -145,7 +145,8 @@
   (file-error (load "ldefs-boot.el")))
 
 (load "emacs-lisp/nadvice")
-(load "minibuffer")
+(load "emacs-lisp/cl-preloaded")
+(load "minibuffer")            ;After loaddefs, for define-minor-mode.
 (load "abbrev")         ;lisp-mode.el and simple.el use define-abbrev-table.
 (load "simple")
 
diff --git a/lisp/net/net-utils.el b/lisp/net/net-utils.el
index 28aa43117da..ebcbc714ffb 100644
--- a/lisp/net/net-utils.el
+++ b/lisp/net/net-utils.el
@@ -328,7 +328,15 @@ This variable is only used if the variable
 
 (defun net-utils-run-program (name header program args)
   "Run a network information program."
-  (let ((buf (get-buffer-create (concat "*" name "*"))))
+  (let ((buf (get-buffer-create (concat "*" name "*")))
+        (coding-system-for-read
+         ;; MS-Windows versions of network utilities output text
+         ;; encoded in the console (a.k.a. "OEM") codepage, which is
+         ;; different from the default system (a.k.a. "ANSI")
+         ;; codepage.
+         (if (eq system-type 'windows-nt)
+             (intern (format "cp%d" (w32-get-console-output-codepage)))
+           coding-system-for-read)))
     (set-buffer buf)
     (erase-buffer)
     (insert header "\n")
@@ -352,7 +360,15 @@ This variable is only used if the variable
       (when proc
         (set-process-filter proc nil)
         (delete-process proc)))
-    (let ((inhibit-read-only t))
+    (let ((inhibit-read-only t)
+        (coding-system-for-read
+         ;; MS-Windows versions of network utilities output text
+         ;; encoded in the console (a.k.a. "OEM") codepage, which is
+         ;; different from the default system (a.k.a. "ANSI")
+         ;; codepage.
+         (if (eq system-type 'windows-nt)
+             (intern (format "cp%d" (w32-get-console-output-codepage)))
+           coding-system-for-read)))
       (erase-buffer))
     (net-utils-mode)
     (setq-local net-utils--revert-cmd
diff --git a/lisp/net/shr.el b/lisp/net/shr.el
index a0c9eba4144..59c277b01c2 100644
--- a/lisp/net/shr.el
+++ b/lisp/net/shr.el
@@ -1628,6 +1628,8 @@ The preference is a float determined from `shr-prefer-media-type'."
   (let ((trs nil)
         (shr-inhibit-decoration (not fill))
         (rowspans (make-vector (length widths) 0))
+        (colspan-remaining 0)
+        colspan-width colspan-count
         width colspan)
     (dolist (row (dom-non-text-children dom))
       (when (eq (dom-tag row) 'tr)
@@ -1659,24 +1661,39 @@ The preference is a float determined from `shr-prefer-media-type'."
                     (if column
                         (aref widths width-column)
                       10))
-              (when (and fill
-                         (setq colspan (dom-attr column 'colspan)))
+              (when (setq colspan (dom-attr column 'colspan))
                 (setq colspan (min (string-to-number colspan)
                                    ;; The colspan may be wrong, so
                                    ;; truncate it to the length of the
                                    ;; remaining columns.
                                    (- (length widths) i)))
                 (dotimes (j (1- colspan))
-                  (if (> (+ i 1 j) (1- (length widths)))
-                      (setq width (aref widths (1- (length widths))))
-                    (setq width (+ width
-                                   shr-table-separator-length
-                                   (aref widths (+ i 1 j))))))
-                (setq width-column (+ width-column (1- colspan))))
+                  (setq width
+                        (if (> (+ i 1 j) (1- (length widths)))
+                            ;; If we have a colspan spec that's longer
+                            ;; than the table is wide, just use the last
+                            ;; width as the width.
+                            (aref widths (1- (length widths)))
+                          ;; Sum up the widths of the columns we're
+                          ;; spanning.
+                          (+ width
+                             shr-table-separator-length
+                             (aref widths (+ i 1 j))))))
+                (setq width-column (+ width-column (1- colspan))
+                      colspan-count colspan
+                      colspan-remaining colspan))
               (when (or column
                         (not fill))
-                (push (shr-render-td column width fill)
-                      tds))
+                (let ((data (shr-render-td column width fill)))
+                  (if (and (not fill)
+                           (> colspan-remaining 0))
+                      (progn
+                        (when (= colspan-count colspan-remaining)
+                          (setq colspan-width data))
+                        (let ((this-width (/ colspan-width colspan-count)))
+                          (push this-width tds)
+                          (setq colspan-remaining (1- colspan-remaining))))
+                    (push data tds))))
               (setq i (1+ i)
                     width-column (1+ width-column))))
           (push (nreverse tds) trs))))
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index d44c8ea2f6d..ba0d13eab8b 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -64,7 +64,6 @@
 (defvar bkup-backup-directory-info)
 (defvar directory-sep-char)
 (defvar eshell-path-env)
-(defvar file-notify-descriptors)
 (defvar ls-lisp-use-insert-directory-program)
 (defvar outline-regexp)
 
@@ -3415,7 +3414,7 @@ of."
 (defun tramp-handle-file-notify-rm-watch (proc)
   "Like `file-notify-rm-watch' for Tramp files."
   ;; The descriptor must be a process object.
-  (unless (and (processp proc) (gethash proc file-notify-descriptors))
+  (unless (processp proc)
     (tramp-error proc 'file-notify-error "Not a valid descriptor %S" proc))
   (tramp-message proc 6 "Kill %S" proc)
   (kill-process proc))
diff --git a/lisp/outline.el b/lisp/outline.el
index 11d71fb1226..ae31b8088f0 100644
--- a/lisp/outline.el
+++ b/lisp/outline.el
@@ -35,9 +35,6 @@
 
 ;;; Code:
 
-(defvar font-lock-warning-face)
-
-
 (defgroup outlines nil
   "Support for hierarchical outlining."
   :prefix "outline-"
@@ -65,73 +62,66 @@ in the file it applies to.")
     (define-key map "@" 'outline-mark-subtree)
     (define-key map "\C-n" 'outline-next-visible-heading)
     (define-key map "\C-p" 'outline-previous-visible-heading)
-    (define-key map "\C-i" 'show-children)
-    (define-key map "\C-s" 'show-subtree)
-    (define-key map "\C-d" 'hide-subtree)
+    (define-key map "\C-i" 'outline-show-children)
+    (define-key map "\C-s" 'outline-show-subtree)
+    (define-key map "\C-d" 'outline-hide-subtree)
     (define-key map "\C-u" 'outline-up-heading)
     (define-key map "\C-f" 'outline-forward-same-level)
     (define-key map "\C-b" 'outline-backward-same-level)
-    (define-key map "\C-t" 'hide-body)
-    (define-key map "\C-a" 'show-all)
-    (define-key map "\C-c" 'hide-entry)
-    (define-key map "\C-e" 'show-entry)
-    (define-key map "\C-l" 'hide-leaves)
-    (define-key map "\C-k" 'show-branches)
-    (define-key map "\C-q" 'hide-sublevels)
-    (define-key map "\C-o" 'hide-other)
+    (define-key map "\C-t" 'outline-hide-body)
+    (define-key map "\C-a" 'outline-show-all)
+    (define-key map "\C-c" 'outline-hide-entry)
+    (define-key map "\C-e" 'outline-show-entry)
+    (define-key map "\C-l" 'outline-hide-leaves)
+    (define-key map "\C-k" 'outline-show-branches)
+    (define-key map "\C-q" 'outline-hide-sublevels)
+    (define-key map "\C-o" 'outline-hide-other)
     (define-key map "\C-^" 'outline-move-subtree-up)
     (define-key map "\C-v" 'outline-move-subtree-down)
     (define-key map [(control ?<)] 'outline-promote)
     (define-key map [(control ?>)] 'outline-demote)
     (define-key map "\C-m" 'outline-insert-heading)
-    ;; Where to bind outline-cycle ?
     map))
 
 (defvar outline-mode-menu-bar-map
   (let ((map (make-sparse-keymap)))
-
     (define-key map [hide] (cons "Hide" (make-sparse-keymap "Hide")))
-
-    (define-key map [hide hide-other]
-      '(menu-item "Hide Other" hide-other
+    (define-key map [hide outline-hide-other]
+      '(menu-item "Hide Other" outline-hide-other
                   :help "Hide everything except current body and parent and top-level headings"))
-    (define-key map [hide hide-sublevels]
-      '(menu-item "Hide Sublevels" hide-sublevels
+    (define-key map [hide outline-hide-sublevels]
+      '(menu-item "Hide Sublevels" outline-hide-sublevels
                   :help "Hide everything but the top LEVELS levels of headers, in whole buffer"))
-    (define-key map [hide hide-subtree]
-      '(menu-item "Hide Subtree" hide-subtree
+    (define-key map [hide outline-hide-subtree]
+      '(menu-item "Hide Subtree" outline-hide-subtree
                   :help "Hide everything after this heading at deeper levels"))
-    (define-key map [hide hide-entry]
-      '(menu-item "Hide Entry" hide-entry
+    (define-key map [hide outline-hide-entry]
+      '(menu-item "Hide Entry" outline-hide-entry
                   :help "Hide the body directly following this heading"))
-    (define-key map [hide hide-body]
-      '(menu-item "Hide Body" hide-body
+    (define-key map [hide outline-hide-body]
+      '(menu-item "Hide Body" outline-hide-body
                   :help "Hide all body lines in buffer, leaving all headings visible"))
-    (define-key map [hide hide-leaves]
-      '(menu-item "Hide Leaves" hide-leaves
+    (define-key map [hide outline-hide-leaves]
+      '(menu-item "Hide Leaves" outline-hide-leaves
                   :help "Hide the body after this heading and at deeper levels"))
-
     (define-key map [show] (cons "Show" (make-sparse-keymap "Show")))
-
-    (define-key map [show show-subtree]
-      '(menu-item "Show Subtree" show-subtree
+    (define-key map [show outline-show-subtree]
+      '(menu-item "Show Subtree" outline-show-subtree
                   :help "Show everything after this heading at deeper levels"))
-    (define-key map [show show-children]
-      '(menu-item "Show Children" show-children
+    (define-key map [show outline-show-children]
+      '(menu-item "Show Children" outline-show-children
                   :help "Show all direct subheadings of this heading"))
-    (define-key map [show show-branches]
-      '(menu-item "Show Branches" show-branches
+    (define-key map [show outline-show-branches]
+      '(menu-item "Show Branches" outline-show-branches
                   :help "Show all subheadings of this heading, but not their bodies"))
-    (define-key map [show show-entry]
-      '(menu-item "Show Entry" show-entry
+    (define-key map [show outline-show-entry]
+      '(menu-item "Show Entry" outline-show-entry
                   :help "Show the body directly following this heading"))
-    (define-key map [show show-all]
-      '(menu-item "Show All" show-all
+    (define-key map [show outline-show-all]
+      '(menu-item "Show All" outline-show-all
                   :help "Show all of the text in the buffer"))
-
     (define-key map [headings]
       (cons "Headings" (make-sparse-keymap "Headings")))
-
     (define-key map [headings demote-subtree]
       '(menu-item "Demote Subtree" outline-demote
                   :help "Demote headings lower down the tree"))
@@ -152,23 +142,18 @@ in the file it applies to.")
       '(menu-item "New Heading" outline-insert-heading
                   :help "Insert a new heading at same depth at point"))
     (define-key map [headings outline-backward-same-level]
-
       '(menu-item "Previous Same Level" outline-backward-same-level
                   :help "Move backward to the arg'th subheading at same level as this one."))
     (define-key map [headings outline-forward-same-level]
-
       '(menu-item "Next Same Level" outline-forward-same-level
                   :help "Move forward to the arg'th subheading at same level as this one"))
     (define-key map [headings outline-previous-visible-heading]
-
       '(menu-item "Previous" outline-previous-visible-heading
                   :help "Move to the previous heading line"))
     (define-key map [headings outline-next-visible-heading]
-
       '(menu-item "Next" outline-next-visible-heading
                   :help "Move to the next visible heading line"))
     (define-key map [headings outline-up-heading]
-
       '(menu-item "Up" outline-up-heading
                   :help "Move to the visible heading line of which the present line is a subheading"))
     map))
@@ -190,7 +175,6 @@ in the file it applies to.")
                                    outline-mode-menu-bar-map))))))
     map))
 
-
 (defvar outline-mode-map
   (let ((map (make-sparse-keymap)))
     (define-key map "\C-c" outline-mode-prefix-map)
@@ -198,7 +182,7 @@ in the file it applies to.")
     map))
 
 (defvar outline-font-lock-keywords
-  '(;;
+  '(
     ;; Highlight headings according to the level.
     (eval . (list (concat "^\\(?:" outline-regexp "\\).+")
                   0 '(outline-font-lock-face) nil t)))
@@ -248,33 +232,14 @@ in the file it applies to.")
   [outline-1 outline-2 outline-3 outline-4
    outline-5 outline-6 outline-7 outline-8])
 
-;; (defvar outline-font-lock-levels nil)
-;; (make-variable-buffer-local 'outline-font-lock-levels)
-
 (defun outline-font-lock-face ()
-  ;; (save-excursion
-  ;;   (outline-back-to-heading t)
-  ;;   (let* ((count 0)
-  ;;       (start-level (funcall outline-level))
-  ;;       (level start-level)
-  ;;       face-level)
-  ;;     (while (not (setq face-level
-  ;;                    (if (or (bobp) (eq level 1)) 0
-  ;;                      (cdr (assq level outline-font-lock-levels)))))
-  ;;    (outline-up-heading 1 t)
-  ;;    (setq count (1+ count))
-  ;;    (setq level (funcall outline-level)))
-  ;;     ;; Remember for later.
-  ;;     (unless (zerop count)
-  ;;    (setq face-level (+ face-level count))
-  ;;    (push (cons start-level face-level) outline-font-lock-levels))
-  ;;     (condition-case nil
-  ;;      (aref outline-font-lock-faces face-level)
-  ;;    (error font-lock-warning-face))))
+  "Return one of `outline-font-lock-faces' for current level."
   (save-excursion
     (goto-char (match-beginning 0))
     (looking-at outline-regexp)
-    (aref outline-font-lock-faces (% (1- (funcall outline-level)) (length outline-font-lock-faces)))))
+    (aref outline-font-lock-faces
+          (% (1- (funcall outline-level))
+             (length outline-font-lock-faces)))))
 
 (defvar outline-view-change-hook nil
   "Normal hook to be run after outline visibility changes.")
@@ -296,29 +261,11 @@ invisible, or visible again.  Invisible lines are attached to the end
 of the heading, so they move with it, if the line is killed and yanked
 back.  A heading with text hidden under it is marked with an ellipsis (...).
 
-Commands:\\<outline-mode-map>
-\\[outline-next-visible-heading]   outline-next-visible-heading      move by visible headings
-\\[outline-previous-visible-heading]   outline-previous-visible-heading
-\\[outline-forward-same-level]   outline-forward-same-level        similar but skip subheadings
-\\[outline-backward-same-level]   outline-backward-same-level
-\\[outline-up-heading]   outline-up-heading                 move from subheading to heading
-
-\\[hide-body]   make all text invisible (not headings).
-\\[show-all]    make everything in buffer visible.
-\\[hide-sublevels]  make only the first N levels of headers visible.
-
-The remaining commands are used when point is on a heading line.
-They apply to some of the body or subheadings of that heading.
-\\[hide-subtree]   hide-subtree make body and subheadings invisible.
-\\[show-subtree]   show-subtree make body and subheadings visible.
-\\[show-children]   show-children       make direct subheadings visible.
-                 No effect on body, or subheadings 2 or more levels down.
-                 With arg N, affects subheadings N levels down.
-\\[hide-entry]     make immediately following body invisible.
-\\[show-entry]     make it visible.
-\\[hide-leaves]    make body under heading and under its subheadings invisible.
-                     The subheadings remain visible.
-\\[show-branches]  make all subheadings at all levels visible.
+\\{outline-mode-map}
+The commands `outline-hide-subtree', `outline-show-subtree',
+`outline-show-children', `outline-hide-entry',
+`outline-show-entry', `outline-hide-leaves', and `outline-show-branches'
+are used when point is on a heading line.
 
 The variable `outline-regexp' can be changed to control what is a heading.
 A line is a heading if `outline-regexp' matches something at the
@@ -340,7 +287,7 @@ Turning on outline mode calls the value of `text-mode-hook' and then of
        '(outline-font-lock-keywords t nil nil backward-paragraph))
   (setq imenu-generic-expression
         (list (list nil (concat "^\\(?:" outline-regexp "\\).*$") 0)))
-  (add-hook 'change-major-mode-hook 'show-all nil t))
+  (add-hook 'change-major-mode-hook 'outline-show-all nil t))
 
 (defcustom outline-minor-mode-prefix "\C-c@"
   "Prefix key to use for Outline commands in Outline minor mode.
@@ -373,7 +320,7 @@ See the command `outline-mode' for more information on this mode."
     ;; Cause use of ellipses for invisible text.
     (remove-from-invisibility-spec '(outline . t))
     ;; When turning off outline mode, get rid of any outline hiding.
-    (show-all)))
+    (outline-show-all)))
 
 (defvar outline-level 'outline-level
   "Function of no args to compute a header's nesting level in an outline.
@@ -441,7 +388,8 @@ at the end of the buffer."
                       nil 'move))
 
 (defsubst outline-invisible-p (&optional pos)
-  "Non-nil if the character after point is invisible."
+  "Non-nil if the character after POS is invisible.
+If POS is nil, use `point' instead."
   (get-char-property (or pos (point)) 'invisible))
 
 (defun outline-back-to-heading (&optional invisible-ok)
@@ -454,7 +402,7 @@ Only visible heading lines are considered, unless INVISIBLE-OK is non-nil."
           (while (not found)
             (or (re-search-backward (concat "^\\(?:" outline-regexp "\\)")
                                     nil t)
-                (error "before first heading"))
+                (error "Before first heading"))
             (setq found (and (or invisible-ok (not (outline-invisible-p)))
                              (point)))))
         (goto-char found)
@@ -489,6 +437,9 @@ If INVISIBLE-OK is non-nil, an invisible heading line is ok too."
     (run-hooks 'outline-insert-heading-hook)))
 
 (defun outline-invent-heading (head up)
+  "Create a heading by using heading HEAD as a template.
+When UP is non-nil, the created heading will be one level above.
+Otherwise, it will be one level below."
   (save-match-data
     ;; Let's try to invent one by repeating or deleting the last char.
     (let ((new-head (if up (substring head 0 -1)
@@ -504,7 +455,7 @@ If INVISIBLE-OK is non-nil, an invisible heading line is ok too."
 
 (defun outline-promote (&optional which)
   "Promote headings higher up the tree.
-If transient-mark-mode is on, and mark is active, promote headings in
+If `transient-mark-mode' is on, and mark is active, promote headings in
 the region (from a Lisp program, pass `region' for WHICH).  Otherwise:
 without prefix argument, promote current heading and all headings in the
 subtree (from a Lisp program, pass `subtree' for WHICH); with prefix
@@ -543,7 +494,7 @@ nil for WHICH, or do not pass any argument)."
 
 (defun outline-demote (&optional which)
   "Demote headings lower down the tree.
-If transient-mark-mode is on, and mark is active, demote headings in
+If `transient-mark-mode' is on, and mark is active, demote headings in
 the region (from a Lisp program, pass `region' for WHICH).  Otherwise:
 without prefix argument, demote current heading and all headings in the
 subtree (from a Lisp program, pass `subtree' for WHICH); with prefix
@@ -585,7 +536,7 @@ nil for WHICH, or do not pass any argument)."
       (replace-match down-head nil t)))))
 
 (defun outline-head-from-level (level head &optional alist)
-  "Get new heading with level LEVEL from ALIST.
+  "Get new heading with level LEVEL, closest to HEAD, from ALIST.
 If there are no such entries, return nil.
 ALIST defaults to `outline-heading-alist'.
 Similar to (car (rassoc LEVEL ALIST)).
@@ -677,16 +628,17 @@ the match data is set appropriately."
     (move-marker ins-point (point))
     (insert (delete-and-extract-region beg end))
     (goto-char ins-point)
-    (if folded (hide-subtree))
+    (if folded (outline-hide-subtree))
     (move-marker ins-point nil)))
 
 (defun outline-end-of-heading ()
+  "Move to one char before the next `outline-heading-end-regexp'."
   (if (re-search-forward outline-heading-end-regexp nil 'move)
       (forward-char -1)))
 
 (defun outline-next-visible-heading (arg)
   "Move to the next visible heading line.
-With argument, repeats or can move backward if negative.
+With ARG, repeats or can move backward if negative.
 A heading line is one that starts with a `*' (or that
 `outline-regexp' matches)."
   (interactive "p")
@@ -714,7 +666,7 @@ A heading line is one that starts with a `*' (or that
 
 (defun outline-previous-visible-heading (arg)
   "Move to the previous heading line.
-With argument, repeats or can move forward if negative.
+With ARG, repeats or can move forward if negative.
 A heading line is one that starts with a `*' (or that
 `outline-regexp' matches)."
   (interactive "p")
@@ -739,7 +691,7 @@ This puts point at the start of the current subtree, and mark at the end."
 (defvar outline-isearch-open-invisible-function nil
   "Function called if `isearch' finishes in an invisible overlay.
 The function is called with the overlay as its only argument.
-If nil, `show-entry' is called to reveal the invisible text.")
+If nil, `outline-show-entry' is called to reveal the invisible text.")
 
 (put 'outline 'reveal-toggle-invisible 'outline-reveal-toggle-invisible)
 (defun outline-flag-region (from to flag)
@@ -763,51 +715,51 @@ If FLAG is nil then text is shown, while if FLAG is t the text is hidden."
   (save-excursion
     (goto-char (overlay-start o))
     (if hidep
-        ;; When hiding the area again, we could just clean it up and let
-        ;; reveal do the rest, by simply doing:
-        ;; (remove-overlays (overlay-start o) (overlay-end o)
-        ;;                  'invisible 'outline)
-        ;;
-        ;; That works fine as long as everything is in sync, but if the
-        ;; structure of the document is changed while revealing parts of it,
-        ;; the resulting behavior can be ugly.  I.e. we need to make
-        ;; sure that we hide exactly a subtree.
-        (progn
-          (let ((end (overlay-end o)))
-            (delete-overlay o)
-            (while (progn
-                     (hide-subtree)
-                     (outline-next-visible-heading 1)
-                     (and (not (eobp)) (< (point) end))))))
+        ;; When hiding the area again, we could just clean it up and let
+        ;; reveal do the rest, by simply doing:
+        ;; (remove-overlays (overlay-start o) (overlay-end o)
+        ;;                  'invisible 'outline)
+        ;;
+        ;; That works fine as long as everything is in sync, but if the
+        ;; structure of the document is changed while revealing parts of it,
+        ;; the resulting behavior can be ugly.  I.e. we need to make
+        ;; sure that we hide exactly a subtree.
+        (progn
+          (let ((end (overlay-end o)))
+            (delete-overlay o)
+            (while (progn
+                     (outline-hide-subtree)
+                     (outline-next-visible-heading 1)
+                     (and (not (eobp)) (< (point) end))))))
 
       ;; When revealing, we just need to reveal sublevels.  If point is
       ;; inside one of the sublevels, reveal will call us again.
       ;; But we need to preserve the original overlay.
       (let ((o1 (copy-overlay o)))
-        (overlay-put o 'invisible nil)  ;Show (most of) the text.
-        (while (progn
-                 (show-entry)
-                 (show-children)
-                 ;; Normally just the above is needed.
-                 ;; But in odd cases, the above might fail to show anything.
-                 ;; To avoid an infinite loop, we have to make sure that
-                 ;; *something* gets shown.
-                 (and (equal (overlay-start o) (overlay-start o1))
-                      (< (point) (overlay-end o))
-                      (= 0 (forward-line 1)))))
-        ;; If still nothing was shown, just kill the damn thing.
-        (when (equal (overlay-start o) (overlay-start o1))
-          ;; I've seen it happen at the end of buffer.
-          (delete-overlay o1))))))
+        (overlay-put o 'invisible nil)  ;Show (most of) the text.
+        (while (progn
+                 (outline-show-entry)
+                 (outline-show-children)
+                 ;; Normally just the above is needed.
+                 ;; But in odd cases, the above might fail to show anything.
+                 ;; To avoid an infinite loop, we have to make sure that
+                 ;; *something* gets shown.
+                 (and (equal (overlay-start o) (overlay-start o1))
+                      (< (point) (overlay-end o))
+                      (= 0 (forward-line 1)))))
+        ;; If still nothing was shown, just kill the damn thing.
+        (when (equal (overlay-start o) (overlay-start o1))
+          ;; I've seen it happen at the end of buffer.
+          (delete-overlay o1))))))
 
 ;; Function to be set as an outline-isearch-open-invisible' property
 ;; to the overlay that makes the outline invisible (see
 ;; `outline-flag-region').
 (defun outline-isearch-open-invisible (_overlay)
   ;; We rely on the fact that isearch places point on the matched text.
-  (show-entry))
+  (outline-show-entry))
 
-(defun hide-entry ()
+(defun outline-hide-entry ()
   "Hide the body directly following this heading."
   (interactive)
   (save-excursion
@@ -815,22 +767,31 @@ If FLAG is nil then text is shown, while if FLAG is t the text is hidden."
     (outline-end-of-heading)
     (outline-flag-region (point) (progn (outline-next-preface) (point)) t)))
 
-(defun show-entry ()
+(define-obsolete-function-alias
+    'hide-entry 'outline-hide-entry "25.1")
+
+(defun outline-show-entry ()
   "Show the body directly following this heading.
 Show the heading too, if it is currently invisible."
   (interactive)
   (save-excursion
     (outline-back-to-heading t)
     (outline-flag-region (1- (point))
-                         (progn (outline-next-preface) (point)) nil)))
+                         (progn (outline-next-preface) (point)) nil)))
+
+(define-obsolete-function-alias
+    'show-entry 'outline-show-entry "25.1")
 
-(defun hide-body ()
+(defun outline-hide-body ()
   "Hide all body lines in buffer, leaving all headings visible."
   (interactive)
-  (hide-region-body (point-min) (point-max)))
+  (outline-hide-region-body (point-min) (point-max)))
 
-(defun hide-region-body (start end)
-  "Hide all body lines in the region, but not headings."
+(define-obsolete-function-alias
+    'hide-body 'outline-hide-body "25.1")
+
+(defun outline-hide-region-body (start end)
+  "Hide all body lines between START and END, but not headings."
   ;; Nullify the hook to avoid repeated calls to `outline-flag-region'
   ;; wasting lots of time running `lazy-lock-fontify-after-outline'
   ;; and run the hook finally.
@@ -850,30 +811,47 @@ Show the heading too, if it is currently invisible."
             (outline-end-of-heading))))))
   (run-hooks 'outline-view-change-hook))
 
-(defun show-all ()
+(define-obsolete-function-alias
+    'hide-region-body 'outline-hide-region-body "25.1")
+
+(defun outline-show-all ()
   "Show all of the text in the buffer."
   (interactive)
   (outline-flag-region (point-min) (point-max) nil))
 
-(defun hide-subtree ()
+(define-obsolete-function-alias
+    'show-all 'outline-show-all "25.1")
+
+(defun outline-hide-subtree ()
   "Hide everything after this heading at deeper levels."
   (interactive)
   (outline-flag-subtree t))
 
-(defun hide-leaves ()
+(define-obsolete-function-alias
+    'hide-subtree 'outline-hide-subtree "25.1")
+
+(defun outline-hide-leaves ()
   "Hide the body after this heading and at deeper levels."
   (interactive)
   (save-excursion
     (outline-back-to-heading)
-;; Turned off to fix bug reported by Otto Maddox on 22 Nov 2005.
-;;    (outline-end-of-heading)
-    (hide-region-body (point) (progn (outline-end-of-subtree) (point)))))
+    ;; Turned off to fix bug reported by Otto Maddox on 22 Nov 2005.
+    ;;    (outline-end-of-heading)
+    (outline-hide-region-body
+     (point)
+     (progn (outline-end-of-subtree) (point)))))
+
+(define-obsolete-function-alias
+    'hide-leaves 'outline-hide-leaves "25.1")
 
-(defun show-subtree ()
+(defun outline-show-subtree ()
   "Show everything after this heading at deeper levels."
   (interactive)
   (outline-flag-subtree nil))
 
+(define-obsolete-function-alias
+    'show-subtree 'outline-show-subtree "25.1")
+
 (defun outline-show-heading ()
   "Show the current heading and move to its end."
   (outline-flag-region (- (point)
@@ -884,7 +862,7 @@ Show the heading too, if it is currently invisible."
                        (progn (outline-end-of-heading) (point))
                        nil))
 
-(defun hide-sublevels (levels)
+(defun outline-hide-sublevels (levels)
   "Hide everything but the top LEVELS levels of headers, in whole buffer."
   (interactive (list
                 (cond
@@ -922,14 +900,17 @@ Show the heading too, if it is currently invisible."
           (outline-flag-region (1- (point)) (point) nil))))
   (run-hooks 'outline-view-change-hook))
 
-(defun hide-other ()
+(define-obsolete-function-alias
+    'hide-sublevels 'outline-hide-sublevels "25.1")
+
+(defun outline-hide-other ()
   "Hide everything except current body and parent and top-level headings."
   (interactive)
-  (hide-sublevels 1)
+  (outline-hide-sublevels 1)
   (let (outline-view-change-hook)
     (save-excursion
       (outline-back-to-heading t)
-      (show-entry)
+      (outline-show-entry)
       (while (condition-case nil (progn (outline-up-heading 1 t) (not (bobp)))
                (error nil))
         (outline-flag-region (1- (point))
@@ -937,17 +918,21 @@ Show the heading too, if it is currently invisible."
                              nil))))
   (run-hooks 'outline-view-change-hook))
 
+(define-obsolete-function-alias
+    'hide-other 'outline-hide-other "25.1")
+
 (defun outline-toggle-children ()
   "Show or hide the current subtree depending on its current state."
   (interactive)
   (save-excursion
     (outline-back-to-heading)
     (if (not (outline-invisible-p (line-end-position)))
-        (hide-subtree)
-      (show-children)
-      (show-entry))))
+        (outline-hide-subtree)
+      (outline-show-children)
+      (outline-show-entry))))
 
 (defun outline-flag-subtree (flag)
+  "Assign FLAG to the current subtree."
   (save-excursion
     (outline-back-to-heading)
     (outline-end-of-heading)
@@ -956,6 +941,7 @@ Show the heading too, if it is currently invisible."
                           flag)))
 
 (defun outline-end-of-subtree ()
+  "Move to the end of the current subtree."
   (outline-back-to-heading)
   (let ((first t)
         (level (funcall outline-level)))
@@ -972,12 +958,15 @@ Show the heading too, if it is currently invisible."
               ;; leave blank line before heading
               (forward-char -1))))))
 
-(defun show-branches ()
+(defun outline-show-branches ()
   "Show all subheadings of this heading, but not their bodies."
   (interactive)
-  (show-children 1000))
+  (outline-show-children 1000))
+
+(define-obsolete-function-alias
+    'show-branches 'outline-show-branches "25.1")
 
-(defun show-children (&optional level)
+(defun outline-show-children (&optional level)
   "Show all direct subheadings of this heading.
 Prefix arg LEVEL is how many levels below the current level should be shown.
 Default is enough to cause the following heading to appear."
@@ -1004,6 +993,9 @@ Default is enough to cause the following heading to appear."
               (if (eobp) (point-max) (1+ (point)))))))
   (run-hooks 'outline-view-change-hook))
 
+(define-obsolete-function-alias
+    'show-children 'outline-show-children "25.1")
+
 
 
 (defun outline-up-heading (arg &optional invisible-ok)
@@ -1086,7 +1078,7 @@ If there is no such heading, return nil."
         (point)))))
 
 (defun outline-headers-as-kill (beg end)
-  "Save the visible outline headers in region at the start of the kill ring.
+  "Save the visible outline headers between BEG and END to the kill ring.
 
 Text shown between the headers isn't copied.  Two newlines are
 inserted between saved headers.  Yanking the result may be a
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 13ff439bef2..d340550a017 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -463,9 +463,14 @@ The type returned can be `comment', `string' or `paren'."
      ((nth 8 ppss) (if (nth 4 ppss) 'comment 'string))
      ((nth 1 ppss) 'paren))))
 
-(defsubst python-syntax-comment-or-string-p ()
-  "Return non-nil if point is inside 'comment or 'string."
-  (nth 8 (syntax-ppss)))
+(defsubst python-syntax-comment-or-string-p (&optional ppss)
+  "Return non-nil if PPSS is inside 'comment or 'string."
+  (nth 8 (or ppss (syntax-ppss))))
+
+(defsubst python-syntax-closing-paren-p ()
+  "Return non-nil if char after point is a closing paren."
+  (= (syntax-class (syntax-after (point)))
+     (syntax-class (string-to-syntax ")"))))
 
 (define-obsolete-function-alias
   'python-info-ppss-context #'python-syntax-context "24.3")
@@ -704,11 +709,28 @@ It makes underscores and dots word constituent chars.")
   'python-guess-indent 'python-indent-guess-indent-offset "24.3")
 
 (defvar python-indent-current-level 0
-  "Current indentation level `python-indent-line-function' is using.")
+  "Deprecated var available for compatibility.")
 
 (defvar python-indent-levels '(0)
-  "Levels of indentation available for `python-indent-line-function'.
-Can also be `noindent' if automatic indentation can't be used.")
+  "Deprecated var available for compatibility.")
+
+(make-obsolete-variable
+ 'python-indent-current-level
+ "The indentation API changed to avoid global state.
+The function `python-indent-calculate-levels' does not use it
+anymore.  If you were defadvising it and or depended on this
+variable for indentation customizations, refactor your code to
+work on `python-indent-calculate-indentation' instead."
+ "24.5")
+
+(make-obsolete-variable
+ 'python-indent-levels
+ "The indentation API changed to avoid global state.
+The function `python-indent-calculate-levels' does not use it
+anymore.  If you were defadvising it and or depended on this
+variable for indentation customizations, refactor your code to
+work on `python-indent-calculate-indentation' instead."
+ "24.5")
 
 (defun python-indent-guess-indent-offset ()
   "Guess and set `python-indent-offset' for the current buffer."
@@ -748,362 +770,358 @@ Can also be `noindent' if automatic indentation can't be used.")
                      python-indent-offset)))))))
 
 (defun python-indent-context ()
-  "Get information on indentation context.
-Context information is returned with a cons with the form:
-    (STATUS . START)
-
-Where status can be any of the following symbols:
-
- * after-comment: When current line might continue a comment block
- * inside-paren: If point in between (), {} or []
- * inside-string: If point is inside a string
- * after-backslash: Previous line ends in a backslash
- * after-beginning-of-block: Point is after beginning of block
- * after-line: Point is after normal line
- * dedenter-statement: Point is on a dedenter statement.
- * no-indent: Point is at beginning of buffer or other special case
-START is the buffer position where the sexp starts."
+  "Get information about the current indentation context.
+Context is returned in a cons with the form (STATUS . START).
+
+STATUS can be one of the following:
+
+keyword
+-------
+
+:after-comment
+ - Point is after a comment line.
+ - START is the position of the \"#\" character.
+:inside-string
+ - Point is inside string.
+ - START is the position of the first quote that starts it.
+:no-indent
+ - No possible indentation case matches.
+ - START is always zero.
+
+:inside-paren
+ - Fallback case when point is inside paren.
+ - START is the first non space char position *after* the open paren.
+:inside-paren-at-closing-nested-paren
+ - Point is on a line that contains a nested paren closer.
+ - START is the position of the open paren it closes.
+:inside-paren-at-closing-paren
+ - Point is on a line that contains a paren closer.
+ - START is the position of the open paren.
+:inside-paren-newline-start
+ - Point is inside a paren with items starting in their own line.
+ - START is the position of the open paren.
+:inside-paren-newline-start-from-block
+ - Point is inside a paren with items starting in their own line
+   from a block start.
+ - START is the position of the open paren.
+
+:after-backslash
+ - Fallback case when point is after backslash.
+ - START is the char after the position of the backslash.
+:after-backslash-assignment-continuation
+ - Point is after a backslashed assignment.
+ - START is the char after the position of the backslash.
+:after-backslash-block-continuation
+ - Point is after a backslashed block continuation.
+ - START is the char after the position of the backslash.
+:after-backslash-dotted-continuation
+ - Point is after a backslashed dotted continuation.  Previous
+   line must contain a dot to align with.
+ - START is the char after the position of the backslash.
+:after-backslash-first-line
+ - First line following a backslashed continuation.
+ - START is the char after the position of the backslash.
+
+:after-block-end
+ - Point is after a line containing a block ender.
+ - START is the position where the ender starts.
+:after-block-start
+ - Point is after a line starting a block.
+ - START is the position where the block starts.
+:after-line
+ - Point is after a simple line.
+ - START is the position where the previous line starts.
+:at-dedenter-block-start
+ - Point is on a line starting a dedenter block.
+ - START is the position where the dedenter block starts."
   (save-restriction
     (widen)
-    (let ((ppss (save-excursion (beginning-of-line) (syntax-ppss)))
-          (start))
-      (cons
-       (cond
-        ;; Beginning of buffer
-        ((save-excursion
-           (goto-char (line-beginning-position))
-           (bobp))
-         'no-indent)
-        ;; Comment continuation
-        ((save-excursion
-           (when (and
-                  (or
-                   (python-info-current-line-comment-p)
-                   (python-info-current-line-empty-p))
-                  (progn
-                    (forward-comment -1)
-                    (python-info-current-line-comment-p)))
-             (setq start (point))
-             'after-comment)))
-        ;; Inside string
-        ((setq start (python-syntax-context 'string ppss))
-         'inside-string)
-        ;; Inside a paren
-        ((setq start (python-syntax-context 'paren ppss))
-         'inside-paren)
-        ;; After backslash
-        ((setq start (when (not (or (python-syntax-context 'string ppss)
-                                    (python-syntax-context 'comment ppss)))
-                       (let ((line-beg-pos (line-number-at-pos)))
-                         (python-info-line-ends-backslash-p
-                          (1- line-beg-pos)))))
-         'after-backslash)
-        ;; After beginning of block
-        ((setq start (save-excursion
-                       (when (progn
-                               (back-to-indentation)
-                               (python-util-forward-comment -1)
-                               (equal (char-before) ?:))
-                         ;; Move to the first block start that's not in within
-                         ;; a string, comment or paren and that's not a
-                         ;; continuation line.
-                         (while (and (re-search-backward
-                                      (python-rx block-start) nil t)
-                                     (or
-                                      (python-syntax-context-type)
-                                      (python-info-continuation-line-p))))
-                         (when (looking-at (python-rx block-start))
-                           (point-marker)))))
-         'after-beginning-of-block)
-        ((when (setq start (python-info-dedenter-statement-p))
-           'dedenter-statement))
-        ;; After normal line
-        ((setq start (save-excursion
+    (let ((ppss (save-excursion
+                  (beginning-of-line)
+                  (syntax-ppss))))
+      (cond
+       ;; Beginning of buffer.
+       ((= (line-number-at-pos) 1)
+        (cons :no-indent 0))
+       ;; Comment continuation (maybe).
+       ((save-excursion
+          (when (and
+                 (or
+                  (python-info-current-line-comment-p)
+                  (python-info-current-line-empty-p))
+                 (forward-comment -1)
+                 (python-info-current-line-comment-p))
+            (cons :after-comment (point)))))
+       ;; Inside a string.
+       ((let ((start (python-syntax-context 'string ppss)))
+          (when start
+            (cons :inside-string start))))
+       ;; Inside a paren.
+       ((let* ((start (python-syntax-context 'paren ppss))
+               (starts-in-newline
+                (when start
+                  (save-excursion
+                    (goto-char start)
+                    (forward-char)
+                    (not
+                     (= (line-number-at-pos)
+                        (progn
+                          (python-util-forward-comment)
+                          (line-number-at-pos))))))))
+          (when start
+            (cond
+             ;; Current line only holds the closing paren.
+             ((save-excursion
+                (skip-syntax-forward " ")
+                (when (and (python-syntax-closing-paren-p)
+                           (progn
+                             (forward-char 1)
+                             (not (python-syntax-context 'paren))))
+                  (cons :inside-paren-at-closing-paren start))))
+             ;; Current line only holds a closing paren for nested.
+             ((save-excursion
+                (back-to-indentation)
+                (python-syntax-closing-paren-p))
+              (cons :inside-paren-at-closing-nested-paren start))
+             ;; This line starts from a opening block in its own line.
+             ((save-excursion
+                (goto-char start)
+                (when (and
+                       starts-in-newline
+                       (save-excursion
+                         (back-to-indentation)
+                         (looking-at (python-rx block-start))))
+                  (cons
+                   :inside-paren-newline-start-from-block start))))
+             (starts-in-newline
+              (cons :inside-paren-newline-start start))
+             ;; General case.
+             (t (cons :inside-paren
+                      (save-excursion
+                        (goto-char (1+ start))
+                        (skip-syntax-forward "(" 1)
+                        (skip-syntax-forward " ")
+                        (point))))))))
+       ;; After backslash.
+       ((let ((start (when (not (python-syntax-comment-or-string-p ppss))
+                       (python-info-line-ends-backslash-p
+                        (1- (line-number-at-pos))))))
+          (when start
+            (cond
+             ;; Continuation of dotted expression.
+             ((save-excursion
+                (back-to-indentation)
+                (when (eq (char-after) ?\.)
+                  ;; Move point back until it's not inside a paren.
+                  (while (prog2
+                             (forward-line -1)
+                             (and (not (bobp))
+                                  (python-syntax-context 'paren))))
+                  (goto-char (line-end-position))
+                  (while (and (search-backward
+                               "." (line-beginning-position) t)
+                              (python-syntax-context-type)))
+                  ;; Ensure previous statement has dot to align with.
+                  (when (and (eq (char-after) ?\.)
+                             (not (python-syntax-context-type)))
+                    (cons :after-backslash-dotted-continuation (point))))))
+             ;; Continuation of block definition.
+             ((let ((block-continuation-start
+                     (python-info-block-continuation-line-p)))
+                (when block-continuation-start
+                  (save-excursion
+                    (goto-char block-continuation-start)
+                    (re-search-forward
+                     (python-rx block-start (* space))
+                     (line-end-position) t)
+                    (cons :after-backslash-block-continuation (point))))))
+             ;; Continuation of assignment.
+             ((let ((assignment-continuation-start
+                     (python-info-assignment-continuation-line-p)))
+                (when assignment-continuation-start
+                  (save-excursion
+                    (goto-char assignment-continuation-start)
+                    (cons :after-backslash-assignment-continuation (point))))))
+             ;; First line after backslash continuation start.
+             ((save-excursion
+                (goto-char start)
+                (when (or (= (line-number-at-pos) 1)
+                          (not (python-info-beginning-of-backslash
+                                (1- (line-number-at-pos)))))
+                  (cons :after-backslash-first-line start))))
+             ;; General case.
+             (t (cons :after-backslash start))))))
+       ;; After beginning of block.
+       ((let ((start (save-excursion
+                       (back-to-indentation)
+                       (python-util-forward-comment -1)
+                       (when (equal (char-before) ?:)
+                         (python-nav-beginning-of-block)))))
+          (when start
+            (cons :after-block-start start))))
+       ;; At dedenter statement.
+       ((let ((start (python-info-dedenter-statement-p)))
+          (when start
+            (cons :at-dedenter-block-start start))))
+       ;; After normal line.
+       ((let ((start (save-excursion
                        (back-to-indentation)
-                       (skip-chars-backward (rx (or whitespace ?\n)))
+                       (skip-chars-backward " \t\n")
                        (python-nav-beginning-of-statement)
-                       (point-marker)))
-         'after-line)
-        ;; Do not indent
-        (t 'no-indent))
-       start))))
-
-(defun python-indent-calculate-indentation ()
-  "Calculate correct indentation offset for the current line.
-Returns `noindent' if the indentation does not depend on Python syntax,
-such as in strings."
-  (let* ((indentation-context (python-indent-context))
-         (context-status (car indentation-context))
-         (context-start (cdr indentation-context)))
-    (save-restriction
-      (widen)
-      (save-excursion
-        (pcase context-status
-          (`no-indent 0)
-          (`after-comment
-           (goto-char context-start)
-           (current-indentation))
-          ;; When point is after beginning of block just add one level
-          ;; of indentation relative to the context-start
-          (`after-beginning-of-block
-           (goto-char context-start)
-           (+ (current-indentation) python-indent-offset))
-          ;; When after a simple line just use previous line
-          ;; indentation.
-          (`after-line
-           (let* ((pair (save-excursion
-                          (goto-char context-start)
-                          (cons
-                           (current-indentation)
-                           (python-info-beginning-of-block-p))))
-                  (context-indentation (car pair))
-                  ;; TODO: Separate block enders into its own case.
-                  (adjustment
-                   (if (save-excursion
-                         (python-util-forward-comment -1)
-                         (python-nav-beginning-of-statement)
-                         (looking-at (python-rx block-ender)))
-                       python-indent-offset
-                     0)))
-             (- context-indentation adjustment)))
-          ;; When point is on a dedenter statement, search for the
-          ;; opening block that corresponds to it and use its
-          ;; indentation.  If no opening block is found just remove
-          ;; indentation as this is an invalid python file.
-          (`dedenter-statement
-           (let ((block-start-point
-                  (python-info-dedenter-opening-block-position)))
-             (save-excursion
-               (if (not block-start-point)
-                   0
-                 (goto-char block-start-point)
-                 (current-indentation)))))
-          ;; When inside of a string, do nothing. just use the current
-          ;; indentation.  XXX: perhaps it would be a good idea to
-          ;; invoke standard text indentation here
-          (`inside-string 'noindent)
-          ;; After backslash we have several possibilities.
-          (`after-backslash
-           (cond
-            ;; Check if current line is a dot continuation.  For this
-            ;; the current line must start with a dot and previous
-            ;; line must contain a dot too.
-            ((save-excursion
-               (back-to-indentation)
-               (when (looking-at "\\.")
-                 ;; If after moving one line back point is inside a paren it
-                 ;; needs to move back until it's not anymore
-                 (while (prog2
-                            (forward-line -1)
-                            (and (not (bobp))
-                                 (python-syntax-context 'paren))))
-                 (goto-char (line-end-position))
-                 (while (and (re-search-backward
-                              "\\." (line-beginning-position) t)
-                             (python-syntax-context-type)))
-                 (if (and (looking-at "\\.")
-                          (not (python-syntax-context-type)))
-                     ;; The indentation is the same column of the
-                     ;; first matching dot that's not inside a
-                     ;; comment, a string or a paren
-                     (current-column)
-                   ;; No dot found on previous line, just add another
-                   ;; indentation level.
-                   (+ (current-indentation) python-indent-offset)))))
-            ;; Check if prev line is a block continuation
-            ((let ((block-continuation-start
-                    (python-info-block-continuation-line-p)))
-               (when block-continuation-start
-                 ;; If block-continuation-start is set jump to that
-                 ;; marker and use first column after the block start
-                 ;; as indentation value.
-                 (goto-char block-continuation-start)
-                 (re-search-forward
-                  (python-rx block-start (* space))
-                  (line-end-position) t)
-                 (current-column))))
-            ;; Check if current line is an assignment continuation
-            ((let ((assignment-continuation-start
-                    (python-info-assignment-continuation-line-p)))
-               (when assignment-continuation-start
-                 ;; If assignment-continuation is set jump to that
-                 ;; marker and use first column after the assignment
-                 ;; operator as indentation value.
-                 (goto-char assignment-continuation-start)
-                 (current-column))))
-            (t
-             (forward-line -1)
-             (goto-char (python-info-beginning-of-backslash))
-             (if (save-excursion
-                   (and
-                    (forward-line -1)
-                    (goto-char
-                     (or (python-info-beginning-of-backslash) (point)))
-                    (python-info-line-ends-backslash-p)))
-                 ;; The two previous lines ended in a backslash so we must
-                 ;; respect previous line indentation.
-                 (current-indentation)
-               ;; What happens here is that we are dealing with the second
-               ;; line of a backslash continuation, in that case we just going
-               ;; to add one indentation level.
-               (+ (current-indentation) python-indent-offset)))))
-          ;; When inside a paren there's a need to handle nesting
-          ;; correctly
-          (`inside-paren
-           (cond
-            ;; If current line closes the outermost open paren use the
-            ;; current indentation of the context-start line.
-            ((save-excursion
-               (skip-syntax-forward "\s" (line-end-position))
-               (when (and (looking-at (regexp-opt '(")" "]" "}")))
-                          (progn
-                            (forward-char 1)
-                            (not (python-syntax-context 'paren))))
-                 (goto-char context-start)
-                 (current-indentation))))
-            ;; If open paren is contained on a line by itself add another
-            ;; indentation level, else look for the first word after the
-            ;; opening paren and use it's column position as indentation
-            ;; level.
-            ((let* ((content-starts-in-newline)
-                    (indent
-                     (save-excursion
-                       (if (setq content-starts-in-newline
-                                 (progn
-                                   (goto-char context-start)
-                                   (forward-char)
-                                   (save-restriction
-                                     (narrow-to-region
-                                      (line-beginning-position)
-                                      (line-end-position))
-                                     (python-util-forward-comment))
-                                   (looking-at "$")))
-                           (+ (current-indentation) python-indent-offset)
-                         (current-column)))))
-               ;; Adjustments
-               (cond
-                ;; If current line closes a nested open paren de-indent one
-                ;; level.
-                ((progn
-                   (back-to-indentation)
-                   (looking-at (regexp-opt '(")" "]" "}"))))
-                 (- indent python-indent-offset))
-                ;; If the line of the opening paren that wraps the current
-                ;; line starts a block add another level of indentation to
-                ;; follow new pep8 recommendation. See: http://ur1.ca/5rojx
-                ((save-excursion
-                   (when (and content-starts-in-newline
-                              (progn
-                                (goto-char context-start)
-                                (back-to-indentation)
-                                (looking-at (python-rx block-start))))
-                     (+ indent python-indent-offset))))
-                (t indent)))))))))))
-
-(defun python-indent-calculate-levels ()
-  "Calculate `python-indent-levels' and reset `python-indent-current-level'."
-  (if (or (python-info-continuation-line-p)
-          (not (python-info-dedenter-statement-p)))
-      ;; XXX: This asks for a refactor.  Even if point is on a
-      ;; dedenter statement, it could be multiline and in that case
-      ;; the continuation lines should be indented with normal rules.
-      (let* ((indentation (python-indent-calculate-indentation)))
-        (if (not (numberp indentation))
-            (setq python-indent-levels indentation)
-          (let* ((remainder (% indentation python-indent-offset))
-                 (steps (/ (- indentation remainder) python-indent-offset)))
-            (setq python-indent-levels (list 0))
-            (dotimes (step steps)
-              (push (* python-indent-offset (1+ step)) python-indent-levels))
-            (when (not (eq 0 remainder))
-              (push (+ (* python-indent-offset steps) remainder)
-                    python-indent-levels)))))
-    (setq python-indent-levels
-          (or
-           (mapcar (lambda (pos)
-                     (save-excursion
-                       (goto-char pos)
-                       (current-indentation)))
-                   (python-info-dedenter-opening-block-positions))
-           (list 0))))
-  (when (listp python-indent-levels)
-    (setq python-indent-current-level (1- (length python-indent-levels))
-          python-indent-levels (nreverse python-indent-levels))))
-
-(defun python-indent-toggle-levels ()
-  "Toggle `python-indent-current-level' over `python-indent-levels'."
-  (setq python-indent-current-level (1- python-indent-current-level))
-  (when (< python-indent-current-level 0)
-    (setq python-indent-current-level (1- (length python-indent-levels)))))
-
-(defun python-indent-line (&optional force-toggle)
+                       (point))))
+          (when start
+            (if (save-excursion
+                  (python-util-forward-comment -1)
+                  (python-nav-beginning-of-statement)
+                  (looking-at (python-rx block-ender)))
+                (cons :after-block-end start)
+              (cons :after-line start)))))
+       ;; Default case: do not indent.
+       (t (cons :no-indent 0))))))
+
+(defun python-indent--calculate-indentation ()
+  "Internal implementation of `python-indent-calculate-indentation'.
+May return an integer for the maximum possible indentation at
+current context or a list of integers.  The latter case is only
+happening for :at-dedenter-block-start context since the
+possibilities can be narrowed to especific indentation points."
+  (save-restriction
+    (widen)
+    (save-excursion
+      (pcase (python-indent-context)
+        (`(:no-indent . ,_) 0)
+        (`(,(or :after-line
+                :after-comment
+                :inside-string
+                :after-backslash
+                :inside-paren-at-closing-paren
+                :inside-paren-at-closing-nested-paren) . ,start)
+         ;; Copy previous indentation.
+         (goto-char start)
+         (current-indentation))
+        (`(,(or :after-block-start
+                :after-backslash-first-line
+                :inside-paren-newline-start) . ,start)
+         ;; Add one indentation level.
+         (goto-char start)
+         (+ (current-indentation) python-indent-offset))
+        (`(,(or :inside-paren
+                :after-backslash-block-continuation
+                :after-backslash-assignment-continuation
+                :after-backslash-dotted-continuation) . ,start)
+         ;; Use the column given by the context.
+         (goto-char start)
+         (current-column))
+        (`(:after-block-end . ,start)
+         ;; Subtract one indentation level.
+         (goto-char start)
+         (- (current-indentation) python-indent-offset))
+        (`(:at-dedenter-block-start . ,_)
+         ;; List all possible indentation levels from opening blocks.
+         (let ((opening-block-start-points
+                (python-info-dedenter-opening-block-positions)))
+           (if (not opening-block-start-points)
+               0  ; if not found default to first column
+             (mapcar (lambda (pos)
+                       (save-excursion
+                         (goto-char pos)
+                         (current-indentation)))
+                     opening-block-start-points))))
+        (`(,(or :inside-paren-newline-start-from-block) . ,start)
+         ;; Add two indentation levels to make the suite stand out.
+         (goto-char start)
+         (+ (current-indentation) (* python-indent-offset 2)))))))
+
+(defun python-indent--calculate-levels (indentation)
+  "Calculate levels list given INDENTATION.
+Argument INDENTATION can either be an integer or a list of
+integers.  Levels are returned in ascending order, and in the
+case INDENTATION is a list, this order is enforced."
+  (if (listp indentation)
+      (sort (copy-sequence indentation) #'<)
+    (let* ((remainder (% indentation python-indent-offset))
+           (steps (/ (- indentation remainder) python-indent-offset))
+           (levels (mapcar (lambda (step)
+                             (* python-indent-offset step))
+                           (number-sequence steps 0 -1))))
+      (reverse
+       (if (not (zerop remainder))
+           (cons indentation levels)
+         levels)))))
+
+(defun python-indent--previous-level (levels indentation)
+  "Return previous level from LEVELS relative to INDENTATION."
+  (let* ((levels (sort (copy-sequence levels) #'>))
+         (default (car levels)))
+    (catch 'return
+      (dolist (level levels)
+        (when (funcall #'< level indentation)
+          (throw 'return level)))
+      default)))
+
+(defun python-indent-calculate-indentation (&optional previous)
+  "Calculate indentation.
+Get indentation of PREVIOUS level when argument is non-nil.
+Return the max level of the cycle when indentation reaches the
+minimum."
+  (let* ((indentation (python-indent--calculate-indentation))
+         (levels (python-indent--calculate-levels indentation)))
+    (if previous
+        (python-indent--previous-level levels (current-indentation))
+      (apply #'max levels))))
+
+(defun python-indent-line (&optional previous)
   "Internal implementation of `python-indent-line-function'.
-Uses the offset calculated in
-`python-indent-calculate-indentation' and available levels
-indicated by the variable `python-indent-levels' to set the
-current indentation.
+Use the PREVIOUS level when argument is non-nil, otherwise indent
+to the maxium available level.  When indentation is the minimum
+possible and PREVIOUS is non-nil, cycle back to the maximum
+level."
+  (let ((follow-indentation-p
+         ;; Check if point is within indentation.
+         (and (<= (line-beginning-position) (point))
+              (>= (+ (line-beginning-position)
+                     (current-indentation))
+                  (point)))))
+    (save-excursion
+      (indent-line-to
+       (python-indent-calculate-indentation previous))
+      (python-info-dedenter-opening-block-message))
+    (when follow-indentation-p
+      (back-to-indentation))))
 
-When the variable `last-command' is equal to one of the symbols
-inside `python-indent-trigger-commands' or FORCE-TOGGLE is
-non-nil it cycles levels indicated in the variable
-`python-indent-levels' by setting the current level in the
-variable `python-indent-current-level'.
-
-When the variable `last-command' is not equal to one of the
-symbols inside `python-indent-trigger-commands' and FORCE-TOGGLE
-is nil it calculates possible indentation levels and saves them
-in the variable `python-indent-levels'.  Afterwards it sets the
-variable `python-indent-current-level' correctly so offset is
-equal to
-   (nth python-indent-current-level python-indent-levels)"
-  (if (and (or (and (memq this-command python-indent-trigger-commands)
-                    (eq last-command this-command))
-               force-toggle)
-           (not (equal python-indent-levels '(0))))
-      (if (listp python-indent-levels)
-          (python-indent-toggle-levels))
-    (python-indent-calculate-levels))
-  (if (eq python-indent-levels 'noindent)
-      python-indent-levels
-    (let* ((starting-pos (point-marker))
-           (indent-ending-position
-            (+ (line-beginning-position) (current-indentation)))
-           (follow-indentation-p
-            (or (bolp)
-                (and (<= (line-beginning-position) starting-pos)
-                     (>= indent-ending-position starting-pos))))
-           (next-indent (nth python-indent-current-level python-indent-levels)))
-      (unless (= next-indent (current-indentation))
-        (beginning-of-line)
-        (delete-horizontal-space)
-        (indent-to next-indent)
-        (goto-char starting-pos))
-      (and follow-indentation-p (back-to-indentation)))
-    (python-info-dedenter-opening-block-message)))
+(defun python-indent-calculate-levels ()
+  "Return possible indentation levels."
+  (python-indent--calculate-levels
+   (python-indent--calculate-indentation)))
 
 (defun python-indent-line-function ()
   "`indent-line-function' for Python mode.
-See `python-indent-line' for details."
-  (python-indent-line))
+When the variable `last-command' is equal to one of the symbols
+inside `python-indent-trigger-commands' it cycles possible
+indentation levels from right to left."
+  (python-indent-line
+   (and (memq this-command python-indent-trigger-commands)
+        (eq last-command this-command))))
 
 (defun python-indent-dedent-line ()
   "De-indent current line."
   (interactive "*")
-  (when (and (not (python-syntax-comment-or-string-p))
-             (<= (point) (save-excursion
-                                  (back-to-indentation)
-                           (point)))
-             (> (current-column) 0))
-    (python-indent-line t)
-    t))
+  (when (and (not (bolp))
+           (not (python-syntax-comment-or-string-p))
+           (= (+ (line-beginning-position)
+                 (current-indentation))
+              (point)))
+      (python-indent-line t)
+      t))
 
 (defun python-indent-dedent-line-backspace (arg)
   "De-indent current line.
 Argument ARG is passed to `backward-delete-char-untabify' when
 point is not in between the indentation."
   (interactive "*p")
-  (when (not (python-indent-dedent-line))
+  (unless (python-indent-dedent-line)
     (backward-delete-char-untabify arg)))
+
 (put 'python-indent-dedent-line-backspace 'delete-selection 'supersede)
 
 (defun python-indent-region (start end)
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index e8b6bf5adf7..135f945dbb9 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -1,7 +1,6 @@
 ;;; sh-script.el --- shell-script editing commands for Emacs  -*- lexical-binding:t -*-
 
-;; Copyright (C) 1993-1997, 1999, 2001-2015 Free Software Foundation,
-;; Inc.
+;; Copyright (C) 1993-1997, 1999, 2001-2015 Free Software Foundation, Inc.
 
 ;; Author: Daniel Pfeiffer <occitan@esperanto.org>
 ;; Version: 2.0f
@@ -1599,7 +1598,6 @@ buffer indents as it currently is indented.
 
 
 \\[backward-delete-char-untabify]        Delete backward one position, even if it was a tab.
-\\[newline-and-indent]   Delete unquoted space and indent new line same as this one.
 \\[sh-end-of-command]    Go to end of successive commands.
 \\[sh-beginning-of-command]      Go to beginning of successive commands.
 \\[sh-set-shell]         Set this buffer's shell, and maybe its magic number.
@@ -2501,7 +2499,8 @@ Lines containing only comments are considered empty."
                     (current-column)))
         current)
     (save-excursion
-      (indent-to (if (eq this-command 'newline-and-indent)
+      (indent-to (if (or (eq this-command 'newline-and-indent)
+                         (and electric-indent-mode (eq this-command 'newline)))
                      previous
                    (if (< (current-column)
                           (setq current (progn (back-to-indentation)
diff --git a/lisp/subr.el b/lisp/subr.el
index 05345853edc..68cd230c5e2 100644
--- a/lisp/subr.el
+++ b/lisp/subr.el
@@ -1082,7 +1082,12 @@ The return value is a positive integer."
 ;;;; Extracting fields of the positions in an event.
 
 (defun posnp (obj)
-  "Return non-nil if OBJ appears to be a valid `posn' object."
+  "Return non-nil if OBJ appears to be a valid `posn' object specifying a window.
+If OBJ is a valid `posn' object, but specifies a frame rather
+than a window, return nil."
+  ;; FIXME: Correct the behavior of this function so that all valid
+  ;; `posn' objects are recognized, after updating other code that
+  ;; depends on its present behavior.
   (and (windowp (car-safe obj))
        (atom (car-safe (setq obj (cdr obj))))                ;AREA-OR-POS.
        (integerp (car-safe (car-safe (setq obj (cdr obj))))) ;XOFFSET.
@@ -1142,24 +1147,28 @@ For a scroll-bar event, the result column is 0, and the row
 corresponds to the vertical position of the click in the scroll bar.
 POSITION should be a list of the form returned by the `event-start'
 and `event-end' functions."
-  (let* ((pair   (posn-x-y position))
-         (window (posn-window position))
-         (area   (posn-area position)))
+  (let* ((pair            (posn-x-y position))
+         (frame-or-window (posn-window position))
+         (frame           (if (framep frame-or-window)
+                              frame-or-window
+                            (window-frame frame-or-window)))
+         (window          (when (windowp frame-or-window) frame-or-window))
+         (area            (posn-area position)))
     (cond
-     ((null window)
+     ((null frame-or-window)
       '(0 . 0))
      ((eq area 'vertical-scroll-bar)
       (cons 0 (scroll-bar-scale pair (1- (window-height window)))))
      ((eq area 'horizontal-scroll-bar)
       (cons (scroll-bar-scale pair (window-width window)) 0))
      (t
-      (let* ((frame (if (framep window) window (window-frame window)))
-             ;; FIXME: This should take line-spacing properties on
-             ;; newlines into account.
-             (spacing (when (display-graphic-p frame)
-                        (or (with-current-buffer (window-buffer window)
-                              line-spacing)
-                            (frame-parameter frame 'line-spacing)))))
+      ;; FIXME: This should take line-spacing properties on
+      ;; newlines into account.
+      (let* ((spacing (when (display-graphic-p frame)
+                        (or (with-current-buffer
+                                (window-buffer (frame-selected-window frame))
+                              line-spacing)
+                            (frame-parameter frame 'line-spacing)))))
         (cond ((floatp spacing)
                (setq spacing (truncate (* spacing
                                           (frame-char-height frame)))))
diff --git a/lisp/tar-mode.el b/lisp/tar-mode.el
index 1ee54515bea..6c7f7553f82 100644
--- a/lisp/tar-mode.el
+++ b/lisp/tar-mode.el
@@ -50,9 +50,6 @@
 ;;
 ;; o  chmod should understand "a+x,og-w".
 ;;
-;; o  It's not possible to add a NEW file to a tar archive; not that
-;;    important, but still...
-;;
 ;; o  The code is less efficient that it could be - in a lot of places, I
 ;;    pull a 512-character string out of the buffer and parse it, when I could
 ;;    be parsing it in place, not garbaging a string.  Should redo that.
@@ -369,6 +366,80 @@ write-date, checksum, link-type, and link-name."
         string)
   (tar-parse-octal-integer string))
 
+(defun tar-new-regular-file-header (filename &optional size time)
+  "Return a Tar header for a regular file.
+The header will lack a proper checksum; use `tar-header-block-checksum'
+to compute one, or request `tar-header-serialize' to do that.
+
+Other tar-mode facilities may also require the data-start header
+field to be set to a valid value.
+
+If SIZE is not given or nil, it defaults to 0.
+If TIME is not given or nil, assume now."
+  (make-tar-header
+   nil
+   filename
+   #o644 0 0 (or size 0)
+   (or time (current-time))
+   nil                          ; checksum
+   nil nil
+   nil nil nil nil nil))
+
+(defun tar--pad-to (pos)
+  (make-string (+ pos (- (point)) (point-min)) 0))
+
+(defun tar--put-at (pos val &optional fmt mask)
+  (when val
+    (insert (tar--pad-to pos)
+            (if fmt
+                (format fmt (if mask (logand mask val) val))
+              val))))
+
+(defun tar-header-serialize (header &optional update-checksum)
+  "Return the serialization of a Tar HEADER as a string.
+This function calls `tar-header-block-check-checksum' to ensure the
+checksum is correct.
+
+If UPDATE-CHECKSUM is non-nil, update HEADER with the newly-computed
+checksum before doing the check."
+  (with-temp-buffer
+    (set-buffer-multibyte nil)
+    (let ((encoded-name
+           (encode-coding-string (tar-header-name header)
+                                 tar-file-name-coding-system)))
+      (unless (< (length encoded-name) 99)
+        ;; FIXME: Implement it.
+        (error "Long file name support is not implemented"))
+      (insert encoded-name))
+    (tar--put-at tar-mode-offset (tar-header-mode header) "%6o\0 " #o777777)
+    (tar--put-at tar-uid-offset  (tar-header-uid  header) "%6o\0 " #o777777)
+    (tar--put-at tar-gid-offset  (tar-header-gid  header) "%6o\0 " #o777777)
+    (tar--put-at tar-size-offset (tar-header-size header) "%11o ")
+    (insert (tar--pad-to tar-time-offset)
+            (tar-octal-time (tar-header-date header))
+            " ")
+    ;; Omit tar-header-checksum (tar-chk-offset) for now.
+    (tar--put-at   tar-linkp-offset (tar-header-link-type header))
+    (tar--put-at   tar-link-offset  (tar-header-link-name header))
+    (when (tar-header-magic header)
+      (tar--put-at tar-magic-offset (tar-header-magic header))
+      (tar--put-at tar-uname-offset (tar-header-uname header))
+      (tar--put-at tar-gname-offset (tar-header-gname header))
+      (tar--put-at tar-dmaj-offset (tar-header-dmaj header) "%7o\0" #o7777777)
+      (tar--put-at tar-dmin-offset (tar-header-dmin header) "%7o\0" #o7777777))
+    (tar--put-at 512 "")
+    (let ((ck (tar-header-block-checksum (buffer-string))))
+      (goto-char (+ (point-min) tar-chk-offset))
+      (delete-char 8)
+      (insert (format "%6o\0 " ck))
+      (when update-checksum
+        (setf (tar-header-checksum header) ck))
+      (tar-header-block-check-checksum (buffer-string)
+                                       (tar-header-checksum header)
+                                       (tar-header-name header)))
+    ;; .
+    (buffer-string)))
+
 
 (defun tar-header-block-checksum (string)
   "Compute and return a tar-acceptable checksum for this block."
@@ -547,6 +618,7 @@ MODE should be an integer which is a file mode value."
     (define-key map "p" 'tar-previous-line)
     (define-key map "\^P" 'tar-previous-line)
     (define-key map [up] 'tar-previous-line)
+    (define-key map "I" 'tar-new-entry)
     (define-key map "R" 'tar-rename-entry)
     (define-key map "u" 'tar-unflag)
     (define-key map "v" 'tar-view)
@@ -731,10 +803,14 @@ tar-file's buffer."
   (interactive "p")
   (tar-next-line (- arg)))
 
+(defun tar-current-position ()
+  "Return the `tar-parse-info' index for the current line."
+  (count-lines (point-min) (line-beginning-position)))
+
 (defun tar-current-descriptor (&optional noerror)
   "Return the tar-descriptor of the current line, or signals an error."
   ;; I wish lines had plists, like in ZMACS...
-  (or (nth (count-lines (point-min) (line-beginning-position))
+  (or (nth (tar-current-position)
            tar-parse-info)
       (if noerror
           nil
@@ -948,6 +1024,37 @@ the current tar-entry."
         (write-region start end to-file nil nil nil t)))
     (message "Copied tar entry %s to %s" name to-file)))
 
+(defun tar-new-entry (filename &optional index)
+  "Insert a new empty regular file before point."
+  (interactive "*sFile name: ")
+  (let* ((buffer  (current-buffer))
+         (index   (or index (tar-current-position)))
+         (d-list  (and (not (zerop index))
+                       (nthcdr (+ -1 index) tar-parse-info)))
+         (pos     (if d-list
+                      (tar-header-data-end (car d-list))
+                    (point-min)))
+         (new-descriptor
+          (tar-new-regular-file-header filename)))
+    ;; Update the data buffer; fill the missing descriptor fields.
+    (with-current-buffer tar-data-buffer
+      (goto-char pos)
+      (insert (tar-header-serialize new-descriptor t))
+      (setf  (tar-header-data-start new-descriptor)
+             (copy-marker (point) nil)))
+    ;; Update tar-parse-info.
+    (if d-list
+        (setcdr d-list     (cons new-descriptor (cdr d-list)))
+      (setq tar-parse-info (cons new-descriptor tar-parse-info)))
+    ;; Update the listing buffer.
+    (save-excursion
+      (goto-char (point-min))
+      (forward-line index)
+      (let ((inhibit-read-only t))
+        (insert (tar-header-block-summarize new-descriptor) ?\n)))
+    ;; .
+    index))
+
 (defun tar-flag-deleted (p &optional unflag)
   "In Tar mode, mark this sub-file to be deleted from the tar file.
 With a prefix argument, mark that many files."
diff --git a/lisp/textmodes/artist.el b/lisp/textmodes/artist.el
index 8a2383c12ff..85d9410868a 100644
--- a/lisp/textmodes/artist.el
+++ b/lisp/textmodes/artist.el
@@ -4963,52 +4963,55 @@ The event, EV, is the mouse event."
     (artist-funcall init-fn x1 y1)
     (if (not artist-rubber-banding)
         (artist-no-rb-set-point1 x1 y1))
-    (track-mouse
-      (while (or (mouse-movement-p ev)
-                 (member 'down (event-modifiers ev)))
-        (setq ev-start-pos (artist-coord-win-to-buf
-                            (posn-col-row (event-start ev))))
-        (setq x1 (car ev-start-pos))
-        (setq y1 (cdr ev-start-pos))
-
-        ;; Cancel previous timer
-        (if timer
-            (cancel-timer timer))
-
-        (if (not (eq initial-win (posn-window (event-start ev))))
-            ;; If we moved outside the window, do nothing
-            nil
-
-          ;; Still in same window:
-          ;;
-          ;; Check if user presses or releases shift key
-          (if (artist-shift-has-changed shift-state ev)
-
-              ;; First check that the draw-how is the same as we
-              ;; already have. Otherwise, ignore the changed shift-state.
-              (if (not (eq draw-how
-                           (artist-go-get-draw-how-from-symbol
-                            (if (not shift-state) shifted unshifted))))
-                  (message "Cannot switch to shifted operation")
-
-                ;; progn is "implicit" since this is the else-part
-                (setq shift-state (not shift-state))
-                (setq op          (if shift-state shifted unshifted))
-                (setq draw-how    (artist-go-get-draw-how-from-symbol op))
-                (setq draw-fn     (artist-go-get-draw-fn-from-symbol op))))
-
-          ;; Draw the new shape
-          (setq shape (artist-funcall draw-fn x1 y1))
-          (artist-move-to-xy x1 y1)
-
-          ;; Start the timer to call `draw-fn' repeatedly every
-          ;; `interval' second
-          (if (and interval draw-fn)
-              (setq timer (run-at-time interval interval draw-fn x1 y1))))
-
-        ;; Read next event
-        (setq ev (read-event))))
-
+    (unwind-protect
+        (track-mouse
+          (while (or (mouse-movement-p ev)
+                     (member 'down (event-modifiers ev)))
+            (setq ev-start-pos (artist-coord-win-to-buf
+                                (posn-col-row (event-start ev))))
+            (setq x1 (car ev-start-pos))
+            (setq y1 (cdr ev-start-pos))
+
+            ;; Cancel previous timer
+            (if timer
+                (cancel-timer timer))
+
+            (if (not (eq initial-win (posn-window (event-start ev))))
+                ;; If we moved outside the window, do nothing
+                nil
+
+              ;; Still in same window:
+              ;;
+              ;; Check if user presses or releases shift key
+              (if (artist-shift-has-changed shift-state ev)
+
+                  ;; First check that the draw-how is the same as we
+                  ;; already have. Otherwise, ignore the changed shift-state.
+                  (if (not (eq draw-how
+                               (artist-go-get-draw-how-from-symbol
+                                (if (not shift-state) shifted unshifted))))
+                      (message "Cannot switch to shifted operation")
+
+                    ;; progn is "implicit" since this is the else-part
+                    (setq shift-state (not shift-state))
+                    (setq op          (if shift-state shifted unshifted))
+                    (setq draw-how    (artist-go-get-draw-how-from-symbol op))
+                    (setq draw-fn     (artist-go-get-draw-fn-from-symbol op))))
+
+              ;; Draw the new shape
+              (setq shape (artist-funcall draw-fn x1 y1))
+              (artist-move-to-xy x1 y1)
+
+              ;; Start the timer to call `draw-fn' repeatedly every
+              ;; `interval' second
+              (if (and interval draw-fn)
+                  (setq timer (run-at-time interval interval draw-fn x1 y1))))
+
+            ;; Read next event
+            (setq ev (read-event))))
+      ;; Cleanup: get rid of any active timer.
+      (if timer
+          (cancel-timer timer)))
     ;; Cancel any timers
     (if timer
         (cancel-timer timer))
diff --git a/lisp/textmodes/reftex.el b/lisp/textmodes/reftex.el
index 160d9fb4cdf..7cf54c6d28a 100644
--- a/lisp/textmodes/reftex.el
+++ b/lisp/textmodes/reftex.el
@@ -106,17 +106,21 @@
 (defvar reftex-syntax-table nil)
 (defvar reftex-syntax-table-for-bib nil)
 
-(unless reftex-syntax-table
+(defun reftex--prepare-syntax-tables ()
   (setq reftex-syntax-table (copy-syntax-table))
   (modify-syntax-entry ?\( "." reftex-syntax-table)
-  (modify-syntax-entry ?\) "." reftex-syntax-table))
+  (modify-syntax-entry ?\) "." reftex-syntax-table)
 
-(unless reftex-syntax-table-for-bib
   (setq reftex-syntax-table-for-bib (copy-syntax-table))
   (modify-syntax-entry ?\' "." reftex-syntax-table-for-bib)
   (modify-syntax-entry ?\" "." reftex-syntax-table-for-bib)
   (modify-syntax-entry ?\[ "." reftex-syntax-table-for-bib)
-  (modify-syntax-entry ?\] "." reftex-syntax-table-for-bib))
+  (modify-syntax-entry ?\] "." reftex-syntax-table-for-bib)
+  (modify-syntax-entry ?\( "." reftex-syntax-table-for-bib)
+  (modify-syntax-entry ?\) "." reftex-syntax-table-for-bib))
+
+(unless (and reftex-syntax-table reftex-syntax-table-for-bib)
+  (reftex--prepare-syntax-tables))
 
 ;; The following definitions are out of place, but I need them here
 ;; to make the compilation of reftex-mode not complain.
@@ -180,15 +184,7 @@ on the menu bar.
           (put 'reftex-auto-recenter-toc 'initialized t))
 
         ;; Prepare the special syntax tables.
-        (setq reftex-syntax-table (copy-syntax-table (syntax-table)))
-        (modify-syntax-entry ?\( "." reftex-syntax-table)
-        (modify-syntax-entry ?\) "." reftex-syntax-table)
-
-        (setq reftex-syntax-table-for-bib (copy-syntax-table))
-        (modify-syntax-entry ?\' "." reftex-syntax-table-for-bib)
-        (modify-syntax-entry ?\" "." reftex-syntax-table-for-bib)
-        (modify-syntax-entry ?\[ "." reftex-syntax-table-for-bib)
-        (modify-syntax-entry ?\] "." reftex-syntax-table-for-bib)
+        (reftex--prepare-syntax-tables)
 
         (run-hooks 'reftex-mode-hook))
     ;; Mode was turned off