CC Mode: Fontify "found types" which are recognized after being first scanned

This aims to fix the scenario where on jit-lock's first scan of a type, it is
not recognized as such, and only later does this happen.  The fontification of
such found types is now done by background scanning in short time slices
immediately after initialising the mode.

* lisp/progmodes/cc-engine.el (c-add-type-1): New function.
(c-add-type): Extract c-add-type-1 from it, and reformulate the mechanism for
protecting c-found-types from excessive partial identifiers.

* lisp/progmodes/cc-fonts.el (c-font-lock-complex-decl-prepare): Remove the
code which cleared c-found-types on fontification at BOB.
(c-find-types-background): New function, based on c-font-lock-declarations).
(c-types-finder-timer-func): New function.
(c-re-redisplay-timer): New variable.
(c-force-redisplay, c-fontify-new-found-type): New functions.

* lisp/progmodes/cc-mode.el (c-type-finder-timer): New variable.
(c-leave-cc-mode-mode): Nullify c-post-command-hook and c-type-finder-timer
when the last CC Mode buffer of a session is killed.
(c-type-finder-pos): New variable.
(c-basic-common-init): Initialize c-type-finder-pos and c-type-finder-timer.
(c-new-id-start, c-new-id-end, c-new-id-is-type): New variables.
(c-update-new-id): New function.
(c-post-command): New post command hook function, used for checking moving
away from partially typed identifiers, and making them full identifiers.
(c-before-change): Add code to clear c-found-types on a buffer change at BOB.
(c-after-change): Call c-update-new-id to keep track of partially typed
identifiers.

* doc/misc/cc-mode.texi (Found Types): New @section in the @Chapter Font
Locking.

* lisp/progmodes/cc-vars.el (c-type-finder-time-slot)
(c-type-finder-repeat-time, c-type-finder-chunk-size): New customizable
options.

1 files changed, 194 insertions, 7 deletions

diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index bc0ae6cc95a..588674464a1 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -93,10 +93,12 @@
 (cc-bytecomp-defvar c-preprocessor-face-name)
 (cc-bytecomp-defvar c-reference-face-name)
 (cc-bytecomp-defvar c-block-comment-flag)
+(cc-bytecomp-defvar c-type-finder-pos)
 (cc-bytecomp-defun c-fontify-recorded-types-and-refs)
 (cc-bytecomp-defun c-font-lock-declarators)
 (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)
 
 
 ;; Note that font-lock in XEmacs doesn't expand face names as
@@ -919,13 +921,6 @@ casts and declarations are fontified.  Used on level 2 and higher."
   ;; This function does hidden buffer changes.
 
   ;;(message "c-font-lock-complex-decl-prepare %s %s" (point) limit)
-
-  ;; Clear the list of found types if we start from the start of the
-  ;; buffer, to make it easier to get rid of misspelled types and
-  ;; variables that have gotten recognized as types in malformed code.
-  (when (bobp)
-    (c-clear-found-types))
-
   (c-skip-comments-and-strings limit)
   (when (< (point) limit)
 
@@ -1605,6 +1600,158 @@ casts and declarations are fontified.  Used on level 2 and higher."
 
 	nil))))
 
+(defun c-find-types-background (start limit)
+  ;; Find any "found types" between START and LIMIT.  Allow any such types to
+  ;; be entered into `c-found-types' by the action of `c-forward-name' or
+  ;; `c-forward-type' called from this function.  This process also causes
+  ;; occurrences of the type to be prepared for fontification throughout the
+  ;; buffer.
+  ;;
+  ;; This function is called from the timer `c-type-finder-timer'.  It may do
+  ;; hidden buffer changes.
+  (save-excursion
+    (save-restriction
+      (widen)
+      (goto-char start)
+      (c-skip-comments-and-strings limit)
+      (when (< (point) limit)
+	(let (
+	      ;; o - 'decl if we're in an arglist containing declarations
+	      ;;   (but if `c-recognize-paren-inits' is set it might also be
+	      ;;   an initializer arglist);
+	      ;; o - '<> if the arglist is of angle bracket type;
+	      ;; o - 'arglist if it's some other arglist;
+	      ;; o - nil, if not in an arglist at all.  This includes the
+	      ;;   parenthesized condition which follows "if", "while", etc.
+	      context
+	      ;; A list of starting positions of possible type declarations, or of
+	      ;; the typedef preceding one, if any.
+	      last-cast-end
+	      ;; The result from `c-forward-decl-or-cast-1'.
+	      decl-or-cast
+	      ;; The maximum of the end positions of all the checked type
+	      ;; decl expressions in the successfully identified
+	      ;; declarations.  The position might be either before or
+	      ;; after the syntactic whitespace following the last token
+	      ;; in the type decl expression.
+	      (max-type-decl-end 0)
+	      ;; Same as `max-type-decl-*', but used when we're before
+	      ;; `token-pos'.
+	      (max-type-decl-end-before-token 0)
+	      )
+	  (goto-char start)
+	  (c-find-decl-spots
+	   limit
+	   c-decl-start-re
+	   nil				; (eval c-maybe-decl-faces)
+
+	   (lambda (match-pos inside-macro &optional toplev)
+	     ;; Note to maintainers: don't use `limit' inside this lambda form;
+	     ;; c-find-decl-spots sometimes narrows to less than `limit'.
+	     (if (and c-macro-with-semi-re
+		      (looking-at c-macro-with-semi-re))
+		 ;; Don't do anything more if we're looking at something that
+		 ;; can't start a declaration.
+		 t
+
+	       ;; Set `context' and `c-restricted-<>-arglists'.  Look for
+	       ;; "<" for the sake of C++-style template arglists.
+	       ;; "Ignore "(" when it's part of a control flow construct
+	       ;; (e.g. "for (").
+	       (let ((got-context
+		      (c-get-fontification-context
+		       match-pos
+		       (< match-pos (if inside-macro
+					max-type-decl-end-before-token
+				      max-type-decl-end))
+		       toplev)))
+		 (setq context (car got-context)
+		       c-restricted-<>-arglists (cdr got-context)))
+
+	       ;; In QT, "more" is an irritating keyword that expands to nothing.
+	       ;; We skip over it to prevent recognition of "more slots: <symbol>"
+	       ;; as a bitfield declaration.
+	       (when (and (c-major-mode-is 'c++-mode)
+			  (looking-at
+			   (concat "\\(more\\)\\([^" c-symbol-chars "]\\|$\\)")))
+		 (goto-char (match-end 1))
+		 (c-forward-syntactic-ws))
+
+	       ;; Now analyze the construct.  This analysis will cause
+	       ;; `c-forward-name' and `c-forward-type' to call `c-add-type',
+	       ;; triggering the desired recognition and fontification of
+	       ;; these found types.
+	       (when (not (eq context 'not-decl))
+		 (setq decl-or-cast
+		       (c-forward-decl-or-cast-1
+			match-pos context last-cast-end))
+
+		 (cond
+		  ((eq decl-or-cast 'cast)
+		   ;; Save the position after the previous cast so we can feed
+		   ;; it to `c-forward-decl-or-cast-1' in the next round.  That
+		   ;; helps it discover cast chains like "(a) (b) c".
+		   (setq last-cast-end (point))
+		   nil)
+		  (decl-or-cast
+		   ;; We've found a declaration.
+
+		   ;; Set `max-type-decl-end' or `max-type-decl-end-before-token'
+		   ;; under the assumption that we're after the first type decl
+		   ;; expression in the declaration now.  That's not really true;
+		   ;; we could also be after a parenthesized initializer
+		   ;; expression in C++, but this is only used as a last resort
+		   ;; to slant ambiguous expression/declarations, and overall
+		   ;; it's worth the risk to occasionally fontify an expression
+		   ;; as a declaration in an initializer expression compared to
+		   ;; getting ambiguous things in normal function prototypes
+		   ;; fontified as expressions.
+		   (if inside-macro
+		       (when (> (point) max-type-decl-end-before-token)
+			 (setq max-type-decl-end-before-token (point)))
+		     (when (> (point) max-type-decl-end)
+		       (setq max-type-decl-end (point)))))
+		  (t t)))))))))))
+
+(defun c-types-finder-timer-func ()
+  ;; A CC Mode idle timer function for finding "found types".  It triggers
+  ;; every `c-type-finder-repeat-time' seconds and processes buffer chunks of
+  ;; size around `c-type-finder-chunk-size' characters, and runs for (a little
+  ;; over) `c-type-finder-time-slot' seconds.  The types it finds are inserted
+  ;; into `c-found-types', and their occurrences throughout the buffer are
+  ;; prepared for fontification.
+  (let* ((stop-time (+ (float-time) c-type-finder-time-slot))
+	 (buf-list (buffer-list)))
+    ;; One CC Mode buffer needing processing each time around this loop.
+    (while buf-list
+      ;; Cdr through BUF-LIST to find the next buffer needing processing.
+      (while (and buf-list
+		  (not (with-current-buffer (car buf-list) c-type-finder-pos)))
+	(setq buf-list (cdr buf-list)))
+      (when buf-list
+	(with-current-buffer (car buf-list)
+	  (save-restriction
+	    (widen)
+	    ;; Process one `c-type-finder-chunk-size' chunk each time around
+	    ;; this loop.
+	    (while (and c-type-finder-pos
+			(< (float-time) stop-time))			
+	      ;; Process one chunk per iteration.
+	      (c-save-buffer-state
+		  ((beg (marker-position c-type-finder-pos))
+		   (end (min (+ beg c-type-finder-chunk-size) (point-max)))
+		   (region (c-before-context-fl-expand-region beg end)))
+		(setq beg (car region)
+		      end (cdr region))
+		(c-find-types-background beg end)
+		(move-marker c-type-finder-pos
+			     (if (save-excursion (goto-char end) (eobp))
+				 nil
+			       end))
+		(when (not (marker-position c-type-finder-pos))
+		  (setq c-type-finder-pos nil))))))
+	(setq buf-list (cdr buf-list))))))
+
 (defun c-font-lock-enum-body (limit)
   ;; Fontify the identifiers of each enum we find by searching forward.
   ;;
@@ -2255,6 +2402,46 @@ higher."
     ;; defvar will install its default value later on.
     (makunbound def-var)))
 
+;; `c-re-redisplay-timer' is a timer which, when triggered, causes a
+;; redisplay.
+(defvar c-re-redisplay-timer nil)
+
+(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.
+  (jit-lock-force-redisplay (copy-marker start) (copy-marker end))
+  (setq c-re-redisplay-timer nil))
+
+(defun c-fontify-new-found-type (type)
+  ;; Cause the fontification of TYPE, a string, wherever it occurs in the
+  ;; 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)
+	     (eq font-lock-support-mode 'jit-lock-mode))
+    (c-save-buffer-state
+	((window-boundaries
+	  (mapcar (lambda (win)
+		    (cons (window-start win)
+			  (window-end win)))
+		  (get-buffer-window-list (current-buffer) 'no-mini t)))
+	 (target-re (concat "\\_<" type "\\_>")))
+      (save-excursion
+	(save-restriction
+	  (widen)
+	  (goto-char (point-min))
+	  (while (re-search-forward target-re nil t)
+	    (put-text-property (match-beginning 0) (match-end 0)
+			       'fontified nil)
+	    (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
+				      (match-beginning 0) (match-end 0)))))))))))
+
 
 ;;; C.