From 3aba4ba37859e4407eff2bb3f4d99c44b108ed79 Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Fri, 22 Apr 2022 21:50:52 +0200
Subject: [PATCH 01/11] feat(treesitter): upstream is_parent()

Util from the nvim-treesitter project.
Renamed is_parent to is_ancestor for clarity.
---
 runtime/lua/vim/treesitter.lua            | 23 ++++++++++++++++++
 test/functional/treesitter/utils_spec.lua | 29 +++++++++++++++++++++++
 2 files changed, 52 insertions(+)
 create mode 100644 test/functional/treesitter/utils_spec.lua

diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index 70f2c425ed..37ab59b259 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -118,4 +118,27 @@ function M.get_string_parser(str, lang, opts)
   return LanguageTree.new(str, lang, opts)
 end
 
+--- Determines whether a node is the ancestor of another
+---
+---@param dest table the possible ancestor
+---@param source table the possible descendant node
+---
+---@returns (boolean) True if dest is an ancestor of source
+function M.is_ancestor(dest, source)
+  if not (dest and source) then
+    return false
+  end
+
+  local current = source
+  while current ~= nil do
+    if current == dest then
+      return true
+    end
+
+    current = current:parent()
+  end
+
+  return false
+end
+
 return M
diff --git a/test/functional/treesitter/utils_spec.lua b/test/functional/treesitter/utils_spec.lua
new file mode 100644
index 0000000000..c5609501a7
--- /dev/null
+++ b/test/functional/treesitter/utils_spec.lua
@@ -0,0 +1,29 @@
+local helpers = require('test.functional.helpers')(after_each)
+
+local clear = helpers.clear
+local insert = helpers.insert
+local eq = helpers.eq
+local exec_lua = helpers.exec_lua
+
+before_each(clear)
+
+describe('treesitter utils', function()
+  clear()
+  it('can find an ancestor', function()
+    insert([[
+      int main() {
+        int x = 3;
+      }]])
+
+    exec_lua([[
+      parser = vim.treesitter.get_parser(0, "c")
+      tree = parser:parse()[1]
+      root = tree:root()
+      ancestor = root:child(0)
+      child = ancestor:child(0)
+    ]])
+
+    eq(true, exec_lua('return vim.treesitter.is_ancestor(ancestor, child)'))
+    eq(false, exec_lua('return vim.treesitter.is_ancestor(child, ancestor)'))
+  end)
+end)

From 733b2e12b86a34c00aa07e0491762f88582792a5 Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Tue, 26 Apr 2022 22:42:48 +0200
Subject: [PATCH 02/11] feat(treesitter): add opts.concat to
 query.get_text_node

As part of the upstream of utility functions from nvim-treesitter, this
option when set to false allows to return a table (downstream behavior).
Effectively making the switch from the downstream to the upstream
function much easier.
---
 runtime/lua/vim/treesitter/query.lua | 13 +++++++++----
 1 file changed, 9 insertions(+), 4 deletions(-)

diff --git a/runtime/lua/vim/treesitter/query.lua b/runtime/lua/vim/treesitter/query.lua
index 103e85abfd..697e2e7691 100644
--- a/runtime/lua/vim/treesitter/query.lua
+++ b/runtime/lua/vim/treesitter/query.lua
@@ -181,9 +181,14 @@ end
 
 --- Gets the text corresponding to a given node
 ---
----@param node the node
----@param source The buffer or string from which the node is extracted
-function M.get_node_text(node, source)
+---@param node table The node
+---@param source table The buffer or string from which the node is extracted
+---@param opts table Optional parameters.
+---          - concat: (boolean default true) Concatenate result in a string
+function M.get_node_text(node, source, opts)
+  opts = opts or {}
+  local concat = vim.F.if_nil(opts.concat, true)
+
   local start_row, start_col, start_byte = node:start()
   local end_row, end_col, end_byte = node:end_()
 
@@ -210,7 +215,7 @@ function M.get_node_text(node, source)
       end
     end
 
-    return table.concat(lines, '\n')
+    return concat and table.concat(lines, '\n') or lines
   elseif type(source) == 'string' then
     return source:sub(start_byte + 1, end_byte)
   end

From 6b2d42eb0352d01923e4bf2e3ce0824c662b7be4 Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Sat, 30 Apr 2022 10:43:26 +0200
Subject: [PATCH 03/11] feat(treesitter): add ability to retreive a tree/node
 given a range

---
 runtime/lua/vim/treesitter/languagetree.lua  | 38 ++++++++++++++++++++
 test/functional/treesitter/language_spec.lua | 29 +++++++++++++++
 2 files changed, 67 insertions(+)

diff --git a/runtime/lua/vim/treesitter/languagetree.lua b/runtime/lua/vim/treesitter/languagetree.lua
index 4d3b0631a2..f87a66ddab 100644
--- a/runtime/lua/vim/treesitter/languagetree.lua
+++ b/runtime/lua/vim/treesitter/languagetree.lua
@@ -549,6 +549,44 @@ function LanguageTree:contains(range)
   return false
 end
 
+--- Gets the tree that contains {range}
+---
+---@param range table A text range
+---@param opts table Options table
+---@param opts.ignore_injections boolean (default true) Ignore injected languages.
+function LanguageTree:tree_for_range(range, opts)
+  opts = opts or {}
+  local ignore = vim.F.if_nil(opts.ignore_injections, true)
+
+  if not ignore then
+    for _, child in pairs(self._children) do
+      for _, tree in pairs(child:trees()) do
+        if tree_contains(tree, range) then
+          return tree
+        end
+      end
+    end
+  end
+
+  for _, tree in pairs(self._trees) do
+    if tree_contains(tree, range) then
+      return tree
+    end
+  end
+
+  return nil
+end
+
+--- Gets the smallest named node that contains {range}
+---
+---@param range table A text range
+---@param opts table Options table
+---@param opts.ignore_injections boolean (default true) Ignore injected languages.
+function LanguageTree:named_node_for_range(range, opts)
+  local tree = self:tree_for_range(range, opts)
+  return tree:root():named_descendant_for_range(unpack(range))
+end
+
 --- Gets the appropriate language that contains {range}
 ---
 ---@param range A text range, see |LanguageTree:contains|
diff --git a/test/functional/treesitter/language_spec.lua b/test/functional/treesitter/language_spec.lua
index 8aa8524a26..b66a56264f 100644
--- a/test/functional/treesitter/language_spec.lua
+++ b/test/functional/treesitter/language_spec.lua
@@ -7,6 +7,7 @@ local exec_lua = helpers.exec_lua
 local pcall_err = helpers.pcall_err
 local matches = helpers.matches
 local pending_c_parser = helpers.pending_c_parser
+local insert = helpers.insert
 
 before_each(clear)
 
@@ -84,5 +85,33 @@ describe('treesitter language API', function()
     eq("Error executing lua: .../language.lua:0: no parser for 'borklang' language, see :help treesitter-parsers",
        pcall_err(exec_lua, "new_parser = vim.treesitter.get_parser(0)"))
   end)
+
+  it('retrieve the tree given a range', function ()
+    insert([[
+      int main() {
+        int x = 3;
+      }]])
+
+    exec_lua([[
+      langtree = vim.treesitter.get_parser(0, "c")
+      tree = langtree:tree_for_range({1, 3, 1, 3})
+    ]])
+
+    eq('<node translation_unit>', exec_lua('return tostring(tree:root())'))
+  end)
+
+  it('retrieve the node given a range', function ()
+    insert([[
+      int main() {
+        int x = 3;
+      }]])
+
+    exec_lua([[
+      langtree = vim.treesitter.get_parser(0, "c")
+      node = langtree:named_node_for_range({1, 3, 1, 3})
+    ]])
+
+    eq('<node primitive_type>', exec_lua('return tostring(node)'))
+  end)
 end)
 

From a577fb778addb6eb305ade82a229b52673ced234 Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Sat, 30 Apr 2022 20:54:25 +0200
Subject: [PATCH 04/11] feat(treesitter): upstream get_named_children() as a
 node method

Util from the nvim-treesitter project.
---
 src/nvim/lua/treesitter.c                | 26 ++++++++++++++++++++++++
 test/functional/treesitter/node_spec.lua | 18 ++++++++++++++++
 2 files changed, 44 insertions(+)

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 954c3410d3..2ef4d6052c 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -88,6 +88,7 @@ static struct luaL_Reg node_meta[] = {
   { "prev_sibling", node_prev_sibling },
   { "next_named_sibling", node_next_named_sibling },
   { "prev_named_sibling", node_prev_named_sibling },
+  { "named_children", node_named_children },
   { NULL, NULL }
 };
 
@@ -1062,6 +1063,31 @@ static int node_prev_named_sibling(lua_State *L)
   return 1;
 }
 
+static int node_named_children(lua_State *L)
+{
+  TSNode source;
+  if (!node_check(L, 1, &source)) {
+    return 0;
+  }
+  TSTreeCursor cursor = ts_tree_cursor_new(source);
+
+  lua_newtable(L);
+  int curr_index = 0;
+
+  if (ts_tree_cursor_goto_first_child(&cursor)) {
+    do {
+      TSNode node = ts_tree_cursor_current_node(&cursor);
+      if (ts_node_is_named(node)) {
+        push_node(L, node, 1);
+        lua_rawseti(L, -2, ++curr_index);
+      }
+    } while (ts_tree_cursor_goto_next_sibling(&cursor));
+  }
+
+  ts_tree_cursor_delete(&cursor);
+  return 1;
+}
+
 /// assumes the match table being on top of the stack
 static void set_match(lua_State *L, TSQueryMatch *match, int nodeidx)
 {
diff --git a/test/functional/treesitter/node_spec.lua b/test/functional/treesitter/node_spec.lua
index 21c287644e..b9ad4925c9 100644
--- a/test/functional/treesitter/node_spec.lua
+++ b/test/functional/treesitter/node_spec.lua
@@ -59,4 +59,22 @@ describe('treesitter node API', function()
     exec_lua 'node = node:prev_named_sibling()'
     eq('int x', lua_eval('node_text(node)'))
   end)
+
+  it('can retrieve the children of a node', function()
+    insert([[
+      int main() {
+        int x = 3;
+      }]])
+
+    local len = exec_lua([[
+      tree = vim.treesitter.get_parser(0, "c"):parse()[1]
+      node = tree:root():child(0)
+      children = node:named_children()
+
+      return #children
+    ]])
+
+    eq(3, len)
+    eq('<node compound_statement>', lua_eval('tostring(children[3])'))
+  end)
 end)

From baba43681e792db30318bdedc3e73e4fe12482a6 Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Sun, 1 May 2022 11:35:12 +0200
Subject: [PATCH 05/11] feat(treesitter): upstream get_root_for_node() as a
 node method

Util from the nvim-treesitter project.
---
 src/nvim/lua/treesitter.c                | 23 +++++++++++++++++++++++
 test/functional/treesitter/node_spec.lua | 15 +++++++++++++++
 2 files changed, 38 insertions(+)

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 2ef4d6052c..083042ad98 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -89,6 +89,8 @@ static struct luaL_Reg node_meta[] = {
   { "next_named_sibling", node_next_named_sibling },
   { "prev_named_sibling", node_prev_named_sibling },
   { "named_children", node_named_children },
+  { "root", node_root },
+
   { NULL, NULL }
 };
 
@@ -1088,6 +1090,27 @@ static int node_named_children(lua_State *L)
   return 1;
 }
 
+static int node_root(lua_State *L)
+{
+  TSNode parent;
+  TSNode result;
+
+  TSNode node;
+  if (!node_check(L, 1, &node)) {
+    return 0;
+  }
+  parent = node;
+  result = node;
+
+  while (!ts_node_is_null(parent)){
+    result = parent;
+    parent = ts_node_parent(result);
+  }
+
+  push_node(L, result, 1);
+  return 1;
+}
+
 /// assumes the match table being on top of the stack
 static void set_match(lua_State *L, TSQueryMatch *match, int nodeidx)
 {
diff --git a/test/functional/treesitter/node_spec.lua b/test/functional/treesitter/node_spec.lua
index b9ad4925c9..9450526257 100644
--- a/test/functional/treesitter/node_spec.lua
+++ b/test/functional/treesitter/node_spec.lua
@@ -77,4 +77,19 @@ describe('treesitter node API', function()
     eq(3, len)
     eq('<node compound_statement>', lua_eval('tostring(children[3])'))
   end)
+
+  it('can retrieve the tree root given a node', function()
+    insert([[
+      int main() {
+        int x = 3;
+      }]])
+
+    exec_lua([[
+      tree = vim.treesitter.get_parser(0, "c"):parse()[1]
+      root = tree:root()
+      node = root:child(0):child(2)
+    ]])
+
+    eq(lua_eval('tostring(root)'), lua_eval('tostring(node:root())'))
+  end)
 end)

From f57341a4b69398ff0c58686e66c2f4138be164aa Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Sun, 1 May 2022 21:13:47 +0200
Subject: [PATCH 06/11] feat(treesitter): upstream node_length() as a node
 method

Util from the nvim-treesitter project.
---
 src/nvim/lua/treesitter.c                | 15 +++++++++++++++
 test/functional/treesitter/node_spec.lua | 16 ++++++++++++++++
 2 files changed, 31 insertions(+)

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 083042ad98..8803fd452c 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -90,6 +90,7 @@ static struct luaL_Reg node_meta[] = {
   { "prev_named_sibling", node_prev_named_sibling },
   { "named_children", node_named_children },
   { "root", node_root },
+  { "byte_length", node_byte_length },
 
   { NULL, NULL }
 };
@@ -1111,6 +1112,20 @@ static int node_root(lua_State *L)
   return 1;
 }
 
+static int node_byte_length(lua_State *L)
+{
+  TSNode node;
+  if (!node_check(L, 1, &node)) {
+    return 0;
+  }
+
+  uint32_t start_byte = ts_node_start_byte(node);
+  uint32_t end_byte = ts_node_end_byte(node);
+
+  lua_pushnumber(L, end_byte - start_byte);
+  return 1;
+}
+
 /// assumes the match table being on top of the stack
 static void set_match(lua_State *L, TSQueryMatch *match, int nodeidx)
 {
diff --git a/test/functional/treesitter/node_spec.lua b/test/functional/treesitter/node_spec.lua
index 9450526257..87ce1b973c 100644
--- a/test/functional/treesitter/node_spec.lua
+++ b/test/functional/treesitter/node_spec.lua
@@ -92,4 +92,20 @@ describe('treesitter node API', function()
 
     eq(lua_eval('tostring(root)'), lua_eval('tostring(node:root())'))
   end)
+
+  it('can compute the byte length of a node', function()
+    insert([[
+      int main() {
+        int x = 3;
+      }]])
+
+    exec_lua([[
+      tree = vim.treesitter.get_parser(0, "c"):parse()[1]
+      root = tree:root()
+      child = root:child(0):child(0)
+    ]])
+
+    eq(28, lua_eval('root:byte_length()'))
+    eq(3, lua_eval('child:byte_length()'))
+  end)
 end)

From 133ff6e11ea862c7425d9c6a2827b20c97cf297f Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Thu, 2 Jun 2022 18:13:05 +0200
Subject: [PATCH 07/11] feat(treesitter): upstream node_contains()

Util from the nvim-treesitter project.
---
 runtime/lua/vim/treesitter.lua | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index 37ab59b259..0936d62296 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -141,4 +141,17 @@ function M.is_ancestor(dest, source)
   return false
 end
 
+---Determines if a node contains a range
+---@param node table The node
+---@param range table The range
+---
+---@returns (boolean) True if the node contains the range
+function M.node_contains(node, range)
+  local start_row, start_col, end_row, end_col = node:range()
+  local start_fits = start_row < range[1] or (start_row == range[1] and start_col <= range[2])
+  local end_fits = end_row > range[3] or (end_row == range[3] and end_col >= range[4])
+
+  return start_fits and end_fits
+end
+
 return M

From 244a115e494bce8e8205c04a6e5f3ab74ec4ed65 Mon Sep 17 00:00:00 2001
From: Quentin Rasmont <qrasmont@gmail.com>
Date: Sun, 24 Jul 2022 20:49:33 +0200
Subject: [PATCH 08/11] feat(treesitter): clarify similar 'get_node_range'
 functions

The private 'get_node_range' function from the languagetree module has
been renamed and remains private as it serve a purpose that is only
relevant inside the languagetree module.

The 'get_node_range' upstreamed from nvim-treesitter in the treesitter
module has been made public as it is in itself a utlity function.
---
 runtime/lua/vim/treesitter.lua              | 13 +++++++++++++
 runtime/lua/vim/treesitter/languagetree.lua |  6 +++---
 2 files changed, 16 insertions(+), 3 deletions(-)

diff --git a/runtime/lua/vim/treesitter.lua b/runtime/lua/vim/treesitter.lua
index 0936d62296..82d41070ee 100644
--- a/runtime/lua/vim/treesitter.lua
+++ b/runtime/lua/vim/treesitter.lua
@@ -141,6 +141,19 @@ function M.is_ancestor(dest, source)
   return false
 end
 
+--- Get the node's range or unpack a range table
+---
+---@param node_or_range table
+---
+---@returns start_row, start_col, end_row, end_col
+function M.get_node_range(node_or_range)
+  if type(node_or_range) == 'table' then
+    return unpack(node_or_range)
+  else
+    return node_or_range:range()
+  end
+end
+
 ---Determines if a node contains a range
 ---@param node table The node
 ---@param range table The range
diff --git a/runtime/lua/vim/treesitter/languagetree.lua b/runtime/lua/vim/treesitter/languagetree.lua
index f87a66ddab..70317a9f94 100644
--- a/runtime/lua/vim/treesitter/languagetree.lua
+++ b/runtime/lua/vim/treesitter/languagetree.lua
@@ -299,7 +299,7 @@ function LanguageTree:included_regions()
 end
 
 ---@private
-local function get_node_range(node, id, metadata)
+local function get_range_from_metadata(node, id, metadata)
   if metadata[id] and metadata[id].range then
     return metadata[id].range
   end
@@ -362,7 +362,7 @@ function LanguageTree:_get_injections()
         elseif name == 'combined' then
           combined = true
         elseif name == 'content' and #ranges == 0 then
-          table.insert(ranges, get_node_range(node, id, metadata))
+          table.insert(ranges, get_range_from_metadata(node, id, metadata))
           -- Ignore any tags that start with "_"
           -- Allows for other tags to be used in matches
         elseif string.sub(name, 1, 1) ~= '_' then
@@ -371,7 +371,7 @@ function LanguageTree:_get_injections()
           end
 
           if #ranges == 0 then
-            table.insert(ranges, get_node_range(node, id, metadata))
+            table.insert(ranges, get_range_from_metadata(node, id, metadata))
           end
         end
       end

From 8554164b1e985e552576cf3dcf1178a959ebf5e3 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Thu, 25 Aug 2022 15:52:56 +0200
Subject: [PATCH 09/11] fix(docs): update auto-generated documentation

---
 runtime/doc/treesitter.txt | 61 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 58 insertions(+), 3 deletions(-)

diff --git a/runtime/doc/treesitter.txt b/runtime/doc/treesitter.txt
index 06409f9980..c80d8f4479 100644
--- a/runtime/doc/treesitter.txt
+++ b/runtime/doc/treesitter.txt
@@ -352,6 +352,15 @@ attribute: >
 ==============================================================================
 Lua module: vim.treesitter                               *lua-treesitter-core*
 
+get_node_range({node_or_range})                             *get_node_range()*
+    Get the node's range or unpack a range table
+
+    Parameters: ~
+        {node_or_range}  (table)
+
+    Return: ~
+        start_row, start_col, end_row, end_col
+
 get_parser({bufnr}, {lang}, {opts})                             *get_parser()*
     Gets the parser for this bufnr / ft combination.
 
@@ -374,6 +383,26 @@ get_string_parser({str}, {lang}, {opts})                 *get_string_parser()*
         {lang}  The language of this string
         {opts}  Options to pass to the created language tree
 
+is_ancestor({dest}, {source})                                  *is_ancestor()*
+    Determines whether a node is the ancestor of another
+
+    Parameters: ~
+        {dest}    (table) the possible ancestor
+        {source}  (table) the possible descendant node
+
+    Return: ~
+        (boolean) True if dest is an ancestor of source
+
+node_contains({node}, {range})                               *node_contains()*
+    Determines if a node contains a range
+
+    Parameters: ~
+        {node}   (table) The node
+        {range}  (table) The range
+
+    Return: ~
+        (boolean) True if the node contains the range
+
 
 ==============================================================================
 Lua module: vim.treesitter.language                      *treesitter-language*
@@ -427,12 +456,16 @@ add_predicate({name}, {handler}, {force})                    *add_predicate()*
         {handler}  the handler function to be used signature will be (match,
                    pattern, bufnr, predicate)
 
-get_node_text({node}, {source})                              *get_node_text()*
+get_node_text({node}, {source}, {opts})                      *get_node_text()*
     Gets the text corresponding to a given node
 
     Parameters: ~
-        {node}    the node
-        {source}  The buffer or string from which the node is extracted
+        {node}    (table) The node
+        {source}  (table) The buffer or string from which the node is
+                  extracted
+        {opts}    (table) Optional parameters.
+                  • concat: (boolean default true) Concatenate result in a
+                    string
 
 get_query({lang}, {query_name})                                  *get_query()*
     Returns the runtime query {query_name} for {lang}.
@@ -678,6 +711,17 @@ LanguageTree:language_for_range({self}, {range})
 
     Parameters: ~
         {range}  A text range, see |LanguageTree:contains|
+        {self}
+
+                                         *LanguageTree:named_node_for_range()*
+LanguageTree:named_node_for_range({self}, {range}, {opts})
+    Gets the smallest named node that contains {range}
+
+    Parameters: ~
+        {range}                   (table) A text range
+        {opts}                    (table) Options table
+        {opts.ignore_injections}  (boolean) (default true) Ignore injected
+                                  languages.
         {self}
 
 LanguageTree:parse({self})                              *LanguageTree:parse()*
@@ -738,6 +782,17 @@ LanguageTree:source({self})                            *LanguageTree:source()*
     Returns the source content of the language tree (bufnr or string).
 
     Parameters: ~
+        {self}
+
+                                               *LanguageTree:tree_for_range()*
+LanguageTree:tree_for_range({self}, {range}, {opts})
+    Gets the tree that contains {range}
+
+    Parameters: ~
+        {range}                   (table) A text range
+        {opts}                    (table) Options table
+        {opts.ignore_injections}  (boolean) (default true) Ignore injected
+                                  languages.
         {self}
 
 LanguageTree:trees({self})                              *LanguageTree:trees()*

From e5fe41198c57a746b282fdfcde5ccb7c5adad605 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Thu, 25 Aug 2022 18:24:56 +0200
Subject: [PATCH 10/11] fix(treesitter): more efficient node:root()

---
 src/nvim/lua/treesitter.c | 15 +++------------
 1 file changed, 3 insertions(+), 12 deletions(-)

diff --git a/src/nvim/lua/treesitter.c b/src/nvim/lua/treesitter.c
index 8803fd452c..7ff4fbbff4 100644
--- a/src/nvim/lua/treesitter.c
+++ b/src/nvim/lua/treesitter.c
@@ -623,7 +623,7 @@ void push_tree(lua_State *L, TSTree *tree, bool do_copy)
   lua_setfenv(L, -2);  // [udata]
 }
 
-static TSTree **tree_check(lua_State *L, uint16_t index)
+static TSTree **tree_check(lua_State *L, int index)
 {
   TSTree **ud = luaL_checkudata(L, index, TS_META_TREE);
   return ud;
@@ -1093,22 +1093,13 @@ static int node_named_children(lua_State *L)
 
 static int node_root(lua_State *L)
 {
-  TSNode parent;
-  TSNode result;
-
   TSNode node;
   if (!node_check(L, 1, &node)) {
     return 0;
   }
-  parent = node;
-  result = node;
 
-  while (!ts_node_is_null(parent)){
-    result = parent;
-    parent = ts_node_parent(result);
-  }
-
-  push_node(L, result, 1);
+  TSNode root = ts_tree_root_node(node.tree);
+  push_node(L, root, 1);
   return 1;
 }
 

From 73ee2b35d1fc738be9bd4b99f49ce8f84351fbe6 Mon Sep 17 00:00:00 2001
From: bfredl <bjorn.linse@gmail.com>
Date: Thu, 25 Aug 2022 20:49:27 +0200
Subject: [PATCH 11/11] fix(tests): use pending_c_parser when needed

---
 test/functional/treesitter/language_spec.lua | 2 ++
 test/functional/treesitter/utils_spec.lua    | 6 +++++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/test/functional/treesitter/language_spec.lua b/test/functional/treesitter/language_spec.lua
index b66a56264f..8e9941d797 100644
--- a/test/functional/treesitter/language_spec.lua
+++ b/test/functional/treesitter/language_spec.lua
@@ -87,6 +87,7 @@ describe('treesitter language API', function()
   end)
 
   it('retrieve the tree given a range', function ()
+    if pending_c_parser(pending) then return end
     insert([[
       int main() {
         int x = 3;
@@ -101,6 +102,7 @@ describe('treesitter language API', function()
   end)
 
   it('retrieve the node given a range', function ()
+    if pending_c_parser(pending) then return end
     insert([[
       int main() {
         int x = 3;
diff --git a/test/functional/treesitter/utils_spec.lua b/test/functional/treesitter/utils_spec.lua
index c5609501a7..4f4c18a748 100644
--- a/test/functional/treesitter/utils_spec.lua
+++ b/test/functional/treesitter/utils_spec.lua
@@ -4,12 +4,16 @@ local clear = helpers.clear
 local insert = helpers.insert
 local eq = helpers.eq
 local exec_lua = helpers.exec_lua
+local pending_c_parser = helpers.pending_c_parser
 
 before_each(clear)
 
 describe('treesitter utils', function()
-  clear()
+  before_each(clear)
+
   it('can find an ancestor', function()
+    if pending_c_parser(pending) then return end
+
     insert([[
       int main() {
         int x = 3;