bug#60655: 30.0.50; tree-sitter: `treesit-transpose-sexps' is broken.

[Juri Linkov]

> The tree-sitter-enabled function, `treesit-transpose-sexps',
> that is called by transpose-sexps, is broken.

After many unsuccessful attempts I finally arrived at the
usable implementation.  For example, typing 'C-M-t'
between two conditions:

if (x > 72 &&
    -!-y < 85) { // found
  do_something();
}

swaps these two conditions:

if (y < 85 &&
    x > 72) { // found
  do_something();
}

whereas inside the binary expression

if (x > -!-72 &&
    y < 85) { // found
  do_something();
}

it swaps its components:

if (72 > x &&
    y < 85) { // found
  do_something();
}

Or with point between two objects in an array:

var a = [{
  case: 'zzzz',
  default: 'yyyy'
},
-!-{
  case: 'zzzz2',
  default: 'yyyy'
}];

it swaps these objects:

var a = [{
  case: 'zzzz2',
  default: 'yyyy'
},
{
  case: 'zzzz',
  default: 'yyyy'
}];

whereas with point between two pairs

var a = [{
  case: 'zzzz',
  -!-default: 'yyyy'
}];

it swaps these pairs

var a = [{
  default: 'yyyy',
  case: 'zzzz'
}];

while keeping the right punctuation.

In a string it falls back to the default function.

diff --git a/lisp/treesit.el b/lisp/treesit.el
index 4fe4f7276f6..c17ffb1f9f4 100644
--- a/lisp/treesit.el
+++ b/lisp/treesit.el
@@ -2608,26 +2630,15 @@ treesit-transpose-sexps
 Return a pair of positions as described by
 `transpose-sexps-function' for use in `transpose-subr' and
 friends."
-  ;; First arrive at the right level at where the node at point is
-  ;; considered a sexp. If sexp isn't defined, or we can't find any
-  ;; node that's a sexp, use the node at point.
-  (let* ((node (or (treesit-thing-at-point 'sexp 'nested)
-                   (treesit-node-at (point))))
-         (parent (treesit-node-parent node))
-         (child (treesit-node-child parent 0 t)))
-    (named-let loop ((prev child)
-                     (next (treesit-node-next-sibling child t)))
-      (when (and prev next)
-        (if (< (point) (treesit-node-end next))
-            (if (= arg -1)
-                (cons (treesit-node-start prev)
-                      (treesit-node-end prev))
-              (when-let* ((n (treesit-node-child
-                              parent (+ arg (treesit-node-index prev t)) t)))
-                (cons (treesit-node-end n)
-                      (treesit-node-start n))))
-          (loop (treesit-node-next-sibling prev t)
-                (treesit-node-next-sibling next t)))))))
+  (let* ((pred #'treesit-node-named)
+         (sibling (if (> arg 0)
+                      (treesit-thing-next (point) pred)
+                    (treesit-thing-prev (point) pred))))
+    (or (when sibling
+          (if (> arg 0)
+              (cons (treesit-node-end sibling) (treesit-node-start sibling))
+            (cons (treesit-node-start sibling) (treesit-node-end sibling))))
+        (transpose-sexps-default-function arg))))
 
 ;;; Navigation, defun, things
 ;;