CC Mode: Recognize a noise macro with parens after a declarator's identifier

* lisp/progmodes/cc-engine (c-forward-decl-or-cast-1): In the while loop
following comment "Skip over type decl suffix operators." insert code also
to check for noise macros with parentheses.

1 files changed, 36 insertions, 30 deletions

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index f7a850f4118..c6aa56e11ff 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -7433,36 +7433,42 @@ comment at the start of cc-engine.el for more info."
                (setq got-identifier (c-forward-name))
                (setq name-start pos)))
 
-      ;; Skip over type decl suffix operators.
-      (while (if (looking-at c-type-decl-suffix-key)
+      ;; Skip over type decl suffix operators and trailing noise macros.
+      (while
+          (cond
+           ((and c-opt-cpp-prefix
+                 (looking-at c-noise-macro-with-parens-name-re))
+            (c-forward-noise-clause))
 
-                 (if (eq (char-after) ?\))
-                     (when (> paren-depth 0)
-                       (setq paren-depth (1- paren-depth))
-                       (forward-char)
-                       t)
-                   (when (if (save-match-data (looking-at "\\s("))
-                             (c-safe (c-forward-sexp 1) t)
-                           (goto-char (match-end 1))
-                           t)
-                     (when (and (not got-suffix-after-parens)
-                                (= paren-depth 0))
-                       (setq got-suffix-after-parens (match-beginning 0)))
-                     (setq got-suffix t)))
-
-               ;; No suffix matched.  We might have matched the
-               ;; identifier as a type and the open paren of a
-               ;; function arglist as a type decl prefix.  In that
-               ;; case we should "backtrack": Reinterpret the last
-               ;; type as the identifier, move out of the arglist and
-               ;; continue searching for suffix operators.
-               ;;
-               ;; Do this even if there's no preceding type, to cope
-               ;; with old style function declarations in K&R C,
-               ;; (con|de)structors in C++ and `c-typeless-decl-kwds'
-               ;; style declarations.  That isn't applicable in an
-               ;; arglist context, though.
-               (when (and (= paren-depth 1)
+           ((looking-at c-type-decl-suffix-key)
+            (if (eq (char-after) ?\))
+                (when (> paren-depth 0)
+                  (setq paren-depth (1- paren-depth))
+                  (forward-char)
+                  t)
+              (when (if (save-match-data (looking-at "\\s("))
+                        (c-safe (c-forward-sexp 1) t)
+                      (goto-char (match-end 1))
+                      t)
+                (when (and (not got-suffix-after-parens)
+                           (= paren-depth 0))
+                  (setq got-suffix-after-parens (match-beginning 0)))
+                (setq got-suffix t))))
+
+           (t
+            ;; No suffix matched.  We might have matched the
+            ;; identifier as a type and the open paren of a
+            ;; function arglist as a type decl prefix.  In that
+            ;; case we should "backtrack": Reinterpret the last
+            ;; type as the identifier, move out of the arglist and
+            ;; continue searching for suffix operators.
+            ;;
+            ;; Do this even if there's no preceding type, to cope
+            ;; with old style function declarations in K&R C,
+            ;; (con|de)structors in C++ and `c-typeless-decl-kwds'
+            ;; style declarations.  That isn't applicable in an
+            ;; arglist context, though.
+            (when (and (= paren-depth 1)
                           (not got-prefix-before-parens)
                           (not (eq at-type t))
                           (or backup-at-type
@@ -7474,7 +7480,7 @@ comment at the start of cc-engine.el for more info."
                           (eq (char-before pos) ?\)))
                  (c-fdoc-shift-type-backward)
                  (goto-char pos)
-                 t))
+                 t)))
 
         (c-forward-syntactic-ws))