🚀 go-pugleaf

Thanks for that, but I’m afraid I haven’t yet had time.  I provided the test code and target file in the hopes that others could confirm the scaling behavior and then experiment with algorithm tweaks, if anything obvious presented itself.

> On Aug 17, 2023, at 6:56 AM, Dmitry Gutov <dmitry@gutov.dev> wrote:
> 
> On 17/08/2023 07:01, JD Smith wrote:
>> I’m unclear whether this is fundamental to the tree-sitter parse/tree algorithm, or if the scaling comes from Emacs’ TS implementation.  It does vaguely remind me of similar scaling with an old line-numbering algorithm, where lines were always being counted from the beginning of the buffer, so very fast at the front, and very slow near the end.
> 
> Have you tried my patch yet?

--MMbW8Q8QT+A3vO2G
Content-Type: text/plain; charset=utf-8
Content-Disposition: inline
Content-Transfer-Encoding: quoted-printable

On Thu, Aug 17, 2023 at 02:41:24PM +0300, Eli Zaretskii wrote:
> > Date: Thu, 17 Aug 2023 13:56:46 +0300
> > From: Dmitry Gutov <dmitry@gutov.dev>
> > 
> > On 17/08/2023 07:01, JD Smith wrote:
> > > It 
> > > does vaguely remind me of similar scaling with an old line-numbering 
> > > algorithm, where lines were always being counted from the beginning of 
> > > the buffer, so very fast at the front, and very slow near the end.
> 
> Why on earth would someone need to count lines far from the beginning
> of the buffer?  Or have a computer with more than 640KB of memory?

Oh, oh, fond memories of Windows around 3.1 where the available editor
(notepad) wasn't capable of loading the only C header (<windows.h>)
because that one had more than 64K lines...

Cheers
-- 
t

--MMbW8Q8QT+A3vO2G
Content-Type: application/pgp-signature; name="signature.asc"

-----BEGIN PGP SIGNATURE-----

iF0EABECAB0WIQRp53liolZD6iXhAoIFyCz1etHaRgUCZN4JxAAKCRAFyCz1etHa
RuISAJ9Q/YPZfbu4i7J4GUKpI9g8R3ZScgCfSzVqwJ6rzcs8sKQ8U7ZeDkVbkuQ©Gg
-----END PGP SIGNATURE-----

--MMbW8Q8QT+A3vO2G--

On 17/08/2023 07:01, JD Smith wrote:
> I’m unclear whether this is fundamental to the tree-sitter parse/tree
> algorithm, or if the scaling comes from Emacs’ TS implementation.  It
> does vaguely remind me of similar scaling with an old line-numbering
> algorithm, where lines were always being counted from the beginning of
> the buffer, so very fast at the front, and very slow near the end.

Have you tried my patch yet?

> Date: Thu, 17 Aug 2023 13:56:46 +0300
> From: Dmitry Gutov <dmitry@gutov.dev>
>
> On 17/08/2023 07:01, JD Smith wrote:
> > It
> > does vaguely remind me of similar scaling with an old line-numbering
> > algorithm, where lines were always being counted from the beginning of
> > the buffer, so very fast at the front, and very slow near the end.

Why on earth would someone need to count lines far from the beginning
of the buffer?  Or have a computer with more than 640KB of memory?

On 17/08/2023 15:21, JD Smith wrote:
> I provided the test code and target file in the hopes that others could confirm the scaling behavior and then experiment with algorithm tweaks, if anything obvious presented itself.

I experimented a little bit with benchmarking (treesit-node-parent)
calls, and the patch came from that.

On 17/08/2023 15:34, Dmitry Gutov wrote:
> On 17/08/2023 15:21, JD Smith wrote:
>> I provided the test code and target file in the hopes that others
>> could confirm the scaling behavior and then experiment with algorithm
>> tweaks, if anything obvious presented itself.
>
> I experimented a little bit with benchmarking (treesit-node-parent)
> calls, and the patch came from that.

In case somebody else here wants to try it:

diff --git a/src/treesit.c b/src/treesit.c
index 1f694e47201..4b35e5ee2e5 100644
--- a/src/treesit.c
+++ b/src/treesit.c
@@ -52,6 +52,7 @@ Copyright (C) 2021-2023 Free Software Foundation, Inc.
  #undef ts_node_named_descendant_for_byte_range
  #undef ts_node_next_named_sibling
  #undef ts_node_next_sibling
+#undef ts_node_parent
  #undef ts_node_prev_named_sibling
  #undef ts_node_prev_sibling
  #undef ts_node_start_byte
@@ -1899,16 +1900,27 @@ DEFUN ("treesit-node-parent",

    TSNode treesit_node = XTS_NODE (node)->node;
    Lisp_Object parser = XTS_NODE (node)->parser;
-  TSTreeCursor cursor;
-  if (!treesit_cursor_helper (&cursor, treesit_node, parser))
-    return return_value;

-  if (ts_tree_cursor_goto_parent (&cursor))
-  {
-    TSNode parent = ts_tree_cursor_current_node (&cursor);
-    return_value = make_treesit_node (parser, parent);
-  }
-  ts_tree_cursor_delete (&cursor);
+  if (treesit_node_uptodate_p(node))
+    {
+      TSNode parent = ts_node_parent (treesit_node);
+      return_value = make_treesit_node (parser, parent);
+    }
+  else
+    {
+      Lisp_Object parser = XTS_NODE (node)->parser;
+      TSTreeCursor cursor;
+      if (!treesit_cursor_helper (&cursor, treesit_node, parser))
+	return return_value;
+
+      if (ts_tree_cursor_goto_parent (&cursor))
+	{
+	  TSNode parent = ts_tree_cursor_current_node (&cursor);
+	  return_value = make_treesit_node (parser, parent);
+	}
+      ts_tree_cursor_delete (&cursor);
+    }
+
    return return_value;
  }

> On Aug 16, 2023, at 9:01 PM, JD Smith <jdtsmith@gmail.com> wrote:
> 
> I recently posted about the high variability of Emacs 29’s tree-sitter navigation performance within a file.  I decided to conduct a simple test on a large python file of about 8400 lines to see if I could learn more.  The test is as follows: at the start of each line, locate the current syntax node, and starting from it, navigate up to the root node via `treesit-node-parent’.  
> 
> I was surprised to find that the time this takes grows as sqrt(N), for line number N.  This leads to performance variability of >100x for code that needs to walk the local syntax tree in large files.  Such variability can make performance projections and optimizations for latency-sensitive uses of tree-sitter (e.g. via font-lock) tricky.  
> 
> I’m unclear whether this is fundamental to the tree-sitter parse/tree algorithm, or if the scaling comes from Emacs’ TS implementation.  It does vaguely remind me of similar scaling with an old line-numbering algorithm, where lines were always being counted from the beginning of the buffer, so very fast at the front, and very slow near the end. 
> 
> Code and details here:
> 
>   
> https://gist.github.com/jdtsmith/7fa6263a13559d587abb51827e6ae472

I’m not entirely surprised. In the parse tree that tree-sitter generates is a DAG, where the parent node has pointers to the child nodes, but not the other way around. That means to go to the parent node from a child node, what tree-sitter actually does is go down from the root node until it hits the parent node. This process is linear to the height of the tree.

Also, getting the node at point isn’t free either. To get the node at point, we actually iterates from the first child node of the root node until reaching one that contains the point, then iterate from the first child node of that node until reaching one that contains the point, etc, until we reach a leaf node. So log(N) time complexity is expected.

Theses are fundamental limits of tree-sitter, unless it changes its data structure. I’m not too worried tho, because IIRC the absolute time is very short. The 100x variability doesn’t mean much if the 100x is still very fast.

Yuan

>> to go to the parent node from a child node, what tree-sitter actually does is go down from the root node until it hits the parent node. This process is linear to the height of the tree.
> 
> Do you mean linear in the width of the tree?  I’ve color-coded the plot by tree depth (i.e. how many ancestors a given node has back to root).  Or maybe you are thinking of the tree lying on its side (like vundo ;)?

Going down from the root node is proportion to the height of the tree, no?

> 
>> Also, getting the node at point isn’t free either. To get the node at point, we actually iterates from the first child node of the root node until reaching one that contains the point, then iterate from the first child node of that node until reaching one that contains the point, etc, until we reach a leaf node. So log(N) time complexity is expected.
> 
> I tested node-at-point on the same file, and it is quite fast, with worst case performance only 30µs (vs. 3ms for the full parent navigation), and growing very slowly, between sqrt(log(N)) and log(N).  Check the gist for a new figure.
> 
> Unless I am misunderstanding, for the common case of finding parent of the node at point, it seems the algorithm you describe could be tweaked to work well.  I.e. instead of "stop when reaching a leaf node containing point", just "stop when you reach a node containing point who has the original node as a child”?   This should give (hypothetical) “parent-of-node-at-point” the same great speed as node-at-point.  

I should’ve been more clear. For finding the parent of a node x, we stop at the parent of x. We only go to the leaf node when finding the node at point, which always returns a leaf node.

> 
> Then “parent-of-node-at-point-until” could do something quite clever: accumulate parent nodes all the way from root to the child’s direct parent into a list (same low cost, modulo the node storage).  Then run the predicate on that list (in reverse), returning the first match.  Could of course return that full list too (“ancestors-of-node-at-point”), for other uses.  These should all be quite fast compared to a full breadth and depth searching of every nook and cranny in the syntax tree that node-parent seems to do (having no positional information to wield).

Sure, there hasn’t been a clever version because so far no one have complained they can’t find the parent of a node fast enough. Also I doubt the amount of gain we can get with a more clever algorithm. You can try implement one and benchmark it. I’m curious to know the result :-)

> 
>> I’m not too worried tho, because IIRC the absolute time is very short. The 100x variability doesn’t mean much if the 100x is still very fast.
> 
> 
> This is on a brand new fast machine, and 3ms is pretty slow for things that need to run dozens of times per keystroke (e.g. font-lock).

Font-lock doesn’t need to find the parent of a node. So that hasn’t been a problem. In use-cases where finding the parent of a node is useful, 3ms hasn’t been a problem AFAIK. (Well, I guess indentation could benefit from a faster parent-finding function.)

> 
>> These are fundamental limits of tree-sitter, unless it changes its data structure. 
> 
> That is an interesting limitation for sure.  It seems that perhaps each node's start..end information can be really helpful here for winnowing the tree, when you are mostly concerned about nodes relevant to and covering particular positions in the buffer.

> BTW, https://tree-sitter.github.io/tree-sitter/using-parsers says:
>     • 
> A TSNode represents a single node in the syntax tree. It tracks its start and end positions in the source code, as well as its relation to other nodes like its parent, siblings and children.

I’m not entirely sure what exactly do you have in mind. A node’s start and end position doesn’t really help us finding it. Suppose you have an array of numbers, and you know one of the numbers is 3. How do you find the index of the number 3 in the array?

While the documentation say it tracks its relation to other nodes, I think it’s more pedagogical than factual. Behind the scenes, tree-sitter’s own node API does the same thing as I described: it goes from the root node and traverses down.

Yuan

--Apple-Mail=_C2142055-6695-4BB6-A7AD-FD3A285C1256
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain;
	charset=utf-8


> On Aug 17, 2023, at 11:00 PM, Yuan Fu <casouri@gmail.com> wrote:
>> 
>> Code and details here:
>> 
>> https://gist.github.com/jdtsmith/7fa6263a13559d587abb51827e6ae472
> 
> I’m not entirely surprised. In the parse tree that tree-sitter generates is a DAG, where the parent node has pointers to the child nodes, but not the other way around. That means to go to the parent node from a child node, what tree-sitter actually does is go down from the root node until it hits the parent node. This process is linear to the height of the tree.

Thanks for this info, very interesting.  

> to go to the parent node from a child node, what tree-sitter actually does is go down from the root node until it hits the parent node. This process is linear to the height of the tree.

Do you mean linear in the width of the tree?  I’ve color-coded the plot by tree depth (i.e. how many ancestors a given node has back to root).  Or maybe you are thinking of the tree lying on its side (like vundo ;)?

> Also, getting the node at point isn’t free either. To get the node at point, we actually iterates from the first child node of the root node until reaching one that contains the point, then iterate from the first child node of that node until reaching one that contains the point, etc, until we reach a leaf node. So log(N) time complexity is expected.

I tested node-at-point on the same file, and it is quite fast, with worst case performance only 30µs (vs. 3ms for the full parent navigation), and growing very slowly, between sqrt(log(N)) and log(N).  Check the gist for a new figure.

Unless I am misunderstanding, for the common case of finding parent of the node at point, it seems the algorithm you describe could be tweaked to work well.  I.e. instead of "stop when reaching a leaf node containing point", just "stop when you reach a node containing point who has the original node as a child”?   This should give (hypothetical) “parent-of-node-at-point” the same great speed as node-at-point.  

Then “parent-of-node-at-point-until” could do something quite clever: accumulate parent nodes all the way from root to the child’s direct parent into a list (same low cost, modulo the node storage).  Then run the predicate on that list (in reverse), returning the first match.  Could of course return that full list too (“ancestors-of-node-at-point”), for other uses.  These should all be quite fast compared to a full breadth and depth searching of every nook and cranny in the syntax tree that node-parent seems to do (having no positional information to wield).

> I’m not too worried tho, because IIRC the absolute time is very short. The 100x variability doesn’t mean much if the 100x is still very fast.


This is on a brand new fast machine, and 3ms is pretty slow for things that need to run dozens of times per keystroke (e.g. font-lock).

> These are fundamental limits of tree-sitter, unless it changes its data structure. 

That is an interesting limitation for sure.  It seems that perhaps each node's start..end information can be really helpful here for winnowing the tree, when you are mostly concerned about nodes relevant to and covering particular positions in the buffer.
--Apple-Mail=_C2142055-6695-4BB6-A7AD-FD3A285C1256
Content-Transfer-Encoding: quoted-printable
Content-Type: text/html;
	charset=utf-8

<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"></head><body style="overflow-wrap: break-word; -webkit-nbsp-mode: space; line-break: after-white-space;"><br><div><blockquote type="cite"><div>On Aug 17, 2023, at 11:00 PM, Yuan Fu <casouri@gmail.com> wrote:</div><div><blockquote type="cite" style="font-family: Helvetica; font-size: 12px; font-style: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; orphans: auto; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; widows: auto; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration: none;"><br>Code and details here:<br><br><a href="https://gist.github.com/jdtsmith/7fa6263a13559d587abb51827e6ae472">https://gist.github.com/jdtsmith/7fa6263a13559d587abb51827e6ae472</a><br></blockquote><br style="caret-color: rgb(0, 0, 0); font-family: Helvetica; font-size: 12px; font-style: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration: none;"><span style="caret-color: rgb(0, 0, 0); font-family: Helvetica; font-size: 12px; font-style: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration: none; float: none; display: inline !important;">I’m not entirely surprised. In the parse tree that tree-sitter generates is a DAG, where the parent node has pointers to the child nodes, but not the other way around. That means to go to the parent node from a child node, what tree-sitter actually does is go down from the root node until it hits the parent node. This process is linear to the height of the tree.</span><br style="caret-color: rgb(0, 0, 0); font-family: Helvetica; font-size: 12px; font-style: normal; font-variant-caps: normal; font-weight: 400; letter-spacing: normal; text-align: start; text-indent: 0px; text-transform: none; white-space: normal; word-spacing: 0px; -webkit-text-stroke-width: 0px; text-decoration: none;"></div></blockquote></div><br><div>Thanks for this info, very interesting.  </div><div><br></div><div><blockquote type="cite">to go to the parent node from a child node, what tree-sitter actually does is go down from the root node until it hits the parent node. This process is linear to the height of the tree.<br></blockquote><br></div><div>Do you mean linear in the width of the tree?  I’ve color-coded the plot by tree depth (i.e. how many ancestors a given node has back to root).  Or maybe you are thinking of the tree lying on its side (like vundo ;)?</div><div><br></div><div><blockquote type="cite">Also, getting the node at point isn’t free either. To get the node at point, we actually iterates from the first child node of the root node until reaching one that contains the point, then iterate from the first child node of that node until reaching one that contains the point, etc, until we reach a leaf node. So log(N) time complexity is expected.</blockquote><br></div><div>I tested node-at-point on the same file, and it is quite fast, with worst case performance only 30µs (vs. 3ms for the full parent navigation), and growing very slowly, between sqrt(log(N)) and log(N).  Check the gist for a new figure.</div><div><br></div><div>Unless I am misunderstanding, for the common case of finding parent of the node at point, it seems the algorithm you describe could be tweaked to work well.  I.e. instead of "stop when reaching a leaf node containing point", just "stop when you reach a node containing point who has the original node as a child”?   This should give (hypothetical) “parent-of-node-at-point” the same great speed as node-at-point.  </div><div><br></div><div>Then<font color="#000000"> “parent-of-node-at-point-until” could do something quite clever: accumulate parent nodes all the way from root to the child’s direct parent into a list (same low cost, modulo the node storage).  Then run the predicate on that list (in reverse), returning the first match.  Could of course return that full list too (“ancestors-of-node-at-point”), for other uses.  These should all be quite fast compared to a full breadth and depth searching of every nook and cranny in the syntax tree that node-parent seems to do (having no positional information to wield).</font></div><div><br></div><div><blockquote type="cite">I’m not too worried tho, because IIRC the absolute time is very short. The 100x variability doesn’t mean much if the 100x is still very fast.</blockquote></div><div><br></div><div>This is on a brand new fast machine, and 3ms is pretty slow for things that need to run dozens of times per keystroke (e.g. font-lock).</div><div><br></div><div><blockquote type="cite">These are fundamental limits of tree-sitter, unless it changes its data structure. <br></blockquote><div><br></div></div><div>That is an interesting limitation for sure.  It seems that perhaps each node's start..end information can be really helpful here for winnowing the tree, when you are mostly concerned about nodes relevant to and covering particular positions in the buffer.</div></body></html>
--Apple-Mail=_C2142055-6695-4BB6-A7AD-FD3A285C1256--

On 18/08/2023 08:20, Yuan Fu wrote:

>>> I’m not too worried tho, because IIRC the absolute time is very short. The 100x variability doesn’t mean much if the 100x is still very fast.
>>
>>
>> This is on a brand new fast machine, and 3ms is pretty slow for things that need to run dozens of times per keystroke (e.g. font-lock).
>
> Font-lock doesn’t need to find the parent of a node. So that hasn’t been a problem. In use-cases where finding the parent of a node is useful, 3ms hasn’t been a problem AFAIK. (Well, I guess indentation could benefit from a faster parent-finding function.)

It could be unrelated, but someone on Reddit complained about the speed
of rust-ts-mode's font-lock in a large enough file, and this mode's
fontification rules contain treesit-node-parent calls.

Thanks for your patch, Dmitry.  I had a chance to test it this morning (the new, non-crashing version).  I made a new NS build, with and without the patch.  The results are really striking (scroll to bottom):

  https://gist.github.com/jdtsmith/7fa6263a13559d587abb51827e6ae472

Summary:

- Applying the same test above on _axes.py reproduces the earlier emacs-mac/29 results: the time to navigate from the node at line beginning to root starts at under 10µs, but rises as sqrt(N) by ~100x, reaching over 3000µs.

- With Dimitry’s patch, it performs much, much better, starting off with similar timing at early positions in the file, but rising no higher than 50µs, scaling much shallower than sqrt(N).

I should emphasize this is a new fast machine; I fully expect my old laptop would be much slower (10x ?) than 3ms in files this large, which makes using parent navigation for things like font-lock problematic.

The patched version results also make a lot more sense in terms of their similar logarithmic growth as node-at-point, since the method of search for a node at point and for its parent is, as Yuan points at, quite similar.

--Apple-Mail=_CE95BE45-A34F-4904-A5EB-8F9B30DCFA86
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain;
	charset=utf-8



> On Aug 19, 2023, at 7:24 AM, JD Smith <jdtsmith@gmail.com> wrote:
> 
> Thanks for your patch, Dmitry.  I had a chance to test it this morning (the new, non-crashing version).  I made a new NS build, with and without the patch.  The results are really striking (scroll to bottom):
> 
>  https://gist.github.com/jdtsmith/7fa6263a13559d587abb51827e6ae472
> 
> Summary:
> 
> - Applying the same test above on _axes.py reproduces the earlier emacs-mac/29 results: the time to navigate from the node at line beginning to root starts at under 10µs, but rises as sqrt(N) by ~100x, reaching over 3000µs.
> 
> - With Dimitry’s patch, it performs much, much better, starting off with similar timing at early positions in the file, but rising no higher than 50µs, scaling much shallower than sqrt(N).
> 
> I should emphasize this is a new fast machine; I fully expect my old laptop would be much slower (10x ?) than 3ms in files this large, which makes using parent navigation for things like font-lock problematic.
> 
> The patched version results also make a lot more sense in terms of their similar logarithmic growth as node-at-point, since the method of search for a node at point and for its parent is, as Yuan points at, quite similar.

I inspected the descending algorithm, and there’s indeed an oversight made by me. Here’s a patch that should fix it. I tested it briefly and it does speeds things up greatly. Thanks for investigating this, JD!

I think the patch is relatively safe, so maybe we can push it to emacs-29 instead of master.

Yuan


--Apple-Mail=_CE95BE45-A34F-4904-A5EB-8F9B30DCFA86
Content-Disposition: attachment;
	filename=node-parent.patch
Content-Type: application/octet-stream;
	x-unix-mode44;
	name="node-parent.patch"
Content-Transfer-Encoding: quoted-printable

From dd20c4449493765c22dd2067ae410490e9f1d1dc Mon Sep 17 00:00:00 2001
From: Yuan Fu <casouri@gmail.com>
Date: Sat, 19 Aug 2023 15:04:20 -0700
Subject: [PATCH] Fix treesit_cursor_helper_1

* src/treesit.c (treesit_cursor_helper_1): Skip child nodes that can't
contain TARGET when traversing the tree: only traverse down the child
node if that node's end is grater or equal to TARGET's end.
---
 src/treesit.c | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/treesit.c b/src/treesit.c
index 1f694e47201..f9e98244a4f 100644
--- a/src/treesit.c
+++ b/src/treesit.c
@@ -3048,7 +3048,8 @@ treesit_cursor_helper_1 (TSTreeCursor *cursor, TSNode *target,
      siblings that could contain TARGET.  */
   while (ts_node_start_byte (cursor_node) <= end_pos)
     {
-      if (treesit_cursor_helper_1 (cursor, target, end_pos, limit - 1))
+      if (ts_node_end_byte (cursor_node) >= end_pos
+	  && treesit_cursor_helper_1 (cursor, target, end_pos, limit - 1))
 	return true;
 
       if (!ts_tree_cursor_goto_next_sibling (cursor))
-- 
2.41.0


--Apple-Mail=_CE95BE45-A34F-4904-A5EB-8F9B30DCFA86--

--Apple-Mail=_16D2F22E-327A-46FC-8A07-85E1F80AAEFB
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain;
	charset=utf-8



> On Aug 19, 2023, at 5:39 PM, Dmitry Gutov <dmitry@gutov.dev> wrote:
> 
> On 20/08/2023 03:18, JD Smith wrote:
>> Great, thanks.  I tried this patch out, and there is indeed about 10x of improvement.  Check the bottom of the gist.  That said, node_parent remains 10x faster yet (at worst, in a long file), so maybe there’s room for further improvement?
> 
> Similarly, I also see an improvement from Yuan's patch in my testing (about 2x), while the patch with ts_node_parent remains the fastest anyway. Where my test looks like this:
> 
>  (benchmark 1000 '(treesit-node-parent n))
> 
> I looked around for the reasons for the difference. Built the latest tree-sitter (didn't help) and found these two threads on GH:
> 
> https://github.com/tree-sitter/tree-sitter/issues/567#issuecomment-595564171 - Max Brunsfield says "There is some caching done in that method to make sure it performs well in the common case of walking repeatedly up the tree", but I haven't found where said caching resides so far.
> 
> https://github.com/tree-sitter/tree-sitter/discussions/878 - mentions that mixing cursor and direct node apis leads to suboptimal results, and just using the former gives an improvement. No "good" code example in there.
> 
> >  May be worth looking at how others are doing it, e.g. the python API.
> 
> Apparently they have both a wrapper for a cursor API, and node_get_parent which is implemented using ts_node_parent: https://github.com/tree-sitter/py-tree-sitter/issues/34
> 
> Leaving it to the callers to choose which one to use.

Ok, I fiddled around a bit more, and this patch (applies to master) should make the speed comparable to ts_node_parent.

Yuan


--Apple-Mail=_16D2F22E-327A-46FC-8A07-85E1F80AAEFB
Content-Disposition: attachment;
	filename=node-parent.patch
Content-Type: application/octet-stream;
	x-unix-mode44;
	name="node-parent.patch"
Content-Transfer-Encoding: quoted-printable

From 21d3e612d1d6819278621b956629f6c28a324145 Mon Sep 17 00:00:00 2001
From: Yuan Fu <casouri@gmail.com>
Date: Sat, 19 Aug 2023 15:04:20 -0700
Subject: [PATCH] Improve performance of treesit_cursor_helper_1

* src/treesit.c: (treesit_cursor_helper_1): Use
ts_tree_cursor_goto_first_child_for_byte to speed up traversing among
siblings.  The "while (ts_node_end_byte (cursor_node) < end_pos)" can
be removed with the check added in the loop below.
---
 src/treesit.c | 22 +++++++++-------------
 1 file changed, 9 insertions(+), 13 deletions(-)

diff --git a/src/treesit.c b/src/treesit.c
index 1f694e47201..1017c64f899 100644
--- a/src/treesit.c
+++ b/src/treesit.c
@@ -3023,7 +3023,8 @@ treesit_assume_true (bool val)
    limit.  */
 static bool
 treesit_cursor_helper_1 (TSTreeCursor *cursor, TSNode *target,
-			 uint32_t end_pos, ptrdiff_t limit)
+			 uint32_t start_pos, uint32_t end_pos,
+			 ptrdiff_t limit)
 {
   if (limit <= 0)
     return false;
@@ -3032,23 +3033,17 @@ treesit_cursor_helper_1 (TSTreeCursor *cursor, TSNode *target,
   if (ts_node_eq (cursor_node, *target))
     return true;
 
-  if (!ts_tree_cursor_goto_first_child (cursor))
+  if (ts_tree_cursor_goto_first_child_for_byte (cursor, start_pos) == -1)
     return false;
 
-  /* Skip nodes that definitely don't contain TARGET.  */
-  while (ts_node_end_byte (cursor_node) < end_pos)
-    {
-      if (!ts_tree_cursor_goto_next_sibling (cursor))
-	break;
-      cursor_node = ts_tree_cursor_current_node (cursor);
-    }
-
   /* Go through each sibling that could contain TARGET.  Because of
      missing nodes (their width is 0), there could be multiple
      siblings that could contain TARGET.  */
   while (ts_node_start_byte (cursor_node) <= end_pos)
     {
-      if (treesit_cursor_helper_1 (cursor, target, end_pos, limit - 1))
+      if (ts_node_end_byte (cursor_node) >= end_pos
+	  && treesit_cursor_helper_1 (cursor, target, start_pos, end_pos,
+				      limit - 1))
 	return true;
 
       if (!ts_tree_cursor_goto_next_sibling (cursor))
@@ -3080,11 +3075,12 @@ treesit_cursor_helper_1 (TSTreeCursor *cursor, TSNode *target,
 static bool
 treesit_cursor_helper (TSTreeCursor *cursor, TSNode node, Lisp_Object parser)
 {
+  uint32_t start_pos = ts_node_start_byte (node);
   uint32_t end_pos = ts_node_end_byte (node);
   TSNode root = ts_tree_root_node (XTS_PARSER (parser)->tree);
   *cursor = ts_tree_cursor_new (root);
-  bool success = treesit_cursor_helper_1 (cursor, &node, end_pos,
-					  TREESIT_RECURSION_LIMIT);
+  bool success = treesit_cursor_helper_1 (cursor, &node, start_pos,
+					  end_pos, TREESIT_RECURSION_LIMIT);
   if (!success)
     ts_tree_cursor_delete (cursor);
   return success;
-- 
2.41.0


--Apple-Mail=_16D2F22E-327A-46FC-8A07-85E1F80AAEFB
Content-Transfer-Encoding: 7bit
Content-Type: text/plain;
	charset=us-ascii




--Apple-Mail=_16D2F22E-327A-46FC-8A07-85E1F80AAEFB--

Great, thanks.  I tried this patch out, and there is indeed about 10x of improvement.  Check the bottom of the gist.  That said, node_parent remains 10x faster yet (at worst, in a long file), so maybe there’s room for further improvement?  May be worth looking at how others are doing it, e.g. the python API.  

Alternatively, have we ruled the seemingly simplest node_parent out prematurely?  If the issue is a node being its own parent in some odd trees, wouldn’t a simple check suffice to guard against this rare possibility?

> On Aug 19, 2023, at 6:16 PM, Yuan Fu <casouri@gmail.com> wrote:
> 
> 
> 
>> On Aug 19, 2023, at 7:24 AM, JD Smith <jdtsmith@gmail.com> wrote:
>> 
>> Thanks for your patch, Dmitry.  I had a chance to test it this morning (the new, non-crashing version).  I made a new NS build, with and without the patch.  The results are really striking (scroll to bottom):
>> 
>> https://gist.github.com/jdtsmith/7fa6263a13559d587abb51827e6ae472
>> 
>> Summary:
>> 
>> - Applying the same test above on _axes.py reproduces the earlier emacs-mac/29 results: the time to navigate from the node at line beginning to root starts at under 10µs, but rises as sqrt(N) by ~100x, reaching over 3000µs.
>> 
>> - With Dimitry’s patch, it performs much, much better, starting off with similar timing at early positions in the file, but rising no higher than 50µs, scaling much shallower than sqrt(N).
>> 
>> I should emphasize this is a new fast machine; I fully expect my old laptop would be much slower (10x ?) than 3ms in files this large, which makes using parent navigation for things like font-lock problematic.
>> 
>> The patched version results also make a lot more sense in terms of their similar logarithmic growth as node-at-point, since the method of search for a node at point and for its parent is, as Yuan points at, quite similar.
> 
> I inspected the descending algorithm, and there’s indeed an oversight made by me. Here’s a patch that should fix it. I tested it briefly and it does speeds things up greatly. Thanks for investigating this, JD!
> 
> I think the patch is relatively safe, so maybe we can push it to emacs-29 instead of master.
> 
> Yuan
> 
> <node-parent.patch>

On 20/08/2023 03:18, JD Smith wrote:
> Great, thanks.  I tried this patch out, and there is indeed about 10x of improvement.  Check the bottom of the gist.  That said, node_parent remains 10x faster yet (at worst, in a long file), so maybe there’s room for further improvement?

Similarly, I also see an improvement from Yuan's patch in my testing
(about 2x), while the patch with ts_node_parent remains the fastest
anyway. Where my test looks like this:

   (benchmark 1000 '(treesit-node-parent n))

I looked around for the reasons for the difference. Built the latest
tree-sitter (didn't help) and found these two threads on GH:

https://github.com/tree-sitter/tree-sitter/issues/567#issuecomment-595564171
- Max Brunsfield says "There is some caching done in that method to make
sure it performs well in the common case of walking repeatedly up the
tree", but I haven't found where said caching resides so far.

https://github.com/tree-sitter/tree-sitter/discussions/878 - mentions
that mixing cursor and direct node apis leads to suboptimal results, and
just using the former gives an improvement. No "good" code example in there.

 >  May be worth looking at how others are doing it, e.g. the python API.

Apparently they have both a wrapper for a cursor API, and
node_get_parent which is implemented using ts_node_parent:
https://github.com/tree-sitter/py-tree-sitter/issues/34

Leaving it to the callers to choose which one to use.

--Apple-Mail=_017751E0-2B68-4F2E-BE63-4DE9A8352BD3
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain;
	charset=utf-8

Looks like a winner (see below, or the gist)!  Thanks all.  

I do think we should consider a treesit-node-ancestors function that collects all the parent (of parent) nodes in one go into an (emacs) list, since you basically have to descend the whole tree from root to find the 1st parent anyway.   Then people who want to know, e.g., “am I in an if block?” can just test node type down the full ancestor list.  Of course, also, node-parent-until/while could be re-written to use node-ancestors, for some additional efficiency.


--Apple-Mail=_017751E0-2B68-4F2E-BE63-4DE9A8352BD3
Content-Disposition: inline;
	filename=PastedGraphic-1.png
Content-Type: image/png;
	name="PastedGraphic-1.png"
Content-Transfer-Encoding: base64
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--Apple-Mail=_017751E0-2B68-4F2E-BE63-4DE9A8352BD3
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain;
	charset=utf-8



> On Aug 19, 2023, at 10:01 PM, Yuan Fu <casouri@gmail.com> wrote:
> 
> 
> 
>> On Aug 19, 2023, at 5:39 PM, Dmitry Gutov <dmitry@gutov.dev> wrote:
>> 
>> On 20/08/2023 03:18, JD Smith wrote:
>>> Great, thanks.  I tried this patch out, and there is indeed about 10x of improvement.  Check the bottom of the gist.  That said, node_parent remains 10x faster yet (at worst, in a long file), so maybe there’s room for further improvement?
>> 
>> Similarly, I also see an improvement from Yuan's patch in my testing (about 2x), while the patch with ts_node_parent remains the fastest anyway. Where my test looks like this:
>> 
>> (benchmark 1000 '(treesit-node-parent n))
>> 
>> I looked around for the reasons for the difference. Built the latest tree-sitter (didn't help) and found these two threads on GH:
>> 
>> https://github.com/tree-sitter/tree-sitter/issues/567#issuecomment-595564171 - Max Brunsfield says "There is some caching done in that method to make sure it performs well in the common case of walking repeatedly up the tree", but I haven't found where said caching resides so far.
>> 
>> https://github.com/tree-sitter/tree-sitter/discussions/878 - mentions that mixing cursor and direct node apis leads to suboptimal results, and just using the former gives an improvement. No "good" code example in there.
>> 
>>> May be worth looking at how others are doing it, e.g. the python API.
>> 
>> Apparently they have both a wrapper for a cursor API, and node_get_parent which is implemented using ts_node_parent: https://github.com/tree-sitter/py-tree-sitter/issues/34
>> 
>> Leaving it to the callers to choose which one to use.
> 
> Ok, I fiddled around a bit more, and this patch (applies to master) should make the speed comparable to ts_node_parent.
> 
> Yuan
> 
> <node-parent.patch>
> 


--Apple-Mail=_017751E0-2B68-4F2E-BE63-4DE9A8352BD3--

> From: Yuan Fu <casouri@gmail.com>
> Date: Sat, 19 Aug 2023 15:16:12 -0700
> Cc: Dmitry Gutov <dmitry@gutov.dev>,
>  emacs-devel@gnu.org
>
> I inspected the descending algorithm, and there’s indeed an oversight made by me. Here’s a patch that should fix it. I tested it briefly and it does speeds things up greatly. Thanks for investigating this, JD!
>
> I think the patch is relatively safe, so maybe we can push it to emacs-29 instead of master.

Yes, please install on emacs-29 (assuming no one comes up with some
regression due to it).

Thanks.

On 20/08/2023 15:40, JD Smith wrote:
> Looks like a winner (see below, or the gist)!  Thanks all.

Same here, thanks all indeed.

> I do think we should consider a treesit-node-ancestors function that collects all the parent (of parent) nodes in one go into an (emacs) list, since you basically have to descend the whole tree from root to find the 1st parent anyway.   Then people who want to know, e.g., “am I in an if block?” can just test node type down the full ancestor list.  Of course, also, node-parent-until/while could be re-written to use node-ancestors, for some additional efficiency.

Should be useful, but the speedup from traversing only once might be
negated by the work of allocating the full list of Lisp objects. So it
might improve only certain applications.

OTOH, node-parent-until/while could be rewritten in a way that only
allocates Lisp on-demand.

> On Aug 20, 2023, at 1:26 PM, Dmitry Gutov <dmitry@gutov.dev> wrote:
> 
> On 20/08/2023 15:40, JD Smith wrote:
>> Looks like a winner (see below, or the gist)!  Thanks all.
> 
> Same here, thanks all indeed.

Let’s run with this patch for sometime. If all goes well, I’ll push to emacs-29. 

> 
>> I do think we should consider a treesit-node-ancestors function that collects all the parent (of parent) nodes in one go into an (emacs) list, since you basically have to descend the whole tree from root to find the 1st parent anyway.   Then people who want to know, e.g., “am I in an if block?” can just test node type down the full ancestor list.  Of course, also, node-parent-until/while could be re-written to use node-ancestors, for some additional efficiency.
> 
> Should be useful, but the speedup from traversing only once might be negated by the work of allocating the full list of Lisp objects. So it might improve only certain applications.
> 
> OTOH, node-parent-until/while could be rewritten in a way that only allocates Lisp on-demand.

Yeah, node-parent is already fast, and a tree’s height mostly doesn’t grow higher than, say, 30 levels, so I won’t worry about it until some real scenario pops up.

Yuan

> On Aug 21, 2023, at 9:41 PM, Yuan Fu <casouri@gmail.com> wrote:
> 
> 
> 
>> On Aug 20, 2023, at 1:26 PM, Dmitry Gutov <dmitry@gutov.dev> wrote:
>> 
>> On 20/08/2023 15:40, JD Smith wrote:
>>> Looks like a winner (see below, or the gist)!  Thanks all.
>> 
>> Same here, thanks all indeed.
> 
> Let’s run with this patch for sometime. If all goes well, I’ll push to emacs-29. 
> 
>> 
>>> I do think we should consider a treesit-node-ancestors function that collects all the parent (of parent) nodes in one go into an (emacs) list, since you basically have to descend the whole tree from root to find the 1st parent anyway.   Then people who want to know, e.g., “am I in an if block?” can just test node type down the full ancestor list.  Of course, also, node-parent-until/while could be re-written to use node-ancestors, for some additional efficiency.
>> 
>> Should be useful, but the speedup from traversing only once might be negated by the work of allocating the full list of Lisp objects. So it might improve only certain applications.
>> 
>> OTOH, node-parent-until/while could be rewritten in a way that only allocates Lisp on-demand.
> 
> Yeah, node-parent is already fast, and a tree’s height mostly doesn’t grow higher than, say, 30 levels, so I won’t worry about it until some real scenario pops up.
> 

Sounds good.  In the meantime I have discovered treesit-query-capture, which is already very fast and can generate a list of all parents (of a certain type etc.):

(let* ((qry (treesit-query-compile 'python '([(argument_list) (parameters) (list) (dictionary)
     (parenthesized_expression) (subscript)]
    @ctx)))
       (n (treesit-node-at (point)))
       (bg (treesit-node-start n))
       (en (treesit-node-end n)))
  (treesit-query-capture 'python qry bg en t))

It is key to compile the query in advance.  It’s actually pretty similar in speed to the parent navigation.

> On Aug 22, 2023, at 2:07 PM, JD Smith <jdtsmith@gmail.com> wrote:
> 
> 
> 
>> On Aug 21, 2023, at 9:41 PM, Yuan Fu <casouri@gmail.com> wrote:
>> 
>> 
>> 
>>> On Aug 20, 2023, at 1:26 PM, Dmitry Gutov <dmitry@gutov.dev> wrote:
>>> 
>>> On 20/08/2023 15:40, JD Smith wrote:
>>>> Looks like a winner (see below, or the gist)!  Thanks all.
>>> 
>>> Same here, thanks all indeed.
>> 
>> Let’s run with this patch for sometime. If all goes well, I’ll push to emacs-29. 
>> 

I’ve pushed the patch to emacs-29.

Yuan

> From: Yuan Fu <casouri@gmail.com>
> Date: Wed, 30 Aug 2023 21:26:58 -0700
> Cc: Dmitry Gutov <dmitry@gutov.dev>,
>  emacs-devel@gnu.org
>
> >>> On 20/08/2023 15:40, JD Smith wrote:
> >>>> Looks like a winner (see below, or the gist)!  Thanks all.
> >>>
> >>> Same here, thanks all indeed.
> >>
> >> Let’s run with this patch for sometime. If all goes well, I’ll push to emacs-29.
> >>
>
> I’ve pushed the patch to emacs-29.

Thanks, but why emacs-29?  Is this a bugfix?

--Apple-Mail=_15992026-EE10-45A0-BBAF-AE7949D0E5F4
Content-Transfer-Encoding: quoted-printable
Content-Type: text/plain;
	charset=utf-8

The scale of the improvement is up to 100x.  For me it has been on the edge between “acceptable” and “very bad”.  I have the impression that most modes are using treesit-query-capture with compiled queries for performance-sensitive stuff (font lock), which is fast, and hasn’t changed.  So those shouldn’t be affected. 

But any tree-sitter modes developed over the next few years to respect more “containing context” (structural editing, navigation, smarter context highlighting and folding, etc.) will I bet first reach for treesit-node-parent and its friends treesit-parent-while/until, as I did.  For example, I believe combobulate[1] is using these frequently (Mickey copied here).  These functions are up to 100x slower than necessary on long but still reasonable (10k line) files.

Is there a test harness somewhere that exercises treesit commands in large buffers of various different languages?  Perhaps a test could be added to “navigate up several generations” from random locations in the buffer and confirm the same nodes are reached.

[1] https://github.com/mickeynp/combobulate

> On Aug 31, 2023, at 8:51 AM, Eli Zaretskii <eliz@gnu.org> wrote:
> 
>> Date: Thu, 31 Aug 2023 14:04:39 +0300
>> Cc: jdtsmith@gmail.com, emacs-devel@gnu.org
>> From: Dmitry Gutov <dmitry@gutov.dev>
>> 
>> On 31/08/2023 09:03, Eli Zaretskii wrote:
>>> Thanks, but why emacs-29?  Is this a bugfix?
>> 
>> Depending on the POV, O(N^2) performance for certain buffer interactions 
>> can be considered a bug.
> 
> Performance improvement is an enhancement.  Unless the performance is
> very bad, I don't think its place is on the release branch, especially
> after the major release.
> 
> Stefan, WDYT?


--Apple-Mail=_15992026-EE10-45A0-BBAF-AE7949D0E5F4
Content-Transfer-Encoding: quoted-printable
Content-Type: text/html;
	charset=utf-8

<html><head><meta http-equiv="content-type" content="text/html; charset=utf-8"></head><body style="overflow-wrap: break-word; -webkit-nbsp-mode: space; line-break: after-white-space;">The scale of the improvement is up to 100x.  <font color="#000000">For me it has been on the edge between “acceptable” and “very bad”.  I have the impression that most modes are using treesit-query-capture with compiled queries for performance-sensitive stuff (font lock), which is fast, and hasn’t changed.  So those shouldn’t be affected. </font><div><font color="#000000"><br></font></div><div><font color="#000000">But</font> any tree-sitter modes developed over the next few years to respect more “containing context” (structural editing, navigation, smarter context highlighting and folding, etc.) will I bet first reach for treesit-node-parent and its friends treesit-parent-while/<span style="caret-color: rgb(0, 0, 0); color: rgb(0, 0, 0);">until</span>, as I did.  For example, I believe combobulate[1] is using these frequently (Mickey copied here).  These functions are up to 100x slower than necessary on long but still reasonable (10k line) files.</div><div><div><div><div><br></div><div>Is there a test harness somewhere that exercises treesit commands in large buffers of various different languages?  Perhaps a test could be added to “navigate up several generations” from random locations in the buffer and confirm the same nodes are reached.<br><div><br></div><div>[1] <a href="https://github.com/mickeynp/combobulate">https://github.com/mickeynp/combobulate</a></div><div><br><blockquote type="cite"><div>On Aug 31, 2023, at 8:51 AM, Eli Zaretskii <eliz@gnu.org> wrote:</div><br class="Apple-interchange-newline"><div><div><blockquote type="cite">Date: Thu, 31 Aug 2023 14:04:39 +0300<br>Cc: jdtsmith@gmail.com, emacs-devel@gnu.org<br>From: Dmitry Gutov <dmitry@gutov.dev><br><br>On 31/08/2023 09:03, Eli Zaretskii wrote:<br><blockquote type="cite">Thanks, but why emacs-29?  Is this a bugfix?<br></blockquote><br>Depending on the POV, O(N^2) performance for certain buffer interactions <br>can be considered a bug.<br></blockquote><br>Performance improvement is an enhancement.  Unless the performance is<br>very bad, I don't think its place is on the release branch, especially<br>after the major release.<br><br>Stefan, WDYT?<br></div></div></blockquote></div><br></div></div></div></div></body></html>
--Apple-Mail=_15992026-EE10-45A0-BBAF-AE7949D0E5F4--

> On Aug 30, 2023, at 11:03 PM, Eli Zaretskii <eliz@gnu.org> wrote:
> 
>> From: Yuan Fu <casouri@gmail.com>
>> Date: Wed, 30 Aug 2023 21:26:58 -0700
>> Cc: Dmitry Gutov <dmitry@gutov.dev>,
>> emacs-devel@gnu.org
>> 
>>>>> On 20/08/2023 15:40, JD Smith wrote:
>>>>>> Looks like a winner (see below, or the gist)!  Thanks all.
>>>>> 
>>>>> Same here, thanks all indeed.
>>>> 
>>>> Let’s run with this patch for sometime. If all goes well, I’ll push to emacs-29. 
>>>> 
>> 
>> I’ve pushed the patch to emacs-29.
> 
> Thanks, but why emacs-29?  Is this a bugfix?

The line is a bit blurry for this one, as others have discussed. I pushed to emacs-29 because a while ago you said yes to pushing to emacs-29. Admittedly that was a slightly different patch but the result is the same. Personally I don’t have strong feelings either way.

Yuan

On 31/08/2023 09:03, Eli Zaretskii wrote:
> Thanks, but why emacs-29?  Is this a bugfix?

Depending on the POV, O(N^2) performance for certain buffer interactions
can be considered a bug.

> Date: Thu, 31 Aug 2023 14:04:39 +0300
> Cc: jdtsmith@gmail.com, emacs-devel@gnu.org
> From: Dmitry Gutov <dmitry@gutov.dev>
>
> On 31/08/2023 09:03, Eli Zaretskii wrote:
> > Thanks, but why emacs-29?  Is this a bugfix?
>
> Depending on the POV, O(N^2) performance for certain buffer interactions
> can be considered a bug.

Performance improvement is an enhancement.  Unless the performance is
very bad, I don't think its place is on the release branch, especially
after the major release.

Stefan, WDYT?

Dmitry Gutov <dmitry@gutov.dev> writes:

> Depending on the POV, O(N^2) performance for certain buffer
> interactions can be considered a bug.

But is fixing it is worth the risk?  Is the change innocuous enough for
the release branch?

On 31/08/2023 14:42, Po Lu wrote:
> Dmitry Gutov<dmitry@gutov.dev>  writes:
>
>> Depending on the POV, O(N^2) performance for certain buffer
>> interactions can be considered a bug.
> But is fixing it is worth the risk?  Is the change innocuous enough for
> the release branch?

It seems so, yes.

The change doesn't increase code complexity, and rather fixes an
omission where many nodes weren't outright filtered out during the search.

Also, as JD said, packages using tree-sitter are going to be constrained
by the lower common denominator of the primitives' performance
characteristics. At least some of those will be able to recommend 29.2
(or put it as a dependency).

On 31/08/2023 15:51, Eli Zaretskii wrote:
> Unless the performance is
> very bad, I don't think its place is on the release branch, especially
> after the major release.

There was a complaint on Reddit about rust-ts-mode's syntax-highlighting
performance is certain large (but not huge) files.

> From: Yuan Fu <casouri@gmail.com>
> Date: Thu, 31 Aug 2023 12:03:49 -0700
> Cc: JD Smith <jdtsmith@gmail.com>,
>  Dmitry Gutov <dmitry@gutov.dev>,
>  emacs-devel@gnu.org
>
> >> I’ve pushed the patch to emacs-29.
> >
> > Thanks, but why emacs-29?  Is this a bugfix?
>
> The line is a bit blurry for this one, as others have discussed. I pushed to emacs-29 because a while ago you said yes to pushing to emacs-29. Admittedly that was a slightly different patch but the result is the same. Personally I don’t have strong feelings either way.

Stefan, WDYT about this?  I admit I'm a bit weary, but everyone else
seems to think this is a bugfix.

Eli Zaretskii <eliz@gnu.org> writes:

> Stefan, WDYT about this?  I admit I'm a bit weary, but everyone else
> seems to think this is a bugfix.

I'm not sure I can be of much help here; I really haven't been
following treesitter development very closely.  Having looked at the
patch, the fix is also slightly less trivial than I had hoped, in the
sense that I don't understand it.  :-)

That said, I do think that stability expectations might be a bit
different for a completely new and (arguably) semi-optional feature.
Yuan Fu's stated opinion up-thread was that the patch is "relatively
safe".

If it was up to me, I'd probably keep it on emacs-29, with a readiness
to revert if any issues were to crop up.  But I won't object either
way.

> From: Stefan Kangas <stefankangas@gmail.com>
> Date: Thu, 31 Aug 2023 22:24:03 +0200
> Cc: Yuan Fu <casouri@gmail.com>, jdtsmith@gmail.com, dmitry@gutov.dev,
> 	emacs-devel@gnu.org
>
> Eli Zaretskii <eliz@gnu.org> writes:
>
> > Stefan, WDYT about this?  I admit I'm a bit weary, but everyone else
> > seems to think this is a bugfix.
>
> I'm not sure I can be of much help here; I really haven't been
> following treesitter development very closely.  Having looked at the
> patch, the fix is also slightly less trivial than I had hoped, in the
> sense that I don't understand it.  :-)
>
> That said, I do think that stability expectations might be a bit
> different for a completely new and (arguably) semi-optional feature.
> Yuan Fu's stated opinion up-thread was that the patch is "relatively
> safe".
>
> If it was up to me, I'd probably keep it on emacs-29, with a readiness
> to revert if any issues were to crop up.  But I won't object either
> way.

OK, so let's keep it on emacs-29 and watch for any possible problems
it could cause.

Thanks.