Support for treesit.el

* Add support for treesit.el from @abougouffa fork (thank you!).
* Allow unfold by clicking fold-replacement.

Author: DevelopmentCool2449

Eask

@@ -14,7 +14,6 @@
 (source "melpa")
 
 (depends-on "emacs" "29.1")
-(depends-on "tree-sitter")
 (depends-on "s")
 (depends-on "fringe-helper")
 

treesit-fold-indicators.el

@@ -121,7 +121,7 @@
   "Enable `treesit-fold-indicators' mode."
   (if (or treesit-fold-mode (treesit-fold-mode 1))  ; Enable `treesit-fold-mode' automatically
       (progn
-        (add-hook 'tree-sitter-after-change-functions #'treesit-fold-indicators-refresh nil t)
+        (add-hook 'after-change-functions #'treesit-fold-indicators-refresh nil t)
         (add-hook 'after-save-hook #'treesit-fold-indicators-refresh nil t)
         (add-hook 'window-size-change-functions #'treesit-fold-indicators--size-change)
         (add-hook 'window-scroll-functions #'treesit-fold-indicators--scroll)
@@ -130,27 +130,26 @@
 
 (defun treesit-fold-indicators--disable ()
   "Disable `treesit-fold-indicators' mode."
-  (remove-hook 'tree-sitter-after-change-functions #'treesit-fold-indicators-refresh t)
+  (remove-hook 'after-change-functions #'treesit-fold-indicators-refresh t)
   (remove-hook 'after-save-hook #'treesit-fold-indicators-refresh t)
   (remove-hook 'window-size-change-functions #'treesit-fold-indicators--size-change)
   (remove-hook 'window-scroll-functions #'treesit-fold-indicators--scroll)
   (treesit-fold-indicators--remove-ovs-buffer))
 
 ;;;###autoload
 (define-minor-mode treesit-fold-indicators-mode
-  "Minor mode for indicators mode."
+  "Minor mode for display fringe folding indicators."
   :group 'treesit-fold
   :lighter nil
   :keymap treesit-fold-indicators-mode-map
   :init-value nil
-  (tree-sitter--handle-dependent treesit-fold-indicators-mode
-    #'treesit-fold-indicators--enable
-    #'treesit-fold-indicators--disable))
+  (if treesit-fold-indicators-mode
+      (treesit-fold-indicators--enable)
+    (treesit-fold-indicators--disable)))
 
 ;;;###autoload
 (define-minor-mode global-treesit-fold-indicators-mode
-  "Global minor mode for turning on treesit-fold with indicators
-whenever avaliable."
+  "Toggle treesit-fold-indicatos in all buffers avaliable."
   :group 'treesit-fold
   :lighter nil
   :init-value nil
@@ -329,8 +328,8 @@ Optional arguments WEND and WSTART are the range for caching."
        (range (cl-case treesit-fold-indicators-render-method
                 (`full
                  (ignore-errors (treesit-fold--get-fold-range node)))
-                (`partial (cons (tsc-node-start-position node)
-                                (tsc-node-end-position node)))
+                (`partial (cons (treesit-node-start node)
+                                (treesit-node-end node)))
                 (t
                  (user-error "Invalid render method: %s" treesit-fold-indicators-render-method))))
        (start (car range))
@@ -343,16 +342,15 @@ Optional arguments WEND and WSTART are the range for caching."
 ;;;###autoload
 (defun treesit-fold-indicators-refresh (&rest _)
   "Refresh indicators for all folding range."
-  (when (and tree-sitter-mode treesit-fold-indicators-mode)
+  (when (and (ignore-errors (treesit-buffer-root-node)) treesit-fold-indicators-mode)
     (treesit-fold--ensure-ts
      (when-let*
-         ((node (ignore-errors (tsc-root-node tree-sitter-tree)))
+         ((node (ignore-errors (treesit-buffer-root-node)))
           (patterns (seq-mapcat (lambda (fold-range) `((,(car fold-range)) @name))
-                                (alist-get major-mode treesit-fold-range-alist)
-                                'vector))
+                                (alist-get major-mode treesit-fold-range-alist)))
           (query (ignore-errors
-                   (tsc-make-query tree-sitter-language patterns)))
-          (nodes-to-fold (tsc-query-captures query node #'ignore))
+                   (treesit-query-compile (treesit-node-language node) patterns)))
+          (nodes-to-fold (treesit-query-capture node query))
           (wend (window-end nil t))
           (wstart (window-start))
           (nodes-to-fold

treesit-fold-parsers.el

@@ -103,6 +103,7 @@
 ;; (@* "Parsers" )
 ;;
 
+;; Should these functions be variables?
 ;; TODO(everyone): keep the function alphabetically sorted
 
 (defun treesit-fold-parsers-actionscript ()
@@ -125,7 +126,7 @@
     (block_comment . treesit-fold-range-c-like-comment)
     (line_comment
      . (lambda (node offset)
-         (let ((text (tsc-node-text node)))
+         (let ((text (treesit-node-text node)))
            (cond ((string-prefix-p ";;" text)
                   (treesit-fold-range-line-comment node offset ";;"))
                  ((string-prefix-p "#" text)
@@ -523,17 +524,18 @@
     (compound_statement  . treesit-fold-range-seq)
     (comment
      . (lambda (node offset)
-         (if (string-prefix-p "#" (tsc-node-text node))
+         (if (string-prefix-p "#" (treesit-node-text node))
              (treesit-fold-range-line-comment node offset "#")
            (treesit-fold-range-c-like-comment node offset))))))
 
 (defun treesit-fold-parsers-python ()
   "Rule set for Python."
-  '((function_definition  . treesit-fold-range-python-def)
-    (class_definition     . treesit-fold-range-python-def)
-    (list                 . treesit-fold-range-seq)
-    (dictionary           . treesit-fold-range-seq)
-    (expression_statement . treesit-fold-range-python-expression-statement)
+  '((function_definition      . treesit-fold-range-python-def)
+    (class_definition         . treesit-fold-range-python-def)
+    (list                     . treesit-fold-range-seq)
+    (dictionary               . treesit-fold-range-seq)
+    (parenthesized_expression . treesit-fold-range-seq)
+    (expression_statement     . treesit-fold-range-python-expression-statement)
     (comment
      . (lambda (node offset)
          (treesit-fold-range-line-comment node offset "#")))))

treesit-fold-summary.el

@@ -105,7 +105,7 @@ type of content by checking the word boundary's existence."
 (defun treesit-fold-summary-csharp-vsdoc (doc-str)
   "Extract summary from DOC-STR in C# vsdoc."
   (let ((type-triple (string-match-p "///" doc-str)))
-    (setq doc-str (s-replace-regexp "<[/]*[^>]+." "" doc-str))
+    (setq doc-str (s-replace-regexp "<[/]*[^>]+." "" doc-str)) ; should use `replace-regexp-in-string'?
     (treesit-fold-summary--generic doc-str (if type-triple "///" "//"))))
 
 (defun treesit-fold-summary-csharp (doc-str)

treesit-fold-util.el

@@ -25,8 +25,6 @@
 
 ;;; Code:
 
-(require 'tsc)
-
 ;;
 ;; (@* "Redisplay" )
 ;;
@@ -174,52 +172,29 @@ See macro `with-selected-window' description for arguments WINDOW and BODY."
 
 (defun treesit-fold--compare-type (node type)
   "Compare NODE's type to TYPE."
-  ;; tsc-node-type returns a symbol or a string and `string=' automatically
-  ;; converts symbols to strings
-  (string= (tsc-node-type node) type))
-
-(defun treesit-fold-get-children (node)
-  "Get list of direct children of NODE."
-  (let (children)
-    (dotimes (index (tsc-count-children node))
-      (push (tsc-get-nth-child node index) children))
-    (reverse children)))
-
-(defun treesit-fold-get-children-traverse (node)
-  "Return children from NODE but traverse it."
-  (let (nodes)
-    (tsc-traverse-mapc (lambda (child) (push child nodes)) node)
-    (reverse nodes)))
+  (string= (treesit-node-type node) type))
 
 (defun treesit-fold-find-children (node type)
   "Search through the children of NODE to find all with type equal to TYPE;
 then return that list."
   (cl-remove-if-not (lambda (child) (treesit-fold--compare-type child type))
-                    (treesit-fold-get-children node)))
-
-(defun treesit-fold-find-children-traverse (node type)
-  "Like function `treesit-fold-find-children' but traverse it.
-
-For arguments NODE and TYPE, see function `treesit-fold-find-children' for more
-information."
-  (cl-remove-if-not (lambda (child) (treesit-fold--compare-type child type))
-                    (treesit-fold-get-children-traverse node)))
+                    (treesit-node-children node)))
 
 (defun treesit-fold-find-parent (node type)
   "Find the TYPE of parent from NODE."
-  (let ((parent (tsc-get-parent node))
+  (let ((parent (treesit-node-parent node))
         (break))
     (while (and parent (not break))
       (setq break (treesit-fold--compare-type parent type))
       (unless break
-        (setq parent (tsc-get-parent parent))))
+        (setq parent (treesit-node-parent parent))))
     parent))
 
 (defun treesit-fold-last-child (node)
   "Return last child node from parent NODE."
-  (when-let* ((count (tsc-count-children node))
+  (when-let* ((count (treesit-node-child-count node))
               ((not (= count 0))))
-    (tsc-get-nth-child node (1- count))))
+    (treesit-node-child node (1- count))))
 
 (provide 'treesit-fold-util)
 ;;; treesit-fold-util.el ends here