 (c-lang-defconst c-modifier-kwds
   csharp '("public" "partial" "private" "const" "abstract" "sealed"
            "protected" "ref" "out" "static" "virtual"
-           "override" "params" "internal"))
+           "override" "params" "internal" "async"))
 
 
 ;; Thu, 22 Apr 2010  23:02

                       nil))
                  )))


           ;; Case 3: declaration of constructor
           ;;
           ;; Example:
           ;;
           ;; private Foo(...) {...}
           ;;
           ,@(when t
               `((,(byte-compile
                    `(lambda (limit)
                       (let ((parse-sexp-lookup-properties
                              (cc-eval-when-compile
                                (boundp 'parse-sexp-lookup-properties)))
                             (found-it nil))
                         (while (re-search-forward
                                 ,(concat
                                   "^[ \t\n\r\f\v]*"
                                   "\\(\\<\\(public\\|private\\|protected\\)\\)?[ \t\n\r\f\v]+"
                                   "\\(@?[[:alpha:]_][[:alnum:]_]*\\)" ;; name of constructor
                                   "[ \t\n\r\f\v]*"
                                   "\\("
                                   "("
                                   "\\)")
                                 limit t)

                           (unless
                               (progn
                                 (goto-char (match-beginning 0))
                                 (c-skip-comments-and-strings limit))

                             (goto-char (match-end 0))

                             (csharp-log 3 "ctor decl? L(%d) B(%d) E(%d)"
                                         limit (match-beginning 0) (point))

                             (backward-char 1) ;; just left of the open paren
                             (save-match-data
                               ;; Jump over the parens, safely.
                               ;; If it's an unbalanced paren, no problem,
                               ;; do nothing.
                               (if (c-safe (c-forward-sexp 1) t)
                                   (progn
                                     (c-forward-syntactic-ws)
                                     (cond

                                      ;; invokes base or this constructor.
                                      ((re-search-forward
                                        ,(concat
                                          "\\(:[ \t\n\r\f\v]*\\(base\\|this\\)\\)"
                                          "[ \t\n\r\f\v]*"
                                          "("
                                          )
                                        limit t)
                                       (csharp-log 3 " - ctor with dependency?")

                                       (goto-char (match-end 0))
                                       (backward-char 1) ;; just left of the open paren
                                       (csharp-log 3 " - before paren at %d" (point))

                                       (if (c-safe (c-forward-sexp 1) t)
                                           (progn
                                             (c-forward-syntactic-ws)
                                             (csharp-log 3 " - skipped over paren pair %d" (point))
                                             (if (eq (char-after) ?{)
                                                 (setq found-it t)))))

                                      ;; open curly. no depedency on other ctor.
                                      ((eq (char-after) ?{)
                                       (csharp-log 3 " - no dependency, curly at %d" (point))
                                       (setq found-it t)))

                                     )))

                             (if found-it
                                 ;; fontify the constructor symbol
                                 (c-put-font-lock-face (match-beginning 3)
                                                       (match-end 3)
                                                       'font-lock-function-name-face))
                             (goto-char (match-end 0)))))
                       nil)))))


           ;; Case 4: using clause. Without this, using (..) gets fontified as a fn.
           ,@(when t
               `((,(byte-compile

            (cond
             ((string-match "[ \t\f\v\n\r]" cs)
              t)
	     ((string-match "[=]" cs)
	      ;; = means what we slurped was a default-value for a param
	      ;; go back to slurping param-name
	      (setq state 0))
             ;; non-ws indicates the type spec is beginning
             (t
              (incf i)
