upstream

25 files changed, 465 insertions, 183 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 509c940a8f4..9f9302680be 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,120 @@
+2013-05-28  Alan Mackenzie  <acm@muc.de>
+
+        Handle "capitalised keywords" correctly.
+        * progmodes/cc-mode.el (c-after-change): bind case-fold-search to
+        nil.
+
+2013-05-28  Aidan Gauland  <aidalgol@amuri.net>
+
+        * eshell/em-unix.el: Added -r option to cp
+
+2013-05-28  Glenn Morris  <rgm@gnu.org>
+
+        * vc/vc-arch.el (vc-exec-after): Declare.
+        (vc-switches): Autoload.
+        * vc/vc-bzr.el: No need to require vc when compiling.
+        (vc-exec-after, vc-set-async-update, vc-default-dir-printer)
+        (vc-resynch-buffer, vc-dir-refresh): Declare.
+        (vc-setup-buffer, vc-switches): Autoload.
+        * vc/vc-cvs.el (vc-exec-after, vc-coding-system-for-diff)
+        (vc-resynch-buffer): Declare.
+        (vc-switches, vc-default-revert, vc-version-backup-file): Autoload.
+        * vc/vc-dir.el (desktop-missing-file-warning): Declare.
+        * vc/vc-git.el (vc-exec-after, vc-set-async-update)
+        (grep-read-regexp, grep-read-files, grep-expand-template)
+        (vc-dir-refresh): Declare.
+        (vc-setup-buffer, vc-switches, vc-resynch-buffer): Autoload.
+        * vc/vc-hg.el (vc-exec-after, vc-set-async-update): Declare.
+        (vc-setup-buffer, vc-switches, vc-do-async-command): Autoload.
+        * vc/vc-mtn.el (vc-exec-after): Declare.
+        (vc-switches): Autoload.
+        * vc/vc-rcs.el (vc-expand-dirs, vc-switches)
+        (vc-tag-precondition, vc-buffer-sync, vc-rename-master): Autoload.
+        (vc-file-tree-walk): Declare.
+        * vc/vc-sccs.el (vc-file-tree-walk): Declare.
+        (vc-expand-dirs, vc-switches, vc-setup-buffer, vc-delistify)
+        (vc-tag-precondition, vc-rename-master): Autoload.
+        * vc/vc-svn.el (vc-exec-after): Declare.
+        (vc-switches, vc-setup-buffer): Autoload.
+        * obsolete/vc-mcvs.el (vc-checkout, vc-switches, vc-default-revert):
+        Autoload.
+        (vc-resynch-buffer): Declare.
+
+        * obsolete/fast-lock.el (byte-compile-warnings):
+        Don't warn about obsolete features in this obsolete file.
+
+        * progmodes/cc-vars.el (c-macro-names-with-semicolon):
+        Move definition before use.
+
+        * play/dunnet.el (byte-compile-warnings): Don't disable them all.
+        (dun-unix-verbs): Remove dun-zippy.
+        (dun-zippy): Remove function.
+
+        * emacs-lisp/bytecomp.el (byte-compile-warnings): Doc fix.
+
+2013-05-27  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (replace-search): New function with code moved out
+        from `perform-replace'.
+        (replace-highlight, replace-dehighlight): Move function definitions
+        up closer to `replace-search'.  (Bug#11746)
+
+2013-05-27  Juri Linkov  <juri@jurta.org>
+
+        * replace.el (perform-replace): Ignore invisible matches.
+        In addition to checking `query-replace-skip-read-only', also
+        filter out matches by calling `run-hook-with-args-until-failure'
+        on `isearch-filter-predicates', and also check `search-invisible'
+        for t or call `isearch-range-invisible'.
+        (replace-dehighlight): Call `isearch-clean-overlays'.  (Bug#11746)
+
+2013-05-27  Juri Linkov  <juri@jurta.org>
+
+        * isearch.el (isearch-filter-predicates): Rename from
+        `isearch-filter-predicate'.  Doc fix.  (Bug#11378)
+        (isearch-message-prefix): Display text from the property
+        `isearch-message-prefix' of the currently active filters.
+        (isearch-search): Don't compare `isearch-filter-predicate' with
+        `isearch-filter-visible'.  Call `run-hook-with-args-until-failure'
+        on `isearch-filter-predicates'.  Also check `search-invisible' for t
+        or call `isearch-range-invisible'.
+        (isearch-filter-visible): Make obsolete.
+        (isearch-lazy-highlight-search):
+        Call `run-hook-with-args-until-failure' on
+        `isearch-filter-predicates' and use `isearch-range-invisible'.
+
+        * info.el (Info-search): Call `run-hook-with-args-until-failure' on
+        `isearch-filter-predicates' instead of `funcall'ing
+        `isearch-filter-predicate'.
+        (Info-mode): Set `Info-isearch-filter' to
+        `isearch-filter-predicates' instead of `isearch-filter-predicate'.
+
+        * dired-aux.el (dired-isearch-filter-predicate-orig):
+        Remove variable.
+        (dired-isearch-filenames-toggle, dired-isearch-filenames-setup)
+        (dired-isearch-filenames-end): Add and remove
+        `dired-isearch-filter-filenames' in `isearch-filter-predicates'
+        instead of changing the value of `isearch-filter-predicate'.
+        Rebind `dired-isearch-filenames-toggle' from "\M-sf" to "\M-sff".
+        (dired-isearch-filter-filenames): Don't use `isearch-filter-visible'.
+        Put property `isearch-message-prefix' to "filename " on
+        `dired-isearch-filter-filenames'.
+
+        * wdired.el (wdired-change-to-wdired-mode):
+        Add `isearch-filter-predicates' to `wdired-isearch-filter-read-only'
+        locally instead of changing `isearch-filter-predicate'.
+        (wdired-isearch-filter-read-only): Don't use `isearch-filter-visible'.
+
+2013-05-27  Dmitry Gutov  <dgutov@yandex.ru>
+
+        * vc/vc-git.el (vc-git-working-revision): When in detached mode,
+        return the commit hash (Bug#14459).  Also set the
+        `vc-git-detached' property.
+        (vc-git--rev-parse): Extract from `vc-git-previous-revision'.
+        (vc-git-mode-line-string): Use the same help-echo format whether
+        in detached mode or not, because we know the actual revision now.
+        When in detached mode, shorten the revision to 7 chars.
+
 2013-05-27  Stefan Monnier  <monnier@iro.umontreal.ca>
 
         * emacs-lisp/easy-mmode.el (define-minor-mode):
diff --git a/lisp/dired-aux.el b/lisp/dired-aux.el
index f6ff32b0b01..7cb63f6b012 100644
--- a/lisp/dired-aux.el
+++ b/lisp/dired-aux.el
@@ -2491,18 +2491,16 @@ a file name.  Otherwise, it searches the whole buffer without restrictions."
   :group 'dired
   :version "23.1")
 
-(defvar dired-isearch-filter-predicate-orig nil)
-
 (defun dired-isearch-filenames-toggle ()
   "Toggle file names searching on or off.
 When on, Isearch skips matches outside file names using the predicate
 `dired-isearch-filter-filenames' that matches only at file names.
 When off, it uses the original predicate."
   (interactive)
-  (setq isearch-filter-predicate
-        (if (eq isearch-filter-predicate 'dired-isearch-filter-filenames)
-            dired-isearch-filter-predicate-orig
-          'dired-isearch-filter-filenames))
+  (setq isearch-filter-predicates
+        (if (memq 'dired-isearch-filter-filenames isearch-filter-predicates)
+            (delq 'dired-isearch-filter-filenames isearch-filter-predicates)
+          (cons 'dired-isearch-filter-filenames isearch-filter-predicates)))
   (setq isearch-success t isearch-adjusted t)
   (isearch-update))
 
@@ -2513,29 +2511,27 @@ Intended to be added to `isearch-mode-hook'."
   (when (or (eq dired-isearch-filenames t)
             (and (eq dired-isearch-filenames 'dwim)
                  (get-text-property (point) 'dired-filename)))
-    (setq isearch-message-prefix-add "filename ")
-    (define-key isearch-mode-map "\M-sf" 'dired-isearch-filenames-toggle)
-    (setq dired-isearch-filter-predicate-orig
-          (default-value 'isearch-filter-predicate))
-    (setq-default isearch-filter-predicate 'dired-isearch-filter-filenames)
+    (define-key isearch-mode-map "\M-sff" 'dired-isearch-filenames-toggle)
+    (add-hook 'isearch-filter-predicates 'dired-isearch-filter-filenames nil t)
     (add-hook 'isearch-mode-end-hook 'dired-isearch-filenames-end nil t)))
 
 (defun dired-isearch-filenames-end ()
   "Clean up the Dired file name search after terminating isearch."
   (setq isearch-message-prefix-add nil)
-  (define-key isearch-mode-map "\M-sf" nil)
-  (setq-default isearch-filter-predicate dired-isearch-filter-predicate-orig)
+  (define-key isearch-mode-map "\M-sff" nil)
+  (remove-hook 'isearch-filter-predicates 'dired-isearch-filter-filenames t)
   (remove-hook 'isearch-mode-end-hook 'dired-isearch-filenames-end t))
 
 (defun dired-isearch-filter-filenames (beg end)
-  "Test whether the current search hit is a visible file name.
+  "Test whether the current search hit is a file name.
 Return non-nil if the text from BEG to END is part of a file
-name (has the text property `dired-filename') and is visible."
-  (and (isearch-filter-visible beg end)
-       (if dired-isearch-filenames
-           (text-property-not-all (min beg end) (max beg end)
-                                  'dired-filename nil)
-         t)))
+name (has the text property `dired-filename')."
+  (if dired-isearch-filenames
+      (text-property-not-all (min beg end) (max beg end)
+                             'dired-filename nil)
+    t))
+
+(put 'dired-isearch-filter-filenames 'isearch-message-prefix "filename ")
 
 ;;;###autoload
 (defun dired-isearch-filenames ()
diff --git a/lisp/dired.el b/lisp/dired.el
index f03e0aca475..5b6a78759db 100644
--- a/lisp/dired.el
+++ b/lisp/dired.el
@@ -3864,7 +3864,7 @@ Ask means pop up a menu for the user to select one of copy, move or link."
 ;;;;;;  dired-run-shell-command dired-do-shell-command dired-do-async-shell-command
 ;;;;;;  dired-clean-directory dired-do-print dired-do-touch dired-do-chown
 ;;;;;;  dired-do-chgrp dired-do-chmod dired-compare-directories dired-backup-diff
-;;;;;;  dired-diff) "dired-aux" "dired-aux.el" "d6a694b6d13fa948465fde52a9ffb3ba")
+;;;;;;  dired-diff) "dired-aux" "dired-aux.el" "8f5af3aa4eee1b3448525896fa6f39a3")
 ;;; Generated autoloads from dired-aux.el
 
 (autoload 'dired-diff "dired-aux" "\
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index 5e20bba2ddb..c910acdbc14 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -289,10 +289,11 @@ Elements of the list may be:
   obsolete    obsolete variables and functions.
   noruntime   functions that may not be defined at runtime (typically
               defined only under `eval-when-compile').
-  cl-functions    calls to runtime functions from the CL package (as
-                  distinguished from macros and aliases).
+  cl-functions    calls to runtime functions (as distinguished from macros and
+                  aliases) from the old CL package (not the newer cl-lib).
   interactive-only
               commands that normally shouldn't be called from Lisp code.
+  lexical     global/dynamic variables lacking a prefix.
   make-local  calls to make-variable-buffer-local that may be incorrect.
   mapcar      mapcar called for effect.
   constants   let-binding of, or assignment to, constants/nonvariables.
diff --git a/lisp/eshell/em-unix.el b/lisp/eshell/em-unix.el
index 60caf38710a..af54d875cb0 100644
--- a/lisp/eshell/em-unix.el
+++ b/lisp/eshell/em-unix.el
@@ -532,8 +532,10 @@ Rename SOURCE to DEST, or move SOURCE(s) to DIRECTORY.
          "don't change anything on disk")
      (?p "preserve" nil preserve
          "preserve file attributes if possible")
-     (?R "recursive" nil em-recursive
+     (?r "recursive" nil em-recursive
          "copy directories recursively")
+     (?R nil nil em-recursive
+         "as for -r")
      (?v "verbose" nil em-verbose
          "explain what is being done")
      (nil "help" nil nil "show this usage screen")
diff --git a/lisp/info.el b/lisp/info.el
index b4673731383..9dc312fc697 100644
--- a/lisp/info.el
+++ b/lisp/info.el
@@ -1931,7 +1931,8 @@ If DIRECTION is `backward', search in the reverse direction."
                               (point-max)))
           (while (and (not give-up)
                       (or (null found)
-                          (not (funcall isearch-filter-predicate beg-found found))))
+                          (not (run-hook-with-args-until-failure
+                                'isearch-filter-predicates beg-found found))))
             (let ((search-spaces-regexp Info-search-whitespace-regexp))
               (if (if backward
                       (re-search-backward regexp bound t)
@@ -2009,7 +2010,8 @@ If DIRECTION is `backward', search in the reverse direction."
                 (setq give-up nil found nil)
                 (while (and (not give-up)
                             (or (null found)
-                                (not (funcall isearch-filter-predicate beg-found found))))
+                                (not (run-hook-with-args-until-failure
+                                      'isearch-filter-predicates beg-found found))))
                   (let ((search-spaces-regexp Info-search-whitespace-regexp))
                     (if (if backward
                             (re-search-backward regexp nil t)
@@ -4275,8 +4277,8 @@ Advanced commands:
        'Info-isearch-wrap)
   (set (make-local-variable 'isearch-push-state-function)
        'Info-isearch-push-state)
-  (set (make-local-variable 'isearch-filter-predicate)
-       'Info-isearch-filter)
+  (set (make-local-variable 'isearch-filter-predicates)
+       '(Info-isearch-filter))
   (set (make-local-variable 'revert-buffer-function)
        'Info-revert-buffer-function)
   (Info-set-mode-line)
diff --git a/lisp/isearch.el b/lisp/isearch.el
index fe73bf7d6a4..5bf2818fadc 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -187,12 +187,21 @@ or to the end of the buffer for a backward search.")
   "Function to save a function restoring the mode-specific Isearch state
 to the search status stack.")
 
-(defvar isearch-filter-predicate 'isearch-filter-visible
-  "Predicate that filters the search hits that would normally be available.
-Search hits that dissatisfy the predicate are skipped.  The function
-has two arguments: the positions of start and end of text matched by
-the search.  If this function returns nil, continue searching without
-stopping at this match.")
+(defvar isearch-filter-predicates nil
+  "Predicates that filter the search hits that would normally be available.
+Search hits that dissatisfy the list of predicates are skipped.
+Each function in this list has two arguments: the positions of
+start and end of text matched by the search.
+The search loop uses `run-hook-with-args-until-failure' to call
+each predicate in order, and when one of the predicates returns nil,
+skips this match and continues searching for the next match.
+When the list of predicates is empty, `run-hook-with-args-until-failure'
+returns non-nil that means that the found match is accepted.
+The property `isearch-message-prefix' put on the predicate's symbol
+specifies the prefix string displyed in the search message.")
+(define-obsolete-variable-alias 'isearch-filter-predicate
+                                'isearch-filter-predicates
+                                "24.4")
 
 ;; Search ring.
 
@@ -2491,6 +2500,13 @@ If there is no completion possible, say so and continue searching."
                               (< (point) isearch-opoint)))
                        "over")
                    (if isearch-wrapped "wrapped ")
+                   (mapconcat (lambda (s)
+                                (and (symbolp s)
+                                     (get s 'isearch-message-prefix)))
+                              (if (consp isearch-filter-predicates)
+                                  isearch-filter-predicates
+                                (list isearch-filter-predicates))
+                              "")
                    (if isearch-word
                        (or (and (symbolp isearch-word)
                                 (get isearch-word 'isearch-message-prefix))
@@ -2622,10 +2638,7 @@ update the match data, and return point."
       (setq isearch-case-fold-search
             (isearch-no-upper-case-p isearch-string isearch-regexp)))
   (condition-case lossage
-      (let ((inhibit-point-motion-hooks
-             ;; FIXME: equality comparisons on functions is asking for trouble.
-             (and (eq isearch-filter-predicate 'isearch-filter-visible)
-                  search-invisible))
+      (let ((inhibit-point-motion-hooks search-invisible)
             (inhibit-quit nil)
             (case-fold-search isearch-case-fold-search)
             (retry t))
@@ -2638,8 +2651,15 @@ update the match data, and return point."
           (if (or (not isearch-success)
                   (bobp) (eobp)
                   (= (match-beginning 0) (match-end 0))
-                  (funcall isearch-filter-predicate
-                           (match-beginning 0) (match-end 0)))
+                  ;; When one of filter predicates returns nil,
+                  ;; retry the search.  Otherwise, act according
+                  ;; to search-invisible (open overlays, etc.)
+                  (and (run-hook-with-args-until-failure
+                        'isearch-filter-predicates
+                        (match-beginning 0) (match-end 0))
+                       (or (eq search-invisible t)
+                           (not (isearch-range-invisible
+                                 (match-beginning 0) (match-end 0))))))
               (setq retry nil)))
         (setq isearch-just-started nil)
         (if isearch-success
@@ -2816,6 +2836,7 @@ determined by `isearch-range-invisible' unless invisible text can be
 searched too when `search-invisible' is t."
   (or (eq search-invisible t)
       (not (isearch-range-invisible beg end))))
+(make-obsolete 'isearch-filter-visible 'search-invisible "24.4")
 
 
 ;; General utilities
@@ -3041,8 +3062,11 @@ Attempt to do the search exactly the way the pending Isearch would."
           (if (or (not success)
                   (= (point) bound) ; like (bobp) (eobp) in `isearch-search'.
                   (= (match-beginning 0) (match-end 0))
-                  (funcall isearch-filter-predicate
-                           (match-beginning 0) (match-end 0)))
+                  (and (run-hook-with-args-until-failure
+                        'isearch-filter-predicates
+                        (match-beginning 0) (match-end 0))
+                       (not (isearch-range-invisible
+                             (match-beginning 0) (match-end 0)))))
               (setq retry nil)))
         success)
     (error nil)))
diff --git a/lisp/net/dbus.el b/lisp/net/dbus.el
index 94a906122fe..0e9c4fc5c76 100644
--- a/lisp/net/dbus.el
+++ b/lisp/net/dbus.el
@@ -268,6 +268,8 @@ object is returned instead of a list containing this single Lisp object.
     ;; Wait until `dbus-call-method-handler' has put the result into
     ;; `dbus-return-values-table'.  If no timeout is given, use the
     ;; default 25".  Events which are not from D-Bus must be restored.
+    ;; `read-event' performs a redisplay.  This must be suppressed; it
+    ;; hurts when reading D-Bus events asynchronously.
     (with-timeout ((if timeout (/ timeout 1000.0) 25))
       (while (eq (gethash key dbus-return-values-table :ignore) :ignore)
         (let ((event (let ((inhibit-redisplay t) unread-command-events)
diff --git a/lisp/obsolete/fast-lock.el b/lisp/obsolete/fast-lock.el
index 941ba3b4902..98f9b836a3b 100644
--- a/lisp/obsolete/fast-lock.el
+++ b/lisp/obsolete/fast-lock.el
@@ -855,3 +855,7 @@ See `fast-lock-get-face-properties'."
 (provide 'fast-lock)
 
 ;;; fast-lock.el ends here
+
+;; Local Variables:
+;; byte-compile-warnings: (not obsolete)
+;; End:
diff --git a/lisp/obsolete/vc-mcvs.el b/lisp/obsolete/vc-mcvs.el
index dd597be32b1..9f9bd7a0e76 100644
--- a/lisp/obsolete/vc-mcvs.el
+++ b/lisp/obsolete/vc-mcvs.el
@@ -189,6 +189,8 @@ This is only meaningful if you don't use the implicit checkout model
 ;;;
 ;;; State-changing functions
 ;;;
+(autoload 'vc-checkout "vc")
+(autoload 'vc-switches "vc")
 
 (defun vc-mcvs-register (files &optional rev comment)
   "Register FILES into the Meta-CVS version-control system.
@@ -345,6 +347,8 @@ This is only possible if Meta-CVS is responsible for FILE's directory.")
 (defun vc-mcvs-rename-file (old new)
   (vc-mcvs-command nil 0 new "move" (file-relative-name old)))
 
+(autoload 'vc-default-revert "vc")
+
 (defun vc-mcvs-revert (file &optional contents-done)
   "Revert FILE to the working revision it was based on."
   (vc-default-revert 'MCVS file contents-done)
@@ -478,6 +482,10 @@ workspace is immediately moved to that new branch)."
     (vc-mcvs-command nil 0 dir "branch" name)
     (vc-mcvs-command nil 0 dir "switch" name)))
 
+;; vc-mcvs-command calls the autoloaded vc-do-command from vc-dispatcher.
+(declare-function vc-resynch-buffer "vc-dispatcher"
+                  (file &optional keep noquery reset-vc-info))
+
 (defun vc-mcvs-retrieve-tag (dir name update)
   "Retrieve a tag at and below DIR.
 NAME is the name of the tag; if it is empty, do a `cvs update'.
diff --git a/lisp/play/dunnet.el b/lisp/play/dunnet.el
index db525fe531f..9d48d36bb30 100644
--- a/lisp/play/dunnet.el
+++ b/lisp/play/dunnet.el
@@ -1,4 +1,4 @@
-;;; dunnet.el --- text adventure for Emacs -*-  byte-compile-warnings: nil -*-
+;;; dunnet.el --- text adventure for Emacs
 
 ;; Copyright (C) 1992-1993, 2001-2013 Free Software Foundation, Inc.
 
@@ -1386,7 +1386,7 @@ for a moment, then straighten yourself up.
 (setq dun-unix-verbs '((ls . dun-ls) (ftp . dun-ftp) (echo . dun-echo)
                        (exit . dun-uexit) (cd . dun-cd) (pwd . dun-pwd)
                        (rlogin . dun-rlogin) (uncompress . dun-uncompress)
-                       (cat . dun-cat) (zippy . dun-zippy)))
+                       (cat . dun-cat)))
 
 (setq dun-dos-verbs '((dir . dun-dos-dir) (type . dun-dos-type)
                       (exit . dun-dos-exit) (command . dun-dos-spawn)
@@ -2996,9 +2996,6 @@ drwxr-xr-x  3 root     staff          2048 Jan 1 1970 ..")
                 (dun-mprincl "Ascii files only.")
               (dun-mprincl "File not found."))))))))
 
-(defun dun-zippy (args)
-  (dun-mprincl (yow)))
-
 (defun dun-rlogin-endgame ()
   (if (not (= (dun-score nil) 90))
       (dun-mprincl
@@ -3356,3 +3353,7 @@ File not found")))
 (provide 'dunnet)
 
 ;;; dunnet.el ends here
+
+;; Local Variables:
+;; byte-compile-warnings: (not free-vars lexical)
+;; End:
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 2c32a7a5607..746b75d962b 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1059,7 +1059,7 @@ Note that the style variables are always made local to the buffer."
   ;; This calls the language variable c-before-font-lock-functions, if non nil.
   ;; This typically sets `syntax-table' properties.
 
-  (c-save-buffer-state ()
+  (c-save-buffer-state (case-fold-search)
     ;; When `combine-after-change-calls' is used we might get calls
     ;; with regions outside the current narrowing.  This has been
     ;; observed in Emacs 20.7.
diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index 66ff217c73e..f830cc7edc1 100644
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -1622,6 +1622,24 @@ names)."))
 )
 (make-variable-buffer-local 'c-macro-with-semi-re)
 
+(defvar c-macro-names-with-semicolon
+  '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE" "Q_ENUMS")
+  "List of #defined symbols whose expansion ends with a semicolon.
+Alternatively it can be a string, a regular expression which
+matches all such symbols.
+
+The \"symbols\" must be syntactically valid identifiers in the
+target language \(C, C++, Objective C), or \(as the case may be)
+the regular expression must match only valid identifiers.
+
+If you change this variable's value, call the function
+`c-make-macros-with-semi-re' to set the necessary internal
+variables.
+
+Note that currently \(2008-11-04) this variable is a prototype,
+and is likely to disappear or change its form soon.")
+(make-variable-buffer-local 'c-macro-names-with-semicolon)
+
 (defun c-make-macro-with-semi-re ()
   ;; Convert `c-macro-names-with-semicolon' into the regexp
   ;; `c-macro-with-semi-re' (or just copy it if it's already a re).
@@ -1643,24 +1661,6 @@ names)."))
 c-macro-names-with-semicolon: %s"
                     c-macro-names-with-semicolon))))))
 
-(defvar c-macro-names-with-semicolon
-  '("Q_OBJECT" "Q_PROPERTY" "Q_DECLARE" "Q_ENUMS")
-  "List of #defined symbols whose expansion ends with a semicolon.
-Alternatively it can be a string, a regular expression which
-matches all such symbols.
-
-The \"symbols\" must be syntactically valid identifiers in the
-target language \(C, C++, Objective C), or \(as the case may be)
-the regular expression must match only valid identifiers.
-
-If you change this variable's value, call the function
-`c-make-macros-with-semi-re' to set the necessary internal
-variables.
-
-Note that currently \(2008-11-04) this variable is a prototype,
-and is likely to disappear or change its form soon.")
-(make-variable-buffer-local 'c-macro-names-with-semicolon)
-
 (defvar c-file-style nil
   "Variable interface for setting style via File Local Variables.
 In a file's Local Variable section, you can set this variable to a
diff --git a/lisp/replace.el b/lisp/replace.el
index 1bebff448fa..86956a614cd 100644
--- a/lisp/replace.el
+++ b/lisp/replace.el
@@ -1838,6 +1838,68 @@ It is used by `query-replace-regexp', `replace-regexp',
 It is called with three arguments, as if it were
 `re-search-forward'.")
 
+(defun replace-search (search-string limit regexp-flag delimited-flag
+                                     case-fold-search)
+  "Search for the next occurence of SEARCH-STRING to replace."
+  ;; Let-bind global isearch-* variables to values used
+  ;; to search the next replacement.  These let-bindings
+  ;; should be effective both at the time of calling
+  ;; `isearch-search-fun-default' and also at the
+  ;; time of funcalling `search-function'.
+  ;; These isearch-* bindings can't be placed higher
+  ;; outside of this function because then another I-search
+  ;; used after `recursive-edit' might override them.
+  (let* ((isearch-regexp regexp-flag)
+         (isearch-word delimited-flag)
+         (isearch-lax-whitespace
+          replace-lax-whitespace)
+         (isearch-regexp-lax-whitespace
+          replace-regexp-lax-whitespace)
+         (isearch-case-fold-search case-fold-search)
+         (isearch-adjusted nil)
+         (isearch-nonincremental t)     ; don't use lax word mode
+         (isearch-forward t)
+         (search-function
+          (or (if regexp-flag
+                  replace-re-search-function
+                replace-search-function)
+              (isearch-search-fun-default))))
+    (funcall search-function search-string limit t)))
+
+(defvar replace-overlay nil)
+
+(defun replace-highlight (match-beg match-end range-beg range-end
+                          search-string regexp-flag delimited-flag
+                          case-fold-search)
+  (if query-replace-highlight
+      (if replace-overlay
+          (move-overlay replace-overlay match-beg match-end (current-buffer))
+        (setq replace-overlay (make-overlay match-beg match-end))
+        (overlay-put replace-overlay 'priority 1001) ;higher than lazy overlays
+        (overlay-put replace-overlay 'face 'query-replace)))
+  (if query-replace-lazy-highlight
+      (let ((isearch-string search-string)
+            (isearch-regexp regexp-flag)
+            (isearch-word delimited-flag)
+            (isearch-lax-whitespace
+             replace-lax-whitespace)
+            (isearch-regexp-lax-whitespace
+             replace-regexp-lax-whitespace)
+            (isearch-case-fold-search case-fold-search)
+            (isearch-forward t)
+            (isearch-other-end match-beg)
+            (isearch-error nil))
+        (isearch-lazy-highlight-new-loop range-beg range-end))))
+
+(defun replace-dehighlight ()
+  (when replace-overlay
+    (delete-overlay replace-overlay))
+  (when query-replace-lazy-highlight
+    (lazy-highlight-cleanup lazy-highlight-cleanup)
+    (setq isearch-lazy-highlight-last-string nil))
+  ;; Close overlays opened by `isearch-range-invisible' in `perform-replace'.
+  (isearch-clean-overlays))
+
 (defun perform-replace (from-string replacements
                         query-flag regexp-flag delimited-flag
                         &optional repeat-count map start end)
@@ -1925,62 +1987,40 @@ make, or the user didn't cancel the call."
         ;; Loop finding occurrences that perhaps should be replaced.
         (while (and keep-going
                     (not (or (eobp) (and limit (>= (point) limit))))
-                    ;; Let-bind global isearch-* variables to values used
-                    ;; to search the next replacement.  These let-bindings
-                    ;; should be effective both at the time of calling
-                    ;; `isearch-search-fun-default' and also at the
-                    ;; time of funcalling `search-function'.
-                    ;; These isearch-* bindings can't be placed higher
-                    ;; outside of this loop because then another I-search
-                    ;; used after `recursive-edit' might override them.
-                    (let* ((isearch-regexp regexp-flag)
-                           (isearch-word delimited-flag)
-                           (isearch-lax-whitespace
-                            replace-lax-whitespace)
-                           (isearch-regexp-lax-whitespace
-                            replace-regexp-lax-whitespace)
-                           (isearch-case-fold-search case-fold-search)
-                           (isearch-adjusted nil)
-                           (isearch-nonincremental t) ; don't use lax word mode
-                           (isearch-forward t)
-                           (search-function
-                            (or (if regexp-flag
-                                    replace-re-search-function
-                                  replace-search-function)
-                                (isearch-search-fun-default))))
-                      ;; Use the next match if it is already known;
-                      ;; otherwise, search for a match after moving forward
-                      ;; one char if progress is required.
-                      (setq real-match-data
-                            (cond ((consp match-again)
-                                   (goto-char (nth 1 match-again))
-                                   (replace-match-data
-                                    t real-match-data match-again))
-                                  ;; MATCH-AGAIN non-nil means accept an
-                                  ;; adjacent match.
-                                  (match-again
-                                   (and
-                                    (funcall search-function search-string
-                                             limit t)
-                                    ;; For speed, use only integers and
-                                    ;; reuse the list used last time.
-                                    (replace-match-data t real-match-data)))
-                                  ((and (< (1+ (point)) (point-max))
-                                        (or (null limit)
-                                            (< (1+ (point)) limit)))
-                                   ;; If not accepting adjacent matches,
-                                   ;; move one char to the right before
-                                   ;; searching again.  Undo the motion
-                                   ;; if the search fails.
-                                   (let ((opoint (point)))
-                                     (forward-char 1)
-                                     (if (funcall
-                                          search-function search-string
-                                          limit t)
-                                         (replace-match-data
-                                          t real-match-data)
-                                       (goto-char opoint)
-                                       nil)))))))
+                    ;; Use the next match if it is already known;
+                    ;; otherwise, search for a match after moving forward
+                    ;; one char if progress is required.
+                    (setq real-match-data
+                          (cond ((consp match-again)
+                                 (goto-char (nth 1 match-again))
+                                 (replace-match-data
+                                  t real-match-data match-again))
+                                ;; MATCH-AGAIN non-nil means accept an
+                                ;; adjacent match.
+                                (match-again
+                                 (and
+                                  (replace-search search-string limit
+                                                  regexp-flag delimited-flag
+                                                  case-fold-search)
+                                  ;; For speed, use only integers and
+                                  ;; reuse the list used last time.
+                                  (replace-match-data t real-match-data)))
+                                ((and (< (1+ (point)) (point-max))
+                                      (or (null limit)
+                                          (< (1+ (point)) limit)))
+                                 ;; If not accepting adjacent matches,
+                                 ;; move one char to the right before
+                                 ;; searching again.  Undo the motion
+                                 ;; if the search fails.
+                                 (let ((opoint (point)))
+                                   (forward-char 1)
+                                   (if (replace-search search-string limit
+                                                       regexp-flag delimited-flag
+                                                       case-fold-search)
+                                       (replace-match-data
+                                        t real-match-data)
+                                     (goto-char opoint)
+                                     nil))))))
 
           ;; Record whether the match is nonempty, to avoid an infinite loop
           ;; repeatedly matching the same empty string.
@@ -2003,10 +2043,18 @@ make, or the user didn't cancel the call."
                                      match))))))
 
           ;; Optionally ignore matches that have a read-only property.
-          (unless (and query-replace-skip-read-only
-                       (text-property-not-all
-                        (nth 0 real-match-data) (nth 1 real-match-data)
-                        'read-only nil))
+          (when (and (or (not query-replace-skip-read-only)
+                         (not (text-property-not-all
+                               (nth 0 real-match-data) (nth 1 real-match-data)
+                               'read-only nil)))
+                     ;; Optionally filter out matches.
+                     (run-hook-with-args-until-failure
+                      'isearch-filter-predicates
+                      (nth 0 real-match-data) (nth 1 real-match-data))
+                     ;; Optionally ignore invisible matches.
+                     (or (eq search-invisible t)
+                         (not (isearch-range-invisible
+                               (nth 0 real-match-data) (nth 1 real-match-data)))))
 
             ;; Calculate the replacement string, if necessary.
             (when replacements
@@ -2221,36 +2269,4 @@ make, or the user didn't cancel the call."
                  (if (= replace-count 1) "" "s")))
     (or (and keep-going stack) multi-buffer)))
 
-(defvar replace-overlay nil)
-
-(defun replace-highlight (match-beg match-end range-beg range-end
-                          search-string regexp-flag delimited-flag
-                          case-fold-search)
-  (if query-replace-highlight
-      (if replace-overlay
-          (move-overlay replace-overlay match-beg match-end (current-buffer))
-        (setq replace-overlay (make-overlay match-beg match-end))
-        (overlay-put replace-overlay 'priority 1001) ;higher than lazy overlays
-        (overlay-put replace-overlay 'face 'query-replace)))
-  (if query-replace-lazy-highlight
-      (let ((isearch-string search-string)
-            (isearch-regexp regexp-flag)
-            (isearch-word delimited-flag)
-            (isearch-lax-whitespace
-             replace-lax-whitespace)
-            (isearch-regexp-lax-whitespace
-             replace-regexp-lax-whitespace)
-            (isearch-case-fold-search case-fold-search)
-            (isearch-forward t)
-            (isearch-other-end match-beg)
-            (isearch-error nil))
-        (isearch-lazy-highlight-new-loop range-beg range-end))))
-
-(defun replace-dehighlight ()
-  (when replace-overlay
-    (delete-overlay replace-overlay))
-  (when query-replace-lazy-highlight
-    (lazy-highlight-cleanup lazy-highlight-cleanup)
-    (setq isearch-lazy-highlight-last-string nil)))
-
 ;;; replace.el ends here
diff --git a/lisp/vc/vc-arch.el b/lisp/vc/vc-arch.el
index 52609457ebc..f94e19271ee 100644
--- a/lisp/vc/vc-arch.el
+++ b/lisp/vc/vc-arch.el
@@ -311,6 +311,9 @@ Only the value `maybe' can be trusted :-(."
                     'up-to-date
                   'edited)))))))))
 
+;; -dir-status called from vc-dir, which loads vc, which loads vc-dispatcher.
+(declare-function vc-exec-after "vc-dispatcher" (code))
+
 (defun vc-arch-dir-status (dir callback)
   "Run 'tla inventory' for DIR and pass results to CALLBACK.
 CALLBACK expects (ENTRIES &optional MORE-TO-COME); see
@@ -432,6 +435,8 @@ CALLBACK expects (ENTRIES &optional MORE-TO-COME); see
         (message "There are unresolved conflicts in %s"
                  (file-name-nondirectory rej))))))
 
+(autoload 'vc-switches "vc")
+
 (defun vc-arch-checkin (files rev comment)
   (if rev (error "Committing to a specific revision is unsupported"))
   ;; FIXME: This implementation probably only works for singleton filesets
diff --git a/lisp/vc/vc-bzr.el b/lisp/vc/vc-bzr.el
index 4a08403c93e..5e76d8464a5 100644
--- a/lisp/vc/vc-bzr.el
+++ b/lisp/vc/vc-bzr.el
@@ -47,8 +47,7 @@
 
 (eval-when-compile
   (require 'cl-lib)
-  (require 'vc)  ;; for vc-exec-after
-  (require 'vc-dir))
+  (require 'vc-dir))                    ; vc-dir-at-event
 
 ;; Clear up the cache to force vc-call to check again and discover
 ;; new functions when we reload this file.
@@ -320,6 +319,12 @@ in the repository root directory of FILE."
     ("^Using saved parent location: \\(.+\\)" 1 nil nil 0))
   "Value of `compilation-error-regexp-alist' in *vc-bzr* buffers.")
 
+;; Follows vc-bzr-(async-)command, which uses vc-do-(async-)command
+;; from vc-dispatcher.
+(declare-function vc-exec-after "vc-dispatcher" (code))
+;; Follows vc-exec-after.
+(declare-function vc-set-async-update "vc-dispatcher" (process-buffer))
+
 (defun vc-bzr-pull (prompt)
   "Pull changes into the current Bzr branch.
 Normally, this runs \"bzr pull\".  However, if the branch is a
@@ -693,6 +698,8 @@ REV non-nil gets an error."
                     (2 'change-log-email))
                    ("^ *timestamp: \\(.*\\)" (1 'change-log-date-face)))))))
 
+(autoload 'vc-setup-buffer "vc-dispatcher")
+
 (defun vc-bzr-print-log (files buffer &optional shortlog start-revision limit)
   "Print commit log associated with FILES into specified BUFFER.
 If SHORTLOG is non-nil, use --line format.
@@ -778,6 +785,8 @@ If LIMIT is non-nil, show no more than this many entries."
         (goto-char (point-min)))
       found)))
 
+(autoload 'vc-switches "vc")
+
 (defun vc-bzr-diff (files &optional rev1 rev2 buffer)
   "VC bzr backend for diff."
   (let* ((switches (vc-switches 'bzr 'diff))
@@ -898,6 +907,8 @@ stream.  Standard error output is discarded."
             (:conc-name vc-bzr-extra-fileinfo->))
   extra-name)         ;; original name for rename targets, new name for
 
+(declare-function vc-default-dir-printer "vc-dir" (backend fileentry))
+
 (defun vc-bzr-dir-printer (info)
   "Pretty-printer for the vc-dir-fileinfo structure."
   (let ((extra (vc-dir-fileinfo->extra info)))
@@ -1110,6 +1121,10 @@ stream.  Standard error output is discarded."
                      'help-echo shelve-help-echo
                      'face 'font-lock-variable-name-face))))))
 
+;; Follows vc-bzr-command, which uses vc-do-command from vc-dispatcher.
+(declare-function vc-resynch-buffer "vc-dispatcher"
+                  (file &optional keep noquery reset-vc-info))
+
 (defun vc-bzr-shelve (name)
   "Create a shelve."
   (interactive "sShelf name: ")
@@ -1169,6 +1184,9 @@ stream.  Standard error output is discarded."
         (match-string 1)
       (error "Cannot find shelf at point"))))
 
+;; vc-bzr-shelve-delete-at-point must be called from a vc-dir buffer.
+(declare-function vc-dir-refresh "vc-dir" ())
+
 (defun vc-bzr-shelve-delete-at-point ()
   (interactive)
   (let ((shelve (vc-bzr-shelve-get-at-point (point))))
diff --git a/lisp/vc/vc-cvs.el b/lisp/vc/vc-cvs.el
index 7a8f8107509..eee896056c6 100644
--- a/lisp/vc/vc-cvs.el
+++ b/lisp/vc/vc-cvs.el
@@ -280,6 +280,8 @@ committed and support display of sticky tags."
 ;;; State-changing functions
 ;;;
 
+(autoload 'vc-switches "vc")
+
 (defun vc-cvs-register (files &optional _rev comment)
   "Register FILES into the CVS version-control system.
 COMMENT can be used to provide an initial description of FILES.
@@ -415,6 +417,8 @@ REV is the revision to check out."
 (defun vc-cvs-delete-file (file)
   (vc-cvs-command nil 0 file "remove" "-f"))
 
+(autoload 'vc-default-revert "vc")
+
 (defun vc-cvs-revert (file &optional contents-done)
   "Revert FILE to the working revision on which it was based."
   (vc-default-revert 'CVS file contents-done)
@@ -501,6 +505,8 @@ Will fail unless you have administrative privileges on the repo."
 ;;;
 
 (declare-function vc-rcs-print-log-cleanup "vc-rcs" ())
+;; Follows vc-cvs-command, which uses vc-do-command from vc-dispatcher.
+(declare-function vc-exec-after "vc-dispatcher" (code))
 
 (defun vc-cvs-print-log (files buffer &optional _shortlog _start-revision limit)
   "Print commit log associated with FILES into specified BUFFER.
@@ -519,6 +525,9 @@ Remaining arguments are ignored."
   "Get comment history of a file."
   (vc-call-backend 'RCS 'comment-history file))
 
+(autoload 'vc-version-backup-file "vc")
+(declare-function vc-coding-system-for-diff "vc" (file))
+
 (defun vc-cvs-diff (files &optional oldvers newvers buffer)
   "Get a difference report using CVS between two revisions of FILE."
   (let* (process-file-side-effects
@@ -665,6 +674,10 @@ workspace is immediately moved to that new branch)."
   (vc-cvs-command nil 0 dir "tag" "-c" (if branchp "-b") name)
   (when branchp (vc-cvs-command nil 0 dir "update" "-r" name)))
 
+;; Follows vc-cvs-command, which uses vc-do-command from vc-dispatcher.
+(declare-function vc-resynch-buffer "vc-dispatcher"
+                  (file &optional keep noquery reset-vc-info))
+
 (defun vc-cvs-retrieve-tag (dir name update)
   "Retrieve a tag at and below DIR.
 NAME is the name of the tag; if it is empty, do a `cvs update'.
diff --git a/lisp/vc/vc-dir.el b/lisp/vc/vc-dir.el
index d10e3934680..e0bd0a574a5 100644
--- a/lisp/vc/vc-dir.el
+++ b/lisp/vc/vc-dir.el
@@ -1301,6 +1301,8 @@ These are the commands available for use in the file status buffer:
   "Auxiliary information to be saved in desktop file."
   (cons (desktop-file-name default-directory dirname) vc-dir-backend))
 
+(defvar desktop-missing-file-warning)
+
 (defun vc-dir-restore-desktop-buffer (_filename _buffername misc-data)
   "Restore a `vc-dir' buffer specified in a desktop file."
   (let ((dir (car misc-data))
diff --git a/lisp/vc/vc-git.el b/lisp/vc/vc-git.el
index 06474cb4604..af5be361047 100644
--- a/lisp/vc/vc-git.el
+++ b/lisp/vc/vc-git.el
@@ -234,30 +234,30 @@ matching the resulting Git log output, and KEYWORDS is a list of
             (vc-git--state-code diff-letter)))
       (if (vc-git--empty-db-p) 'added 'up-to-date))))
 
-(defun vc-git-working-revision (_file)
+(defun vc-git-working-revision (file)
   "Git-specific version of `vc-working-revision'."
   (let* (process-file-side-effects
-         (str (with-output-to-string
-                (with-current-buffer standard-output
-                  (vc-git--out-ok "symbolic-ref" "HEAD")))))
-    (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str)
-        (match-string 2 str)
-      str)))
+         (str (vc-git--run-command-string nil "symbolic-ref" "HEAD")))
+    (vc-file-setprop file 'vc-git-detached (null str))
+    (if str
+        (if (string-match "^\\(refs/heads/\\)?\\(.+\\)$" str)
+            (match-string 2 str)
+          str)
+      (vc-git--rev-parse "HEAD"))))
 
 (defun vc-git-workfile-unchanged-p (file)
   (eq 'up-to-date (vc-git-state file)))
 
 (defun vc-git-mode-line-string (file)
   "Return a string for `vc-mode-line' to put in the mode line for FILE."
-  (let* ((branch (vc-working-revision file))
+  (let* ((rev (vc-working-revision file))
+         (detached (vc-file-getprop file 'vc-git-detached))
          (def-ml (vc-default-mode-line-string 'Git file))
          (help-echo (get-text-property 0 'help-echo def-ml)))
-    (if (zerop (length branch))
-        (propertize
-         (concat def-ml "!")
-         'help-echo (concat help-echo "\nNo current branch (detached HEAD)"))
-      (propertize def-ml
-                  'help-echo (concat help-echo "\nCurrent branch: " branch)))))
+    (propertize (if detached
+                    (substring def-ml 0 (- 7 (length rev)))
+                  def-ml)
+                'help-echo (concat help-echo "\nCurrent revision: " rev))))
 
 (cl-defstruct (vc-git-extra-fileinfo
             (:copier nil)
@@ -443,6 +443,12 @@ or an empty string if none."
     (when next-stage
       (vc-git-dir-status-goto-stage next-stage files update-function))))
 
+;; Follows vc-git-command (or vc-do-async-command), which uses vc-do-command
+;; from vc-dispatcher.
+(declare-function vc-exec-after "vc-dispatcher" (code))
+;; Follows vc-exec-after.
+(declare-function vc-set-async-update "vc-dispatcher" (process-buffer))
+
 (defun vc-git-dir-status-goto-stage (stage files update-function)
   (erase-buffer)
   (pcase stage
@@ -731,6 +737,8 @@ This prompts for a branch to merge from."
 
 ;;; HISTORY FUNCTIONS
 
+(autoload 'vc-setup-buffer "vc-dispatcher")
+
 (defun vc-git-print-log (files buffer &optional shortlog start-revision limit)
   "Print commit log associated with FILES into specified BUFFER.
 If SHORTLOG is non-nil, use a short format based on `vc-git-root-log-format'.
@@ -857,6 +865,8 @@ or BRANCH^ (where \"^\" can be repeated)."
       (indent-region (point-min) (point-max) 2)
       (buffer-string))))
 
+(autoload 'vc-switches "vc")
+
 (defun vc-git-diff (files &optional rev1 rev2 buffer)
   "Get a difference report using Git between two revisions of FILES."
   (let (process-file-side-effects)
@@ -943,10 +953,13 @@ or BRANCH^ (where \"^\" can be repeated)."
                            (point)
                            (1- (point-max)))))))
         (or (vc-git-symbolic-commit prev-rev) prev-rev))
-    (with-temp-buffer
-      (and
-       (vc-git--out-ok "rev-parse" (concat rev "^"))
-       (buffer-substring-no-properties (point-min) (+ (point-min) 40))))))
+    (vc-git--rev-parse (concat rev "^"))))
+
+(defun vc-git--rev-parse (rev)
+  (with-temp-buffer
+    (and
+     (vc-git--out-ok "rev-parse" rev)
+     (buffer-substring-no-properties (point-min) (+ (point-min) 40)))))
 
 (defun vc-git-next-revision (file rev)
   "Git-specific version of `vc-next-revision'."
@@ -1007,6 +1020,12 @@ or BRANCH^ (where \"^\" can be repeated)."
   (or (vc-file-getprop file 'git-root)
       (vc-file-setprop file 'git-root (vc-find-root file ".git"))))
 
+;; grep-compute-defaults autoloads grep.
+(declare-function grep-read-regexp "grep" ())
+(declare-function grep-read-files "grep" (regexp))
+(declare-function grep-expand-template "grep"
+                 (template &optional regexp files dir excl))
+
 ;; Derived from `lgrep'.
 (defun vc-git-grep (regexp &optional files dir)
   "Run git grep, searching for REGEXP in FILES in directory DIR.
@@ -1062,6 +1081,10 @@ This command shares argument histories with \\[rgrep] and \\[grep]."
         (if (eq next-error-last-buffer (current-buffer))
             (setq default-directory dir))))))
 
+;; Everywhere but here, follows vc-git-command, which uses vc-do-command
+;; from vc-dispatcher.
+(autoload 'vc-resynch-buffer "vc-dispatcher")
+
 (defun vc-git-stash (name)
   "Create a stash."
   (interactive "sStash name: ")
@@ -1119,6 +1142,9 @@ This command shares argument histories with \\[rgrep] and \\[grep]."
         (match-string 1)
       (error "Cannot find stash at point"))))
 
+;; vc-git-stash-delete-at-point must be called from a vc-dir buffer.
+(declare-function vc-dir-refresh "vc-dir" ())
+
 (defun vc-git-stash-delete-at-point ()
   (interactive)
   (let ((stash (vc-git-stash-get-at-point (point))))
diff --git a/lisp/vc/vc-hg.el b/lisp/vc/vc-hg.el
index feec015e52a..a80a103c675 100644
--- a/lisp/vc/vc-hg.el
+++ b/lisp/vc/vc-hg.el
@@ -245,6 +245,8 @@ highlighting the Log View buffer."
                  (repeat :tag "Argument List" :value ("") string))
   :group 'vc-hg)
 
+(autoload 'vc-setup-buffer "vc-dispatcher")
+
 (defun vc-hg-print-log (files buffer &optional shortlog start-revision limit)
   "Print commit log associated with FILES into specified BUFFER.
 If SHORTLOG is non-nil, use a short format based on `vc-hg-root-log-format'.
@@ -306,6 +308,8 @@ If LIMIT is non-nil, show no more than this many entries."
             ("^tag: +\\([^ ]+\\)$" (1 'highlight))
             ("^summary:[ \t]+\\(.+\\)" (1 'log-view-message)))))))
 
+(autoload 'vc-switches "vc")
+
 (defun vc-hg-diff (files &optional oldvers newvers buffer)
   "Get a difference report using hg between two revisions of FILES."
   (let* ((firstfile (car files))
@@ -591,6 +595,12 @@ REV is the revision to check out into WORKFILE."
         (forward-line))
       (funcall update-function result)))
 
+;; Follows vc-hg-command (or vc-do-async-command), which uses vc-do-command
+;; from vc-dispatcher.
+(declare-function vc-exec-after "vc-dispatcher" (code))
+;; Follows vc-exec-after.
+(declare-function vc-set-async-update "vc-dispatcher" (process-buffer))
+
 (defun vc-hg-dir-status (dir update-function)
   (vc-hg-command (current-buffer) 'async dir "status" "-C")
   (vc-exec-after
@@ -651,6 +661,8 @@ REV is the revision to check out into WORKFILE."
   ;;       modified files
   "Value of `compilation-error-regexp-alist' in *vc-hg* buffers.")
 
+(autoload 'vc-do-async-command "vc-dispatcher")
+
 (defun vc-hg-pull (prompt)
   "Issue a Mercurial pull command.
 If called interactively with a set of marked Log View buffers,
diff --git a/lisp/vc/vc-mtn.el b/lisp/vc/vc-mtn.el
index fbfd89561b7..29996fafe92 100644
--- a/lisp/vc/vc-mtn.el
+++ b/lisp/vc/vc-mtn.el
@@ -123,6 +123,9 @@ If nil, use the value of `vc-diff-switches'.  If t, use no switches."
              ((match-end 2) (push (list (match-string 3) 'added) result))))
     (funcall update-function result)))
 
+;; -dir-status called from vc-dir, which loads vc, which loads vc-dispatcher.
+(declare-function vc-exec-after "vc-dispatcher" (code))
+
 (defun vc-mtn-dir-status (dir update-function)
   (vc-mtn-command (current-buffer) 'async dir "status")
   (vc-exec-after
@@ -233,6 +236,8 @@ If LIMIT is non-nil, show no more than this many entries."
 ;; (defun vc-mtn-show-log-entry (revision)
 ;;   )
 
+(autoload 'vc-switches "vc")
+
 (defun vc-mtn-diff (files &optional rev1 rev2 buffer)
   "Get a difference report using monotone between two revisions of FILES."
   (apply 'vc-mtn-command (or buffer "*vc-diff*") 1 files "diff"
diff --git a/lisp/vc/vc-rcs.el b/lisp/vc/vc-rcs.el
index 0a2fc804e6d..e85494b2156 100644
--- a/lisp/vc/vc-rcs.el
+++ b/lisp/vc/vc-rcs.el
@@ -200,6 +200,8 @@ For a description of possible values, see `vc-check-master-templates'."
                    (vc-rcs-state file))))
         (vc-rcs-state file)))))
 
+(autoload 'vc-expand-dirs "vc")
+
 (defun vc-rcs-dir-status (dir update-function)
   ;; FIXME: this function should be rewritten or `vc-expand-dirs'
   ;; should be changed to take a backend parameter.  Using
@@ -270,6 +272,8 @@ When VERSION is given, perform check for that version."
   ;; RCS is totally file-oriented, so all we have to do is make the directory.
   (make-directory "RCS"))
 
+(autoload 'vc-switches "vc")
+
 (defun vc-rcs-register (files &optional rev comment)
   "Register FILES into the RCS version-control system.
 REV is the optional revision number for the files.  COMMENT can be used
@@ -821,6 +825,9 @@ systime, or nil if there is none.  Also, reposition point."
 ;;; Tag system
 ;;;
 
+(autoload 'vc-tag-precondition "vc")
+(declare-function vc-file-tree-walk "vc" (dirname func &rest args))
+
 (defun vc-rcs-create-tag (dir name branchp)
   (when branchp
     (error "RCS backend does not support module branches"))
@@ -892,6 +899,8 @@ and CVS."
           (t "rcs2log")))
   "Path to the `rcs2log' program (normally in `exec-directory').")
 
+(autoload 'vc-buffer-sync "vc-dispatcher")
+
 (defun vc-rcs-update-changelog (files)
   "Default implementation of update-changelog.
 Uses `rcs2log' which only works for RCS and CVS."
@@ -958,6 +967,8 @@ Uses `rcs2log' which only works for RCS and CVS."
             nil t)
       (replace-match "$\\1$"))))
 
+(autoload 'vc-rename-master "vc")
+
 (defun vc-rcs-rename-file (old new)
   ;; Just move the master file (using vc-rcs-master-templates).
   (vc-rename-master (vc-name old) new vc-rcs-master-templates))
diff --git a/lisp/vc/vc-sccs.el b/lisp/vc/vc-sccs.el
index d3cf650ddf9..7bce1ea3ba6 100644
--- a/lisp/vc/vc-sccs.el
+++ b/lisp/vc/vc-sccs.el
@@ -155,6 +155,8 @@ For a description of possible values, see `vc-check-master-templates'."
             (vc-sccs-state file))))
     (vc-sccs-state file)))
 
+(autoload 'vc-expand-dirs "vc")
+
 (defun vc-sccs-dir-status (dir update-function)
   ;; FIXME: this function should be rewritten, using `vc-expand-dirs'
   ;; is not TRTD because it returns files from multiple backends.
@@ -216,6 +218,8 @@ Optional string REV is a revision."
   ;; SCCS is totally file-oriented, so all we have to do is make the directory
   (make-directory "SCCS"))
 
+(autoload 'vc-switches "vc")
+
 (defun vc-sccs-register (files &optional rev comment)
   "Register FILES into the SCCS version-control system.
 REV is the optional revision number for the file.  COMMENT can be used
@@ -356,6 +360,9 @@ Remaining arguments are ignored."
   (vc-sccs-do-command buffer 0 "prs" (mapcar 'vc-name files))
   (when limit 'limit-unsupported))
 
+(autoload 'vc-setup-buffer "vc-dispatcher")
+(autoload 'vc-delistify "vc-dispatcher")
+
 ;; FIXME use sccsdiff if present?
 (defun vc-sccs-diff (files &optional oldvers newvers buffer)
   "Get a difference report using SCCS between two filesets."
@@ -432,6 +439,9 @@ Remaining arguments are ignored."
 ;;; our own set of name-to-revision mappings.
 ;;;
 
+(autoload 'vc-tag-precondition "vc")
+(declare-function vc-file-tree-walk "vc" (dirname func &rest args))
+
 (defun vc-sccs-create-tag (dir name branchp)
   (when branchp
     (error "SCCS backend does not support module branches"))
@@ -460,6 +470,8 @@ Remaining arguments are ignored."
     (goto-char (point-min))
     (re-search-forward  "%[A-Z]%" nil t)))
 
+(autoload 'vc-rename-master "vc")
+
 (defun vc-sccs-rename-file (old new)
   ;; Move the master file (using vc-rcs-master-templates).
   (vc-rename-master (vc-name old) new vc-sccs-master-templates)
diff --git a/lisp/vc/vc-svn.el b/lisp/vc/vc-svn.el
index a94bf0d6117..39b107b81b5 100644
--- a/lisp/vc/vc-svn.el
+++ b/lisp/vc/vc-svn.el
@@ -215,6 +215,9 @@ If you want to force an empty list of arguments, use t."
          (setq result (cons (list filename state) result)))))
     (funcall callback result)))
 
+;; -dir-status called from vc-dir, which loads vc, which loads vc-dispatcher.
+(declare-function vc-exec-after "vc-dispatcher" (code))
+
 (defun vc-svn-dir-status (dir callback)
   "Run 'svn status' for DIR and update BUFFER via CALLBACK.
 CALLBACK is called as (CALLBACK RESULT BUFFER), where
@@ -293,6 +296,8 @@ RESULT is a list of conses (FILE . STATE) for directory DIR."
   (vc-svn-command "*vc*" 0 "." "checkout"
                   (concat "file://" default-directory "SVN")))
 
+(autoload 'vc-switches "vc")
+
 (defun vc-svn-register (files &optional rev comment)
   "Register FILES into the SVN version-control system.
 The COMMENT argument is ignored  This does an add but not a commit.
@@ -493,6 +498,8 @@ or svn+ssh://."
   (require 'add-log)
   (set (make-local-variable 'log-view-per-file-logs) nil))
 
+(autoload 'vc-setup-buffer "vc-dispatcher")
+
 (defun vc-svn-print-log (files buffer &optional shortlog start-revision limit)
   "Print commit log associated with FILES into specified BUFFER.
 SHORTLOG is ignored.
diff --git a/lisp/wdired.el b/lisp/wdired.el
index 47cd99f45ac..55665fbb6a0 100644
--- a/lisp/wdired.el
+++ b/lisp/wdired.el
@@ -239,8 +239,7 @@ See `wdired-mode'."
        (dired-remember-marks (point-min) (point-max)))
   (set (make-local-variable 'wdired-old-point) (point))
   (set (make-local-variable 'query-replace-skip-read-only) t)
-  (set (make-local-variable 'isearch-filter-predicate)
-       'wdired-isearch-filter-read-only)
+  (add-hook 'isearch-filter-predicates 'wdired-isearch-filter-read-only nil t)
   (use-local-map wdired-mode-map)
   (force-mode-line-update)
   (setq buffer-read-only nil)
@@ -268,9 +267,8 @@ or \\[wdired-abort-changes] to abort changes")))
 
 (defun wdired-isearch-filter-read-only (beg end)
   "Skip matches that have a read-only property."
-  (and (isearch-filter-visible beg end)
-       (not (text-property-not-all (min beg end) (max beg end)
-                                   'read-only nil))))
+  (not (text-property-not-all (min beg end) (max beg end)
+                              'read-only nil)))
 
 ;; Protect the buffer so only the filenames can be changed, and put
 ;; properties so filenames (old and new) can be easily found.