C++ Mode: handle __attribute__,etc. inside constructor argument lists

This corrects both the fontification and indentation of these things, fixing
bug #42270.

* lisp/progmodes/cc-engine.el (c-do-declarators): Skip over "hangon keys" and
noise macros whilst scanning a putative C++ function.
(c-forward-decl-or-cast-1): When checking for typeless functions, skip over
"hangon keys" and noise macros.

* lisp/progmodes/cc-mode.el (c-fl-decl-end): Deal with certain invalid
"nested declarators" by scanning over them with a recursive call of
c-fl-decl-end.

* lisp/progmodes/cc-vars.el (c-noise-macro-names)
(c-noise-macro-with-parens-names): State in the doc strings that if either of
these is a regexp, it must have a submatch 1 which matches the noise macro
exactly.

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index 7ff424c6a7e3d403127b20b98e8b5266c1134db9..7d10027c76f61c63623ee6346e175cf027f642f5 100644 (file)
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -2238,7 +2238,7 @@ comment at the start of cc-engine.el for more info."
 
             ((and c-opt-cpp-prefix
                   (looking-at c-noise-macro-name-re))
-             ;; Skip over a noise macro.
+             ;; Skip over a noise macro without parens.
              (goto-char (match-end 1))
              (not (eobp)))
 
@@ -9130,6 +9130,12 @@ This function might do hidden buffer changes."
                                  (catch 'is-function
                                    (while
                                        (progn
+                                         (while
+                                             (cond
+                                              ((looking-at c-decl-hangon-key)
+                                               (c-forward-keyword-clause 1))
+                                              ((looking-at c-noise-macro-with-parens-name-re)
+                                               (c-forward-noise-clause))))
                                          (if (eq (char-after) ?\))
                                              (throw 'is-function t))
                                          (setq cdd-got-type (c-forward-type))
@@ -9782,6 +9788,16 @@ This function might do hidden buffer changes."
                                  (save-excursion
                                    (goto-char after-paren-pos)
                                    (c-forward-syntactic-ws)
+                                   (progn
+                                     (while
+                                         (cond
+                                          ((and
+                                            c-opt-cpp-prefix
+                                            (looking-at c-noise-macro-with-parens-name-re))
+                                           (c-forward-noise-clause))
+                                          ((looking-at c-decl-hangon-key)
+                                           (c-forward-keyword-clause 1))))
+                                     t)
                                    (or (c-forward-type)
                                        ;; Recognize a top-level typeless
                                        ;; function declaration in C.

diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 73275cfa621998038e05f962d444e2010a52579f..c6dd671051dd11bee2d7bd23d7ca476dfbc7aef6 100644 (file)
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -2266,7 +2266,8 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
 (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).
+  ;; count as being in a declarator (on pragmatic grounds).  POINT is not
+  ;; preserved.
   (goto-char pos)
   (let ((lit-start (c-literal-start))
        enclosing-attribute pos1)
@@ -2279,12 +2280,31 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
        (let ((lim (save-excursion
                     (and (c-beginning-of-macro)
                          (progn (c-end-of-macro) (point))))))
-         (when (and (c-forward-declarator lim)
-                    (or (not (eq (char-after) ?\())
-                        (c-go-list-forward nil lim))
-                    (eq (c-forward-token-2 1 nil lim) 0))
-           (c-backward-syntactic-ws)
-           (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)
+                            (eq (char-before) ?\())
+                          (c-fl-decl-end (1- (point))))
+                       (c-backward-syntactic-ws)
+                       (point))))
+                (and (progn (c-forward-syntactic-ws lim)
+                            (not (eobp)))
+                     (c-backward-syntactic-ws)
+                     (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

diff --git a/lisp/progmodes/cc-vars.el b/lisp/progmodes/cc-vars.el
index b885f6ae1d81f1c7e997dd9d5debf96d3ae28f5c..9e6f9527ca1cea1f6f2c401cfe3eb5be00e4fd8c 100644 (file)
--- a/lisp/progmodes/cc-vars.el
+++ b/lisp/progmodes/cc-vars.el
@@ -1670,7 +1670,8 @@ indented as a statement."
 like \"INLINE\" which are syntactic noise.  Such a macro/extension is complete
 in itself, never having parentheses.  All these names must be syntactically
 valid identifiers.  Alternatively, this variable may be a regular expression
-which matches the names of such macros.
+which matches the names of such macros, in which case it must have a submatch
+1 which matches the actual noise macro name.
 
 If you change this variable's value, call the function
 `c-make-noise-macro-regexps' to set the necessary internal variables (or do
@@ -1686,7 +1687,8 @@ this implicitly by reinitializing C/C++/Objc Mode on any buffer)."
 which optionally have arguments in parentheses, and which expand to nothing.
 All these names must be syntactically valid identifiers.  These are recognized
 by CC Mode only in declarations.  Alternatively, this variable may be a
-regular expression which matches the names of such macros.
+regular expression which matches the names of such macros, in which case it
+must have a submatch 1 which matches the actual noise macro name.
 
 If you change this variable's value, call the function
 `c-make-noise-macro-regexps' to set the necessary internal variables (or do