Cope better with C++ and Objective-C protection keywords in class declarations

This fix fixes the fontification of a method inside a class at the time it is
typed, when there is a protection keyword clause preceding it.

* lisp/progmodes/cc-engine.el (c-forward-keyword-clause): Handle protection
keywords.
(c-looking-at-decl-block): Avoid scanning forward over protection keyword
clauses too eagerly.

* lisp/progmodes/cc-langs.el (c-protection-key c-post-protection-token): New
lang defconsts and defvars.

* lisp/progmodes/cc-mode.el (c-fl-decl-start): When we encounter a protection
keyword following a semicolon or brace, move forward over it before attempting
to parse a type.

diff --git a/lisp/progmodes/cc-engine.el b/lisp/progmodes/cc-engine.el
index d5083ed2481abef95e58839d40efab6219e34fd7..05b391a3d3876eee3f31268254ed6de64a5880e0 100644 (file)
--- a/lisp/progmodes/cc-engine.el
+++ b/lisp/progmodes/cc-engine.el
@@ -6924,7 +6924,7 @@ comment at the start of cc-engine.el for more info."
   ;; recognized are those specified by `c-type-list-kwds',
   ;; `c-ref-list-kwds', `c-colon-type-list-kwds',
   ;; `c-paren-nontype-kwds', `c-paren-type-kwds', `c-<>-type-kwds',
-  ;; and `c-<>-arglist-kwds'.
+  ;; `c-<>-arglist-kwds', and `c-protection-kwds'.
   ;;
   ;; This function records identifier ranges on
   ;; `c-record-type-identifiers' and `c-record-ref-identifiers' if
@@ -6994,6 +6994,17 @@ comment at the start of cc-engine.el for more info."
             (not (looking-at c-symbol-start))
             (c-safe (c-forward-sexp) t))
        (c-forward-syntactic-ws)
+       (setq safe-pos (point)))
+
+       ((and (c-keyword-member kwd-sym 'c-protection-kwds)
+            (or (null c-post-protection-token)
+                (and (looking-at c-post-protection-token)
+                     (save-excursion
+                       (goto-char (match-end 0))
+                       (not (c-end-of-current-token))))))
+       (if c-post-protection-token
+           (goto-char (match-end 0)))
+       (c-forward-syntactic-ws)
        (setq safe-pos (point))))
 
       (when (c-keyword-member kwd-sym 'c-colon-type-list-kwds)
@@ -10169,8 +10180,16 @@ comment at the start of cc-engine.el for more info."
                  ;; Could be more restrictive wrt invalid keywords,
                  ;; but that'd only occur in invalid code so there's
                  ;; no use spending effort on it.
-                 (let ((end (match-end 0)))
-                   (unless (c-forward-keyword-clause 0)
+                 (let ((end (match-end 0))
+                       (kwd-sym (c-keyword-sym (match-string 0))))
+                   (unless
+                       (and kwd-sym
+                            ;; Moving over a protection kwd and the following
+                            ;; ":" (in C++ Mode) to the next token could take
+                            ;; us all the way up to `kwd-start', leaving us
+                            ;; no chance to update `first-specifier-pos'.
+                            (not (c-keyword-member kwd-sym 'c-protection-kwds))
+                            (c-forward-keyword-clause 0))
                      (goto-char end)
                      (c-forward-syntactic-ws)))
 

diff --git a/lisp/progmodes/cc-langs.el b/lisp/progmodes/cc-langs.el
index ef6b88c372768b349a0349e635f3632fc4191d50..7a285f93d34c9ed25d95806e2cf17f302fb99659 100644 (file)
--- a/lisp/progmodes/cc-langs.el
+++ b/lisp/progmodes/cc-langs.el
@@ -2284,6 +2284,18 @@ one of `c-type-list-kwds', `c-ref-list-kwds',
   c++  '("private" "protected" "public")
   objc '("@private" "@protected" "@public"))
 
+(c-lang-defconst c-protection-key
+  ;; A regexp match an element of `c-protection-kwds' cleanly.
+  t (c-make-keywords-re t (c-lang-const c-protection-kwds)))
+(c-lang-defvar c-protection-key (c-lang-const c-protection-key))
+
+(c-lang-defconst c-post-protection-token
+  "The token which (may) follow a protection keyword,
+e.g. the \":\" in C++ Mode's \"public:\".  nil if there is no such token."
+  t    nil
+  c++  ":")
+(c-lang-defvar c-post-protection-token (c-lang-const c-post-protection-token))
+
 (c-lang-defconst c-block-decls-with-vars
   "Keywords introducing declarations that can contain a block which
 might be followed by variable declarations, e.g. like \"foo\" in

diff --git a/lisp/progmodes/cc-mode.el b/lisp/progmodes/cc-mode.el
index 354dee82df908c4d5c3d88cb7efd28825e04528b..8867453e85c3cd827f11c402497f57a03c74319b 100644 (file)
--- a/lisp/progmodes/cc-mode.el
+++ b/lisp/progmodes/cc-mode.el
@@ -1526,14 +1526,17 @@ Note that this is a strict tail, so won't match, e.g. \"0x....\".")
         (> (point) bod-lim)
         (progn (c-forward-syntactic-ws)
                (setq bo-decl (point))
-               ;; Are we looking at a keyword such as "template" or
-               ;; "typedef" which can decorate a type, or the type itself?
-               (when (or (looking-at c-prefix-spec-kwds-re)
-                         (c-forward-type t))
-                 ;; We've found another candidate position.
-                 (setq new-pos (min new-pos bo-decl))
-                 (goto-char bo-decl))
-               t)
+               (or (not (looking-at c-protection-key))
+                   (c-forward-keyword-clause 1)))
+        (progn
+          ;; Are we looking at a keyword such as "template" or
+          ;; "typedef" which can decorate a type, or the type itself?
+          (when (or (looking-at c-prefix-spec-kwds-re)
+                    (c-forward-type t))
+            ;; We've found another candidate position.
+            (setq new-pos (min new-pos bo-decl))
+            (goto-char bo-decl))
+          t)
         ;; Try and go out a level to search again.
         (progn
           (c-backward-syntactic-ws bod-lim)