Speedup align-forms by introducing indentation rules caching

Author: rrudakov

clojure-ts-mode.el

@@ -1003,9 +1003,9 @@ If there is no namespace, returns nil."
 (defun clojure-ts--node-child-skip-metadata (node n)
   "Return the Nth child of NODE like `treesit-node-child', sans metadata.
 Skip the optional metadata node at pos 0 if present."
-  (let ((value-nodes (seq-filter (lambda (child)
-                                   (string= (treesit-node-field-name child) "value"))
-                                 (treesit-node-children node t))))
+  (let ((value-nodes (treesit-filter-child node
+                                           #'clojure-ts--value-type-node-p
+                                           t)))
     (seq-elt value-nodes n)))
 
 (defun clojure-ts--first-value-child (node)
@@ -1147,6 +1147,10 @@ Includes a dispatch value when applicable (defmethods)."
   "Return non-nil if NODE represents a protocol or interface definition."
   (clojure-ts--definition-node-match-p clojure-ts--interface-type-regexp node))
 
+(defun clojure-ts--value-type-node-p (node)
+  "Return non-nil if field name of the NODE is value."
+  (string= (treesit-node-field-name node) "value"))
+
 (defvar clojure-ts--imenu-settings
   `(("Namespace" "list_lit" clojure-ts--ns-node-p)
     ("Function" "list_lit" clojure-ts--function-node-p
@@ -1435,17 +1439,34 @@ If NS is defined, then the fully qualified symbol is passed to
                        (seq-sort (lambda (spec1 _spec2)
                                    (equal (car spec1) :block)))))))))
 
-(defun clojure-ts--find-semantic-rules-for-node (node)
-  "Return a list of semantic rules for NODE."
-  (let* ((first-child (clojure-ts--node-child-skip-metadata node 0))
-         (symbol-name (clojure-ts--named-node-text first-child))
-         (symbol-namespace (clojure-ts--node-namespace-text first-child)))
+(defvar clojure-ts--dynamic-indent-for-symbol-cache
+  (make-hash-table :test 'equal))
+
+(defvar clojure-ts--dynamic-indent-for-symbol-cache-p nil
+  "If set to nil, do not use cache for dynamic indentation rules.")
+
+(defun clojure-ts--find-semantic-rules-for-symbol (node)
+  "Return a list of semantic rules for symbol NODE.
+
+If rules are not found return :not-found symbol."
+  (let ((symbol-name (clojure-ts--named-node-text node))
+        (symbol-namespace (clojure-ts--node-namespace-text node)))
     (or (clojure-ts--dynamic-indent-for-symbol symbol-name symbol-namespace)
         (alist-get symbol-name
                    clojure-ts--semantic-indent-rules-cache
                    nil
                    nil
-                   #'equal))))
+                   #'equal)
+        :not-found)))
+
+(defun clojure-ts--find-semantic-rules-for-node (node)
+  "Return a list of semantic rules for NODE."
+  (let* ((first-child (clojure-ts--first-value-child node))
+         (symbol-full-name (treesit-node-text first-child)))
+    (if clojure-ts--dynamic-indent-for-symbol-cache-p
+        (with-memoization (gethash symbol-full-name clojure-ts--dynamic-indent-for-symbol-cache)
+          (clojure-ts--find-semantic-rules-for-symbol first-child))
+      (clojure-ts--find-semantic-rules-for-symbol first-child))))
 
 (defun clojure-ts--find-semantic-rule (node parent current-depth)
   "Return a suitable indentation rule for NODE, considering the CURRENT-DEPTH.
@@ -1457,7 +1478,8 @@ increasing the CURRENT-DEPTH.  If a rule is not found upon reaching the
 root of the syntax tree, it returns nil.  A rule is considered a match
 only if the CURRENT-DEPTH matches the rule's required depth."
   (let* ((idx (- (treesit-node-index node) 2)))
-    (if-let* ((rule-set (clojure-ts--find-semantic-rules-for-node parent)))
+    (if-let* ((rule-set (clojure-ts--find-semantic-rules-for-node parent))
+              ((not (equal rule-set :not-found))))
         (if (zerop current-depth)
             (let ((rule (car rule-set)))
               (if (equal (car rule) :block)
@@ -1912,9 +1934,11 @@ between BEG and END."
                            (end (clojure-ts--end-of-defun-pos)))
                        (list start end))))))
   (setq end (copy-marker end))
+  (clrhash clojure-ts--dynamic-indent-for-symbol-cache)
   (let* ((sexps-to-align (clojure-ts--get-nodes-to-align beg (marker-position end)))
          ;; We have to disable it here to avoid endless recursion.
-         (clojure-ts-align-forms-automatically nil))
+         (clojure-ts-align-forms-automatically nil)
+         (clojure-ts--dynamic-indent-for-symbol-cache-p t))
     (save-excursion
       (indent-region beg (marker-position end))
       (dolist (sexp sexps-to-align)
@@ -2566,6 +2590,28 @@ before DELIM-OPEN."
         (goto-char pos))
     (user-error "Must be invoked inside a list")))
 
+(defun clojure-ts--toggle-ignore-next-sexp (&optional n)
+  "Insert or delete N `#_' ignore macros at the current point.
+
+Point must be directly before a sexp or the #_ characters.  When acting
+on a top level form, insert #_ on a new line preceding the form to
+prevent indentation changes."
+
+  (dotimes (_ (or n 1)) (insert-before-markers "#_")))
+
+(defun clojure-ts-toggle-ignore (&optional n)
+  "Toggle the #_ ignore reader form for the sexp at point.
+
+With the numeric argument, toggle N number of #_ forms at the same point.
+
+e.g. with N = 2:
+|a b c => #_#_a b c"
+  (interactive "p")
+  (let ((sexp (treesit-thing-at-point 'sexp 'nested)))
+    (goto-char (treesit-node-start sexp))
+    (clojure-ts--toggle-ignore-next-sexp n)
+    ))
+
 (defvar clojure-ts-refactor-map
   (let ((map (make-sparse-keymap)))
     (keymap-set map "C-t" #'clojure-ts-thread)

test/samples/refactoring.clj

@@ -141,7 +141,7 @@
   false)
 
 (when-not true
-  (println "Hello world"))
+  (println #_#_"Hello world" "again"))
 
 (extend-protocol prepare/SettableParameter
   clojure.lang.IPersistentMap