c-get-fontification-context: Refine the last non-default arm of the cond

This fixes bug #58772.

* lisp/progmodes/cc-fonts.el (c-get-fontification-context): Make the function
return (decl . nil) when MATCH-POS is in the second paren list of something
like DEFUN (..) (..).  Tidy up untidy code with save-excursion's for greater
accuracy.  Set a c-type text property value c-decl-arg-start to speed up
future calls.  Reindent the entire function.

1 files changed, 133 insertions, 122 deletions

diff --git a/lisp/progmodes/cc-fonts.el b/lisp/progmodes/cc-fonts.el
index 608919d0c90..9444828a0ed 100644
--- a/lisp/progmodes/cc-fonts.el
+++ b/lisp/progmodes/cc-fonts.el
@@ -1218,134 +1218,145 @@ casts and declarations are fontified.  Used on level 2 and higher."
 		    (c-backward-syntactic-ws)
 		    (eq (char-before) ?\()))))
       (c-get-fontification-context (point) not-front-decl toplev))
-	  ((not (memq (char-before match-pos) '(?\( ?, ?\[ ?< ?{)))
-	   (cons (and toplev 'top) nil))
-	  ;; A control flow expression or a decltype
-	  ((and (eq (char-before match-pos) ?\()
-		(save-excursion
-		  (goto-char match-pos)
-		  (backward-char)
-		  (c-backward-token-2)
-		  (cond
-		   ((looking-at c-paren-stmt-key)
-		    ;; Allow comma separated <> arglists in for statements.
-		    (cons nil nil))
-		   ((or (looking-at c-block-stmt-2-key)
-			(looking-at c-block-stmt-1-2-key)
-			(looking-at c-typeof-key))
-		    (cons nil t))
-		   (t nil)))))
-	  ;; Near BOB.
-	  ((<= match-pos (point-min))
-	   (cons 'arglist t))
-	  ;; Got a cached hit in a declaration arglist.
-	  ((eq type 'c-decl-arg-start)
-	   (cons 'decl nil))
-	  ;; We're inside (probably) a brace list.
-	  ((eq type 'c-not-decl)
-	   (cons 'not-decl nil))
-	  ;; Inside a C++11 lambda function arglist.
-	  ((and (c-major-mode-is 'c++-mode)
-		(eq (char-before match-pos) ?\()
-		(save-excursion
-		  (goto-char match-pos)
-		  (c-backward-token-2)
-		  (and
-		   (c-safe (goto-char (scan-sexps (point) -1)))
-		   (c-looking-at-c++-lambda-capture-list))))
-	   (c-put-char-property (1- match-pos) 'c-type
-				'c-decl-arg-start)
-	   (cons 'decl nil))
-	  ;; We're inside a brace list.
-	  ((and (eq (char-before match-pos) ?{)
-		(c-inside-bracelist-p (1- match-pos)
-				      (cdr (c-parse-state))
-				      nil))
-	   (c-put-char-property (1- match-pos) 'c-type
-				'c-not-decl)
-	   (cons 'not-decl nil))
-	  ;; We're inside an "ordinary" open brace.
-	  ((eq (char-before match-pos) ?{)
-	   (cons (and toplev 'top) nil))
-	  ;; Inside an angle bracket arglist.
-	  ((or (eq type 'c-<>-arg-sep)
-	       (eq (char-before match-pos) ?<))
-	   (cons '<> nil))
-	  ;; Got a cached hit in some other type of arglist.
-	  (type
-	   (cons 'arglist t))
-	  ;; We're at a C++ uniform initialization.
-	  ((and (c-major-mode-is 'c++-mode)
-		(eq (char-before match-pos) ?\()
-		(save-excursion
-		  (goto-char match-pos)
-		  (and
-		   (zerop (c-backward-token-2 2))
-		   (looking-at c-identifier-start)
-		   (c-got-face-at (point)
-				  '(font-lock-variable-name-face)))))
-	   (cons 'not-decl nil))
-	  ((and not-front-decl
+     ((not (memq (char-before match-pos) '(?\( ?, ?\[ ?< ?{)))
+      (cons (and toplev 'top) nil))
+     ;; A control flow expression or a decltype
+     ((and (eq (char-before match-pos) ?\()
+	   (save-excursion
+	     (goto-char match-pos)
+	     (backward-char)
+	     (c-backward-token-2)
+	     (cond
+	      ((looking-at c-paren-stmt-key)
+	       ;; Allow comma separated <> arglists in for statements.
+	       (cons nil nil))
+	      ((or (looking-at c-block-stmt-2-key)
+		   (looking-at c-block-stmt-1-2-key)
+		   (looking-at c-typeof-key))
+	       (cons nil t))
+	      (t nil)))))
+     ;; Near BOB.
+     ((<= match-pos (point-min))
+      (cons 'arglist t))
+     ;; Got a cached hit in a declaration arglist.
+     ((eq type 'c-decl-arg-start)
+      (cons 'decl nil))
+     ;; We're inside (probably) a brace list.
+     ((eq type 'c-not-decl)
+      (cons 'not-decl nil))
+     ;; Inside a C++11 lambda function arglist.
+     ((and (c-major-mode-is 'c++-mode)
+	   (eq (char-before match-pos) ?\()
+	   (save-excursion
+	     (goto-char match-pos)
+	     (c-backward-token-2)
+	     (and
+	      (c-safe (goto-char (scan-sexps (point) -1)))
+	      (c-looking-at-c++-lambda-capture-list))))
+      (c-put-char-property (1- match-pos) 'c-type
+			   'c-decl-arg-start)
+      (cons 'decl nil))
+     ;; We're inside a brace list.
+     ((and (eq (char-before match-pos) ?{)
+	   (c-inside-bracelist-p (1- match-pos)
+				 (cdr (c-parse-state))
+				 nil))
+      (c-put-char-property (1- match-pos) 'c-type
+			   'c-not-decl)
+      (cons 'not-decl nil))
+     ;; We're inside an "ordinary" open brace.
+     ((eq (char-before match-pos) ?{)
+      (cons (and toplev 'top) nil))
+     ;; Inside an angle bracket arglist.
+     ((or (eq type 'c-<>-arg-sep)
+	  (eq (char-before match-pos) ?<))
+      (cons '<> nil))
+     ;; Got a cached hit in some other type of arglist.
+     (type
+      (cons 'arglist t))
+     ;; We're at a C++ uniform initialization.
+     ((and (c-major-mode-is 'c++-mode)
+	   (eq (char-before match-pos) ?\()
+	   (save-excursion
+	     (goto-char match-pos)
+	     (and
+	      (zerop (c-backward-token-2 2))
+	      (looking-at c-identifier-start)
+	      (c-got-face-at (point)
+			     '(font-lock-variable-name-face)))))
+      (cons 'not-decl nil))
+     ((and not-front-decl
 	   ;; The point is within the range of a previously
 	   ;; encountered type decl expression, so the arglist
 	   ;; is probably one that contains declarations.
 	   ;; However, if `c-recognize-paren-inits' is set it
 	   ;; might also be an initializer arglist.
-		(or (not c-recognize-paren-inits)
-		    (save-excursion
-		      (goto-char match-pos)
-		      (not (c-back-over-member-initializers)))))
-	   ;; The result of this check is cached with a char
-	   ;; property on the match token, so that we can look
-	   ;; it up again when refontifying single lines in a
-	   ;; multiline declaration.
-	   (c-put-char-property (1- match-pos)
-				'c-type 'c-decl-arg-start)
-	   (cons 'decl nil))
-	  ;; Got (an) open paren(s) preceded by an arith operator.
-	  ((and (eq (char-before match-pos) ?\()
-		(save-excursion
-		  (goto-char match-pos)
-		  (while
-		      (and (zerop (c-backward-token-2))
-			   (eq (char-after) ?\()))
-		  (looking-at c-arithmetic-op-regexp)))
-	   (cons nil nil))
-	  ;; In a C++ member initialization list.
-	  ((and (eq (char-before match-pos) ?,)
-	  	(c-major-mode-is 'c++-mode)
-	  	(save-excursion
-		  (goto-char match-pos)
-		  (c-back-over-member-initializers)))
-	   (c-put-char-property (1- match-pos) 'c-type 'c-not-decl)
-	   (cons 'not-decl nil))
-	  ;; At start of a declaration inside a declaration paren.
-	  ((save-excursion
+	   (or (not c-recognize-paren-inits)
+	       (save-excursion
+		 (goto-char match-pos)
+		 (not (c-back-over-member-initializers)))))
+      ;; The result of this check is cached with a char
+      ;; property on the match token, so that we can look
+      ;; it up again when refontifying single lines in a
+      ;; multiline declaration.
+      (c-put-char-property (1- match-pos)
+			   'c-type 'c-decl-arg-start)
+      (cons 'decl nil))
+     ;; Got (an) open paren(s) preceded by an arith operator.
+     ((and (eq (char-before match-pos) ?\()
+	   (save-excursion
 	     (goto-char match-pos)
-	     (and (memq (char-before match-pos) '(?\( ?\,))
-		  (c-go-up-list-backward match-pos
-					  ; c-determine-limit is too slow, here.
-					 (max (- (point) 2000) (point-min)))
-		  (eq (char-after) ?\()
-		  (let ((type (c-get-char-property (point) 'c-type)))
-		    (or (memq type '(c-decl-arg-start c-decl-type-start))
-			(and
-			 (progn (c-backward-syntactic-ws) t)
-			 (or
-			  (and
-		           (c-back-over-compound-identifier)
-			   (progn
-			     (c-backward-syntactic-ws)
-			     (or (bobp)
-				 (progn
-				   (setq type (c-get-char-property (1- (point))
-								   'c-type))
-				   (memq type '(c-decl-arg-start
-						c-decl-type-start))))))
-			  (and (zerop (c-backward-token-2))
-			       (looking-at c-fun-name-substitute-key))))))))
-	   (cons 'decl nil))
-	  (t (cons 'arglist t)))))
+	     (while
+		 (and (zerop (c-backward-token-2))
+		      (eq (char-after) ?\()))
+	     (looking-at c-arithmetic-op-regexp)))
+      (cons nil nil))
+     ;; In a C++ member initialization list.
+     ((and (eq (char-before match-pos) ?,)
+	   (c-major-mode-is 'c++-mode)
+	   (save-excursion
+	     (goto-char match-pos)
+	     (c-back-over-member-initializers)))
+      (c-put-char-property (1- match-pos) 'c-type 'c-not-decl)
+      (cons 'not-decl nil))
+     ;; At start of a declaration inside a declaration paren.
+     ((save-excursion
+	(goto-char match-pos)
+	(and (memq (char-before match-pos) '(?\( ?\,))
+	     (c-go-up-list-backward match-pos
+					; c-determine-limit is too slow, here.
+				    (max (- (point) 2000) (point-min)))
+	     (eq (char-after) ?\()
+	     (let ((type (c-get-char-property (point) 'c-type)))
+	       (or (memq type '(c-decl-arg-start c-decl-type-start))
+		   (progn
+		     (c-backward-syntactic-ws)
+		     (cond
+		      ((and toplev
+			    (eq (char-before) ?\)))
+		       (save-excursion
+			 (and (c-go-list-backward nil (max (- (point) 2000)
+							   (point-min)))
+			      (eq (char-after) ?\()
+			      (progn (c-backward-syntactic-ws)
+				     (c-back-over-compound-identifier)))))
+		      ((save-excursion
+			 (and
+			  (c-back-over-compound-identifier)
+			  (progn
+			    (c-backward-syntactic-ws)
+			    (or (bobp)
+				(progn
+				  (setq type (c-get-char-property (1- (point))
+								  'c-type))
+				  (memq type '(c-decl-arg-start
+					       c-decl-type-start))))))))
+		      ((and (zerop (c-backward-token-2))
+			    (looking-at c-fun-name-substitute-key)))))))))
+      ;; Cache the result of this test for next time around.
+      (c-put-char-property (1- match-pos) 'c-type 'c-decl-arg-start)
+      (cons 'decl nil))
+     (t (cons 'arglist t)))))
 
 (defun c-font-lock-single-decl (limit decl-or-cast match-pos context toplev)
   ;; Try to fontify a single declaration, together with all its declarators.