14 files changed, 148 insertions, 81 deletions

diff --git a/lisp/cedet/ede/locate.el b/lisp/cedet/ede/locate.el
index 2ff83418f78..a076c46513c 100644
--- a/lisp/cedet/ede/locate.el
+++ b/lisp/cedet/ede/locate.el
@@ -353,7 +353,7 @@ that created this EDE locate object."
 
 (cl-defmethod ede-locate-create/update-root-database
   ((loc (subclass ede-locate-cscope)) root)
-  "Create or update the GNU Global database for the current project."
+  "Create or update the Cscope database for the current project."
   (require 'cedet-cscope)
   (cedet-cscope-create/update-database root))
 
diff --git a/lisp/emacs-lisp/bytecomp.el b/lisp/emacs-lisp/bytecomp.el
index d732c730bff..f0d2ee48ed2 100644
--- a/lisp/emacs-lisp/bytecomp.el
+++ b/lisp/emacs-lisp/bytecomp.el
@@ -979,16 +979,6 @@ Each function's symbol gets added to `byte-compile-noruntime-functions'."
            (lambda (x) (if (symbolp x) (list 'prin1-to-string x) x))
            args))))))
 
-(defvar byte-compile--interactive nil
-  "Determine if `byte-compile--message' uses the minibuffer.")
-
-(defun byte-compile--message (format &rest args)
-  "Like `message', except sometimes don't print to minibuffer.
-If the variable `byte-compile--interactive' is nil, the message
-is not displayed on the minibuffer."
-  (let ((inhibit-message (not byte-compile--interactive)))
-    (apply #'message format args)))
-
 ;; Log something that isn't a warning.
 (defun byte-compile-log-1 (string)
   (with-current-buffer byte-compile-log-buffer
@@ -996,7 +986,7 @@ is not displayed on the minibuffer."
       (goto-char (point-max))
       (byte-compile-warning-prefix nil nil)
       (cond (noninteractive
-             (byte-compile--message " %s" string))
+             (message " %s" string))
             (t
              (insert (format "%s\n" string)))))))
 
@@ -1600,10 +1590,7 @@ extra args."
   "Recompile every `.el' file in DIRECTORY that already has a `.elc' file.
 Files in subdirectories of DIRECTORY are processed also."
   (interactive "DByte force recompile (directory): ")
-  (let ((byte-compile--interactive
-         (or byte-compile--interactive
-             (called-interactively-p 'any))))
-    (byte-recompile-directory directory nil t)))
+  (byte-recompile-directory directory nil t))
 
 ;;;###autoload
 (defun byte-recompile-directory (directory &optional arg force)
@@ -1633,9 +1620,6 @@ that already has a `.elc' file."
       (compilation-mode))
     (let ((directories (list default-directory))
           (default-directory default-directory)
-          (byte-compile--interactive
-           (or byte-compile--interactive
-               (called-interactively-p 'any)))
           (skip-count 0)
           (fail-count 0)
           (file-count 0)
@@ -1644,7 +1628,7 @@ that already has a `.elc' file."
       (displaying-byte-compile-warnings
        (while directories
          (setq directory (car directories))
-         (byte-compile--message "Checking %s..." directory)
+         (message "Checking %s..." directory)
          (dolist (file (directory-files directory))
            (let ((source (expand-file-name file directory)))
              (if (file-directory-p source)
@@ -1669,13 +1653,13 @@ that already has a `.elc' file."
                              (`t file-count)
                              (_ fail-count)))
                           (or noninteractive
-                              (byte-compile--message "Checking %s..." directory))
+                              (message "Checking %s..." directory))
                           (if (not (eq last-dir directory))
                               (setq last-dir directory
                                     dir-count (1+ dir-count)))
                           )))))
          (setq directories (cdr directories))))
-      (byte-compile--message "Done (Total of %d file%s compiled%s%s%s)"
+      (message "Done (Total of %d file%s compiled%s%s%s)"
                file-count (if (= file-count 1) "" "s")
                (if (> fail-count 0) (format ", %d failed" fail-count) "")
                (if (> skip-count 0) (format ", %d skipped" skip-count) "")
@@ -1722,10 +1706,7 @@ If compilation is needed, this functions returns the result of
            current-prefix-arg)))
   (let ((dest (byte-compile-dest-file filename))
         ;; Expand now so we get the current buffer's defaults
-        (filename (expand-file-name filename))
-        (byte-compile--interactive
-         (or byte-compile--interactive
-             (called-interactively-p 'any))))
+        (filename (expand-file-name filename)))
     (if (if (file-exists-p dest)
             ;; File was already compiled
             ;; Compile if forced to, or filename newer
@@ -1737,7 +1718,7 @@ If compilation is needed, this functions returns the result of
                                      filename "? ")))))
         (progn
           (if (and noninteractive (not byte-compile-verbose))
-              (byte-compile--message "Compiling %s..." filename))
+              (message "Compiling %s..." filename))
           (byte-compile-file filename load))
       (when load
         (load (if (file-exists-p dest) dest filename)))
@@ -1781,9 +1762,6 @@ The value is non-nil if there were no errors, nil if errors."
   (let ((byte-compile-current-file filename)
         (byte-compile-current-group nil)
         (set-auto-coding-for-load t)
-        (byte-compile--interactive
-         (or byte-compile--interactive
-             (called-interactively-p 'any)))
         target-file input-buffer output-buffer
         byte-compile-dest-file)
     (setq target-file (byte-compile-dest-file filename))
@@ -1839,14 +1817,14 @@ The value is non-nil if there were no errors, nil if errors."
           ;;       (byte-compile-abbreviate-file filename)
           ;;       (with-current-buffer input-buffer no-byte-compile))
           (when (file-exists-p target-file)
-            (byte-compile--message "%s deleted because of `no-byte-compile: %s'"
+            (message "%s deleted because of `no-byte-compile: %s'"
                      (byte-compile-abbreviate-file target-file)
                      (buffer-local-value 'no-byte-compile input-buffer))
             (condition-case nil (delete-file target-file) (error nil)))
           ;; We successfully didn't compile this file.
           'no-byte-compile)
       (when byte-compile-verbose
-        (byte-compile--message "Compiling %s..." filename))
+        (message "Compiling %s..." filename))
       (setq byte-compiler-error-flag nil)
       ;; It is important that input-buffer not be current at this call,
       ;; so that the value of point set in input-buffer
@@ -1858,7 +1836,7 @@ The value is non-nil if there were no errors, nil if errors."
       (if byte-compiler-error-flag
           nil
         (when byte-compile-verbose
-          (byte-compile--message "Compiling %s...done" filename))
+          (message "Compiling %s...done" filename))
         (kill-buffer input-buffer)
         (with-current-buffer output-buffer
           (goto-char (point-max))
@@ -1884,7 +1862,7 @@ The value is non-nil if there were no errors, nil if errors."
                 ;; recompiled).  Previously this was accomplished by
                 ;; deleting target-file before writing it.
                 (rename-file tempfile target-file t)
-                (or noninteractive (byte-compile--message "Wrote %s" target-file)))
+                (or noninteractive (message "Wrote %s" target-file)))
             ;; This is just to give a better error message than write-region
             (signal 'file-error
                     (list "Opening output file"
@@ -1918,9 +1896,6 @@ With argument ARG, insert value in current buffer after the form."
            (byte-compile-read-position (point))
            (byte-compile-last-position byte-compile-read-position)
            (byte-compile-last-warned-form 'nothing)
-           (byte-compile--interactive
-            (or byte-compile--interactive
-                (called-interactively-p 'any)))
            (value (eval
                    (let ((read-with-symbol-positions (current-buffer))
                          (read-symbol-positions-list nil))
@@ -1928,10 +1903,10 @@ With argument ARG, insert value in current buffer after the form."
                       (byte-compile-sexp (read (current-buffer)))))
                    lexical-binding)))
       (cond (arg
-             (byte-compile--message "Compiling from buffer... done.")
+             (message "Compiling from buffer... done.")
              (prin1 value (current-buffer))
              (insert "\n"))
-            ((byte-compile--message "%s" (prin1-to-string value)))))))
+            ((message "%s" (prin1-to-string value)))))))
 
 (defun byte-compile-from-buffer (inbuffer)
   (let ((byte-compile-current-buffer inbuffer)
@@ -2435,7 +2410,7 @@ not to take responsibility for the actual compilation of the code."
         (byte-compile-arglist-warn name arglist macro))
 
     (if byte-compile-verbose
-        (byte-compile--message "Compiling %s... (%s)"
+        (message "Compiling %s... (%s)"
                  (or byte-compile-current-file "") name))
     (cond ((not (or macro (listp body)))
            ;; We do not know positively if the definition is a macro
@@ -2605,7 +2580,7 @@ If FORM is a lambda or a macro, byte-compile it as a function."
        ;; error to a simple message for the known case where signaling an error
        ;; causes problems.
        ((byte-code-function-p fun)
-        (byte-compile--message "Function %s is already compiled"
+        (message "Function %s is already compiled"
                  (if (symbolp form) form "provided"))
         fun)
        (t
@@ -4423,8 +4398,8 @@ binding slots have been popped."
                   name macro arglist body rest)
            (when macro
              (if (null fun)
-                 (byte-compile--message "Macro %s unrecognized, won't work in file" name)
-               (byte-compile--message "Macro %s partly recognized, trying our luck" name)
+                 (message "Macro %s unrecognized, won't work in file" name)
+               (message "Macro %s partly recognized, trying our luck" name)
                (push (cons name (eval fun))
                      byte-compile-macro-environment)))
            (byte-compile-keep-pending form))))
@@ -4550,11 +4525,11 @@ The call tree also lists those functions which are not known to be called
 \(that is, to which no calls have been compiled\), and which cannot be
 invoked interactively."
   (interactive)
-  (byte-compile--message "Generating call tree...")
+  (message "Generating call tree...")
   (with-output-to-temp-buffer "*Call-Tree*"
     (set-buffer "*Call-Tree*")
     (erase-buffer)
-    (byte-compile--message "Generating call tree... (sorting on %s)"
+    (message "Generating call tree... (sorting on %s)"
              byte-compile-call-tree-sort)
     (insert "Call tree for "
             (cond ((null byte-compile-current-file) (or filename "???"))
diff --git a/lisp/emacs-lisp/eieio-core.el b/lisp/emacs-lisp/eieio-core.el
index 92d7234bc73..bf3f44206c4 100644
--- a/lisp/emacs-lisp/eieio-core.el
+++ b/lisp/emacs-lisp/eieio-core.el
@@ -730,7 +730,7 @@ Argument FN is the function calling this verifier."
   (cl-check-type slot symbol)
   (cl-check-type obj (or eieio-object class))
   (let* ((class (cond ((symbolp obj)
-                       (error "eieio-oref called on a class!")
+                       (error "eieio-oref called on a class: %s" obj)
                        (let ((c (eieio--class-v obj)))
                          (if (eieio--class-p c) (eieio-class-un-autoload obj))
                          c))
diff --git a/lisp/emacs-lisp/ert.el b/lisp/emacs-lisp/ert.el
index 384fef546ae..8dc8261365f 100644
--- a/lisp/emacs-lisp/ert.el
+++ b/lisp/emacs-lisp/ert.el
@@ -269,7 +269,7 @@ DATA is displayed to the user and should state the reason for skipping."
 (defun ert--special-operator-p (thing)
   "Return non-nil if THING is a symbol naming a special operator."
   (and (symbolp thing)
-       (let ((definition (ignore-errors (indirect-function thing))))
+       (let ((definition (indirect-function thing)))
          (and (subrp definition)
               (eql (cdr (subr-arity definition)) 'unevalled)))))
 
diff --git a/lisp/emacs-lisp/pcase.el b/lisp/emacs-lisp/pcase.el
index 978c3f0dd30..5a81bb20e57 100644
--- a/lisp/emacs-lisp/pcase.el
+++ b/lisp/emacs-lisp/pcase.el
@@ -91,6 +91,10 @@
 
 (def-edebug-spec pcase-MACRO pcase--edebug-match-macro)
 
+;; Only called from edebug.
+(declare-function get-edebug-spec "edebug" (symbol))
+(declare-function edebug-match "edebug" (cursor specs))
+
 (defun pcase--edebug-match-macro (cursor)
   (let (specs)
     (mapatoms
@@ -158,12 +162,18 @@ Currently, the following patterns are provided this way:"
         ;; (puthash (car cases) `(,exp ,cases ,@expansion) pcase--memoize-2)
         expansion))))
 
+(declare-function help-fns--signature "help-fns"
+                  (function doc real-def real-function))
+
 ;; FIXME: Obviously, this will collide with nadvice's use of
 ;; function-documentation if we happen to advise `pcase'.
 (put 'pcase 'function-documentation '(pcase--make-docstring))
 (defun pcase--make-docstring ()
   (let* ((main (documentation (symbol-function 'pcase) 'raw))
          (ud (help-split-fundoc main 'pcase)))
+    ;; So that eg emacs -Q -l cl-lib --eval "(documentation 'pcase)" works,
+    ;; where cl-lib is anything using pcase-defmacro.
+    (require 'help-fns)
     (with-temp-buffer
       (insert (or (cdr ud) main))
       (mapatoms
diff --git a/lisp/emacs-lisp/seq.el b/lisp/emacs-lisp/seq.el
index 2f3f519e986..456debf5f7c 100644
--- a/lisp/emacs-lisp/seq.el
+++ b/lisp/emacs-lisp/seq.el
@@ -344,6 +344,7 @@ This is an optimization for lists in `seq-take-while'."
 (defalias 'seq-do #'mapc)
 (defalias 'seq-each #'seq-do)
 (defalias 'seq-map #'mapcar)
+(defalias 'seq-p #'sequencep)
 
 (unless (fboundp 'elisp--font-lock-flush-elisp-buffers)
   ;; In Emacs≥25, (via elisp--font-lock-flush-elisp-buffers and a few others)
diff --git a/lisp/files.el b/lisp/files.el
index 045eeaf154c..ef6ac7b8c92 100644
--- a/lisp/files.el
+++ b/lisp/files.el
@@ -654,10 +654,14 @@ the value of `default-directory'."
                   'file-directory-p))
 
 
-(defun pwd ()
-  "Show the current default directory."
-  (interactive nil)
-  (message "Directory %s" default-directory))
+(defun pwd (&optional insert)
+  "Show the current default directory.
+With prefix argument INSERT, insert the current default directory
+at point instead."
+  (interactive "P")
+  (if insert
+      (insert default-directory)
+    (message "Directory %s" default-directory)))
 
 (defvar cd-path nil
   "Value of the CDPATH environment variable, as a list.
diff --git a/lisp/isearch.el b/lisp/isearch.el
index c714ba0055d..dc10502309f 100644
--- a/lisp/isearch.el
+++ b/lisp/isearch.el
@@ -452,7 +452,7 @@ This is like `describe-bindings', but displays only Isearch keys."
     (define-key map "\M-\C-s" 'isearch-repeat-forward)
     (define-key map "\M-\C-r" 'isearch-repeat-backward)
     (define-key map "\177" 'isearch-delete-char)
-    (define-key map [backspace] 'isearch-delete-char)
+    (define-key map [backspace] 'undefined) ;bug#20466.
     (define-key map "\C-g" 'isearch-abort)
 
     ;; This assumes \e is the meta-prefix-char.
diff --git a/lisp/progmodes/cmacexp.el b/lisp/progmodes/cmacexp.el
index 357625d10cf..19d0473c42d 100644
--- a/lisp/progmodes/cmacexp.el
+++ b/lisp/progmodes/cmacexp.el
@@ -364,8 +364,8 @@ Optional arg DISPLAY non-nil means show messages in the echo area."
             ;; Find and delete the mark of the start of the expansion.
             ;; Look for `# nn "file.c"' lines and delete them.
             (goto-char (point-min))
-            (search-forward startmarker)
-            (delete-region 1 (point)))
+            (if (search-forward startmarker nil t)
+                (delete-region 1 (point))))
           (while (re-search-forward (concat "^# [0-9]+ \""
                                             (regexp-quote filename)
                                             "\"") nil t)
diff --git a/lisp/progmodes/elisp-mode.el b/lisp/progmodes/elisp-mode.el
index f2890686e79..2bb661a59c8 100644
--- a/lisp/progmodes/elisp-mode.el
+++ b/lisp/progmodes/elisp-mode.el
@@ -587,6 +587,8 @@ It can be quoted, or be inside a quoted form."
       (let ((sym (intern-soft id)))
         (when sym
           (elisp--xref-find-definitions sym))))
+    (`references
+     (elisp--xref-find-references id))
     (`apropos
      (elisp--xref-find-apropos id))))
 
@@ -635,6 +637,25 @@ It can be quoted, or be inside a quoted form."
              lst))))
       lst)))
 
+(defun elisp--xref-find-references (symbol)
+  (let* ((dirs (sort
+                (mapcar
+                 (lambda (dir)
+                   (file-name-as-directory (expand-file-name dir)))
+                 (cons package-user-dir load-path))
+                #'string<))
+         (ref dirs))
+    ;; Delete subdirectories from the list.
+    (while (cdr ref)
+      (if (string-prefix-p (car ref) (cadr ref))
+          (setcdr ref (cddr ref))
+        (setq ref (cdr ref))))
+    (cl-mapcan
+     (lambda (dir)
+       (and (file-exists-p dir)
+            (xref-collect-references symbol dir)))
+     dirs)))
+
 (defun elisp--xref-find-apropos (regexp)
   (apply #'nconc
          (let (lst)
diff --git a/lisp/progmodes/etags.el b/lisp/progmodes/etags.el
index b4ce8b11c9c..4e923aac197 100644
--- a/lisp/progmodes/etags.el
+++ b/lisp/progmodes/etags.el
@@ -2082,6 +2082,15 @@ for \\[find-tag] (which see)."
 (defun etags-xref-find (action id)
   (pcase action
     (`definitions (etags--xref-find-definitions id))
+    (`references
+     (let ((dirs (if tags-table-list
+                     (mapcar #'file-name-directory tags-table-list)
+                   ;; If no tags files are loaded, prompt for the dir.
+                   (list (read-directory-name "In directory: " nil nil t)))))
+       (cl-mapcan
+        (lambda (dir)
+          (xref-collect-references id dir))
+        dirs)))
     (`apropos (etags--xref-find-definitions id t))))
 
 (defun etags--xref-find-definitions (pattern &optional regexp?)
diff --git a/lisp/progmodes/xref.el b/lisp/progmodes/xref.el
index fc27c268845..099c08045b2 100644
--- a/lisp/progmodes/xref.el
+++ b/lisp/progmodes/xref.el
@@ -674,6 +674,49 @@ and just use etags."
     (setq-local xref-identifier-completion-table-function
                 (cdr xref-etags-mode--saved))))
 
+(declare-function semantic-symref-find-references-by-name "semantic/symref")
+(declare-function semantic-find-file-noselect "semantic/fw")
+
+(defun xref-collect-references (name dir)
+  "Collect mentions of NAME inside DIR.
+Uses the Semantic Symbol Reference API, see
+`semantic-symref-find-references-by-name' for details on which
+tools are used, and when."
+  (require 'semantic/symref)
+  (defvar semantic-symref-tool)
+  (cl-assert (directory-name-p dir))
+  (let* ((default-directory dir)
+         (semantic-symref-tool 'detect)
+         (res (semantic-symref-find-references-by-name name 'subdirs))
+         (hits (and res (oref res :hit-lines)))
+         (orig-buffers (buffer-list)))
+    (unwind-protect
+        (delq nil
+              (mapcar (lambda (hit) (xref--collect-reference hit name)) hits))
+      (mapc #'kill-buffer
+            (cl-set-difference (buffer-list) orig-buffers)))))
+
+(defun xref--collect-reference (hit name)
+  (pcase-let* ((`(,line . ,file) hit)
+               (buf (or (find-buffer-visiting file)
+                        (semantic-find-file-noselect file))))
+    (with-current-buffer buf
+      (save-excursion
+        (goto-char (point-min))
+        (forward-line (1- line))
+        (when (re-search-forward (format "\\_<%s\\_>"
+                                         (regexp-quote name))
+                                 (line-end-position) t)
+          (goto-char (match-beginning 0))
+          (xref-make (format
+                      "%d: %s"
+                      line
+                      (buffer-substring
+                       (line-beginning-position)
+                       (line-end-position)))
+                     (xref-make-file-location file line
+                                              (current-column))))))))
+
 
 (provide 'xref)
 
diff --git a/lisp/simple.el b/lisp/simple.el
index cf1912ade4f..31efe3896d4 100644
--- a/lisp/simple.el
+++ b/lisp/simple.el
@@ -6992,8 +6992,9 @@ The function should return non-nil if the two tokens do not match.")
                     (buffer-substring blinkpos (1+ blinkpos))))
                   ;; There is nothing to show except the char itself.
                   (t (buffer-substring blinkpos (1+ blinkpos))))))
-            (message "Matches %s"
-                     (substring-no-properties open-paren-line-string)))))))))
+            (minibuffer-message
+             "Matches %s"
+             (substring-no-properties open-paren-line-string)))))))))
 
 (defvar blink-paren-function 'blink-matching-open
   "Function called, if non-nil, whenever a close parenthesis is inserted.
diff --git a/lisp/whitespace.el b/lisp/whitespace.el
index b4cd67ff6b9..fad3e2f3ea6 100644
--- a/lisp/whitespace.el
+++ b/lisp/whitespace.el
@@ -538,31 +538,34 @@ cleaning up a buffer.  See `whitespace-cleanup' and
 `whitespace-cleanup-region' for documentation.
 
 See also `whitespace-display-mappings' for documentation."
-  :type '(repeat :tag "Kind of Blank"
-                 (choice :tag "Kind of Blank Face"
-                         (const :tag "(Face) Face visualization"
-                                face)
-                         (const :tag "(Face) Trailing TABs, SPACEs and HARD SPACEs"
-                                trailing)
-                         (const :tag "(Face) SPACEs and HARD SPACEs"
-                                spaces)
-                         (const :tag "(Face) TABs" tabs)
-                         (const :tag "(Face) Lines" lines)
-                         (const :tag "(Face) SPACEs before TAB"
-                                space-before-tab)
-                         (const :tag "(Face) NEWLINEs" newline)
-                         (const :tag "(Face) Indentation SPACEs"
-                                indentation)
-                         (const :tag "(Face) Too much line indentation"
-                                big-indent)
-                         (const :tag "(Face) Empty Lines At BOB And/Or EOB"
-                                empty)
-                         (const :tag "(Face) SPACEs after TAB"
-                                space-after-tab)
-                         (const :tag "(Mark) SPACEs and HARD SPACEs"
-                                space-mark)
-                         (const :tag "(Mark) TABs" tab-mark)
-                         (const :tag "(Mark) NEWLINEs" newline-mark)))
+  :type '(set :tag "Kind of Blank"
+              (const :tag "(Face) Face visualization" face)
+              (const :tag "(Face) Trailing TABs, SPACEs and HARD SPACEs"
+                     trailing)
+              (const :tag "(Face) TABs" tabs)
+              (const :tag "(Face) SPACEs and HARD SPACEs" spaces)
+              (const :tag "(Face) Lines" lines)
+              (const :tag "(Face) Lines, only overlong part" lines-tail)
+              (const :tag "(Face) NEWLINEs" newline)
+              (const :tag "(Face) Empty Lines At BOB And/Or EOB" empty)
+              (const :tag "(Face) Indentation SPACEs" indentation::tab)
+              (const :tag "(Face) Indentation TABs"
+                     indentation::space)
+              (const :tag "(Face) Indentation TABs or SPACEs" indentation)
+              (const :tag "(Face) Too much line indentation" big-indent)
+              (const :tag "(Face) SPACEs after TAB: SPACEs"
+                     space-after-tab::tab)
+              (const :tag "(Face) SPACEs after TAB: TABs"
+                     space-after-tab::space)
+              (const :tag "(Face) SPACEs after TAB" space-after-tab)
+              (const :tag "(Face) SPACEs before TAB: SPACEs"
+                     space-before-tab::tab)
+              (const :tag "(Face) SPACEs before TAB: TABs"
+                     space-before-tab::space)
+              (const :tag "(Face) SPACEs before TAB" space-before-tab)
+              (const :tag "(Mark) SPACEs and HARD SPACEs" space-mark)
+              (const :tag "(Mark) TABs" tab-mark)
+              (const :tag "(Mark) NEWLINEs" newline-mark))
   :group 'whitespace)
 
 (defvar whitespace-space 'whitespace-space