bug#56841: Emacs-28 C Mode: Fontification errors when arglist closing ) is on next line

[Alan Mackenzie]

Hello, Eli and Bill.

On Sat, Jul 30, 2022 at 18:10:12 +0300, Eli Zaretskii wrote:
> > Date: Sat, 30 Jul 2022 14:27:53 +0000
> > Cc: 56841@debbugs.gnu.org, sacks@ucar.edu, acm@muc.de
> > From: Alan Mackenzie <acm@muc.de>

> > > Are you saying this is not a bug in CC mode but somewhere else?  Or
> > > are you saying that you don't yet know what is the culprit and will
> > > investigate?

> > It is most definitely a bug in CC Mode, and I'm looking at it at the
> > moment.

> Thanks.

> > My feeling right now is that the fix will be too involved to go into the
> > release branch.

> Let's talk when you have a fix.  But generally, this doesn't sound
> like a too grave problem to me, especially since there's an easy way
> of asking Emacs to fontify correctly.

Here's a proposed version of the fix, which seems to work.  The diff is
probably best perused with diff -b.  The patch will apply to both the master
branch and Emacs-28.1.


CC Mode: Fontify args correctly when arglist closing ) is not on the same line

This should fix bug #56841.

* lisp/progmodes/cc-engine.el (c-forward-declarator): Fix an off-by-one
comparing the position after a c-forward-name with a limit.

* lisp/progmodes/cc-mode.el (c-fl-decl-end): Handle correctly point starting
inside a literal.  Insert a missing c-backward-syntactic-ws in the handling of
C++ attributes.  Better handle point starting inside a [ or (.  Tidy up the
handling of syntactic whitespace at the end of the buffer.



diff -r e4e62074b8a6 cc-engine.el
--- a/cc-engine.el      Sat Jul 30 09:15:53 2022 +0000
+++ b/cc-engine.el      Sun Jul 31 15:39:26 2022 +0000
@@ -9576,7 +9576,7 @@
         (or (= paren-depth 0)
             (c-safe (goto-char (scan-lists (point) 1 paren-depth))))
 
-        (<= (point) limit)
+        (< (point) limit)
 
         ;; Skip over any trailing bit, such as "__attribute__".
         (progn
diff -r e4e62074b8a6 cc-mode.el
--- a/cc-mode.el        Sat Jul 30 09:15:53 2022 +0000
+++ b/cc-mode.el        Sun Jul 31 15:39:26 2022 +0000
@@ -2412,49 +2412,59 @@
       (and (/= new-pos pos) new-pos))))
 
 (defun c-fl-decl-end (pos)
-  ;; If POS is inside a declarator, return the end of the token that follows
-  ;; the declarator, otherwise return nil.  POS being in a literal does not
-  ;; count as being in a declarator (on pragmatic grounds).  POINT is not
-  ;; preserved.
+  ;; If POS is inside a declarator, return the end of the paren pair that
+  ;; terminates it, or the token that follows the declarator, otherwise return
+  ;; nil.  If there is no such token, the end of the last token in the buffer
+  ;; is used.  POS being in a literal is now (2022-07) handled correctly.
+  ;; POINT is not preserved.
   (goto-char pos)
   (let ((lit-start (c-literal-start))
        (lim (c-determine-limit 1000))
        enclosing-attribute pos1)
-    (unless lit-start
-      (c-backward-syntactic-ws
-       lim)
-      (when (setq enclosing-attribute (c-enclosing-c++-attribute))
-       (goto-char (car enclosing-attribute))) ; Only happens in C++ Mode.
-      (when (setq pos1 (c-on-identifier))
-       (goto-char pos1)
-       (let ((lim (save-excursion
-                    (and (c-beginning-of-macro)
-                         (progn (c-end-of-macro) (point))))))
-         (and (c-forward-declarator lim)
-              (if (eq (char-after) ?\()
-                  (and
-                   (c-go-list-forward nil lim)
-                   (progn (c-forward-syntactic-ws lim)
-                          (not (eobp)))
-                   (progn
-                     (if (looking-at c-symbol-char-key)
-                         ;; Deal with baz (foo((bar)) type var), where
-                         ;; foo((bar)) is not semantically valid.  The result
-                         ;; must be after var).
-                         (and
-                          (goto-char pos)
-                          (setq pos1 (c-on-identifier))
-                          (goto-char pos1)
-                          (progn
-                            (c-backward-syntactic-ws lim)
-                            (eq (char-before) ?\())
-                          (c-fl-decl-end (1- (point))))
-                       (c-backward-syntactic-ws lim)
-                       (point))))
-                (and (progn (c-forward-syntactic-ws lim)
-                            (not (eobp)))
+    (if lit-start
+       (goto-char lit-start))
+    (c-backward-syntactic-ws lim)
+    (when (setq enclosing-attribute (c-enclosing-c++-attribute))
+      (goto-char (car enclosing-attribute)) ; Only happens in C++ Mode.
+      (c-backward-syntactic-ws lim))
+    (while (and (> (point) lim)
+               (memq (char-before) '(?\[ ?\()))
+      (backward-char)
+      (c-backward-syntactic-ws lim))
+    (when (setq pos1 (c-on-identifier))
+      (goto-char pos1)
+      (let ((lim (save-excursion
+                  (and (c-beginning-of-macro)
+                       (progn (c-end-of-macro) (point))))))
+       (and (c-forward-declarator lim)
+            (if (eq (char-after) ?\()
+                (and
+                 (c-go-list-forward nil lim)
+                 (progn (c-forward-syntactic-ws lim)
+                        (not (eobp)))
+                 (progn
+                   (if (looking-at c-symbol-char-key)
+                       ;; Deal with baz (foo((bar)) type var), where
+                       ;; foo((bar)) is not semantically valid.  The result
+                       ;; must be after var).
+                       (and
+                        (goto-char pos)
+                        (setq pos1 (c-on-identifier))
+                        (goto-char pos1)
+                        (progn
+                          (c-backward-syntactic-ws lim)
+                          (eq (char-before) ?\())
+                        (c-fl-decl-end (1- (point))))
                      (c-backward-syntactic-ws lim)
-                     (point)))))))))
+                     (point))))
+              (if (progn (c-forward-syntactic-ws lim)
+                         (not (eobp)))
+                  (c-forward-over-token)
+                (let ((lit-start (c-literal-start)))
+                  (when lit-start
+                      (goto-char lit-start))
+                  (c-backward-syntactic-ws)))
+              (and (>= (point) pos) (point))))))))
 
 (defun c-change-expand-fl-region (_beg _end _old-len)
   ;; Expand the region (c-new-BEG c-new-END) to an after-change font-lock


-- 
Alan Mackenzie (Nuremberg, Germany).