Merge from origin/emacs-25

b787d55 More format-time-string change fixups
13c8f29 make-xwidget unused arg cleanup
36e05f0 Remove unused arguments from make-xwidget
1042217 Document incompatible changes in 'format-time-string'
7228eb8 Improve documentation of byte-code objects
0020047 Adapt calls to 'format-time-string' to changes in Emacs 25
17b5152 Improve vc-diff with Git backend
c28f87a (js--continued-expression-p): Special-case unary plus and minus
2d02a5f ; * lisp/vc/vc-annotate.el (vc-annotate): Clarify commentary.
9151f16 Prevent C++ Mode wrongly fontifying some identifiers near tem...
b3b523c Avoid crashes due to insanely large columns in tabulated-list...
a3daa34 Teach M-x disassemble a default argument.
e30c3e9 Fix EOL decoding in vc-annotate with SVN back-end on MS-Windows
df441b3 Fix OS X specific settings in tramp-tests
2244331 Finish fixing a cacheing bug in CC Mode (see 2016-03-09)

# Conflicts:
#	lisp/net/tramp-sh.el
#	lisp/progmodes/cc-engine.el

14 files changed, 257 insertions, 186 deletions

diff --git a/lisp/emacs-lisp/disass.el b/lisp/emacs-lisp/disass.el
index e67b0220e14..8506ed69669 100644
--- a/lisp/emacs-lisp/disass.el
+++ b/lisp/emacs-lisp/disass.el
@@ -54,9 +54,13 @@ OBJECT can be a symbol defined as a function, or a function itself
 \(a lambda expression or a compiled-function object).
 If OBJECT is not already compiled, we compile it, but do not
 redefine OBJECT if it is a symbol."
-  (interactive (list (intern (completing-read "Disassemble function: "
-                                              obarray 'fboundp t))
-                     nil 0 t))
+  (interactive
+   (let* ((fn (function-called-at-point))
+          (prompt (if fn (format "Disassemble function (default %s): " fn)
+                    "Disassemble function: "))
+          (def (and fn (symbol-name fn))))
+     (list (intern (completing-read prompt obarray 'fboundp t nil nil def))
+           nil 0 t)))
   (if (and (consp object) (not (functionp object)))
       (setq object `(lambda () ,object)))
   (or indent (setq indent 0))           ;Default indent to zero
diff --git a/lisp/gnus/gmm-utils.el b/lisp/gnus/gmm-utils.el
index 785a286c915..f6455cf9f1a 100644
--- a/lisp/gnus/gmm-utils.el
+++ b/lisp/gnus/gmm-utils.el
@@ -286,7 +286,7 @@ specifiers `%Z' and `%z' will be replaced with a numeric form. "
           (setq st nd))
         (push (substring format-string st) rest)
         (format-time-string (apply 'concat (nreverse rest)) time))
-    (format-time-string format-string time tz)))
+    (format-time-string format-string time t)))
 
 (provide 'gmm-utils)
 
diff --git a/lisp/net/tramp.el b/lisp/net/tramp.el
index 4edca5a5998..e101c42a494 100644
--- a/lisp/net/tramp.el
+++ b/lisp/net/tramp.el
@@ -3764,6 +3764,26 @@ This is used internally by `tramp-file-mode-from-int'."
       (when vec (tramp-message vec 7 "locale %s" (or locale "C")))
       (or locale "C"))))
 
+(defun tramp-get-local-locale (&optional vec)
+  ;; We use key nil for local connection properties.
+  (with-tramp-connection-property nil "locale"
+    (let ((candidates '("en_US.utf8" "C.utf8" "en_US.UTF-8"))
+          locale)
+      (with-temp-buffer
+        (unless (or (memq system-type '(windows-nt))
+                    (not (zerop (tramp-call-process
+                                 nil "locale" nil t nil "-a"))))
+          (while candidates
+            (goto-char (point-min))
+            (if (string-match (format "^%s\r?$" (regexp-quote (car candidates)))
+                              (buffer-string))
+                (setq locale (car candidates)
+                      candidates nil)
+              (setq candidates (cdr candidates))))))
+      ;; Return value.
+      (when vec (tramp-message vec 7 "locale %s" (or locale "C")))
+      (or locale "C"))))
+
 ;;;###tramp-autoload
 (defun tramp-check-cached-permissions (vec access)
   "Check `file-attributes' caches for VEC.
diff --git a/lisp/org/org.el b/lisp/org/org.el
index 6e7d54d39c0..d2b48a64e45 100644
--- a/lisp/org/org.el
+++ b/lisp/org/org.el
@@ -22663,7 +22663,7 @@ contains commented lines.  Otherwise, comment them."
   "Non-nil when TIMESTAMP has a time specified."
   (org-element-property :hour-start timestamp))
 
-(defun org-timestamp-format (timestamp format &optional end utc)
+(defun org-timestamp-format (timestamp format &optional end zone)
   "Format a TIMESTAMP element into a string.
 
 FORMAT is a format specifier to be passed to
@@ -22672,8 +22672,9 @@ FORMAT is a format specifier to be passed to
 When optional argument END is non-nil, use end of date-range or
 time-range, if possible.
 
-When optional argument UTC is non-nil, time will be expressed as
-Universal Time."
+The optional ZONE is omitted or nil for Emacs local time, t for
+Universal Time, `wall' for system wall clock time, or a string as in
+`set-time-zone-rule' for a time zone rule."
   (format-time-string
    format
    (apply 'encode-time
@@ -22683,7 +22684,7 @@ Universal Time."
                  (if end '(:minute-end :hour-end :day-end :month-end :year-end)
                    '(:minute-start :hour-start :day-start :month-start
                                    :year-start)))))
-   utc))
+   zone))
 
 (defun org-timestamp-split-range (timestamp &optional end)
   "Extract a timestamp object from a date or time range.
diff --git a/lisp/org/ox-icalendar.el b/lisp/org/ox-icalendar.el
index 0d34ba19f45..cd54d1ee8de 100644
--- a/lisp/org/ox-icalendar.el
+++ b/lisp/org/ox-icalendar.el
@@ -393,7 +393,8 @@ Universal Time, ignoring `org-icalendar-date-time-format'."
       ;; Convert timestamp into internal time in order to use
       ;; `format-time-string' and fix any mistake (i.e. MI >= 60).
       (encode-time 0 mi h d m y)
-      (or utc (and with-time-p (org-icalendar-use-UTC-date-time-p)))))))
+      (not (not (or utc (and with-time-p
+                             (org-icalendar-use-UTC-date-time-p)))))))))
 
 (defun org-icalendar-dtstamp ()
   "Return DTSTAMP property, as a string."
diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 764f44a8dd8..59f2729c43d 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1594,70 +1594,69 @@ defun."
       (c-region-is-active-p)
       (push-mark))
 
-  (c-self-bind-state-cache ; We must not share with other users of c-state-cache.
-   (c-save-buffer-state
-       (beginning-of-defun-function
-        end-of-defun-function
-        (start (point))
-        (paren-state (c-parse-state))
-        (orig-point-min (point-min)) (orig-point-max (point-max))
-        lim                 ; Position of { which has been widened to.
-        where pos case-fold-search)
-
-     (save-restriction
-       (if (eq c-defun-tactic 'go-outward)
-           (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace.
-                      paren-state orig-point-min orig-point-max)))
-
-       ;; Move back out of any macro/comment/string we happen to be in.
-       (c-beginning-of-macro)
-       (setq pos (c-literal-limits))
-       (if pos (goto-char (car pos)))
-
-       (setq where (c-where-wrt-brace-construct))
-
-       (if (< arg 0)
-           ;; Move forward to the closing brace of a function.
-           (progn
-             (if (memq where '(at-function-end outwith-function))
-                 (setq arg (1+ arg)))
-             (if (< arg 0)
-                 (c-while-widening-to-decl-block
-                  (< (setq arg (- (c-forward-to-nth-EOF-} (- arg) where))) 0)))
-             ;; Move forward to the next opening brace....
-             (when (and (= arg 0)
-                        (progn
-                          (c-while-widening-to-decl-block
-                           (not (c-syntactic-re-search-forward "{" nil 'eob)))
-                          (eq (char-before) ?{)))
-               (backward-char)
-               ;; ... and backward to the function header.
-               (c-beginning-of-decl-1)
-               t))
-
-         ;; Move backward to the opening brace of a function, making successively
-         ;; larger portions of the buffer visible as necessary.
-         (when (> arg 0)
-           (c-while-widening-to-decl-block
-            (> (setq arg (c-backward-to-nth-BOF-{ arg where)) 0)))
-
-         (when (eq arg 0)
-           ;; Go backward to this function's header.
-           (c-beginning-of-decl-1)
-
-           (setq pos (point))
-           ;; We're now there, modulo comments and whitespace.
-           ;; Try to be line oriented; position point at the closest
-           ;; preceding boi that isn't inside a comment, but if we hit
-           ;; the previous declaration then we use the current point
-           ;; instead.
-           (while (and (/= (point) (c-point 'boi))
-                       (c-backward-single-comment)))
-           (if (/= (point) (c-point 'boi))
-               (goto-char pos)))
-
-         (c-keep-region-active)
-         (= arg 0))))))
+  (c-save-buffer-state
+      (beginning-of-defun-function
+       end-of-defun-function
+       (start (point))
+       (paren-state (c-parse-state))
+       (orig-point-min (point-min)) (orig-point-max (point-max))
+       lim                  ; Position of { which has been widened to.
+       where pos case-fold-search)
+
+    (save-restriction
+      (if (eq c-defun-tactic 'go-outward)
+          (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace.
+                     paren-state orig-point-min orig-point-max)))
+
+      ;; Move back out of any macro/comment/string we happen to be in.
+      (c-beginning-of-macro)
+      (setq pos (c-literal-limits))
+      (if pos (goto-char (car pos)))
+
+      (setq where (c-where-wrt-brace-construct))
+
+      (if (< arg 0)
+          ;; Move forward to the closing brace of a function.
+          (progn
+            (if (memq where '(at-function-end outwith-function))
+                (setq arg (1+ arg)))
+            (if (< arg 0)
+                (c-while-widening-to-decl-block
+                 (< (setq arg (- (c-forward-to-nth-EOF-} (- arg) where))) 0)))
+            ;; Move forward to the next opening brace....
+            (when (and (= arg 0)
+                       (progn
+                         (c-while-widening-to-decl-block
+                          (not (c-syntactic-re-search-forward "{" nil 'eob)))
+                         (eq (char-before) ?{)))
+              (backward-char)
+              ;; ... and backward to the function header.
+              (c-beginning-of-decl-1)
+              t))
+
+        ;; Move backward to the opening brace of a function, making successively
+        ;; larger portions of the buffer visible as necessary.
+        (when (> arg 0)
+          (c-while-widening-to-decl-block
+           (> (setq arg (c-backward-to-nth-BOF-{ arg where)) 0)))
+
+        (when (eq arg 0)
+          ;; Go backward to this function's header.
+          (c-beginning-of-decl-1)
+
+          (setq pos (point))
+          ;; We're now there, modulo comments and whitespace.
+          ;; Try to be line oriented; position point at the closest
+          ;; preceding boi that isn't inside a comment, but if we hit
+          ;; the previous declaration then we use the current point
+          ;; instead.
+          (while (and (/= (point) (c-point 'boi))
+                      (c-backward-single-comment)))
+          (if (/= (point) (c-point 'boi))
+              (goto-char pos)))
+
+        (c-keep-region-active)
+        (= arg 0)))))
 
 (defun c-forward-to-nth-EOF-} (n where)
   ;; Skip to the closing brace of the Nth function after point.  If
@@ -1719,68 +1718,66 @@ the open-parenthesis that starts a defun; see `beginning-of-defun'."
       (c-region-is-active-p)
       (push-mark))
 
-  (c-self-bind-state-cache ; c-state-cache's list structure must not be shared
-                           ; with other users.
-   (c-save-buffer-state
-       (beginning-of-defun-function
-        end-of-defun-function
-        (start (point))
-        (paren-state (c-parse-state))
-        (orig-point-min (point-min)) (orig-point-max (point-max))
-        lim
-        where pos case-fold-search)
-
-     (save-restriction
-       (if (eq c-defun-tactic 'go-outward)
-           (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace
-                      paren-state orig-point-min orig-point-max)))
-
-       ;; Move back out of any macro/comment/string we happen to be in.
-       (c-beginning-of-macro)
-       (setq pos (c-literal-limits))
-       (if pos (goto-char (car pos)))
-
-       (setq where (c-where-wrt-brace-construct))
-
-       (if (< arg 0)
-           ;; Move backwards to the } of a function
-           (progn
-             (if (memq where '(at-header outwith-function))
-                 (setq arg (1+ arg)))
-             (if (< arg 0)
-                 (c-while-widening-to-decl-block
-                  (< (setq arg (- (c-backward-to-nth-BOF-{ (- arg) where))) 0)))
-             (if (= arg 0)
-                 (c-while-widening-to-decl-block
-                  (progn (c-syntactic-skip-backward "^}")
-                         (not (eq (char-before) ?}))))))
-
-         ;; Move forward to the } of a function
-         (if (> arg 0)
-             (c-while-widening-to-decl-block
-              (> (setq arg (c-forward-to-nth-EOF-} arg where)) 0))))
-
-       ;; Do we need to move forward from the brace to the semicolon?
-       (when (eq arg 0)
-         (if (c-in-function-trailer-p)  ; after "}" of struct/enum, etc.
-             (c-syntactic-re-search-forward ";"))
+  (c-save-buffer-state
+      (beginning-of-defun-function
+       end-of-defun-function
+       (start (point))
+       (paren-state (c-parse-state))
+       (orig-point-min (point-min)) (orig-point-max (point-max))
+       lim
+       where pos case-fold-search)
 
-         (setq pos (point))
-         ;; We're there now, modulo comments and whitespace.
-         ;; Try to be line oriented; position point after the next
-         ;; newline that isn't inside a comment, but if we hit the
-         ;; next declaration then we use the current point instead.
-         (while (and (not (bolp))
-                     (not (looking-at "\\s *$"))
-                     (c-forward-single-comment)))
-         (cond ((bolp))
-               ((looking-at "\\s *$")
-                (forward-line 1))
-               (t
-                (goto-char pos))))
+    (save-restriction
+      (if (eq c-defun-tactic 'go-outward)
+          (setq lim (c-widen-to-enclosing-decl-scope ; e.g. class, namespace
+                     paren-state orig-point-min orig-point-max)))
 
-       (c-keep-region-active)
-       (= arg 0)))))
+      ;; Move back out of any macro/comment/string we happen to be in.
+      (c-beginning-of-macro)
+      (setq pos (c-literal-limits))
+      (if pos (goto-char (car pos)))
+
+      (setq where (c-where-wrt-brace-construct))
+
+      (if (< arg 0)
+          ;; Move backwards to the } of a function
+          (progn
+            (if (memq where '(at-header outwith-function))
+                (setq arg (1+ arg)))
+            (if (< arg 0)
+                (c-while-widening-to-decl-block
+                 (< (setq arg (- (c-backward-to-nth-BOF-{ (- arg) where))) 0)))
+            (if (= arg 0)
+                (c-while-widening-to-decl-block
+                 (progn (c-syntactic-skip-backward "^}")
+                        (not (eq (char-before) ?}))))))
+
+        ;; Move forward to the } of a function
+        (if (> arg 0)
+            (c-while-widening-to-decl-block
+             (> (setq arg (c-forward-to-nth-EOF-} arg where)) 0))))
+
+      ;; Do we need to move forward from the brace to the semicolon?
+      (when (eq arg 0)
+        (if (c-in-function-trailer-p)   ; after "}" of struct/enum, etc.
+            (c-syntactic-re-search-forward ";"))
+
+        (setq pos (point))
+        ;; We're there now, modulo comments and whitespace.
+        ;; Try to be line oriented; position point after the next
+        ;; newline that isn't inside a comment, but if we hit the
+        ;; next declaration then we use the current point instead.
+        (while (and (not (bolp))
+                    (not (looking-at "\\s *$"))
+                    (c-forward-single-comment)))
+        (cond ((bolp))
+              ((looking-at "\\s *$")
+               (forward-line 1))
+              (t
+               (goto-char pos))))
+
+      (c-keep-region-active)
+      (= arg 0))))
 
 (defun c-defun-name ()
   "Return the name of the current defun, or NIL if there isn't one.
diff --git a/lisp/progmodes/cc-defs.el b/lisp/progmodes/cc-defs.el
index ba15d7f13e0..64e57017174 100644
--- a/lisp/progmodes/cc-defs.el
+++ b/lisp/progmodes/cc-defs.el
@@ -1402,25 +1402,41 @@ been put there by c-put-char-property.  POINT remains unchanged."
          (c-set-cpp-delimiters ,beg ,end)))))
 
 (defmacro c-self-bind-state-cache (&rest forms)
-  ;; Bind the state cache to itself and execute the FORMS.  It is assumed that no
-  ;; buffer changes will happen in FORMS, and no hidden buffer changes which could
-  ;; affect the parsing will be made by FORMS.
-  `(let ((c-state-cache (copy-tree c-state-cache))
-         (c-state-cache-good-pos c-state-cache-good-pos)
-         ;(c-state-nonlit-pos-cache (copy-tree c-state-nonlit-pos-cache))
-         ;(c-state-nonlit-pos-cache-limit c-state-nonlit-pos-cache-limit)
-         ;(c-state-semi-nonlit-pos-cache (copy-tree c-state-semi-nonlit-pos-cache))
-         ;(c-state-semi-nonlit-pos-cache-limit c-state-semi-nonlit-pos-cache)
-         (c-state-brace-pair-desert (copy-tree c-state-brace-pair-desert))
-         (c-state-point-min c-state-point-min)
-         (c-state-point-min-lit-type c-state-point-min-lit-type)
-         (c-state-point-min-lit-start c-state-point-min-lit-start)
-         (c-state-min-scan-pos c-state-min-scan-pos)
-         (c-state-old-cpp-beg c-state-old-cpp-beg)
-         (c-state-old-cpp-end c-state-old-cpp-end))
-     ,@forms))
+  ;; Bind the state cache to itself and execute the FORMS.  Return the result
+  ;; of the last FORM executed.  It is assumed that no buffer changes will
+  ;; happen in FORMS, and no hidden buffer changes which could affect the
+  ;; parsing will be made by FORMS.
+  `(let* ((c-state-cache (copy-tree c-state-cache))
+          (c-state-cache-good-pos c-state-cache-good-pos)
+          ;(c-state-nonlit-pos-cache (copy-tree c-state-nonlit-pos-cache))
+          ;(c-state-nonlit-pos-cache-limit c-state-nonlit-pos-cache-limit)
+          ;(c-state-semi-nonlit-pos-cache (copy-tree c-state-semi-nonlit-pos-cache))
+          ;(c-state-semi-nonlit-pos-cache-limit c-state-semi-nonlit-pos-cache)
+          (c-state-brace-pair-desert (copy-tree c-state-brace-pair-desert))
+          (c-state-point-min c-state-point-min)
+          (c-state-point-min-lit-type c-state-point-min-lit-type)
+          (c-state-point-min-lit-start c-state-point-min-lit-start)
+          (c-state-min-scan-pos c-state-min-scan-pos)
+          (c-state-old-cpp-beg-marker (if (markerp c-state-old-cpp-beg-marker)
+                                          (copy-marker c-state-old-cpp-beg-marker)
+                                        c-state-old-cpp-beg-marker))
+          (c-state-old-cpp-beg (if (markerp c-state-old-cpp-beg)
+                                   c-state-old-cpp-beg-marker
+                                 c-state-old-cpp-beg))
+          (c-state-old-cpp-end-marker (if (markerp c-state-old-cpp-end-marker)
+                                          (copy-marker c-state-old-cpp-end-marker)
+                                        c-state-old-cpp-end-marker))
+          (c-state-old-cpp-end (if (markerp c-state-old-cpp-end)
+                                   c-state-old-cpp-end-marker
+                                 c-state-old-cpp-end))
+          (c-parse-state-state c-parse-state-state))
+     (prog1
+         (progn ,@forms)
+       (if (markerp c-state-old-cpp-beg-marker)
+           (move-marker c-state-old-cpp-beg-marker nil))
+       (if (markerp c-state-old-cpp-end-marker)
+           (move-marker c-state-old-cpp-end-marker nil)))))
 
-
 ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
 ;; The following macros are to be used only in `c-parse-state' and its
 ;; subroutines.  Their main purpose is to simplify the handling of C++/Java
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index e04929a7226..4aff0dc14e0 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -3501,6 +3501,9 @@ comment at the start of cc-engine.el for more info."
 (make-variable-buffer-local 'c-parse-state-state)
 (defun c-record-parse-state-state ()
   (setq c-parse-state-point (point))
+  (when (markerp (cdr (assq 'c-state-old-cpp-beg c-parse-state-state)))
+    (move-marker (cdr (assq 'c-state-old-cpp-beg c-parse-state-state)) nil)
+    (move-marker (cdr (assq 'c-state-old-cpp-end c-parse-state-state)) nil))
   (setq c-parse-state-state
         (mapcar
          (lambda (arg)
@@ -5841,10 +5844,11 @@ comment at the start of cc-engine.el for more info."
                     ((and c-opt-cpp-prefix
                           (looking-at c-noise-macro-with-parens-name-re))
                      (c-forward-noise-clause)))))
-     (when (memq res '(t known found prefix))
-       ,(when (eq type 'ref)
-          `(when c-record-type-identifiers
-             (c-record-ref-id c-last-identifier-range)))
+     (when (memq res '(t known found prefix maybe))
+       (when c-record-type-identifiers
+        ,(if (eq type 'type)
+             `(c-record-type-id c-last-identifier-range)
+           `(c-record-ref-id c-last-identifier-range)))
        t)))
 
 (defmacro c-forward-id-comma-list (type update-safe-pos)
@@ -6411,13 +6415,15 @@ comment at the start of cc-engine.el for more info."
                     (eq (char-after) ?<))
                ;; Maybe an angle bracket arglist.
                (when (let ((c-record-type-identifiers t)
-                           (c-record-found-types t))
+                           (c-record-found-types t)
+                           (c-last-identifier-range))
                        (c-forward-<>-arglist nil))
 
-                 (c-add-type start (1+ pos))
                  (c-forward-syntactic-ws)
-                 (setq pos (point)
-                       c-last-identifier-range nil)
+                 (unless (eq (char-after) ?\()
+                   (setq c-last-identifier-range nil)
+                   (c-add-type start (1+ pos)))
+                 (setq pos (point))
 
                  (if (and c-opt-identifier-concat-key
                           (looking-at c-opt-identifier-concat-key))
@@ -6431,7 +6437,8 @@ comment at the start of cc-engine.el for more info."
                        (c-forward-syntactic-ws)
                        t)
 
-                   (when (and c-record-type-identifiers id-start)
+                   (when (and c-record-type-identifiers id-start
+                              (not (eq (char-after) ?\()))
                      (c-record-type-id (cons id-start id-end)))
                    (setq res 'template)
                    nil)))
@@ -6613,9 +6620,18 @@ comment at the start of cc-engine.el for more info."
                            ;; It's an identifier that might be a type.
                            'maybe))))
             ((eq name-res 'template)
-             ;; A template is a type.
+             ;; A template is sometimes a type.
              (goto-char id-end)
-             (setq res t))
+             (c-forward-syntactic-ws)
+             (setq res
+                   (if (eq (char-after) ?\()
+                       (if (c-check-type id-start id-end)
+                           ;; It's an identifier that has been used as
+                           ;; a type somewhere else.
+                           'found
+                         ;; It's an identifier that might be a type.
+                         'maybe)
+                     t)))
             (t
              ;; Otherwise it's an operator identifier, which is not a type.
              (goto-char start)
diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 67e88a34bf9..e171b20f328 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -914,7 +914,7 @@ casts and declarations are fontified.  Used on level 2 and higher."
   ;;
   ;; Fontify types and references in names containing angle bracket
   ;; arglists from the point to LIMIT.  Note that
-  ;; `c-font-lock-declarations' already has handled many of them.
+  ;; `c-font-lock-declarations' has already handled many of them.
   ;;
   ;; This function might do hidden buffer changes.
 
@@ -976,11 +976,12 @@ casts and declarations are fontified.  Used on level 2 and higher."
                     (when (and c-opt-identifier-concat-key
                                (not (get-text-property id-start 'face)))
                       (c-forward-syntactic-ws)
-                      (if (looking-at c-opt-identifier-concat-key)
-                          (c-put-font-lock-face id-start id-end
-                                                c-reference-face-name)
-                        (c-put-font-lock-face id-start id-end
-                                              'font-lock-type-face)))))
+                      (cond ((looking-at c-opt-identifier-concat-key)
+                             (c-put-font-lock-face id-start id-end
+                                                c-reference-face-name))
+                            ((eq (char-after) ?\())
+                            (t (c-put-font-lock-face id-start id-end
+                                              'font-lock-type-face))))))
 
                 (goto-char pos)))
           (goto-char pos)))))
diff --git a/lisp/progmodes/js.el b/lisp/progmodes/js.el
index 15a52ba8cdc..8c93ffa8731 100644
--- a/lisp/progmodes/js.el
+++ b/lisp/progmodes/js.el
@@ -1770,16 +1770,20 @@ This performs fontification according to `js--class-styles'."
   "Return non-nil if the current line continues an expression."
   (save-excursion
     (back-to-indentation)
-    (or (js--looking-at-operator-p)
-        (and (js--re-search-backward "\n" nil t)
-             (progn
-               (skip-chars-backward " \t")
-               (or (bobp) (backward-char))
-               (and (> (point) (point-min))
-                    (save-excursion (backward-char) (not (looking-at "[/*]/")))
-                    (js--looking-at-operator-p)
-                    (and (progn (backward-char)
-                                (not (looking-at "+\\+\\|--\\|/[/*]"))))))))))
+    (if (js--looking-at-operator-p)
+        (or (not (memq (char-after) '(?- ?+)))
+            (progn
+              (forward-comment (- (point)))
+              (not (memq (char-before) '(?, ?\[ ?\()))))
+      (and (js--re-search-backward "\n" nil t)
+           (progn
+             (skip-chars-backward " \t")
+             (or (bobp) (backward-char))
+             (and (> (point) (point-min))
+                  (save-excursion (backward-char) (not (looking-at "[/*]/")))
+                  (js--looking-at-operator-p)
+                  (and (progn (backward-char)
+                              (not (looking-at "+\\+\\|--\\|/[/*]"))))))))))
 
 
 (defun js--end-of-do-while-loop-p ()
diff --git a/lisp/vc/pcvs-info.el b/lisp/vc/pcvs-info.el
index 1abc7729045..b9ecc892540 100644
--- a/lisp/vc/pcvs-info.el
+++ b/lisp/vc/pcvs-info.el
@@ -465,7 +465,7 @@ DIR can also be a file."
                ((equal date "Result of merge") (setq subtype 'MERGED))
                ((let ((mtime (nth 5 (file-attributes (concat dir f))))
                       (system-time-locale "C"))
-                  (setq timestamp (format-time-string "%c" mtime 'utc))
+                  (setq timestamp (format-time-string "%c" mtime t))
                   ;; Solaris sometimes uses "Wed Sep 05", not "Wed Sep  5".
                   ;; See "grep '[^a-z_]ctime' cvs/src/*.c" for reference.
                   (if (= (aref timestamp 8) ?0)
diff --git a/lisp/vc/vc-annotate.el b/lisp/vc/vc-annotate.el
index ed038f1d4e5..774453f8b54 100644
--- a/lisp/vc/vc-annotate.el
+++ b/lisp/vc/vc-annotate.el
@@ -432,6 +432,15 @@ should be applied to the background or to the foreground."
     (with-output-to-temp-buffer temp-buffer-name
       (let ((backend (or vc-bk (vc-backend file)))
             (coding-system-for-read buffer-file-coding-system))
+        ;; For a VC backend running on DOS/Windows, it's normal to
+        ;; produce CRLF EOLs even if the original file has Unix EOLs,
+        ;; which will show ^M characters in the Annotate buffer.  (One
+        ;; known case in point is "svn annotate".)  Prevent that by
+        ;; forcing DOS EOL decoding.
+        (if (memq system-type '(windows-nt ms-dos))
+            (setq coding-system-for-read
+                  (coding-system-change-eol-conversion coding-system-for-read
+                                                       'dos)))
         (vc-call-backend backend 'annotate-command file
                          (get-buffer temp-buffer-name) rev)
         ;; we must setup the mode first, and then set our local
diff --git a/lisp/vc/vc-git.el b/lisp/vc/vc-git.el
index 8498cc82761..f2466d86493 100644
--- a/lisp/vc/vc-git.el
+++ b/lisp/vc/vc-git.el
@@ -853,7 +853,8 @@ If SHORTLOG is non-nil, use a short format based on `vc-git-root-log-format'.
 \(This requires at least Git version 1.5.6, for the --graph option.)
 If START-REVISION is non-nil, it is the newest revision to show.
 If LIMIT is non-nil, show no more than this many entries."
-  (let ((coding-system-for-read vc-git-commits-coding-system))
+  (let ((coding-system-for-read
+         (or coding-system-for-read vc-git-commits-coding-system)))
     ;; `vc-do-command' creates the buffer, but we need it before running
     ;; the command.
     (vc-setup-buffer buffer)
@@ -1387,8 +1388,10 @@ This command shares argument histories with \\[rgrep] and \\[grep]."
   "A wrapper around `vc-do-command' for use in vc-git.el.
 The difference to vc-do-command is that this function always invokes
 `vc-git-program'."
-  (let ((coding-system-for-read vc-git-commits-coding-system)
-        (coding-system-for-write vc-git-commits-coding-system))
+  (let ((coding-system-for-read
+         (or coding-system-for-read vc-git-commits-coding-system))
+        (coding-system-for-write
+         (or coding-system-for-write vc-git-commits-coding-system)))
     (apply 'vc-do-command (or buffer "*vc*") okstatus vc-git-program
            ;; http://debbugs.gnu.org/16897
            (unless (and (not (cdr-safe file-or-list))
diff --git a/lisp/xwidget.el b/lisp/xwidget.el
index cd8ec0ec29d..19f631f17f3 100644
--- a/lisp/xwidget.el
+++ b/lisp/xwidget.el
@@ -42,7 +42,7 @@ The possible values are: `native' or `image'."
   :type '(choice (const native) (const image)))
 
 (declare-function make-xwidget "xwidget.c"
-                  (beg end type title width height arguments &optional buffer))
+                  (type title width height arguments &optional buffer))
 (declare-function xwidget-set-adjustment "xwidget.c"
                   (xwidget axis relative value))
 (declare-function xwidget-buffer "xwidget.c" (xwidget))
@@ -66,8 +66,7 @@ See `make-xwidget' for the possible TYPE values.
 The usage of optional argument ARGS depends on the xwidget.
 This returns the result of `make-xwidget'."
   (goto-char pos)
-  (let ((id (make-xwidget (point) (point)
-                          type title width height args)))
+  (let ((id (make-xwidget type title width height args)))
     (put-text-property (point) (+ 1 (point))
                        'display (list 'xwidget ':xwidget id))
     id))
@@ -454,7 +453,7 @@ For example, use this to display an anchor."
     (setq xwidget-webkit-last-session-buffer (switch-to-buffer
                                               (get-buffer-create bufname)))
     (insert " 'a' adjusts the xwidget size.")
-    (setq xw (xwidget-insert 1 'webkit-osr  bufname 1000 1000))
+    (setq xw (xwidget-insert 1 'webkit  bufname 1000 1000))
     (xwidget-put xw 'callback 'xwidget-webkit-callback)
     (xwidget-webkit-mode)
     (xwidget-webkit-goto-uri (xwidget-webkit-last-session) url)))