Merge branch 'master' into xwidget

9 files changed, 294 insertions, 156 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 680adc71d0a..b1a3a73864c 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,74 @@
+2015-01-19  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * ido.el: Update Customization instructions.
+
+2015-01-19  Jonas Bernoulli  <jonas@bernoul.li>
+
+        Define Ido keymaps once (bug#17000).
+        * ido.el (ido-common-completion-map)
+        (ido-file-dir-completion-map)
+        (ido-file-completion-map, ido-buffer-completion-map): Set up key
+        bindings when each variable is defined.
+        (ido-completion-map): Move definition.
+        (ido-init-completion-maps): Noop.
+        (ido-common-initialization): Don't call it.
+        (ido-setup-completion-map): Improve doc-string, cleanup.
+
+2015-01-19  Ivan Shmakov  <ivan@siamics.net>
+
+        * cus-dep.el (custom-make-dependencies): Ensure that
+        default-directory is interpreted as a directory (see bug#19140.)
+
+2015-01-19  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/xref.el (xref--display-position):
+        Set `other-window-scroll-buffer'.
+        (xref-goto-xref): Use `user-error'.
+
+2015-01-19  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/xref.el (xref--display-history): New variable.
+        (xref--window-configuration): Remove.
+        (xref--save-to-history): New function.
+        (xref--display-position): Use it.  Add new argument.
+        (xref--restore-window-configuration): Remove.
+        (xref--show-location, xref-show-location-at-point): Update
+        accordingly.
+        (xref--xref-buffer-mode): Don't use `pre-command-hook'.
+        (xref--quit): New command.
+        (xref-goto-xref): Use it.
+        (xref--xref-buffer-mode-map): Bind `q' to it.
+
+2015-01-18  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * progmodes/xref.el (xref-goto-xref): Perform the jump even inside
+        indentation or at eol.
+
+2015-01-18  Stefan Monnier  <monnier@iro.umontreal.ca>
+
+        * emacs-lisp/eieio-core.el: Add `subclass' specializer for cl-generic.
+        (eieio--generic-subclass-tagcode, eieio--generic-subclass-tag-types):
+        New functions.
+        (cl-generic-tagcode-function, cl-generic-tag-types-function): Use them.
+
+        * emacs-lisp/eieio.el (defclass): Add obsolescence warning for the
+        `newname' argument.
+
+        * emacs-lisp/cl-generic.el (cl-generic-define-method): Correctly handle
+        introduction of a new dispatch argument.
+        (cl--generic-cache-miss): Handle dispatch on an argument which was not
+        considered as dispatchable for this method.
+        (cl-defmethod): Warn when adding a method to an obsolete generic function.
+        (cl--generic-lambda): Make sure it works if cl-lib is not yet loaded.
+
+        * emacs-lisp/eieio-generic.el (eieio--defgeneric-init-form): Use autoloadp.
+
+2015-01-18  Artur Malabarba  <bruce.connor.am@gmail.com>
+
+        * emacs-lisp/package.el (package--append-to-alist): Rename from
+        `package--add-to-alist'
+        Updated docstring due to new name.
+
 2015-01-18  Leo Liu  <sdl.web@gmail.com>
 
         * emacs-lisp/cl-extra.el (cl-subseq): Use seq-subseq and fix
@@ -132,8 +203,8 @@
 2015-01-16  Artur Malabarba  <bruce.connor.am@gmail.com>
 
         * emacs-lisp/package.el (package--read-pkg-desc):
-        New function. Read a `define-package' form in current buffer. Return
-        the pkg-desc, with desc-kind set to KIND.
+        New function. Read a `define-package' form in current buffer.
+        Return the pkg-desc, with desc-kind set to KIND.
         (package-dir-info): New function. Find package information for a
         directory. The return result is a `package-desc'.
         (package-install-from-buffer): Install packages from dired buffer.
@@ -856,8 +927,8 @@
 2014-12-27  Eli Zaretskii  <eliz@gnu.org>
 
         * language/misc-lang.el (composition-function-table): Add Syriac
-        characters and also ZWJ/ZWNJ.  See
-        http://lists.gnu.org/archive/html/help-gnu-emacs/2014-12/msg00248.html
+        characters and also ZWJ/ZWNJ.
+        See http://lists.gnu.org/archive/html/help-gnu-emacs/2014-12/msg00248.html
         for the details.
 
 2014-12-27  Fabián Ezequiel Gallina  <fgallina@gnu.org>
diff --git a/lisp/cus-dep.el b/lisp/cus-dep.el
index 453b15ddcea..b8a9eb82655 100644
--- a/lisp/cus-dep.el
+++ b/lisp/cus-dep.el
@@ -62,7 +62,8 @@ Usage: emacs -batch -l ./cus-dep.el -f custom-make-dependencies DIRS"
       (while (setq subdir (pop command-line-args-left))
         (message "Directory %s" subdir)
         (let ((files (directory-files subdir nil "\\`[^=.].*\\.el\\'"))
-              (default-directory (expand-file-name subdir))
+              (default-directory
+                (file-name-as-directory (expand-file-name subdir)))
               (preloaded (concat "\\`\\(\\./+\\)?"
                                  (regexp-opt preloaded-file-list t)
                                  "\\.el\\'")))
diff --git a/lisp/emacs-lisp/cl-generic.el b/lisp/emacs-lisp/cl-generic.el
index 819e2e92888..544f1fa140f 100644
--- a/lisp/emacs-lisp/cl-generic.el
+++ b/lisp/emacs-lisp/cl-generic.el
@@ -212,13 +212,13 @@ This macro can only be used within the lexical scope of a cl-generic method."
             (macroenv (cons `(cl-generic-current-method-specializers
                               . ,(lambda () specializers))
                             macroexpand-all-environment)))
+        (require 'cl-lib)        ;Needed to expand `cl-flet' and `cl-function'.
         (if (not with-cnm)
             (cons nil (macroexpand-all fun macroenv))
           ;; First macroexpand away the cl-function stuff (e.g. &key and
           ;; destructuring args, `declare' and whatnot).
           (pcase (macroexpand fun macroenv)
             (`#'(lambda ,args . ,body)
-             (require 'cl-lib)          ;Needed to expand `cl-flet'.
              (let* ((doc-string (and doc-string (stringp (car body))
                                      (pop body)))
                     (cnm (make-symbol "cl--cnm"))
@@ -287,6 +287,13 @@ which case this method will be invoked when the argument is `eql' to VAL.
                                              (cadr name))))
               (setq name setter)
               code))
+         ,(and (get name 'byte-obsolete-info)
+               (or (not (fboundp 'byte-compile-warning-enabled-p))
+                   (byte-compile-warning-enabled-p 'obsolete))
+               (let* ((obsolete (get name 'byte-obsolete-info)))
+                 (macroexp--warn-and-return
+                  (macroexp--obsolete-warning name obsolete "generic function")
+                  nil)))
          (cl-generic-define-method ',name ',qualifiers ',args
                                    ,uses-cnm ,fun)))))
 
@@ -308,13 +315,14 @@ which case this method will be invoked when the argument is `eql' to VAL.
     (dolist (specializer specializers)
       (let* ((tagcode (funcall cl-generic-tagcode-function specializer 'arg))
              (x (assq i dispatches)))
-        (if (not x)
-            (setf (cl--generic-dispatches generic)
-                  (setq dispatches (cons (list i tagcode) dispatches)))
-          (unless (member tagcode (cdr x))
-            (setf (cdr x)
-                  (nreverse (sort (cons tagcode (cdr x))
-                                  #'car-less-than-car)))))
+        (unless x
+          (setq x (list i (funcall cl-generic-tagcode-function t 'arg)))
+          (setf (cl--generic-dispatches generic)
+                (setq dispatches (cons x dispatches))))
+        (unless (member tagcode (cdr x))
+          (setf (cdr x)
+                (nreverse (sort (cons tagcode (cdr x))
+                                #'car-less-than-car))))
         (setq i (1+ i))))
     (if me (setcdr me (cons uses-cnm function))
       (setf (cl--generic-method-table generic)
@@ -478,7 +486,8 @@ for all those different tags in the method-cache.")
   (let ((types (apply #'append (mapcar cl-generic-tag-types-function tags)))
         (methods '()))
     (dolist (method-desc (cl--generic-method-table generic))
-      (let ((m (member (nth dispatch-arg (caar method-desc)) types)))
+      (let* ((specializer (or (nth dispatch-arg (caar method-desc)) t))
+             (m (member specializer types)))
         (when m
           (push (cons (length m) method-desc) methods))))
     ;; Sort the methods, most specific first.
diff --git a/lisp/emacs-lisp/eieio-core.el b/lisp/emacs-lisp/eieio-core.el
index a82e887fa0c..e4221e48fe2 100644
--- a/lisp/emacs-lisp/eieio-core.el
+++ b/lisp/emacs-lisp/eieio-core.el
@@ -1227,6 +1227,8 @@ method invocation orders of the involved classes."
 
 (require 'cl-generic)
 
+;;;; General support to dispatch based on the type of the argument.
+
 (add-function :before-until cl-generic-tagcode-function
               #'eieio--generic-tagcode)
 (defun eieio--generic-tagcode (type name)
@@ -1246,6 +1248,29 @@ method invocation orders of the involved classes."
        (mapcar #'eieio--class-symbol
                (eieio--class-precedence-list (symbol-value tag)))))
 
+;;;; Dispatch for arguments which are classes.
+
+;; Since EIEIO does not support metaclasses, users can't easily use the
+;; "dispatch on argument type" for class arguments.  That's why EIEIO's
+;; `defmethod' added the :static qualifier.  For cl-generic, such a qualifier
+;; would not make much sense (e.g. to which argument should it apply?).
+;; Instead, we add a new "subclass" specializer.
+
+(add-function :before-until cl-generic-tagcode-function
+              #'eieio--generic-subclass-tagcode)
+(defun eieio--generic-subclass-tagcode (type name)
+  (when (eq 'subclass (car-safe type))
+    `(60 . (and (symbolp ,name) (eieio--class-v ,name)))))
+
+(add-function :before-until cl-generic-tag-types-function
+              #'eieio--generic-subclass-tag-types)
+(defun eieio--generic-subclass-tag-types (tag)
+  (when (eieio--class-p tag)
+    (mapcar (lambda (class)
+              `(subclass
+                ,(if (symbolp class) class (eieio--class-symbol class))))
+            (eieio--class-precedence-list tag))))
+
 ;;; Backward compatibility functions
 ;; To support .elc files compiled for older versions of EIEIO.
 
diff --git a/lisp/emacs-lisp/eieio-generic.el b/lisp/emacs-lisp/eieio-generic.el
index 27a58493905..74ecefe7863 100644
--- a/lisp/emacs-lisp/eieio-generic.el
+++ b/lisp/emacs-lisp/eieio-generic.el
@@ -110,7 +110,7 @@ Methods with only primary implementations are executed in an optimized way."
 
   (cond
    ((or (not (fboundp method))
-        (eq 'autoload (car-safe (symbol-function method))))
+        (autoloadp (symbol-function method)))
     ;; Make sure the method tables are installed.
     (eieio--mt-install method)
     ;; Construct the actual body of this function.
diff --git a/lisp/emacs-lisp/eieio.el b/lisp/emacs-lisp/eieio.el
index c5597b83170..0c85d90151a 100644
--- a/lisp/emacs-lisp/eieio.el
+++ b/lisp/emacs-lisp/eieio.el
@@ -276,6 +276,17 @@ and reference them using the function `class-option'."
           `(defun ,name (&rest slots)
              ,(format "Create a new object with name NAME of class type %S."
                       name)
+             (declare (compiler-macro
+                       (lambda (whole)
+                         (if (not (stringp (car slots)))
+                             whole
+                           (macroexp--warn-and-return
+                            (format "Obsolete name arg %S to constructor %S"
+                                    (car slots) (car whole))
+                            ;; Keep the name arg, for backward compatibility,
+                            ;; but hide it so we don't trigger indefinitely.
+                            `(,(car whole) (identity ,(car slots))
+                              ,@(cdr slots)))))))
              (apply #'eieio-constructor ',name slots))))))
 
 
diff --git a/lisp/emacs-lisp/package.el b/lisp/emacs-lisp/package.el
index 4be3b584a72..0f094b556ba 100644
--- a/lisp/emacs-lisp/package.el
+++ b/lisp/emacs-lisp/package.el
@@ -1154,13 +1154,15 @@ Also, add the originating archive to the `package-desc' structure."
     (when (not (and pinned-to-archive
                     (not (equal (cdr pinned-to-archive) archive))))
       (setq package-archive-contents
-            (package--add-to-alist pkg-desc package-archive-contents)))))
+            (package--append-to-alist pkg-desc package-archive-contents)))))
 
-(defun package--add-to-alist (pkg-desc alist)
-  "Add PKG-DESC to ALIST.
+(defun package--append-to-alist (pkg-desc alist)
+  "Append an entry for PKG-DESC to the start of ALIST and return it.
+This entry takes the form (`package-desc-name' PKG-DESC).
 
-Packages are grouped by name. The package descriptions are sorted
-by version number."
+If ALIST already has an entry with this name, destructively add
+PKG-DESC to the cdr of this entry instead, sorted by version
+number."
   (let* ((name (package-desc-name pkg-desc))
          (priority-version (package-desc-priority-version pkg-desc))
          (existing-packages (assq name alist)))
@@ -2100,7 +2102,7 @@ If optional arg BUTTON is non-nil, describe its associated package."
         (cond ((member status '("installed" "unsigned"))
                (push pkg-desc installed))
               ((member status '("available" "new"))
-               (setq available (package--add-to-alist pkg-desc available))))))
+               (setq available (package--append-to-alist pkg-desc available))))))
     ;; Loop through list of installed packages, finding upgrades.
     (dolist (pkg-desc installed)
       (let* ((name (package-desc-name pkg-desc))
diff --git a/lisp/ido.el b/lisp/ido.el
index 2321b57d08a..1f4e3facd36 100644
--- a/lisp/ido.el
+++ b/lisp/ido.el
@@ -208,13 +208,13 @@
 ;;
 ;; Customize the Ido group to change the Ido functionality.
 ;;
-;; To modify the keybindings, use the ido-setup-hook.  For example:
-;;(add-hook 'ido-setup-hook 'ido-my-keys)
+;; To modify the keybindings, use `define-key' on
+;; `ido-common-completion-map' or one of the specialized keymaps:
+;; `ido-file-dir-completion-map', `ido-file-completion-map' or
+;; `ido-buffer-completion-map'.
 ;;
-;;(defun ido-my-keys ()
-;;  "Add my keybindings for ido."
-;;  (define-key ido-completion-map " " 'ido-next-match)
-;;  )
+;; (with-eval-after-load 'ido
+;;   (define-key ido-common-completion-map " " 'ido-next-match))
 
 ;; Seeing all the matching buffers or files
 ;; ----------------------------------------
@@ -323,8 +323,8 @@
 
 (defvar recentf-list)
 
-;;; User Variables
-;;
+;;;; Options
+
 ;; These are some things you might want to change.
 
 (defun ido-fractionp (n)
@@ -978,25 +978,90 @@ The fallback command is passed as an argument to the functions."
   :type 'hook
   :group 'ido)
 
-;;; Internal Variables
-
-;; Persistent variables
-
-(defvar ido-completion-map nil
-  "Currently active keymap for Ido commands.")
+;;;; Keymaps
 
-(defvar ido-common-completion-map nil
+(defvar ido-common-completion-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map minibuffer-local-map)
+    (define-key map "\C-a" 'ido-toggle-ignore)
+    (define-key map "\C-c" 'ido-toggle-case)
+    (define-key map "\C-e" 'ido-edit-input)
+    (define-key map "\t" 'ido-complete)
+    (define-key map " " 'ido-complete-space)
+    (define-key map "\C-j" 'ido-select-text)
+    (define-key map "\C-m" 'ido-exit-minibuffer)
+    (define-key map "\C-p" 'ido-toggle-prefix)
+    (define-key map "\C-r" 'ido-prev-match)
+    (define-key map "\C-s" 'ido-next-match)
+    (define-key map [?\C-.] 'ido-next-match)
+    (define-key map [?\C-,] 'ido-prev-match)
+    (define-key map "\C-t" 'ido-toggle-regexp)
+    (define-key map "\C-z" 'ido-undo-merge-work-directory)
+    (define-key map [(control ?\s)] 'ido-restrict-to-matches)
+    (define-key map [(meta ?\s)] 'ido-take-first-match)
+    (define-key map [(control ?@)] 'ido-restrict-to-matches)
+    (define-key map [right] 'ido-next-match)
+    (define-key map [left] 'ido-prev-match)
+    (define-key map "?" 'ido-completion-help)
+    (define-key map "\C-b" 'ido-magic-backward-char)
+    (define-key map "\C-f" 'ido-magic-forward-char)
+    (define-key map "\C-d" 'ido-magic-delete-char)
+    map)
   "Keymap for all Ido commands.")
 
-(defvar ido-file-completion-map nil
-  "Keymap for Ido file commands.")
-
-(defvar ido-file-dir-completion-map nil
+(defvar ido-file-dir-completion-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map ido-common-completion-map)
+    (define-key map "\C-x\C-b" 'ido-enter-switch-buffer)
+    (define-key map "\C-x\C-f" 'ido-fallback-command)
+    (define-key map "\C-x\C-d" 'ido-enter-dired)
+    (define-key map [down] 'ido-next-match-dir)
+    (define-key map [up]   'ido-prev-match-dir)
+    (define-key map [(meta up)] 'ido-prev-work-directory)
+    (define-key map [(meta down)] 'ido-next-work-directory)
+    (define-key map [backspace] 'ido-delete-backward-updir)
+    (define-key map "\d"        'ido-delete-backward-updir)
+    (define-key map [remap delete-backward-char] 'ido-delete-backward-updir) ; BS
+    (define-key map [remap backward-kill-word] 'ido-delete-backward-word-updir)  ; M-DEL
+    (define-key map [(control backspace)] 'ido-up-directory)
+    (define-key map "\C-l" 'ido-reread-directory)
+    (define-key map [(meta ?d)] 'ido-wide-find-dir-or-delete-dir)
+    (define-key map [(meta ?b)] 'ido-push-dir)
+    (define-key map [(meta ?v)] 'ido-push-dir-first)
+    (define-key map [(meta ?f)] 'ido-wide-find-file-or-pop-dir)
+    (define-key map [(meta ?k)] 'ido-forget-work-directory)
+    (define-key map [(meta ?m)] 'ido-make-directory)
+    (define-key map [(meta ?n)] 'ido-next-work-directory)
+    (define-key map [(meta ?o)] 'ido-prev-work-file)
+    (define-key map [(meta control ?o)] 'ido-next-work-file)
+    (define-key map [(meta ?p)] 'ido-prev-work-directory)
+    (define-key map [(meta ?s)] 'ido-merge-work-directories)
+    map)
   "Keymap for Ido file and directory commands.")
 
-(defvar ido-buffer-completion-map nil
+(defvar ido-file-completion-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map ido-file-dir-completion-map)
+    (define-key map "\C-k" 'ido-delete-file-at-head)
+    (define-key map "\C-o" 'ido-copy-current-word)
+    (define-key map "\C-w" 'ido-copy-current-file-name)
+    (define-key map [(meta ?l)] 'ido-toggle-literal)
+    map)
+  "Keymap for Ido file commands.")
+
+(defvar ido-buffer-completion-map
+  (let ((map (make-sparse-keymap)))
+    (set-keymap-parent map ido-common-completion-map)
+    (define-key map "\C-x\C-f" 'ido-enter-find-file)
+    (define-key map "\C-x\C-b" 'ido-fallback-command)
+    (define-key map "\C-k" 'ido-kill-buffer-at-head)
+    (define-key map [?\C-\S-b] 'ido-bury-buffer-at-head)
+    (define-key map "\C-o" 'ido-toggle-virtual-buffers)
+    map)
   "Keymap for Ido buffer commands.")
 
+;;;; Persistent variables
+
 (defvar  ido-file-history nil
   "History of files selected using `ido-find-file'.")
 
@@ -1027,7 +1092,10 @@ Each element in the list is of the form (DIR (MTIME) FILE...).")
 Intended to be let-bound by functions which call Ido repeatedly.
 Should never be set permanently.")
 
-;; Temporary storage
+;;;; Temporary storage
+
+(defvar ido-completion-map nil
+  "Currently active keymap for Ido commands.")
 
 (defvar ido-eoinput 1
   "Point where minibuffer input ends and completion info begins.
@@ -1086,13 +1154,14 @@ Value is an integer which is number of chars to right of prompt.")
 This is a copy of `recentf-list', pared down and with faces applied.
 Only used if `ido-use-virtual-buffers' is non-nil.")
 
-;;; Variables with dynamic bindings.
-;;; Declared here to keep the byte compiler quiet.
+;;;; Variables with dynamic bindings.
+
+;; These are declared here to keep the byte compiler quiet.
 
 ;; Stores the current ido item type ('file, 'dir, 'buffer, or 'list).
 (defvar ido-cur-item)
 
-;;; Stores the current default item
+;; Stores the current default item.
 (defvar ido-default-item)
 
 ;; Stores the current list of items that will be searched through.
@@ -1502,7 +1571,6 @@ Removes badly formatted data and ignored directories."
   (ido-save-history))
 
 (defun ido-common-initialization ()
-  (ido-init-completion-maps)
   (add-hook 'minibuffer-setup-hook 'ido-minibuffer-setup)
   (add-hook 'choose-completion-string-functions 'ido-choose-completion-string))
 
@@ -1596,120 +1664,51 @@ This function also adds a hook to the minibuffer."
 
 
 ;;; IDO KEYMAP
-(defun ido-init-completion-maps ()
-  "Set up the completion keymaps used by Ido."
-
-  ;; Common map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\C-a" 'ido-toggle-ignore)
-    (define-key map "\C-c" 'ido-toggle-case)
-    (define-key map "\C-e" 'ido-edit-input)
-    (define-key map "\t" 'ido-complete)
-    (define-key map " " 'ido-complete-space)
-    (define-key map "\C-j" 'ido-select-text)
-    (define-key map "\C-m" 'ido-exit-minibuffer)
-    (define-key map "\C-p" 'ido-toggle-prefix)
-    (define-key map "\C-r" 'ido-prev-match)
-    (define-key map "\C-s" 'ido-next-match)
-    (define-key map [?\C-.] 'ido-next-match)
-    (define-key map [?\C-,] 'ido-prev-match)
-    (define-key map "\C-t" 'ido-toggle-regexp)
-    (define-key map "\C-z" 'ido-undo-merge-work-directory)
-    (define-key map [(control ?\s)] 'ido-restrict-to-matches)
-    (define-key map [(meta ?\s)] 'ido-take-first-match)
-    (define-key map [(control ?@)] 'ido-restrict-to-matches)
-    (define-key map [right] 'ido-next-match)
-    (define-key map [left] 'ido-prev-match)
-    (define-key map "?" 'ido-completion-help)
-    ;; Magic commands.
-    (define-key map "\C-b" 'ido-magic-backward-char)
-    (define-key map "\C-f" 'ido-magic-forward-char)
-    (define-key map "\C-d" 'ido-magic-delete-char)
-    (set-keymap-parent map minibuffer-local-map)
-    (setq ido-common-completion-map map))
-
-  ;; File and directory map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\C-x\C-b" 'ido-enter-switch-buffer)
-    (define-key map "\C-x\C-f" 'ido-fallback-command)
-    (define-key map "\C-x\C-d" 'ido-enter-dired)
-    (define-key map [down] 'ido-next-match-dir)
-    (define-key map [up]   'ido-prev-match-dir)
-    (define-key map [(meta up)] 'ido-prev-work-directory)
-    (define-key map [(meta down)] 'ido-next-work-directory)
-    (define-key map [backspace] 'ido-delete-backward-updir)
-    (define-key map "\d"        'ido-delete-backward-updir)
-    (define-key map [remap delete-backward-char] 'ido-delete-backward-updir) ; BS
-    (define-key map [remap backward-kill-word] 'ido-delete-backward-word-updir)  ; M-DEL
 
-    (define-key map [(control backspace)] 'ido-up-directory)
-    (define-key map "\C-l" 'ido-reread-directory)
-    (define-key map [(meta ?d)] 'ido-wide-find-dir-or-delete-dir)
-    (define-key map [(meta ?b)] 'ido-push-dir)
-    (define-key map [(meta ?v)] 'ido-push-dir-first)
-    (define-key map [(meta ?f)] 'ido-wide-find-file-or-pop-dir)
-    (define-key map [(meta ?k)] 'ido-forget-work-directory)
-    (define-key map [(meta ?m)] 'ido-make-directory)
-    (define-key map [(meta ?n)] 'ido-next-work-directory)
-    (define-key map [(meta ?o)] 'ido-prev-work-file)
-    (define-key map [(meta control ?o)] 'ido-next-work-file)
-    (define-key map [(meta ?p)] 'ido-prev-work-directory)
-    (define-key map [(meta ?s)] 'ido-merge-work-directories)
-    (set-keymap-parent map ido-common-completion-map)
-    (setq ido-file-dir-completion-map map))
+(defalias 'ido-init-completion-maps 'ignore "")
+(make-obsolete 'ido-init-completion-maps "it does nothing." "25.1")
 
-  ;; File only map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\C-k" 'ido-delete-file-at-head)
-    (define-key map "\C-o" 'ido-copy-current-word)
-    (define-key map "\C-w" 'ido-copy-current-file-name)
-    (define-key map [(meta ?l)] 'ido-toggle-literal)
-    (set-keymap-parent map ido-file-dir-completion-map)
-    (setq ido-file-completion-map map))
+(defun ido-setup-completion-map ()
+  "Set up the completion keymap used by Ido.
 
-  ;; Buffer map
-  (let ((map (make-sparse-keymap)))
-    (define-key map "\C-x\C-f" 'ido-enter-find-file)
-    (define-key map "\C-x\C-b" 'ido-fallback-command)
-    (define-key map "\C-k" 'ido-kill-buffer-at-head)
-    (define-key map [?\C-\S-b] 'ido-bury-buffer-at-head)
-    (define-key map "\C-o" 'ido-toggle-virtual-buffers)
-    (set-keymap-parent map ido-common-completion-map)
-    (setq ido-buffer-completion-map map)))
+Create a keymap, bind `ido-completion-map' to it, and depending
+on what is being completed (`ido-cur-item') set its parent keymap
+to one of:
 
+  `ido-common-completion-map'
+  `ido-file-dir-completion-map'
+  `ido-file-completion-map'
+  `ido-buffer-completion-map'
 
-(defun ido-setup-completion-map ()
-  "Set up the keymap for Ido."
-
+If option `ido-context-switch-command' is non-nil or `viper-mode'
+is enabled then some keybindings are changed in the keymap."
   ;; generated every time so that it can inherit new functions.
   (let ((map (make-sparse-keymap))
         (viper-p (if (boundp 'viper-mode) viper-mode)))
-
     (when viper-p
       (define-key map [remap viper-intercept-ESC-key] 'ignore))
-
-    (cond
-     ((memq ido-cur-item '(file dir))
+    (pcase ido-cur-item
+     ((or `file `dir)
       (when ido-context-switch-command
         (define-key map "\C-x\C-b" ido-context-switch-command)
         (define-key map "\C-x\C-d" 'ignore))
       (when viper-p
-        (define-key map [remap viper-backward-char] 'ido-delete-backward-updir)
-        (define-key map [remap viper-del-backward-char-in-insert] 'ido-delete-backward-updir)
-        (define-key map [remap viper-delete-backward-word] 'ido-delete-backward-word-updir))
+        (define-key map [remap viper-backward-char]
+          'ido-delete-backward-updir)
+        (define-key map [remap viper-del-backward-char-in-insert]
+          'ido-delete-backward-updir)
+        (define-key map [remap viper-delete-backward-word]
+          'ido-delete-backward-word-updir))
       (set-keymap-parent map
                          (if (eq ido-cur-item 'file)
                              ido-file-completion-map
                            ido-file-dir-completion-map)))
-
-     ((eq ido-cur-item 'buffer)
+     (`buffer
       (when ido-context-switch-command
         (define-key map "\C-x\C-f" ido-context-switch-command))
       (set-keymap-parent map ido-buffer-completion-map))
-
-     (t
+     (_
       (set-keymap-parent map ido-common-completion-map)))
-
     (setq ido-completion-map map)))
 
 (defun ido-final-slash (dir &optional fix-it)
diff --git a/lisp/progmodes/xref.el b/lisp/progmodes/xref.el
index 7f77d218a48..12123c8f2e2 100644
--- a/lisp/progmodes/xref.el
+++ b/lisp/progmodes/xref.el
@@ -51,6 +51,7 @@
 (require 'cl-lib)
 (require 'eieio)
 (require 'ring)
+(require 'pcase)
 
 (defgroup xref nil "Cross-referencing commands"
   :group 'tools)
@@ -333,19 +334,32 @@ WINDOW controls how the buffer is displayed:
 
 ;; The xref buffer is used to display a set of xrefs.
 
-(defvar-local xref--window-configuration nil)
+(defvar-local xref--display-history nil
+  "List of pairs (BUFFER . WINDOW), for temporarily displayed buffers.")
 
-(defun xref--display-position (pos other-window recenter-arg)
-  ;; show the location, but don't hijack focus.
+(defun xref--save-to-history (buf win)
+  (let ((restore (window-parameter win 'quit-restore)))
+    ;; Save the new entry if the window displayed another buffer
+    ;; previously.
+    (when (and restore (not (eq (car restore) 'same)))
+      (push (cons buf win) xref--display-history))))
+
+(defun xref--display-position (pos other-window recenter-arg xref-buf)
+  ;; Show the location, but don't hijack focus.
   (with-selected-window (display-buffer (current-buffer) other-window)
     (goto-char pos)
-    (recenter recenter-arg)))
+    (recenter recenter-arg)
+    (let ((buf (current-buffer))
+          (win (selected-window)))
+      (with-current-buffer xref-buf
+        (setq-local other-window-scroll-buffer buf)
+        (xref--save-to-history buf win)))))
 
 (defun xref--show-location (location)
   (condition-case err
-      (progn
+      (let ((xref-buf (current-buffer)))
         (xref--goto-location location)
-        (xref--display-position (point) t 1))
+        (xref--display-position (point) t 1 xref-buf))
     (user-error (message (error-message-string err)))))
 
 (defun xref-show-location-at-point ()
@@ -353,14 +367,8 @@ WINDOW controls how the buffer is displayed:
   (interactive)
   (let ((loc (xref--location-at-point)))
     (when loc
-      (setq xref--window-configuration (current-window-configuration))
       (xref--show-location loc))))
 
-(defun xref--restore-window-configuration ()
-  (when xref--window-configuration
-    (set-window-configuration xref--window-configuration)
-    (setq xref--window-configuration nil)))
-
 (defun xref-next-line ()
   "Move to the next xref and display its source in the other window."
   (interactive)
@@ -379,21 +387,21 @@ WINDOW controls how the buffer is displayed:
 (defvar-local xref--window nil)
 
 (defun xref-goto-xref ()
-  "Jump to the xref at point and bury the xref buffer."
+  "Jump to the xref on the current line and bury the xref buffer."
   (interactive)
+  (back-to-indentation)
   (let ((loc (or (xref--location-at-point)
-                 (error "No reference at point")))
+                 (user-error "No reference at point")))
         (window xref--window))
-    (quit-window)
+    (xref--quit)
     (xref--pop-to-location loc window)))
 
 (define-derived-mode xref--xref-buffer-mode fundamental-mode "XREF"
   "Mode for displaying cross-references."
-  (setq buffer-read-only t)
-  (add-hook 'pre-command-hook #'xref--restore-window-configuration nil t))
+  (setq buffer-read-only t))
 
 (let ((map xref--xref-buffer-mode-map))
-  (define-key map (kbd "q") #'quit-window)
+  (define-key map (kbd "q") #'xref--quit)
   (define-key map (kbd "n") #'xref-next-line)
   (define-key map (kbd "p") #'xref-prev-line)
   (define-key map (kbd "RET") #'xref-goto-xref)
@@ -403,6 +411,18 @@ WINDOW controls how the buffer is displayed:
   (define-key map (kbd ".") #'xref-next-line)
   (define-key map (kbd ",") #'xref-prev-line))
 
+(defun xref--quit ()
+  "Quit all windows in `xref--display-history', then quit current window."
+  (interactive)
+  (let ((window (selected-window))
+        (history xref--display-history))
+    (setq xref--display-history nil)
+    (pcase-dolist (`(,buf . ,win) history)
+      (when (and (window-live-p win)
+                 (eq buf (window-buffer win)))
+        (quit-window nil win)))
+    (quit-window nil window)))
+
 (defconst xref-buffer-name "*xref*"
   "The name of the buffer to show xrefs.")