[Emacs-diffs] trunk r117817: * lisp/emacs-lisp/eldoc.el (eldoc-highlight-function-argument): Handle the

[Stefan Monnier]

------------------------------------------------------------
revno: 117817
revision-id: address@hidden
parent: address@hidden
fixes bug: http://debbugs.gnu.org/cgi/bugreport.cgi?bug=18048
author: Thierry Volpiatto <address@hidden>
committer: Stefan Monnier <address@hidden>
branch nick: trunk
timestamp: Thu 2014-09-04 10:49:56 -0400
message:
  * lisp/emacs-lisp/eldoc.el (eldoc-highlight-function-argument): Handle the
  case where we're currently providing part of the &rest arg after some
  &key args, as in define-ibuffer-op.
modified:
  lisp/ChangeLog                 changelog-20091113204419-o5vbwnq5f7feedwu-1432
  lisp/emacs-lisp/eldoc.el       eldoc.el-20091113204419-o5vbwnq5f7feedwu-952

=== modified file 'lisp/ChangeLog'
--- a/lisp/ChangeLog    2014-09-03 19:10:15 +0000
+++ b/lisp/ChangeLog    2014-09-04 14:49:56 +0000
@@ -1,3 +1,9 @@
+2014-09-04  Thierry Volpiatto  <address@hidden>
+
+       * emacs-lisp/eldoc.el (eldoc-highlight-function-argument): Handle the
+       case where we're currently providing part of the &rest arg after some
+       &key args, as in define-ibuffer-op (bug#18048).
+
 2014-09-03  Stefan Monnier  <address@hidden>
 
        * progmodes/which-func.el (which-func-ff-hook): Obey pre-existing

=== modified file 'lisp/emacs-lisp/eldoc.el'
--- a/lisp/emacs-lisp/eldoc.el  2014-08-18 19:28:40 +0000
+++ b/lisp/emacs-lisp/eldoc.el  2014-09-04 14:49:56 +0000
@@ -369,9 +369,16 @@
 (defun eldoc-highlight-function-argument (sym args index)
   "Highlight argument INDEX in ARGS list for function SYM.
 In the absence of INDEX, just call `eldoc-docstring-format-sym-doc'."
+  ;; FIXME: This should probably work on the list representation of `args'
+  ;; rather than its string representation.
+  ;; FIXME: This function is much too long, we need to split it up!
   (let ((start          nil)
        (end            0)
-       (argument-face  'eldoc-highlight-function-argument))
+       (argument-face  'eldoc-highlight-function-argument)
+        (args-lst (mapcar (lambda (x)
+                            (replace-regexp-in-string
+                             "\\`[(]\\|[)]\\'" "" x))
+                          (split-string args))))
     ;; Find the current argument in the argument string.  We need to
     ;; handle `&rest' and informal `...' properly.
     ;;
@@ -385,23 +392,53 @@
     ;; position in ARGS based on this current arg.
     (when (string-match "&key" args)
       (let* (case-fold-search
+             key-have-value
+             (sym-name (symbol-name sym))
              (cur-w (current-word))
+             (args-lst-ak (cdr (member "&key" args-lst)))
              (limit (save-excursion
-                      (when (re-search-backward (symbol-name sym) nil t)
+                      (when (re-search-backward sym-name nil t)
                         (match-end 0))))
-             (cur-a (if (string-match ":\\([^ ()]*\\)" cur-w)
+             (cur-a (if (and cur-w (string-match ":\\([^ ()]*\\)" cur-w))
                         (substring cur-w 1)
                       (save-excursion
-                        (when (re-search-backward ":\\([^ ()\n]*\\)" limit t)
-                            (match-string 1))))))
-        ;; If `cur-a' is nil probably cursor is on a positional arg
-        ;; before `&key', in this case, exit this block and determine
-        ;; position with `index'.
-        (when (and cur-a
-                   (string-match (concat "\\_<" (upcase cur-a) "\\_>") args))
-          (setq index nil ; Skip next block based on positional args.
-                start (match-beginning 0)
-                end   (match-end 0)))))
+                        (let (split)
+                          (when (re-search-backward ":\\([^()\n]*\\)" limit t)
+                            (setq split (split-string (match-string 1) " " t))
+                            (prog1 (car split)
+                              (when (cdr split)
+                                (setq key-have-value t))))))))
+             ;; If `cur-a' is not one of `args-lst-ak'
+             ;; assume user is entering an unknow key
+             ;; referenced in last position in signature.
+             (other-key-arg (and (stringp cur-a)
+                                 args-lst-ak
+                                 (not (member (upcase cur-a) args-lst-ak))
+                                 (upcase (car (last args-lst-ak))))))
+        (unless (string= cur-w sym-name)
+          ;; The last keyword have already a value
+          ;; i.e :foo a b and cursor is at b.
+          ;; If signature have also `&rest'
+          ;; (assume it is after the `&key' section)
+          ;; go to the arg after `&rest'.
+          (if (and key-have-value
+                   (save-excursion
+                     (not (re-search-forward ":.*" (point-at-eol) t)))
+                   (string-match "&rest \\([^ ()]*\\)" args))
+              (setq index nil ; Skip next block based on positional args.
+                    start (match-beginning 1)
+                    end   (match-end 1))
+            ;; If `cur-a' is nil probably cursor is on a positional arg
+            ;; before `&key', in this case, exit this block and determine
+            ;; position with `index'.
+            (when (and cur-a     ; A keyword arg (dot removed) or nil.
+                       (or (string-match
+                            (concat "\\_<" (upcase cur-a) "\\_>") args)
+                           (string-match
+                            (concat "\\_<" other-key-arg "\\_>") args)))
+              (setq index nil ; Skip next block based on positional args.
+                    start (match-beginning 0)
+                    end   (match-end 0)))))))
     ;; Handle now positional arguments.
     (while (and index (>= index 1))
       (if (string-match "[^ ()]+" args end)
@@ -412,12 +449,15 @@
              (cond ((string= argument "&rest")
                     ;; All the rest arguments are the same.
                     (setq index 1))
-                   ((string= argument "&optional")) ; Skip.
+                   ((string= argument "&optional"))         ; Skip.
                     ((string= argument "&allow-other-keys")) ; Skip.
                     ;; Back to index 0 in ARG1 ARG2 ARG2 ARG3 etc...
                     ;; like in `setq'.
-                   ((or (string-match-p "\\.\\.\\.$" argument)
-                         (and (string-match-p "\\.\\.\\.)?$" args)
+                   ((or (and (string-match-p "\\.\\.\\.$" argument)
+                              (string= argument (car (last args-lst))))
+                         (and (string-match-p "\\.\\.\\.$"
+                                              (substring args 1 (1- (length 
args))))
+                              (= (length (remove "..." args-lst)) 2)
                               (> index 1) (cl-oddp index)))
                      (setq index 0))
                    (t