Merge branch 'master' into cairo

11 files changed, 484 insertions, 177 deletions

diff --git a/lisp/progmodes/cc-awk.el b/lisp/progmodes/cc-awk.el
index 1ef80c801ee..ad0248561a8 100644
--- a/lisp/progmodes/cc-awk.el
+++ b/lisp/progmodes/cc-awk.el
@@ -61,6 +61,7 @@
 (cc-bytecomp-defun c-backward-token-1)
 (cc-bytecomp-defun c-beginning-of-statement-1)
 (cc-bytecomp-defun c-backward-sws)
+(cc-bytecomp-defun c-forward-sws)
 
 (defvar awk-mode-syntax-table
   (let ((st (make-syntax-table)))
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 68075f356ab..94dc34bb20e 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1317,6 +1317,9 @@ keyword on the line, the keyword is not inserted inside a literal, and
   (autoload 'c-subword-mode "cc-subword"
     "Mode enabling subword movement and editing keys." t)))
 
+(declare-function c-forward-subword "ext:cc-subword" (&optional arg))
+(declare-function c-backward-subword "ext:cc-subword" (&optional arg))
+
 ;; "nomenclature" functions + c-scope-operator.
 (defun c-forward-into-nomenclature (&optional arg)
   "Compatibility alias for `c-forward-subword'."
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 ad35c48a101..e06b920e5d7 100644
--- a/lisp/progmodes/elisp-mode.el
+++ b/lisp/progmodes/elisp-mode.el
@@ -30,7 +30,6 @@
 
 (require 'lisp-mode)
 
-(defvar emacs-lisp-mode-abbrev-table nil)
 (define-abbrev-table 'emacs-lisp-mode-abbrev-table ()
   "Abbrev table for Emacs Lisp mode.
 It has `lisp-mode-abbrev-table' as its parent."
@@ -476,11 +475,12 @@ It can be quoted, or be inside a quoted form."
                       (point)))
                 (scan-error pos))))
            ;; t if in function position.
-           (funpos (eq (char-before beg) ?\()))
+           (funpos (eq (char-before beg) ?\())
+           (quoted (elisp--form-quoted-p beg)))
       (when (and end (or (not (nth 8 (syntax-ppss)))
                          (eq (char-before beg) ?`)))
         (let ((table-etc
-               (if (not funpos)
+               (if (or (not funpos) quoted)
                    ;; FIXME: We could look at the first element of the list and
                    ;; use it to provide a more specific completion table in some
                    ;; cases.  E.g. filter out keywords that are not understood by
@@ -492,7 +492,7 @@ It can be quoted, or be inside a quoted form."
                            :company-doc-buffer #'elisp--company-doc-buffer
                            :company-docsig #'elisp--company-doc-string
                            :company-location #'elisp--company-location))
-                    ((elisp--form-quoted-p beg)
+                    (quoted
                      (list nil obarray
                            ;; Don't include all symbols (bug#16646).
                            :predicate (lambda (sym)
@@ -544,10 +544,11 @@ It can be quoted, or be inside a quoted form."
                                         (< (point) beg)))))
                         (list t obarray
                               :predicate (lambda (sym) (get sym 'error-conditions))))
-                       ((and ?\(
+                       ((and (or ?\( `let `let*)
                              (guard (save-excursion
                                       (goto-char (1- beg))
-                                      (up-list -1)
+                                      (when (eq parent ?\()
+                                        (up-list -1))
                                       (forward-symbol -1)
                                       (looking-at "\\_<let\\*?\\_>"))))
                         (list t obarray
@@ -580,6 +581,7 @@ It can be quoted, or be inside a quoted form."
 (declare-function xref-make-elisp-location "xref" (symbol type file))
 (declare-function xref-make-bogus-location "xref" (message))
 (declare-function xref-make "xref" (description location))
+(declare-function xref-collect-matches "xref" (input dir &optional kind))
 
 (defun elisp-xref-find (action id)
   (require 'find-func)
@@ -588,6 +590,10 @@ 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-matches id 'symbol))
+    (`matches
+     (elisp--xref-find-matches id 'regexp))
     (`apropos
      (elisp--xref-find-apropos id))))
 
@@ -600,12 +606,16 @@ It can be quoted, or be inside a quoted form."
                        (setq sym (car fun-lib))
                        (cdr fun-lib))))
            (`defvar (and (boundp sym)
-                         ;; Don't show minor modes twice.
-                         ;; TODO: If TYPE ever becomes dependent on the
-                         ;; context, move this check outside.
-                         (not (fboundp sym))
-                         (or (symbol-file sym 'defvar)
-                             (help-C-file-name sym 'var))))
+                         (let ((el-file (symbol-file sym 'defvar)))
+                           (if el-file
+                               (and
+                                ;; Don't show minor modes twice.
+                                ;; TODO: If TYPE ever becomes dependent on the
+                                ;; context, move this check outside.
+                                (not (and (fboundp sym)
+                                          (memq sym minor-mode-list)))
+                                el-file)
+                             (help-C-file-name sym 'var)))))
            (`feature (and (featurep sym)
                           ;; Skip when a function with the same name
                           ;; is defined, because it's probably in the
@@ -620,6 +630,12 @@ It can be quoted, or be inside a quoted form."
         (setq file (substring file 0 -1)))
       (xref-make-elisp-location sym type file))))
 
+(defvar elisp--xref-format
+  (let ((str "(%s %s)"))
+    (put-text-property 1 3 'face 'font-lock-keyword-face str)
+    (put-text-property 4 6 'face 'font-lock-function-name-face str)
+    str))
+
 (defun elisp--xref-find-definitions (symbol)
   (save-excursion
     (let (lst)
@@ -631,11 +647,35 @@ It can be quoted, or be inside a quoted form."
                   (xref-make-bogus-location (error-message-string err))))))
           (when loc
             (push
-             (xref-make (format "(%s %s)" type symbol)
+             (xref-make (format elisp--xref-format type symbol)
                         loc)
              lst))))
       lst)))
 
+(defvar package-user-dir)
+
+(defun elisp--xref-find-matches (symbol kind)
+  (let* ((dirs (sort
+                (mapcar
+                 (lambda (dir)
+                   (file-name-as-directory (expand-file-name dir)))
+                 ;; It's one level above a number of `load-path'
+                 ;; elements (one for each installed package).
+                 ;; Save us some process calls.
+                 (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-matches symbol dir kind)))
+     dirs)))
+
 (defun elisp--xref-find-apropos (regexp)
   (apply #'nconc
          (let (lst)
@@ -1141,13 +1181,13 @@ which see."
     (cond ((null current-fnsym)
            nil)
           ((eq current-symbol (car current-fnsym))
-           (or (apply #'elisp--get-fnsym-args-string current-fnsym)
-               (elisp--get-var-docstring current-symbol)))
+           (or (apply #'elisp-get-fnsym-args-string current-fnsym)
+               (elisp-get-var-docstring current-symbol)))
           (t
-           (or (elisp--get-var-docstring current-symbol)
-               (apply #'elisp--get-fnsym-args-string current-fnsym))))))
+           (or (elisp-get-var-docstring current-symbol)
+               (apply #'elisp-get-fnsym-args-string current-fnsym))))))
 
-(defun elisp--get-fnsym-args-string (sym &optional index)
+(defun elisp-get-fnsym-args-string (sym &optional index prefix)
   "Return a string containing the parameter list of the function SYM.
 If SYM is a subr and no arglist is obtainable from the docstring
 or elsewhere, return a 1-line docstring."
@@ -1164,20 +1204,29 @@ or elsewhere, return a 1-line docstring."
                   (args
                    (cond
                     ((listp advertised) advertised)
-                    ((setq doc (help-split-fundoc (documentation sym t) sym))
+                    ((setq doc (help-split-fundoc
+                                (condition-case nil (documentation sym t)
+                                  (invalid-function nil))
+                                sym))
                      (car doc))
                     (t (help-function-arglist sym)))))
              ;; Stringify, and store before highlighting, downcasing, etc.
-             ;; FIXME should truncate before storing.
-             (elisp--last-data-store sym (elisp--function-argstring args)
+             (elisp--last-data-store sym (elisp-function-argstring args)
                                     'function))))))
     ;; Highlight, truncate.
     (if argstring
-        (elisp--highlight-function-argument sym argstring index))))
-
-(defun elisp--highlight-function-argument (sym args index)
+        (elisp--highlight-function-argument
+         sym argstring index
+         (or prefix
+             (concat (propertize (symbol-name sym) 'face
+                                 (if (functionp sym)
+                                     'font-lock-function-name-face
+                                   'font-lock-keyword-face))
+                     ": "))))))
+
+(defun elisp--highlight-function-argument (sym args index prefix)
   "Highlight argument INDEX in ARGS list for function SYM.
-In the absence of INDEX, just call `elisp--docstring-format-sym-doc'."
+In the absence of INDEX, just call `eldoc-docstring-format-sym-doc'."
   ;; FIXME: This should probably work on the list representation of `args'
   ;; rather than its string representation.
   ;; FIXME: This function is much too long, we need to split it up!
@@ -1262,9 +1311,9 @@ In the absence of INDEX, just call `elisp--docstring-format-sym-doc'."
                     ((string= argument "&allow-other-keys")) ; Skip.
                     ;; Back to index 0 in ARG1 ARG2 ARG2 ARG3 etc...
                     ;; like in `setq'.
-                    ((or (and (string-match-p "\\.\\.\\.$" argument)
+                    ((or (and (string-match-p "\\.\\.\\.\\'" argument)
                               (string= argument (car (last args-lst))))
-                         (and (string-match-p "\\.\\.\\.$"
+                         (and (string-match-p "\\.\\.\\.\\'"
                                               (substring args 1 (1- (length args))))
                               (= (length (remove "..." args-lst)) 2)
                               (> index 1) (eq (logand index 1) 1)))
@@ -1279,14 +1328,12 @@ In the absence of INDEX, just call `elisp--docstring-format-sym-doc'."
       (when start
         (setq doc (copy-sequence args))
         (add-text-properties start end (list 'face argument-face) doc))
-      (setq doc (elisp--docstring-format-sym-doc
-                 sym doc (if (functionp sym) 'font-lock-function-name-face
-                           'font-lock-keyword-face)))
+      (setq doc (eldoc-docstring-format-sym-doc prefix doc))
       doc)))
 
 ;; Return a string containing a brief (one-line) documentation string for
 ;; the variable.
-(defun elisp--get-var-docstring (sym)
+(defun elisp-get-var-docstring (sym)
   (cond ((not sym) nil)
         ((and (eq sym (aref elisp--eldoc-last-data 0))
               (eq 'variable (aref elisp--eldoc-last-data 2)))
@@ -1294,7 +1341,7 @@ In the absence of INDEX, just call `elisp--docstring-format-sym-doc'."
         (t
          (let ((doc (documentation-property sym 'variable-documentation t)))
            (when doc
-             (let ((doc (elisp--docstring-format-sym-doc
+             (let ((doc (eldoc-docstring-format-sym-doc
                          sym (elisp--docstring-first-line doc)
                          'font-lock-variable-name-face)))
                (elisp--last-data-store sym doc 'variable)))))))
@@ -1318,36 +1365,6 @@ In the absence of INDEX, just call `elisp--docstring-format-sym-doc'."
                    (substring doc start (match-beginning 0)))
                   ((zerop start) doc)
                   (t (substring doc start))))))))
-
-(defvar eldoc-echo-area-use-multiline-p)
-
-;; If the entire line cannot fit in the echo area, the symbol name may be
-;; truncated or eliminated entirely from the output to make room for the
-;; description.
-(defun elisp--docstring-format-sym-doc (sym doc face)
-  (save-match-data
-    (let* ((name (symbol-name sym))
-           (ea-multi eldoc-echo-area-use-multiline-p)
-           ;; Subtract 1 from window width since emacs will not write
-           ;; any chars to the last column, or in later versions, will
-           ;; cause a wraparound and resize of the echo area.
-           (ea-width (1- (window-width (minibuffer-window))))
-           (strip (- (+ (length name) (length ": ") (length doc)) ea-width)))
-      (cond ((or (<= strip 0)
-                 (eq ea-multi t)
-                 (and ea-multi (> (length doc) ea-width)))
-             (format "%s: %s" (propertize name 'face face) doc))
-            ((> (length doc) ea-width)
-             (substring (format "%s" doc) 0 ea-width))
-            ((>= strip (length name))
-             (format "%s" doc))
-            (t
-             ;; Show the end of the partial symbol name, rather
-             ;; than the beginning, since the former is more likely
-             ;; to be unique given package namespace conventions.
-             (setq name (substring name strip))
-             (format "%s: %s" (propertize name 'face face) doc))))))
-
 
 ;; Return a list of current function name and argument index.
 (defun elisp--fnsym-in-current-sexp ()
@@ -1392,7 +1409,7 @@ In the absence of INDEX, just call `elisp--docstring-format-sym-doc'."
          (memq (char-syntax c) '(?w ?_))
          (intern-soft (current-word)))))
 
-(defun elisp--function-argstring (arglist)
+(defun elisp-function-argstring (arglist)
   "Return ARGLIST as a string enclosed by ().
 ARGLIST is either a string, or a list of strings or symbols."
   (let ((str (cond ((stringp arglist) arglist)
diff --git a/lisp/progmodes/etags.el b/lisp/progmodes/etags.el
index b470352f8dc..7a87377503d 100644
--- a/lisp/progmodes/etags.el
+++ b/lisp/progmodes/etags.el
@@ -947,6 +947,7 @@ onto a ring and may be popped back to with \\[pop-tag-mark].
 Contrast this with the ring of marks gone to by the command.
 
 See documentation of variable `tags-file-name'."
+  (declare (obsolete xref-find-definitions "25.1"))
   (interactive (find-tag-interactive "Find tag: "))
   (let* ((buf (find-tag-noselect tagname next-p regexp-p))
          (pos (with-current-buffer buf (point))))
@@ -2073,12 +2074,28 @@ for \\[find-tag] (which see)."
 ;; we hit the limit rarely.
 (defconst etags--xref-limit 1000)
 
+(defvar etags-xref-find-definitions-tag-order '(tag-exact-match-p
+                                                tag-implicit-name-match-p)
+  "Tag order used in `etags-xref-find' to look for definitions.")
+
 ;;;###autoload
 (defun etags-xref-find (action id)
   (pcase action
     (`definitions (etags--xref-find-definitions id))
+    (`references (etags--xref-find-matches id 'symbol))
+    (`matches (etags--xref-find-matches id 'regexp))
     (`apropos (etags--xref-find-definitions id t))))
 
+(defun etags--xref-find-matches (input kind)
+  (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-matches input dir kind))
+     dirs)))
+
 (defun etags--xref-find-definitions (pattern &optional regexp?)
   ;; This emulates the behaviour of `find-tag-in-order' but instead of
   ;; returning one match at a time all matches are returned as list.
@@ -2094,7 +2111,7 @@ for \\[find-tag] (which see)."
       (while (visit-tags-table-buffer (not first-time))
         (setq first-time nil)
         (dolist (order-fun (cond (regexp? find-tag-regexp-tag-order)
-                                 (t find-tag-tag-order)))
+                                 (t etags-xref-find-definitions-tag-order)))
           (goto-char (point-min))
           (while (and (funcall search-fun pattern nil t)
                       (< (hash-table-count marks) etags--xref-limit))
@@ -2129,6 +2146,10 @@ for \\[find-tag] (which see)."
         (etags-goto-tag-location tag-info)
         (point-marker)))))
 
+(cl-defmethod xref-location-line ((l xref-etags-location))
+  (with-slots (tag-info) l
+    (nth 1 tag-info)))
+
 
 (provide 'etags)
 
diff --git a/lisp/progmodes/idlw-shell.el b/lisp/progmodes/idlw-shell.el
index 40c40eef302..02a8ec8a560 100644
--- a/lisp/progmodes/idlw-shell.el
+++ b/lisp/progmodes/idlw-shell.el
@@ -1445,12 +1445,8 @@ Otherwise just move the line.  Move down unless UP is non-nil."
   (interactive "p")
   (idlwave-shell-move-or-history nil arg))
 
-;; Newer versions of comint.el changed the name of comint-filter to
-;; comint-output-filter.
-(defalias 'idlwave-shell-comint-filter
-  (if (fboundp 'comint-output-filter)
-      #'comint-output-filter
-    #'comint-filter))
+(define-obsolete-function-alias 'idlwave-shell-comint-filter
+  'comint-output-filter "25.1")
 
 (defun idlwave-shell-is-running ()
   "Return t if the shell process is running."
@@ -1496,7 +1492,7 @@ and then calls `idlwave-shell-send-command' for any pending commands."
                      (get-buffer-create idlwave-shell-hidden-output-buffer))
                     (goto-char (point-max))
                     (insert string))
-                (idlwave-shell-comint-filter proc string))
+                (comint-output-filter proc string))
               ;; Watch for magic - need to accumulate the current line
               ;; since it may not be sent all at once.
               (if (string-match "\n" string)
@@ -1552,7 +1548,7 @@ and then calls `idlwave-shell-send-command' for any pending commands."
                   (if idlwave-shell-hide-output
                       (if (and idlwave-shell-show-if-error
                                (eq idlwave-shell-current-state 'error))
-                          (idlwave-shell-comint-filter proc full-output)
+                          (comint-output-filter proc full-output)
                         ;; If it's only *mostly* hidden, filter % lines,
                         ;; and show anything that remains
                         (if (eq idlwave-shell-hide-output 'mostly)
@@ -1560,7 +1556,7 @@ and then calls `idlwave-shell-send-command' for any pending commands."
                                    (idlwave-shell-filter-hidden-output
                                     full-output)))
                               (if filtered
-                                  (idlwave-shell-comint-filter
+                                  (comint-output-filter
                                    proc filtered))))))
 
                   ;; Call the post-command hook
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index 62f19f42df1..f06c5c75b1a 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -2852,10 +2852,6 @@ with `js--js-encode-value'."
 (defsubst js--js-true (value)
   (not (js--js-not value)))
 
-;; The somewhat complex code layout confuses the byte-compiler into
-;; thinking this function "might not be defined at runtime".
-(declare-function js--optimize-arglist "js" (arglist))
-
 (eval-and-compile
   (defun js--optimize-arglist (arglist)
     "Convert immediate js< and js! references to deferred ones."
diff --git a/lisp/progmodes/python.el b/lisp/progmodes/python.el
index eb17d075921..4b0a028faa3 100644
--- a/lisp/progmodes/python.el
+++ b/lisp/progmodes/python.el
@@ -2268,7 +2268,8 @@ banner and the initial prompt are received separately."
       (while t
         (when (not (accept-process-output process timeout))
           (throw 'found nil))
-        (when (looking-back regexp)
+        (when (looking-back
+               regexp (car (python-util-comint-last-prompt)))
           (throw 'found t))))))
 
 (defun python-shell-comint-end-of-output-p (output)
diff --git a/lisp/progmodes/tcl.el b/lisp/progmodes/tcl.el
index 8f7705ba17d..e4e96554c95 100644
--- a/lisp/progmodes/tcl.el
+++ b/lisp/progmodes/tcl.el
@@ -1028,7 +1028,8 @@ Returns nil if line starts inside a string, t if in a comment."
     (with-current-buffer (process-buffer proc)
       ;; Delete prompt if requested.
       (when (marker-buffer inferior-tcl-delete-prompt-marker)
-        (delete-region (process-mark proc) inferior-tcl-delete-prompt-marker)
+        (let ((inhibit-read-only t))
+          (delete-region (process-mark proc) inferior-tcl-delete-prompt-marker))
         (set-marker inferior-tcl-delete-prompt-marker nil))))
   (comint-output-filter proc string))
 
diff --git a/lisp/progmodes/verilog-mode.el b/lisp/progmodes/verilog-mode.el
index 57206544b9b..a1ad49e9a2c 100644
--- a/lisp/progmodes/verilog-mode.el
+++ b/lisp/progmodes/verilog-mode.el
@@ -123,7 +123,7 @@
 ;;; Code:
 
 ;; This variable will always hold the version number of the mode
-(defconst verilog-mode-version "2015-02-20-0d6420b-vpo"
+(defconst verilog-mode-version "2015-05-14-6232468-vpo-GNU"
   "Version of this Verilog mode.")
 (defconst verilog-mode-release-emacs t
   "If non-nil, this version of Verilog mode was released with Emacs itself.")
@@ -282,6 +282,50 @@ STRING should be given if the last search was by `string-match' on STRING."
     ;; Emacs.
     (defalias 'verilog-regexp-opt 'regexp-opt)))
 
+;; emacs >=22 has looking-back, but older emacs and xemacs don't.
+;; This function is lifted directly from emacs's subr.el
+;; so that it can be used by xemacs.
+;; The idea for this was borrowed from org-mode via this link:
+;; https://lists.gnu.org/archive/html/emacs-orgmode/2009-12/msg00032.html
+(eval-and-compile
+  (cond
+   ((fboundp 'looking-back)
+    (defalias 'verilog-looking-back 'looking-back))
+   (t
+    (defun verilog-looking-back (regexp limit &optional greedy)
+      "Return non-nil if text before point matches regular expression REGEXP.
+Like `looking-at' except matches before point, and is slower.
+LIMIT if non-nil speeds up the search by specifying a minimum
+starting position, to avoid checking matches that would start
+before LIMIT.
+
+If GREEDY is non-nil, extend the match backwards as far as
+possible, stopping when a single additional previous character
+cannot be part of a match for REGEXP.  When the match is
+extended, its starting position is allowed to occur before
+LIMIT.
+
+As a general recommendation, try to avoid using `looking-back'
+wherever possible, since it is slow."
+   (let ((start (point))
+         (pos
+          (save-excursion
+            (and (re-search-backward (concat "\\(?:" regexp "\\)\\=") limit t)
+                 (point)))))
+     (if (and greedy pos)
+         (save-restriction
+           (narrow-to-region (point-min) start)
+           (while (and (> pos (point-min))
+                       (save-excursion
+                         (goto-char pos)
+                         (backward-char 1)
+                         (looking-at (concat "\\(?:"  regexp "\\)\\'"))))
+             (setq pos (1- pos)))
+           (save-excursion
+             (goto-char pos)
+             (looking-at (concat "\\(?:"  regexp "\\)\\'")))))
+     (not (null pos)))))))
+
 (eval-and-compile
   ;; Both xemacs and emacs
   (condition-case nil
@@ -662,9 +706,10 @@ to see the effect as font color choices are cached by Emacs."
 
 (defcustom verilog-highlight-grouping-keywords nil
   "Non-nil means highlight grouping keywords more dramatically.
-If false, these words are in the `font-lock-type-face'; if True then they are in
-`verilog-font-lock-ams-face'.  Some find that special highlighting on these
-grouping constructs allow the structure of the code to be understood at a glance."
+If false, these words are in the `font-lock-type-face'; if True
+then they are in `verilog-font-lock-grouping-keywords-face'.
+Some find that special highlighting on these grouping constructs
+allow the structure of the code to be understood at a glance."
   :group 'verilog-mode-indent
   :type 'boolean)
 (put 'verilog-highlight-grouping-keywords 'safe-local-variable 'verilog-booleanp)
@@ -1880,14 +1925,22 @@ find the errors."
 (if (featurep 'xemacs) (add-hook 'compilation-mode-hook 'verilog-error-regexp-add-xemacs))
 (if (featurep 'emacs) (add-hook 'compilation-mode-hook 'verilog-error-regexp-add-emacs))
 
-(defconst verilog-directive-re
+(defconst verilog-compiler-directives
   (eval-when-compile
-    (verilog-regexp-words
-     '(
-   "`case" "`default" "`define" "`else" "`elsif" "`endfor" "`endif"
-   "`endprotect" "`endswitch" "`endwhile" "`for" "`format" "`if" "`ifdef"
-   "`ifndef" "`include" "`let" "`protect" "`switch" "`timescale"
-   "`time_scale" "`undef" "`while" ))))
+    '( ;; compiler directives, from IEEE 1800-2012 section 22.1
+    "`__FILE__" "`__LINE" "`begin_keywords" "`celldefine" "`default_nettype"
+    "`define" "`else" "`elsif" "`end_keywords" "`endcelldefine" "`endif"
+    "`ifdef" "`ifndef" "`include" "`line" "`nounconnected_drive" "`pragma"
+    "`resetall" "`timescale" "`unconnected_drive" "`undef" "`undefineall"
+     ;; compiler directives not covered by IEEE 1800
+     "`case" "`default" "`endfor" "`endprotect" "`endswitch" "`endwhile" "`for"
+     "`format" "`if" "`let" "`protect" "`switch" "`timescale" "`time_scale"
+     "`while"
+     ))
+  "List of Verilog compiler directives.")
+
+(defconst verilog-directive-re
+  (verilog-regexp-words verilog-compiler-directives))
 
 (defconst verilog-directive-re-1
   (concat "[ \t]*"  verilog-directive-re))
@@ -2411,11 +2464,9 @@ find the errors."
    "\\(\\<begin\\>\\)\\|"                        ; 1
    "\\(\\<else\\>\\)\\|"                         ; 2
    "\\(\\<end\\>\\s-+\\<else\\>\\)\\|"           ; 3
-   "\\(\\<always_comb\\>\\(\[ \t\]*@\\)?\\)\\|"  ; 4
-   "\\(\\<always_ff\\>\\(\[ \t\]*@\\)?\\)\\|"    ; 5
-   "\\(\\<always_latch\\>\\(\[ \t\]*@\\)?\\)\\|" ; 6
+   "\\(\\<always\\(?:_ff\\)?\\>\\(?:\[ \t\]*@\\)\\)\\|"    ; 4 (matches always or always_ff w/ @...)
+   "\\(\\<always\\(?:_comb\\|_latch\\)?\\>\\)\\|"  ; 5 (matches always, always_comb, always_latch w/o @...)
    "\\(\\<fork\\>\\)\\|"                         ; 7
-   "\\(\\<always\\>\\(\[ \t\]*@\\)?\\)\\|"
    "\\(\\<if\\>\\)\\|"
    verilog-property-re "\\|"
    "\\(\\(" verilog-label-re "\\)?\\<assert\\>\\)\\|"
@@ -2581,10 +2632,10 @@ find the errors."
 (defconst verilog-declaration-re
   (concat "\\(" verilog-declaration-prefix-re "\\s-*\\)?" verilog-declaration-core-re))
 (defconst verilog-range-re "\\(\\[[^]]*\\]\\s-*\\)+")
-(defconst verilog-optional-signed-re "\\s-*\\(signed\\)?")
+(defconst verilog-optional-signed-re "\\s-*\\(\\(un\\)?signed\\)?")
 (defconst verilog-optional-signed-range-re
   (concat
-   "\\s-*\\(\\<\\(reg\\|wire\\)\\>\\s-*\\)?\\(\\<signed\\>\\s-*\\)?\\(" verilog-range-re "\\)?"))
+   "\\s-*\\(\\<\\(reg\\|wire\\)\\>\\s-*\\)?\\(\\<\\(un\\)?signed\\>\\s-*\\)?\\(" verilog-range-re "\\)?"))
 (defconst verilog-macroexp-re "`\\sw+")
 
 (defconst verilog-delay-re "#\\s-*\\(\\([0-9_]+\\('s?[hdxbo][0-9a-fA-F_xz]+\\)?\\)\\|\\(([^()]*)\\)\\|\\(\\sw+\\)\\)")
@@ -2799,17 +2850,23 @@ find the errors."
      ;; from http://www.emacswiki.org/emacs/MultilineRegexp
      (concat "\\<\\(`define\\|`if\\)\\>" ;; directive
              "\\s-+" ;; separator
-             "\\(.*\\(?:\n.*\\)*?\\)" ;; definition: to tend of line, the maybe more lines (excludes any trailing \n)
+             "\\(?:.*?\\(?:\n.*\\)*?\\)" ;; definition: to end of line, then maybe more lines (excludes any trailing \n)
+             "\\(?:\n\\s-*\n\\|\\'\\)") ;; blank line or EOF
+     "\\)\\|\\(?:"
+     ;; `<macro>() : i.e. `uvm_info(a,b,c) or any other pre-defined macro
+     ;; Since parameters inside the macro can have parentheses, and
+     ;; the macro can span multiple lines, just look for the opening
+     ;; parentheses and then continue to the end of the first
+     ;; non-escaped EOL
+     (concat "\\<`\\w+\\>\\s-*("
+      "\\(?:.*?\\(?:\n.*\\)*?\\)" ;; definition: to end of line, then maybe more lines (excludes any trailing \n)
              "\\(?:\n\\s-*\n\\|\\'\\)") ;; blank line or EOF
      "\\)"
      )))
 
 (defconst verilog-keywords
-  '( "`case" "`default" "`define" "`else" "`endfor" "`endif"
-     "`endprotect" "`endswitch" "`endwhile" "`for" "`format" "`if" "`ifdef"
-     "`ifndef" "`include" "`let" "`protect" "`switch" "`timescale"
-     "`time_scale" "`undef" "`while"
-
+  (append verilog-compiler-directives
+   '(
      "after" "alias" "always" "always_comb" "always_ff" "always_latch" "and"
      "assert" "assign" "assume" "automatic" "before" "begin" "bind"
      "bins" "binsof" "bit" "break" "buf" "bufif0" "bufif1" "byte"
@@ -2851,7 +2908,7 @@ find the errors."
      "sync_reject_on" "unique0" "until" "until_with" "untyped" "weak"
      ;; 1800-2012
      "implements" "interconnect" "nettype" "soft"
-     )
+     ))
   "List of Verilog keywords.")
 
 (defconst verilog-comment-start-regexp "//\\|/\\*"
@@ -2955,10 +3012,10 @@ See also `verilog-font-lock-extra-types'.")
 (defface verilog-font-lock-grouping-keywords-face
   '((((class color)
       (background light))
-     (:foreground "red4" :bold t ))
+     (:foreground "Purple" :bold t ))
     (((class color)
       (background dark))
-     (:foreground "red4" :bold t ))
+     (:foreground "orange1" :bold t ))
     (t (:italic t)))
   "Font lock mode face used to highlight verilog grouping keywords."
   :group 'font-lock-highlighting-faces)
@@ -3068,7 +3125,7 @@ See also `verilog-font-lock-extra-types'.")
          ;; Fontify all types
          (if verilog-highlight-grouping-keywords
              (cons (concat "\\<\\(" verilog-font-grouping-keywords "\\)\\>")
-                   'verilog-font-lock-ams-face)
+                   'verilog-font-lock-grouping-keywords-face)
            (cons (concat "\\<\\(" verilog-font-grouping-keywords "\\)\\>")
                  'font-lock-type-face))
          (cons (concat "\\<\\(" verilog-type-font-keywords "\\)\\>")
@@ -4200,6 +4257,8 @@ Uses `verilog-scan' cache."
         (not (or
               ;; stop if beginning of buffer
               (bobp)
+              ;; stop if looking at a pre-processor directive
+              (looking-at "`\\w+")
               ;; stop if we find a ;
               (= (preceding-char) ?\;)
               ;; stop if we see a named coverpoint
@@ -4208,12 +4267,13 @@ Uses `verilog-scan' cache."
               (not (or (looking-at "\\<") (forward-word -1)))
               ;; stop if we see an assertion (perhaps labeled)
               (and
-               (looking-at "\\(\\<\\(assert\\|assume\\|cover\\)\\>\\s-+\\<property\\>\\)\\|\\(\\<assert\\>\\)")
+               (looking-at "\\(\\w+\\W*:\\W*\\)?\\(\\<\\(assert\\|assume\\|cover\\)\\>\\s-+\\<property\\>\\)\\|\\(\\<assert\\>\\)")
                (progn
                  (setq h (point))
                  (save-excursion
                    (verilog-backward-token)
-                   (if (looking-at verilog-label-re)
+                   (if (and (looking-at verilog-label-re)
+                            (not (looking-at verilog-end-block-re)))
                        (setq h (point))))
                  (goto-char h)))
               ;; stop if we see an extended complete reg, perhaps a complete one
@@ -4715,8 +4775,8 @@ primitive or interface named NAME."
                                             (setq str (concat " // else: !assert " str ))
                                             (throw 'skip 1)))))))))
 
-                             (; always_comb, always_ff, always_latch
-                              (or (match-end 4) (match-end 5) (match-end 6))
+                             (; always, always_comb, always_latch w/o @...
+                              (match-end 5)
                               (goto-char (match-end 0))
                               (setq there (point))
                               (setq err nil)
@@ -4800,6 +4860,9 @@ primitive or interface named NAME."
                                 (throw 'skip 1))))
                          ))))
                   (end-of-line)
+      (if kill-existing-comment
+          (verilog-kill-existing-comment))
+      (delete-horizontal-space)
                   (insert (concat " // " string ))))
 
                (;- this is end{function,generate,task,module,primitive,table,generate}
@@ -5161,7 +5224,8 @@ FILENAME to find directory to run in, or defaults to `buffer-file-name`."
           ;; We should use font-lock-ensure in preference to
           ;; font-lock-fontify-buffer, but IIUC the problem this is supposed to
           ;; solve only appears in Emacsen older than font-lock-ensure anyway.
-          (when fontlocked (font-lock-fontify-buffer)))))))
+          ;; So avoid bytecomp's interactive-only by going through intern.
+          (when fontlocked (funcall (intern "font-lock-fontify-buffer"))))))))
 
 
 ;;
@@ -5530,8 +5594,12 @@ Return a list of two elements: (INDENT-TYPE INDENT-LEVEL)."
            ((equal (char-after) ?\{)
             ;; block type returned based on outer constraint { or inner
             (if (verilog-at-constraint-p)
-                (cond (inconstraint (throw 'nesting 'constraint))
-                      (t            (throw 'nesting 'statement)))))
+                (cond (inconstraint
+                       (beginning-of-line nil)
+                       (skip-chars-forward " \t")
+                       (throw 'nesting 'constraint))
+                      (t
+                       (throw 'nesting 'statement)))))
            ((equal (char-after) ?\})
             (let (par-pos
                   (there (verilog-at-close-constraint-p)))
@@ -6044,7 +6112,16 @@ Optional BOUND limits search."
  (save-match-data
    (save-excursion
      (verilog-re-search-backward "\\((\\*\\)\\|\\(\\*)\\)" nil 'move)
-     (numberp (match-beginning 1)))))
+     (cond
+      ((match-end 1)
+         (progn (goto-char (match-end 1))
+                (not (looking-at "\\s-*)")))
+        nil)
+       ((match-end 2)
+        (progn (goto-char (match-beginning 2))
+               (not (looking-at "(\\s-*")))
+        nil)
+       (t nil)))))
 
 (defun verilog-in-parameter-p ()
  "Return true if point is in a parameter assignment #( p1=1, p2=5)."
@@ -6176,7 +6253,7 @@ Return >0 for nested struct."
                        ))
             ;; if first word token not keyword, it maybe the instance name
             ;;   check next word token
-            (if (looking-at "\\<\\w+\\>\\|\\s-*(\\s-*\\w+")
+            (if (looking-at "\\<\\w+\\>\\|\\s-*(\\s-*\\S-+")
                 (progn (verilog-beg-of-statement)
                        (if (looking-at (concat "\\<\\(constraint\\|"
                                                "\\(?:\\w+\\s-*:\\s-*\\)?\\(coverpoint\\|cross\\)"
@@ -6275,8 +6352,8 @@ Return >0 for nested struct."
                (goto-char (- (point) 2))
                t) ;; Let nth 4 state handle the rest
               ((and (not (bobp))
-                    (= (char-before) ?\))
-                    (= (char-before (1- (point))) ?\*))
+                    (verilog-looking-back "\\*)" nil)
+                    (not (verilog-looking-back "(\\s-*\\*)" nil)))
                (goto-char (- (point) 2))
                (if (search-backward "(*" nil t)
                    (progn
@@ -6320,7 +6397,8 @@ Return >0 for nested struct."
               (progn
                 (goto-char h)
                 nil))))
-         ((looking-at "(\\*")
+         ((and (looking-at "(\\*")              ;; attribute start, but not an event (*) or (* )
+               (not (looking-at "(\\*\\s-*)")))
           (progn
             (setq h (point))
             (goto-char (match-end 0))
@@ -6375,7 +6453,6 @@ Only look at a few lines to determine indent level."
         (cond
          ((or
            (= (preceding-char) ?\,)
-           (= (preceding-char) ?\])
            (save-excursion
              (verilog-beg-of-statement-1)
              (looking-at verilog-declaration-re)))
@@ -7830,6 +7907,48 @@ Signals must be in standard (base vector) form."
            (nreverse out-list)))))
 ;;(verilog-signals-not-in '(("A" "") ("B" "") ("DEL" "[2:3]")) '(("DEL" "") ("EXT" "")))
 
+(defun verilog-signals-not-in-struct (in-list not-list)
+  "Return list of signals in IN-LIST that aren't also in NOT-LIST.
+Also remove any duplicates in IN-LIST.
+Any structure in not-list will remove all members in in-list.
+Signals must be in standard (base vector) form."
+  (cond ((eval-when-compile (fboundp 'make-hash-table))
+         (let ((ht (make-hash-table :test 'equal :rehash-size 4.0))
+               out-list addit nm)
+           (while not-list
+             (puthash (car (car not-list)) t ht)
+             (setq not-list (cdr not-list)))
+           (while in-list
+             (setq nm (verilog-sig-name (car in-list)))
+             (when (not (gethash nm ht))
+               (setq addit t)
+               (while (string-match "^\\([^\\].*\\)\\.[^.]+$" nm)
+                 (setq nm (match-string 1 nm))
+                 (setq addit (and addit
+                                  (not (gethash nm ht)))))
+               (when addit
+                 (setq out-list (cons (car in-list) out-list))
+                 (puthash (verilog-sig-name (car in-list)) t ht)))
+             (setq in-list (cdr in-list)))
+           (nreverse out-list)))
+        ;; Slower Fallback if no hash tables (pre Emacs 21.1/XEmacs 21.4)
+        (t
+         (let (out-list addit nm)
+           (while in-list
+             (setq nm (verilog-sig-name (car in-list)))
+             (when (and (not (assoc nm not-list))
+                        (not (assoc nm out-list)))
+               (setq addit t)
+               (while (string-match "^\\([^\\].*\\)\\.[^.]+$" nm)
+                 (setq nm (match-string 1 nm))
+                 (setq addit (and addit
+                                  (not (assoc nm not-list)))))
+               (when addit
+                 (setq out-list (cons (car in-list) out-list))))
+             (setq in-list (cdr in-list)))
+           (nreverse out-list)))))
+;;(verilog-signals-not-in-struct '(("A" "") ("B" "") ("DEL.SUB.A" "[2:3]")) '(("DEL.SUB" "") ("EXT" "")))
+
 (defun verilog-signals-memory (in-list)
   "Return list of signals in IN-LIST that are memorized (multidimensional)."
   (let (out-list)
@@ -8281,10 +8400,9 @@ Return an array of [outputs inouts inputs wire reg assign const]."
                        typedefed nil  multidim nil    ptype nil   modport nil
                        expect-signal 'sigs-assign     sig-paren paren))
                 ((member keywd '("localparam" "genvar"))
-                 (unless io
-                   (setq vec nil        enum nil      rvalue nil  signed nil
-                         typedefed nil  multidim nil  ptype nil   modport nil
-                         expect-signal 'sigs-const    sig-paren paren)))
+                 (setq vec nil        enum nil      rvalue nil  signed nil
+                       typedefed nil  multidim nil  ptype nil   modport nil
+                       expect-signal 'sigs-const    sig-paren paren))
                 ((member keywd '("signed" "unsigned"))
                  (setq signed keywd))
                 ((member keywd '("assert" "assume" "cover" "expect" "restrict"))
@@ -12134,20 +12252,26 @@ You may also provide an optional third argument regular
 expression, in which case only signals which have that pin
 direction and data type matching that regular expression will be
 included.  This matches against everything before the signal name
-in the declaration, for example against \"input\" (single bit),
-\"output logic\" (direction and type) or \"output
-[1:0]\" (direction and implicit type).  You also probably want to
-skip spaces in your regexp.
+in the declaration, for example against \"input\" (single
+bit), \"output logic\" (direction and type) or
+\"output [1:0]\" (direction and implicit type).  You also
+probably want to skip spaces in your regexp.
 
 For example, the below will result in matching the output \"o\"
 against the previous example's module:
 
-           /*AUTOINOUTMODULE(\"ExampMain\",\"\",\"^output.*\")*/"
+           /*AUTOINOUTMODULE(\"ExampMain\",\"\",\"^output.*\")*/
+
+You may also provide an optional fourth argument regular
+expression, which if not \"\" only signals which do NOT match
+that expression are included."
+  ;; Beware spacing of quotes in above as can mess up Emacs indenter
   (save-excursion
-    (let* ((params (verilog-read-auto-params 1 3))
+    (let* ((params (verilog-read-auto-params 1 4))
            (submod (nth 0 params))
            (regexp (nth 1 params))
            (direction-re (nth 2 params))
+           (not-re (nth 3 params))
            submodi)
       ;; Lookup position, etc of co-module
       ;; Note this may raise an error
@@ -12182,20 +12306,24 @@ against the previous example's module:
                              (append (verilog-decls-get-interfaces moddecls)))))
           (forward-line 1)
           (setq sig-list-i  (verilog-signals-edit-wire-reg
-                             (verilog-signals-matching-dir-re
-                              (verilog-signals-matching-regexp sig-list-i regexp)
-                              "input" direction-re))
+                             (verilog-signals-not-matching-regexp
+                              (verilog-signals-matching-dir-re
+                               (verilog-signals-matching-regexp sig-list-i regexp)
+                               "input" direction-re) not-re))
                 sig-list-o  (verilog-signals-edit-wire-reg
-                             (verilog-signals-matching-dir-re
-                              (verilog-signals-matching-regexp sig-list-o regexp)
-                              "output" direction-re))
+                             (verilog-signals-not-matching-regexp
+                              (verilog-signals-matching-dir-re
+                               (verilog-signals-matching-regexp sig-list-o regexp)
+                               "output" direction-re) not-re))
                 sig-list-io (verilog-signals-edit-wire-reg
+                             (verilog-signals-not-matching-regexp
+                              (verilog-signals-matching-dir-re
+                               (verilog-signals-matching-regexp sig-list-io regexp)
+                               "inout" direction-re) not-re))
+                sig-list-if (verilog-signals-not-matching-regexp
                              (verilog-signals-matching-dir-re
-                              (verilog-signals-matching-regexp sig-list-io regexp)
-                              "inout" direction-re))
-                sig-list-if (verilog-signals-matching-dir-re
-                             (verilog-signals-matching-regexp sig-list-if regexp)
-                             "interface" direction-re))
+                              (verilog-signals-matching-regexp sig-list-if regexp)
+                              "interface" direction-re) not-re))
           (when v2k (verilog-repair-open-comma))
           (when (or sig-list-i sig-list-o sig-list-io sig-list-if)
             (verilog-insert-indent "// Beginning of automatic in/out/inouts (from specific module)\n")
@@ -12262,15 +12390,20 @@ You may also provide an optional third argument regular
 expression, in which case only signals which have that pin
 direction and data type matching that regular expression will be
 included.  This matches against everything before the signal name
-in the declaration, for example against \"input\" (single bit),
-\"output logic\" (direction and type) or \"output
-[1:0]\" (direction and implicit type).  You also probably want to
-skip spaces in your regexp.
+in the declaration, for example against \"input\" (single
+bit), \"output logic\" (direction and type)
+or \"output [1:0]\" (direction and implicit type).  You also
+probably want to skip spaces in your regexp.
 
 For example, the below will result in matching the output \"o\"
 against the previous example's module:
 
-           /*AUTOINOUTCOMP(\"ExampMain\",\"\",\"^output.*\")*/"
+           /*AUTOINOUTCOMP(\"ExampMain\",\"\",\"^output.*\")*/
+
+You may also provide an optional fourth argument regular
+expression, which if not \"\" only signals which do NOT match
+that expression are included."
+  ;; Beware spacing of quotes in above as can mess up Emacs indenter
   (verilog-auto-inout-module t nil))
 
 (defun verilog-auto-inout-in ()
@@ -12793,14 +12926,15 @@ Typing \\[verilog-auto] will make this into:
         (verilog-re-search-backward-quick "\\(@\\|\\<\\(always\\(_latch\\|_ff\\|_comb\\)?\\)\\>\\)" nil t)
         (setq sigss (verilog-read-always-signals)))
       (setq dly-list (verilog-alw-get-outputs-delayed sigss))
-      (setq sig-list (verilog-signals-not-in (append
-                                              (verilog-alw-get-outputs-delayed sigss)
-                                              (when (or (not (verilog-alw-get-uses-delayed sigss))
-                                                        verilog-auto-reset-blocking-in-non)
-                                                (verilog-alw-get-outputs-immediate sigss)))
-                                             (append
-                                              (verilog-alw-get-temps sigss)
-                                              prereset-sigs)))
+      (setq sig-list (verilog-signals-not-in-struct
+                      (append
+                       (verilog-alw-get-outputs-delayed sigss)
+                       (when (or (not (verilog-alw-get-uses-delayed sigss))
+                                 verilog-auto-reset-blocking-in-non)
+                         (verilog-alw-get-outputs-immediate sigss)))
+                      (append
+                       (verilog-alw-get-temps sigss)
+                       prereset-sigs)))
       (setq sig-list (sort sig-list `verilog-signals-sort-compare))
       (when sig-list
         (insert "\n");
diff --git a/lisp/progmodes/xref.el b/lisp/progmodes/xref.el
index 0257210a6c7..ef46e34e78f 100644
--- a/lisp/progmodes/xref.el
+++ b/lisp/progmodes/xref.el
@@ -73,13 +73,17 @@
   "Return a string used to group a set of locations.
 This is typically the filename.")
 
+(cl-defgeneric xref-location-line (_location)
+  "Return the line number corresponding to the location."
+  nil)
+
 ;;;; Commonly needed location classes are defined here:
 
 ;; FIXME: might be useful to have an optional "hint" i.e. a string to
 ;; search for in case the line number is sightly out of date.
 (defclass xref-file-location (xref-location)
   ((file :type string :initarg :file)
-   (line :type fixnum :initarg :line)
+   (line :type fixnum :initarg :line :reader xref-location-line)
    (column :type fixnum :initarg :column))
   :documentation "A file location is a file/line/column triple.
 Line numbers start from 1 and columns from 0.")
@@ -203,6 +207,9 @@ found, return nil.
  (apropos PATTERN): Find all symbols that match PATTERN.  PATTERN
 is a regexp.
 
+ (matches REGEXP): Find all matches for REGEXP in the related
+files.  REGEXP is an Emacs regular expression.
+
 IDENTIFIER can be any string returned by
 `xref-identifier-at-point-function', or from the table returned
 by `xref-identifier-completion-table-function'.
@@ -276,6 +283,20 @@ backward."
   :type 'integer
   :version "25.1")
 
+(defcustom xref-prompt-for-identifier nil
+  "When non-nil, always prompt for the identifier name.
+
+Otherwise, only prompt when there's no value at point we can use,
+or when the command has been called with the prefix argument."
+  :type '(choice (const :tag "always" t)
+                 (const :tag "auto" nil))
+  :version "25.1")
+
+(defcustom xref-pulse-on-jump t
+  "When non-nil, momentarily highlight jump locations."
+  :type 'boolean
+  :version "25.1")
+
 (defvar xref--marker-ring (make-ring xref-marker-ring-length)
   "Ring of markers to implement the marker stack.")
 
@@ -294,7 +315,20 @@ backward."
       (switch-to-buffer (or (marker-buffer marker)
                             (error "The marked buffer has been deleted")))
       (goto-char (marker-position marker))
-      (set-marker marker nil nil))))
+      (set-marker marker nil nil)
+      (xref--maybe-pulse))))
+
+(defun xref--maybe-pulse ()
+  (when xref-pulse-on-jump
+    (let (beg end)
+      (save-excursion
+        (back-to-indentation)
+        (if (eolp)
+            (setq beg (line-beginning-position)
+                  end (1+ (point)))
+          (setq beg (point)
+                end (line-end-position))))
+      (pulse-momentary-highlight-region beg end 'next-error))))
 
 ;; etags.el needs this
 (defun xref-clear-marker-stack ()
@@ -329,7 +363,8 @@ WINDOW controls how the buffer is displayed:
   (cl-ecase window
     ((nil)  (switch-to-buffer (current-buffer)))
     (window (pop-to-buffer (current-buffer) t))
-    (frame  (let ((pop-up-frames t)) (pop-to-buffer (current-buffer) t)))))
+    (frame  (let ((pop-up-frames t)) (pop-to-buffer (current-buffer) t))))
+  (xref--maybe-pulse))
 
 
 ;;; XREF buffer (part of the UI)
@@ -365,6 +400,7 @@ Used for temporary buffers.")
   (with-selected-window (display-buffer (current-buffer) other-window)
     (goto-char pos)
     (recenter recenter-arg)
+    (xref--maybe-pulse)
     (let ((buf (current-buffer))
           (win (selected-window)))
       (with-current-buffer xref-buf
@@ -406,7 +442,9 @@ Used for temporary buffers.")
   (xref-show-location-at-point))
 
 (defun xref--location-at-point ()
-  (get-text-property (point) 'xref-location))
+  (save-excursion
+    (back-to-indentation)
+    (get-text-property (point) 'xref-location)))
 
 (defvar-local xref--window nil
   "ACTION argument to call `display-buffer' with.")
@@ -414,7 +452,6 @@ Used for temporary buffers.")
 (defun xref-goto-xref ()
   "Jump to the xref on the current line and bury the xref buffer."
   (interactive)
-  (back-to-indentation)
   (let ((loc (or (xref--location-at-point)
                  (user-error "No reference at point")))
         (window xref--window))
@@ -435,7 +472,22 @@ Used for temporary buffers.")
 
 (define-derived-mode xref--xref-buffer-mode special-mode "XREF"
   "Mode for displaying cross-references."
-  (setq buffer-read-only t))
+  (setq buffer-read-only t)
+  (setq next-error-function #'xref--next-error-function)
+  (setq next-error-last-buffer (current-buffer)))
+
+(defun xref--next-error-function (n reset?)
+  (when reset?
+    (goto-char (point-min)))
+  (let ((backward (< n 0))
+        (n (abs n))
+        (loc nil))
+    (dotimes (_ n)
+      (setq loc (xref--search-property 'xref-location backward)))
+    (cond (loc
+           (xref--pop-to-location loc))
+          (t
+           (error "No %s xref" (if backward "previous" "next"))))))
 
 (defun xref-quit (&optional kill)
   "Bury temporarily displayed buffers, then quit the current window.
@@ -485,22 +537,35 @@ meantime are preserved."
 XREF-ALIST is of the form ((GROUP . (XREF ...)) ...).  Where
 GROUP is a string for decoration purposes and XREF is an
 `xref--xref' object."
-  (cl-loop for ((group . xrefs) . more1) on xref-alist do
-           (xref--insert-propertized '(face bold) group "\n")
+  (require 'compile) ; For the compilation faces.
+  (cl-loop for ((group . xrefs) . more1) on xref-alist
+           for max-line-width =
+           (cl-loop for xref in xrefs
+                    maximize (let ((line (xref-location-line
+                                          (oref xref :location))))
+                               (length (and line (format "%d" line)))))
+           for line-format = (and max-line-width
+                                  (format "%%%dd: " max-line-width))
+           do
+           (xref--insert-propertized '(face compilation-info) group "\n")
            (cl-loop for (xref . more2) on xrefs do
-                    (insert "  ")
                     (with-slots (description location) xref
-                      (xref--insert-propertized
-                       (list 'xref-location location
-                             'face 'font-lock-keyword-face
-                             'mouse-face 'highlight
-                             'keymap xref--button-map
-                             'help-echo
-                             (concat "mouse-2: display in another window, "
-                                     "RET or mouse-1: follow reference"))
-                       description))
-                    (when (or more1 more2)
-                      (insert "\n")))))
+                      (let* ((line (xref-location-line location))
+                             (prefix
+                              (if line
+                                  (propertize (format line-format line)
+                                              'face 'compilation-line-number)
+                                "  ")))
+                        (xref--insert-propertized
+                         (list 'xref-location location
+                               ;; 'face 'font-lock-keyword-face
+                               'mouse-face 'highlight
+                               'keymap xref--button-map
+                               'help-echo
+                               (concat "mouse-2: display in another window, "
+                                       "RET or mouse-1: follow reference"))
+                         prefix description)))
+                    (insert "\n"))))
 
 (defun xref--analyze (xrefs)
   "Find common filenames in XREFS.
@@ -559,10 +624,10 @@ Return an alist of the form ((FILENAME . (XREF ...)) ...)."
 (defun xref--read-identifier (prompt)
   "Return the identifier at point or read it from the minibuffer."
   (let ((id (funcall xref-identifier-at-point-function)))
-    (cond ((or current-prefix-arg (not id))
+    (cond ((or current-prefix-arg xref-prompt-for-identifier (not id))
            (completing-read prompt
                             (funcall xref-identifier-completion-table-function)
-                            nil t nil
+                            nil nil nil
                             'xref--read-identifier-history id))
           (t id))))
 
@@ -599,6 +664,12 @@ With prefix argument, prompt for the identifier."
   (interactive (list (xref--read-identifier "Find references of: ")))
   (xref--show-xrefs identifier 'references identifier nil))
 
+;;;###autoload
+(defun xref-find-regexp (regexp)
+  "Find all matches for REGEXP."
+  (interactive (list (xref--read-identifier "Find regexp: ")))
+  (xref--show-xrefs regexp 'matches regexp nil))
+
 (declare-function apropos-parse-pattern "apropos" (pattern))
 
 ;;;###autoload
@@ -650,6 +721,72 @@ 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-symref-find-text "semantic/symref")
+(declare-function semantic-find-file-noselect "semantic/fw")
+
+(defun xref-collect-matches (input dir &optional kind)
+  "Collect KIND matches for INPUT inside DIR according.
+KIND can be `symbol', `regexp' or nil, the last of which means
+literal matches.  This function 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))
+  (when (null kind)
+    (setq input (regexp-quote input)))
+  (let* ((default-directory dir)
+         (semantic-symref-tool 'detect)
+         (res (if (eq kind 'symbol)
+                  (semantic-symref-find-references-by-name input 'subdirs)
+                (semantic-symref-find-text (xref--regexp-to-extended input)
+                                           'subdirs)))
+         (hits (and res (oref res :hit-lines)))
+         (orig-buffers (buffer-list)))
+    (unwind-protect
+        (delq nil
+              (mapcar (lambda (hit) (xref--collect-match hit input kind)) hits))
+      (mapc #'kill-buffer
+            (cl-set-difference (buffer-list) orig-buffers)))))
+
+(defun xref--regexp-to-extended (str)
+  (replace-regexp-in-string
+   ;; FIXME: Add tests.  Move to subr.el, make a public function.
+   ;; Maybe error on Emacs-only constructs.
+   "\\(?:\\\\\\\\\\)*\\(?:\\\\[][]\\)?\\(?:\\[.+?\\]\\|\\(\\\\?[(){}|]\\)\\)"
+   (lambda (str)
+     (cond
+      ((not (match-beginning 1))
+       str)
+      ((eq (length (match-string 1 str)) 2)
+       (concat (substring str 0 (match-beginning 1))
+               (substring (match-string 1 str) 1 2)))
+      (t
+       (concat (substring str 0 (match-beginning 1))
+               "\\"
+               (match-string 1 str)))))
+   str t t))
+
+(defun xref--collect-match (hit input kind)
+  (pcase-let* ((`(,line . ,file) hit)
+               (buf (or (find-buffer-visiting file)
+                        (semantic-find-file-noselect file)))
+               (input (if (eq kind 'symbol)
+                          (format "\\_<%s\\_>" (regexp-quote input))
+                        input)))
+    (with-current-buffer buf
+      (save-excursion
+        (goto-char (point-min))
+        (forward-line (1- line))
+        (when (re-search-forward input (line-end-position) t)
+          (goto-char (match-beginning 0))
+          (xref-make (buffer-substring
+                      (line-beginning-position)
+                      (line-end-position))
+                     (xref-make-file-location file line
+                                              (current-column))))))))
+
 
 (provide 'xref)