bug#68824: treesitter support for outline-minor-mode

[Juri Linkov <juri@linkov.net>]

[-- Attachment #1: Type: text/plain, Size: 2475 bytes --]

>> As discussed on https://lists.gnu.org/archive/html/emacs-devel/2024-01/msg00916.html
>> here is the patch that adds the support for outline-minor-mode to treesit.el.
>> It has been tested on c-ts-mode, dockerfile-ts-mode, elixir-ts-mode, heex-ts-mode,
>> java-ts-mode, js-ts-mode, typescript-ts-mode, css-ts-mode, html-ts-mode, toml-ts-mode.
>
> Thanks, but shouldn't this minor mode be documented more prominently
> in the Emacs user manual, now that there are so many major modes that
> support it?  And since major modes that want to support it have to set
> up its support, I would say the ELisp manual should document that
> setup.
>
> IOW, it makes little sense to make this minor mode more and more
> prolific in Emacs, and still have almost nothing about it in our
> manuals.

I agree.  Also could add corresponding menu item to the global menu-bar,
or at least to menus of major modes deriving from prog-mode/text-mode.

>> +(defvar-local treesit-outline-predicate nil
>> +  "Predicate used to find outline headings in a sparse tree.
>
> How do "sparse trees" enter the scene here?  AFAICS, "sparse trees" is
> mentioned only once in the entire chapter dedicated to Tree Sitter
> support in the ELisp manual.  Is it important to mention here the fact
> that the tree is sparse?

Actually I realized now there is no need to use sparse trees here.
Below is a new implementation that directly traverses the syntax tree.
This implementation is much better than sparse trees because
sparse trees can be created only once when the file is visited,
but when the buffer is modified it takes too much time
to regenerate sparse trees completely after every change.
So a new implementation below uses the search on the syntax tree
that is much faster to do after every buffer modification.

>> diff --git a/lisp/progmodes/heex-ts-mode.el b/lisp/progmodes/heex-ts-mode.el
>> +    ;; Outline minor mode
>> +    ;; Restore default value for `treesit-outline-search'.
>> +    (kill-local-variable 'outline-regexp)
>> +    (kill-local-variable 'outline-heading-end-regexp)
>> +    (kill-local-variable 'outline-level)
>
> This mode seems to do something to support outline-minor-mode that is
> not mentioned in the NEWS entry, and neither is treesit-outline-search.

This just disables outline settings inherited from html-mode.
I will add more explanations.

Here is a new patch with a shorter implementation.
And I will send a complete patch with documentation changes later.


[-- Warning: decoded text below may be mangled, UTF-8 assumed --]
[-- Attachment #2: treesit-outline-search.patch --]
[-- Type: text/x-diff, Size: 3168 bytes --]

diff --git a/lisp/treesit.el b/lisp/treesit.el
index 96222ed81cb..72c994c257c 100644
--- a/lisp/treesit.el
+++ b/lisp/treesit.el
@@ -2836,6 +2836,48 @@ treesit-simple-imenu
                     index))))
             treesit-simple-imenu-settings)))
 
+;;; Outline minor mode
+
+(defvar-local treesit-outline-predicate nil
+  "Predicate used to find outline headings in the syntax tree.
+Intended to be set by a major mode.  When nil, the predicate
+is constructed from the value of `treesit-simple-imenu-settings'
+when a major mode sets it.")
+
+(defun treesit-outline-search (&optional bound move backward looking-at)
+  "Search for the next outline heading in the syntax tree.
+See the descriptions of arguments in `outline-search-function'."
+  (if looking-at
+      (treesit-parent-until (treesit-node-at (pos-bol)) treesit-outline-predicate)
+    (let* ((current (treesit-node-at (pos-bol)))
+           (current (or (treesit-parent-until current treesit-outline-predicate)
+                        current))
+           (node (treesit-search-forward
+                   current treesit-outline-predicate backward))
+           (found (when node (treesit-node-start node))))
+      (if found
+          (if (or (not bound) (if backward (>= found bound) (<= found bound)))
+              (progn
+                (goto-char found)
+                (search-forward (or (treesit-defun-name node) ""))
+                (goto-char (pos-bol))
+                (set-match-data (list (point) (pos-eol)))
+                t)
+            (when move (goto-char bound))
+            nil)
+        (when move (goto-char (or bound (if backward (point-min) (point-max)))))
+        nil))))
+
+(defun treesit-outline-level ()
+  "Return the depth of the current outline heading."
+  (let ((node (treesit-node-at (point)))
+        (level 0))
+    (while node
+      (when (funcall treesit-outline-predicate node)
+        (setq level (1+ level)))
+      (setq node (treesit-node-parent node)))
+    level))
+
 ;;; Activating tree-sitter
 
 (defun treesit-ready-p (language &optional quiet)
@@ -2966,6 +3008,23 @@ treesit-major-mode-setup
     (setq-local imenu-create-index-function
                 #'treesit-simple-imenu))
 
+  ;; Outline minor mode.
+  (when (and (or treesit-outline-predicate treesit-simple-imenu-settings)
+             (not (seq-some #'local-variable-p
+                            '(outline-search-function
+                              outline-regexp outline-level))))
+    (unless treesit-outline-predicate
+      (setq treesit-outline-predicate
+            (lambda (node)
+              (seq-some
+               (lambda (setting)
+                 (and (string-match-p (nth 1 setting) (treesit-node-type node))
+                      (or (null (nth 2 setting))
+                          (funcall (nth 2 setting) node))))
+               treesit-simple-imenu-settings))))
+    (setq-local outline-search-function #'treesit-outline-search
+                outline-level #'treesit-outline-level))
+
   ;; Remove existing local parsers.
   (dolist (ov (overlays-in (point-min) (point-max)))
     (when-let ((parser (overlay-get ov 'treesit-parser)))