Merge branch 'master' into feature/igcfeature/igc

4 files changed, 241 insertions, 147 deletions

diff --git a/lisp/vc/diff-mode.el b/lisp/vc/diff-mode.el
index 5c0fb5fba4c..559310ff770 100644
--- a/lisp/vc/diff-mode.el
+++ b/lisp/vc/diff-mode.el
@@ -201,8 +201,9 @@ The default \"-b\" means to ignore whitespace-only changes,
 (defvar-keymap diff-mode-shared-map
   :doc "Bindings for read-only `diff-mode' buffers.
 These bindings are also available with an ESC prefix
-(i.e. a \\=`M-' prefix) in read-write `diff-mode' buffers,
-and with a `diff-minor-mode-prefix' prefix in `diff-minor-mode'.
+(i.e. a \\=`M-' prefix) in all `diff-mode' buffers, including in
+particular read-write `diff-mode' buffers, and with a
+`diff-minor-mode-prefix' prefix in `diff-minor-mode'.
 See also `diff-mode-read-only-map'."
   "n" #'diff-hunk-next
   "N" #'diff-file-next
@@ -217,14 +218,7 @@ See also `diff-mode-read-only-map'."
   "RET" #'diff-goto-source
   "<mouse-2>" #'diff-goto-source
   "o" #'diff-goto-source                ; other-window
-  "<remap> <undo>" #'undo-ignore-read-only
-
-  ;; The foregoing commands don't affect buffers beyond this one.
-  ;; The following command is the only one that has a single-letter
-  ;; binding and which affects buffers beyond this one.
-  ;; However, the following command asks for confirmation by default,
-  ;; so that seems okay.  --spwhitton
-  "u" #'diff-revert-and-kill-hunk)
+  "<remap> <undo>" #'undo-ignore-read-only)
 
 ;; Not `diff-read-only-mode-map' because there is no such mode
 ;; `diff-read-only-mode'; see comment above.
@@ -233,15 +227,28 @@ See also `diff-mode-read-only-map'."
   :doc "Additional bindings for read-only `diff-mode' buffers.
 Most of the bindings for read-only `diff-mode' buffers are in
 `diff-mode-shared-map'.  This map contains additional bindings for
-read-only `diff-mode' buffers that are *not* available with an ESC
-prefix (i.e. a \\=`M-' prefix) in read-write `diff-mode' buffers."
+read-only `diff-mode' buffers that are *not* also available with an ESC
+prefix (i.e. a \\=`M-' prefix) in read-write (nor read-only) `diff-mode'
+buffers."
   ;; We don't want the following in read-write `diff-mode' buffers
   ;; because they hide useful `M-<foo>' global bindings when editing.
   "W" #'widen
   "w" #'diff-kill-ring-save
   "A" #'diff-ediff-patch
   "r" #'diff-restrict-view
-  "R" #'diff-reverse-direction)
+  "R" #'diff-reverse-direction
+  "s" #'diff-split-hunk
+
+  ;; The foregoing commands in `diff-mode-shared-map' and
+  ;; `diff-mode-read-only-map' don't affect buffers beyond this one.
+  ;; The following command is the only one that has a single-character
+  ;; binding and which affects buffers beyond this one.  However, the
+  ;; following command asks for confirmation by default, so that seems
+  ;; okay.  --spwhitton
+  "u" #'diff-revert-and-kill-hunk
+  ;; `diff-revert-and-kill-hunk' is the `diff-mode' analogue of what '@'
+  ;; does in VC-Dir, so give it the same short binding.
+  "@" #'diff-revert-and-kill-hunk)
 
 (defvar-keymap diff-mode-map
   :doc "Keymap for `diff-mode'.  See also `diff-mode-shared-map'."
@@ -882,31 +889,19 @@ If the prefix ARG is given, restrict the view to the current file instead."
     (goto-char (point-min))
     (re-search-forward diff-hunk-header-re nil t)))
 
-(defun diff-hunk-kill ()
-  "Kill the hunk at point."
-  (interactive)
-  (if (not (diff--some-hunks-p))
-      (error "No hunks")
-    (diff-beginning-of-hunk t)
-    (let* ((hunk-bounds (diff-bounds-of-hunk))
-           (file-bounds (ignore-errors (diff-bounds-of-file)))
-           ;; If the current hunk is the only one for its file, kill the
-           ;; file header too.
-           (bounds (if (and file-bounds
-                            (progn (goto-char (car file-bounds))
-                                   (= (progn (diff-hunk-next) (point))
-                                      (car hunk-bounds)))
-                            (progn (goto-char (cadr hunk-bounds))
-                                   ;; bzr puts a newline after the last hunk.
-                                   (while (looking-at "^\n")
-                                     (forward-char 1))
-                                   (= (point) (cadr file-bounds))))
-                       file-bounds
-                     hunk-bounds))
-           (inhibit-read-only t))
-      (apply #'kill-region bounds)
-      (goto-char (car bounds))
-      (ignore-errors (diff-beginning-of-hunk t)))))
+(defun diff-hunk-kill (&optional beg end)
+  "Kill the hunk at point.
+When killing the last hunk left for a file, kill the file header too.
+Interactively, if the region is active, kill all hunks that the region
+overlaps.
+
+When called from Lisp with optional arguments BEG and END non-nil, kill
+all hunks overlapped by the region from BEG to END as though called
+interactively with an active region delimited by BEG and END."
+  (interactive "R")
+  (when (xor beg end)
+    (error "Invalid call to `diff-hunk-kill'"))
+  (diff--revert-kill-hunks beg end nil))
 
 ;; This is not `diff-kill-other-hunks' because we might need to make
 ;; copies of file headers in order to ensure the new kill ring entry
@@ -2282,6 +2277,83 @@ With a prefix argument, try to REVERSE the hunk."
   :type 'boolean
   :version "31.1")
 
+(defun diff--revert-kill-hunks (beg end revertp)
+  "Workhorse routine for killing hunks, after possibly reverting them.
+If BEG and END are nil, kill the hunk at point.
+Otherwise kill all hunks overlapped by region delimited by BEG and END.
+When killing a hunk that's the only one remaining for its file, kill the
+file header too.
+If REVERTP is non-nil, reverse-apply hunks before killing them."
+  ;; With BEG and END non-nil, we push each hunk to the kill ring
+  ;; separately.  If we want to push to the kill ring just once, we have
+  ;; to decide how to handle file headers such that the meanings of the
+  ;; hunks in the kill ring entry, considered as a whole patch, do not
+  ;; deviate too far from the meanings the hunks had in this buffer.
+  ;;
+  ;; For example, if we have a single hunk for one file followed by
+  ;; multiple hunks for another file, and we naïvely kill the single
+  ;; hunk and the first of the multiple hunks, our kill ring entry will
+  ;; be a patch applying those two hunks to the first file.  This is
+  ;; because killing the single hunk will have brought its file header
+  ;; with it, but not so killing the second hunk.  So we will have put
+  ;; together hunks that were previously for two different files.
+  ;;
+  ;; One option is to *copy* every file header that the region overlaps
+  ;; (and that we will not kill, because we are leaving other hunks for
+  ;; that file behind).  But then the text this command pushes to the
+  ;; kill ring would be different from the text it removes from the
+  ;; buffer, which would be unintuitive for an Emacs kill command.
+  ;;
+  ;; An alternative might be to have restrictions as follows:
+  ;;
+  ;;   Interactively, if the region is active, try to kill all hunks that the
+  ;;   region overlaps.  This works when either
+  ;;   - all the hunks the region overlaps are for the same file; or
+  ;;   - the last hunk the region overlaps is the last hunk for its file.
+  ;;   These restrictions are so that the text added to the kill ring does not
+  ;;   merge together hunks for different files under a single file header.
+  ;;
+  ;; We would error out if neither property is met.  When either holds,
+  ;; any file headers the region overlaps are ones we should kill.
+  (unless (diff--some-hunks-p)
+    (error "No hunks"))
+  (if beg
+      (save-excursion
+        (goto-char beg)
+        (setq beg (car (diff-bounds-of-hunk)))
+        (goto-char end)
+        (unless (looking-at diff-hunk-header-re)
+          (setq end (cadr (diff-bounds-of-hunk)))))
+    (pcase-setq `(,beg ,end) (diff-bounds-of-hunk)))
+  (when (or (not revertp) (null (diff-apply-buffer beg end t)))
+    (goto-char end)
+    (when-let* ((pos (diff--at-diff-header-p)))
+      (goto-char pos))
+    (setq beg (copy-marker beg) end (point-marker))
+    (unwind-protect
+        (cl-loop initially (goto-char beg)
+                 with inhibit-read-only = t
+                 for (hunk-beg hunk-end) = (diff-bounds-of-hunk)
+                 for file-bounds = (ignore-errors (diff-bounds-of-file))
+                 for (file-beg file-end) = file-bounds
+                 if (and file-bounds
+                         (progn
+                           (goto-char file-beg)
+                           (diff-hunk-next)
+                           (eq (point) hunk-beg))
+                         (progn
+                           (goto-char hunk-end)
+                           ;; bzr puts a newline after the last hunk.
+                           (while (looking-at "^\n") (forward-char 1))
+                           (eq (point) file-end)))
+                 do (kill-region file-beg file-end) (goto-char file-beg)
+                 else do (kill-region hunk-beg hunk-end) (goto-char hunk-beg)
+                 do (ignore-errors (diff-beginning-of-hunk t))
+                 until (or (< (point) (marker-position beg))
+                           (eql (point) (marker-position end))))
+      (set-marker beg nil)
+      (set-marker end nil))))
+
 (defun diff-revert-and-kill-hunk (&optional beg end)
   "Reverse-apply and then kill the hunk at point.  Save changed buffer.
 Interactively, if the region is active, reverse-apply and kill all
@@ -2307,27 +2379,7 @@ BEG and END."
     (error "Invalid call to `diff-revert-and-kill-hunk'"))
   (when (or (not diff-ask-before-revert-and-kill-hunk)
             (y-or-n-p "Really reverse-apply and kill hunk(s)?"))
-    (if beg
-        (save-excursion
-          (goto-char beg)
-          (setq beg (car (diff-bounds-of-hunk)))
-          (goto-char end)
-          (unless (looking-at diff-hunk-header-re)
-            (setq end (cadr (diff-bounds-of-hunk)))))
-      (pcase-setq `(,beg ,end) (diff-bounds-of-hunk)))
-    (when (null (diff-apply-buffer beg end t))
-      ;; Use `diff-hunk-kill' because it properly handles file headers.
-      (goto-char end)
-      (when-let* ((pos (diff--at-diff-header-p)))
-        (goto-char pos))
-      (setq beg (copy-marker beg) end (point-marker))
-      (unwind-protect
-          (cl-loop initially (goto-char beg)
-                   do (diff-hunk-kill)
-                   until (or (< (point) (marker-position beg))
-                             (eql (point) (marker-position end))))
-        (set-marker beg nil)
-        (set-marker end nil)))))
+    (diff--revert-kill-hunks beg end t)))
 
 (defun diff-apply-buffer (&optional beg end reverse test-or-no-save)
   "Apply the diff in the entire diff buffer.
diff --git a/lisp/vc/vc-dispatcher.el b/lisp/vc/vc-dispatcher.el
index dc17b582ed7..2015e7540ae 100644
--- a/lisp/vc/vc-dispatcher.el
+++ b/lisp/vc/vc-dispatcher.el
@@ -384,6 +384,9 @@ the man pages for \"torsocks\" for more details about Tor."
   :version "27.1"
   :group 'vc)
 
+(defvar vc-user-edit-command-history nil
+  "Name of minibuffer history variable for `vc-user-edit-command'.")
+
 (defun vc-user-edit-command (command file-or-list flags)
   "Prompt the user to edit VC command COMMAND and FLAGS.
 Intended to be used as the value of `vc-filter-command-function'."
@@ -398,7 +401,8 @@ Intended to be used as the value of `vc-filter-command-function'."
                             (cons command (remq nil (if files-separator-p
                                                         (butlast flags)
                                                       flags))))
-                           " ")))))
+                           " ")
+                   vc-user-edit-command-history))))
     (list (car edited) file-or-list
           (nconc (cdr edited) (and files-separator-p '("--"))))))
 
diff --git a/lisp/vc/vc-git.el b/lisp/vc/vc-git.el
index 73db9c0f181..5e51b28fb37 100644
--- a/lisp/vc/vc-git.el
+++ b/lisp/vc/vc-git.el
@@ -772,70 +772,91 @@ or an empty string if none."
   (vc-git--out-match '("symbolic-ref" "HEAD")
                      "^\\(refs/heads/\\)?\\(.+\\)$" 2))
 
+(defun vc-git--branch-remotes ()
+  "Return alist of configured remote branches for current branch.
+If there is a configured upstream, return the remote-tracking branch
+with key `upstream'.  If there is a distinct configured push remote,
+return the remote-tracking branch there with key `push'.
+A configured push remote that's just the same as the upstream remote is
+ignored because that means we're not actually in a triangular workflow."
+  ;; Possibly we could simplify this using @{push}, but that may involve
+  ;; an unwanted dependency on the setting of push.default.
+  (cl-flet ((get (key)
+              (string-trim-right (vc-git--out-str "config" key))))
+    (let* ((branch (vc-git-working-branch))
+           (pull (get (format "branch.%s.remote" branch)))
+           (merge (string-remove-prefix "refs/heads/"
+                                        (get (format "branch.%s.merge"
+                                                     branch))))
+           (push (get (format "branch.%s.pushRemote" branch)))
+           (push (if (string-empty-p push)
+                     (get "remote.pushDefault")
+                   push))
+           (alist (and (not (string-empty-p pull))
+                       (not (string-empty-p merge))
+                       `((upstream . ,(format "%s/%s" pull merge))))))
+      (if (or (string-empty-p push) (equal push pull))
+          alist
+        (cl-acons 'push (format "%s/%s" push branch) alist)))))
+
 (defun vc-git-trunk-or-topic-p ()
   "Return `topic' if branch has distinct pull and push remotes, else nil.
 This is able to identify topic branches for certain forge workflows."
-  (let* ((branch (vc-git-working-branch))
-         (merge (string-trim-right
-                 (vc-git--out-str "config" (format "branch.%s.remote"
-                                                   branch))))
-         (push (string-trim-right
-                (vc-git--out-str "config" (format "branch.%s.pushRemote"
-                                                  branch))))
-         (push (if (string-empty-p push)
-                   (string-trim-right
-                    (vc-git--out-str "config" "remote.pushDefault"))
-                 push)))
-    (and (plusp (length merge))
-         (plusp (length push))
-         (not (equal merge push))
-         'topic)))
+  (let ((remotes (vc-git--branch-remotes)))
+    (and (assq 'upstream remotes) (assq 'push remotes) 'topic)))
 
 (defun vc-git-topic-outgoing-base ()
   "Return the outgoing base for the current branch as a string.
 This works by considering the current branch as a topic branch
 (whether or not it actually is).
-Requires that the corresponding trunk exists as a local branch.
-
-The algorithm employed is as follows.  Find all merge bases between the
-current branch and other local branches.  Each of these is a commit on
-the current branch.  Use `git merge-base --independent' on them all to
-find the topologically most recent.  Take the branch for which that
-commit is a merge base with the current branch to be the branch into
-which the current branch will eventually be merged.  Find its upstream.
-(If there is more than one branch whose merge base with the current
-branch is that same topologically most recent commit, try them
-one-by-one, accepting the first that has an upstream.)"
-  (cl-flet ((get-line () (buffer-substring (point) (pos-eol))))
-    (let* ((branches (vc-git-branches))
-           (current (pop branches))
-           merge-bases)
-      (with-temp-buffer
-        (dolist (branch branches)
-          (erase-buffer)
-          (when (vc-git--out-ok "merge-base" "--all" branch current)
-            (goto-char (point-min))
-            (while (not (eobp))
-              (push branch
-                    (alist-get (get-line) merge-bases nil nil #'equal))
-              (forward-line 1))))
-        (erase-buffer)
-        (unless (apply #'vc-git--out-ok "merge-base" "--independent"
-                       (mapcar #'car merge-bases))
-          (error "`git merge-base --independent' failed"))
-        ;; If 'git merge-base --independent' printed more than one line,
-        ;; just pick the first.
-        (goto-char (point-min))
-        (catch 'ret
-          (dolist (target (cdr (assoc (get-line) merge-bases)))
+
+If there is a distinct push remote for this branch, assume the target
+for outstanding changes is the tracking branch, and return that.
+
+Otherwise, fall back to the following algorithm, which requires that the
+corresponding trunk exists as a local branch.  Find all merge bases
+between the current branch and other local branches.  Each of these is a
+commit on the current branch.  Use `git merge-base --independent' on
+them all to find the topologically most recent.  Take the branch for
+which that commit is a merge base with the current branch to be the
+branch into which the current branch will eventually be merged.  Find
+its upstream.  (If there is more than one branch whose merge base with
+the current branch is that same topologically most recent commit, try
+them one-by-one, accepting the first that has an upstream.)"
+  (if-let* ((remotes (vc-git--branch-remotes))
+            (_ (assq 'push remotes))
+            (upstream (assq 'upstream remotes)))
+      (cdr upstream)
+    (cl-flet ((get-line () (buffer-substring (point) (pos-eol))))
+      (let* ((branches (vc-git-branches))
+             (current (pop branches))
+             merge-bases)
+        (with-temp-buffer
+          (dolist (branch branches)
             (erase-buffer)
-            (when (vc-git--out-ok "for-each-ref"
-                                  "--format=%(upstream:short)"
-                                  (concat "refs/heads/" target))
+            (when (vc-git--out-ok "merge-base" "--all" branch current)
               (goto-char (point-min))
-              (let ((outgoing-base (get-line)))
-                (unless (string-empty-p outgoing-base)
-                  (throw 'ret outgoing-base))))))))))
+              (while (not (eobp))
+                (push branch (alist-get (get-line) merge-bases
+                                        nil nil #'equal))
+                (forward-line 1))))
+          (erase-buffer)
+          (unless (apply #'vc-git--out-ok "merge-base" "--independent"
+                         (mapcar #'car merge-bases))
+            (error "`git merge-base --independent' failed"))
+          ;; If 'git merge-base --independent' printed more than one
+          ;; line, just pick the first.
+          (goto-char (point-min))
+          (catch 'ret
+            (dolist (target (cdr (assoc (get-line) merge-bases)))
+              (erase-buffer)
+              (when (vc-git--out-ok "for-each-ref"
+                                    "--format=%(upstream:short)"
+                                    (concat "refs/heads/" target))
+                (goto-char (point-min))
+                (let ((outgoing-base (get-line)))
+                  (unless (string-empty-p outgoing-base)
+                    (throw 'ret outgoing-base)))))))))))
 
 (defun vc-git-dir--branch-headers ()
   "Return headers for branch-related information."
@@ -1451,7 +1472,9 @@ line of the commit message in an entry with key \"Subject\"."
                  (if (eq system-type 'windows-nt)
                      locale-coding-system
                    coding-system-for-write)))
-            (vc-git--call input-file t "mailinfo" msg-file patch-file))
+            (vc-git--call input-file t "mailinfo"
+                          (file-local-name msg-file)
+                          (file-local-name patch-file)))
           (goto-char (point-min))
           ;; git-mailinfo joins up any header continuation lines for us.
           (while (re-search-forward "^\\([^\t\n\s:]+\\):\\(.*\\)$" nil t)
@@ -1591,7 +1614,9 @@ If PROMPT is non-nil, prompt for the Git command to run."
          (vc-filter-command-function
           (if prompt
               (lambda (&rest args)
-                (cl-destructuring-bind (&whole args git _ flags)
+                (cl-destructuring-bind
+                    (&whole args git _ flags
+                            &aux (vc-user-edit-command-history 'vc-git-history))
                     (apply #'vc-user-edit-command args)
                   (setq git-program git
                         command (car flags)
@@ -2567,9 +2592,9 @@ This command shares argument histories with \\[rgrep] and \\[grep]."
   ;; In *vc-dir*, if nothing is marked, act on the whole working tree
   ;; regardless of the position of point.  This preserves historical
   ;; behavior and is also probably more useful.
-  (if (derived-mode-p 'vc-dir-mode)
-      (vc-dir-marked-files)
-    (cadr (vc-deduce-fileset))))
+  (mapcar #'file-relative-name (if (derived-mode-p 'vc-dir-mode)
+                                   (vc-dir-marked-files)
+                                 (cadr (vc-deduce-fileset)))))
 
 (defun vc-git-stash (name)
   "Create a stash named NAME.
diff --git a/lisp/vc/vc.el b/lisp/vc/vc.el
index 770906ff6cc..88324a2a444 100644
--- a/lisp/vc/vc.el
+++ b/lisp/vc/vc.el
@@ -3330,15 +3330,13 @@ to which `vc-push' would push as UPSTREAM-LOCATION, unconditionally.
 (This is passed when the user invokes an outgoing base command with a
  \\`C-u C-u' prefix argument; see `vc--maybe-read-outgoing-base'.)
 REFRESH is passed on to `vc--incoming-revision'."
-  (if-let* ((incoming
-             (vc--incoming-revision backend
-                                    (pcase upstream-location
-                                      ('t nil)
-                                      ('nil (vc--outgoing-base backend))
-                                      (_ upstream-location))
-                                    refresh)))
-      (vc-call-backend backend 'mergebase incoming)
-    (user-error "No incoming revision -- local-only branch?")))
+  (vc-call-backend backend 'mergebase
+                   (vc--incoming-revision backend
+                                          (pcase upstream-location
+                                            ('t nil)
+                                            ('nil (vc--outgoing-base backend))
+                                            (_ upstream-location))
+                                          refresh)))
 
 ;;;###autoload
 (defun vc-root-diff-outgoing-base (&optional upstream-location)
@@ -3349,7 +3347,9 @@ Uncommitted changes are included in the diff.
 
 When unspecified, UPSTREAM-LOCATION is the outgoing base.
 For a trunk branch this is always the place \\[vc-push] would push to.
-For a topic branch, query the backend for an appropriate outgoing base.
+For a topic branch, see whether the branch matches one of
+`vc-trunk-branch-regexps' or `vc-topic-branch-regexps', or else query
+the backend for an appropriate outgoing base.
 See `vc-trunk-branch-regexps' and `vc-topic-branch-regexps' regarding
 the difference between trunk and topic branches.
 
@@ -3377,7 +3377,9 @@ Uncommitted changes are included in the diff.
 
 When unspecified, UPSTREAM-LOCATION is the outgoing base.
 For a trunk branch this is always the place \\[vc-push] would push to.
-For a topic branch, query the backend for an appropriate outgoing base.
+For a topic branch, see whether the branch matches one of
+`vc-trunk-branch-regexps' or `vc-topic-branch-regexps', or else query
+the backend for an appropriate outgoing base.
 See `vc-trunk-branch-regexps' and `vc-topic-branch-regexps' regarding
 the difference between trunk and topic branches.
 
@@ -3411,7 +3413,9 @@ working revision and UPSTREAM-LOCATION.
 
 When unspecified, UPSTREAM-LOCATION is the outgoing base.
 For a trunk branch this is always the place \\[vc-push] would push to.
-For a topic branch, query the backend for an appropriate outgoing base.
+For a topic branch, see whether the branch matches one of
+`vc-trunk-branch-regexps' or `vc-topic-branch-regexps', or else query
+the backend for an appropriate outgoing base.
 See `vc-trunk-branch-regexps' and `vc-topic-branch-regexps' regarding
 the difference between trunk and topic branches.
 
@@ -3443,7 +3447,9 @@ working revision and UPSTREAM-LOCATION.
 
 When unspecified, UPSTREAM-LOCATION is the outgoing base.
 For a trunk branch this is always the place \\[vc-push] would push to.
-For a topic branch, query the backend for an appropriate outgoing base.
+For a topic branch, see whether the branch matches one of
+`vc-trunk-branch-regexps' or `vc-topic-branch-regexps', or else query
+the backend for an appropriate outgoing base.
 See `vc-trunk-branch-regexps' and `vc-topic-branch-regexps' regarding
 the difference between trunk and topic branches.
 
@@ -4435,20 +4441,23 @@ BACKEND is the VC backend."
   ;; Do store `nil', before signaling an error, if there is no incoming
   ;; revision, because that's also something that can be slow to
   ;; determine and so should be remembered.
-  (if-let* ((_ (not refresh))
-            (record (assoc upstream-location
-                           (vc--repo-getprop backend 'vc-incoming-revision))))
-      (cdr record)
-    (let ((res (vc-call-backend backend 'incoming-revision
-                                upstream-location refresh)))
-      (if-let* ((alist (vc--repo-getprop backend 'vc-incoming-revision)))
-          (setf (alist-get upstream-location alist nil nil #'equal)
-                res)
-        (vc--repo-setprop backend
-                          'vc-incoming-revision
-                          `((,upstream-location . ,res))))
-      (or res
-          (user-error "No incoming revision -- local-only branch?")))))
+  (or (if-let* ((_ (not refresh))
+                (record (assoc upstream-location
+                               (vc--repo-getprop backend
+                                                 'vc-incoming-revision))))
+          (cdr record)
+        (let ((res (vc-call-backend backend 'incoming-revision
+                                    upstream-location refresh)))
+          (if-let* ((alist (vc--repo-getprop backend
+                                             'vc-incoming-revision)))
+              (setf (alist-get upstream-location alist
+                               nil nil #'equal)
+                    res)
+            (vc--repo-setprop backend
+                              'vc-incoming-revision
+                              `((,upstream-location . ,res))))
+          res))
+      (user-error "No incoming revision -- local-only branch?")))
 
 ;;;###autoload
 (defun vc-root-log-incoming (&optional upstream-location)
@@ -5017,6 +5026,9 @@ log entries should be gathered."
 
 (defvar vc-filter-command-function)
 
+(defvar vc-edit-next-command-history nil
+  "Minibuffer history for `vc-edit-next-command'.")
+
 ;;;###autoload
 (defun vc-edit-next-command ()
   "Request editing the next VC shell command before execution.
@@ -5040,7 +5052,8 @@ immediately after this one."
     (add-hook 'prefix-command-echo-keystrokes-functions echofun)
     (setq vc-filter-command-function
           (lambda (&rest args)
-            (apply #'vc-user-edit-command (apply old args))))))
+            (let ((vc-user-edit-command-history 'vc-edit-next-command-history))
+              (apply #'vc-user-edit-command (apply old args)))))))
 
 ;; This is used in .dir-locals.el in the Emacs source tree.
 ;;;###autoload (put 'vc-prepare-patches-separately 'safe-local-variable 'booleanp)