Merge branch 'master' of git.sv.gnu.org:/srv/git/emacs

78 files changed, 1325 insertions, 2291 deletions

diff --git a/lisp/cedet/mode-local.el b/lisp/cedet/mode-local.el
index 30320b00946..ce367485c16 100644
--- a/lisp/cedet/mode-local.el
+++ b/lisp/cedet/mode-local.el
@@ -670,7 +670,7 @@ SYMBOL is a function that can be overridden."
 
 (add-hook 'help-fns-describe-function-functions 'describe-mode-local-overload)
 
-(declare-function xref-item-location "xref" (xref))
+(declare-function xref-item-location "xref" (xref) t)
 
 (defun xref-mode-local--override-present (sym xrefs)
   "Return non-nil if SYM is in XREFS."
diff --git a/lisp/descr-text.el b/lisp/descr-text.el
index dcc697e1b9a..a352ed0849c 100644
--- a/lisp/descr-text.el
+++ b/lisp/descr-text.el
@@ -322,7 +322,7 @@ This function is semi-obsolete.  Use `get-char-code-property'."
                                                (nth 13 fields) 16)))))))))))
 
 ;; Not defined on builds without X, but behind display-graphic-p.
-(declare-function internal-char-font "fontset.c" (position &optional ch))
+(declare-function internal-char-font "font.c" (position &optional ch))
 
 ;; Return information about how CHAR is displayed at the buffer
 ;; position POS.  If the selected frame is on a graphic display,
diff --git a/lisp/desktop.el b/lisp/desktop.el
index cb973c48f8d..e795d9c2300 100644
--- a/lisp/desktop.el
+++ b/lisp/desktop.el
@@ -140,8 +140,15 @@
 
 (defvar desktop-file-version "208"
   "Version number of desktop file format.
-Written into the desktop file and used at desktop read to provide
-backward compatibility.")
+Used at desktop read to provide backward compatibility.")
+
+(defconst desktop-native-file-version 208
+  "Format version of the current desktop package, an integer.")
+(defvar desktop-io-file-version nil
+  "The format version of the current desktop file (an integer) or nil.")
+;; Note: Historically, the version number is embedded in the entry for
+;; each buffer.  It is highly inadvisable for different buffer entries
+;; to have different format versions.
 
 ;; ----------------------------------------------------------------------------
 ;; USER OPTIONS -- settings you might want to play with.
@@ -693,6 +700,7 @@ deletes all frames except the selected one (and its minibuffer frame,
 if different)."
   (interactive)
   (desktop-lazy-abort)
+  (setq desktop-io-file-version nil)
   (dolist (var desktop-globals-to-clear)
     (if (symbolp var)
         (eval `(setq-default ,var nil))
@@ -781,44 +789,46 @@ buffer, which is (in order):
     local variables;
     auxiliary information given by `desktop-var-serdes-funs'."
   (set-buffer buffer)
-  (list
-   ;; base name of the buffer; replaces the buffer name if managed by uniquify
-   (and (fboundp 'uniquify-buffer-base-name) (uniquify-buffer-base-name))
-   ;; basic information
-   (desktop-file-name (buffer-file-name) desktop-dirname)
-   (buffer-name)
-   major-mode
-   ;; minor modes
-   (let (ret)
-     (dolist (minor-mode (mapcar #'car minor-mode-alist) ret)
-       (and (boundp minor-mode)
-            (symbol-value minor-mode)
-            (let* ((special (assq minor-mode desktop-minor-mode-table))
-                   (value (cond (special (cadr special))
-                                ((functionp minor-mode) minor-mode))))
-              (when value (cl-pushnew value ret))))))
-   ;; point and mark, and read-only status
-   (point)
-   (list (mark t) mark-active)
-   buffer-read-only
-   ;; auxiliary information
-   (when (functionp desktop-save-buffer)
-     (funcall desktop-save-buffer desktop-dirname))
-   ;; local variables
-   (let ((loclist (buffer-local-variables))
-         (ll nil))
-     (dolist (local desktop-locals-to-save)
-       (let ((here (assq local loclist)))
-         (cond (here
-                (push here ll))
-               ((member local loclist)
-                (push local ll)))))
-     ll)
-   (mapcar (lambda (record)
-             (let ((var (car record)))
-               (list var
-                     (funcall (cadr record) (symbol-value var)))))
-           desktop-var-serdes-funs)))
+  `(
+    ;; base name of the buffer; replaces the buffer name if managed by uniquify
+    ,(and (fboundp 'uniquify-buffer-base-name) (uniquify-buffer-base-name))
+    ;; basic information
+    ,(desktop-file-name (buffer-file-name) desktop-dirname)
+    ,(buffer-name)
+    ,major-mode
+    ;; minor modes
+    ,(let (ret)
+       (dolist (minor-mode (mapcar #'car minor-mode-alist) ret)
+         (and (boundp minor-mode)
+              (symbol-value minor-mode)
+              (let* ((special (assq minor-mode desktop-minor-mode-table))
+                     (value (cond (special (cadr special))
+                                  ((functionp minor-mode) minor-mode))))
+                (when value (cl-pushnew value ret))))))
+    ;; point and mark, and read-only status
+    ,(point)
+    ,(list (mark t) mark-active)
+    ,buffer-read-only
+    ;; auxiliary information
+    ,(when (functionp desktop-save-buffer)
+       (funcall desktop-save-buffer desktop-dirname))
+    ;; local variables
+    ,(let ((loclist (buffer-local-variables))
+           (ll nil))
+       (dolist (local desktop-locals-to-save)
+         (let ((here (assq local loclist)))
+           (cond (here
+                  (push here ll))
+                 ((member local loclist)
+                  (push local ll)))))
+       ll)
+   ,@(when (>= desktop-io-file-version 208)
+       (list
+        (mapcar (lambda (record)
+                  (let ((var (car record)))
+                    (list var
+                          (funcall (cadr record) (symbol-value var)))))
+                desktop-var-serdes-funs)))))
 
 ;; ----------------------------------------------------------------------------
 (defun desktop--v2s (value)
@@ -983,20 +993,41 @@ Frames with a non-nil `desktop-dont-save' parameter are not saved."
                             :predicate #'desktop--check-dont-save))))
 
 ;;;###autoload
-(defun desktop-save (dirname &optional release only-if-changed)
+(defun desktop-save (dirname &optional release only-if-changed version)
   "Save the desktop in a desktop file.
 Parameter DIRNAME specifies where to save the desktop file.
-Optional parameter RELEASE says whether we're done with this desktop.
-If ONLY-IF-CHANGED is non-nil, compare the current desktop information
-to that in the desktop file, and if the desktop information has not
-changed since it was last saved then do not rewrite the file."
+Optional parameter RELEASE says whether we're done with this
+desktop.  If ONLY-IF-CHANGED is non-nil, compare the current
+desktop information to that in the desktop file, and if the
+desktop information has not changed since it was last saved then
+do not rewrite the file.
+
+This function can save the desktop in either format version
+208 (which only Emacs 25.1 and later can read) or version
+206 (which is readable by any Emacs from version 22.1 onwards).
+By default, it will use the same format the desktop file had when
+it was last saved, or version 208 when writing a fresh desktop
+file.
+
+To upgrade a version 206 file to version 208, call this command
+explicitly with a bare prefix argument: C-u M-x desktop-save.
+You are recommended to do this once you have firmly upgraded to
+Emacs 25.1 (or later).  To downgrade a version 208 file to version
+206, use a double command prefix: C-u C-u M-x desktop-save.
+Confirmation will be requested in either case.  In a non-interactive
+call, VERSION can be given as an integer, either 206 or 208, which
+will be accepted as the format version in which to save the file
+without further confirmation."
   (interactive (list
                 ;; Or should we just use (car desktop-path)?
                 (let ((default (if (member "." desktop-path)
                                    default-directory
                                  user-emacs-directory)))
                   (read-directory-name "Directory to save desktop file in: "
-                                       default default t))))
+                                       default default t))
+                nil
+                nil
+                current-prefix-arg))
   (setq desktop-dirname (file-name-as-directory (expand-file-name dirname)))
   (save-excursion
     (let ((eager desktop-restore-eager)
@@ -1017,12 +1048,34 @@ changed since it was last saved then do not rewrite the file."
             (desktop-release-lock)
           (unless (and new-modtime (desktop-owner)) (desktop-claim-lock)))
 
+        ;; What format are we going to write the file in?
+        (setq desktop-io-file-version
+              (cond
+               ((equal version '(4))
+                (if (or (eq desktop-io-file-version 208)
+                        (yes-or-no-p "Save desktop file in format 208 \
+\(Readable by Emacs 25.1 and later only)? "))
+                    208
+                  (or desktop-io-file-version desktop-native-file-version)))
+               ((equal version '(16))
+                (if (or (eq desktop-io-file-version 206)
+                        (yes-or-no-p "Save desktop file in format 206 \
+\(Readable by all Emacs versions since 22.1)? "))
+                    206
+                  (or desktop-io-file-version desktop-native-file-version)))
+               ((memq version '(206 208))
+                version)
+               ((null desktop-io-file-version) ; As yet, no desktop file exists.
+                desktop-native-file-version)
+               (t
+                desktop-io-file-version)))
+
         (with-temp-buffer
           (insert
            ";; -*- mode: emacs-lisp; coding: emacs-mule; -*-\n"
            desktop-header
            ";; Created " (current-time-string) "\n"
-           ";; Desktop file format version " desktop-file-version "\n"
+           ";; Desktop file format version " (format "%d" desktop-io-file-version) "\n"
            ";; Emacs version " emacs-version "\n")
           (save-excursion (run-hooks 'desktop-save-hook))
           (goto-char (point-max))
@@ -1052,7 +1105,7 @@ changed since it was last saved then do not rewrite the file."
                             "desktop-create-buffer"
                           "desktop-append-buffer-args")
                         " "
-                        desktop-file-version)
+                        (format "%d" desktop-io-file-version))
                 ;; If there's a non-empty base name, we save it instead of the buffer name
                 (when (and base (not (string= base "")))
                   (setcar (nthcdr 1 l) base))
@@ -1390,6 +1443,8 @@ and try to load that."
      compacted-vars
      &rest _unsupported)
 
+  (setq desktop-io-file-version file-version)
+
   (let ((desktop-file-version       file-version)
         (desktop-buffer-file-name   buffer-filename)
         (desktop-buffer-name        buffer-name)
diff --git a/lisp/dired-aux.el b/lisp/dired-aux.el
index a678fca3ea3..ab10edeedbf 100644
--- a/lisp/dired-aux.el
+++ b/lisp/dired-aux.el
@@ -2713,6 +2713,41 @@ with the command \\[tags-loop-continue]."
   (tags-query-replace from to delimited
                       '(dired-get-marked-files nil nil 'dired-nondirectory-p)))
 
+(declare-function xref--show-xrefs "xref")
+(declare-function xref-query-replace "xref")
+
+;;;###autoload
+(defun dired-do-find-regexp (regexp)
+  "Find all matches for REGEXP in all marked files, recursively."
+  (interactive "sSearch marked files (regexp): ")
+  (require 'grep)
+  (defvar grep-find-ignored-files)
+  (let* ((files (dired-get-marked-files))
+         (ignores (nconc (mapcar
+                          (lambda (s) (concat s "/"))
+                          vc-directory-exclusion-list)
+                         grep-find-ignored-files))
+         (xrefs (cl-mapcan
+                 (lambda (file)
+                   (xref-collect-matches regexp "*" file
+                                         (and (file-directory-p file)
+                                              ignores)))
+                 files)))
+    (unless xrefs
+      (user-error "No matches for: %s" regexp))
+    (xref--show-xrefs xrefs nil t)))
+
+;;;###autoload
+(defun dired-do-find-regexp-and-replace (from to)
+  "Replace matches of FROM with TO, in all marked files, recursively."
+  (interactive
+   (let ((common
+          (query-replace-read-args
+           "Query replace regexp in marked files" t t)))
+     (list (nth 0 common) (nth 1 common))))
+  (with-current-buffer (dired-do-find-regexp from)
+    (xref-query-replace from to)))
+
 (defun dired-nondirectory-p (file)
   (not (file-directory-p file)))
 
diff --git a/lisp/dired-x.el b/lisp/dired-x.el
index 053b3cb9738..e8cea85d988 100644
--- a/lisp/dired-x.el
+++ b/lisp/dired-x.el
@@ -816,16 +816,14 @@ If in a Dired buffer, reverts it."
   (interactive)
   (if (file-exists-p dired-local-variables-file)
       (error "Old-style dired-local-variables-file `./%s' found;
-replace it with a dir-locals-file `./%s'"
+replace it with a dir-locals-file `./%s.el'"
              dired-local-variables-file
              dir-locals-file))
-  (if (file-exists-p dir-locals-file)
-      (message "File `./%s' already exists." dir-locals-file)
-    (with-temp-buffer
-      (insert "\
-\((dired-mode . ((subdirs . nil)
-                (dired-omit-mode . t))))\n")
-      (write-file dir-locals-file))
+  (if (dir-locals--all-files default-directory)
+      (message "File `./%s' already exists."
+               (car (dir-locals--all-files default-directory)))
+    (add-dir-local-variable 'dired-mode 'subdirs nil)
+    (add-dir-local-variable 'dired-mode 'dired-omit-mode t)
     ;; Run extra-hooks and revert directory.
     (when (derived-mode-p 'dired-mode)
       (hack-dir-local-variables-non-file-buffer)
diff --git a/lisp/dired.el b/lisp/dired.el
index 63124fce5e5..6c7445c3486 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -1453,7 +1453,7 @@ Do so according to the former subdir alist OLD-SUBDIR-ALIST."
     (define-key map "." 'dired-clean-directory)
     (define-key map "~" 'dired-flag-backup-files)
     ;; Upper case keys (except !) for operating on the marked files
-    (define-key map "A" 'dired-do-search)
+    (define-key map "A" 'dired-do-find-regexp)
     (define-key map "C" 'dired-do-copy)
     (define-key map "B" 'dired-do-byte-compile)
     (define-key map "D" 'dired-do-delete)
@@ -1463,7 +1463,7 @@ Do so according to the former subdir alist OLD-SUBDIR-ALIST."
     (define-key map "M" 'dired-do-chmod)
     (define-key map "O" 'dired-do-chown)
     (define-key map "P" 'dired-do-print)
-    (define-key map "Q" 'dired-do-query-replace-regexp)
+    (define-key map "Q" 'dired-do-find-regexp-and-replace)
     (define-key map "R" 'dired-do-rename)
     (define-key map "S" 'dired-do-symlink)
     (define-key map "T" 'dired-do-touch)
diff --git a/lisp/dos-fns.el b/lisp/dos-fns.el
index 7defb388b74..0ce2b23527d 100644
--- a/lisp/dos-fns.el
+++ b/lisp/dos-fns.el
@@ -201,8 +201,8 @@ that are used in Emacs Lisp sources; any other file name will be
 returned unaltered."
   (cond
    ;; See files.el:dir-locals-file.
-   ((string= file-name ".dir-locals.el")
-    "_dir-locals.el")
+   ((string= file-name ".dir-locals")
+    "_dir-locals")
    (t
     file-name)))
 
diff --git a/lisp/electric.el b/lisp/electric.el
index abddd986ef8..ab79943c9dd 100644
--- a/lisp/electric.el
+++ b/lisp/electric.el
@@ -417,14 +417,17 @@ The variable `electric-layout-rules' says when and how to insert newlines."
 
 (defcustom electric-quote-comment t
   "Non-nil means to use electric quoting in program comments."
+  :version "25.1"
   :type 'boolean :safe 'booleanp :group 'electricity)
 
 (defcustom electric-quote-string nil
   "Non-nil means to use electric quoting in program strings."
+  :version "25.1"
   :type 'boolean :safe 'booleanp :group 'electricity)
 
 (defcustom electric-quote-paragraph t
   "Non-nil means to use electric quoting in text paragraphs."
+  :version "25.1"
   :type 'boolean :safe 'booleanp :group 'electricity)
 
 (defun electric--insertable-p (string)
diff --git a/lisp/emacs-lisp/check-declare.el b/lisp/emacs-lisp/check-declare.el
index 513aa319798..b6fa0546088 100644
--- a/lisp/emacs-lisp/check-declare.el
+++ b/lisp/emacs-lisp/check-declare.el
@@ -131,6 +131,7 @@ With optional argument FULL, sums the number of elements in each element."
 
 (defcustom check-declare-ext-errors nil
   "When non-nil, warn about functions not found in :ext."
+  :version "25.1"
   :type 'boolean)
 
 (defun check-declare-verify (fnfile fnlist)
diff --git a/lisp/emacs-lisp/cursor-sensor.el b/lisp/emacs-lisp/cursor-sensor.el
index 70c4458d300..ac063d4896a 100644
--- a/lisp/emacs-lisp/cursor-sensor.el
+++ b/lisp/emacs-lisp/cursor-sensor.el
@@ -167,8 +167,8 @@
 This property should hold a list of functions which react to the motion
 of the cursor.  They're called with three arguments (WINDOW OLDPOS DIR)
 where WINDOW is the affected window, OLDPOS is the last known position of
-the cursor and DIR can be `left' or `entered' depending on whether the cursor is
-entering the area covered by the text-property property or leaving it."
+the cursor and DIR can be `entered' or `left' depending on whether the cursor
+is entering the area covered by the text-property property or leaving it."
   nil nil nil
   (if cursor-sensor-mode
       (add-hook 'pre-redisplay-functions #'cursor-sensor--detect
diff --git a/lisp/emacs-lisp/inline.el b/lisp/emacs-lisp/inline.el
index 56780fbb05a..058c56c3b49 100644
--- a/lisp/emacs-lisp/inline.el
+++ b/lisp/emacs-lisp/inline.el
@@ -102,7 +102,7 @@ VARS should be a list of elements of the form (VAR EXP) or just VAR, in case
 EXP is equal to VAR.  The result is to evaluate EXP and bind the result to VAR.
 
 The tail of VARS can be either nil or a symbol VAR which should hold a list
-of arguments,in which case each argument is evaluated and the resulting
+of arguments, in which case each argument is evaluated and the resulting
 new list is re-bound to VAR.
 
 After VARS is handled, BODY is evaluated in the new environment."
diff --git a/lisp/emacs-lisp/package.el b/lisp/emacs-lisp/package.el
index 057d01488cc..08f64147d44 100644
--- a/lisp/emacs-lisp/package.el
+++ b/lisp/emacs-lisp/package.el
@@ -329,6 +329,7 @@ by running `package-install-selected-packages'.
 To check if a package is contained in this list here, use
 `package--user-selected-p', as it may populate the variable with
 a sane initial value."
+  :version "25.1"
   :type '(repeat symbol))
 
 (defcustom package-menu-async t
@@ -2654,6 +2655,7 @@ omitted from the package menu.  To toggle this, type \\[package-menu-toggle-hidi
 
 Values can be interactively added to this list by typing
 \\[package-menu-hide-package] on a package"
+  :version "25.1"
   :type '(repeat (regexp :tag "Hide packages with name matching")))
 
 (defun package-menu--refresh (&optional packages keywords)
diff --git a/lisp/emacs-lisp/syntax.el b/lisp/emacs-lisp/syntax.el
index e20a210de71..c221a017f51 100644
--- a/lisp/emacs-lisp/syntax.el
+++ b/lisp/emacs-lisp/syntax.el
@@ -416,6 +416,9 @@ point (where the PPSS is equivalent to nil).")
               (error nil)))
           syntax-ppss-stats))
 
+(defvar-local syntax-ppss-table nil
+  "Syntax-table to use during `syntax-ppss', if any.")
+
 (defun syntax-ppss (&optional pos)
   "Parse-Partial-Sexp State at POS, defaulting to point.
 The returned value is the same as that of `parse-partial-sexp'
@@ -431,6 +434,7 @@ running the hook."
   (unless pos (setq pos (point)))
   (syntax-propertize pos)
   ;;
+  (with-syntax-table (or syntax-ppss-table (syntax-table))
   (let ((old-ppss (cdr syntax-ppss-last))
         (old-pos (car syntax-ppss-last))
         (ppss nil)
@@ -567,7 +571,7 @@ running the hook."
        ;; we may end up calling parse-partial-sexp with a position before
        ;; point-min.  In that case, just parse from point-min assuming
        ;; a nil state.
-       (parse-partial-sexp (point-min) pos)))))
+       (parse-partial-sexp (point-min) pos))))))
 
 ;; Debugging functions
 
diff --git a/lisp/epg-config.el b/lisp/epg-config.el
index 5fac079d3c0..e92bcd62a66 100644
--- a/lisp/epg-config.el
+++ b/lisp/epg-config.el
@@ -53,6 +53,7 @@
 
 (defcustom epg-gpgconf-program "gpgconf"
   "The `gpgconf' executable."
+  :version "25.1"
   :group 'epg
   :type 'string)
 
diff --git a/lisp/erc/erc.el b/lisp/erc/erc.el
index 3824c195d39..56317b83a98 100644
--- a/lisp/erc/erc.el
+++ b/lisp/erc/erc.el
@@ -265,14 +265,16 @@ A typical value would be \(\"JOIN\" \"PART\" \"QUIT\")."
 (defcustom erc-network-hide-list nil
   "A list of IRC networks to hide message types from.
 A typical value would be \((\"freenode\" \"MODE\")
-(\"OFTC\" \"JOIN\" \"QUIT\"))."
+  \(\"OFTC\" \"JOIN\" \"QUIT\"))."
+  :version "25.1"
   :group 'erc-ignore
   :type 'erc-message-type)
 
 (defcustom erc-channel-hide-list nil
   "A list of IRC channels to hide message types from.
 A typical value would be \((\"#emacs\" \"QUIT\" \"JOIN\")
-(\"#erc\" \"NICK\")."
+  \(\"#erc\" \"NICK\")."
+  :version "25.1"
   :group 'erc-ignore
   :type 'erc-message-type)
 
diff --git a/lisp/eshell/em-term.el b/lisp/eshell/em-term.el
index aabc5fdb1a2..3e5de0c0097 100644
--- a/lisp/eshell/em-term.el
+++ b/lisp/eshell/em-term.el
@@ -136,6 +136,7 @@ character to the invoked process."
   "If non-nil, term buffers are destroyed after their processes die.
 WARNING: Setting this to non-nil may result in unexpected
 behavior for short-lived processes, see bug#18108."
+  :version "25.1"
   :type 'boolean
   :group 'eshell-term)
 
diff --git a/lisp/files-x.el b/lisp/files-x.el
index ed3d49df385..2e1a728356e 100644
--- a/lisp/files-x.el
+++ b/lisp/files-x.el
@@ -444,10 +444,8 @@ from the MODE alist ignoring the input argument VALUE."
                    (if (nth 2 variables-file)
                        (car (last (dir-locals--all-files (car variables-file))))
                      (cadr variables-file)))
-                  ;; Try to make a proper file-name.  This doesn't cover all
-                  ;; wildcards, but it covers the default value of `dir-locals-file'.
-                  (t (replace-regexp-in-string
-                      "\\*" "" (replace-regexp-in-string  "\\?" "-" dir-locals-file)))))
+                  ;; Try to make a proper file-name.
+                  (t (concat dir-locals-file ".el"))))
       ;; I can't be bothered to handle this case right now.
       ;; Dir locals were set directly from a class.  You need to
       ;; directly modify the class in dir-locals-class-alist.
diff --git a/lisp/files.el b/lisp/files.el
index 9cb46fcd0a9..5a15c71aab6 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -3713,7 +3713,7 @@ VARIABLES list of the class.  The list is processed in order.
   applied by recursively following these rules."
   (setf (alist-get class dir-locals-class-alist) variables))
 
-(defconst dir-locals-file ".dir-locals*.el"
+(defconst dir-locals-file ".dir-locals"
   "Pattern for files that contain directory-local variables.
 It has to be constant to enforce uniform values across different
 environments and users.
@@ -3730,16 +3730,20 @@ return a sorted list of all files matching `dir-locals-file' in
 this directory.
 The returned list is sorted by `string<' order."
   (require 'seq)
-  (let ((default-directory (if (file-directory-p file-or-dir)
-                               file-or-dir
-                             default-directory)))
+  (let ((dir (if (file-directory-p file-or-dir)
+                 file-or-dir
+               (or (file-name-directory file-or-dir)
+                   default-directory)))
+        (file (cond ((not (file-directory-p file-or-dir)) (file-name-nondirectory file-or-dir))
+                    ((eq system-type 'ms-dos) (dosified-file-name dir-locals-file))
+                    (t dir-locals-file))))
     (seq-filter (lambda (f) (and (file-readable-p f)
-                            (file-regular-p f)))
-                (file-expand-wildcards
-                 (cond ((not (file-directory-p file-or-dir)) file-or-dir)
-                       ((eq system-type 'ms-dos) (dosified-file-name dir-locals-file))
-                       (t dir-locals-file))
-                 'full))))
+                            (file-regular-p f)
+                            (not (file-directory-p f))))
+                (mapcar (lambda (f) (expand-file-name f dir))
+                        (nreverse
+                         (let ((completion-regexp-list '("\\.el\\'")))
+                           (file-name-all-completions file dir)))))))
 
 (defun dir-locals-find-file (file)
   "Find the directory-local variables for FILE.
diff --git a/lisp/font-lock.el b/lisp/font-lock.el
index 3c1f01d5886..c79835dda49 100644
--- a/lisp/font-lock.el
+++ b/lisp/font-lock.el
@@ -1564,6 +1564,7 @@ START should be at the beginning of a line."
   "Put proper face on each string and comment between START and END.
 START should be at the beginning of a line."
   (syntax-propertize end)  ; Apply any needed syntax-table properties.
+  (with-syntax-table (or syntax-ppss-table (syntax-table))
   (let ((comment-end-regexp
          (or font-lock-comment-end-skip
              (regexp-quote
@@ -1598,7 +1599,7 @@ START should be at the beginning of a line."
                                      font-lock-comment-delimiter-face))))
           (< (point) end))
       (setq state (parse-partial-sexp (point) end nil nil state
-                                      'syntax-table)))))
+                                      'syntax-table))))))
 
 ;;; End of Syntactic fontification functions.
 
diff --git a/lisp/gnus/gnus-fun.el b/lisp/gnus/gnus-fun.el
index fa78b5c6e15..a6b27300233 100644
--- a/lisp/gnus/gnus-fun.el
+++ b/lisp/gnus/gnus-fun.el
@@ -44,7 +44,7 @@
   "Regexp to match faces in `gnus-x-face-directory' to be omitted."
   :version "25.1"
   :group 'gnus-fun
-  :type 'string)
+  :type '(choice (const nil) string))
 
 (defcustom gnus-face-directory (expand-file-name "faces" gnus-directory)
   "*Directory where Face PNG files are stored."
@@ -56,7 +56,7 @@
   "Regexp to match faces in `gnus-face-directory' to be omitted."
   :version "25.1"
   :group 'gnus-fun
-  :type 'string)
+  :type '(choice (const nil) string))
 
 (defcustom gnus-convert-pbm-to-x-face-command "pbmtoxbm %s | compface"
   "Command for converting a PBM to an X-Face."
diff --git a/lisp/gnus/gnus-util.el b/lisp/gnus/gnus-util.el
index ea5f3155478..31645fcd315 100644
--- a/lisp/gnus/gnus-util.el
+++ b/lisp/gnus/gnus-util.el
@@ -1996,6 +1996,14 @@ to case differences."
   (defun gnus-timer--function (timer)
     (elt timer 5)))
 
+(defun gnus-test-list (list predicate)
+  "To each element of LIST apply PREDICATE.
+Return nil if LIST is no list or is empty or some test returns nil;
+otherwise, return t."
+  (when (and list (listp list))
+    (let ((result (mapcar predicate list)))
+      (not (memq nil result)))))
+
 (defun gnus-subsetp (list1 list2)
   "Return t if LIST1 is a subset of LIST2.
 Similar to `subsetp' but use member for element test so that this works for
@@ -2006,6 +2014,13 @@ lists of strings."
              (gnus-subsetp (cdr list1) list2))
       t)))
 
+(defun gnus-setdiff (list1 list2)
+  "Return member-based set difference of LIST1 and LIST2."
+  (when (and list1 (listp list1) (listp list2))
+    (if (member (car list1) list2)
+        (gnus-setdiff (cdr list1) list2)
+      (cons (car list1) (gnus-setdiff (cdr list1) list2)))))
+
 (provide 'gnus-util)
 
 ;;; gnus-util.el ends here
diff --git a/lisp/gnus/gnus.el b/lisp/gnus/gnus.el
index 1196ea9dfec..5d2ce7ee19f 100644
--- a/lisp/gnus/gnus.el
+++ b/lisp/gnus/gnus.el
@@ -1637,6 +1637,7 @@ this variable.  I think."
                                              (const post-mail))
                         (checklist :inline t :greedy t
                                    (const :format "%v " address)
+                                   (const cloud)
                                    (const global)
                                    (const :format "%v " prompt-address)
                                    (const :format "%v " physical-address)
diff --git a/lisp/gnus/mml-sec.el b/lisp/gnus/mml-sec.el
index dbd31629f97..48e6384497e 100644
--- a/lisp/gnus/mml-sec.el
+++ b/lisp/gnus/mml-sec.el
@@ -25,7 +25,9 @@
 
 (eval-when-compile (require 'cl))
 
-(autoload 'gnus-subsetp "gnus-util")
+(require 'gnus-util)
+(require 'epg)
+
 (autoload 'mail-strip-quoted-names "mail-utils")
 (autoload 'mml2015-sign "mml2015")
 (autoload 'mml2015-encrypt "mml2015")
@@ -40,6 +42,7 @@
 (autoload 'mml-smime-encrypt-query "mml-smime")
 (autoload 'mml-smime-verify "mml-smime")
 (autoload 'mml-smime-verify-test "mml-smime")
+(autoload 'epa--select-keys "epa")
 
 (defvar mml-sign-alist
   '(("smime"     mml-smime-sign-buffer     mml-smime-sign-query)
@@ -91,7 +94,7 @@ signs and encrypt the message in one step.
 
 Note that the output generated by using a `combined' mode is NOT
 understood by all PGP implementations, in particular PGP version
-2 does not support it!  See Info node `(message)Security' for
+2 does not support it!  See Info node `(message) Security' for
 details."
   :version "22.1"
   :group 'message
@@ -111,7 +114,9 @@ details."
   (if (boundp 'password-cache)
       password-cache
     t)
-  "If t, cache passphrase."
+  "If t, cache OpenPGP or S/MIME passphrases inside Emacs.
+Passphrase caching in Emacs is NOT recommended.  Use gpg-agent instead.
+See Info node `(message) Security'."
   :group 'message
   :type 'boolean)
 
@@ -425,6 +430,534 @@ If called with a prefix argument, only encrypt (do NOT sign)."
   (interactive "P")
   (mml-secure-message "pgpauto" (if dontsign 'encrypt 'signencrypt)))
 
+;;; Common functionality for mml1991.el, mml2015.el, mml-smime.el
+
+(define-obsolete-variable-alias 'mml1991-signers 'mml-secure-openpgp-signers
+  "25.1")
+(define-obsolete-variable-alias 'mml2015-signers 'mml-secure-openpgp-signers
+  "25.1")
+(defcustom mml-secure-openpgp-signers nil
+  "A list of your own key ID(s) which will be used to sign OpenPGP messages.
+If set, it is added to the setting of `mml-secure-openpgp-sign-with-sender'."
+  :group 'mime-security
+  :type '(repeat (string :tag "Key ID")))
+
+(define-obsolete-variable-alias 'mml-smime-signers 'mml-secure-smime-signers
+  "25.1")
+(defcustom mml-secure-smime-signers nil
+  "A list of your own key ID(s) which will be used to sign S/MIME messages.
+If set, it is added to the setting of `mml-secure-smime-sign-with-sender'."
+  :group 'mime-security
+  :type '(repeat (string :tag "Key ID")))
+
+(define-obsolete-variable-alias
+  'mml1991-encrypt-to-self 'mml-secure-openpgp-encrypt-to-self "25.1")
+(define-obsolete-variable-alias
+  'mml2015-encrypt-to-self 'mml-secure-openpgp-encrypt-to-self "25.1")
+(defcustom mml-secure-openpgp-encrypt-to-self nil
+  "List of own key ID(s) or t; determines additional recipients with OpenPGP.
+If t, also encrypt to key for message sender; if list, encrypt to those keys.
+With this variable, you can ensure that you can decrypt your own messages.
+Alternatives to this variable include Bcc'ing the message to yourself or
+using the encrypt-to or hidden-encrypt-to option in gpg.conf (see man gpg(1)).
+Note that this variable and the encrypt-to option give away your identity
+for *every* encryption without warning, which is not what you want if you are
+using, e.g., remailers.
+Also, use of Bcc gives away your identity for *every* encryption without
+warning, which is a bug, see:
+https://debbugs.gnu.org/cgi/bugreport.cgi?bug=18718"
+  :group 'mime-security
+  :type '(choice (const :tag "None" nil)
+                 (const :tag "From address" t)
+                 (repeat (string :tag "Key ID"))))
+
+(define-obsolete-variable-alias
+  'mml-smime-encrypt-to-self 'mml-secure-smime-encrypt-to-self "25.1")
+(defcustom mml-secure-smime-encrypt-to-self nil
+  "List of own key ID(s) or t; determines additional recipients with S/MIME.
+If t, also encrypt to key for message sender; if list, encrypt to those keys.
+With this variable, you can ensure that you can decrypt your own messages.
+Alternatives to this variable include Bcc'ing the message to yourself or
+using the encrypt-to option in gpgsm.conf (see man gpgsm(1)).
+Note that this variable and the encrypt-to option give away your identity
+for *every* encryption without warning, which is not what you want if you are
+using, e.g., remailers.
+Also, use of Bcc gives away your identity for *every* encryption without
+warning, which is a bug, see:
+https://debbugs.gnu.org/cgi/bugreport.cgi?bug=18718"
+  :group 'mime-security
+  :type '(choice (const :tag "None" nil)
+                 (const :tag "From address" t)
+                 (repeat (string :tag "Key ID"))))
+
+(define-obsolete-variable-alias
+  'mml2015-sign-with-sender 'mml-secure-openpgp-sign-with-sender "25.1")
+;mml1991-sign-with-sender did never exist.
+(defcustom mml-secure-openpgp-sign-with-sender nil
+  "If t, use message sender to find an OpenPGP key to sign with."
+  :group 'mime-security
+  :type 'boolean)
+
+(define-obsolete-variable-alias
+  'mml-smime-sign-with-sender 'mml-secure-smime-sign-with-sender "25.1")
+(defcustom mml-secure-smime-sign-with-sender nil
+  "If t, use message sender to find an S/MIME key to sign with."
+  :group 'mime-security
+  :type 'boolean)
+
+(define-obsolete-variable-alias
+  'mml2015-always-trust 'mml-secure-openpgp-always-trust "25.1")
+;mml1991-always-trust did never exist.
+(defcustom mml-secure-openpgp-always-trust t
+  "If t, skip key validation of GnuPG on encryption."
+  :group 'mime-security
+  :type 'boolean)
+
+(defcustom mml-secure-fail-when-key-problem nil
+  "If t, raise an error if some key is missing or several keys exist.
+Otherwise, ask the user."
+  :version "25.1"
+  :group 'mime-security
+  :type 'boolean)
+
+(defcustom mml-secure-key-preferences
+  '((OpenPGP (sign) (encrypt)) (CMS (sign) (encrypt)))
+  "Protocol- and usage-specific fingerprints of preferred keys.
+This variable is only relevant if a recipient owns multiple key pairs (for
+encryption) or you own multiple key pairs (for signing).  In such cases,
+you will be asked which key(s) should be used, and your choice can be
+customized in this variable."
+  :version "25.1"
+  :group 'mime-security
+  :type '(alist :key-type (symbol :tag "Protocol") :value-type
+                (alist :key-type (symbol :tag "Usage") :value-type
+                       (alist :key-type (string :tag "Name") :value-type
+                              (repeat (string :tag "Fingerprint"))))))
+
+(defun mml-secure-cust-usage-lookup (context usage)
+  "Return preferences for CONTEXT and USAGE."
+  (let* ((protocol (epg-context-protocol context))
+         (protocol-prefs (cdr (assoc protocol mml-secure-key-preferences))))
+    (assoc usage protocol-prefs)))
+
+(defun mml-secure-cust-fpr-lookup (context usage name)
+  "Return fingerprints of preferred keys for CONTEXT, USAGE, and NAME."
+  (let* ((usage-prefs (mml-secure-cust-usage-lookup context usage))
+         (fprs (assoc name (cdr usage-prefs))))
+    (when fprs
+      (cdr fprs))))
+
+(defun mml-secure-cust-record-keys (context usage name keys &optional save)
+  "For CONTEXT, USAGE, and NAME record fingerprint(s) of KEYS.
+If optional SAVE is not nil, save customized fingerprints.
+Return keys."
+  (assert keys)
+  (let* ((usage-prefs (mml-secure-cust-usage-lookup context usage))
+         (curr-fprs (cdr (assoc name (cdr usage-prefs))))
+         (key-fprs (mapcar 'mml-secure-fingerprint keys))
+         (new-fprs (gnus-union curr-fprs key-fprs :test 'equal)))
+    (if curr-fprs
+        (setcdr (assoc name (cdr usage-prefs)) new-fprs)
+      (setcdr usage-prefs (cons (cons name new-fprs) (cdr usage-prefs))))
+    (when save
+        (customize-save-variable
+         'mml-secure-key-preferences mml-secure-key-preferences))
+    keys))
+
+(defun mml-secure-cust-remove-keys (context usage name)
+  "Remove keys for CONTEXT, USAGE, and NAME.
+Return t if a customization for NAME was present (and has been removed)."
+  (let* ((usage-prefs (mml-secure-cust-usage-lookup context usage))
+         (current (assoc name usage-prefs)))
+    (when current
+      (setcdr usage-prefs (remove current (cdr usage-prefs)))
+      t)))
+
+(defvar mml-secure-secret-key-id-list nil)
+
+(defun mml-secure-add-secret-key-id (key-id)
+  "Record KEY-ID in list of secret keys."
+  (add-to-list 'mml-secure-secret-key-id-list key-id))
+
+(defun mml-secure-clear-secret-key-id-list ()
+  "Remove passwords from cache and clear list of secret keys."
+  ;; Loosely based on code inside mml2015-epg-encrypt,
+  ;; mml2015-epg-clear-decrypt, and mml2015-epg-decrypt
+  (dolist (key-id mml-secure-secret-key-id-list nil)
+    (password-cache-remove key-id))
+  (setq mml-secure-secret-key-id-list nil))
+
+(defvar mml1991-cache-passphrase)
+(defvar mml1991-passphrase-cache-expiry)
+
+(defun mml-secure-cache-passphrase-p (protocol)
+  "Return t if OpenPGP or S/MIME passphrases should be cached for PROTOCOL.
+Passphrase caching in Emacs is NOT recommended.  Use gpg-agent instead."
+  (or (and (eq 'OpenPGP protocol)
+           (or mml-secure-cache-passphrase
+               (and (boundp 'mml2015-cache-passphrase)
+                    mml2015-cache-passphrase)
+               (and (boundp 'mml1991-cache-passphrase)
+                    mml1991-cache-passphrase)))
+      (and (eq 'CMS protocol)
+           (or mml-secure-cache-passphrase
+               (and (boundp 'mml-smime-cache-passphrase)
+                    mml-smime-cache-passphrase)))))
+
+(defun mml-secure-cache-expiry-interval (protocol)
+  "Return time in seconds to cache passphrases for PROTOCOL.
+Passphrase caching in Emacs is NOT recommended.  Use gpg-agent instead."
+  (or (and (eq 'OpenPGP protocol)
+           (or (and (boundp 'mml2015-passphrase-cache-expiry)
+                    mml2015-passphrase-cache-expiry)
+               (and (boundp 'mml1991-passphrase-cache-expiry)
+                    mml1991-passphrase-cache-expiry)
+               mml-secure-passphrase-cache-expiry))
+      (and (eq 'CMS protocol)
+           (or (and (boundp 'mml-smime-passphrase-cache-expiry)
+                    mml-smime-passphrase-cache-expiry)
+               mml-secure-passphrase-cache-expiry))))
+
+(defun mml-secure-passphrase-callback (context key-id standard)
+  "Ask for passphrase in CONTEXT for KEY-ID for STANDARD.
+The passphrase is read and cached."
+  ;; Based on mml2015-epg-passphrase-callback.
+  (if (eq key-id 'SYM)
+      (epg-passphrase-callback-function context key-id nil)
+    (let* ((password-cache-key-id
+            (if (eq key-id 'PIN)
+                "PIN"
+               key-id))
+           (entry (assoc key-id epg-user-id-alist))
+           (passphrase
+            (password-read
+             (if (eq key-id 'PIN)
+                 "Passphrase for PIN: "
+               (if entry
+                   (format "Passphrase for %s %s: " key-id (cdr entry))
+                 (format "Passphrase for %s: " key-id)))
+             ;; TODO: With mml-smime.el, password-cache-key-id is not passed
+             ;; as argument to password-read.
+             ;; Is that on purpose?  If so, the following needs to be placed
+             ;; inside an if statement.
+             password-cache-key-id)))
+      (when passphrase
+        (let ((password-cache-expiry (mml-secure-cache-expiry-interval
+                                      (epg-context-protocol context))))
+          (password-cache-add password-cache-key-id passphrase))
+        (mml-secure-add-secret-key-id password-cache-key-id)
+        (copy-sequence passphrase)))))
+
+(defun mml-secure-check-user-id (key recipient)
+  "Check whether KEY has a non-revoked, non-expired UID for RECIPIENT."
+  ;; Based on mml2015-epg-check-user-id.
+  (let ((uids (epg-key-user-id-list key)))
+    (catch 'break
+      (dolist (uid uids nil)
+        (if (and (stringp (epg-user-id-string uid))
+                 (equal (car (mail-header-parse-address
+                              (epg-user-id-string uid)))
+                        (car (mail-header-parse-address
+                              recipient)))
+                 (not (memq (epg-user-id-validity uid)
+                            '(revoked expired))))
+            (throw 'break t))))))
+
+(defun mml-secure-secret-key-exists-p (context subkey)
+  "Return t if keyring for CONTEXT contains secret key for public SUBKEY."
+  (let* ((fpr (epg-sub-key-fingerprint subkey))
+         (candidates (epg-list-keys context fpr 'secret))
+         (candno (length candidates)))
+    ;; If two or more subkeys with the same fingerprint exist, something is
+    ;; terribly wrong.
+    (when (>= candno 2)
+      (error "Found %d secret keys with same fingerprint %s" candno fpr))
+    (= 1 candno)))
+
+(defun mml-secure-check-sub-key (context key usage &optional fingerprint)
+  "Check whether in CONTEXT the public KEY has a usable subkey for USAGE.
+This is the case if KEY is not disabled, and there is a subkey for
+USAGE that is neither revoked nor expired.  Additionally, if optional
+FINGERPRINT is present and if it is not the primary key's fingerprint, then
+the returned subkey must have that FINGERPRINT.  FINGERPRINT must consist of
+hexadecimal digits only (no leading \"0x\" allowed).
+If USAGE is not `encrypt', then additionally an appropriate secret key must
+be present in the keyring."
+  ;; Based on mml2015-epg-check-sub-key, extended by
+  ;; - check for secret keys if usage is not 'encrypt and
+  ;; - check for new argument FINGERPRINT.
+  (let* ((subkeys (epg-key-sub-key-list key))
+         (primary (car subkeys))
+         (fpr (epg-sub-key-fingerprint primary)))
+    ;; The primary key will be marked as disabled, when the entire
+    ;; key is disabled (see 12 Field, Format of colon listings, in
+    ;; gnupg/doc/DETAILS)
+    (unless (memq 'disabled (epg-sub-key-capability primary))
+      (catch 'break
+        (dolist (subkey subkeys nil)
+          (if (and (memq usage (epg-sub-key-capability subkey))
+                   (not (memq (epg-sub-key-validity subkey)
+                              '(revoked expired)))
+                   (or (eq 'encrypt usage) ; Encryption works with public key.
+                       ;; In contrast, signing requires secret key.
+                       (mml-secure-secret-key-exists-p context subkey))
+                   (or (not fingerprint)
+                       (gnus-string-match-p (concat fingerprint "$") fpr)
+                       (gnus-string-match-p (concat fingerprint "$")
+                                            (epg-sub-key-fingerprint subkey))))
+              (throw 'break t)))))))
+
+(defun mml-secure-find-usable-keys (context name usage &optional justone)
+  "In CONTEXT return a list of keys for NAME and USAGE.
+If USAGE is `encrypt' public keys are returned, otherwise secret ones.
+Only non-revoked and non-expired keys are returned whose primary key is
+not disabled.
+NAME can be an e-mail address or a key ID.
+If NAME just consists of hexadecimal digits (possibly prefixed by \"0x\"), it
+is treated as key ID for which at most one key must exist in the keyring.
+Otherwise, NAME is treated as user ID, for which no keys are returned if it
+is expired or revoked.
+If optional JUSTONE is not nil, return the first key instead of a list."
+  (let* ((keys (epg-list-keys context name))
+         (iskeyid (string-match "\\(0x\\)?\\([0-9a-fA-F]\\{8,\\}\\)" name))
+         (fingerprint (match-string 2 name))
+         result)
+    (when (and iskeyid (>= (length keys) 2))
+      (error
+       "Name %s (for %s) looks like a key ID but multiple keys found"
+       name usage))
+    (catch 'break
+      (dolist (key keys result)
+        (if (and (or iskeyid
+                     (mml-secure-check-user-id key name))
+                 (mml-secure-check-sub-key context key usage fingerprint))
+            (if justone
+                (throw 'break key)
+              (push key result)))))))
+
+(defun mml-secure-select-preferred-keys (context names usage)
+  "Return list of preferred keys in CONTEXT for NAMES and USAGE.
+This inspects the keyrings to find keys for each name in NAMES.  If several
+keys are found for a name, `mml-secure-select-keys' is used to look for
+customized preferences or have the user select preferable ones.
+When `mml-secure-fail-when-key-problem' is t, fail with an error in
+case of missing, outdated, or multiple keys."
+  ;; Loosely based on code appearing inside mml2015-epg-sign and
+  ;; mml2015-epg-encrypt.
+  (apply
+   #'nconc
+   (mapcar
+    (lambda (name)
+      (let* ((keys (mml-secure-find-usable-keys context name usage))
+             (keyno (length keys)))
+        (cond ((= 0 keyno)
+               (when (or mml-secure-fail-when-key-problem
+                         (not (y-or-n-p
+                               (format "No %s key for %s; skip it? "
+                                       usage name))))
+                 (error "No %s key for %s" usage name)))
+              ((= 1 keyno) keys)
+              (t (mml-secure-select-keys context name keys usage)))))
+    names)))
+
+(defun mml-secure-fingerprint (key)
+  "Return fingerprint for public KEY."
+  (epg-sub-key-fingerprint (car (epg-key-sub-key-list key))))
+
+(defun mml-secure-filter-keys (keys fprs)
+  "Filter KEYS to subset with fingerprints in FPRS."
+  (when keys
+    (if (member (mml-secure-fingerprint (car keys)) fprs)
+        (cons (car keys) (mml-secure-filter-keys (cdr keys) fprs))
+      (mml-secure-filter-keys (cdr keys) fprs))))
+
+(defun mml-secure-normalize-cust-name (name)
+  "Normalize NAME to be used for customization.
+Currently, remove ankle brackets."
+  (if (string-match "^<\\(.*\\)>$" name)
+      (match-string 1 name)
+    name))
+
+(defun mml-secure-select-keys (context name keys usage)
+  "In CONTEXT for NAME select among KEYS for USAGE.
+KEYS should be a list with multiple entries.
+NAME is normalized first as customized keys are inspected.
+When `mml-secure-fail-when-key-problem' is t, fail with an error in case of
+outdated or multiple keys."
+  (let* ((nname (mml-secure-normalize-cust-name name))
+         (fprs (mml-secure-cust-fpr-lookup context usage nname))
+         (usable-fprs (mapcar 'mml-secure-fingerprint keys)))
+    (if fprs
+        (if (gnus-subsetp fprs usable-fprs)
+            (mml-secure-filter-keys keys fprs)
+          (mml-secure-cust-remove-keys context usage nname)
+          (let ((diff (gnus-setdiff fprs usable-fprs)))
+            (if mml-secure-fail-when-key-problem
+                (error "Customization of %s keys for %s outdated" usage nname)
+              (mml-secure-select-keys-1
+               context nname keys usage (format "\
+Customized keys
+ (%s)
+for %s not available any more.
+Select anew.  "
+                                               diff nname)))))
+      (if mml-secure-fail-when-key-problem
+          (error "Multiple %s keys for %s" usage nname)
+        (mml-secure-select-keys-1
+         context nname keys usage (format "\
+Multiple %s keys for:
+ %s
+Select preferred one(s).  "
+                                         usage nname))))))
+
+(defun mml-secure-select-keys-1 (context name keys usage message)
+  "In CONTEXT for NAME let user select among KEYS for USAGE, showing MESSAGE.
+Return selected keys."
+  (let* ((selected (epa--select-keys message keys))
+         (selno (length selected))
+         ;; TODO: y-or-n-p does not always resize the echo area but may
+         ;; truncate the message.  Why?  The following does not help.
+         ;; yes-or-no-p shows full message, though.
+         (message-truncate-lines nil))
+    (if selected
+        (if (y-or-n-p
+             (format "%d %s key(s) selected.  Store for %s? "
+                     selno usage name))
+            (mml-secure-cust-record-keys context usage name selected 'save)
+          selected)
+      (unless (y-or-n-p
+               (format "No %s key for %s; skip it? " usage name))
+        (error "No %s key for %s" usage name)))))
+
+(defun mml-secure-signer-names (protocol sender)
+  "Determine signer names for PROTOCOL and message from SENDER.
+Returned names may be e-mail addresses or key IDs and are determined based
+on `mml-secure-openpgp-signers' and `mml-secure-openpgp-sign-with-sender' with
+OpenPGP or `mml-secure-smime-signers' and `mml-secure-smime-sign-with-sender'
+with S/MIME."
+  (if (eq 'OpenPGP protocol)
+      (append mml-secure-openpgp-signers
+              (if (and mml-secure-openpgp-sign-with-sender sender)
+                  (list (concat "<" sender ">"))))
+    (append mml-secure-smime-signers
+            (if (and mml-secure-smime-sign-with-sender sender)
+                (list (concat "<" sender ">"))))))
+
+(defun mml-secure-signers (context signer-names)
+  "Determine signing keys in CONTEXT from SIGNER-NAMES.
+If `mm-sign-option' is `guided', the user is asked to choose.
+Otherwise, `mml-secure-select-preferred-keys' is used."
+  ;; Based on code appearing inside mml2015-epg-sign and
+  ;; mml2015-epg-encrypt.
+  (if (eq mm-sign-option 'guided)
+      (epa-select-keys context "\
+Select keys for signing.
+If no one is selected, default secret key is used.  "
+                       signer-names t)
+    (mml-secure-select-preferred-keys context signer-names 'sign)))
+
+(defun mml-secure-self-recipients (protocol sender)
+  "Determine additional recipients based on encrypt-to-self variables.
+PROTOCOL specifies OpenPGP or S/MIME for a message from SENDER."
+  (let ((encrypt-to-self
+         (if (eq 'OpenPGP protocol)
+             mml-secure-openpgp-encrypt-to-self
+           mml-secure-smime-encrypt-to-self)))
+    (when encrypt-to-self
+      (if (listp encrypt-to-self)
+          encrypt-to-self
+        (list sender)))))
+
+(defun mml-secure-recipients (protocol context config sender)
+  "Determine encryption recipients.
+PROTOCOL specifies OpenPGP or S/MIME with matching CONTEXT and CONFIG
+for a message from SENDER."
+  ;; Based on code appearing inside mml2015-epg-encrypt.
+  (let ((recipients
+         (apply #'nconc
+                (mapcar
+                 (lambda (recipient)
+                   (or (epg-expand-group config recipient)
+                       (list (concat "<" recipient ">"))))
+                 (split-string
+                  (or (message-options-get 'message-recipients)
+                      (message-options-set 'message-recipients
+                                           (read-string "Recipients: ")))
+                  "[ \f\t\n\r\v,]+")))))
+    (nconc recipients (mml-secure-self-recipients protocol sender))
+    (if (eq mm-encrypt-option 'guided)
+        (setq recipients
+              (epa-select-keys context "\
+Select recipients for encryption.
+If no one is selected, symmetric encryption will be performed.  "
+                               recipients))
+      (setq recipients
+            (mml-secure-select-preferred-keys context recipients 'encrypt))
+      (unless recipients
+        (error "No recipient specified")))
+    recipients))
+
+(defun mml-secure-epg-encrypt (protocol cont &optional sign)
+  ;; Based on code appearing inside mml2015-epg-encrypt.
+  (let* ((context (epg-make-context protocol))
+         (config (epg-configuration))
+         (sender (message-options-get 'message-sender))
+         (recipients (mml-secure-recipients protocol context config sender))
+         (signer-names (mml-secure-signer-names protocol sender))
+         cipher signers)
+    (when sign
+      (setq signers (mml-secure-signers context signer-names))
+      (epg-context-set-signers context signers))
+    (when (eq 'OpenPGP protocol)
+      (epg-context-set-armor context t)
+      (epg-context-set-textmode context t))
+    (when (mml-secure-cache-passphrase-p protocol)
+      (epg-context-set-passphrase-callback
+       context
+       (cons 'mml-secure-passphrase-callback protocol)))
+    (condition-case error
+        (setq cipher
+              (if (eq 'OpenPGP protocol)
+                  (epg-encrypt-string context (buffer-string) recipients sign
+                                      mml-secure-openpgp-always-trust)
+                (epg-encrypt-string context (buffer-string) recipients))
+              mml-secure-secret-key-id-list nil)
+      (error
+       (mml-secure-clear-secret-key-id-list)
+       (signal (car error) (cdr error))))
+    cipher))
+
+(defun mml-secure-epg-sign (protocol mode)
+  ;; Based on code appearing inside mml2015-epg-sign.
+  (let* ((context (epg-make-context protocol))
+         (sender (message-options-get 'message-sender))
+         (signer-names (mml-secure-signer-names protocol sender))
+         (signers (mml-secure-signers context signer-names))
+         signature micalg)
+    (when (eq 'OpenPGP protocol)
+      (epg-context-set-armor context t)
+      (epg-context-set-textmode context t))
+    (epg-context-set-signers context signers)
+    (when (mml-secure-cache-passphrase-p protocol)
+      (epg-context-set-passphrase-callback
+       context
+       (cons 'mml-secure-passphrase-callback protocol)))
+    (condition-case error
+        (setq signature
+              (if (eq 'OpenPGP protocol)
+                  (epg-sign-string context (buffer-string) mode)
+                (epg-sign-string context
+                                 (mm-replace-in-string (buffer-string)
+                                                       "\n" "\r\n") t))
+              mml-secure-secret-key-id-list nil)
+      (error
+       (mml-secure-clear-secret-key-id-list)
+       (signal (car error) (cdr error))))
+    (if (epg-context-result-for context 'sign)
+        (setq micalg (epg-new-signature-digest-algorithm
+                      (car (epg-context-result-for context 'sign)))))
+    (cons signature micalg)))
+
 (provide 'mml-sec)
 
 ;;; mml-sec.el ends here
diff --git a/lisp/gnus/mml-smime.el b/lisp/gnus/mml-smime.el
index b19c9e89ba9..2d8f25c5003 100644
--- a/lisp/gnus/mml-smime.el
+++ b/lisp/gnus/mml-smime.el
@@ -32,9 +32,17 @@
 (autoload 'message-narrow-to-headers "message")
 (autoload 'message-fetch-field "message")
 
+;; Prefer epg over openssl if it is available as epg uses GnuPG's gpgsm,
+;; which features full-fledged certificate management, while openssl requires
+;; major manual efforts for certificate revocation and expiry and has bugs
+;; as documented under man smime(1).
+(ignore-errors (require 'epg))
+
 (defcustom mml-smime-use (if (featurep 'epg) 'epg 'openssl)
-  "Whether to use OpenSSL or EPG to decrypt S/MIME messages.
-Defaults to EPG if it's loaded."
+  "Whether to use OpenSSL or EasyPG (EPG) to handle S/MIME messages.
+Defaults to EPG if it's available.
+If you think about using OpenSSL, please read the BUGS section in the manual
+for the `smime' command coming with OpenSSL first.  EasyPG is recommended."
   :group 'mime-security
   :type '(choice (const :tag "EPG" epg)
                  (const :tag "OpenSSL" openssl)))
@@ -57,6 +65,9 @@ Defaults to EPG if it's loaded."
   "If t, cache passphrase."
   :group 'mime-security
   :type 'boolean)
+(make-obsolete-variable 'mml-smime-cache-passphrase
+                        'mml-secure-cache-passphrase
+                        "25.1")
 
 (defcustom mml-smime-passphrase-cache-expiry mml-secure-passphrase-cache-expiry
   "How many seconds the passphrase is cached.
@@ -64,6 +75,9 @@ Whether the passphrase is cached at all is controlled by
 `mml-smime-cache-passphrase'."
   :group 'mime-security
   :type 'integer)
+(make-obsolete-variable 'mml-smime-passphrase-cache-expiry
+                        'mml-secure-passphrase-cache-expiry
+                        "25.1")
 
 (defcustom mml-smime-signers nil
   "A list of your own key ID which will be used to sign a message."
@@ -202,7 +216,7 @@ Whether the passphrase is cached at all is controlled by
                                         "")))))
           (if (setq cert (smime-cert-by-dns who))
               (setq result (list 'certfile (buffer-name cert)))
-            (setq bad (gnus-format-message "`%s' not found. " who))))
+            (setq bad (format "`%s' not found. " who))))
       (quit))
     result))
 
@@ -221,7 +235,7 @@ Whether the passphrase is cached at all is controlled by
                                         "")))))
           (if (setq cert (smime-cert-by-ldap who))
               (setq result (list 'certfile (buffer-name cert)))
-            (setq bad (gnus-format-message "`%s' not found. " who))))
+            (setq bad (format "`%s' not found. " who))))
       (quit))
     result))
 
@@ -317,83 +331,29 @@ Whether the passphrase is cached at all is controlled by
 (defvar inhibit-redisplay)
 (defvar password-cache-expiry)
 
-(autoload 'epg-make-context "epg")
-(autoload 'epg-passphrase-callback-function "epg")
-(declare-function epg-context-set-signers "epg" (context signers))
-(declare-function epg-context-result-for "epg" (context name))
-(declare-function epg-new-signature-digest-algorithm "epg" (cl-x) t)
-(declare-function epg-verify-result-to-string "epg" (verify-result))
-(declare-function epg-list-keys "epg" (context &optional name mode))
-(declare-function epg-verify-string "epg"
-                  (context signature &optional signed-text))
-(declare-function epg-sign-string "epg" (context plain &optional mode))
-(declare-function epg-encrypt-string "epg"
-                  (context plain recipients &optional sign always-trust))
-(declare-function epg-context-set-passphrase-callback "epg"
-                  (context passphrase-callback))
-(declare-function epg-sub-key-fingerprint "epg" (cl-x) t)
-(declare-function epg-configuration "epg-config" ())
-(declare-function epg-expand-group "epg-config" (config group))
-(declare-function epa-select-keys "epa"
-                  (context prompt &optional names secret))
-
-(defvar mml-smime-epg-secret-key-id-list nil)
-
-(defun mml-smime-epg-passphrase-callback (context key-id ignore)
-  (if (eq key-id 'SYM)
-      (epg-passphrase-callback-function context key-id nil)
-    (let* (entry
-           (passphrase
-            (password-read
-             (if (eq key-id 'PIN)
-                 "Passphrase for PIN: "
-               (if (setq entry (assoc key-id epg-user-id-alist))
-                   (format "Passphrase for %s %s: " key-id (cdr entry))
-                 (format "Passphrase for %s: " key-id)))
-             (if (eq key-id 'PIN)
-                 "PIN"
-               key-id))))
-      (when passphrase
-        (let ((password-cache-expiry mml-smime-passphrase-cache-expiry))
-          (password-cache-add key-id passphrase))
-        (setq mml-smime-epg-secret-key-id-list
-              (cons key-id mml-smime-epg-secret-key-id-list))
-        (copy-sequence passphrase)))))
+(eval-when-compile
+  (autoload 'epg-make-context "epg")
+  (autoload 'epg-context-set-armor "epg")
+  (autoload 'epg-context-set-signers "epg")
+  (autoload 'epg-context-result-for "epg")
+  (autoload 'epg-new-signature-digest-algorithm "epg")
+  (autoload 'epg-verify-result-to-string "epg")
+  (autoload 'epg-list-keys "epg")
+  (autoload 'epg-decrypt-string "epg")
+  (autoload 'epg-verify-string "epg")
+  (autoload 'epg-sign-string "epg")
+  (autoload 'epg-encrypt-string "epg")
+  (autoload 'epg-passphrase-callback-function "epg")
+  (autoload 'epg-context-set-passphrase-callback "epg")
+  (autoload 'epg-sub-key-fingerprint "epg")
+  (autoload 'epg-configuration "epg-config")
+  (autoload 'epg-expand-group "epg-config")
+  (autoload 'epa-select-keys "epa"))
 
 (declare-function epg-key-sub-key-list   "epg" (key) t)
 (declare-function epg-sub-key-capability "epg" (sub-key) t)
 (declare-function epg-sub-key-validity   "epg" (sub-key) t)
 
-(defun mml-smime-epg-find-usable-key (keys usage)
-  (catch 'found
-    (while keys
-      (let ((pointer (epg-key-sub-key-list (car keys))))
-        (while pointer
-          (if (and (memq usage (epg-sub-key-capability (car pointer)))
-                   (not (memq (epg-sub-key-validity (car pointer))
-                              '(revoked expired))))
-              (throw 'found (car keys)))
-          (setq pointer (cdr pointer))))
-      (setq keys (cdr keys)))))
-
-;; XXX: since gpg --list-secret-keys does not return validity of each
-;; key, `mml-smime-epg-find-usable-key' defined above is not enough for
-;; secret keys.  The function `mml-smime-epg-find-usable-secret-key'
-;; below looks at appropriate public keys to check usability.
-(defun mml-smime-epg-find-usable-secret-key (context name usage)
-  (let ((secret-keys (epg-list-keys context name t))
-        secret-key)
-    (while (and (not secret-key) secret-keys)
-      (if (mml-smime-epg-find-usable-key
-           (epg-list-keys context (epg-sub-key-fingerprint
-                                   (car (epg-key-sub-key-list
-                                         (car secret-keys)))))
-           usage)
-          (setq secret-key (car secret-keys)
-                secret-keys nil)
-        (setq secret-keys (cdr secret-keys))))
-    secret-key))
-
 (autoload 'mml-compute-boundary "mml")
 
 ;; We require mm-decode, which requires mm-bodies, which autoloads
@@ -401,146 +361,37 @@ Whether the passphrase is cached at all is controlled by
 (declare-function message-options-set "message" (symbol value))
 
 (defun mml-smime-epg-sign (cont)
-  (let* ((inhibit-redisplay t)
-         (context (epg-make-context 'CMS))
-         (boundary (mml-compute-boundary cont))
-         (sender (message-options-get 'message-sender))
-         (signer-names (or mml-smime-signers
-                           (if (and mml-smime-sign-with-sender sender)
-                               (list (concat "<" sender ">")))))
-         signer-key
-         (signers
-          (or (message-options-get 'mml-smime-epg-signers)
-              (message-options-set
-               'mml-smime-epg-signers
-               (if (eq mm-sign-option 'guided)
-                   (epa-select-keys context "\
-Select keys for signing.
-If no one is selected, default secret key is used.  "
-                                    signer-names
-                                    t)
-                 (if (or sender mml-smime-signers)
-                     (delq nil
-                           (mapcar
-                            (lambda (signer)
-                              (setq signer-key
-                                    (mml-smime-epg-find-usable-secret-key
-                                     context signer 'sign))
-                              (unless (or signer-key
-                                          (y-or-n-p
-                                           (format
-                                            "No secret key for %s; skip it? "
-                                            signer)))
-                                (error "No secret key for %s" signer))
-                              signer-key)
-                            signer-names)))))))
-         signature micalg)
-    (epg-context-set-signers context signers)
-    (if mml-smime-cache-passphrase
-        (epg-context-set-passphrase-callback
-         context
-         #'mml-smime-epg-passphrase-callback))
-    (condition-case error
-        (setq signature (epg-sign-string context
-                                         (mm-replace-in-string (buffer-string)
-                                                               "\n" "\r\n")
-                                         t)
-              mml-smime-epg-secret-key-id-list nil)
-      (error
-       (while mml-smime-epg-secret-key-id-list
-         (password-cache-remove (car mml-smime-epg-secret-key-id-list))
-         (setq mml-smime-epg-secret-key-id-list
-               (cdr mml-smime-epg-secret-key-id-list)))
-       (signal (car error) (cdr error))))
-    (if (epg-context-result-for context 'sign)
-        (setq micalg (epg-new-signature-digest-algorithm
-                      (car (epg-context-result-for context 'sign)))))
+  (let ((inhibit-redisplay t)
+        (boundary (mml-compute-boundary cont)))
     (goto-char (point-min))
-    (insert (format "Content-Type: multipart/signed; boundary=\"%s\";\n"
-                    boundary))
-    (if micalg
-        (insert (format "\tmicalg=%s; "
-                        (downcase
-                         (cdr (assq micalg
-                                    epg-digest-algorithm-alist))))))
-    (insert "protocol=\"application/pkcs7-signature\"\n")
-    (insert (format "\n--%s\n" boundary))
-    (goto-char (point-max))
-    (insert (format "\n--%s\n" boundary))
-    (insert "Content-Type: application/pkcs7-signature; name=smime.p7s
+    (let* ((pair (mml-secure-epg-sign 'CMS cont))
+           (signature (car pair))
+           (micalg (cdr pair)))
+      (insert (format "Content-Type: multipart/signed; boundary=\"%s\";\n"
+                      boundary))
+      (if micalg
+          (insert (format "\tmicalg=%s; "
+                          (downcase
+                           (cdr (assq micalg
+                                      epg-digest-algorithm-alist))))))
+      (insert "protocol=\"application/pkcs7-signature\"\n")
+      (insert (format "\n--%s\n" boundary))
+      (goto-char (point-max))
+      (insert (format "\n--%s\n" boundary))
+      (insert "Content-Type: application/pkcs7-signature; name=smime.p7s
 Content-Transfer-Encoding: base64
 Content-Disposition: attachment; filename=smime.p7s
 
 ")
-    (insert (base64-encode-string signature) "\n")
-    (goto-char (point-max))
-    (insert (format "--%s--\n" boundary))
-    (goto-char (point-max))))
+      (insert (base64-encode-string signature) "\n")
+      (goto-char (point-max))
+      (insert (format "--%s--\n" boundary))
+      (goto-char (point-max)))))
 
 (defun mml-smime-epg-encrypt (cont)
   (let* ((inhibit-redisplay t)
-         (context (epg-make-context 'CMS))
-         (config (epg-configuration))
-         (recipients (message-options-get 'mml-smime-epg-recipients))
-         cipher signers
-         (sender (message-options-get 'message-sender))
-         (signer-names (or mml-smime-signers
-                           (if (and mml-smime-sign-with-sender sender)
-                               (list (concat "<" sender ">")))))
          (boundary (mml-compute-boundary cont))
-         recipient-key)
-    (unless recipients
-      (setq recipients
-            (apply #'nconc
-                   (mapcar
-                    (lambda (recipient)
-                      (or (epg-expand-group config recipient)
-                          (list recipient)))
-                    (split-string
-                     (or (message-options-get 'message-recipients)
-                         (message-options-set 'message-recipients
-                                              (read-string "Recipients: ")))
-                     "[ \f\t\n\r\v,]+"))))
-      (when mml-smime-encrypt-to-self
-        (unless signer-names
-          (error "Neither message sender nor mml-smime-signers are set"))
-        (setq recipients (nconc recipients signer-names)))
-      (if (eq mm-encrypt-option 'guided)
-          (setq recipients
-                (epa-select-keys context "\
-Select recipients for encryption.
-If no one is selected, symmetric encryption will be performed.  "
-                                 recipients))
-        (setq recipients
-              (mapcar
-               (lambda (recipient)
-                 (setq recipient-key (mml-smime-epg-find-usable-key
-                                      (epg-list-keys context recipient)
-                                      'encrypt))
-                 (unless (or recipient-key
-                             (y-or-n-p
-                              (format "No public key for %s; skip it? "
-                                      recipient)))
-                   (error "No public key for %s" recipient))
-                 recipient-key)
-               recipients))
-        (unless recipients
-          (error "No recipient specified")))
-      (message-options-set 'mml-smime-epg-recipients recipients))
-    (if mml-smime-cache-passphrase
-        (epg-context-set-passphrase-callback
-         context
-         #'mml-smime-epg-passphrase-callback))
-    (condition-case error
-        (setq cipher
-              (epg-encrypt-string context (buffer-string) recipients)
-              mml-smime-epg-secret-key-id-list nil)
-      (error
-       (while mml-smime-epg-secret-key-id-list
-         (password-cache-remove (car mml-smime-epg-secret-key-id-list))
-         (setq mml-smime-epg-secret-key-id-list
-               (cdr mml-smime-epg-secret-key-id-list)))
-       (signal (car error) (cdr error))))
+         (cipher (mml-secure-epg-encrypt 'CMS cont)))
     (delete-region (point-min) (point-max))
     (goto-char (point-min))
     (insert "\
diff --git a/lisp/gnus/mml1991.el b/lisp/gnus/mml1991.el
index 6469636451f..bb5c940f173 100644
--- a/lisp/gnus/mml1991.el
+++ b/lisp/gnus/mml1991.el
@@ -63,11 +63,17 @@
 
 (defvar mml1991-cache-passphrase mml-secure-cache-passphrase
   "If t, cache passphrase.")
+(make-obsolete-variable 'mml1991-cache-passphrase
+                        'mml-secure-cache-passphrase
+                        "25.1")
 
 (defvar mml1991-passphrase-cache-expiry mml-secure-passphrase-cache-expiry
   "How many seconds the passphrase is cached.
 Whether the passphrase is cached at all is controlled by
 `mml1991-cache-passphrase'.")
+(make-obsolete-variable 'mml1991-passphrase-cache-expiry
+                        'mml-secure-passphrase-cache-expiry
+                        "25.1")
 
 (defvar mml1991-signers nil
   "A list of your own key ID which will be used to sign a message.")
@@ -75,6 +81,7 @@ Whether the passphrase is cached at all is controlled by
 (defvar mml1991-encrypt-to-self nil
   "If t, add your own key ID to recipient list when encryption.")
 
+
 ;;; mailcrypt wrapper
 
 (autoload 'mc-sign-generic "mc-toplev")
@@ -255,91 +262,9 @@ Whether the passphrase is cached at all is controlled by
 (autoload 'epg-configuration "epg-config")
 (autoload 'epg-expand-group "epg-config")
 
-(defvar mml1991-epg-secret-key-id-list nil)
-
-(defun mml1991-epg-passphrase-callback (context key-id ignore)
-  (if (eq key-id 'SYM)
-      (epg-passphrase-callback-function context key-id nil)
-    (let* ((entry (assoc key-id epg-user-id-alist))
-           (passphrase
-            (password-read
-             (format "GnuPG passphrase for %s: "
-                     (if entry
-                         (cdr entry)
-                       key-id))
-             (if (eq key-id 'PIN)
-                 "PIN"
-               key-id))))
-      (when passphrase
-        (let ((password-cache-expiry mml1991-passphrase-cache-expiry))
-          (password-cache-add key-id passphrase))
-        (setq mml1991-epg-secret-key-id-list
-              (cons key-id mml1991-epg-secret-key-id-list))
-        (copy-sequence passphrase)))))
-
-(defun mml1991-epg-find-usable-key (keys usage)
-  (catch 'found
-    (while keys
-      (let ((pointer (epg-key-sub-key-list (car keys))))
-        ;; The primary key will be marked as disabled, when the entire
-        ;; key is disabled (see 12 Field, Format of colon listings, in
-        ;; gnupg/doc/DETAILS)
-        (unless (memq 'disabled (epg-sub-key-capability (car pointer)))
-          (while pointer
-            (if (and (memq usage (epg-sub-key-capability (car pointer)))
-                     (not (memq (epg-sub-key-validity (car pointer))
-                                '(revoked expired))))
-                (throw 'found (car keys)))
-            (setq pointer (cdr pointer)))))
-      (setq keys (cdr keys)))))
-
-;; XXX: since gpg --list-secret-keys does not return validity of each
-;; key, `mml1991-epg-find-usable-key' defined above is not enough for
-;; secret keys.  The function `mml1991-epg-find-usable-secret-key'
-;; below looks at appropriate public keys to check usability.
-(defun mml1991-epg-find-usable-secret-key (context name usage)
-  (let ((secret-keys (epg-list-keys context name t))
-        secret-key)
-    (while (and (not secret-key) secret-keys)
-      (if (mml1991-epg-find-usable-key
-           (epg-list-keys context (epg-sub-key-fingerprint
-                                   (car (epg-key-sub-key-list
-                                         (car secret-keys)))))
-           usage)
-          (setq secret-key (car secret-keys)
-                secret-keys nil)
-        (setq secret-keys (cdr secret-keys))))
-    secret-key))
-
 (defun mml1991-epg-sign (cont)
-  (let ((context (epg-make-context))
-        headers cte signer-key signers signature)
-    (if (eq mm-sign-option 'guided)
-        (setq signers (epa-select-keys context "Select keys for signing.
-If no one is selected, default secret key is used.  "
-                                       mml1991-signers t))
-      (if mml1991-signers
-          (setq signers (delq nil
-                              (mapcar
-                               (lambda (name)
-                                 (setq signer-key
-                                       (mml1991-epg-find-usable-secret-key
-                                        context name 'sign))
-                                 (unless (or signer-key
-                                             (y-or-n-p
-                                              (format
-                                               "No secret key for %s; skip it? "
-                                               name)))
-                                   (error "No secret key for %s" name))
-                                 signer-key)
-                               mml1991-signers)))))
-    (epg-context-set-armor context t)
-    (epg-context-set-textmode context t)
-    (epg-context-set-signers context signers)
-    (if mml1991-cache-passphrase
-        (epg-context-set-passphrase-callback
-         context
-         #'mml1991-epg-passphrase-callback))
+  (let ((inhibit-redisplay t)
+        headers cte)
     ;; Don't sign headers.
     (goto-char (point-min))
     (when (re-search-forward "^$" nil t)
@@ -352,28 +277,21 @@ If no one is selected, default secret key is used.  "
       (when cte
         (setq cte (intern (downcase cte)))
         (mm-decode-content-transfer-encoding cte)))
-    (condition-case error
-        (setq signature (epg-sign-string context (buffer-string) 'clear)
-              mml1991-epg-secret-key-id-list nil)
-      (error
-       (while mml1991-epg-secret-key-id-list
-         (password-cache-remove (car mml1991-epg-secret-key-id-list))
-         (setq mml1991-epg-secret-key-id-list
-               (cdr mml1991-epg-secret-key-id-list)))
-       (signal (car error) (cdr error))))
-    (delete-region (point-min) (point-max))
-    (mm-with-unibyte-current-buffer
-      (insert signature)
-      (goto-char (point-min))
-      (while (re-search-forward "\r+$" nil t)
-        (replace-match "" t t))
-      (when cte
-        (mm-encode-content-transfer-encoding cte))
-      (goto-char (point-min))
-      (when headers
-        (insert headers))
-      (insert "\n"))
-    t))
+    (let* ((pair (mml-secure-epg-sign 'OpenPGP 'clear))
+           (signature (car pair)))
+      (delete-region (point-min) (point-max))
+      (mm-with-unibyte-current-buffer
+        (insert signature)
+        (goto-char (point-min))
+        (while (re-search-forward "\r+$" nil t)
+          (replace-match "" t t))
+        (when cte
+          (mm-encode-content-transfer-encoding cte))
+        (goto-char (point-min))
+        (when headers
+          (insert headers))
+        (insert "\n"))
+      t)))
 
 (defun mml1991-epg-encrypt (cont &optional sign)
   (goto-char (point-min))
@@ -386,78 +304,7 @@ If no one is selected, default secret key is used.  "
       (delete-region (point-min) (point))
       (when cte
         (mm-decode-content-transfer-encoding (intern (downcase cte))))))
-  (let ((context (epg-make-context))
-        (recipients
-         (if (message-options-get 'message-recipients)
-             (split-string
-              (message-options-get 'message-recipients)
-              "[ \f\t\n\r\v,]+")))
-        recipient-key signer-key cipher signers config)
-    (when mml1991-encrypt-to-self
-      (unless mml1991-signers
-        (error "mml1991-signers is not set"))
-      (setq recipients (nconc recipients mml1991-signers)))
-    ;; We should remove this check if epg-0.0.6 is released.
-    (if (and (condition-case nil
-                 (require 'epg-config)
-               (error))
-             (functionp #'epg-expand-group))
-        (setq config (epg-configuration)
-              recipients
-              (apply #'nconc
-                     (mapcar (lambda (recipient)
-                               (or (epg-expand-group config recipient)
-                                   (list recipient)))
-                             recipients))))
-    (if (eq mm-encrypt-option 'guided)
-        (setq recipients
-              (epa-select-keys context "Select recipients for encryption.
-If no one is selected, symmetric encryption will be performed.  "
-                               recipients))
-      (setq recipients
-            (delq nil (mapcar
-                       (lambda (name)
-                         (setq recipient-key (mml1991-epg-find-usable-key
-                                              (epg-list-keys context name)
-                                              'encrypt))
-                         (unless (or recipient-key
-                                   (y-or-n-p
-                                    (format "No public key for %s; skip it? "
-                                            name)))
-                           (error "No public key for %s" name))
-                         recipient-key)
-                       recipients)))
-      (unless recipients
-        (error "No recipient specified")))
-    (when sign
-      (if (eq mm-sign-option 'guided)
-          (setq signers (epa-select-keys context "Select keys for signing.
-If no one is selected, default secret key is used.  "
-                                         mml1991-signers t))
-        (if mml1991-signers
-            (setq signers (delq nil
-                                (mapcar
-                                 (lambda (name)
-                                   (mml1991-epg-find-usable-secret-key
-                                    context name 'sign))
-                                 mml1991-signers)))))
-      (epg-context-set-signers context signers))
-    (epg-context-set-armor context t)
-    (epg-context-set-textmode context t)
-    (if mml1991-cache-passphrase
-        (epg-context-set-passphrase-callback
-         context
-         #'mml1991-epg-passphrase-callback))
-    (condition-case error
-        (setq cipher
-              (epg-encrypt-string context (buffer-string) recipients sign)
-              mml1991-epg-secret-key-id-list nil)
-      (error
-       (while mml1991-epg-secret-key-id-list
-         (password-cache-remove (car mml1991-epg-secret-key-id-list))
-         (setq mml1991-epg-secret-key-id-list
-               (cdr mml1991-epg-secret-key-id-list)))
-       (signal (car error) (cdr error))))
+  (let ((cipher (mml-secure-epg-encrypt 'OpenPGP cont sign)))
     (delete-region (point-min) (point-max))
     (insert "\n" cipher))
   t)
diff --git a/lisp/gnus/mml2015.el b/lisp/gnus/mml2015.el
index 10ba126ae2b..e2e99771801 100644
--- a/lisp/gnus/mml2015.el
+++ b/lisp/gnus/mml2015.el
@@ -111,6 +111,9 @@ Valid packages include `epg', `pgg' and `mailcrypt'.")
   "If t, cache passphrase."
   :group 'mime-security
   :type 'boolean)
+(make-obsolete-variable 'mml2015-cache-passphrase
+                        'mml-secure-cache-passphrase
+                        "25.1")
 
 (defcustom mml2015-passphrase-cache-expiry mml-secure-passphrase-cache-expiry
   "How many seconds the passphrase is cached.
@@ -118,6 +121,9 @@ Whether the passphrase is cached at all is controlled by
 `mml2015-cache-passphrase'."
   :group 'mime-security
   :type 'integer)
+(make-obsolete-variable 'mml2015-passphrase-cache-expiry
+                        'mml-secure-passphrase-cache-expiry
+                        "25.1")
 
 (defcustom mml2015-signers nil
   "A list of your own key ID(s) which will be used to sign a message.
@@ -774,99 +780,6 @@ If set, it overrides the setting of `mml2015-sign-with-sender'."
 (autoload 'epg-expand-group "epg-config")
 (autoload 'epa-select-keys "epa")
 
-(defvar mml2015-epg-secret-key-id-list nil)
-
-(defun mml2015-epg-passphrase-callback (context key-id ignore)
-  (if (eq key-id 'SYM)
-      (epg-passphrase-callback-function context key-id nil)
-    (let* ((password-cache-key-id
-            (if (eq key-id 'PIN)
-                "PIN"
-               key-id))
-           entry
-           (passphrase
-            (password-read
-             (if (eq key-id 'PIN)
-                 "Passphrase for PIN: "
-               (if (setq entry (assoc key-id epg-user-id-alist))
-                   (format "Passphrase for %s %s: " key-id (cdr entry))
-                 (format "Passphrase for %s: " key-id)))
-             password-cache-key-id)))
-      (when passphrase
-        (let ((password-cache-expiry mml2015-passphrase-cache-expiry))
-          (password-cache-add password-cache-key-id passphrase))
-        (setq mml2015-epg-secret-key-id-list
-              (cons password-cache-key-id mml2015-epg-secret-key-id-list))
-        (copy-sequence passphrase)))))
-
-(defun mml2015-epg-check-user-id (key recipient)
-  (let ((pointer (epg-key-user-id-list key))
-        result)
-    (while pointer
-      (if (and (equal (car (mail-header-parse-address
-                            (epg-user-id-string (car pointer))))
-                      (car (mail-header-parse-address
-                            recipient)))
-               (not (memq (epg-user-id-validity (car pointer))
-                          '(revoked expired))))
-          (setq result t
-                pointer nil)
-        (setq pointer (cdr pointer))))
-    result))
-
-(defun mml2015-epg-check-sub-key (key usage)
-  (let ((pointer (epg-key-sub-key-list key))
-        result)
-    ;; The primary key will be marked as disabled, when the entire
-    ;; key is disabled (see 12 Field, Format of colon listings, in
-    ;; gnupg/doc/DETAILS)
-    (unless (memq 'disabled (epg-sub-key-capability (car pointer)))
-      (while pointer
-        (if (and (memq usage (epg-sub-key-capability (car pointer)))
-                 (not (memq (epg-sub-key-validity (car pointer))
-                            '(revoked expired))))
-            (setq result t
-                  pointer nil)
-          (setq pointer (cdr pointer)))))
-    result))
-
-(defun mml2015-epg-find-usable-key (context name usage
-                                            &optional name-is-key-id)
-  (let ((keys (epg-list-keys context name))
-        key)
-    (while keys
-      (if (and (or name-is-key-id
-                   ;; Non email user-id can be supplied through
-                   ;; mml2015-signers if mml2015-encrypt-to-self is set.
-                   ;; Treat it as valid, as it is user's intention.
-                   (not (string-match "\\`<" name))
-                   (mml2015-epg-check-user-id (car keys) name))
-               (mml2015-epg-check-sub-key (car keys) usage))
-          (setq key (car keys)
-                keys nil)
-        (setq keys (cdr keys))))
-    key))
-
-;; XXX: since gpg --list-secret-keys does not return validity of each
-;; key, `mml2015-epg-find-usable-key' defined above is not enough for
-;; secret keys.  The function `mml2015-epg-find-usable-secret-key'
-;; below looks at appropriate public keys to check usability.
-(defun mml2015-epg-find-usable-secret-key (context name usage)
-  (let ((secret-keys (epg-list-keys context name t))
-        secret-key)
-    (while (and (not secret-key) secret-keys)
-      (if (mml2015-epg-find-usable-key
-           context
-           (epg-sub-key-fingerprint
-            (car (epg-key-sub-key-list
-                  (car secret-keys))))
-           usage
-           t)
-          (setq secret-key (car secret-keys)
-                secret-keys nil)
-        (setq secret-keys (cdr secret-keys))))
-    secret-key))
-
 (autoload 'gnus-create-image "gnus-ems")
 
 (defun mml2015-epg-key-image (key-id)
@@ -921,18 +834,15 @@ If set, it overrides the setting of `mml2015-sign-with-sender'."
          mm-security-handle 'gnus-info "Corrupted")
         (throw 'error handle))
       (setq context (epg-make-context))
-      (if mml2015-cache-passphrase
+      (if (or mml2015-cache-passphrase mml-secure-cache-passphrase)
           (epg-context-set-passphrase-callback
            context
-           #'mml2015-epg-passphrase-callback))
+           (cons 'mml-secure-passphrase-callback 'OpenPGP)))
       (condition-case error
           (setq plain (epg-decrypt-string context (mm-get-part child))
-                mml2015-epg-secret-key-id-list nil)
+                mml-secure-secret-key-id-list nil)
         (error
-         (while mml2015-epg-secret-key-id-list
-           (password-cache-remove (car mml2015-epg-secret-key-id-list))
-           (setq mml2015-epg-secret-key-id-list
-                 (cdr mml2015-epg-secret-key-id-list)))
+         (mml-secure-clear-secret-key-id-list)
          (mm-set-handle-multipart-parameter
           mm-security-handle 'gnus-info "Failed")
          (if (eq (car error) 'quit)
@@ -968,18 +878,15 @@ If set, it overrides the setting of `mml2015-sign-with-sender'."
   (let ((inhibit-redisplay t)
         (context (epg-make-context))
         plain)
-    (if mml2015-cache-passphrase
+    (if (or mml2015-cache-passphrase mml-secure-cache-passphrase)
         (epg-context-set-passphrase-callback
          context
-         #'mml2015-epg-passphrase-callback))
+         (cons 'mml-secure-passphrase-callback 'OpenPGP)))
     (condition-case error
         (setq plain (epg-decrypt-string context (buffer-string))
-              mml2015-epg-secret-key-id-list nil)
+              mml-secure-secret-key-id-list nil)
       (error
-       (while mml2015-epg-secret-key-id-list
-         (password-cache-remove (car mml2015-epg-secret-key-id-list))
-         (setq mml2015-epg-secret-key-id-list
-               (cdr mml2015-epg-secret-key-id-list)))
+       (mml-secure-clear-secret-key-id-list)
        (mm-set-handle-multipart-parameter
         mm-security-handle 'gnus-info "Failed")
        (if (eq (car error) 'quit)
@@ -1065,176 +972,37 @@ If set, it overrides the setting of `mml2015-sign-with-sender'."
       (mml2015-extract-cleartext-signature))))
 
 (defun mml2015-epg-sign (cont)
-  (let* ((inhibit-redisplay t)
-         (context (epg-make-context))
-         (boundary (mml-compute-boundary cont))
-         (sender (message-options-get 'message-sender))
-         (signer-names (or mml2015-signers
-                           (if (and mml2015-sign-with-sender sender)
-                               (list (concat "<" sender ">")))))
-         signer-key
-         (signers
-          (or (message-options-get 'mml2015-epg-signers)
-              (message-options-set
-               'mml2015-epg-signers
-               (if (eq mm-sign-option 'guided)
-                   (epa-select-keys context "\
-Select keys for signing.
-If no one is selected, default secret key is used.  "
-                                    signer-names
-                                    t)
-                 (if (or sender mml2015-signers)
-                     (delq nil
-                           (mapcar
-                            (lambda (signer)
-                              (setq signer-key
-                                    (mml2015-epg-find-usable-secret-key
-                                     context signer 'sign))
-                              (unless (or signer-key
-                                          (y-or-n-p
-                                           (format
-                                            "No secret key for %s; skip it? "
-                                            signer)))
-                                (error "No secret key for %s" signer))
-                              signer-key)
-                            signer-names)))))))
-         signature micalg)
-    (epg-context-set-armor context t)
-    (epg-context-set-textmode context t)
-    (epg-context-set-signers context signers)
-    (if mml2015-cache-passphrase
-        (epg-context-set-passphrase-callback
-         context
-         #'mml2015-epg-passphrase-callback))
+  (let ((inhibit-redisplay t)
+        (boundary (mml-compute-boundary cont)))
     ;; Signed data must end with a newline (RFC 3156, 5).
     (goto-char (point-max))
     (unless (bolp)
       (insert "\n"))
-    (condition-case error
-        (setq signature (epg-sign-string context (buffer-string) t)
-              mml2015-epg-secret-key-id-list nil)
-      (error
-       (while mml2015-epg-secret-key-id-list
-         (password-cache-remove (car mml2015-epg-secret-key-id-list))
-         (setq mml2015-epg-secret-key-id-list
-               (cdr mml2015-epg-secret-key-id-list)))
-       (signal (car error) (cdr error))))
-    (if (epg-context-result-for context 'sign)
-        (setq micalg (epg-new-signature-digest-algorithm
-                      (car (epg-context-result-for context 'sign)))))
-    (goto-char (point-min))
-    (insert (format "Content-Type: multipart/signed; boundary=\"%s\";\n"
-                    boundary))
-    (if micalg
-        (insert (format "\tmicalg=pgp-%s; "
-                        (downcase
-                         (cdr (assq micalg
-                                    epg-digest-algorithm-alist))))))
-    (insert "protocol=\"application/pgp-signature\"\n")
-    (insert (format "\n--%s\n" boundary))
-    (goto-char (point-max))
-    (insert (format "\n--%s\n" boundary))
-    (insert "Content-Type: application/pgp-signature; name=\"signature.asc\"\n\n")
-    (insert signature)
-    (goto-char (point-max))
-    (insert (format "--%s--\n" boundary))
-    (goto-char (point-max))))
+    (let* ((pair (mml-secure-epg-sign 'OpenPGP t))
+           (signature (car pair))
+           (micalg (cdr pair)))
+      (goto-char (point-min))
+      (insert (format "Content-Type: multipart/signed; boundary=\"%s\";\n"
+                      boundary))
+      (if micalg
+          (insert (format "\tmicalg=pgp-%s; "
+                          (downcase
+                           (cdr (assq micalg
+                                      epg-digest-algorithm-alist))))))
+      (insert "protocol=\"application/pgp-signature\"\n")
+      (insert (format "\n--%s\n" boundary))
+      (goto-char (point-max))
+      (insert (format "\n--%s\n" boundary))
+      (insert "Content-Type: application/pgp-signature; name=\"signature.asc\"\n\n")
+      (insert signature)
+      (goto-char (point-max))
+      (insert (format "--%s--\n" boundary))
+      (goto-char (point-max)))))
 
 (defun mml2015-epg-encrypt (cont &optional sign)
   (let* ((inhibit-redisplay t)
-         (context (epg-make-context))
          (boundary (mml-compute-boundary cont))
-         (config (epg-configuration))
-         (recipients (message-options-get 'mml2015-epg-recipients))
-         cipher
-         (sender (message-options-get 'message-sender))
-         (signer-names (or mml2015-signers
-                           (if (and mml2015-sign-with-sender sender)
-                               (list (concat "<" sender ">")))))
-         signers
-         recipient-key signer-key)
-    (unless recipients
-      (setq recipients
-            (apply #'nconc
-                   (mapcar
-                    (lambda (recipient)
-                      (or (epg-expand-group config recipient)
-                          (list (concat "<" recipient ">"))))
-                    (split-string
-                     (or (message-options-get 'message-recipients)
-                         (message-options-set 'message-recipients
-                                              (read-string "Recipients: ")))
-                     "[ \f\t\n\r\v,]+"))))
-      (when mml2015-encrypt-to-self
-        (unless signer-names
-          (error "Neither message sender nor mml2015-signers are set"))
-        (setq recipients (nconc recipients signer-names)))
-      (if (eq mm-encrypt-option 'guided)
-          (setq recipients
-                (epa-select-keys context "\
-Select recipients for encryption.
-If no one is selected, symmetric encryption will be performed.  "
-                                 recipients))
-        (setq recipients
-              (delq nil
-                    (mapcar
-                     (lambda (recipient)
-                       (setq recipient-key (mml2015-epg-find-usable-key
-                                            context recipient 'encrypt))
-                       (unless (or recipient-key
-                                   (y-or-n-p
-                                    (format "No public key for %s; skip it? "
-                                            recipient)))
-                         (error "No public key for %s" recipient))
-                       recipient-key)
-                     recipients)))
-        (unless recipients
-          (error "No recipient specified")))
-      (message-options-set 'mml2015-epg-recipients recipients))
-    (when sign
-      (setq signers
-            (or (message-options-get 'mml2015-epg-signers)
-                (message-options-set
-                 'mml2015-epg-signers
-                 (if (eq mm-sign-option 'guided)
-                     (epa-select-keys context "\
-Select keys for signing.
-If no one is selected, default secret key is used.  "
-                                      signer-names
-                                      t)
-                   (if (or sender mml2015-signers)
-                       (delq nil
-                             (mapcar
-                              (lambda (signer)
-                                (setq signer-key
-                                      (mml2015-epg-find-usable-secret-key
-                                       context signer 'sign))
-                                (unless (or signer-key
-                                            (y-or-n-p
-                                             (format
-                                              "No secret key for %s; skip it? "
-                                              signer)))
-                                  (error "No secret key for %s" signer))
-                                signer-key)
-                              signer-names)))))))
-      (epg-context-set-signers context signers))
-    (epg-context-set-armor context t)
-    (epg-context-set-textmode context t)
-    (if mml2015-cache-passphrase
-        (epg-context-set-passphrase-callback
-         context
-         #'mml2015-epg-passphrase-callback))
-    (condition-case error
-        (setq cipher
-              (epg-encrypt-string context (buffer-string) recipients sign
-                                  mml2015-always-trust)
-              mml2015-epg-secret-key-id-list nil)
-      (error
-       (while mml2015-epg-secret-key-id-list
-         (password-cache-remove (car mml2015-epg-secret-key-id-list))
-         (setq mml2015-epg-secret-key-id-list
-               (cdr mml2015-epg-secret-key-id-list)))
-       (signal (car error) (cdr error))))
+         (cipher (mml-secure-epg-encrypt 'OpenPGP cont sign)))
     (delete-region (point-min) (point-max))
     (goto-char (point-min))
     (insert (format "Content-Type: multipart/encrypted; boundary=\"%s\";\n"
diff --git a/lisp/gnus/nntp.el b/lisp/gnus/nntp.el
index 0e10dfdb8be..f56b04568c8 100644
--- a/lisp/gnus/nntp.el
+++ b/lisp/gnus/nntp.el
@@ -1115,24 +1115,14 @@ command whose response triggered the error."
 
 (deffoo nntp-request-newgroups (date &optional server)
   (nntp-with-open-group
-   nil server
-   (with-current-buffer nntp-server-buffer
-     (let* ((time (date-to-time date))
-            (ls (- (cadr time) (nth 8 (decode-time time)))))
-       (cond ((< ls 0)
-              (setcar time (1- (car time)))
-              (setcar (cdr time) (+ ls 65536)))
-             ((>= ls 65536)
-              (setcar time (1+ (car time)))
-              (setcar (cdr time) (- ls 65536)))
-             (t
-              (setcar (cdr time) ls)))
-       (prog1
-           (nntp-send-command
-            "^\\.\r?\n" "NEWGROUPS"
-            (format-time-string "%y%m%d %H%M%S" time)
-            "GMT")
-         (nntp-decode-text))))))
+      nil server
+    (with-current-buffer nntp-server-buffer
+      (prog1
+          (nntp-send-command
+           "^\\.\r?\n" "NEWGROUPS"
+           (format-time-string "%y%m%d %H%M%S" (date-to-time date) t)
+           "GMT")
+        (nntp-decode-text)))))
 
 (deffoo nntp-request-post (&optional server)
   (nntp-with-open-group
diff --git a/lisp/help-fns.el b/lisp/help-fns.el
index bc96601a45c..2021885e996 100644
--- a/lisp/help-fns.el
+++ b/lisp/help-fns.el
@@ -918,29 +918,28 @@ if it is given a local binding.\n"))))
                         ;; If the cache element has an mtime, we
                         ;; assume it came from a file.
                         (if (nth 2 file)
-                            (setq file (expand-file-name
-                                        dir-locals-file (car file)))
+                            ;; (car file) is a directory.
+                            (setq file (dir-locals--all-files (car file)))
                           ;; Otherwise, assume it was set directly.
                           (setq file (car file)
                                 is-directory t)))
                       (if (null file)
                           (princ ".\n")
                         (princ ", set ")
-                        (let ((files (file-expand-wildcards file)))
-                          (princ (substitute-command-keys
-                                  (cond
-                                   (is-directory "for the directory\n  `")
-                                   ;; Many files matched.
-                                   ((cdr files)
-                                    (setq file (file-name-directory (car files)))
-                                    (format "by a file\n  matching `%s' in the directory\n  `"
-                                            dir-locals-file))
-                                   (t (setq file (car files))
-                                      "by the file\n  `"))))
+                        (princ (substitute-command-keys
+                                (cond
+                                 (is-directory "for the directory\n  `")
+                                 ;; Many files matched.
+                                 ((and (consp file) (cdr file))
+                                  (setq file (file-name-directory (car file)))
+                                  (format "by one of the\n  %s files in the directory\n  `"
+                                          dir-locals-file))
+                                 (t (setq file (car file))
+                                    "by the file\n  `"))))
                         (with-current-buffer standard-output
                           (insert-text-button
                            file 'type 'help-dir-local-var-def
-                             'help-args (list variable file))))
+                             'help-args (list variable file)))
                         (princ (substitute-command-keys "'.\n"))))
                   (princ (substitute-command-keys
                           "  This variable's value is file-local.\n"))))
diff --git a/lisp/international/mule-util.el b/lisp/international/mule-util.el
index 24ad342d4e0..ae58f1ec7e1 100644
--- a/lisp/international/mule-util.el
+++ b/lisp/international/mule-util.el
@@ -259,7 +259,7 @@ language environment LANG-ENV."
         (with-coding-priority coding-priority
           (detect-coding-region from to)))))
 
-(declare-function internal-char-font "fontset.c" (position &optional ch))
+(declare-function internal-char-font "font.c" (position &optional ch))
 
 ;;;###autoload
 (defun char-displayable-p (char)
diff --git a/lisp/mail/rmail.el b/lisp/mail/rmail.el
index 05511a84540..5464c38af76 100644
--- a/lisp/mail/rmail.el
+++ b/lisp/mail/rmail.el
@@ -694,8 +694,9 @@ Element N specifies the summary line for message N+1.")
 This is set to nil by default.")
 
 (defcustom rmail-get-coding-function nil
-  "Function of no args to try to determine coding system for a message."
-  :type 'function
+  "Function of no args to try to determine coding system for a message.
+If nil, just search for `rmail-mime-charset-pattern'."
+  :type '(choice (const nil) function)
   :group 'rmail
   :version "24.4")
 
diff --git a/lisp/mh-e/mh-e.el b/lisp/mh-e/mh-e.el
index c900248c9b6..20029f8e0b5 100644
--- a/lisp/mh-e/mh-e.el
+++ b/lisp/mh-e/mh-e.el
@@ -5,7 +5,7 @@
 
 ;; Author: Bill Wohler <wohler@newt.com>
 ;; Maintainer: Bill Wohler <wohler@newt.com>
-;; Version: 8.6
+;; Version: 8.6+git
 ;; Keywords: mail
 
 ;; This file is part of GNU Emacs.
@@ -127,7 +127,7 @@
 ;; Try to keep variables local to a single file. Provide accessors if
 ;; variables are shared. Use this section as a last resort.
 
-(defconst mh-version "8.6" "Version number of MH-E.")
+(defconst mh-version "8.6+git" "Version number of MH-E.")
 
 ;; Variants
 
diff --git a/lisp/net/browse-url.el b/lisp/net/browse-url.el
index 26fa0d94b88..2bda97f95d0 100644
--- a/lisp/net/browse-url.el
+++ b/lisp/net/browse-url.el
@@ -349,6 +349,7 @@ functionality is not available there."
   "Whether to open up new windows in a buffer or a new window.
 If non-nil, then open the URL in a new buffer rather than a new window if
 `browse-url-conkeror' is asked to open it in a new window."
+  :version "25.1"
   :type 'boolean
   :group 'browse-url)
 
@@ -415,6 +416,7 @@ commands reverses the effect of this variable."
 
 (defcustom browse-url-conkeror-arguments nil
   "A list of strings to pass to Conkeror as arguments."
+  :version "25.1"
   :type '(repeat (string :tag "Argument"))
   :group 'browse-url)
 
diff --git a/lisp/net/newst-reader.el b/lisp/net/newst-reader.el
index 1647ef85364..9c29216ccaf 100644
--- a/lisp/net/newst-reader.el
+++ b/lisp/net/newst-reader.el
@@ -69,6 +69,7 @@ This must be one of the functions `newsticker-plainview' or
 (defcustom newsticker-download-logos
   t
   "If non-nil newsticker downloads logo images of subscribed feeds."
+  :version "25.1"
   :type 'boolean
   :group 'newsticker-reader)
 
diff --git a/lisp/net/newst-treeview.el b/lisp/net/newst-treeview.el
index 0e75236154b..4de3d1d1125 100644
--- a/lisp/net/newst-treeview.el
+++ b/lisp/net/newst-treeview.el
@@ -132,9 +132,9 @@ Example: (\"Topmost group\" \"feed1\" (\"subgroup1\" \"feed 2\")
 
 (defcustom newsticker-groups-filename
   nil
-  "Name of the newsticker groups settings file.  This variable is obsolete."
+  "Name of the newsticker groups settings file."
   :version "25.1"                       ; changed default value to nil
-  :type 'string
+  :type '(choice (const nil) string)
   :group 'newsticker-treeview)
 (make-obsolete-variable 'newsticker-groups-filename 'newsticker-dir "23.1")
 
diff --git a/lisp/net/shr.el b/lisp/net/shr.el
index 2511d673e7e..290a6422bd7 100644
--- a/lisp/net/shr.el
+++ b/lisp/net/shr.el
@@ -1617,7 +1617,9 @@ The preference is a float determined from `shr-prefer-media-type'."
     (shr-insert-table (shr-make-table dom sketch-widths t) sketch-widths)))
 
 (defun shr-table-body (dom)
-  (let ((tbodies (dom-by-tag dom 'tbody)))
+  (let ((tbodies (seq-filter (lambda (child)
+                               (eq (dom-tag child) 'tbody))
+                             (dom-children dom))))
     (cond
      ((null tbodies)
       dom)
diff --git a/lisp/net/tramp-sh.el b/lisp/net/tramp-sh.el
index 7b1aa2a13b0..baebb13dd22 100644
--- a/lisp/net/tramp-sh.el
+++ b/lisp/net/tramp-sh.el
@@ -284,6 +284,15 @@ The string is used in `tramp-methods'.")
     (tramp-remote-shell-args    ("-c"))
     (tramp-connection-timeout   10)))
 ;;;###tramp-autoload
+(add-to-list
+ 'tramp-methods
+ '("sg"
+   (tramp-login-program        "sg")
+   (tramp-login-args           (("-") ("%u")))
+   (tramp-remote-shell         "/bin/sh")
+   (tramp-remote-shell-args    ("-c"))
+   (tramp-connection-timeout   10)))
+;;;###tramp-autoload
 (add-to-list 'tramp-methods
   '("sudo"
     (tramp-login-program        "sudo")
@@ -445,12 +454,17 @@ The string is used in `tramp-methods'.")
   "Default list of (FUNCTION FILE) pairs to be examined for su methods.")
 
 ;;;###tramp-autoload
+(defconst tramp-completion-function-alist-sg
+  '((tramp-parse-etc-group "/etc/group"))
+  "Default list of (FUNCTION FILE) pairs to be examined for sg methods.")
+
+;;;###tramp-autoload
 (defconst tramp-completion-function-alist-putty
   `((tramp-parse-putty
      ,(if (memq system-type '(windows-nt))
           "HKEY_CURRENT_USER\\Software\\SimonTatham\\PuTTY\\Sessions"
         "~/.putty/sessions")))
-  "Default list of (FUNCTION REGISTRY) pairs to be examined for putty sessions.")
+ "Default list of (FUNCTION REGISTRY) pairs to be examined for putty sessions.")
 
 ;;;###tramp-autoload
 (eval-after-load 'tramp
@@ -470,6 +484,7 @@ The string is used in `tramp-methods'.")
      (tramp-set-completion-function "su" tramp-completion-function-alist-su)
      (tramp-set-completion-function "sudo" tramp-completion-function-alist-su)
      (tramp-set-completion-function "ksu" tramp-completion-function-alist-su)
+     (tramp-set-completion-function "sg" tramp-completion-function-alist-sg)
      (tramp-set-completion-function
       "krlogin" tramp-completion-function-alist-rsh)
      (tramp-set-completion-function "plink" tramp-completion-function-alist-ssh)
@@ -5724,5 +5739,7 @@ function cell is returned to be applied on a buffer."
 ;;   rsync).
 ;; * Keep a second connection open for out-of-band methods like scp or
 ;;   rsync.
+;; * Check, whether we could also use "getent passwd" and "getent
+;;   group" for user/group name completion.
 
 ;;; tramp-sh.el ends here
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index 5c6788082b1..e52f1958592 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -432,6 +432,7 @@ names from FILE for completion.  The following predefined FUNCTIONs exists:
  * `tramp-parse-sknownhosts' for \"~/.ssh2/knownhosts/*\" like files,
  * `tramp-parse-hosts'       for \"/etc/hosts\" like files,
  * `tramp-parse-passwd'      for \"/etc/passwd\" like files.
+ * `tramp-parse-etc-group'   for \"/etc/group\" like files.
  * `tramp-parse-netrc'       for \"~/.netrc\" like files.
  * `tramp-parse-putty'       for PuTTY registered sessions.
 
@@ -509,6 +510,7 @@ This regexp must match both `tramp-initial-end-of-output' and
 
 (defcustom tramp-password-prompt-regexp
   (format "^.*\\(%s\\).*:\^@? *"
+          ;; `password-word-equivalents' has been introduced with Emacs 24.4.
           (if (boundp 'password-word-equivalents)
               (regexp-opt (symbol-value 'password-word-equivalents))
             "password\\|passphrase"))
@@ -2645,6 +2647,22 @@ Host is always \"localhost\"."
      result))
 
 ;;;###tramp-autoload
+(defun tramp-parse-etc-group (filename)
+  "Return a list of (group host) tuples allowed to access.
+Host is always \"localhost\"."
+  (tramp-parse-file filename 'tramp-parse-etc-group-group))
+
+(defun tramp-parse-etc-group-group ()
+   "Return a (group host) tuple allowed to access.
+Host is always \"localhost\"."
+   (let ((result)
+         (split (split-string (buffer-substring (point) (point-at-eol)) ":")))
+     (when (member (user-login-name) (split-string (nth 3 split) "," 'omit))
+       (setq result (list (nth 0 split) "localhost")))
+     (forward-line 1)
+     result))
+
+;;;###tramp-autoload
 (defun tramp-parse-netrc (filename)
   "Return a list of (user host) tuples allowed to access.
 User may be nil."
diff --git a/lisp/nxml/nxml-enc.el b/lisp/nxml/nxml-enc.el
index bcee0882aa2..6406f57ff63 100644
--- a/lisp/nxml/nxml-enc.el
+++ b/lisp/nxml/nxml-enc.el
@@ -1,4 +1,4 @@
-;;; nxml-enc.el --- XML encoding auto-detection
+;;; nxml-enc.el --- XML encoding auto-detection  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
@@ -68,7 +68,7 @@
     (and nxml-non-xml-set-auto-coding-function
          (funcall nxml-non-xml-set-auto-coding-function file-name size))))
 
-(defun nxml-set-xml-coding (file-name size)
+(defun nxml-set-xml-coding (_file-name size)
   "Function to use as `set-auto-coding-function' when file is known to be XML."
   (nxml-detect-coding-system (+ (point) (min size 1024))))
 
diff --git a/lisp/nxml/nxml-glyph.el b/lisp/nxml/nxml-glyph.el
deleted file mode 100644
index 4a518218c23..00000000000
--- a/lisp/nxml/nxml-glyph.el
+++ /dev/null
@@ -1,423 +0,0 @@
-;;; nxml-glyph.el --- glyph-handling for nxml-mode
-
-;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
-
-;; Author: James Clark
-;; Keywords: wp, hypermedia, languages, XML
-
-;; 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 entry point to this file is `nxml-glyph-display-string'.
-;; The current implementation is heuristic due to a lack of
-;; Emacs primitives necessary to implement it properly.  The user
-;; can tweak the heuristics using `nxml-glyph-set-functions'.
-
-;;; Code:
-
-(defconst nxml-ascii-glyph-set
-  [(#x0020 . #x007E)])
-
-(defconst nxml-latin1-glyph-set
-  [(#x0020 . #x007E)
-   (#x00A0 . #x00FF)])
-
-;; These were generated by using nxml-insert-target-repertoire-glyph-set
-;; on the TARGET[123] files in
-;; http://www.cl.cam.ac.uk/~mgk25/download/ucs-fonts.tar.gz
-
-(defconst nxml-misc-fixed-1-glyph-set
-  [(#x0020 . #x007E)
-   (#x00A0 . #x00FF)
-   (#x0100 . #x017F)
-   #x018F #x0192
-   (#x0218 . #x021B)
-   #x0259
-   (#x02C6 . #x02C7)
-   (#x02D8 . #x02DD)
-   (#x0374 . #x0375)
-   #x037A #x037E
-   (#x0384 . #x038A)
-   #x038C
-   (#x038E . #x03A1)
-   (#x03A3 . #x03CE)
-   (#x0401 . #x040C)
-   (#x040E . #x044F)
-   (#x0451 . #x045C)
-   (#x045E . #x045F)
-   (#x0490 . #x0491)
-   (#x05D0 . #x05EA)
-   (#x1E02 . #x1E03)
-   (#x1E0A . #x1E0B)
-   (#x1E1E . #x1E1F)
-   (#x1E40 . #x1E41)
-   (#x1E56 . #x1E57)
-   (#x1E60 . #x1E61)
-   (#x1E6A . #x1E6B)
-   (#x1E80 . #x1E85)
-   (#x1EF2 . #x1EF3)
-   (#x2010 . #x2022)
-   #x2026 #x2030
-   (#x2039 . #x203A)
-   #x20AC #x2116 #x2122 #x2126
-   (#x215B . #x215E)
-   (#x2190 . #x2193)
-   #x2260
-   (#x2264 . #x2265)
-   (#x23BA . #x23BD)
-   (#x2409 . #x240D)
-   #x2424 #x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524 #x252C #x2534 #x253C #x2592 #x25C6 #x266A #xFFFD]
-  "Glyph set for TARGET1 glyph repertoire of misc-fixed-* font.
-This repertoire is supported for the bold and oblique fonts.")
-
-(defconst nxml-misc-fixed-2-glyph-set
-  [(#x0020 . #x007E)
-   (#x00A0 . #x00FF)
-   (#x0100 . #x017F)
-   #x018F #x0192
-   (#x01FA . #x01FF)
-   (#x0218 . #x021B)
-   #x0259
-   (#x02C6 . #x02C7)
-   #x02C9
-   (#x02D8 . #x02DD)
-   (#x0300 . #x0311)
-   (#x0374 . #x0375)
-   #x037A #x037E
-   (#x0384 . #x038A)
-   #x038C
-   (#x038E . #x03A1)
-   (#x03A3 . #x03CE)
-   #x03D1
-   (#x03D5 . #x03D6)
-   #x03F1
-   (#x0401 . #x040C)
-   (#x040E . #x044F)
-   (#x0451 . #x045C)
-   (#x045E . #x045F)
-   (#x0490 . #x0491)
-   (#x05D0 . #x05EA)
-   (#x1E02 . #x1E03)
-   (#x1E0A . #x1E0B)
-   (#x1E1E . #x1E1F)
-   (#x1E40 . #x1E41)
-   (#x1E56 . #x1E57)
-   (#x1E60 . #x1E61)
-   (#x1E6A . #x1E6B)
-   (#x1E80 . #x1E85)
-   (#x1EF2 . #x1EF3)
-   (#x2010 . #x2022)
-   #x2026 #x2030
-   (#x2032 . #x2034)
-   (#x2039 . #x203A)
-   #x203C #x203E #x2044
-   (#x2070 . #x2071)
-   (#x2074 . #x208E)
-   (#x20A3 . #x20A4)
-   #x20A7 #x20AC
-   (#x20D0 . #x20D7)
-   #x2102 #x2105 #x2113
-   (#x2115 . #x2116)
-   #x211A #x211D #x2122 #x2124 #x2126 #x212E
-   (#x215B . #x215E)
-   (#x2190 . #x2195)
-   (#x21A4 . #x21A8)
-   (#x21D0 . #x21D5)
-   (#x2200 . #x2209)
-   (#x220B . #x220C)
-   #x220F
-   (#x2211 . #x2213)
-   #x2215
-   (#x2218 . #x221A)
-   (#x221D . #x221F)
-   #x2221
-   (#x2224 . #x222B)
-   #x222E #x223C #x2243 #x2245
-   (#x2248 . #x2249)
-   #x2259
-   (#x225F . #x2262)
-   (#x2264 . #x2265)
-   (#x226A . #x226B)
-   (#x2282 . #x228B)
-   #x2295 #x2297
-   (#x22A4 . #x22A7)
-   (#x22C2 . #x22C3)
-   #x22C5 #x2300 #x2302
-   (#x2308 . #x230B)
-   #x2310
-   (#x2320 . #x2321)
-   (#x2329 . #x232A)
-   (#x23BA . #x23BD)
-   (#x2409 . #x240D)
-   #x2424 #x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524 #x252C #x2534 #x253C
-   (#x254C . #x2573)
-   (#x2580 . #x25A1)
-   (#x25AA . #x25AC)
-   (#x25B2 . #x25B3)
-   #x25BA #x25BC #x25C4 #x25C6
-   (#x25CA . #x25CB)
-   #x25CF
-   (#x25D8 . #x25D9)
-   #x25E6
-   (#x263A . #x263C)
-   #x2640 #x2642 #x2660 #x2663
-   (#x2665 . #x2666)
-   (#x266A . #x266B)
-   (#xFB01 . #xFB02)
-   #xFFFD]
-  "Glyph set for TARGET2 glyph repertoire of the misc-fixed-* fonts.
-This repertoire is supported for the following fonts:
-5x7.bdf 5x8.bdf 6x9.bdf 6x10.bdf 6x12.bdf 7x13.bdf 7x14.bdf clR6x12.bdf")
-
-(defconst nxml-misc-fixed-3-glyph-set
-  [(#x0020 . #x007E)
-   (#x00A0 . #x00FF)
-   (#x0100 . #x01FF)
-   (#x0200 . #x0220)
-   (#x0222 . #x0233)
-   (#x0250 . #x02AD)
-   (#x02B0 . #x02EE)
-   (#x0300 . #x034F)
-   (#x0360 . #x036F)
-   (#x0374 . #x0375)
-   #x037A #x037E
-   (#x0384 . #x038A)
-   #x038C
-   (#x038E . #x03A1)
-   (#x03A3 . #x03CE)
-   (#x03D0 . #x03F6)
-   (#x0400 . #x0486)
-   (#x0488 . #x04CE)
-   (#x04D0 . #x04F5)
-   (#x04F8 . #x04F9)
-   (#x0500 . #x050F)
-   (#x0531 . #x0556)
-   (#x0559 . #x055F)
-   (#x0561 . #x0587)
-   (#x0589 . #x058A)
-   (#x05B0 . #x05B9)
-   (#x05BB . #x05C4)
-   (#x05D0 . #x05EA)
-   (#x05F0 . #x05F4)
-   (#x10D0 . #x10F8)
-   #x10FB
-   (#x1E00 . #x1E9B)
-   (#x1EA0 . #x1EF9)
-   (#x1F00 . #x1F15)
-   (#x1F18 . #x1F1D)
-   (#x1F20 . #x1F45)
-   (#x1F48 . #x1F4D)
-   (#x1F50 . #x1F57)
-   #x1F59 #x1F5B #x1F5D
-   (#x1F5F . #x1F7D)
-   (#x1F80 . #x1FB4)
-   (#x1FB6 . #x1FC4)
-   (#x1FC6 . #x1FD3)
-   (#x1FD6 . #x1FDB)
-   (#x1FDD . #x1FEF)
-   (#x1FF2 . #x1FF4)
-   (#x1FF6 . #x1FFE)
-   (#x2000 . #x200A)
-   (#x2010 . #x2027)
-   (#x202F . #x2052)
-   #x2057
-   (#x205F . #x2063)
-   (#x2070 . #x2071)
-   (#x2074 . #x208E)
-   (#x20A0 . #x20B1)
-   (#x20D0 . #x20EA)
-   (#x2100 . #x213A)
-   (#x213D . #x214B)
-   (#x2153 . #x2183)
-   (#x2190 . #x21FF)
-   (#x2200 . #x22FF)
-   (#x2300 . #x23CE)
-   (#x2400 . #x2426)
-   (#x2440 . #x244A)
-   (#x2500 . #x25FF)
-   (#x2600 . #x2613)
-   (#x2616 . #x2617)
-   (#x2619 . #x267D)
-   (#x2680 . #x2689)
-   (#x27E6 . #x27EB)
-   (#x27F5 . #x27FF)
-   (#x2A00 . #x2A06)
-   #x2A1D #x2A3F #x303F
-   (#xFB00 . #xFB06)
-   (#xFB13 . #xFB17)
-   (#xFB1D . #xFB36)
-   (#xFB38 . #xFB3C)
-   #xFB3E
-   (#xFB40 . #xFB41)
-   (#xFB43 . #xFB44)
-   (#xFB46 . #xFB4F)
-   (#xFE20 . #xFE23)
-   (#xFF61 . #xFF9F)
-   #xFFFD]
-  "Glyph set for TARGET3 glyph repertoire of the misc-fixed-* fonts.
-This repertoire is supported for the following fonts:
-6x13.bdf 8x13.bdf 9x15.bdf 9x18.bdf 10x20.bdf")
-
-(defconst nxml-wgl4-glyph-set
-  [(#x0020 . #x007E)
-   (#x00A0 . #x017F)
-   #x0192
-   (#x01FA . #x01FF)
-   (#x02C6 . #x02C7)
-   #x02C9
-   (#x02D8 . #x02DB)
-   #x02DD
-   (#x0384 . #x038A)
-   #x038C
-   (#x038E . #x03A1)
-   (#x03A3 . #x03CE)
-   (#x0401 . #x040C)
-   (#x040E . #x044F)
-   (#x0451 . #x045C)
-   (#x045E . #x045F)
-   (#x0490 . #x0491)
-   (#x1E80 . #x1E85)
-   (#x1EF2 . #x1EF3)
-   (#x2013 . #x2015)
-   (#x2017 . #x201E)
-   (#x2020 . #x2022)
-   #x2026 #x2030
-   (#x2032 . #x2033)
-   (#x2039 . #x203A)
-   #x203C #x203E #x2044 #x207F
-   (#x20A3 . #x20A4)
-   #x20A7 #x20AC #x2105 #x2113 #x2116 #x2122 #x2126 #x212E
-   (#x215B . #x215E)
-   (#x2190 . #x2195)
-   #x21A8 #x2202 #x2206 #x220F
-   (#x2211 . #x2212)
-   #x2215
-   (#x2219 . #x221A)
-   (#x221E . #x221F)
-   #x2229 #x222B #x2248
-   (#x2260 . #x2261)
-   (#x2264 . #x2265)
-   #x2302 #x2310
-   (#x2320 . #x2321)
-   #x2500 #x2502 #x250C #x2510 #x2514 #x2518 #x251C #x2524
-   #x252C #x2534 #x253C
-   (#x2550 . #x256C)
-   #x2580 #x2584 #x2588 #x258C
-   (#x2590 . #x2593)
-   (#x25A0 . #x25A1)
-   (#x25AA . #x25AC)
-   #x25B2 #x25BA #x25BC #x25C4
-   (#x25CA . #x25CB)
-   #x25CF
-   (#x25D8 . #x25D9)
-   #x25E6
-   (#x263A . #x263C)
-   #x2640 #x2642 #x2660 #x2663
-   (#x2665 . #x2666)
-   (#x266A . #x266B)
-   (#xFB01 . #xFB02)]
-  "Glyph set corresponding to Windows Glyph List 4.")
-
-(defvar nxml-glyph-set-functions nil
-  "Abnormal hook for determining the set of glyphs in a face.
-Each function in this hook is called in turn, unless one of them
-returns non-nil.  Each function is called with a single argument
-FACE.  If it can determine the set of glyphs representable by
-FACE, it must set the variable `nxml-glyph-set' and return
-non-nil.  Otherwise, it must return nil.
-
-The constants `nxml-ascii-glyph-set', `nxml-latin1-glyph-set',
-`nxml-misc-fixed-1-glyph-set', `nxml-misc-fixed-2-glyph-set',
-`nxml-misc-fixed-3-glyph-set' and `nxml-wgl4-glyph-set' are
-predefined for use by `nxml-glyph-set-functions'.")
-
-(define-obsolete-variable-alias 'nxml-glyph-set-hook
-  'nxml-glyph-set-functions "24.3")
-
-(defvar nxml-glyph-set nil
-  "Used by `nxml-glyph-set-functions' to return set of glyphs in a FACE.
-This should dynamically bound by any function that runs
-`nxml-glyph-set-functions'.  The value must be either nil representing an
-empty set or a vector. Each member of the vector is either a single
-integer or a cons (FIRST . LAST) representing the range of integers
-from FIRST to LAST.  An integer represents a glyph with that Unicode
-code-point.  The vector must be ordered.")
-
-(defun nxml-x-set-glyph-set (face)
-  (setq nxml-glyph-set
-        (if (equal (face-attribute face :family) "misc-fixed")
-            nxml-misc-fixed-3-glyph-set
-          nxml-wgl4-glyph-set)))
-
-(defun nxml-w32-set-glyph-set (face)
-  (setq nxml-glyph-set nxml-wgl4-glyph-set))
-
-(defun nxml-window-system-set-glyph-set (face)
-  (setq nxml-glyph-set nxml-latin1-glyph-set))
-
-(defun nxml-terminal-set-glyph-set (face)
-  (setq nxml-glyph-set nxml-ascii-glyph-set))
-
-(add-hook 'nxml-glyph-set-functions
-          (or (cdr (assq window-system
-                         '((x . nxml-x-set-glyph-set)
-                           (w32 . nxml-w32-set-glyph-set)
-                           (nil . nxml-terminal-set-glyph-set))))
-              'nxml-window-system-set-glyph-set)
-          t)
-
-;;;###autoload
-(defun nxml-glyph-display-string (n face)
-  "Return a string that can display a glyph for Unicode code-point N.
-FACE gives the face that will be used for displaying the string.
-Return nil if the face cannot display a glyph for N."
-  (let ((nxml-glyph-set nil))
-    (run-hook-with-args-until-success 'nxml-glyph-set-functions face)
-    (and nxml-glyph-set
-         (nxml-glyph-set-contains-p n nxml-glyph-set)
-         (let ((ch (decode-char 'ucs n)))
-           (and ch (string ch))))))
-
-(defun nxml-glyph-set-contains-p (n v)
-  (let ((start 0)
-        (end (length v))
-        found mid mid-val mid-start-val mid-end-val)
-    (while (> end start)
-      (setq mid (+ start
-                   (/ (- end start) 2)))
-      (setq mid-val (aref v mid))
-      (if (consp mid-val)
-          (setq mid-start-val (car mid-val)
-                mid-end-val (cdr mid-val))
-        (setq mid-start-val mid-val
-              mid-end-val mid-val))
-      (cond ((and (<= mid-start-val n)
-                  (<= n mid-end-val))
-             (setq found t)
-             (setq start end))
-            ((< n mid-start-val)
-             (setq end mid))
-            (t
-             (setq start
-                   (if (eq start mid)
-                       end
-                     mid)))))
-    found))
-
-(provide 'nxml-glyph)
-
-;;; nxml-glyph.el ends here
diff --git a/lisp/nxml/nxml-maint.el b/lisp/nxml/nxml-maint.el
index b81e3113efb..5d24d9b3138 100644
--- a/lisp/nxml/nxml-maint.el
+++ b/lisp/nxml/nxml-maint.el
@@ -1,4 +1,4 @@
-;;; nxml-maint.el --- commands for maintainers of nxml-*.el
+;;; nxml-maint.el --- commands for maintainers of nxml-*.el  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
@@ -24,48 +24,6 @@
 
 ;;; Code:
 
-;;; Generating files with Unicode char names.
-
-(require 'nxml-uchnm)
-
-(defun nxml-create-unicode-char-name-sets (file)
-  "Generate files containing char names from Unicode standard."
-  (interactive "fUnicodeData file: ")
-  (mapc (lambda (block)
-          (let ((nameset (nxml-unicode-block-char-name-set (nth 0 block))))
-            (save-excursion
-              (find-file (concat (get nameset 'nxml-char-name-set-file)
-                                 ".el"))
-              (erase-buffer)
-              (insert "(nxml-define-char-name-set '")
-              (prin1 nameset (current-buffer))
-              (insert "\n  '())\n")
-              (goto-char (- (point) 3)))))
-        nxml-unicode-blocks)
-  (save-excursion
-    (find-file file)
-    (goto-char (point-min))
-    (let ((blocks nxml-unicode-blocks)
-          code name)
-      (while (re-search-forward "^\\([0-9A-F]+\\);\\([^<;][^;]*\\);"
-                                nil
-                                t)
-        (setq code (string-to-number (match-string 1) 16))
-        (setq name (match-string 2))
-        (while (and blocks
-                    (> code (nth 2 (car blocks))))
-          (setq blocks (cdr blocks)))
-        (when (and (<= (nth 1 (car blocks)) code)
-                   (<= code (nth 2 (car blocks))))
-          (save-excursion
-            (find-file (concat (get (nxml-unicode-block-char-name-set
-                                     (nth 0 (car blocks)))
-                                    'nxml-char-name-set-file)
-                               ".el"))
-            (insert "(")
-            (prin1 name (current-buffer))
-            (insert (format " #x%04X)\n    " code))))))))
-
 ;;; Parsing target repertoire files from ucs-fonts.
 ;; This is for converting the TARGET? files in
 ;; http://www.cl.cam.ac.uk/~mgk25/download/ucs-fonts.tar.gz
diff --git a/lisp/nxml/nxml-mode.el b/lisp/nxml/nxml-mode.el
index 324350f591c..edc7414bfbf 100644
--- a/lisp/nxml/nxml-mode.el
+++ b/lisp/nxml/nxml-mode.el
@@ -26,14 +26,10 @@
 
 ;;; Code:
 
-(when (featurep 'mucs)
-  (error "nxml-mode is not compatible with Mule-UCS"))
-
 (eval-when-compile (require 'cl-lib))
 
 (require 'xmltok)
 (require 'nxml-enc)
-(require 'nxml-glyph)
 (require 'nxml-util)
 (require 'nxml-rap)
 (require 'nxml-outln)
@@ -41,6 +37,7 @@
 ;; So we might as well just require it and silence the compiler.
 (provide 'nxml-mode)                    ; avoid recursive require
 (require 'rng-nxml)
+(require 'sgml-mode)
 
 ;;; Customization
 
@@ -55,9 +52,7 @@
 
 (defcustom nxml-char-ref-display-glyph-flag t
   "Non-nil means display glyph following character reference.
-The glyph is displayed in face `nxml-glyph'.  The abnormal hook
-`nxml-glyph-set-functions' can be used to change the characters
-for which glyphs are displayed."
+The glyph is displayed in face `nxml-glyph'."
   :group 'nxml
   :type 'boolean)
 
@@ -153,16 +148,6 @@ This is not used directly, but only via inheritance by other faces."
   "Face used to highlight text."
   :group 'nxml-faces)
 
-(defface nxml-comment-content
-  '((t (:inherit font-lock-comment-face)))
-  "Face used to highlight the content of comments."
-  :group 'nxml-faces)
-
-(defface nxml-comment-delimiter
-  '((t (:inherit font-lock-comment-delimiter-face)))
-  "Face used for the delimiters of comments, i.e., <!-- and -->."
-  :group 'nxml-faces)
-
 (defface nxml-processing-instruction-delimiter
   '((t (:inherit nxml-delimiter)))
   "Face used for the delimiters of processing instructions, i.e., <? and ?>."
@@ -280,15 +265,6 @@ This includes ths `x' in hex references."
   "Face used for the delimiters of attribute values."
   :group 'nxml-faces)
 
-(defface nxml-namespace-attribute-value
-  '((t (:inherit nxml-attribute-value)))
-  "Face used for the value of namespace attributes."
-  :group 'nxml-faces)
-
-(defface nxml-namespace-attribute-value-delimiter
-  '((t (:inherit nxml-attribute-value-delimiter)))
-  "Face used for the delimiters of namespace attribute values."
-  :group 'nxml-faces)
 
 (defface nxml-prolog-literal-delimiter
   '((t (:inherit nxml-delimited-data)))
@@ -342,22 +318,19 @@ The delimiters are <! and >."
 
 ;;; Global variables
 
-(defvar nxml-parent-document nil
+(defvar-local nxml-parent-document nil
   "The parent document for a part of a modular document.
 Use `nxml-parent-document-set' to set it.")
-(make-variable-buffer-local 'nxml-parent-document)
 (put 'nxml-parent-document 'safe-local-variable 'stringp)
 
-(defvar nxml-prolog-regions nil
+(defvar-local nxml-prolog-regions nil
   "List of regions in the prolog to be fontified.
 See the function `xmltok-forward-prolog' for more information.")
-(make-variable-buffer-local 'nxml-prolog-regions)
 
-(defvar nxml-degraded nil
+(defvar-local nxml-degraded nil
   "Non-nil if currently operating in degraded mode.
 Degraded mode is enabled when an internal error is encountered in the
 fontification or after-change functions.")
-(make-variable-buffer-local 'nxml-degraded)
 
 (defvar nxml-completion-hook nil
   "Hook run by `nxml-complete'.
@@ -375,13 +348,12 @@ one of the functions returns nil.")
 (defvar nxml-end-tag-indent-scan-distance 4000
   "Maximum distance from point to scan backwards when indenting end-tag.")
 
-(defvar nxml-char-ref-extra-display t
+(defvar-local nxml-char-ref-extra-display t
   "Non-nil means display extra information for character references.
 The extra information consists of a tooltip with the character name
 and, if `nxml-char-ref-display-glyph-flag' is non-nil, a glyph
 corresponding to the referenced character following the character
 reference.")
-(make-variable-buffer-local 'nxml-char-ref-extra-display)
 
 (defvar nxml-mode-map
   (let ((map (make-sparse-keymap)))
@@ -415,7 +387,9 @@ reference.")
 
 (defsubst nxml-set-face (start end face)
   (when (and face (< start end))
-    (font-lock-append-text-property start end 'face face)))
+    ;; Prepend, so the character reference highlighting takes precedence over
+    ;; the string highlighting applied syntactically.
+    (font-lock-prepend-text-property start end 'face face)))
 
 (defun nxml-parent-document-set (parent-document)
   "Set `nxml-parent-document' and inherit the DTD &c."
@@ -519,53 +493,39 @@ Many aspects this mode can be customized using
   ;; FIXME: Use the fact that we're parsing the document already
   ;; rather than using regex-based filtering.
   (setq-local tildify-foreach-region-function
-              (apply-partially 'tildify-foreach-ignore-environments
+              (apply-partially #'tildify-foreach-ignore-environments
                                '(("<! *--" . "-- *>") ("<" . ">"))))
-  (set (make-local-variable 'mode-line-process) '((nxml-degraded "/degraded")))
+  (setq-local mode-line-process '((nxml-degraded "/degraded")))
   ;; We'll determine the fill prefix ourselves
-  (make-local-variable 'adaptive-fill-mode)
-  (setq adaptive-fill-mode nil)
-  (make-local-variable 'forward-sexp-function)
-  (setq forward-sexp-function 'nxml-forward-balanced-item)
-  (make-local-variable 'indent-line-function)
-  (setq indent-line-function 'nxml-indent-line)
-  (make-local-variable 'fill-paragraph-function)
-  (setq fill-paragraph-function 'nxml-do-fill-paragraph)
+  (setq-local adaptive-fill-mode nil)
+  (setq-local forward-sexp-function #'nxml-forward-balanced-item)
+  (setq-local indent-line-function #'nxml-indent-line)
+  (setq-local fill-paragraph-function #'nxml-do-fill-paragraph)
   ;; Comment support
   ;; This doesn't seem to work too well;
   ;; I think we should probably roll our own nxml-comment-dwim function.
-  (make-local-variable 'comment-indent-function)
-  (setq comment-indent-function 'nxml-indent-line)
-  (make-local-variable 'comment-start)
-  (setq comment-start "<!--")
-  (make-local-variable 'comment-start-skip)
-  (setq comment-start-skip "<!--[ \t\r\n]*")
-  (make-local-variable 'comment-end)
-  (setq comment-end "-->")
-  (make-local-variable 'comment-end-skip)
-  (setq comment-end-skip "[ \t\r\n]*-->")
-  (make-local-variable 'comment-line-break-function)
-  (setq comment-line-break-function 'nxml-newline-and-indent)
-  (setq-local comment-quote-nested-function 'nxml-comment-quote-nested)
-  (use-local-map nxml-mode-map)
+  (setq-local comment-indent-function #'nxml-indent-line)
+  (setq-local comment-start "<!--")
+  (setq-local comment-start-skip "<!--[ \t\r\n]*")
+  (setq-local comment-end "-->")
+  (setq-local comment-end-skip "[ \t\r\n]*-->")
+  (setq-local comment-line-break-function #'nxml-newline-and-indent)
+  (setq-local comment-quote-nested-function #'nxml-comment-quote-nested)
   (save-excursion
     (save-restriction
       (widen)
-      (setq nxml-scan-end (copy-marker (point-min) nil))
       (with-silent-modifications
-        (nxml-clear-inside (point-min) (point-max))
         (nxml-with-invisible-motion
           (nxml-scan-prolog)))))
-  (add-hook 'completion-at-point-functions
-            #'nxml-completion-at-point-function nil t)
-  (setq-local syntax-propertize-function #'nxml-after-change)
-  (add-hook 'change-major-mode-hook 'nxml-cleanup nil t)
+  (setq-local syntax-ppss-table sgml-tag-syntax-table)
+  (setq-local syntax-propertize-function sgml-syntax-propertize-function)
+  (add-hook 'change-major-mode-hook #'nxml-cleanup nil t)
 
   ;; Emacs 23 handles the encoding attribute on the xml declaration
   ;; transparently to nxml-mode, so there is no longer a need for the below
   ;; hook. The hook also had the drawback of overriding explicit user
   ;; instruction to save as some encoding other than utf-8.
-  ;;(add-hook 'write-contents-hooks 'nxml-prepare-to-save)
+  ;;(add-hook 'write-contents-hooks #'nxml-prepare-to-save)
   (when (not (and (buffer-file-name) (file-exists-p (buffer-file-name))))
     (when (and nxml-default-buffer-file-coding-system
                (not (local-variable-p 'buffer-file-coding-system)))
@@ -575,16 +535,14 @@ Many aspects this mode can be customized using
 
   (setq font-lock-defaults
         '(nxml-font-lock-keywords
-          t    ; keywords-only; we highlight comments and strings here
+          nil  ; highlight comments and strings based on syntax-tables
           nil  ; font-lock-keywords-case-fold-search. XML is case sensitive
           nil  ; no special syntax table
-          nil  ; no automatic syntactic fontification
           (font-lock-extend-region-functions . (nxml-extend-region))
           (jit-lock-contextually . t)
           (font-lock-unfontify-region-function . nxml-unfontify-region)))
 
-  (rng-nxml-mode-init)
-  (nxml-enable-unicode-char-name-sets))
+  (with-demoted-errors (rng-nxml-mode-init)))
 
 (defun nxml-cleanup ()
   "Clean up after nxml-mode."
@@ -596,7 +554,7 @@ Many aspects this mode can be customized using
     (with-silent-modifications
       (nxml-with-invisible-motion
        (remove-text-properties (point-min) (point-max) '(face)))))
-  (remove-hook 'change-major-mode-hook 'nxml-cleanup t))
+  (remove-hook 'change-major-mode-hook #'nxml-cleanup t))
 
 (defun nxml-degrade (context err)
   (message "Internal nXML mode error in %s (%s), degrading"
@@ -604,12 +562,7 @@ Many aspects this mode can be customized using
            (error-message-string err))
   (ding)
   (setq nxml-degraded t)
-  (setq nxml-prolog-end 1)
-  (save-excursion
-    (save-restriction
-      (widen)
-      (with-silent-modifications
-        (nxml-clear-inside (point-min) (point-max))))))
+  (setq nxml-prolog-end 1))
 
 ;;; Change management
 
@@ -622,41 +575,6 @@ Many aspects this mode can be customized using
     (goto-char font-lock-beg)
     (set-mark font-lock-end)))
 
-(defun nxml-after-change (start end)
-  ;; Called via syntax-propertize-function.
-  (unless nxml-degraded
-    (nxml-with-degradation-on-error 'nxml-after-change
-      (save-restriction
-        (widen)
-        (nxml-with-invisible-motion
-         (nxml-after-change1 start end))))))
-
-(defun nxml-after-change1 (start end)
-  "After-change bookkeeping.
-Returns a cons cell containing a possibly-enlarged change region.
-You must call `nxml-extend-region' on this expanded region to obtain
-the full extent of the area needing refontification.
-
-For bookkeeping, call this function even when fontification is
-disabled."
-  ;; If the prolog might have changed, rescan the prolog.
-  (when (<= start
-            ;; Add 2 so as to include the < and following char that
-            ;; start the instance (document element), since changing
-            ;; these can change where the prolog ends.
-            (+ nxml-prolog-end 2))
-    (nxml-scan-prolog)
-    (setq start (point-min)))
-
-  (when (> end nxml-prolog-end)
-    (goto-char start)
-    (nxml-move-tag-backwards (point-min))
-    (setq start (point))
-    (setq end (max (nxml-scan-after-change start end)
-                   end)))
-
-  (nxml-debug-change "nxml-after-change1" start end))
-
 ;;; Encodings
 
 (defun nxml-insert-xml-declaration ()
@@ -982,11 +900,11 @@ faces appropriately."
        [1 -1 nxml-entity-ref-name]
        [-1 nil nxml-entity-ref-delimiter]))
 
-(put 'comment
-     'nxml-fontify-rule
-     '([nil 4 nxml-comment-delimiter]
-       [4 -3 nxml-comment-content]
-       [-3 nil nxml-comment-delimiter]))
+;; (put 'comment
+;;      'nxml-fontify-rule
+;;      '([nil 4 nxml-comment-delimiter]
+;;        [4 -3 nxml-comment-content]
+;;        [-3 nil nxml-comment-delimiter]))
 
 (put 'processing-instruction
      'nxml-fontify-rule
@@ -1018,7 +936,7 @@ faces appropriately."
      'nxml-fontify-rule
      '([nil nil nxml-attribute-local-name]))
 
-(put 'xml-declaration-attribute-value
+(put 'xml-declaration-attribute-value   ;FIXME: What is this for?
      'nxml-fontify-rule
      '([nil 1 nxml-attribute-value-delimiter]
        [1 -1 nxml-attribute-value]
@@ -1137,28 +1055,11 @@ faces appropriately."
                         'nxml-attribute-prefix
                         'nxml-attribute-colon
                         'nxml-attribute-local-name))
-  (let ((start (xmltok-attribute-value-start att))
-        (end (xmltok-attribute-value-end att))
-        (refs (xmltok-attribute-refs att))
-        (delimiter-face (if namespace-declaration
-                            'nxml-namespace-attribute-value-delimiter
-                          'nxml-attribute-value-delimiter))
-        (value-face (if namespace-declaration
-                        'nxml-namespace-attribute-value
-                      'nxml-attribute-value)))
-    (when start
-      (nxml-set-face (1- start) start delimiter-face)
-      (nxml-set-face end (1+ end) delimiter-face)
-      (while refs
-        (let* ((ref (car refs))
-               (ref-type (aref ref 0))
-               (ref-start (aref ref 1))
-               (ref-end (aref ref 2)))
-          (nxml-set-face start ref-start value-face)
-          (nxml-apply-fontify-rule ref-type ref-start ref-end)
-          (setq start ref-end))
-        (setq refs (cdr refs)))
-      (nxml-set-face start end value-face))))
+  (dolist (ref (xmltok-attribute-refs att))
+    (let* ((ref-type (aref ref 0))
+           (ref-start (aref ref 1))
+           (ref-end (aref ref 2)))
+      (nxml-apply-fontify-rule ref-type ref-start ref-end))))
 
 (defun nxml-fontify-qname (start
                            colon
@@ -1599,30 +1500,7 @@ of the line.  This expects the xmltok-* variables to be set up as by
         (t (back-to-indentation)))
   (current-column))
 
-;;; Completion
-
-(defun nxml-complete ()
-  "Perform completion on the symbol preceding point.
-
-Inserts as many characters as can be completed.  However, if not even
-one character can be completed, then a buffer with the possibilities
-is popped up and the symbol is read from the minibuffer with
-completion.  If the symbol is complete, then any characters that must
-follow the symbol are also inserted.
-
-The name space used for completion and what is treated as a symbol
-depends on the context.  The contexts in which completion is performed
-depend on `nxml-completion-hook'."
-  (interactive)
-  (unless (run-hook-with-args-until-success 'nxml-completion-hook)
-    ;; Eventually we will complete on entity names here.
-    (ding)
-    (message "Cannot complete in this context")))
-
-(defun nxml-completion-at-point-function ()
-  "Call `nxml-complete' to perform completion at point."
-  (when nxml-bind-meta-tab-to-complete-flag
-    #'nxml-complete))
+(define-obsolete-function-alias 'nxml-complete #'completion-at-point "26.1")
 
 ;;; Movement
 
@@ -1674,7 +1552,7 @@ single name.  A character reference contains a character number."
                            (t end)))))
     (nxml-scan-error
      (goto-char (cadr err))
-     (apply 'error (cddr err)))))
+     (apply #'error (cddr err)))))
 
 (defun nxml-backward-single-balanced-item ()
   (condition-case err
@@ -1696,7 +1574,7 @@ single name.  A character reference contains a character number."
                            (t xmltok-start)))))
     (nxml-scan-error
      (goto-char (cadr err))
-     (apply 'error (cddr err)))))
+     (apply #'error (cddr err)))))
 
 (defun nxml-scan-forward-within (end)
   (setq end (- end (nxml-end-delimiter-length xmltok-type)))
@@ -1880,7 +1758,7 @@ single name.  A character reference contains a character number."
           (setq arg (1- arg)))
       (nxml-scan-error
        (goto-char (cadr err))
-       (apply 'error (cddr err))))))
+       (apply #'error (cddr err))))))
 
 (defun nxml-backward-up-element (&optional arg)
   (interactive "p")
@@ -1909,7 +1787,7 @@ single name.  A character reference contains a character number."
           (setq arg (1- arg)))
       (nxml-scan-error
        (goto-char (cadr err))
-       (apply 'error (cddr err))))))
+       (apply #'error (cddr err))))))
 
 (defun nxml-down-element (&optional arg)
   "Move forward down into the content of an element.
@@ -1974,7 +1852,7 @@ Negative ARG means move backward."
           (setq arg (1- arg)))
     (nxml-scan-error
      (goto-char (cadr err))
-     (apply 'error (cddr err))))))
+     (apply #'error (cddr err))))))
 
 (defun nxml-backward-element (&optional arg)
   "Move backward over one element.
@@ -1996,7 +1874,7 @@ Negative ARG means move forward."
           (setq arg (1- arg)))
     (nxml-scan-error
      (goto-char (cadr err))
-     (apply 'error (cddr err))))))
+     (apply #'error (cddr err))))))
 
 (defun nxml-mark-token-after ()
   (interactive)
@@ -2477,116 +2355,15 @@ and attempts to find another possible way to do the markup."
 
 ;;; Character names
 
-(defvar nxml-char-name-ignore-case t)
-
-(defvar nxml-char-name-alist nil
-  "Alist of character names.
-Each member of the list has the form (NAME CODE . NAMESET),
-where NAME is a string naming a character, NAMESET is a symbol
-identifying a set of names and CODE is an integer specifying the
-Unicode scalar value of the named character.
-The NAME will only be used for completion if NAMESET has
-a non-nil `nxml-char-name-set-enabled' property.
-If NAMESET does does not have `nxml-char-name-set-defined' property,
-then it must have a `nxml-char-name-set-file' property and `load'
-will be applied to the value of this property if the nameset
-is enabled.")
-
-(defvar nxml-char-name-table (make-hash-table :test 'eq)
-  "Hash table for mapping char codes to names.
-Each key is a Unicode scalar value.
-Each value is a list of pairs of the form (NAMESET . NAME),
-where NAMESET is a symbol identifying a set of names,
-and NAME is a string naming a character.")
-
-(defvar nxml-autoload-char-name-set-list nil
-  "List of char namesets that can be autoloaded.")
-
-(defun nxml-enable-char-name-set (nameset)
-  (put nameset 'nxml-char-name-set-enabled t))
-
-(defun nxml-disable-char-name-set (nameset)
-  (put nameset 'nxml-char-name-set-enabled nil))
-
-(defun nxml-char-name-set-enabled-p (nameset)
-  (get nameset 'nxml-char-name-set-enabled))
-
-(defun nxml-autoload-char-name-set (nameset file)
-  (unless (memq nameset nxml-autoload-char-name-set-list)
-    (setq nxml-autoload-char-name-set-list
-          (cons nameset nxml-autoload-char-name-set-list)))
-  (put nameset 'nxml-char-name-set-file file))
-
-(defun nxml-define-char-name-set (nameset alist)
-  "Define a set of character names.
-NAMESET is a symbol identifying the set.
-ALIST is a list where each member has the form (NAME CODE),
-where NAME is a string naming a character and code is an
-integer giving the Unicode scalar value of the character."
-  (when (get nameset 'nxml-char-name-set-defined)
-    (error "Nameset `%s' already defined" nameset))
-  (let ((iter alist))
-    (while iter
-      (let* ((name-code (car iter))
-             (name (car name-code))
-             (code (cadr name-code)))
-        (puthash code
-                 (cons (cons nameset name)
-                       (gethash code nxml-char-name-table))
-                 nxml-char-name-table))
-      (setcdr (cdr (car iter)) nameset)
-      (setq iter (cdr iter))))
-  (setq nxml-char-name-alist
-        (nconc alist nxml-char-name-alist))
-  (put nameset 'nxml-char-name-set-defined t))
-
-(defun nxml-get-char-name (code)
-  (mapc 'nxml-maybe-load-char-name-set nxml-autoload-char-name-set-list)
-  (let ((names (gethash code nxml-char-name-table))
-        name)
-    (while (and names (not name))
-      (if (nxml-char-name-set-enabled-p (caar names))
-          (setq name (cdar names))
-        (setq names (cdr names))))
-    name))
-
-(defvar nxml-named-char-history nil)
-
 (defun nxml-insert-named-char (arg)
   "Insert a character using its name.
 The name is read from the minibuffer.
 Normally, inserts the character as a numeric character reference.
 With a prefix argument, inserts the character directly."
   (interactive "*P")
-  (mapc 'nxml-maybe-load-char-name-set nxml-autoload-char-name-set-list)
-  (let ((name
-         (let ((completion-ignore-case nxml-char-name-ignore-case))
-           (completing-read "Character name: "
-                            nxml-char-name-alist
-                            (lambda (member)
-                              (get (cddr member) 'nxml-char-name-set-enabled))
-                            t
-                            nil
-                            'nxml-named-char-history)))
-        (alist nxml-char-name-alist)
-        elt code)
-    (while (and alist (not code))
-      (setq elt (assoc name alist))
-      (if (get (cddr elt) 'nxml-char-name-set-enabled)
-          (setq code (cadr elt))
-        (setq alist (cdr (member elt alist)))))
+  (let ((code (read-char-by-name "Character name: ")))
     (when code
-      (insert (if arg
-                  (or (decode-char 'ucs code)
-                      (error "Character %x is not supported by Emacs"
-                             code))
-                (format "&#x%X;" code))))))
-
-(defun nxml-maybe-load-char-name-set (sym)
-  (when (and (get sym 'nxml-char-name-set-enabled)
-             (not (get sym 'nxml-char-name-set-defined))
-             (stringp (get sym 'nxml-char-name-set-file)))
-    (load (get sym 'nxml-char-name-set-file))))
+      (insert (if arg code (format "&#x%X;" code))))))
 
 (defun nxml-toggle-char-ref-extra-display (arg)
   "Toggle the display of extra information for character references."
@@ -2602,9 +2379,11 @@ With a prefix argument, inserts the character directly."
 
 (defun nxml-char-ref-display-extra (start end n)
   (when nxml-char-ref-extra-display
-    (let ((name (nxml-get-char-name n))
+    (let ((name (or (get-char-code-property n 'name)
+                    (get-char-code-property n 'old-name)))
           (glyph-string (and nxml-char-ref-display-glyph-flag
-                             (nxml-glyph-display-string n 'nxml-glyph)))
+                             (char-displayable-p n)
+                             (string n)))
           ov)
     (when (or name glyph-string)
       (setq ov (make-overlay start end nil t))
diff --git a/lisp/nxml/nxml-outln.el b/lisp/nxml/nxml-outln.el
index 962160cb435..289816a1bba 100644
--- a/lisp/nxml/nxml-outln.el
+++ b/lisp/nxml/nxml-outln.el
@@ -1,4 +1,4 @@
-;;; nxml-outln.el --- outline support for nXML mode
+;;; nxml-outln.el --- outline support for nXML mode  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2004, 2007-2016 Free Software Foundation, Inc.
 
@@ -248,6 +248,16 @@ customize which elements are recognized as sections and headings."
   (interactive)
   (nxml-transform-subtree-outline '((hide-children . t))))
 
+;; These variables are dynamically bound.  They are use to pass information to
+;; nxml-section-tag-transform-outline-state.
+
+(defvar nxml-outline-state-transform-exceptions nil)
+(defvar nxml-target-section-pos nil)
+(defvar nxml-depth-in-target-section nil)
+(defvar nxml-outline-state-transform-alist nil)
+
+(defvar nxml-outline-display-section-tag-function nil)
+
 (defun nxml-hide-other ()
   "Hide text content other than that directly in the section containing point.
 Hide headings other than those of ancestors of that section and their
@@ -275,14 +285,6 @@ customize which elements are recognized as sections and headings."
     (nxml-transform-buffer-outline '((nil . hide-children)
                                      (t . hide-children)))))
 
-;; These variables are dynamically bound.  They are use to pass information to
-;; nxml-section-tag-transform-outline-state.
-
-(defvar nxml-outline-state-transform-exceptions nil)
-(defvar nxml-target-section-pos nil)
-(defvar nxml-depth-in-target-section nil)
-(defvar nxml-outline-state-transform-alist nil)
-
 (defun nxml-transform-buffer-outline (alist)
   (let ((nxml-target-section-pos nil)
         (nxml-depth-in-target-section 0)
@@ -350,7 +352,7 @@ customize which elements are recognized as sections and headings."
 (defun nxml-section-tag-transform-outline-state (startp
                                                  section-start-pos
                                                  &optional
-                                                 heading-start-pos)
+                                                 _heading-start-pos)
   (if (not startp)
       (setq nxml-depth-in-target-section
             (and nxml-depth-in-target-section
@@ -427,8 +429,6 @@ customize which elements are recognized as sections and headings."
       (nxml-outline-error
        (nxml-report-outline-error "Cannot display outline: %s" err)))))
 
-(defvar nxml-outline-display-section-tag-function nil)
-
 (defun nxml-outline-display-rest (outline-state start-tag-indent tag-qnames)
   "Display up to and including the end of the current element.
 OUTLINE-STATE can be nil, t, hide-children.  START-TAG-INDENT is the
@@ -789,7 +789,7 @@ no new overlay will be created."
 (defun nxml-end-of-heading ()
   "Move from the start of the content of the heading to the end.
 Do not move past the end of the line."
-  (let ((pos (condition-case err
+  (let ((pos (condition-case nil
                  (and (nxml-scan-element-forward (point) t)
                       xmltok-start)
                (nxml-scan-error nil))))
@@ -888,7 +888,7 @@ Point is at the end of the tag.  `xmltok-start' is the start."
                       (nxml-ensure-scan-up-to-date)
                       (let ((pos (nxml-inside-start (point))))
                         (when pos
-                          (goto-char (1- pos))
+                          (goto-char pos)
                           t))))
                    ((progn
                       (xmltok-forward)
diff --git a/lisp/nxml/nxml-parse.el b/lisp/nxml/nxml-parse.el
index 41b2e8ee513..edf012921a9 100644
--- a/lisp/nxml/nxml-parse.el
+++ b/lisp/nxml/nxml-parse.el
@@ -1,4 +1,4 @@
-;;; nxml-parse.el --- XML parser, sharing infrastructure with nxml-mode
+;;; nxml-parse.el --- XML parser, sharing infrastructure with nxml-mode  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
diff --git a/lisp/nxml/nxml-rap.el b/lisp/nxml/nxml-rap.el
index 47b23da62ad..e66289d042a 100644
--- a/lisp/nxml/nxml-rap.el
+++ b/lisp/nxml/nxml-rap.el
@@ -1,4 +1,4 @@
-;;; nxml-rap.el --- low-level support for random access parsing for nXML mode
+;;; nxml-rap.el --- low-level support for random access parsing for nXML mode  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003-2004, 2007-2016 Free Software Foundation, Inc.
 
@@ -46,8 +46,7 @@
 ;; look like it scales to large numbers of overlays in a buffer.
 ;;
 ;; We don't in fact track all these constructs, but only track them in
-;; some initial part of the instance. The variable `nxml-scan-end'
-;; contains the limit of where we have scanned up to for them.
+;; some initial part of the instance.
 ;;
 ;; Thus to parse some random point in the file we first ensure that we
 ;; have scanned up to that point.  Then we search backwards for a
@@ -74,93 +73,33 @@
 
 (require 'xmltok)
 (require 'nxml-util)
+(require 'sgml-mode)
 
-(defvar nxml-prolog-end nil
+(defvar-local nxml-prolog-end nil
   "Integer giving position following end of the prolog.")
-(make-variable-buffer-local 'nxml-prolog-end)
-
-(defvar nxml-scan-end nil
-  "Marker giving position up to which we have scanned.
-nxml-scan-end must be >= nxml-prolog-end.  Furthermore, nxml-scan-end
-must not be an inside position in the following sense.  A position is
-inside if the following character is a part of, but not the first
-character of, a CDATA section, comment or processing instruction.
-Furthermore all positions >= nxml-prolog-end and < nxml-scan-end that
-are inside positions must have a non-nil `nxml-inside' property whose
-value is a symbol specifying what it is inside.  Any characters with a
-non-nil `fontified' property must have position < nxml-scan-end and
-the correct face.  Dependent regions must also be established for any
-unclosed constructs starting before nxml-scan-end.
-There must be no `nxml-inside' properties after nxml-scan-end.")
-(make-variable-buffer-local 'nxml-scan-end)
 
 (defsubst nxml-get-inside (pos)
-  (get-text-property pos 'nxml-inside))
-
-(defsubst nxml-clear-inside (start end)
-  (nxml-debug-clear-inside start end)
-  (remove-text-properties start end '(nxml-inside nil)))
-
-(defsubst nxml-set-inside (start end type)
-  (nxml-debug-set-inside start end)
-  (put-text-property start end 'nxml-inside type))
+  (save-excursion (nth 8 (syntax-ppss pos))))
 
 (defun nxml-inside-end (pos)
   "Return the end of the inside region containing POS.
 Return nil if the character at POS is not inside."
-  (if (nxml-get-inside pos)
-      (or (next-single-property-change pos 'nxml-inside)
-          (point-max))
-    nil))
+  (save-excursion
+    (let ((ppss (syntax-ppss pos)))
+      (when (nth 8 ppss)
+        (goto-char (nth 8 ppss))
+        (with-syntax-table sgml-tag-syntax-table
+          (if (nth 3 ppss)
+              (progn (forward-comment 1) (point))
+            (or (scan-sexps (point) 1) (point-max))))))))
 
 (defun nxml-inside-start (pos)
   "Return the start of the inside region containing POS.
 Return nil if the character at POS is not inside."
-  (if (nxml-get-inside pos)
-      (or (previous-single-property-change (1+ pos) 'nxml-inside)
-          (point-min))
-    nil))
+  (save-excursion (nth 8 (syntax-ppss pos))))
 
 ;;; Change management
 
-(defun nxml-scan-after-change (start end)
-  "Restore `nxml-scan-end' invariants after a change.
-The change happened between START and END.
-Return position after which lexical state is unchanged.
-END must be > `nxml-prolog-end'.  START must be outside
-any “inside” regions and at the beginning of a token."
-  (if (>= start nxml-scan-end)
-      nxml-scan-end
-    (let ((inside-remove-start start)
-          xmltok-errors)
-      (while (or (when (xmltok-forward-special (min end nxml-scan-end))
-                   (when (memq xmltok-type
-                               '(comment
-                                 cdata-section
-                                 processing-instruction))
-                     (nxml-clear-inside inside-remove-start
-                                        (1+ xmltok-start))
-                     (nxml-set-inside (1+ xmltok-start)
-                                      (point)
-                                      xmltok-type)
-                     (setq inside-remove-start (point)))
-                   (if (< (point) (min end nxml-scan-end))
-                       t
-                     (setq end (point))
-                     nil))
-                 ;; The end of the change was inside but is now outside.
-                 ;; Imagine something really weird like
-                 ;; <![CDATA[foo <!-- bar ]]> <![CDATA[ stuff --> <!-- ]]> -->
-                 ;; and suppose we deleted "<![CDATA[f"
-                 (let ((inside-end (nxml-inside-end end)))
-                   (when inside-end
-                     (setq end inside-end)
-                     t))))
-      (nxml-clear-inside inside-remove-start end))
-    (when (> end nxml-scan-end)
-      (set-marker nxml-scan-end end))
-    end))
-
 ;; n-s-p only called from nxml-mode.el, where this variable is defined.
 (defvar nxml-prolog-regions)
 
@@ -169,10 +108,7 @@ any “inside” regions and at the beginning of a token."
   (let (xmltok-dtd
         xmltok-errors)
     (setq nxml-prolog-regions (xmltok-forward-prolog))
-    (setq nxml-prolog-end (point))
-    (nxml-clear-inside (point-min) nxml-prolog-end))
-  (when (< nxml-scan-end nxml-prolog-end)
-    (set-marker nxml-scan-end nxml-prolog-end)))
+    (setq nxml-prolog-end (point))))
 
 
 ;;; Random access parsing
@@ -223,14 +159,7 @@ Sets variables like `nxml-token-after'."
 
 (defun nxml-tokenize-forward ()
   (let (xmltok-errors)
-    (when (and (xmltok-forward)
-               (> (point) nxml-scan-end))
-      (cond ((memq xmltok-type '(comment
-                                 cdata-section
-                                 processing-instruction))
-             (with-silent-modifications
-               (nxml-set-inside (1+ xmltok-start) (point) xmltok-type))))
-      (set-marker nxml-scan-end (point)))
+    (xmltok-forward)
     xmltok-type))
 
 (defun nxml-move-tag-backwards (bound)
@@ -253,32 +182,12 @@ As a precondition, point must be >= BOUND."
 Leave point unmoved if it is not inside anything special."
   (let ((start (nxml-inside-start (point))))
     (when start
-      (goto-char (1- start))
+      (goto-char start)
       (when (nxml-get-inside (point))
-        (error "Char before inside-start at %s had nxml-inside property %s"
-               (point)
-               (nxml-get-inside (point)))))))
+        (error "Char before inside-start at %s is still \"inside\"" (point))))))
 
 (defun nxml-ensure-scan-up-to-date ()
-  (let ((pos (point)))
-    (when (< nxml-scan-end pos)
-      (save-excursion
-        (goto-char nxml-scan-end)
-        (let (xmltok-errors)
-          (while (when (xmltok-forward-special pos)
-                   (when (memq xmltok-type
-                               '(comment
-                                 processing-instruction
-                                 cdata-section))
-                     (with-silent-modifications
-                       (nxml-set-inside (1+ xmltok-start)
-                                        (point)
-                                        xmltok-type)))
-                   (if (< (point) pos)
-                       t
-                     (setq pos (point))
-                     nil)))
-          (set-marker nxml-scan-end pos))))))
+  (syntax-propertize (point)))
 
 ;;; Element scanning
 
diff --git a/lisp/nxml/nxml-uchnm.el b/lisp/nxml/nxml-uchnm.el
deleted file mode 100644
index 7d7d785f152..00000000000
--- a/lisp/nxml/nxml-uchnm.el
+++ /dev/null
@@ -1,251 +0,0 @@
-;;; nxml-uchnm.el --- support for Unicode standard cha names in nxml-mode
-
-;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
-
-;; Author: James Clark
-;; Keywords: wp, hypermedia, languages, XML
-
-;; 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:
-
-;; This enables the use of the character names defined in the Unicode
-;; Standard.  The use of the names can be controlled on a per-block
-;; basis, so as both to reduce memory usage and loading time,
-;; and to make completion work better.
-
-;;; Code:
-
-(require 'nxml-mode)
-
-(defconst nxml-unicode-blocks
-  '(("Basic Latin" #x0000 #x007F)
-    ("Latin-1 Supplement" #x0080 #x00FF)
-    ("Latin Extended-A" #x0100 #x017F)
-    ("Latin Extended-B" #x0180 #x024F)
-    ("IPA Extensions" #x0250 #x02AF)
-    ("Spacing Modifier Letters" #x02B0 #x02FF)
-    ("Combining Diacritical Marks" #x0300 #x036F)
-    ("Greek and Coptic" #x0370 #x03FF)
-    ("Cyrillic" #x0400 #x04FF)
-    ("Cyrillic Supplementary" #x0500 #x052F)
-    ("Armenian" #x0530 #x058F)
-    ("Hebrew" #x0590 #x05FF)
-    ("Arabic" #x0600 #x06FF)
-    ("Syriac" #x0700 #x074F)
-    ("Thaana" #x0780 #x07BF)
-    ("Devanagari" #x0900 #x097F)
-    ("Bengali" #x0980 #x09FF)
-    ("Gurmukhi" #x0A00 #x0A7F)
-    ("Gujarati" #x0A80 #x0AFF)
-    ("Oriya" #x0B00 #x0B7F)
-    ("Tamil" #x0B80 #x0BFF)
-    ("Telugu" #x0C00 #x0C7F)
-    ("Kannada" #x0C80 #x0CFF)
-    ("Malayalam" #x0D00 #x0D7F)
-    ("Sinhala" #x0D80 #x0DFF)
-    ("Thai" #x0E00 #x0E7F)
-    ("Lao" #x0E80 #x0EFF)
-    ("Tibetan" #x0F00 #x0FFF)
-    ("Myanmar" #x1000 #x109F)
-    ("Georgian" #x10A0 #x10FF)
-    ("Hangul Jamo" #x1100 #x11FF)
-    ("Ethiopic" #x1200 #x137F)
-    ("Cherokee" #x13A0 #x13FF)
-    ("Unified Canadian Aboriginal Syllabics" #x1400 #x167F)
-    ("Ogham" #x1680 #x169F)
-    ("Runic" #x16A0 #x16FF)
-    ("Tagalog" #x1700 #x171F)
-    ("Hanunoo" #x1720 #x173F)
-    ("Buhid" #x1740 #x175F)
-    ("Tagbanwa" #x1760 #x177F)
-    ("Khmer" #x1780 #x17FF)
-    ("Mongolian" #x1800 #x18AF)
-    ("Latin Extended Additional" #x1E00 #x1EFF)
-    ("Greek Extended" #x1F00 #x1FFF)
-    ("General Punctuation" #x2000 #x206F)
-    ("Superscripts and Subscripts" #x2070 #x209F)
-    ("Currency Symbols" #x20A0 #x20CF)
-    ("Combining Diacritical Marks for Symbols" #x20D0 #x20FF)
-    ("Letterlike Symbols" #x2100 #x214F)
-    ("Number Forms" #x2150 #x218F)
-    ("Arrows" #x2190 #x21FF)
-    ("Mathematical Operators" #x2200 #x22FF)
-    ("Miscellaneous Technical" #x2300 #x23FF)
-    ("Control Pictures" #x2400 #x243F)
-    ("Optical Character Recognition" #x2440 #x245F)
-    ("Enclosed Alphanumerics" #x2460 #x24FF)
-    ("Box Drawing" #x2500 #x257F)
-    ("Block Elements" #x2580 #x259F)
-    ("Geometric Shapes" #x25A0 #x25FF)
-    ("Miscellaneous Symbols" #x2600 #x26FF)
-    ("Dingbats" #x2700 #x27BF)
-    ("Miscellaneous Mathematical Symbols-A" #x27C0 #x27EF)
-    ("Supplemental Arrows-A" #x27F0 #x27FF)
-    ("Braille Patterns" #x2800 #x28FF)
-    ("Supplemental Arrows-B" #x2900 #x297F)
-    ("Miscellaneous Mathematical Symbols-B" #x2980 #x29FF)
-    ("Supplemental Mathematical Operators" #x2A00 #x2AFF)
-    ("CJK Radicals Supplement" #x2E80 #x2EFF)
-    ("Kangxi Radicals" #x2F00 #x2FDF)
-    ("Ideographic Description Characters" #x2FF0 #x2FFF)
-    ("CJK Symbols and Punctuation" #x3000 #x303F)
-    ("Hiragana" #x3040 #x309F)
-    ("Katakana" #x30A0 #x30FF)
-    ("Bopomofo" #x3100 #x312F)
-    ("Hangul Compatibility Jamo" #x3130 #x318F)
-    ("Kanbun" #x3190 #x319F)
-    ("Bopomofo Extended" #x31A0 #x31BF)
-    ("Katakana Phonetic Extensions" #x31F0 #x31FF)
-    ("Enclosed CJK Letters and Months" #x3200 #x32FF)
-    ("CJK Compatibility" #x3300 #x33FF)
-    ("CJK Unified Ideographs Extension A" #x3400 #x4DBF)
-    ;;("CJK Unified Ideographs" #x4E00 #x9FFF)
-    ("Yi Syllables" #xA000 #xA48F)
-    ("Yi Radicals" #xA490 #xA4CF)
-    ;;("Hangul Syllables" #xAC00 #xD7AF)
-    ;;("High Surrogates" #xD800 #xDB7F)
-    ;;("High Private Use Surrogates" #xDB80 #xDBFF)
-    ;;("Low Surrogates" #xDC00 #xDFFF)
-    ;;("Private Use Area" #xE000 #xF8FF)
-    ;;("CJK Compatibility Ideographs" #xF900 #xFAFF)
-    ("Alphabetic Presentation Forms" #xFB00 #xFB4F)
-    ("Arabic Presentation Forms-A" #xFB50 #xFDFF)
-    ("Variation Selectors" #xFE00 #xFE0F)
-    ("Combining Half Marks" #xFE20 #xFE2F)
-    ("CJK Compatibility Forms" #xFE30 #xFE4F)
-    ("Small Form Variants" #xFE50 #xFE6F)
-    ("Arabic Presentation Forms-B" #xFE70 #xFEFF)
-    ("Halfwidth and Fullwidth Forms" #xFF00 #xFFEF)
-    ("Specials" #xFFF0 #xFFFF)
-    ("Old Italic" #x10300 #x1032F)
-    ("Gothic" #x10330 #x1034F)
-    ("Deseret" #x10400 #x1044F)
-    ("Byzantine Musical Symbols" #x1D000 #x1D0FF)
-    ("Musical Symbols" #x1D100 #x1D1FF)
-    ("Mathematical Alphanumeric Symbols" #x1D400 #x1D7FF)
-    ;;("CJK Unified Ideographs Extension B" #x20000 #x2A6DF)
-    ;;("CJK Compatibility Ideographs Supplement" #x2F800 #x2FA1F)
-    ("Tags" #xE0000 #xE007F)
-    ;;("Supplementary Private Use Area-A" #xF0000 #xFFFFF)
-    ;;("Supplementary Private Use Area-B" #x100000 #x10FFFF)
-    )
-  "List of Unicode blocks.
-For each block there is a list (NAME FIRST LAST), where
-NAME is a string giving the official name of the block,
-FIRST is the first code-point and LAST is the last code-point.
-Blocks containing only characters with algorithmic names or no names
-are omitted.")
-
-(defun nxml-unicode-block-char-name-set (name)
-  "Return a symbol for a block whose official Unicode name is NAME.
-The symbol is generated by downcasing and replacing each space
-by a hyphen."
-  (intern (replace-regexp-in-string " " "-" (downcase name))))
-
-;; This is intended to be a superset of the coverage
-;; of existing standard entity sets.
-(defvar nxml-enabled-unicode-blocks-default
-  '(basic-latin
-    latin-1-supplement
-    latin-extended-a
-    latin-extended-b
-    ipa-extensions
-    spacing-modifier-letters
-    combining-diacritical-marks
-    greek-and-coptic
-    cyrillic
-    general-punctuation
-    superscripts-and-subscripts
-    currency-symbols
-    combining-diacritical-marks-for-symbols
-    letterlike-symbols
-    number-forms
-    arrows
-    mathematical-operators
-    miscellaneous-technical
-    control-pictures
-    optical-character-recognition
-    enclosed-alphanumerics
-    box-drawing
-    block-elements
-    geometric-shapes
-    miscellaneous-symbols
-    dingbats
-    miscellaneous-mathematical-symbols-a
-    supplemental-arrows-a
-    supplemental-arrows-b
-    miscellaneous-mathematical-symbols-b
-    supplemental-mathematical-operators
-    cjk-symbols-and-punctuation
-    alphabetic-presentation-forms
-    variation-selectors
-    small-form-variants
-    specials
-    mathematical-alphanumeric-symbols)
-  "Default value for `nxml-enabled-unicode-blocks'.")
-
-(mapc (lambda (block)
-        (nxml-autoload-char-name-set
-         (nxml-unicode-block-char-name-set (car block))
-         (expand-file-name
-          (format "nxml/%05X-%05X"
-                  (nth 1 block)
-                  (nth 2 block))
-          data-directory)))
-      nxml-unicode-blocks)
-
-;; Internal flag to control whether customize reloads the character tables.
-;; Should be set the first time the
-(defvar nxml-internal-unicode-char-name-sets-enabled nil)
-
-(defcustom nxml-enabled-unicode-blocks nxml-enabled-unicode-blocks-default
-  "List of Unicode blocks for which Unicode character names are enabled.
-Each block is identified by a symbol derived from the name
-of the block by downcasing and replacing each space by a hyphen."
-  :group 'nxml
-  :set (lambda (sym value)
-         (set-default 'nxml-enabled-unicode-blocks value)
-         (when nxml-internal-unicode-char-name-sets-enabled
-           (nxml-enable-unicode-char-name-sets)))
-  :type (cons 'set
-              (mapcar (lambda (block)
-                        `(const :tag ,(format "%s (%04X-%04X)"
-                                              (nth 0 block)
-                                              (nth 1 block)
-                                              (nth 2 block))
-                                ,(nxml-unicode-block-char-name-set
-                                  (nth 0 block))))
-                      nxml-unicode-blocks)))
-
-;;;###autoload
-(defun nxml-enable-unicode-char-name-sets ()
-  "Enable the use of Unicode standard names for characters.
-The Unicode blocks for which names are enabled is controlled by
-the variable `nxml-enabled-unicode-blocks'."
-  (interactive)
-  (setq nxml-internal-unicode-char-name-sets-enabled t)
-  (mapc (lambda (block)
-          (nxml-disable-char-name-set
-           (nxml-unicode-block-char-name-set (car block))))
-        nxml-unicode-blocks)
-  (mapc (lambda (nameset)
-          (nxml-enable-char-name-set nameset))
-        nxml-enabled-unicode-blocks))
-
-(provide 'nxml-uchnm)
-
-;;; nxml-uchnm.el ends here
diff --git a/lisp/nxml/nxml-util.el b/lisp/nxml/nxml-util.el
index 14b887ea085..282d4952bf7 100644
--- a/lisp/nxml/nxml-util.el
+++ b/lisp/nxml/nxml-util.el
@@ -36,20 +36,6 @@
     `(nxml-debug "%s: %S" ,name
                 (buffer-substring-no-properties ,start ,end))))
 
-(defmacro nxml-debug-set-inside (start end)
-  (when nxml-debug
-    `(let ((overlay (make-overlay ,start ,end)))
-       (overlay-put overlay 'face '(:background "red"))
-       (overlay-put overlay 'nxml-inside-debug t)
-       (nxml-debug-change "nxml-set-inside" ,start ,end))))
-
-(defmacro nxml-debug-clear-inside (start end)
-  (when nxml-debug
-    `(cl-loop for overlay in (overlays-in ,start ,end)
-           if (overlay-get overlay 'nxml-inside-debug)
-           do (delete-overlay overlay)
-           finally (nxml-debug-change "nxml-clear-inside" ,start ,end))))
-
 (defun nxml-make-namespace (str)
   "Return a symbol for the namespace URI STR.
 STR must be a string.  If STR is the empty string, return nil.
diff --git a/lisp/nxml/rng-cmpct.el b/lisp/nxml/rng-cmpct.el
index 39aee9780ff..a699e9e3d96 100644
--- a/lisp/nxml/rng-cmpct.el
+++ b/lisp/nxml/rng-cmpct.el
@@ -1,4 +1,4 @@
-;;; rng-cmpct.el --- parsing of RELAX NG Compact Syntax schemas
+;;; rng-cmpct.el --- parsing of RELAX NG Compact Syntax schemas  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
diff --git a/lisp/nxml/rng-dt.el b/lisp/nxml/rng-dt.el
index 07166e38fea..a3cb8bc6aa5 100644
--- a/lisp/nxml/rng-dt.el
+++ b/lisp/nxml/rng-dt.el
@@ -1,4 +1,4 @@
-;;; rng-dt.el --- datatype library interface for RELAX NG
+;;; rng-dt.el --- datatype library interface for RELAX NG  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
@@ -57,7 +57,7 @@ a datatype library.")
         (t
          (rng-dt-error "There is no built-in datatype %s" name))))
 
-(put (rng-make-datatypes-uri "") 'rng-dt-compile 'rng-dt-builtin-compile)
+(put (rng-make-datatypes-uri "") 'rng-dt-compile #'rng-dt-builtin-compile)
 
 (provide 'rng-dt)
 
diff --git a/lisp/nxml/rng-loc.el b/lisp/nxml/rng-loc.el
index 553d8ca359d..376e9169d37 100644
--- a/lisp/nxml/rng-loc.el
+++ b/lisp/nxml/rng-loc.el
@@ -1,4 +1,4 @@
-;;; rng-loc.el --- locate the schema to use for validation
+;;; rng-loc.el --- Locate the schema to use for validation  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
@@ -31,10 +31,9 @@
 (require 'rng-util)
 (require 'xmltok)
 
-(defvar rng-current-schema-file-name nil
+(defvar-local rng-current-schema-file-name nil
   "Filename of schema being used for current buffer.
 It is nil if using a vacuous schema.")
-(make-variable-buffer-local 'rng-current-schema-file-name)
 
 (defvar rng-schema-locating-files-default
   (list "schemas.xml" (expand-file-name "schema/schemas.xml" data-directory))
@@ -233,11 +232,11 @@ or nil."
                                  rules))))))))
     best-so-far))
 
-(put 'documentElement 'rng-rule-matcher 'rng-match-document-element-rule)
-(put 'namespace 'rng-rule-matcher 'rng-match-namespace-rule)
-(put 'uri 'rng-rule-matcher 'rng-match-uri-rule)
-(put 'transformURI 'rng-rule-matcher 'rng-match-transform-uri-rule)
-(put 'default 'rng-rule-matcher 'rng-match-default-rule)
+(put 'documentElement 'rng-rule-matcher #'rng-match-document-element-rule)
+(put 'namespace 'rng-rule-matcher #'rng-match-namespace-rule)
+(put 'uri 'rng-rule-matcher #'rng-match-uri-rule)
+(put 'transformURI 'rng-rule-matcher #'rng-match-transform-uri-rule)
+(put 'default 'rng-rule-matcher #'rng-match-default-rule)
 
 (defun rng-match-document-element-rule (props)
   (let ((document-element (rng-document-element))
diff --git a/lisp/nxml/rng-maint.el b/lisp/nxml/rng-maint.el
index 165ca8930a4..32a041e0c17 100644
--- a/lisp/nxml/rng-maint.el
+++ b/lisp/nxml/rng-maint.el
@@ -1,4 +1,4 @@
-;;; rng-maint.el --- commands for RELAX NG maintainers
+;;; rng-maint.el --- commands for RELAX NG maintainers  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
diff --git a/lisp/nxml/rng-match.el b/lisp/nxml/rng-match.el
index df9c0192557..d2b629e8d83 100644
--- a/lisp/nxml/rng-match.el
+++ b/lisp/nxml/rng-match.el
@@ -56,9 +56,8 @@ Used to detect invalid recursive references.")
 ;;; Inline functions
 
 (defsubst rng-update-match-state (new-state)
-  (if (and (eq new-state rng-not-allowed-ipattern)
-           (not (eq rng-match-state rng-not-allowed-ipattern)))
-      nil
+  (if (eq new-state rng-not-allowed-ipattern)
+      (eq rng-match-state rng-not-allowed-ipattern)
     (setq rng-match-state new-state)
     t))
 
diff --git a/lisp/nxml/rng-nxml.el b/lisp/nxml/rng-nxml.el
index fe90dffb555..954a1eb9599 100644
--- a/lisp/nxml/rng-nxml.el
+++ b/lisp/nxml/rng-nxml.el
@@ -1,4 +1,4 @@
-;;; rng-nxml.el --- make nxml-mode take advantage of rng-validate-mode
+;;; rng-nxml.el --- make nxml-mode take advantage of rng-validate-mode  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
@@ -33,6 +33,7 @@
 (require 'rng-valid)
 (require 'nxml-mode)
 (require 'rng-loc)
+(require 'sgml-mode)
 
 (defcustom rng-nxml-auto-validate-flag t
   "Non-nil means automatically turn on validation with nxml-mode."
@@ -65,6 +66,9 @@ Complete on start-tag names regardless.")
     ["Validation" rng-validate-mode
      :style toggle
      :selected rng-validate-mode]
+    ["Electric Pairs" sgml-electric-tag-pair-mode
+     :style toggle
+     :selected sgml-electric-tag-pair-mode]
     "---"
     ("Set Schema"
      ["Automatically" rng-auto-set-schema]
@@ -107,25 +111,15 @@ Validation will be enabled if `rng-nxml-auto-validate-flag' is non-nil."
                'append)
   (cond (rng-nxml-auto-validate-flag
          (rng-validate-mode 1)
-         (add-hook 'nxml-completion-hook 'rng-complete nil t)
-         (add-hook 'nxml-in-mixed-content-hook 'rng-in-mixed-content-p nil t))
+         (add-hook 'completion-at-point-functions #'rng-completion-at-point nil t)
+         (add-hook 'nxml-in-mixed-content-hook #'rng-in-mixed-content-p nil t))
         (t
          (rng-validate-mode 0)
-         (remove-hook 'nxml-completion-hook 'rng-complete t)
-         (remove-hook 'nxml-in-mixed-content-hook 'rng-in-mixed-content-p t))))
-
-(defvar rng-tag-history nil)
-(defvar rng-attribute-name-history nil)
-(defvar rng-attribute-value-history nil)
-
-(defvar rng-complete-target-names nil)
-(defvar rng-complete-name-attribute-flag nil)
-(defvar rng-complete-extra-strings nil)
+         (remove-hook 'completion-at-point-functions #'rng-completion-at-point t)
+         (remove-hook 'nxml-in-mixed-content-hook #'rng-in-mixed-content-p t))))
 
-(defun rng-complete ()
-  "Complete the string before point using the current schema.
-Return non-nil if in a context it understands."
-  (interactive)
+(defun rng-completion-at-point ()
+  "Return completion data for the string before point using the current schema."
   (and rng-validate-mode
        (let ((lt-pos (save-excursion (search-backward "<" nil t)))
              xmltok-dtd)
@@ -145,53 +139,48 @@ Return non-nil if in a context it understands."
    t))
 
 (defun rng-complete-tag (lt-pos)
-  (let (rng-complete-extra-strings)
-    (when (and (= lt-pos (1- (point)))
-               rng-complete-end-tags-after-<
-               rng-open-elements
-               (not (eq (car rng-open-elements) t))
-               (or rng-collecting-text
-                   (rng-match-save
-                     (rng-match-end-tag))))
-      (setq rng-complete-extra-strings
-            (cons (concat "/"
-                          (if (caar rng-open-elements)
-                              (concat (caar rng-open-elements)
-                                      ":"
-                                      (cdar rng-open-elements))
-                            (cdar rng-open-elements)))
-                  rng-complete-extra-strings)))
+  (let ((extra-strings
+         (when (and (= lt-pos (1- (point)))
+                    rng-complete-end-tags-after-<
+                    rng-open-elements
+                    (not (eq (car rng-open-elements) t))
+                    (or rng-collecting-text
+                        (rng-match-save
+                          (rng-match-end-tag))))
+           (list (concat "/"
+                         (if (caar rng-open-elements)
+                             (concat (caar rng-open-elements)
+                                     ":"
+                                     (cdar rng-open-elements))
+                           (cdar rng-open-elements)))))))
     (when (save-excursion
             (re-search-backward rng-in-start-tag-name-regex
                                 lt-pos
                                 t))
       (and rng-collecting-text (rng-flush-text))
-      (let ((completion
-             (let ((rng-complete-target-names
-                    (rng-match-possible-start-tag-names))
-                   (rng-complete-name-attribute-flag nil))
-               (rng-complete-before-point (1+ lt-pos)
-                                          'rng-complete-qname-function
-                                          "Tag: "
-                                          nil
-                                          'rng-tag-history)))
-            name)
-        (when completion
-          (cond ((rng-qname-p completion)
-                 (setq name (rng-expand-qname completion
-                                              t
-                                              'rng-start-tag-expand-recover))
-                 (when (and name
-                            (rng-match-start-tag-open name)
-                            (or (not (rng-match-start-tag-close))
-                                ;; need a namespace decl on the root element
-                                (and (car name)
-                                     (not rng-open-elements))))
-                   ;; attributes are required
-                   (insert " ")))
-                ((member completion rng-complete-extra-strings)
-                 (insert ">")))))
-      t)))
+      (let ((target-names (rng-match-possible-start-tag-names)))
+        `(,(1+ lt-pos)
+          ,(save-excursion (skip-chars-forward "[[:alnum:]_.-:]") (point))
+          ,(apply-partially #'rng-complete-qname-function
+                            target-names nil extra-strings)
+          :exit-function
+          ,(lambda (completion status)
+             (cond
+              ((not (eq status 'finished)) nil)
+              ((rng-qname-p completion)
+               (let ((name (rng-expand-qname completion
+                                             t
+                                             #'rng-start-tag-expand-recover)))
+                 (when (and name
+                            (rng-match-start-tag-open name)
+                            (or (not (rng-match-start-tag-close))
+                                ;; need a namespace decl on the root element
+                                (and (car name)
+                                     (not rng-open-elements))))
+                   ;; attributes are required
+                   (insert " "))))
+              ((member completion extra-strings)
+               (insert ">")))))))))
 
 (defconst rng-in-end-tag-name-regex
   (replace-regexp-in-string
@@ -216,29 +205,18 @@ Return non-nil if in a context it understands."
                       (concat (caar rng-open-elements)
                               ":"
                               (cdar rng-open-elements))
-                    (cdar rng-open-elements)))
-                 (end-tag-name
-                  (buffer-substring-no-properties (+ (match-beginning 0) 2)
-                                                  (point))))
-             (cond ((or (> (length end-tag-name)
-                           (length start-tag-name))
-                        (not (string= (substring start-tag-name
-                                                 0
-                                                 (length end-tag-name))
-                                      end-tag-name)))
-                    (message "Expected end-tag %s"
-                             (rng-quote-string
-                              (concat "</" start-tag-name ">")))
-                    (ding))
-                   (t
-                    (delete-region (- (point) (length end-tag-name))
-                                   (point))
-                    (insert start-tag-name ">")
-                    (when (not (or rng-collecting-text
-                                   (rng-match-end-tag)))
-                      (message "Element %s is incomplete"
-                               (rng-quote-string start-tag-name))))))))
-    t))
+                    (cdar rng-open-elements))))
+             `(,(+ (match-beginning 0) 2)
+               ,(save-excursion (skip-chars-forward "[[:alnum:]_.-:]") (point))
+               ,(list start-tag-name)   ;Sole completion candidate.
+               :exit-function
+               ,(lambda (_completion status)
+                  (when (eq status 'finished)
+                    (unless (eq (char-after) ?>) (insert ">"))
+                    (when (not (or rng-collecting-text
+                                   (rng-match-end-tag)))
+                      (message "Element \"%s\" is incomplete"
+                               start-tag-name))))))))))
 
 (defconst rng-in-attribute-regex
   (replace-regexp-in-string
@@ -260,22 +238,24 @@ Return non-nil if in a context it understands."
           rng-undeclared-prefixes)
       (and (rng-adjust-state-for-attribute lt-pos
                                            attribute-start)
-           (let ((rng-complete-target-names
+           (let ((target-names
                   (rng-match-possible-attribute-names))
-                 (rng-complete-extra-strings
+                 (extra-strings
                   (mapcar (lambda (prefix)
                             (if prefix
                                 (concat "xmlns:" prefix)
                               "xmlns"))
-                          rng-undeclared-prefixes))
-                 (rng-complete-name-attribute-flag t))
-             (rng-complete-before-point attribute-start
-                                        'rng-complete-qname-function
-                                        "Attribute: "
-                                        nil
-                                        'rng-attribute-name-history))
-           (insert "=\"")))
-    t))
+                          rng-undeclared-prefixes)))
+             `(,attribute-start
+               ,(save-excursion (skip-chars-forward "[[:alnum:]_.-:]") (point))
+               ,(apply-partially #'rng-complete-qname-function
+                                 target-names t extra-strings)
+               :exit-function
+               ,(lambda (_completion status)
+                  (when (and (eq status 'finished)
+                             (not (looking-at "=")))
+                    (insert "=\"\"")
+                    (forward-char -1)))))))))
 
 (defconst rng-in-attribute-value-regex
   (replace-regexp-in-string
@@ -292,43 +272,40 @@ Return non-nil if in a context it understands."
 (defun rng-complete-attribute-value (lt-pos)
   (when (save-excursion
           (re-search-backward rng-in-attribute-value-regex lt-pos t))
-    (let ((name-start (match-beginning 1))
-          (name-end (match-end 1))
-          (colon (match-beginning 2))
-          (value-start (1+ (match-beginning 3))))
+    (let* ((name-start (match-beginning 1))
+           (name-end (match-end 1))
+           (colon (match-beginning 2))
+           (value-start (1+ (match-beginning 3)))
+           (exit-function
+            (lambda (_completion status)
+              (when (eq status 'finished)
+                (let ((delim (char-before value-start)))
+                  (unless (eq (char-after) delim) (insert delim)))))))
       (and (rng-adjust-state-for-attribute lt-pos
                                            name-start)
            (if (string= (buffer-substring-no-properties name-start
                                                         (or colon name-end))
                         "xmlns")
-               (rng-complete-before-point
-                value-start
-                (rng-strings-to-completion-alist
-                 (rng-possible-namespace-uris
-                  (and colon
-                       (buffer-substring-no-properties (1+ colon) name-end))))
-                "Namespace URI: "
-                nil
-                'rng-namespace-uri-history)
+               `(,value-start ,(point)
+                 ,(rng-strings-to-completion-table
+                   (rng-possible-namespace-uris
+                    (and colon
+                         (buffer-substring-no-properties (1+ colon) name-end))))
+                 :exit-function ,exit-function)
              (rng-adjust-state-for-attribute-value name-start
                                                    colon
                                                    name-end)
-             (rng-complete-before-point
-              value-start
-              (rng-strings-to-completion-alist
-               (rng-match-possible-value-strings))
-              "Value: "
-              nil
-              'rng-attribute-value-history))
-           (insert (char-before value-start))))
-    t))
+             `(,value-start ,(point)
+               ,(rng-strings-to-completion-table
+                 (rng-match-possible-value-strings))
+               :exit-function ,exit-function))))))
 
 (defun rng-possible-namespace-uris (prefix)
   (let ((ns (if prefix (nxml-ns-get-prefix prefix)
               (nxml-ns-get-default))))
     (if (and ns (memq prefix (nxml-ns-changed-prefixes)))
         (list (nxml-namespace-name ns))
-      (mapcar 'nxml-namespace-name
+      (mapcar #'nxml-namespace-name
               (delq nxml-xml-namespace-uri
                     (rng-match-possible-namespace-uris))))))
 
@@ -349,7 +326,7 @@ Return non-nil if in a context it understands."
                 (recover-fun (funcall recover-fun prefix (cdr qname)))))
       (cons (and defaultp (nxml-ns-get-default)) (cdr qname)))))
 
-(defun rng-start-tag-expand-recover (prefix local-name)
+(defun rng-start-tag-expand-recover (_prefix local-name)
   (let ((ns (rng-match-infer-start-tag-namespace local-name)))
     (and ns
          (cons ns local-name))))
@@ -386,7 +363,7 @@ set `xmltok-dtd'.  Returns the position of the end of the token."
     (save-restriction
       (widen)
       (nxml-with-invisible-motion
-        (if (= pos 1)
+        (if (= pos (point-min))
             (rng-set-initial-state)
           (let ((state (get-text-property (1- pos) 'rng-state)))
             (cond (state
@@ -501,24 +478,21 @@ set `xmltok-dtd'.  Returns the position of the end of the token."
     (and (or (not prefix) ns)
          (rng-match-attribute-name (cons ns local-name)))))
 
-(defun rng-complete-qname-function (string predicate flag)
-  (let ((alist (mapcar (lambda (name) (cons name nil))
-                       (rng-generate-qname-list string))))
-    (cond ((not flag)
-           (try-completion string alist predicate))
-          ((eq flag t)
-           (all-completions string alist predicate))
-          ((eq flag 'lambda)
-           (and (assoc string alist) t)))))
-
-(defun rng-generate-qname-list (&optional string)
+(defun rng-complete-qname-function (candidates attributes-flag extra-strings
+                                               string predicate flag)
+  (complete-with-action flag
+                        (rng-generate-qname-list
+                         string candidates attributes-flag extra-strings)
+                        string predicate))
+
+(defun rng-generate-qname-list (&optional string candidates attribute-flag extra-strings)
   (let ((forced-prefix (and string
                             (string-match ":" string)
                             (> (match-beginning 0) 0)
                             (substring string
                                        0
                                        (match-beginning 0))))
-        (namespaces (mapcar 'car rng-complete-target-names))
+        (namespaces (mapcar #'car candidates))
         ns-prefixes-alist ns-prefixes iter ns prefer)
     (while namespaces
       (setq ns (car namespaces))
@@ -526,7 +500,7 @@ set `xmltok-dtd'.  Returns the position of the end of the token."
         (setq ns-prefixes-alist
               (cons (cons ns (nxml-ns-prefixes-for
                               ns
-                              rng-complete-name-attribute-flag))
+                              attribute-flag))
                     ns-prefixes-alist)))
       (setq namespaces (delq ns (cdr namespaces))))
     (setq iter ns-prefixes-alist)
@@ -546,12 +520,12 @@ set `xmltok-dtd'.  Returns the position of the end of the token."
             (setcdr ns-prefixes (list prefer)))
           ;; Unless it's an attribute with a non-nil namespace,
           ;; allow no prefix for this namespace.
-          (unless rng-complete-name-attribute-flag
+          (unless attribute-flag
             (setcdr ns-prefixes (cons nil (cdr ns-prefixes))))))
       (setq iter (cdr iter)))
     (rng-uniquify-equal
-     (sort (apply 'append
-                  (cons rng-complete-extra-strings
+     (sort (apply #'append
+                  (cons extra-strings
                         (mapcar (lambda (name)
                                   (if (car name)
                                       (mapcar (lambda (prefix)
@@ -563,7 +537,7 @@ set `xmltok-dtd'.  Returns the position of the end of the token."
                                         (cdr (assoc (car name)
                                                     ns-prefixes-alist)))
                                     (list (cdr name))))
-                                rng-complete-target-names)))
+                                candidates)))
            'string<))))
 
 (defun rng-get-preferred-unused-prefix (ns)
@@ -582,10 +556,8 @@ set `xmltok-dtd'.  Returns the position of the end of the token."
             nil))))
     prefix))
 
-(defun rng-strings-to-completion-alist (strings)
-  (mapcar (lambda (s) (cons s s))
-          (rng-uniquify-equal (sort (mapcar 'rng-escape-string strings)
-                                    'string<))))
+(defun rng-strings-to-completion-table (strings)
+  (mapcar #'rng-escape-string strings))
 
 (provide 'rng-nxml)
 
diff --git a/lisp/nxml/rng-parse.el b/lisp/nxml/rng-parse.el
index cde749db672..3ae4b5cc9c4 100644
--- a/lisp/nxml/rng-parse.el
+++ b/lisp/nxml/rng-parse.el
@@ -1,4 +1,4 @@
-;;; rng-parse.el --- parse an XML file and validate it against a schema
+;;; rng-parse.el --- parse an XML file and validate it against a schema  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
diff --git a/lisp/nxml/rng-pttrn.el b/lisp/nxml/rng-pttrn.el
index f358d3c87d4..e847f5e02a8 100644
--- a/lisp/nxml/rng-pttrn.el
+++ b/lisp/nxml/rng-pttrn.el
@@ -1,4 +1,4 @@
-;;; rng-pttrn.el --- RELAX NG patterns
+;;; rng-pttrn.el --- RELAX NG patterns  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
diff --git a/lisp/nxml/rng-uri.el b/lisp/nxml/rng-uri.el
index 75cf23f888d..8fc0a01e293 100644
--- a/lisp/nxml/rng-uri.el
+++ b/lisp/nxml/rng-uri.el
@@ -1,4 +1,4 @@
-;;; rng-uri.el --- URI parsing and manipulation
+;;; rng-uri.el --- URI parsing and manipulation  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
diff --git a/lisp/nxml/rng-util.el b/lisp/nxml/rng-util.el
index 4c14e2b6597..c5d4b6567ed 100644
--- a/lisp/nxml/rng-util.el
+++ b/lisp/nxml/rng-util.el
@@ -82,69 +82,6 @@ LIST is not modified."
                                     (cons item nil))))))))
          list)))
 
-(defun rng-complete-before-point (start table prompt &optional predicate hist)
-  "Complete text between START and point.
-Replaces the text between START and point with a string chosen using a
-completion table and, when needed, input read from the user with the
-minibuffer.
-Returns the new string if either a complete and unique completion was
-determined automatically or input was read from the user.  Otherwise,
-returns nil.
-TABLE is an alist, a symbol bound to a function or an obarray as with
-the function `completing-read'.
-PROMPT is the string to prompt with if user input is needed.
-PREDICATE is nil or a function as with `completing-read'.
-HIST, if non-nil, specifies a history list as with `completing-read'."
-  (let* ((orig (buffer-substring-no-properties start (point)))
-         (completion (try-completion orig table predicate)))
-    (cond ((not completion)
-           (if (string= orig "")
-               (message "No completions available")
-             (message "No completion for %s" (rng-quote-string orig)))
-           (ding)
-           nil)
-          ((eq completion t) orig)
-          ((not (string= completion orig))
-           (delete-region start (point))
-           (insert completion)
-           (cond ((not (rng-completion-exact-p completion table predicate))
-                  (message "Incomplete")
-                  nil)
-                 ((eq (try-completion completion table predicate) t)
-                  completion)
-                 (t
-                  (message "Complete but not unique")
-                  nil)))
-          (t
-           (setq completion
-                 (let ((saved-minibuffer-setup-hook
-                        (default-value 'minibuffer-setup-hook)))
-                   (add-hook 'minibuffer-setup-hook
-                             'minibuffer-completion-help
-                             t)
-                   (unwind-protect
-                       (completing-read prompt
-                                        table
-                                        predicate
-                                        nil
-                                        orig
-                                        hist)
-                     (setq-default minibuffer-setup-hook
-                                   saved-minibuffer-setup-hook))))
-           (delete-region start (point))
-           (insert completion)
-           completion))))
-
-(defun rng-completion-exact-p (string table predicate)
-  (cond ((symbolp table)
-         (funcall table string predicate 'lambda))
-        ((vectorp table)
-         (intern-soft string table))
-        (t (assoc string table))))
-
-(defun rng-quote-string (s)
-  (concat "\"" s "\""))
-
 (defun rng-escape-string (s)
   (replace-regexp-in-string "[&\"<>]"
                             (lambda (match)
diff --git a/lisp/nxml/rng-valid.el b/lisp/nxml/rng-valid.el
index 1020cad2089..946bf791ff8 100644
--- a/lisp/nxml/rng-valid.el
+++ b/lisp/nxml/rng-valid.el
@@ -1,4 +1,4 @@
-;;; rng-valid.el --- real-time validation of XML using RELAX NG
+;;; rng-valid.el --- real-time validation of XML using RELAX NG  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
@@ -430,13 +430,13 @@ The schema is set like `rng-auto-set-schema'."
   (when (buffer-live-p buffer)          ; bug#13999
     (with-current-buffer buffer
       (if rng-validate-mode
-          (if (let ((rng-validate-display-point (point))
-                    (rng-validate-display-modified-p (buffer-modified-p)))
-                (rng-do-some-validation 'rng-validate-while-idle-continue-p))
-              (force-mode-line-update)
-            (rng-validate-done))
-        ;; must have done kill-all-local-variables
-        (rng-kill-timers)))))
+          (if (let ((rng-validate-display-point (point))
+                    (rng-validate-display-modified-p (buffer-modified-p)))
+                (rng-do-some-validation 'rng-validate-while-idle-continue-p))
+              (force-mode-line-update)
+            (rng-validate-done))
+        ;; Must have done kill-all-local-variables.
+        (rng-kill-timers)))))
 
 (defun rng-validate-quick-while-idle (buffer)
   (when (buffer-live-p buffer)          ; bug#13999
@@ -709,7 +709,7 @@ Return t if there is work to do, nil otherwise."
 
 ;; If we don't do this, then the front delimiter can move
 ;; past the end delimiter.
-(defun rng-error-modified (overlay after-p beg end &optional pre-change-len)
+(defun rng-error-modified (overlay after-p _beg _end &optional _pre-change-len)
   (when (and after-p
              (overlay-start overlay)    ; check not deleted
              (>= (overlay-start overlay)
@@ -1138,9 +1138,8 @@ as empty-element."
                 (rng-match-start-tag-open required)
                 (rng-match-after)
                 (rng-match-start-tag-open name))
-           (rng-mark-invalid (concat "Missing element "
-                                     (rng-quote-string
-                                      (rng-name-to-string required)))
+           (rng-mark-invalid (format "Missing element \"%s\""
+                                     (rng-name-to-string required))
                              xmltok-start
                              (1+ xmltok-start)))
           ((and (rng-match-optionalize-elements)
@@ -1177,16 +1176,14 @@ as empty-element."
     (cond ((not required-attributes)
            "Required attributes missing")
           ((not (cdr required-attributes))
-           (concat "Missing attribute "
-                   (rng-quote-string
-                    (rng-name-to-string (car required-attributes) t))))
+           (format "Missing attribute \"%s\""
+                   (rng-name-to-string (car required-attributes) t)))
           (t
-           (concat "Missing attributes "
+           (format "Missing attributes \"%s\""
                    (mapconcat (lambda (nm)
-                                (rng-quote-string
-                                 (rng-name-to-string nm t)))
+                                 (rng-name-to-string nm t))
                               required-attributes
-                              ", "))))))
+                              "\", \""))))))
 
 (defun rng-process-end-tag (&optional partial)
   (cond ((not rng-open-elements)
@@ -1229,8 +1226,7 @@ as empty-element."
 (defun rng-missing-element-message ()
   (let ((element (rng-match-required-element-name)))
     (if element
-        (concat "Missing element "
-                (rng-quote-string (rng-name-to-string element)))
+        (format "Missing element \"%s\"" (rng-name-to-string element))
       "Required child elements missing")))
 
 (defun rng-recover-mismatched-end-tag ()
@@ -1258,17 +1254,16 @@ as empty-element."
 
 (defun rng-mark-missing-end-tags (missing)
   (rng-mark-not-well-formed
-   (format "Missing end-tag%s %s"
+   (format "Missing end-tag%s \"%s\""
            (if (null (cdr missing)) "" "s")
            (mapconcat (lambda (name)
-                        (rng-quote-string
-                         (if (car name)
-                             (concat (car name)
-                                     ":"
-                                     (cdr name))
-                           (cdr name))))
+                        (if (car name)
+                            (concat (car name)
+                                    ":"
+                                    (cdr name))
+                          (cdr name)))
                       missing
-                      ", "))
+                      "\", \""))
    xmltok-start
    (+ xmltok-start 2)))
 
diff --git a/lisp/nxml/rng-xsd.el b/lisp/nxml/rng-xsd.el
index 378319851a0..c0989ae1073 100644
--- a/lisp/nxml/rng-xsd.el
+++ b/lisp/nxml/rng-xsd.el
@@ -1,4 +1,4 @@
-;;; rng-xsd.el --- W3C XML Schema datatypes library for RELAX NG
+;;; rng-xsd.el --- W3C XML Schema datatypes library for RELAX NG  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
@@ -42,7 +42,7 @@
 ;;;###autoload
 (put 'http://www.w3.org/2001/XMLSchema-datatypes
      'rng-dt-compile
-     'rng-xsd-compile)
+     #'rng-xsd-compile)
 
 ;;;###autoload
 (defun rng-xsd-compile (name params)
@@ -50,9 +50,9 @@
 NAME is a symbol giving the local name of the datatype.  PARAMS is a
 list of pairs (PARAM-NAME . PARAM-VALUE) where PARAM-NAME is a symbol
 giving the name of the parameter and PARAM-VALUE is a string giving
-its value.  If NAME or PARAMS are invalid, it calls rng-dt-error
+its value.  If NAME or PARAMS are invalid, it calls `rng-dt-error'
 passing it arguments in the same style as format; the value from
-rng-dt-error will be returned.  Otherwise, it returns a list.  The
+`rng-dt-error' will be returned.  Otherwise, it returns a list.  The
 first member of the list is t if any string is a legal value for the
 datatype and nil otherwise.  The second argument is a symbol; this
 symbol will be called as a function passing it a string followed by
diff --git a/lisp/nxml/xmltok.el b/lisp/nxml/xmltok.el
index 8fc66c99a45..f12905a86d0 100644
--- a/lisp/nxml/xmltok.el
+++ b/lisp/nxml/xmltok.el
@@ -34,10 +34,7 @@
 ;; preceding part of the instance.  This allows the instance to be
 ;; parsed incrementally.  The main entry point is `xmltok-forward':
 ;; this can be called at any point in the instance provided it is
-;; between tokens.  The other entry point is `xmltok-forward-special'
-;; which skips over tokens other comments, processing instructions or
-;; CDATA sections (i.e. the constructs in an instance that can contain
-;; less than signs that don't start a token).
+;; between tokens.
 ;;
 ;; This is a non-validating XML 1.0 processor.  It does not resolve
 ;; parameter entities (including the external DTD subset) and it does
@@ -262,11 +259,10 @@ and VALUE-END, otherwise a STRING giving the value."
   (vector message start end))
 
 (defun xmltok-add-error (message &optional start end)
-  (setq xmltok-errors
-        (cons (xmltok-make-error message
-                                 (or start xmltok-start)
-                                 (or end (point)))
-              xmltok-errors)))
+  (push (xmltok-make-error message
+                           (or start xmltok-start)
+                           (or end (point)))
+        xmltok-errors))
 
 (defun xmltok-forward ()
   (setq xmltok-start (point))
@@ -308,18 +304,6 @@ and VALUE-END, otherwise a STRING giving the value."
            (goto-char (point-max))
            (setq xmltok-type 'data)))))
 
-(defun xmltok-forward-special (bound)
-  "Scan forward past the first special token starting at or after point.
-Return nil if there is no special token that starts before BOUND.
-CDATA sections, processing instructions and comments (and indeed
-anything starting with < following by ? or !) count as special.
-Return the type of the token."
-  (when (re-search-forward "<[?!]" (1+ bound) t)
-    (setq xmltok-start (match-beginning 0))
-    (goto-char (1+ xmltok-start))
-    (let ((case-fold-search nil))
-      (xmltok-scan-after-lt))))
-
 (eval-when-compile
 
   ;; A symbolic regexp is represented by a list whose CAR is the string
@@ -739,19 +723,10 @@ Return the type of the token."
   (setq xmltok-type 'processing-instruction))
 
 (defun xmltok-scan-after-comment-open ()
-  (let ((found-- (search-forward "--" nil 'move)))
-    (setq xmltok-type
-          (cond ((or (eq (char-after) ?>) (not found--))
-                 (goto-char (1+ (point)))
-                 'comment)
-                (t
-                 ;; just include the <!-- in the token
-                 (goto-char (+ xmltok-start 4))
-                 ;; Need do this after the goto-char because
-                 ;; marked error should just apply to <!--
-                 (xmltok-add-error "First following `--' not followed by `>'")
-                 (goto-char (point-max))
-                 'comment)))))
+  (while (and (re-search-forward "--\\(>\\)?" nil 'move)
+              (not (match-end 1)))
+    (xmltok-add-error "`--' not followed by `>'" (match-beginning 0)))
+  (setq xmltok-type 'comment))
 
 (defun xmltok-scan-attributes ()
   (let ((recovering nil)
diff --git a/lisp/nxml/xsd-regexp.el b/lisp/nxml/xsd-regexp.el
index e91e6b77a7d..a3f476d00be 100644
--- a/lisp/nxml/xsd-regexp.el
+++ b/lisp/nxml/xsd-regexp.el
@@ -1,4 +1,4 @@
-;;; xsd-regexp.el --- translate W3C XML Schema regexps to Emacs regexps
+;;; xsd-regexp.el --- translate W3C XML Schema regexps to Emacs regexps  -*- lexical-binding:t -*-
 
 ;; Copyright (C) 2003, 2007-2016 Free Software Foundation, Inc.
 
@@ -147,7 +147,7 @@ ranges are merged wherever possible."
 (defun xsdre-range-list-difference (orig subtract)
   "Return a range-list for the difference of two range-lists."
   (when orig
-    (let (new head next first last)
+    (let (new head first last)
       (while orig
         (setq head (car orig))
         (setq first (xsdre-range-first head))
@@ -745,7 +745,7 @@ Code is inserted into the current buffer."
             (save-excursion
               (goto-char start)
               (down-list 2)
-              (while (condition-case err
+              (while (condition-case nil
                          (progn
                            (forward-sexp)
                            t)
diff --git a/lisp/progmodes/elisp-mode.el b/lisp/progmodes/elisp-mode.el
index 9e175a20e22..8f0b4f13b9e 100644
--- a/lisp/progmodes/elisp-mode.el
+++ b/lisp/progmodes/elisp-mode.el
@@ -245,11 +245,8 @@ Blank lines separate paragraphs.  Semicolons start comments.
 ;; Font-locking support.
 
 (defun elisp--font-lock-flush-elisp-buffers (&optional file)
-  ;; FIXME: Aren't we only ever called from after-load-functions?
-  ;; Don't flush during load unless called from after-load-functions.
-  ;; In that case, FILE is non-nil.  It's somehow strange that
-  ;; load-in-progress is t when an after-load-function is called since
-  ;; that should run *after* the load...
+  ;; We're only ever called from after-load-functions, load-in-progress can
+  ;; still be t in case of nested loads.
   (when (or (not load-in-progress) file)
     ;; FIXME: If the loaded file did not define any macros, there shouldn't
     ;; be any need to font-lock-flush all the Elisp buffers.
diff --git a/lisp/progmodes/etags.el b/lisp/progmodes/etags.el
index 2db7220de5c..271033b15f8 100644
--- a/lisp/progmodes/etags.el
+++ b/lisp/progmodes/etags.el
@@ -1794,7 +1794,6 @@ Two variables control the processing we do on each file: the value of
 interesting (it returns non-nil if so) and `tags-loop-operate' is a form to
 evaluate to operate on an interesting file.  If the latter evaluates to
 nil, we exit; otherwise we scan the next file."
-  (declare (obsolete "use `xref-find-definitions' interface instead." "25.1"))
   (interactive)
   (let (new
         ;; Non-nil means we have finished one file
diff --git a/lisp/progmodes/gud.el b/lisp/progmodes/gud.el
index c22de2f77ac..1a0385e167e 100644
--- a/lisp/progmodes/gud.el
+++ b/lisp/progmodes/gud.el
@@ -1742,6 +1742,7 @@ and source-file directory for your debugger."
 (defcustom gud-guiler-command-name "guile"
   "File name for executing the Guile debugger.
 This should be an executable on your path, or an absolute file name."
+  :version "25.1"
   :type 'string
   :group 'gud)
 
diff --git a/lisp/progmodes/hideif.el b/lisp/progmodes/hideif.el
index 43cf42c048b..8a87eb9770a 100644
--- a/lisp/progmodes/hideif.el
+++ b/lisp/progmodes/hideif.el
@@ -138,7 +138,7 @@
 
 (defcustom hide-ifdef-exclude-define-regexp nil
   "Ignore #define names if those names match this exclusion pattern."
-  :type 'string
+  :type '(choice (const nil) string)
   :version "25.1")
 
 (defcustom hide-ifdef-expand-reinclusion-protection t
@@ -1581,14 +1581,17 @@ Refer to `hide-ifdef-expand-reinclusion-protection' for more details."
     result))
 
 (defun hif-evaluate-macro (rstart rend)
-  "Evaluate the macro expansion result for a region.
+  "Evaluate the macro expansion result for the active region.
 If no region active, find the current #ifdefs and evaluate the result.
 Currently it supports only math calculations, strings or argumented macros can
 not be expanded."
-  (interactive "r")
+  (interactive
+   (if (use-region-p)
+       (list (region-beginning) (region-end))
+     '(nil nil)))
   (let ((case-fold-search nil))
     (save-excursion
-      (unless mark-active
+      (unless (use-region-p)
         (setq rstart nil rend nil)
         (beginning-of-line)
         (when (and (re-search-forward hif-macro-expr-prefix-regexp nil t)
@@ -1844,9 +1847,13 @@ This allows #ifdef VAR to be hidden."
 
 (defun hide-ifdef-undef (start end)
   "Undefine a VAR so that #ifdef VAR would not be included."
-  (interactive "r")
+  (interactive
+   (if (use-region-p)
+       (list (region-beginning) (region-end))
+     '(nil nil)))
   (let* ((symstr
-          (or (and mark-active
+          (or (and (number-or-marker-p start)
+                   (number-or-marker-p end)
                    (buffer-substring-no-properties start end))
               (read-string "Undefine what? " (current-word))))
          (sym (and symstr
@@ -1915,7 +1922,7 @@ Return as (TOP . BOTTOM) the extent of ifdef block."
 With optional prefix argument ARG, also hide the #ifdefs themselves."
   (interactive "P\nr")
   (let ((hide-ifdef-lines arg))
-    (if mark-active
+    (if (use-region-p)
         (let ((hif-recurse-level (1+ hif-recurse-level)))
           (hif-recurse-on start end t)
           (setq mark-active nil))
@@ -1931,8 +1938,12 @@ With optional prefix argument ARG, also hide the #ifdefs themselves."
 
 (defun show-ifdef-block (&optional start end)
   "Show the ifdef block (true or false part) enclosing or before the cursor."
-  (interactive "r")
-  (if mark-active
+  (interactive
+   (if (use-region-p)
+       (list (region-beginning) (region-end))
+     '(nil nil)))
+  (if (and (number-or-marker-p start)
+           (number-or-marker-p end))
       (progn
         (dolist (o (overlays-in start end))
           (if (overlay-get o 'hide-ifdef)
diff --git a/lisp/progmodes/prog-mode.el b/lisp/progmodes/prog-mode.el
index 2f12df47723..718b33932ed 100644
--- a/lisp/progmodes/prog-mode.el
+++ b/lisp/progmodes/prog-mode.el
@@ -202,6 +202,7 @@ is immediately after the symbol.  The prettification will be
 reapplied as soon as point moves away from the symbol.  If
 set to nil, the prettification persists even when point is
 on the symbol."
+  :version "25.1"
   :type '(choice (const :tag "Never unprettify" nil)
                  (const :tag "Unprettify when point is inside" t)
                  (const :tag "Unprettify when point is inside or at right edge" right-edge))
diff --git a/lisp/progmodes/project.el b/lisp/progmodes/project.el
index fe28ed776b2..85f390746d9 100644
--- a/lisp/progmodes/project.el
+++ b/lisp/progmodes/project.el
@@ -156,10 +156,11 @@ end it with `/'.  DIR must be one of `project-roots' or
 
 (defgroup project-vc nil
   "Project implementation using the VC package."
+  :version "25.1"
   :group 'tools)
 
 (defcustom project-vc-ignores nil
-  "List ot patterns to include in `project-ignores'."
+  "List of patterns to include in `project-ignores'."
   :type '(repeat string)
   :safe 'listp)
 
@@ -263,7 +264,6 @@ DIRS must contain directory names."
     (symbol-value var)))
 
 (declare-function grep-read-files "grep")
-(declare-function xref-collect-matches "xref")
 (declare-function xref--show-xrefs "xref")
 (declare-function xref-backend-identifier-at-point "xref")
 (declare-function xref--find-ignores-arguments "xref")
@@ -294,8 +294,8 @@ pattern to search for."
     (project--find-regexp-in dirs regexp pr)))
 
 (defun project--read-regexp ()
-  (read-regexp "Find regexp"
-               (xref-backend-identifier-at-point (xref-find-backend))))
+  (let ((id (xref-backend-identifier-at-point (xref-find-backend))))
+    (read-regexp "Find regexp" (and id (regexp-quote id)))))
 
 (defun project--find-regexp-in (dirs regexp project)
   (require 'grep)
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index 4984c9908bf..a8c65fa23a9 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -715,6 +715,7 @@ It makes underscores and dots word constituent chars.")
 
 (defcustom python-indent-guess-indent-offset-verbose t
   "Non-nil means to emit a warning when indentation guessing fails."
+  :version "25.1"
   :type 'boolean
   :group 'python
   :safe' booleanp)
@@ -1999,6 +2000,7 @@ hosts PATH before starting processes.  Values defined in
 here.  Normally you wont use this variable directly unless you
 plan to ensure a particular set of paths to all Python shell
 executed through tramp connections."
+  :version "25.1"
   :type '(repeat string)
   :group 'python)
 
@@ -2042,8 +2044,8 @@ virtualenv."
 (defun python-shell-calculate-pythonpath ()
   "Calculate the PYTHONPATH using `python-shell-extra-pythonpaths'."
   (let ((pythonpath
-         (tramp-compat-split-string
-          (or (getenv "PYTHONPATH") "") path-separator)))
+         (split-string
+          (or (getenv "PYTHONPATH") "") path-separator 'omit)))
     (python-shell--add-to-path-with-priority
      pythonpath python-shell-extra-pythonpaths)
     (mapconcat 'identity pythonpath path-separator)))
@@ -2114,7 +2116,7 @@ appends `python-shell-remote-exec-path' instead of `exec-path'."
            (md5 tramp-end-of-output)))
         unset vars item)
     (while env
-      (setq item (tramp-compat-split-string (car env) "="))
+      (setq item (split-string (car env) "=" 'omit))
       (setcdr item (mapconcat 'identity (cdr item) "="))
       (if (and (stringp (cdr item)) (not (string-equal (cdr item) "")))
           (push (format "%s %s" (car item) (cdr item)) vars)
@@ -2621,6 +2623,7 @@ current process to not hang waiting for output by safeguarding
 interactive actions can be performed.  This is useful to safely
 attach setup code for long-running processes that eventually
 provide a shell."
+  :version "25.1"
   :type 'hook
   :group 'python)
 
@@ -3258,18 +3261,22 @@ the full statement in the case of imports."
   (list "pypy")
   "List of disabled interpreters.
 When a match is found, native completion is disabled."
+  :version "25.1"
   :type '(repeat string))
 
 (defcustom python-shell-completion-native-enable t
   "Enable readline based native completion."
+  :version "25.1"
   :type 'boolean)
 
 (defcustom python-shell-completion-native-output-timeout 5.0
   "Time in seconds to wait for completion output before giving up."
+  :version "25.1"
   :type 'float)
 
 (defcustom python-shell-completion-native-try-output-timeout 1.0
   "Time in seconds to wait for *trying* native completion output."
+  :version "25.1"
   :type 'float)
 
 (defvar python-shell-completion-native-redirect-buffer
diff --git a/lisp/progmodes/ruby-mode.el b/lisp/progmodes/ruby-mode.el
index 8f08b7c9e60..53f8a6bb4c0 100644
--- a/lisp/progmodes/ruby-mode.el
+++ b/lisp/progmodes/ruby-mode.el
@@ -1830,7 +1830,7 @@ It will be properly highlighted even when the call omits parens.")
      "\\)\\s *")
     "Regexp to match text that can be followed by a regular expression."))
 
-(defun ruby-syntax-propertize-function (start end)
+(defun ruby-syntax-propertize (start end)
   "Syntactic keywords for Ruby mode.  See `syntax-propertize-function'."
   (let (case-fold-search)
     (goto-char start)
@@ -1856,6 +1856,8 @@ It will be properly highlighted even when the call omits parens.")
                           (zerop (skip-syntax-backward "w_")))
                         (memq (preceding-char) '(?@ ?$))))
             (string-to-syntax "_"))))
+      ;; Backtick method redefinition.
+      ("^[ \t]*def +\\(`\\)" (1 "_"))
       ;; Regular expressions.  Start with matching unescaped slash.
       ("\\(?:\\=\\|[^\\]\\)\\(?:\\\\\\\\\\)*\\(/\\)"
        (1 (let ((state (save-excursion (syntax-ppss (match-beginning 1)))))
@@ -1891,6 +1893,9 @@ It will be properly highlighted even when the call omits parens.")
        (1 (prog1 "|" (ruby-syntax-propertize-percent-literal end)))))
      (point) end)))
 
+(define-obsolete-function-alias
+  'ruby-syntax-propertize-function 'ruby-syntax-propertize "25.1")
+
 (defun ruby-syntax-propertize-heredoc (limit)
   (let ((ppss (syntax-ppss))
         (res '()))
@@ -2252,7 +2257,7 @@ See `font-lock-syntax-table'.")
   (setq-local font-lock-keywords ruby-font-lock-keywords)
   (setq-local font-lock-syntax-table ruby-font-lock-syntax-table)
 
-  (setq-local syntax-propertize-function #'ruby-syntax-propertize-function))
+  (setq-local syntax-propertize-function #'ruby-syntax-propertize))
 
 ;;; Invoke ruby-mode when appropriate
 
diff --git a/lisp/progmodes/xref.el b/lisp/progmodes/xref.el
index fe39122d24f..2bccd857576 100644
--- a/lisp/progmodes/xref.el
+++ b/lisp/progmodes/xref.el
@@ -76,6 +76,7 @@
   (require 'semantic/symref)) ;; for hit-lines slot
 
 (defgroup xref nil "Cross-referencing commands"
+  :version "25.1"
   :group 'tools)
 
 
@@ -510,11 +511,18 @@ references displayed in the current *xref* buffer."
    (let ((fr (read-regexp "Xref query-replace (regexp)" ".*")))
      (list fr
            (read-regexp (format "Xref query-replace (regexp) %s with: " fr)))))
-  (let (pairs item)
+  (let ((reporter (make-progress-reporter (format "Saving search results...")
+                                          0 (line-number-at-pos (point-max))))
+        (counter 0)
+        pairs item)
     (unwind-protect
         (progn
           (save-excursion
             (goto-char (point-min))
+            ;; TODO: This list should be computed on-demand instead.
+            ;; As long as the UI just iterates through matches one by
+            ;; one, there's no need to compute them all in advance.
+            ;; Then we can throw away the reporter.
             (while (setq item (xref--search-property 'xref-item))
               (when (xref-match-length item)
                 (save-excursion
@@ -534,9 +542,11 @@ references displayed in the current *xref* buffer."
                                     (line-end-position))
                                    (xref-item-summary item))
                       (user-error "Search results out of date"))
+                    (progress-reporter-update reporter (cl-incf counter))
                     (push (cons beg end) pairs)))))
             (setq pairs (nreverse pairs)))
           (unless pairs (user-error "No suitable matches here"))
+          (progress-reporter-done reporter)
           (xref--query-replace-1 from to pairs))
       (dolist (pair pairs)
         (move-marker (car pair) nil)
@@ -712,9 +722,9 @@ Return an alist of the form ((FILENAME . (XREF ...)) ...)."
 
 (defvar xref--read-pattern-history nil)
 
-(defun xref--show-xrefs (xrefs window)
+(defun xref--show-xrefs (xrefs window &optional always-show-list)
   (cond
-   ((not (cdr xrefs))
+   ((and (not (cdr xrefs)) (not always-show-list))
     (xref-push-marker-stack)
     (xref--pop-to-location (car xrefs) window))
    (t
@@ -865,11 +875,12 @@ tools are used, and when."
       (mapc #'kill-buffer
             (cl-set-difference (buffer-list) orig-buffers)))))
 
+;;;###autoload
 (defun xref-collect-matches (regexp files dir ignores)
   "Collect matches for REGEXP inside FILES in DIR.
 FILES is a string with glob patterns separated by spaces.
 IGNORES is a list of glob patterns."
-  (cl-assert (directory-name-p dir))
+  ;; DIR can also be a regular file for now; let's not advertise that.
   (require 'semantic/fw)
   (grep-compute-defaults)
   (defvar grep-find-template)
@@ -884,6 +895,8 @@ IGNORES is a list of glob patterns."
          (orig-buffers (buffer-list))
          (buf (get-buffer-create " *xref-grep*"))
          (grep-re (caar grep-regexp-alist))
+         (counter 0)
+         reporter
          hits)
     (with-current-buffer buf
       (erase-buffer)
@@ -893,9 +906,17 @@ IGNORES is a list of glob patterns."
         (push (cons (string-to-number (match-string 2))
                     (match-string 1))
               hits)))
+    (setq reporter (make-progress-reporter
+                    (format "Collecting search results...")
+                    0 (length hits)))
     (unwind-protect
-        (cl-mapcan (lambda (hit) (xref--collect-matches hit regexp))
+        (cl-mapcan (lambda (hit)
+                     (prog1
+                         (progress-reporter-update reporter counter)
+                       (cl-incf counter))
+                     (xref--collect-matches hit regexp))
                    (nreverse hits))
+      (progress-reporter-done reporter)
       ;; TODO: Same as above.
       (mapc #'kill-buffer
             (cl-set-difference (buffer-list) orig-buffers)))))
@@ -921,23 +942,24 @@ IGNORES is a list of glob patterns."
 (defun xref--find-ignores-arguments (ignores dir)
   ;; `shell-quote-argument' quotes the tilde as well.
   (cl-assert (not (string-match-p "\\`~" dir)))
-  (concat
-   (shell-quote-argument "(")
-   " -path "
-   (mapconcat
-    (lambda (ignore)
-      (when (string-match-p "/\\'" ignore)
-        (setq ignore (concat ignore "*")))
-      (if (string-match "\\`\\./" ignore)
-          (setq ignore (replace-match dir t t ignore))
-        (unless (string-prefix-p "*" ignore)
-          (setq ignore (concat "*/" ignore))))
-      (shell-quote-argument ignore))
-    ignores
-    " -o -path ")
-   " "
-   (shell-quote-argument ")")
-   " -prune -o "))
+  (when ignores
+    (concat
+     (shell-quote-argument "(")
+     " -path "
+     (mapconcat
+      (lambda (ignore)
+        (when (string-match-p "/\\'" ignore)
+          (setq ignore (concat ignore "*")))
+        (if (string-match "\\`\\./" ignore)
+            (setq ignore (replace-match dir t t ignore))
+          (unless (string-prefix-p "*" ignore)
+            (setq ignore (concat "*/" ignore))))
+        (shell-quote-argument ignore))
+      ignores
+      " -o -path ")
+     " "
+     (shell-quote-argument ")")
+     " -prune -o ")))
 
 (defun xref--regexp-to-extended (str)
   (replace-regexp-in-string
diff --git a/lisp/rect.el b/lisp/rect.el
index 789d0e9082d..73790f2f92a 100644
--- a/lisp/rect.el
+++ b/lisp/rect.el
@@ -403,6 +403,7 @@ With a prefix (or a FILL) argument, also fill too short lines."
 
 (defcustom rectangle-preview t
   "If non-nil, `string-rectangle' will show an-the-fly preview."
+  :version "25.1"
   :type 'boolean)
 
 (defun rectangle--string-preview ()
diff --git a/lisp/term/screen.el b/lisp/term/screen.el
index 704fbefb0ad..7f681154d6e 100644
--- a/lisp/term/screen.el
+++ b/lisp/term/screen.el
@@ -7,6 +7,7 @@
   "Extra capabilities supported under \"screen\".
 Some features of screen depend on the terminal emulator in which
 it runs, which can change when the screen session is moved to another tty."
+  :version "25.1"
   :type xterm--extra-capabilities-type
   :group 'xterm)
 
diff --git a/lisp/term/xterm.el b/lisp/term/xterm.el
index 104f98311a8..e06423ccfdd 100644
--- a/lisp/term/xterm.el
+++ b/lisp/term/xterm.el
@@ -65,6 +65,7 @@ using the OSC 52 sequence.
 If you select a region larger than this size, it won't be copied to your system
 clipboard.  Since clipboard data is base 64 encoded, the actual number of
 string bytes that can be copied is 3/4 of this value."
+  :version "25.1"
   :type 'integer)
 
 (defconst xterm-paste-ending-sequence "\e[201~"
diff --git a/lisp/textmodes/css-mode.el b/lisp/textmodes/css-mode.el
index 48c24844a68..d402fb19955 100644
--- a/lisp/textmodes/css-mode.el
+++ b/lisp/textmodes/css-mode.el
@@ -257,13 +257,13 @@
        (if (not sassy)
            ;; We don't allow / as first char, so as not to
            ;; take a comment as the beginning of a selector.
-           "[^@/:{} \t\n][^:{}]+"
+           "[^@/:{}() \t\n][^:{}()]+"
          ;; Same as for non-sassy except we do want to allow { and }
          ;; chars in selectors in the case of #{$foo}
          ;; variable interpolation!
          (concat "\\(?:" scss--hash-re
-                 "\\|[^@/:{} \t\n#]\\)"
-                 "[^:{}#]*\\(?:" scss--hash-re "[^:{}#]*\\)*"))
+                 "\\|[^@/:{}() \t\n#]\\)"
+                 "[^:{}()#]*\\(?:" scss--hash-re "[^:{}()#]*\\)*"))
        ;; Even though pseudo-elements should be prefixed by ::, a
        ;; single colon is accepted for backward compatibility.
        "\\(?:\\(:" (regexp-opt (append css-pseudo-class-ids
@@ -271,8 +271,8 @@
        "\\|\\::" (regexp-opt css-pseudo-element-ids t) "\\)"
        "\\(?:([^)]+)\\)?"
        (if (not sassy)
-           "[^:{}\n]*"
-         (concat "[^:{}\n#]*\\(?:" scss--hash-re "[^:{}\n#]*\\)*"))
+           "[^:{}()\n]*"
+         (concat "[^:{}()\n#]*\\(?:" scss--hash-re "[^:{}()\n#]*\\)*"))
        "\\)*"
        "\\)\\(?:\n[ \t]*\\)*{")
      (1 'css-selector keep))
diff --git a/lisp/textmodes/sgml-mode.el b/lisp/textmodes/sgml-mode.el
index 98a01e8d83f..f729760e9ca 100644
--- a/lisp/textmodes/sgml-mode.el
+++ b/lisp/textmodes/sgml-mode.el
@@ -862,11 +862,12 @@ Return non-nil if we skipped over matched tags."
                 (if endp
                     (when (sgml-skip-tag-backward 1) (forward-char 1) t)
                   (with-syntax-table sgml-tag-syntax-table
-                    (up-list -1)
-                    (when (sgml-skip-tag-forward 1)
-                      (backward-sexp 1)
-                      (forward-char 2)
-                      t))))
+                    (let ((forward-sexp-function nil))
+                      (up-list -1)
+                      (when (sgml-skip-tag-forward 1)
+                        (backward-sexp 1)
+                        (forward-char 2)
+                        t)))))
                (clones (get-char-property (point) 'text-clones)))
           (when (and match
                      (/= cl-end cl-start)
diff --git a/lisp/textmodes/tildify.el b/lisp/textmodes/tildify.el
index eb799c09510..598060e9ec8 100644
--- a/lisp/textmodes/tildify.el
+++ b/lisp/textmodes/tildify.el
@@ -417,7 +417,7 @@ current `case-fold-search' setting."
   "A list of predicate functions for `tildify-space' function."
   :version "25.1"
   :group 'tildify
-  :type '(repeat 'function))
+  :type '(repeat function))
 
 (defcustom tildify-double-space-undos t
   "Weather `tildify-space' should undo hard space when space is typed again."
diff --git a/lisp/thingatpt.el b/lisp/thingatpt.el
index 9794d002149..1686c02ada3 100644
--- a/lisp/thingatpt.el
+++ b/lisp/thingatpt.el
@@ -280,8 +280,8 @@ If nil, construct the regexp from `thing-at-point-uri-schemes'.")
     "finger://" "fish://" "ftp://" "geo:" "git://" "go:" "gopher://"
     "h323:" "http://" "https://" "im:" "imap://" "info:" "ipp:"
     "irc://" "irc6://" "ircs://" "iris.beep:" "jar:" "ldap://"
-    "ldaps://" "mailto:" "mid:"  "mtqp://" "mupdate://" "news:"
-    "nfs://" "nntp://" "opaquelocktoken:" "pop://" "pres:"
+    "ldaps://" "magnet:" "mailto:" "mid:"  "mtqp://" "mupdate://"
+    "news:" "nfs://" "nntp://" "opaquelocktoken:" "pop://" "pres:"
     "resource://" "rmi://" "rsync://" "rtsp://" "rtspu://" "service:"
     "sftp://" "sip:" "sips:" "smb://" "sms:" "snmp://" "soap.beep://"
     "soap.beeps://" "ssh://" "svn://" "svn+ssh://" "tag:" "tel:"
diff --git a/lisp/time-stamp.el b/lisp/time-stamp.el
index 46c993e1f5f..d58942c3a2b 100644
--- a/lisp/time-stamp.el
+++ b/lisp/time-stamp.el
@@ -5,7 +5,6 @@
 
 ;; This file is part of GNU Emacs.
 
-;; Maintainer's Time-stamp: <2006-04-12 20:30:56 rms>
 ;; Maintainer: Stephen Gildea <gildea@stop.mail-abuse.org>
 ;; Keywords: tools
 
@@ -27,7 +26,6 @@
 ;; A template in a file can be updated with a new time stamp when
 ;; you save the file.  For example:
 ;;     static char *ts = "sdmain.c Time-stamp: <2001-08-13 10:20:51 gildea>";
-;; See the top of `time-stamp.el' for another example.
 
 ;; To use time-stamping, add this line to your init file:
 ;;     (add-hook 'before-save-hook 'time-stamp)
@@ -121,9 +119,12 @@ If nil, no notification is given."
   :group 'time-stamp)
 
 (defcustom time-stamp-time-zone nil
-  "If non-nil, a string naming the timezone to be used by \\[time-stamp].
-Format is the same as that used by the environment variable TZ on your system."
-  :type '(choice (const nil) string)
+  "The time zone to be used by \\[time-stamp].
+Its format is that of the ZONE argument of the `format-time-string' function,"
+  :type '(choice (const :tag "Emacs local time" nil)
+                 (const :tag "Universal Time" t)
+                 (const :tag "system wall clock time" wall)
+                 (string :tag "TZ environment variable value"))
   :group 'time-stamp
   :version "20.1")
 ;;;###autoload(put 'time-stamp-time-zone 'safe-local-variable 'string-or-null-p)
@@ -412,6 +413,8 @@ With ARG, turn time stamping on if and only if arg is positive."
           (> (prefix-numeric-value arg) 0)))
   (message "time-stamp is now %s." (if time-stamp-active "active" "off")))
 
+(defun time-stamp--format (format time)
+  (format-time-string format time time-stamp-time-zone))
 
 (defun time-stamp-string (&optional ts-format)
   "Generate the new string to be inserted by \\[time-stamp].
@@ -420,8 +423,7 @@ format the string."
   (or ts-format
       (setq ts-format time-stamp-format))
   (if (stringp ts-format)
-      (format-time-string (time-stamp-string-preprocess ts-format)
-                          nil time-stamp-time-zone)
+      (time-stamp--format (time-stamp-string-preprocess ts-format) nil)
     ;; handle version 1 compatibility
     (cond ((or (eq time-stamp-old-format-warn 'error)
                (and (eq time-stamp-old-format-warn 'ask)
@@ -515,32 +517,32 @@ and all `time-stamp-format' compatibility."
           "%%")
          ((eq cur-char ?a)              ;day of week
           (if change-case
-              (format-time-string "%#a" time)
+              (time-stamp--format "%#a" time)
             (or alt-form (not (string-equal field-width ""))
                 (time-stamp-conv-warn "%a" "%:a"))
             (if (and alt-form (not (string-equal field-width "")))
                 ""                      ;discourage "%:3a"
-              (format-time-string "%A" time))))
+              (time-stamp--format "%A" time))))
          ((eq cur-char ?A)
           (if alt-form
-              (format-time-string "%A" time)
+              (time-stamp--format "%A" time)
             (or change-case (not (string-equal field-width ""))
                 (time-stamp-conv-warn "%A" "%#A"))
-            (format-time-string "%#A" time)))
+            (time-stamp--format "%#A" time)))
          ((eq cur-char ?b)              ;month name
           (if change-case
-              (format-time-string "%#b" time)
+              (time-stamp--format "%#b" time)
             (or alt-form (not (string-equal field-width ""))
                 (time-stamp-conv-warn "%b" "%:b"))
             (if (and alt-form (not (string-equal field-width "")))
                 ""                      ;discourage "%:3b"
-            (format-time-string "%B" time))))
+            (time-stamp--format "%B" time))))
          ((eq cur-char ?B)
           (if alt-form
-              (format-time-string "%B" time)
+              (time-stamp--format "%B" time)
             (or change-case (not (string-equal field-width ""))
                 (time-stamp-conv-warn "%B" "%#B"))
-            (format-time-string "%#B" time)))
+            (time-stamp--format "%#B" time)))
          ((eq cur-char ?d)              ;day of month, 1-31
           (time-stamp-do-number cur-char alt-form field-width time))
          ((eq cur-char ?H)              ;hour, 0-23
@@ -554,27 +556,27 @@ and all `time-stamp-format' compatibility."
          ((eq cur-char ?p)              ;am or pm
           (or change-case
               (time-stamp-conv-warn "%p" "%#p"))
-          (format-time-string "%#p" time))
+          (time-stamp--format "%#p" time))
          ((eq cur-char ?P)              ;AM or PM
-          (format-time-string "%p" time))
+          (time-stamp--format "%p" time))
          ((eq cur-char ?S)              ;seconds, 00-60
           (time-stamp-do-number cur-char alt-form field-width time))
          ((eq cur-char ?w)              ;weekday number, Sunday is 0
-          (format-time-string "%w" time))
+          (time-stamp--format "%w" time))
          ((eq cur-char ?y)              ;year
           (or alt-form (not (string-equal field-width ""))
               (time-stamp-conv-warn "%y" "%:y"))
-          (string-to-number (format-time-string "%Y" time)))
+          (string-to-number (time-stamp--format "%Y" time)))
          ((eq cur-char ?Y)              ;4-digit year, new style
-          (string-to-number (format-time-string "%Y" time)))
+          (string-to-number (time-stamp--format "%Y" time)))
          ((eq cur-char ?z)              ;time zone lower case
           (if change-case
               ""                        ;discourage %z variations
-            (format-time-string "%#Z" time)))
+            (time-stamp--format "%#Z" time)))
          ((eq cur-char ?Z)
           (if change-case
-              (format-time-string "%#Z" time)
-            (format-time-string "%Z" time)))
+              (time-stamp--format "%#Z" time)
+            (time-stamp--format "%Z" time)))
          ((eq cur-char ?f)              ;buffer-file-name, base name only
           (if buffer-file-name
               (file-name-nondirectory buffer-file-name)
@@ -634,7 +636,7 @@ width specification or \"\".  TIME is the time to convert."
                                (format "%%:%c" format-char)))
     (if (and alt-form (not (string-equal field-width "")))
         ""                              ;discourage "%:2d" and the like
-      (string-to-number (format-time-string format-string time)))))
+      (string-to-number (time-stamp--format format-string time)))))
 
 (defvar time-stamp-conversion-warn t
   "Warn about soon-to-be-unsupported forms in `time-stamp-format'.
diff --git a/lisp/url/url-tramp.el b/lisp/url/url-tramp.el
index 9e191579d47..192a0459f33 100644
--- a/lisp/url/url-tramp.el
+++ b/lisp/url/url-tramp.el
@@ -30,11 +30,11 @@
 
 ;;;###autoload
 (defcustom url-tramp-protocols '("ftp" "ssh" "scp" "rsync" "telnet")
-  "List of URL protocols the work is handled by Tramp.
+  "List of URL protocols for which the work is handled by Tramp.
 They must also be covered by `url-handler-regexp'."
   :group 'url
   :version "25.1"
-  :type '(list string))
+  :type '(repeat string))
 
 (defun url-tramp-convert-url-to-tramp (url)
   "Convert URL to a Tramp file name."