Fix some errors in c-display-defun-name when the type is "struct {..}", etc.

Also fix some errors with c-display-defun-name when there are nested classes.

* lisp/progmodes/cc-cmds.el (c-in-function-trailer-p): Deal with a struct {..}
being merely the type of a function.
(c-where-wrt-brace-construct): Deal with a struct {..} being merely the type
of a function.  Rearrange the order of some Lisp forms.  Insert a check for
c-protection-key ("private", etc.) alongside the checking for a label.
(c-defun-name-1): New function extracted form c-defun-name, which works within
the existing restriction.  Don't regard 'at-function-end as being within the
defun any more.  Recognize "struct", etc., with the new
c-defun-type-name-decl-key rather than c-type-prefix-key.  Make the
recognition of a normal function more accurate.
(c-defun-name): Part left after extracting the above function.  It now just
widens and calls c-defun-name-1.
(c-declaration-limits-1): New function extracted from c-declaration-limits,
which works within the existing restriction.  Move LIM back one block to
account for the possibility of struct {..} as a function type.  Check we're
not inside a declaration without braces.
(c-declaration-limits): Part left after extracting the above function.  It now
just narrows to an enclosing decl block and calls c-declaration-limits-1.
(c-defun-name-and-limits): New function which identifies the name and limits
of the most nested enclosing declaration or macro.
(c-display-defun-name): Use c-defun-name-and-limits rather than two separate
functions (which didn't always agree on which function).

* lisp/progmodes/cc-engine.el (c-beginning-of-statement-1): If we have struct
{..} as the type of a function, go back over this, too.

* lisp/progmodes/cc-langs.el (c-defun-type-name-decl-kwds)
(c-defun-type-name-decl-key): New lang const/var.

3 files changed, 329 insertions, 242 deletions

diff --git a/lisp/progmodes/cc-cmds.el b/lisp/progmodes/cc-cmds.el
index 0c4829e103f..31cf0b11596 100644
--- a/lisp/progmodes/cc-cmds.el
+++ b/lisp/progmodes/cc-cmds.el
@@ -1397,6 +1397,16 @@ No indentation or other \"electric\" behavior is performed."
                 (not (eq (char-before) ?_))
                 (c-syntactic-re-search-forward "[;=([{]" eo-block t t t)
                 (eq (char-before) ?\{)
+                ;; Exclude the entire "struct {...}" being the type of a
+                ;; function being declared.
+                (not
+                 (and
+                  (c-go-up-list-forward)
+                  (eq (char-before) ?})
+                  (progn (c-forward-syntactic-ws)
+                         (c-syntactic-re-search-forward
+                          "[;=([{]" nil t t t))
+                  (eq (char-before) ?\()))
                 bod)))))
 
 (defun c-where-wrt-brace-construct ()
@@ -1434,7 +1444,11 @@ No indentation or other \"electric\" behavior is performed."
        ((and (not least-enclosing)
              (consp paren-state)
              (consp (car paren-state))
-             (eq start (cdar paren-state)))
+             (eq start (cdar paren-state))
+             (not
+              (progn
+                (c-forward-syntactic-ws)
+                (looking-at c-symbol-start))))
         'at-function-end)
        (t
         ;; Find the start of the current declaration.  NOTE: If we're in the
@@ -1450,6 +1464,18 @@ No indentation or other \"electric\" behavior is performed."
 "\\([;#]\\|\\'\\|\\s(\\|\\s)\\|\\s\"\\|\\s\\\\|\\s$\\|\\s<\\|\\s>\\|\\s!\\)")))
             (forward-char))
         (setq kluge-start (point))
+        ;; First approximation as to whether the current "header" we're in is
+        ;; one followed by braces.
+        (setq brace-decl-p
+              (save-excursion
+                (and (c-syntactic-re-search-forward "[;{]" nil t t)
+                     (or (eq (char-before) ?\{)
+                         (and c-recognize-knr-p
+                              ;; Might have stopped on the
+                              ;; ';' in a K&R argdecl.  In
+                              ;; that case the declaration
+                              ;; should contain a block.
+                              (c-in-knr-argdecl))))))
         (setq decl-result
               (car (c-beginning-of-decl-1
                     ;; NOTE: If we're in a K&R region, this might be the start
@@ -1460,17 +1486,9 @@ No indentation or other \"electric\" behavior is performed."
                          (c-safe-position least-enclosing paren-state)))))
 
         ;; Has the declaration we've gone back to got braces?
-        (or (eq decl-result 'label)
-            (setq brace-decl-p
-                  (save-excursion
-                    (and (c-syntactic-re-search-forward "[;{]" nil t t)
-                         (or (eq (char-before) ?\{)
-                             (and c-recognize-knr-p
-                                  ;; Might have stopped on the
-                                  ;; ';' in a K&R argdecl.  In
-                                  ;; that case the declaration
-                                  ;; should contain a block.
-                                  (c-in-knr-argdecl)))))))
+        (if (or (eq decl-result 'label)
+                (looking-at c-protection-key))
+            (setq brace-decl-p nil))
 
         (cond
          ((or (eq decl-result 'label)   ; e.g. "private:" or invalid syntax.
@@ -1817,251 +1835,298 @@ the open-parenthesis that starts a defun; see `beginning-of-defun'."
       (c-keep-region-active)
       (= arg 0))))
 
-(defun c-defun-name ()
-  "Return the name of the current defun, or NIL if there isn't one.
-\"Defun\" here means a function, or other top level construct
-with a brace block."
+(defun c-defun-name-1 ()
+  "Return the name of the current defun, at the current narrowing,
+or NIL if there isn't one.  \"Defun\" here means a function, or
+other top level construct with a brace block."
   (c-save-buffer-state
       (beginning-of-defun-function end-of-defun-function
-       where pos name-end case-fold-search)
+       where pos decl name-start name-end case-fold-search)
+
+    (save-excursion
+      ;; Move back out of any macro/comment/string we happen to be in.
+      (c-beginning-of-macro)
+      (setq pos (c-literal-start))
+      (if pos (goto-char pos))
+
+      (setq where (c-where-wrt-brace-construct))
+
+      ;; Move to the beginning of the current defun, if any, if we're not
+      ;; already there.
+      (if (memq where '(outwith-function at-function-end))
+          nil
+        (unless (eq where 'at-header)
+          (c-backward-to-nth-BOF-{ 1 where)
+          (c-beginning-of-decl-1))
+        (when (looking-at c-typedef-key)
+          (goto-char (match-end 0))
+          (c-forward-syntactic-ws))
+
+        ;; Pick out the defun name, according to the type of defun.
+        (cond
+         ;; struct, union, enum, or similar:
+         ((save-excursion
+            (and
+             (looking-at c-defun-type-name-decl-key)
+             (consp (c-forward-decl-or-cast-1 (c-point 'bosws) 'top nil))
+             (or (not (or (eq (char-after) ?{)
+                          (and c-recognize-knr-p
+                               (c-in-knr-argdecl))))
+                 (progn (c-backward-syntactic-ws)
+                        (not (eq (char-before) ?\)))))))
+          (let ((key-pos (point)))
+            (c-forward-over-token-and-ws) ; over "struct ".
+            (cond
+             ((looking-at c-symbol-key) ; "struct foo { ..."
+              (buffer-substring-no-properties key-pos (match-end 0)))
+             ((eq (char-after) ?{)      ; "struct { ... } foo"
+              (when (c-go-list-forward)
+                (c-forward-syntactic-ws)
+                (when (looking-at c-symbol-key) ; a bit bogus - there might
+                                        ; be several identifiers.
+                  (match-string-no-properties 0)))))))
+
+         ((looking-at "DEFUN\\s-*(")    ;"DEFUN\\_>") think of XEmacs!
+          ;; DEFUN ("file-name-directory", Ffile_name_directory, Sfile_name_directory, ...) ==> Ffile_name_directory
+          ;; DEFUN(POSIX::STREAM-LOCK, stream lockp &key BLOCK SHARED START LENGTH) ==> POSIX::STREAM-LOCK
+          (down-list 1)
+          (c-forward-syntactic-ws)
+          (when (eq (char-after) ?\")
+            (forward-sexp 1)
+            (c-forward-token-2))        ; over the comma and following WS.
+          (buffer-substring-no-properties
+           (point)
+           (progn
+             (c-forward-token-2)
+             (c-backward-syntactic-ws)
+             (point))))
+
+         (t
+          ;; Normal function or initializer.
+          (when
+              (and
+               (consp
+                (setq decl
+                      (c-forward-decl-or-cast-1 (c-point 'bosws) 'top nil)))
+               (setq name-start (car decl))
+               (progn (if (and (looking-at c-after-suffixed-type-decl-key)
+                               (match-beginning 1))
+                          (c-forward-keyword-clause 1))
+                      t)
+               (or (eq (char-after) ?{)
+                   (and c-recognize-knr-p
+                        (c-in-knr-argdecl)))
+               (goto-char name-start)
+               (c-forward-name)
+               (eq (char-after) ?\())
+            (c-backward-syntactic-ws)
+            (when (eq (char-before) ?\=) ; struct foo bar = {0, 0} ;
+              (c-backward-token-2)
+              (c-backward-syntactic-ws))
+            (setq name-end (point))
+            (c-back-over-compound-identifier)
+            (and (looking-at c-symbol-start)
+                 (buffer-substring-no-properties (point) name-end)))))))))
 
+(defun c-defun-name ()
+  "Return the name of the current defun, or NIL if there isn't one.
+\"Defun\" here means a function, or other top level construct
+with a brace block, at the outermost level of nesting."
+  (c-save-buffer-state ()
     (save-restriction
       (widen)
-      (save-excursion
-        ;; Move back out of any macro/comment/string we happen to be in.
-        (c-beginning-of-macro)
-        (setq pos (c-literal-start))
-        (if pos (goto-char pos))
-
-        (setq where (c-where-wrt-brace-construct))
-
-        ;; Move to the beginning of the current defun, if any, if we're not
-        ;; already there.
-        (if (eq where 'outwith-function)
-            nil
-          (unless (eq where 'at-header)
-            (c-backward-to-nth-BOF-{ 1 where)
-            (c-beginning-of-decl-1))
-          (when (looking-at c-typedef-key)
-            (goto-char (match-end 0))
-            (c-forward-syntactic-ws))
-
-          ;; Pick out the defun name, according to the type of defun.
-          (cond
-           ;; struct, union, enum, or similar:
-           ((save-excursion
-              (and
-               (looking-at c-type-prefix-key)
-               (consp (c-forward-decl-or-cast-1 (c-point 'bosws) 'top nil))
-               (or (not (or (eq (char-after) ?{)
-                            (and c-recognize-knr-p
-                                 (c-in-knr-argdecl))))
-                   (progn (c-backward-syntactic-ws)
-                          (not (eq (char-before) ?\)))))))
-            (let ((key-pos (point)))
-              (c-forward-over-token-and-ws) ; over "struct ".
-              (cond
-               ((looking-at c-symbol-key)       ; "struct foo { ..."
-                (buffer-substring-no-properties key-pos (match-end 0)))
-               ((eq (char-after) ?{)    ; "struct { ... } foo"
-                (when (c-go-list-forward)
-                  (c-forward-syntactic-ws)
-                  (when (looking-at c-symbol-key) ; a bit bogus - there might
-                                                  ; be several identifiers.
-                    (match-string-no-properties 0)))))))
-
-           ((looking-at "DEFUN\\s-*(") ;"DEFUN\\_>") think of XEmacs!
-            ;; DEFUN ("file-name-directory", Ffile_name_directory, Sfile_name_directory, ...) ==> Ffile_name_directory
-            ;; DEFUN(POSIX::STREAM-LOCK, stream lockp &key BLOCK SHARED START LENGTH) ==> POSIX::STREAM-LOCK
-            (down-list 1)
-            (c-forward-syntactic-ws)
-            (when (eq (char-after) ?\")
-              (forward-sexp 1)
-              (c-forward-token-2))      ; over the comma and following WS.
-            (buffer-substring-no-properties
-             (point)
-             (progn
-               (c-forward-token-2)
-               (when (looking-at ":")  ; CLISP: DEFUN(PACKAGE:LISP-SYMBOL,...)
-                 (skip-chars-forward "^,"))
-               (c-backward-syntactic-ws)
-               (point))))
-
-           ((looking-at "DEF[a-zA-Z0-9_]* *( *\\([^, ]*\\) *,")
-            ;; DEFCHECKER(sysconf_arg,prefix=_SC,default=, ...) ==> sysconf_arg
-            ;; DEFFLAGSET(syslog_opt_flags,LOG_PID ...) ==> syslog_opt_flags
-            (match-string-no-properties 1))
-
-           ;; Objc selectors.
-           ((assq 'objc-method-intro (c-guess-basic-syntax))
-            (let ((bound (save-excursion (c-end-of-statement) (point)))
-                  (kw-re (concat "\\(?:" c-symbol-key "\\)?:"))
-                  (stretches))
-              (when (c-syntactic-re-search-forward c-symbol-key bound t t t)
-                (push (match-string-no-properties 0) stretches)
-                (while (c-syntactic-re-search-forward kw-re bound t t t)
-                  (push (match-string-no-properties 0) stretches)))
-              (apply 'concat (nreverse stretches))))
-
-           (t
-            ;; Normal function or initializer.
-            (when
-                (and
-                 (consp (c-forward-decl-or-cast-1 (c-point 'bosws) 'top nil))
-                 (or (eq (char-after) ?{)
-                     (and c-recognize-knr-p
-                          (c-in-knr-argdecl)))
-                 (progn
-                   (c-backward-syntactic-ws)
-                   (eq (char-before) ?\)))
-                 (c-go-list-backward))
-              (c-backward-syntactic-ws)
-              (when (eq (char-before) ?\=) ; struct foo bar = {0, 0} ;
-                (c-backward-token-2)
-                (c-backward-syntactic-ws))
-              (setq name-end (point))
-              (c-back-over-compound-identifier)
-              (and (looking-at c-symbol-start)
-                   (buffer-substring-no-properties (point) name-end))))))))))
+      (c-defun-name-1))))
 
-(defun c-declaration-limits (near)
-  ;; Return a cons of the beginning and end positions of the current
-  ;; top level declaration or macro.  If point is not inside any then
-  ;; nil is returned, unless NEAR is non-nil in which case the closest
-  ;; following one is chosen instead (if there is any).  The end
+(defun c-declaration-limits-1 (near)
+  ;; Return a cons of the beginning and end position of the current
+  ;; declaration or macro in the current narrowing.  If there is no current
+  ;; declaration or macro, return nil, unless NEAR is non-nil, in which case
+  ;; the closest following one is chosen instead (if there is any).  The end
   ;; position is at the next line, providing there is one before the
   ;; declaration.
   ;;
   ;; This function might do hidden buffer changes.
   (save-excursion
-    (save-restriction
-      (let ((start (point))
-            (paren-state (c-parse-state))
-            lim pos end-pos where)
-        ;; Narrow enclosing brace blocks out, as required by the values of
-        ;; `c-defun-tactic', `near', and the position of point.
-        (when (eq c-defun-tactic 'go-outward)
-          (let ((bounds
-                 (save-restriction
-                   (if (and (not (save-excursion (c-beginning-of-macro)))
-                            (save-restriction
-                              (c-narrow-to-most-enclosing-decl-block)
-                              (memq (c-where-wrt-brace-construct)
-                                    '(at-function-end outwith-function)))
-                            (not near))
-                       (c-narrow-to-most-enclosing-decl-block nil 2)
-                     (c-narrow-to-most-enclosing-decl-block))
-                   (cons (point-min) (point-max)))))
-            (narrow-to-region (car bounds) (cdr bounds))))
-        (setq paren-state (c-parse-state))
-
-        (or
-         ;; Note: Some code duplication in `c-beginning-of-defun' and
-         ;; `c-end-of-defun'.
-         (catch 'exit
-           (unless (c-safe
-                     (goto-char (c-least-enclosing-brace paren-state))
-                     ;; If we moved to the outermost enclosing paren
-                     ;; then we can use c-safe-position to set the
-                     ;; limit. Can't do that otherwise since the
-                     ;; earlier paren pair on paren-state might very
-                     ;; well be part of the declaration we should go
-                     ;; to.
-                     (setq lim (c-safe-position (point) paren-state))
-                     t)
-             ;; At top level.  Make sure we aren't inside a literal.
-             (setq pos (c-literal-start
-                        (c-safe-position (point) paren-state)))
-             (if pos (goto-char pos)))
-
-           (when (c-beginning-of-macro)
+    (let ((start (point))
+          (paren-state (c-parse-state))
+          lim pos end-pos where)
+      (or
+       ;; Note: Some code duplication in `c-beginning-of-defun' and
+       ;; `c-end-of-defun'.
+       (catch 'exit
+         (unless (c-safe
+                   (goto-char (c-least-enclosing-brace paren-state))
+                   ;; If we moved to the outermost enclosing paren
+                   ;; then we can use c-safe-position to set the
+                   ;; limit. Can't do that otherwise since the
+                   ;; earlier paren pair on paren-state might very
+                   ;; well be part of the declaration we should go
+                   ;; to.
+                   (setq lim (c-safe-position (point) paren-state))
+                   ;; We might have a struct foo {...} as the type of the
+                   ;; function, so set LIM back one further block.
+                   (if (eq (char-before lim) ?})
+                       (setq lim
+                             (or
+                              (save-excursion
+                                (and
+                                 (c-go-list-backward lim)
+                                 (let ((paren-state-1 (c-parse-state)))
+                                   (c-safe-position
+                                    (point) paren-state-1))))
+                              (point-min))))
+                   t)
+           ;; At top level.  Make sure we aren't inside a literal.
+           (setq pos (c-literal-start
+                      (c-safe-position (point) paren-state)))
+           (if pos (goto-char pos)))
+
+         (when (c-beginning-of-macro)
+           (throw 'exit
+                  (cons (point)
+                        (save-excursion
+                          (c-end-of-macro)
+                          (forward-line 1)
+                          (point)))))
+
+         (setq pos (point))
+         (setq where (and (not (save-excursion (c-beginning-of-macro)))
+                          (c-where-wrt-brace-construct)))
+         (when (and (not (eq where 'at-header))
+                    (or (and near
+                             (memq where
+                                   '(at-function-end outwith-function))
+                             ;; Check we're not inside a declaration without
+                             ;; braces.
+                             (save-excursion
+                               (memq (car (c-beginning-of-decl-1 lim))
+                                     '(previous label))))
+                        (eq (car (c-beginning-of-decl-1 lim)) 'previous)
+                        (= pos (point))))
+           ;; We moved back over the previous defun.  Skip to the next
+           ;; one.  Not using c-forward-syntactic-ws here since we
+           ;; should not skip a macro.  We can also be directly after
+           ;; the block in a `c-opt-block-decls-with-vars-key'
+           ;; declaration, but then we won't move significantly far
+           ;; here.
+           (goto-char pos)
+           (c-forward-comments)
+
+           (when (and near (c-beginning-of-macro))
              (throw 'exit
                     (cons (point)
                           (save-excursion
                             (c-end-of-macro)
                             (forward-line 1)
-                            (point)))))
+                            (point))))))
 
-           (setq pos (point))
-           (setq where (and (not (save-excursion (c-beginning-of-macro)))
-                            (c-where-wrt-brace-construct)))
-           (when (and (not (eq where 'at-header))
-                      (or (and near
-                               (memq where
-                                     '(at-function-end outwith-function)))
-                          (eq (car (c-beginning-of-decl-1 lim)) 'previous)
-                          (= pos (point))))
-             ;; We moved back over the previous defun.  Skip to the next
-             ;; one.  Not using c-forward-syntactic-ws here since we
-             ;; should not skip a macro.  We can also be directly after
-             ;; the block in a `c-opt-block-decls-with-vars-key'
-             ;; declaration, but then we won't move significantly far
-             ;; here.
-             (goto-char pos)
-             (c-forward-comments)
-
-             (when (and near (c-beginning-of-macro))
-               (throw 'exit
-                      (cons (point)
-                            (save-excursion
-                              (c-end-of-macro)
-                              (forward-line 1)
-                              (point))))))
+         (if (eobp) (throw 'exit nil))
 
-           (if (eobp) (throw 'exit nil))
+         ;; Check if `c-beginning-of-decl-1' put us after the block in a
+         ;; declaration that doesn't end there.  We're searching back and
+         ;; forth over the block here, which can be expensive.
+         (setq pos (point))
+         (if (and c-opt-block-decls-with-vars-key
+                  (progn
+                    (c-backward-syntactic-ws)
+                    (eq (char-before) ?}))
+                  (eq (car (c-beginning-of-decl-1))
+                      'previous)
+                  (save-excursion
+                    (c-end-of-decl-1)
+                    (and (> (point) pos)
+                         (setq end-pos (point)))))
+             nil
+           (goto-char pos))
+
+         (if (or (and (not near) (> (point) start))
+                 (not (eq (c-where-wrt-brace-construct) 'at-header)))
+             nil
+
+           ;; Try to be line oriented; position the limits at the
+           ;; closest preceding boi, and after the next newline, that
+           ;; isn't inside a comment, but if we hit a neighboring
+           ;; declaration then we instead use the exact declaration
+           ;; limit in that direction.
+           (cons (progn
+                   (setq pos (point))
+                   (while (and (/= (point) (c-point 'boi))
+                               (c-backward-single-comment)))
+                   (if (/= (point) (c-point 'boi))
+                       pos
+                     (point)))
+                 (progn
+                   (if end-pos
+                       (goto-char end-pos)
+                     (c-end-of-decl-1))
+                   (setq pos (point))
+                   (while (and (not (bolp))
+                               (not (looking-at "\\s *$"))
+                               (c-forward-single-comment)))
+                   (cond ((bolp)
+                          (point))
+                         ((looking-at "\\s *$")
+                          (forward-line 1)
+                          (point))
+                         (t
+                          pos))))))
+       (and (not near)
+            (goto-char (point-min))
+            (c-forward-decl-or-cast-1 -1 nil nil)
+            (eq (char-after) ?\{)
+            (cons (point-min) (point-max)))))))
 
-           ;; Check if `c-beginning-of-decl-1' put us after the block in a
-           ;; declaration that doesn't end there.  We're searching back and
-           ;; forth over the block here, which can be expensive.
-           (setq pos (point))
-           (if (and c-opt-block-decls-with-vars-key
-                    (progn
-                      (c-backward-syntactic-ws)
-                      (eq (char-before) ?}))
-                    (eq (car (c-beginning-of-decl-1))
-                        'previous)
-                    (save-excursion
-                      (c-end-of-decl-1)
-                      (and (> (point) pos)
-                           (setq end-pos (point)))))
-               nil
-             (goto-char pos))
-
-           (if (and (not near) (> (point) start))
-               nil
-
-             ;; Try to be line oriented; position the limits at the
-             ;; closest preceding boi, and after the next newline, that
-             ;; isn't inside a comment, but if we hit a neighboring
-             ;; declaration then we instead use the exact declaration
-             ;; limit in that direction.
-             (cons (progn
-                     (setq pos (point))
-                     (while (and (/= (point) (c-point 'boi))
-                                 (c-backward-single-comment)))
-                     (if (/= (point) (c-point 'boi))
-                         pos
-                       (point)))
-                   (progn
-                     (if end-pos
-                         (goto-char end-pos)
-                       (c-end-of-decl-1))
-                     (setq pos (point))
-                     (while (and (not (bolp))
-                                 (not (looking-at "\\s *$"))
-                                 (c-forward-single-comment)))
-                     (cond ((bolp)
-                            (point))
-                           ((looking-at "\\s *$")
-                            (forward-line 1)
-                            (point))
-                           (t
-                            pos))))))
-         (and (not near)
-              (goto-char (point-min))
-              (c-forward-decl-or-cast-1 -1 nil nil)
-              (eq (char-after) ?\{)
-              (cons (point-min) (point-max))))))))
+(defun c-declaration-limits (near)
+  ;; Return a cons of the beginning and end positions of the current
+  ;; top level declaration or macro.  If point is not inside any then
+  ;; nil is returned, unless NEAR is non-nil in which case the closest
+  ;; following one is chosen instead (if there is any).  The end
+  ;; position is at the next line, providing there is one before the
+  ;; declaration.
+  ;;
+  ;; This function might do hidden buffer changes.
+  (save-restriction
+    ;; Narrow enclosing brace blocks out, as required by the values of
+    ;; `c-defun-tactic', `near', and the position of point.
+    (when (eq c-defun-tactic 'go-outward)
+      (let ((bounds
+             (save-restriction
+               (if (and (not (save-excursion (c-beginning-of-macro)))
+                        (save-restriction
+                          (c-narrow-to-most-enclosing-decl-block)
+                          (memq (c-where-wrt-brace-construct)
+                                '(at-function-end outwith-function)))
+                        (not near))
+                   (c-narrow-to-most-enclosing-decl-block nil 2)
+                 (c-narrow-to-most-enclosing-decl-block))
+               (cons (point-min) (point-max)))))
+        (narrow-to-region (car bounds) (cdr bounds))))
+    (c-declaration-limits-1 near)))
+
+(defun c-defun-name-and-limits (near)
+  ;; Return a cons of the name and limits (itself a cons) of the current
+  ;; top-level declaration or macro, or nil of there is none.
+  ;;
+  ;; If `c-defun-tactic' is 'go-outward, we return the name and limits of the
+  ;; most tightly enclosing declaration or macro.  Otherwise, we return that
+  ;; at the file level.
+  (save-restriction
+    (widen)
+    (if (eq c-defun-tactic 'go-outward)
+        (c-save-buffer-state ((paren-state (c-parse-state))
+                              (orig-point-min (point-min))
+                              (orig-point-max (point-max))
+                              lim name where limits fdoc)
+          (setq lim (c-widen-to-enclosing-decl-scope
+                     paren-state orig-point-min orig-point-max))
+          (and lim (setq lim (1- lim)))
+          (c-while-widening-to-decl-block (not (setq name (c-defun-name-1))))
+          (when name
+            (setq limits (c-declaration-limits-1 near))
+            (cons name limits)))
+      (c-save-buffer-state ((name (c-defun-name))
+                            (limits (c-declaration-limits near)))
+        (and name limits (cons name limits))))))
 
 (defun c-display-defun-name (&optional arg)
   "Display the name of the current CC mode defun and the position in it.
@@ -2069,12 +2134,13 @@ With a prefix arg, push the name onto the kill ring too."
   (interactive "P")
   (save-restriction
     (widen)
-    (c-save-buffer-state ((name (c-defun-name))
-                          (limits (c-declaration-limits t))
+    (c-save-buffer-state ((name-and-limits (c-defun-name-and-limits nil))
+                          (name (car name-and-limits))
+                          (limits (cdr name-and-limits))
                           (point-bol (c-point 'bol)))
       (when name
         (message "%s.  Line %s/%s." name
-                 (1+ (count-lines (car limits) point-bol))
+                 (1+ (count-lines (car limits) (max point-bol (car limits))))
                  (count-lines (car limits) (cdr limits)))
         (if arg (kill-new name))
         (sit-for 3 t)))))
diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index b78e85a6708..ceeee6b357d 100644
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -1124,7 +1124,16 @@ comment at the start of cc-engine.el for more info."
                            (not (c-looking-at-inexpr-block lim nil t))
                            (save-excursion
                              (c-backward-token-2 1 t nil)
-                             (not (looking-at "=\\([^=]\\|$\\)"))))
+                             (not (looking-at "=\\([^=]\\|$\\)")))
+                           (or
+                            (not c-opt-block-decls-with-vars-key)
+                            (save-excursion
+                              (c-backward-token-2 1 t nil)
+                              (if (and (looking-at c-symbol-start)
+                                       (not (looking-at c-keywords-regexp)))
+                                  (c-backward-token-2 1 t nil))
+                              (not (looking-at
+                                    c-opt-block-decls-with-vars-key)))))
                           (save-excursion
                             (c-forward-sexp) (point)))
                          ;; Just gone back over some paren block?
diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index c06dd2164db..f1ef89a76ad 100644
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -2107,6 +2107,18 @@ will be handled."
   "Alist associating keywords in c-other-decl-block-decl-kwds with
 their matching \"in\" syntactic symbols.")
 
+(c-lang-defconst c-defun-type-name-decl-kwds
+  "Keywords introducing a named block, where the name is a \"defun\"
+    name."
+  t (append (c-lang-const c-class-decl-kwds)
+            (c-lang-const c-brace-list-decl-kwds)))
+
+(c-lang-defconst c-defun-type-name-decl-key
+  ;; Regexp matching a keyword in `c-defun-name-decl-kwds'.
+  t (c-make-keywords-re t (c-lang-const c-defun-type-name-decl-kwds)))
+(c-lang-defvar c-defun-type-name-decl-key
+  (c-lang-const c-defun-type-name-decl-key))
+
 (c-lang-defconst c-typedef-decl-kwds
   "Keywords introducing declarations where the identifier(s) being
 declared are types.