C++ Mode: Fix incoorect background fontification of <

Where c-record-found-types gets "bound" to itself, we postpone the calling of
c-fontify-new-type on possible new found types until these are confirmed by
the return from the function tentatively finding these types, for exmaple
c-forward-<>-arglist.  We check this "binding" by testing the value of
c-record-found-types.

Correct the background fontification algorithm.

* lisp/progmodes/cc-engine.el (c-record-found-types): Move the definition to
earlier in the file.
(c-add-type-1): Check additionally c-record-found-types is nil before calling
c-fontify-new-found-type.
(c-forward-<>-arglist, c-forward-type): On return from a function which
collects found types in c-record-found-types, call c-fontify-new-found-types
for each such type.

* lisp/progmodes/c-fonts.el (c-force-redisplay): Actually fontify the new
found type.
(c-fontify-new-found-type): Test for font-lock-mode being enabled.  Remove the
spurious condition on the `fontified' text property being nil before causing
c-force-redisplay to get called.

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index a4568bd4efc7b6785b5f5ed8b2de5034ecfa7fa4..c7b01de9b986b36273e0c432e0e7421630861a44 100644 (file)
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -6812,6 +6812,13 @@ comment at the start of cc-engine.el for more info."
 (defvar c-found-types nil)
 (make-variable-buffer-local 'c-found-types)
 
+;; Dynamically bound variable that instructs `c-forward-type' to
+;; record the ranges of types that only are found.  Behaves otherwise
+;; like `c-record-type-identifiers'.  Also when this variable is non-nil,
+;; `c-fontify-new-found-type' doesn't get called (yet) for the purported
+;; type.
+(defvar c-record-found-types nil)
+
 (defsubst c-clear-found-types ()
   ;; Clears `c-found-types'.
   (setq c-found-types
@@ -6825,7 +6832,10 @@ comment at the start of cc-engine.el for more info."
   (let ((type (c-syntactic-content from to c-recognize-<>-arglists)))
     (unless (gethash type c-found-types)
       (puthash type t c-found-types)
-      (when (and (eq (string-match c-symbol-key type) 0)
+      (when (and (not c-record-found-types) ; Only call `c-fontify-new-fount-type'
+                                       ; when we haven't "bound" c-found-types
+                                       ; to itself in c-forward-<>-arglist.
+                (eq (string-match c-symbol-key type) 0)
                 (eq (match-end 0) (length type)))
        (c-fontify-new-found-type type)))))
 
@@ -8225,11 +8235,6 @@ multi-line strings (but not C++, for example)."
           (setq c-record-ref-identifiers
                 (cons range c-record-ref-identifiers))))))
 
-;; Dynamically bound variable that instructs `c-forward-type' to
-;; record the ranges of types that only are found.  Behaves otherwise
-;; like `c-record-type-identifiers'.
-(defvar c-record-found-types nil)
-
 (defmacro c-forward-keyword-prefixed-id (type)
   ;; Used internally in `c-forward-keyword-clause' to move forward
   ;; over a type (if TYPE is 'type) or a name (otherwise) which
@@ -8459,6 +8464,11 @@ multi-line strings (but not C++, for example)."
                (c-forward-<>-arglist-recur all-types)))
        (progn
          (when (consp c-record-found-types)
+           (let ((cur c-record-found-types))
+             (while (consp (car-safe cur))
+               (c-fontify-new-found-type
+                (buffer-substring-no-properties (caar cur) (cdar cur)))
+               (setq cur (cdr cur))))
            (setq c-record-type-identifiers
                  ;; `nconc' doesn't mind that the tail of
                  ;; `c-record-found-types' is t.
@@ -9184,6 +9194,12 @@ multi-line strings (but not C++, for example)."
 
                (when (and (eq res t)
                           (consp c-record-found-types))
+                 ;; Cause the confirmed types to get fontified.
+                 (let ((cur c-record-found-types))
+                   (while (consp (car-safe cur))
+                     (c-fontify-new-found-type
+                      (buffer-substring-no-properties (caar cur) (cdar cur)))
+                     (setq cur (cdr cur))))
                  ;; Merge in the ranges of any types found by the second
                  ;; `c-forward-type'.
                  (setq c-record-type-identifiers

diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 9355409b2af54b3a5ca2114420d6e19f144d3a2e..967464ac14d12d59955134579e9c9cf4215be47a 100644 (file)
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -101,6 +101,7 @@
 (cc-bytecomp-defun c-font-lock-objc-method)
 (cc-bytecomp-defun c-font-lock-invalid-string)
 (cc-bytecomp-defun c-before-context-fl-expand-region)
+(cc-bytecomp-defun c-font-lock-fontify-region)
 
 \f
 ;; Note that font-lock in XEmacs doesn't expand face names as
@@ -2428,6 +2429,7 @@ higher."
 (defun c-force-redisplay (start end)
   ;; Force redisplay immediately.  This assumes `font-lock-support-mode' is
   ;; 'jit-lock-mode.  Set the variable `c-re-redisplay-timer' to nil.
+  (save-excursion (c-font-lock-fontify-region start end))
   (jit-lock-force-redisplay (copy-marker start) (copy-marker end))
   (setq c-re-redisplay-timer nil))
 
@@ -2436,7 +2438,8 @@ higher."
   ;; buffer.  If TYPE is currently displayed in a window, cause redisplay to
   ;; happen "instantaneously".  These actions are done only when jit-lock-mode
   ;; is active.
-  (when (and (boundp 'font-lock-support-mode)
+  (when (and font-lock-mode
+            (boundp 'font-lock-support-mode)
             (eq font-lock-support-mode 'jit-lock-mode))
     (c-save-buffer-state
        ((window-boundaries
@@ -2455,7 +2458,6 @@ higher."
            (dolist (win-boundary window-boundaries)
              (when (and (< (match-beginning 0) (cdr win-boundary))
                         (> (match-end 0) (car win-boundary))
-                        (c-get-char-property (match-beginning 0) 'fontified)
                         (not c-re-redisplay-timer))
                (setq c-re-redisplay-timer
                      (run-with-timer 0 nil #'c-force-redisplay