Merge from origin/emacs-25

1f6898d test/automated/vc-hg.el: Support out-of-tree build
3adb56e Minor change in tramp-tests.el
2b535ba ; * etc/NEWS: Update the js.el entry.
76b518c * etc/HELLO: Add Armenian and Mongolian greetings.
b51f1ef Java Mode: Fontify identifiers in the presence of annotations.
36b9539 Avoid an infloop when we run out of memory
2006752 Avoid unnecessary failures of auto-saving after fatal error
eef6784 Simplify HAVE_MODULES use in mark_maybe_pointer
552694a Revert attempt to use 'noexcept' in typedef
6ad0d39 Update documentation of 'indirect-function'
c6a5314 ; * etc/NEWS: Move entry of 'inhibit-point-motion-hooks'.
303141a Update documentation for obsoleting 'syntax-begin-function'
4e6f61c ; * etc/NEWS: Mark documented and not-to-be-documented entries.
e667bbb Document new features if Eshell
9c4e4e0 ; * etc/NEWS: Update EUDC entries.
1089dc9 Handle too long commands in Tramp
684eb58 * .gitattributes: *.cur and *.pif are binary files too.
d2c7fda * src/alloc.c (mark_maybe_pointer): HAVE_MODULES may be undefined
bd3f53d * sh-script.el (sh-smie-sh-rules): Improve indentation inside $(...)
09b2b8a * src/alloc.c (mark_maybe_pointer): Also check wide-int's emacs_value
cca0f93 ; Account for spaces before the filename
c71e1e8 Use short date for 'hg annotate', and output the author
f50027b Spelling fix
c7dff67 ; * etc/NEWS: Fix the Xref entries that got separated.
cc140bc Document user-level functions in project.el
f8208b6 Document the user-level features of the Xref package
b131fb8 * loading.texi: Add `define-type' entry for load-history
db3c2a8 Improve doc strings and prompts in xref.el
f6117ef Allow the use of `font-lock-extend-region-multiline' in CC Mode.
90fd798 Fix coding system for Tramp on OS X.
e985a0e ; * etc/NEWS: Mark the 'check-expensive' entry not to be documented.
9dfcbf0 Update 'load-history' docs
207e191 Fix (error ...) error
457738f Correctly analyze brace arguments in templated C++ function declarations.
d57724a * lisp/cedet/mode-local.el (describe-function-orig-buffer): Declare.
2a9532d * lisp/ffap.el (ffap-latex-mode): Avoid free variable.
1a6b084 * lisp/play/dunnet.el (dun-fix-screen): Avoid `end-of-buffer`.
8be046f Respect fontification region calculated by major mode.  Fixes bug #22316.
4b37cba Improve documentation of Delete Selection mode
a034dd3 Fix two project-find-file issues
30abf29 Clarify doc string of 'dired-current-directory'
e990bb2 Use the face of preceding text for displaying the ellipsis
5810ac3 Suppress Chinese file name test for OSX in tramp-tests.el
eeb710a ; * lisp/startup.el: Sentences end with two spaces.
428b3de * admin/admin.el (set-version): Also handle the NEWS file.
648de81 ; Add NEWS entry for project.el
671862f apropos-library: Skip obvious duplicates; don't error on generics
51668a5 ; Grammar fix
ed41d11 Add project-find-file and project-or-external-find-file
056da45 ; Improve commentary in 'setup_for_ellipsis'
269d008 ; Improve docstring for `inhibit-startup-echo-area-message'

8 files changed, 178 insertions, 81 deletions

diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index c42fbe7e51f..2056f3907b8 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -656,23 +656,35 @@ right side of it."
 ;; Wrappers for common scan-lists cases, mainly because it's almost
 ;; impossible to get a feel for how that function works.
 
-(defmacro c-go-list-forward ()
-  "Move backward across one balanced group of parentheses.
-
-Return POINT when we succeed, NIL when we fail.  In the latter case, leave
-point unmoved."
-  `(c-safe (let ((endpos (scan-lists (point) 1 0)))
-             (goto-char endpos)
-             endpos)))
-
-(defmacro c-go-list-backward ()
-  "Move backward across one balanced group of parentheses.
-
-Return POINT when we succeed, NIL when we fail.  In the latter case, leave
-point unmoved."
-  `(c-safe (let ((endpos (scan-lists (point) -1 0)))
-             (goto-char endpos)
-             endpos)))
+(defmacro c-go-list-forward (&optional pos limit)
+  "Move forward across one balanced group of parentheses starting at POS or
+point.  Return POINT when we succeed, NIL when we fail.  In the latter case,
+leave point unmoved.
+
+A LIMIT for the search may be given.  The start position is assumed to be
+before it."
+  (let ((res `(c-safe (goto-char (scan-lists ,(or pos `(point)) 1 0)) (point))))
+    (if limit
+        `(save-restriction
+           (if ,limit
+               (narrow-to-region (point-min) ,limit))
+           ,res)
+      res)))
+
+(defmacro c-go-list-backward (&optional pos limit)
+  "Move backward across one balanced group of parentheses starting at POS or
+point.  Return POINT when we succeed, NIL when we fail.  In the latter case,
+leave point unmoved.
+
+A LIMIT for the search may be given.  The start position is assumed to be
+after it."
+  (let ((res `(c-safe (goto-char (scan-lists ,(or pos `(point)) -1 0)) (point))))
+    (if limit
+        `(save-restriction
+           (if ,limit
+               (narrow-to-region ,limit (point-max)))
+           ,res)
+      res)))
 
 (defmacro c-up-list-forward (&optional pos limit)
   "Return the first position after the list sexp containing POS,
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 3301d415923..b08c555e34f 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -5688,8 +5688,8 @@ comment at the start of cc-engine.el for more info."
         (c-backward-token-2)
         (setq c-restricted-<>-arglists
              (and (not (looking-at c-opt-<>-sexp-key))
-                  (progn (c-backward-syntactic-ws) ; to < or ,
-                         (and (memq (char-before) '(?< ?,))
+                  (progn (c-backward-syntactic-ws) ; to ( or ,
+                         (and (memq (char-before) '(?\( ?,)) ; what about <?
                               (not (eq (c-get-char-property (point) 'c-type)
                                        'c-decl-arg-start)))))))
       (or (c-forward-<>-arglist nil)
@@ -6641,16 +6641,22 @@ comment at the start of cc-engine.el for more info."
     res))
 
 (defun c-forward-annotation ()
-  ;; Used for Java code only at the moment.  Assumes point is on the
-  ;; @, moves forward an annotation.  returns nil if there is no
-  ;; annotation at point.
-  (and (looking-at "@")
-       (progn (forward-char) t)
-       (c-forward-type)
-       (progn (c-forward-syntactic-ws) t)
-       (if (looking-at "(")
-           (c-go-list-forward)
-         t)))
+  ;; Used for Java code only at the moment.  Assumes point is on the @, moves
+  ;; forward an annotation and returns t.  Leaves point unmoved and returns
+  ;; nil if there is no annotation at point.
+  (let ((pos (point)))
+    (or
+     (and (looking-at "@")
+          (not (looking-at c-keywords-regexp))
+          (progn (forward-char) t)
+          (looking-at c-symbol-key)
+          (progn (goto-char (match-end 0))
+                 (c-forward-syntactic-ws)
+                 t)
+          (if (looking-at "(")
+              (c-go-list-forward)
+            t))
+     (progn (goto-char pos) nil))))
 
 (defmacro c-pull-open-brace (ps)
   ;; Pull the next open brace from PS (which has the form of paren-state),
@@ -6959,9 +6965,8 @@ comment at the start of cc-engine.el for more info."
           (when (or (looking-at c-prefix-spec-kwds-re) ;FIXME!!! includes auto
                     (and (c-major-mode-is 'java-mode)
                          (looking-at "@[A-Za-z0-9]+")))
-            (save-match-data
-              (if (looking-at c-typedef-key)
-                (setq at-typedef t)))
+            (if (save-match-data (looking-at c-typedef-key))
+                (setq at-typedef t))
             (setq kwd-sym (c-keyword-sym (match-string 1)))
             (save-excursion
               (c-forward-keyword-clause 1)
@@ -9106,6 +9111,11 @@ comment at the start of cc-engine.el for more info."
             (goto-char containing-sexp)
             (if (or (save-excursion
                       (c-backward-syntactic-ws lim)
+                      (while (and (eq (char-before) ?>)
+                                  (c-get-char-property (1- (point))
+                                                       'syntax-table)
+                                  (c-go-list-backward nil lim))
+                        (c-backward-syntactic-ws lim))
                       (and (> (point) (or lim (point-min)))
                            (c-on-identifier)))
                     (and c-special-brace-lists
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index f74e5cbf678..03e67a99515 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -1157,15 +1157,6 @@ casts and declarations are fontified.  Used on level 2 and higher."
           (setq pos (point))))))     ; acts to make the `while' form continue.
   nil)
 
-(defconst c-font-lock-maybe-decl-faces
-  ;; List of faces that might be put at the start of a type when
-  ;; `c-font-lock-declarations' runs.  This needs to be evaluated to
-  ;; ensure that face name aliases in Emacs are resolved.
-  (list nil
-        font-lock-type-face
-        c-reference-face-name
-        font-lock-keyword-face))
-
 (defun c-font-lock-declarations (limit)
   ;; Fontify all the declarations, casts and labels from the point to LIMIT.
   ;; Assumes that strings and comments have been fontified already.
@@ -1256,7 +1247,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
       (c-find-decl-spots
        limit
        c-decl-start-re
-       c-font-lock-maybe-decl-faces
+       (eval c-maybe-decl-faces)
 
        (lambda (match-pos inside-macro)
          ;; Note to maintainers: don't use `limit' inside this lambda form;
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index 08d84fbb625..b52da3f662d 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -3251,6 +3251,19 @@ way."
   objc t)
 (c-lang-defvar c-type-decl-end-used (c-lang-const c-type-decl-end-used))
 
+(c-lang-defconst c-maybe-decl-faces
+  "List of faces that might be put at the start of a type when
+`c-font-lock-declarations' runs.  This must be evaluated (with `eval') at
+runtime to get the actual list of faces.  This ensures that face name
+aliases in Emacs are resolved."
+  t '(list nil
+           font-lock-type-face
+           c-reference-face-name
+           font-lock-keyword-face)
+  java (append (c-lang-const c-maybe-decl-faces)
+               '(font-lock-preprocessor-face)))
+(c-lang-defvar c-maybe-decl-faces (c-lang-const c-maybe-decl-faces))
+
 
 ;;; Wrap up the `c-lang-defvar' system.
 
diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 644065911dd..738870b727a 100644
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1336,12 +1336,13 @@ This function is called from `c-common-init', once per mode initialization."
            . c-mark-function)))
 
   ;; Prevent `font-lock-default-fontify-region' extending the region it will
-  ;; fontify to whole lines by removing `font-lock-extend-region-whole-lines'
-  ;; (and, coincidentally, `font-lock-extend-region-multiline' (which we do
-  ;; not need)) from `font-lock-extend-region-functions'.  (Emacs only).  This
-  ;; fixes Emacs bug #19669.
+  ;; fontify to whole lines by removing `font-lock-extend-region-wholelines'
+  ;; from `font-lock-extend-region-functions'.  (Emacs only).  This fixes
+  ;; Emacs bug #19669.
   (when (boundp 'font-lock-extend-region-functions)
-    (setq font-lock-extend-region-functions nil))
+    (setq font-lock-extend-region-functions
+          (delq 'font-lock-extend-region-wholelines
+                font-lock-extend-region-functions)))
 
   (make-local-variable 'font-lock-fontify-region-function)
   (setq font-lock-fontify-region-function 'c-font-lock-fontify-region)
diff --git a/lisp/progmodes/project.el b/lisp/progmodes/project.el
index d77158761eb..fe28ed776b2 100644
--- a/lisp/progmodes/project.el
+++ b/lisp/progmodes/project.el
@@ -27,6 +27,11 @@
 ;; current project, without having to know which package handles
 ;; detection of that project type, parsing its config files, etc.
 ;;
+;; NOTE: The project API is still experimental and can change in major,
+;; backward-incompatible ways.  Everyone is encouraged to try it, and
+;; report to us any problems or use cases we hadn't anticipated, by
+;; sending an email to emacs-devel, or `M-x report-emacs-bug'.
+;;
 ;; Infrastructure:
 ;;
 ;; Function `project-current', to determine the current project
@@ -45,10 +50,12 @@
 
 ;;; TODO:
 
-;; * Commands `project-find-file' and `project-or-external-find-file'.
-;;   Currently blocked on adding a new completion style that would let
-;;   the user enter just the base file name (or a part of it), and get
-;;   it expanded to the absolute file name.
+;; * Reliably cache the list of files in the project, probably using
+;;   filenotify.el (if supported) to invalidate.  And avoiding caching
+;;   if it's not available (manual cache invalidation is not nice).
+;;
+;; * Allow the backend to override the file-listing logic?  Maybe also
+;;   to delegate file name completion to an external tool.
 ;;
 ;; * Build tool related functionality.  Start with a `project-build'
 ;;   command, which should provide completions on tasks to run, and
@@ -251,13 +258,15 @@ DIRS must contain directory names."
 (defun project--value-in-dir (var dir)
   (with-temp-buffer
     (setq default-directory dir)
-    (hack-dir-local-variables-non-file-buffer)
+    (let ((enable-local-variables :all))
+      (hack-dir-local-variables-non-file-buffer))
     (symbol-value var)))
 
 (declare-function grep-read-files "grep")
 (declare-function xref-collect-matches "xref")
 (declare-function xref--show-xrefs "xref")
 (declare-function xref-backend-identifier-at-point "xref")
+(declare-function xref--find-ignores-arguments "xref")
 
 ;;;###autoload
 (defun project-find-regexp (regexp)
@@ -302,5 +311,53 @@ pattern to search for."
       (user-error "No matches for: %s" regexp))
     (xref--show-xrefs xrefs nil)))
 
+;;;###autoload
+(defun project-find-file ()
+  "Visit a file in the current project's roots.
+
+This is like `find-file', but it limits the file-name completion
+candidates to the files within the current project roots."
+  (interactive)
+  (let* ((pr (project-current t))
+         (dirs (project-roots pr)))
+    (project--find-file-in dirs pr)))
+
+;;;###autoload
+(defun project-or-external-find-file ()
+  "Visit a file in the current project's roots or external roots.
+
+This is like `find-file', but it limits the file-name completion
+candidates to the files within the current project roots and external roots."
+  (interactive)
+  (let* ((pr (project-current t))
+         (dirs (append
+                (project-roots pr)
+                (project-external-roots pr))))
+    (project--find-file-in dirs pr)))
+
+;; FIXME: Uniquely abbreviate the roots?
+(defun project--find-file-in (dirs project)
+  (require 'xref)
+  (let* ((all-files
+          (cl-mapcan
+           (lambda (dir)
+             (let ((command
+                    (format "%s %s %s -type f -print0"
+                            find-program
+                            dir
+                            (xref--find-ignores-arguments
+                             (project-ignores project dir)
+                             (expand-file-name dir)))))
+               (split-string (shell-command-to-string command) "\0" t)))
+           dirs))
+         (table (lambda (string pred action)
+                  (cond
+                   ((eq action 'metadata)
+                    '(metadata . ((category . project-file))))
+                   (t
+                    (complete-with-action action all-files string pred))))))
+    (find-file
+     (completing-read "Find file: " table nil t))))
+
 (provide 'project)
 ;;; project.el ends here
diff --git a/lisp/progmodes/sh-script.el b/lisp/progmodes/sh-script.el
index 02d329d794d..7f89ab2762c 100644
--- a/lisp/progmodes/sh-script.el
+++ b/lisp/progmodes/sh-script.el
@@ -2115,7 +2115,11 @@ May return nil if the line should not be treated as continued."
     ;; sh-indent-after-done: aligned completely differently.
     (`(:after . "in") (sh-var-value 'sh-indent-for-case-label))
     ;; sh-indent-for-continuation: Line continuations are handled differently.
-    (`(:after . ,(or `"(" `"{" `"[")) (sh-var-value 'sh-indent-after-open))
+    (`(:after . ,(or `"(" `"{" `"["))
+     (if (not (looking-at ".[ \t]*[^\n \t#]"))
+         (sh-var-value 'sh-indent-after-open)
+       (goto-char (1- (match-end 0)))
+       `(column . ,(current-column))))
     ;; sh-indent-after-function: we don't handle it differently.
     ))
 
diff --git a/lisp/progmodes/xref.el b/lisp/progmodes/xref.el
index ae5ec61520d..fe39122d24f 100644
--- a/lisp/progmodes/xref.el
+++ b/lisp/progmodes/xref.el
@@ -208,7 +208,7 @@ LENGTH is the match length, in characters."
 
 (defvar xref-backend-functions nil
   "Special hook to find the xref backend for the current context.
-Each functions on this hook is called in turn with no arguments
+Each function on this hook is called in turn with no arguments,
 and should return either nil to mean that it is not applicable,
 or an xref backend, which is a value to be used to dispatch the
 generic functions.")
@@ -502,10 +502,14 @@ WINDOW controls how the buffer is displayed:
     (xref--pop-to-location xref window)))
 
 (defun xref-query-replace (from to)
-  "Perform interactive replacement in all current matches."
+  "Perform interactive replacement of FROM with TO in all displayed xrefs.
+
+This command interactively replaces FROM with TO in the names of the
+references displayed in the current *xref* buffer."
   (interactive
-   (list (read-regexp "Query replace regexp in matches" ".*")
-         (read-regexp "Replace with: ")))
+   (let ((fr (read-regexp "Xref query-replace (regexp)" ".*")))
+     (list fr
+           (read-regexp (format "Xref query-replace (regexp) %s with: " fr)))))
   (let (pairs item)
     (unwind-protect
         (progn
@@ -762,12 +766,10 @@ Return an alist of the form ((FILENAME . (XREF ...)) ...)."
 With prefix argument or when there's no identifier at point,
 prompt for it.
 
-If the backend has sufficient information to determine a unique
-definition for IDENTIFIER, it returns only that definition. If
-there are multiple possible definitions, it returns all of them.
-
-If the backend returns one definition, jump to it; otherwise,
-display the list in a buffer."
+If sufficient information is available to determine a unique
+definition for IDENTIFIER, display it in the selected window.
+Otherwise, display the list of the possible definitions in a
+buffer where the user can select from the list."
   (interactive (list (xref--read-identifier "Find definitions of: ")))
   (xref--find-definitions identifier nil))
 
@@ -876,7 +878,9 @@ IGNORES is a list of glob patterns."
                                                        grep-find-template t t))
          (grep-highlight-matches nil)
          (command (xref--rgrep-command (xref--regexp-to-extended regexp)
-                                       files dir ignores))
+                                       files
+                                       (expand-file-name dir)
+                                       ignores))
          (orig-buffers (buffer-list))
          (buf (get-buffer-create " *xref-grep*"))
          (grep-re (caar grep-regexp-alist))
@@ -912,23 +916,28 @@ IGNORES is a list of glob patterns."
            " "
            (shell-quote-argument ")"))
    dir
-   (concat
-    (shell-quote-argument "(")
-    " -path "
-    (mapconcat
-     (lambda (ignore)
-       (when (string-match-p "/\\'" ignore)
-         (setq ignore (concat ignore "*")))
-       (if (string-match "\\`\\./" ignore)
-           (setq ignore (replace-match dir t t ignore))
-         (unless (string-prefix-p "*" ignore)
-           (setq ignore (concat "*/" ignore))))
-       (shell-quote-argument ignore))
-     ignores
-     " -o -path ")
-    " "
-    (shell-quote-argument ")")
-    " -prune -o ")))
+   (xref--find-ignores-arguments ignores dir)))
+
+(defun xref--find-ignores-arguments (ignores dir)
+  ;; `shell-quote-argument' quotes the tilde as well.
+  (cl-assert (not (string-match-p "\\`~" dir)))
+  (concat
+   (shell-quote-argument "(")
+   " -path "
+   (mapconcat
+    (lambda (ignore)
+      (when (string-match-p "/\\'" ignore)
+        (setq ignore (concat ignore "*")))
+      (if (string-match "\\`\\./" ignore)
+          (setq ignore (replace-match dir t t ignore))
+        (unless (string-prefix-p "*" ignore)
+          (setq ignore (concat "*/" ignore))))
+      (shell-quote-argument ignore))
+    ignores
+    " -o -path ")
+   " "
+   (shell-quote-argument ")")
+   " -prune -o "))
 
 (defun xref--regexp-to-extended (str)
   (replace-regexp-in-string