Tree-sitter powered completion

[bbatsov]

I ran across this video and it seemed like an interesting idea - to use the Tree-sitter AST for completion of things like locals and global definitions in the scope of a single source file. I'm guessing newcomers to Emacs would appreciate having some form of smart completion that doesn't require additional packages (e.g. Eglot, CIDER, inf-clojure, etc).

[sogaiu]

Not sure how this would be done well with the current grammar as what it does is close to what counts as read in Clojure (i.e. before any kind of definition activities occur).

The grammar does not recognize defining forms for example (just things like lists, symbols, etc.).

Some sorts of queries could "fake" recognition of top-level definitions. For janet-ts-mode, I implemented some of the imenu stuff like this. That's probably got overlap with what one might want for completion I imagine.

I didn't try to do any locals stuff -- that seemed like it could get complicated especially with destructuring.

May be something useful is doable though?

[rrudakov]

I guess we can definitely query all defs and defns in the file and get a list of symbol names. Regarding locals I can't think of any reliable solution at the moment, need to do some experiments.

[bbatsov]

I realize we can't do something fancy in this manner, but I'm pretty sure we should be able to put together some simple completion source based on queries.

For the locals I guess we can query up the current scope until a we hit a definition form or a top-level form. I think this is something similar to what Compliment does for its own inference of locals. (see https://github.com/alexander-yakushev/compliment/blob/master/src/compliment/sources/local_bindings.clj)

[rrudakov]

Here's a very quick implementation of completions for global vars and functions:

(defvar clojure-ts--completion-query-globals
  (treesit-query-compile 'clojure
                         `((source
                            (list_lit
                             ((sym_lit) @sym
                              (:match ,clojure-ts--variable-definition-symbol-regexp @sym))
                             :anchor [(comment) (meta_lit) (old_meta_lit)] :*
                             :anchor ((sym_lit) @var-candidate)))
                           (source
                            (list_lit
                             ((sym_lit) @sym
                              (:match ,clojure-ts--function-type-regexp @sym))
                             :anchor [(comment) (meta_lit) (old_meta_lit)] :*
                             :anchor ((sym_lit) @fn-candidate))))))

(defconst clojure-ts--completion-annotations
  (list 'var-candidate " Global variable"
        'fn-candidate " Function"))

(defun clojure-ts--completion-annotation-function (candidate)
  (thread-last minibuffer-completion-table
               (alist-get candidate)
               (plist-get clojure-ts--completion-annotations)))

(defun clojure-ts-completion-at-point-function ()
  (when-let* ((bounds (bounds-of-thing-at-point 'symbol))
              (source (treesit-buffer-root-node 'clojure))
              (nodes (treesit-query-capture source clojure-ts--completion-query-globals)))
    (list (car bounds)
          (cdr bounds)
          (thread-last nodes
                 (seq-filter (lambda (item) (not (equal (car item) 'sym))))
                 (seq-map (lambda (item) (cons (treesit-node-text (cdr item) t) (car item)))))
          :exclusive 'no
          :annotation-function #'clojure-ts--completion-annotation-function)))

I'll try to add locals completion later.

[bbatsov]

Nice! That looks quite promising to me and it'd be another feature that's unique to clojure-ts-mode, compared to clojure-mode, which might speed up its adoption.

[rrudakov]

I've been trying to implement locals completion by fetching proper nodes from proper places and it's mostly working, but now I think it would probably be OK if we just fetch all symbol nodes that we can find in let bindings vector and in function args vector. Am I missing something?

[rrudakov]

I've been trying to implement locals completion by fetching proper nodes from proper places and it's mostly working, but now I think it would probably be OK if we just fetch all symbol nodes that we can find in let bindings vector and in function args vector. Am I missing something?

There are some false positives, if there is a function call in the let bindings, the function name will be among completion candidates, but the implementation is much simpler:

screencast.mp4

[bbatsov]

@rrudakov This certainly looks good enough to me. When you get to doing a PR you can also include a similar short recording in the README, as I think it illustrates the feature great.

[rrudakov]

@rrudakov This certainly looks good enough to me. When you get to doing a PR you can also include a similar short recording in the README, as I think it illustrates the feature great.

I actually found a good compromise, so the problem with false positives should be solved. PR is on the way.