Merge from trunk

lisp/emacs-lisp/cl-loaddefs.el

@@ -282,7 +282,7 @@ Not documented
 ;;;;;;  do-all-symbols do-symbols dotimes dolist do* do loop return-from
 ;;;;;;  return block etypecase typecase ecase case load-time-value
 ;;;;;;  eval-when destructuring-bind function* defmacro* defun* gentemp
-;;;;;;  gensym) "cl-macs" "cl-macs.el" "8b2ce9c2ec0e273606bb37c333c4bdde")
+;;;;;;  gensym) "cl-macs" "cl-macs.el" "0904b956872432ae7cc5fa9abcefce63")
 ;;; Generated autoloads from cl-macs.el
 
 (autoload 'gensym "cl-macs" "\
@@ -389,7 +389,7 @@ This is equivalent to `(return-from nil RESULT)'.
 
 (autoload 'return-from "cl-macs" "\
 Return from the block named NAME.
-This jump out to the innermost enclosing `(block NAME ...)' form,
+This jumps out to the innermost enclosing `(block NAME ...)' form,
 returning RESULT from that form (or nil if RESULT is omitted).
 This is compatible with Common Lisp, but note that `defun' and
 `defmacro' do not create implicit blocks as they do in Common Lisp.

lisp/emacs-lisp/cl-macs.el

@@ -628,7 +628,7 @@ This is equivalent to `(return-from nil RESULT)'."
 ;;;###autoload
 (defmacro return-from (name &optional result)
   "Return from the block named NAME.
-This jump out to the innermost enclosing `(block NAME ...)' form,
+This jumps out to the innermost enclosing `(block NAME ...)' form,
 returning RESULT from that form (or nil if RESULT is omitted).
 This is compatible with Common Lisp, but note that `defun' and
 `defmacro' do not create implicit blocks as they do in Common Lisp."

lisp/emacs-lisp/cl-specs.el

@@ -67,7 +67,7 @@
 (def-edebug-spec multiple-value-list (form))
 (def-edebug-spec multiple-value-call (function-form body))
 (def-edebug-spec multiple-value-bind
-  ((&rest symbolp) form cl-declarations body))
+  ((&rest symbolp) form body))
 (def-edebug-spec multiple-value-setq ((&rest symbolp) form))
 (def-edebug-spec multiple-value-prog1 (form body))
 

lisp/emacs-lisp/edebug.el

@@ -3396,7 +3396,7 @@ go to the end of the last sexp, or if that is the same point, then step."
   ;; Return the function symbol, or nil if not instrumented.
   (let ((func-marker (get func 'edebug)))
     (cond
-     ((markerp func-marker)
+     ((and (markerp func-marker) (marker-buffer func-marker))
       ;; It is uninstrumented, so instrument it.
       (with-current-buffer (marker-buffer func-marker)
 	(goto-char func-marker)

lisp/emacs-lisp/elint.el

@@ -122,7 +122,6 @@ are as follows, and suppress messages about the indicated features:
   ;; FIXME I don't see why they shouldn't just get doc-strings.
   '(vc-mode local-write-file-hooks activate-menubar-hook buffer-name-history
 	    coding-system-history extended-command-history
-	    kbd-macro-termination-hook read-expression-history
 	    yes-or-no-p-history)
   "Standard variables, excluding `elint-builtin-variables'.
 These are variables that we cannot detect automatically for some reason.")

lisp/emacs-lisp/ert.el

@@ -1874,11 +1874,9 @@ BUFFER-NAME, if non-nil, is the buffer name to use."
   (unless buffer-name (setq buffer-name "*ert*"))
   (let ((buffer (get-buffer-create buffer-name)))
     (with-current-buffer buffer
-      (setq buffer-read-only t)
       (let ((inhibit-read-only t))
         (buffer-disable-undo)
         (erase-buffer)
-        (ert-results-mode)
         ;; Erase buffer again in case switching out of the previous
         ;; mode inserted anything.  (This happens e.g. when switching
         ;; from ert-results-mode to ert-results-mode when
@@ -1897,8 +1895,9 @@ BUFFER-NAME, if non-nil, is the buffer name to use."
                 (ewoc-enter-last ewoc
                                  (make-ert--ewoc-entry :test test :hidden-p t)))
           (ert--results-update-ewoc-hf ert--results-ewoc ert--results-stats)
-          (goto-char (1- (point-max)))
-          buffer)))))
+          (goto-char (1- (point-max)))))
+      (ert-results-mode)
+      buffer)))
 
 
 (defvar ert--selector-history nil
@@ -1997,19 +1996,12 @@ and how to display message."
 ;;; Simple view mode for auxiliary information like stack traces or
 ;;; messages.  Mainly binds "q" for quit.
 
-(define-derived-mode ert-simple-view-mode fundamental-mode "ERT-View"
+(define-derived-mode ert-simple-view-mode special-mode "ERT-View"
   "Major mode for viewing auxiliary information in ERT.")
 
-(loop for (key binding) in
-      '(("q" quit-window)
-        )
-      do
-      (define-key ert-simple-view-mode-map key binding))
-
-
 ;;; Commands and button actions for the results buffer.
 
-(define-derived-mode ert-results-mode fundamental-mode "ERT-Results"
+(define-derived-mode ert-results-mode special-mode "ERT-Results"
   "Major mode for viewing results of ERT test runs.")
 
 (loop for (key binding) in
@@ -2017,7 +2009,6 @@ and how to display message."
         ("\t" forward-button)
         ([backtab] backward-button)
         ("j" ert-results-jump-between-summary-and-result)
-        ("q" quit-window)
         ("L" ert-results-toggle-printer-limits-for-test-at-point)
         ("n" ert-results-next-test)
         ("p" ert-results-previous-test)
@@ -2349,11 +2340,9 @@ To be used in the ERT results buffer."
        (let ((backtrace (ert-test-result-with-condition-backtrace result))
              (buffer (get-buffer-create "*ERT Backtrace*")))
          (pop-to-buffer buffer)
-         (setq buffer-read-only t)
          (let ((inhibit-read-only t))
            (buffer-disable-undo)
            (erase-buffer)
-           (ert-simple-view-mode)
            ;; Use unibyte because `debugger-setup-buffer' also does so.
            (set-buffer-multibyte nil)
            (setq truncate-lines t)
@@ -2362,7 +2351,8 @@ To be used in the ERT results buffer."
            (goto-char (point-min))
            (insert "Backtrace for test `")
            (ert-insert-test-name-button (ert-test-name test))
-           (insert "':\n")))))))
+           (insert "':\n")
+           (ert-simple-view-mode)))))))
 
 (defun ert-results-pop-to-messages-for-test-at-point ()
   "Display the part of the *Messages* buffer generated during the test at point.
@@ -2375,16 +2365,15 @@ To be used in the ERT results buffer."
          (result (aref (ert--stats-test-results stats) pos)))
     (let ((buffer (get-buffer-create "*ERT Messages*")))
       (pop-to-buffer buffer)
-      (setq buffer-read-only t)
       (let ((inhibit-read-only t))
         (buffer-disable-undo)
         (erase-buffer)
-        (ert-simple-view-mode)
         (insert (ert-test-result-messages result))
         (goto-char (point-min))
         (insert "Messages for test `")
         (ert-insert-test-name-button (ert-test-name test))
-        (insert "':\n")))))
+        (insert "':\n")
+        (ert-simple-view-mode)))))
 
 (defun ert-results-pop-to-should-forms-for-test-at-point ()
   "Display the list of `should' forms executed during the test at point.
@@ -2397,11 +2386,9 @@ To be used in the ERT results buffer."
          (result (aref (ert--stats-test-results stats) pos)))
     (let ((buffer (get-buffer-create "*ERT list of should forms*")))
       (pop-to-buffer buffer)
-      (setq buffer-read-only t)
       (let ((inhibit-read-only t))
         (buffer-disable-undo)
         (erase-buffer)
-        (ert-simple-view-mode)
         (if (null (ert-test-result-should-forms result))
             (insert "\n(No should forms during this test.)\n")
           (loop for form-description in (ert-test-result-should-forms result)
@@ -2419,7 +2406,8 @@ To be used in the ERT results buffer."
         (insert (concat "(Values are shallow copies and may have "
                         "looked different during the test if they\n"
                         "have been modified destructively.)\n"))
-        (forward-line 1)))))
+        (forward-line 1)
+        (ert-simple-view-mode)))))
 
 (defun ert-results-toggle-printer-limits-for-test-at-point ()
   "Toggle how much of the condition to print for the test at point.
@@ -2451,11 +2439,9 @@ To be used in the ERT results buffer."
     (setq data (sort data (lambda (a b)
                             (> (second a) (second b)))))
     (pop-to-buffer buffer)
-    (setq buffer-read-only t)
     (let ((inhibit-read-only t))
       (buffer-disable-undo)
       (erase-buffer)
-      (ert-simple-view-mode)
       (if (null data)
           (insert "(No data)\n")
         (insert (format "%-3s  %8s %8s\n" "" "time" "cumul"))
@@ -2468,7 +2454,8 @@ To be used in the ERT results buffer."
                 (insert "\n"))))
       (goto-char (point-min))
       (insert "Tests by run time (seconds):\n\n")
-      (forward-line 1))))
+      (forward-line 1)
+      (ert-simple-view-mode))))
 
 ;;;###autoload
 (defun ert-describe-test (test-or-test-name)

lisp/emacs-lisp/package.el

@@ -1213,18 +1213,16 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
 ;;;; Package menu mode.
 
 (defvar package-menu-mode-map
-  (let ((map (make-keymap))
+  (let ((map (copy-keymap special-mode-map))
 	(menu-map (make-sparse-keymap "Package")))
     (set-keymap-parent map button-buffer-map)
     (define-key map "\C-m" 'package-menu-describe-package)
-    (define-key map "q" 'quit-window)
     (define-key map "n" 'next-line)
     (define-key map "p" 'previous-line)
     (define-key map "u" 'package-menu-mark-unmark)
     (define-key map "\177" 'package-menu-backup-unmark)
     (define-key map "d" 'package-menu-mark-delete)
     (define-key map "i" 'package-menu-mark-install)
-    (define-key map "g" 'revert-buffer)
     (define-key map "r" 'package-menu-refresh)
     (define-key map "~" 'package-menu-mark-obsolete-for-deletion)
     (define-key map "x" 'package-menu-execute)
@@ -1290,15 +1288,11 @@ If optional arg NO-ACTIVATE is non-nil, don't activate packages."
 
 (put 'package-menu-mode 'mode-class 'special)
 
-(defun package-menu-mode ()
+(define-derived-mode package-menu-mode special-mode "Package Menu"
   "Major mode for browsing a list of packages.
 Letters do not insert themselves; instead, they are commands.
 \\<package-menu-mode-map>
 \\{package-menu-mode-map}"
-  (kill-all-local-variables)
-  (use-local-map package-menu-mode-map)
-  (setq major-mode 'package-menu-mode)
-  (setq mode-name "Package Menu")
   (setq truncate-lines t)
   (setq buffer-read-only t)
   (set (make-local-variable 'revert-buffer-function) 'package-menu-revert)
@@ -1326,8 +1320,7 @@ Letters do not insert themselves; instead, they are commands.
 	   (20 . "Version")
 	   (32 . "Status")
 	   (43 . "Description"))
-	 ""))
-  (run-mode-hooks 'package-menu-mode-hook))
+	 "")))
 
 (defun package-menu-refresh ()
   "Download the Emacs Lisp package archive.
@@ -1665,10 +1658,10 @@ list; the default is to display everything in `package-alist'."
   (require 'finder-inf nil t)
   (let ((buf (get-buffer-create "*Packages*")))
     (with-current-buffer buf
-      (package-menu-mode)
       (set (make-local-variable 'package-menu-package-list) packages)
       (set (make-local-variable 'package-menu-sort-key) nil)
-      (package--generate-package-list))
+      (package--generate-package-list)
+      (package-menu-mode))
     ;; The package menu buffer has keybindings.  If the user types
     ;; `M-x list-packages', that suggests it should become current.
     (switch-to-buffer buf)))

lisp/emacs-lisp/re-builder.el

@@ -275,6 +275,13 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
   (set (make-local-variable 'blink-matching-paren) nil)
   (reb-mode-common))
 
+(defvar reb-lisp-mode-map
+  (let ((map (make-sparse-keymap)))
+    ;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from
+    ;; `emacs-lisp-mode'
+    (define-key map "\C-c" (lookup-key reb-mode-map "\C-c"))
+    map))
+
 (define-derived-mode reb-lisp-mode
   emacs-lisp-mode "RE Builder Lisp"
   "Major mode for interactively building symbolic Regular Expressions."
@@ -283,11 +290,6 @@ Except for Lisp syntax this is the same as `reb-regexp'.")
 	 (require 'rx)))                   ; require rx anyway
   (reb-mode-common))
 
-;; Use the same "\C-c" keymap as `reb-mode' and use font-locking from
-;; `emacs-lisp-mode'
-(define-key reb-lisp-mode-map "\C-c"
-  (lookup-key reb-mode-map "\C-c"))
-
 (defvar reb-subexp-mode-map
   (let ((m (make-keymap)))
     (suppress-keymap m)

lisp/emacs-lisp/shadow.el

@@ -115,7 +115,7 @@ See the documentation for `list-load-path-shadows' for further information."
 	  ;; FILE now contains the current file name, with no suffix.
 	  (unless (or (member file files-seen-this-dir)
 		      ;; Ignore these files.
-		      (member file '("subdirs")))
+		      (member file '("subdirs" "leim-list")))
 	    ;; File has not been seen yet in this directory.
 	    ;; This test prevents us declaring that XXX.el shadows
 	    ;; XXX.elc (or vice-versa) when they are in the same directory.

lisp/emacs-lisp/smie.el

@@ -915,7 +915,7 @@ This uses SMIE's tables and is expected to be placed on `post-self-insert-hook'.
                      ;; anything else than this trigger char, lest we'd blink
                      ;; both when inserting the trigger char and when
                      ;; inserting a subsequent trigger char like SPC.
-                     (or (eq (point) pos)
+                     (or (eq (char-before) last-command-event)
                          (not (memq (char-before)
                                     smie-blink-matching-triggers)))
                      (or smie-blink-matching-inners
@@ -998,7 +998,10 @@ the beginning of a line."
           (unless (numberp (cadr (assoc tok smie-grammar)))
             (goto-char pos))
           (setq smie--parent
-                (smie-backward-sexp 'halfsexp))))))
+                (or (smie-backward-sexp 'halfsexp)
+                    (let (res)
+                      (while (null (setq res (smie-backward-sexp))))
+                      (list nil (point) (nth 2 res)))))))))
 
 (defun smie-rule-parent-p (&rest parents)
   "Return non-nil if the current token's parent is among PARENTS.
@@ -1403,6 +1406,10 @@ should not be computed on the basis of the following token."
   (and (nth 4 (syntax-ppss))
        'noindent))
 
+(defun smie-indent-inside-string ()
+  (and (nth 3 (syntax-ppss))
+       'noindent))
+
 (defun smie-indent-after-keyword ()
   ;; Indentation right after a special keyword.
   (save-excursion
@@ -1476,8 +1483,9 @@ should not be computed on the basis of the following token."
 
 (defvar smie-indent-functions
   '(smie-indent-fixindent smie-indent-bob smie-indent-close
-                          smie-indent-comment smie-indent-comment-continue smie-indent-comment-close
-                          smie-indent-comment-inside smie-indent-keyword smie-indent-after-keyword
+    smie-indent-comment smie-indent-comment-continue smie-indent-comment-close
+    smie-indent-comment-inside smie-indent-inside-string
+    smie-indent-keyword smie-indent-after-keyword
                           smie-indent-exps)
   "Functions to compute the indentation.
 Each function is called with no argument, shouldn't move point, and should