Question

I’m writing a derived mode, based on comint-mode. The mode is an interface to a command line program (GRASS gis), and the comint mode completion works for the programs. I’m trying to add on support for completing the arguments to the program, via completion-at-point-functions. A toy example is:

(setq my-commands 
      '(("ls"
         ("my-completion-1")
         ("my-completion-2"))
        ("mv"
         ("my-completion-3")
         ("my-completion-4"))))


(defun my-completion-at-point ()
  (interactive)
  (let ((pt (point)) ;; collect point
        start end)

    (save-excursion ;; collect the program name
      (comint-bol)
      (re-search-forward "\\(\\S +\\)\\s ?"))
    (if (and (>= pt (match-beginning 1))
             (<= pt (match-end 1)))
        () ;; if we're still entering the command, pass completion on to
      ;; comint-completion-at-point by returning nil

      (let ((command (match-string-no-properties 1)))
        (when (member* command my-commands :test 'string= :key 'car)
          ;; If the command is one of my-commands, use the associated completions 
          (goto-char pt)
          (re-search-backward "\\S *")
          (setq start (point))
          (re-search-forward "\\S *")
          (setq end (point))
          (list start end (cdr (assoc command my-commands)) :exclusive 'no))))))

(push 'my-completion-at-point completion-at-point-functions)

This almost works. I get normal completion of program names. However, if I have entered ls at the command line, hitting tab inserts my-completion- and doesn’t offer the two options. Hitting tab again inserts my-completion- a second time, so that I now have ls my-completion-mycompletion-.

My actual code includes a few lines to check for multi-line commands, but makes no changes to the completion code. With this version of the code, I hitting tab on a line that starts with one of the program names in my-commands I am presented with a list of the possible arguments to complete the command with, but nothing is inserted in the buffer, and the list does not get narrowed by typing the first few letters of an argument.

I’ve been over the manual, but I can’t figure out the correct way to write a completion-at-point function. Any ideas what I’m missing?

I have looked briefly at pcomplete, but the didn’t really understand the ‘documentation’, and didn’t make any progress.

Answer 1

The problem seems to be with the way you’re finding start and end to return the boundaries of the argument at point. I didn’t spend long enough debugging it to be sure of the details, but I think if you call the function interactively you’ll see that it returns the same value for start and end, and this means that the completion UI doesn’t know to use the argument at point to select from the completion table you’ve passed it.

Changing the last part of your function to the following seems to be one fix:

(when (member* command my-commands :test 'string= :key 'car)
  ;; If the command is one of my-commands, use the associated completions 
  (goto-char pt)
  (let ((start
         (save-excursion
           (skip-syntax-backward "^ ")
           (point))))

    (list start pt (cdr (assoc command my-commands)) :exclusive 'no)))))))

This gives the expected results when added as an element of completion-at-point-functions.

Here I’ve used skip-syntax-backward instead of regexp search, which I think is slightly more idiomatic Elisp for this kind of thing. It just says to move point backwards across anything that is not in syntax class “whitespace”. The skip-syntax functions return the distance moved rather than the value of point, so we have to add a call to point at the end of the save-excursion.

If you do use regexp searches in a function like this, it’s usually a good idea to pass t for the fourth argument, noerror, so that it doesn’t pass on errors to the user if it fails to match. This does mean that you have to check for yourself whether the return value is nil, though.

Finally, instead of push to add the completion function you might want to use add-hook as follows:

(add-hook 'completion-at-point-functions 'my-completion-at-point nil t)

This does two useful things: it checks whether your function is already in the hook before adding it, and (by passing t for the fourth argument, local) it only adds the function to the buffer-local value of the completion-at-point hook. This is almost certainly what you want, since you don’t want to use these completions in every other Emacs buffer when you press the TAB key.