fix(treesitter): standalone implementation

Drop hard nvim-treesitter requirement, but assumes parser and
`locals` query (using the captures documented here:
https://github.com/nvim-treesitter/nvim-treesitter/blob/main/CONTRIBUTING.md#locals)
is available on `runtimepath`.

Locals module is extracted from
https://github.com/nvim-treesitter/nvim-treesitter/blob/53dccb3a77da54a4e428275e8b44dbff77e0d47d/lua/nvim-treesitter/locals.lua
(which has since been removed because it is no longer used).

Author: clason

README.md

@@ -68,7 +68,6 @@ wiki.
 ### Optional dependencies
 
 - [sharkdp/fd](https://github.com/sharkdp/fd) (finder)
-- [nvim-treesitter/nvim-treesitter](https://github.com/nvim-treesitter/nvim-treesitter) (finder/preview)
 - [neovim LSP](https://neovim.io/doc/user/lsp.html) (picker)
 - [devicons](https://github.com/nvim-tree/nvim-web-devicons) (icons)
 

lua/telescope/builtin/__files.lua

@@ -397,50 +397,34 @@ files.find_files = function(opts)
     :find()
 end
 
-local function prepare_match(entry, kind)
-  local entries = {}
-
-  if entry.node then
-    table.insert(entries, entry)
-  else
-    for name, item in pairs(entry) do
-      vim.list_extend(entries, prepare_match(item, name))
-    end
-  end
-
-  return entries
-end
-
 --  TODO: finish docs for opts.show_line
 files.treesitter = function(opts)
   opts.show_line = vim.F.if_nil(opts.show_line, true)
+  local ft = vim.bo[opts.bufnr].filetype
+  local lang = vim.treesitter.language.get_lang(ft)
 
-  local has_nvim_treesitter, _ = pcall(require, "nvim-treesitter")
-  if not has_nvim_treesitter then
+  if not (lang and vim.treesitter.language.add(lang)) then
     utils.notify("builtin.treesitter", {
-      msg = "This picker requires nvim-treesitter",
+      msg = "No parser for the current buffer",
       level = "ERROR",
     })
     return
   end
 
-  local parsers = require "nvim-treesitter.parsers"
-  if not parsers.has_parser(parsers.get_buf_lang(opts.bufnr)) then
+  if not (lang and vim.treesitter.query.get(lang, "locals")) then
     utils.notify("builtin.treesitter", {
-      msg = "No parser for the current buffer",
+      msg = "No locals query for the current buffer",
       level = "ERROR",
     })
     return
   end
 
-  local ts_locals = require "nvim-treesitter.locals"
+  local definitions, _, _ = require("telescope.ts_locals").get(opts.bufnr)
   local results = {}
-  for _, definition in ipairs(ts_locals.get_definitions(opts.bufnr)) do
-    local entries = prepare_match(ts_locals.get_local_nodes(definition))
-    for _, entry in ipairs(entries) do
-      entry.kind = vim.F.if_nil(entry.kind, "")
-      table.insert(results, entry)
-    end
+  for _, definition in ipairs(definitions) do
+    local kind = definition.kind:gsub("local%.definition%.", "")
+    definition.kind = vim.F.if_nil(kind, "")
+    table.insert(results, definition)
   end
 
   results = utils.filter_symbols(results, opts)

lua/telescope/health.lua

@@ -30,11 +30,6 @@ local optional_dependencies = {
 
 local required_plugins = {
   { lib = "plenary", optional = false },
-  {
-    lib = "nvim-treesitter",
-    optional = true,
-    info = "(Required for `:Telescope treesitter`.)",
-  },
 }
 
 local check_binary_installed = function(package)

lua/telescope/ts_locals.lua

@@ -0,0 +1,121 @@
+local ts = vim.treesitter
+
+local M = {}
+
+---Memoize a function using hash_fn to hash the arguments.
+---@generic F: function
+---@param fn F
+---@param hash_fn fun(...): any
+---@return F
+local function memoize(fn, hash_fn)
+  local cache = setmetatable({}, { __mode = "kv" }) ---@type table<any,any[]>
+
+  return function(...)
+    local key = hash_fn(...)
+    if cache[key] == nil then
+      local v = { fn(...) } ---@type any[]
+
+      for k, value in pairs(v) do
+        if value == nil then
+          value[k] = vim.NIL ---@type table
+        end
+      end
+
+      cache[key] = v
+    end
+
+    local v = cache[key]
+
+    for k, value in ipairs(v) do
+      if value == vim.NIL then
+        value[k] = nil ---@type table
+      end
+    end
+
+    return unpack(v)
+  end
+end
+---@param bufnr integer: the buffer
+---@return TSNode|nil root: root node of the buffer
+local function get_root(bufnr)
+  local parser = ts.get_parser(bufnr)
+  if not parser then
+    return
+  end
+  parser:parse()
+  return parser:trees()[1]:root()
+end
+
+---@param bufnr integer: the buffer
+---@return vim.treesitter.Query|nil query: `locals` query
+---@return TSNode|nil root: root node of the bufferocal function get_query(bufnr)
+local function get_query(bufnr)
+  local root = get_root(bufnr)
+
+  local ft = vim.bo[bufnr].filetype
+  local lang = ts.language.get_lang(ft) or ft
+
+  local query = (ts.query.get(lang, "locals"))
+
+  return query, root
+end
+
+---@alias TSScope "parent"|"local"|"global"
+
+---@class TSLocal
+---@field kind string
+---@field node TSNode
+---@field scope TSScope
+
+-- Return all locals for the buffer
+--
+-- memoized by buffer tick
+--
+---@param bufnr integer buffer
+---@return TSLocal[] definitions
+---@return TSLocal[] references
+---@return TSNode[] scopes
+M.get = memoize(function(bufnr)
+  local query, root = get_query(bufnr)
+  if not query or not root then
+    return {}, {}, {}
+  end
+
+  local definitions = {}
+  local scopes = {}
+  local references = {}
+  for id, node, metadata in query:iter_captures(root, bufnr) do
+    local kind = query.captures[id]
+
+    local scope = "local" ---@type string
+    for k, v in
+      pairs(metadata --[[@as {[integer|string]: string}]])
+    do
+      if type(k) == "string" and vim.endswith(k, "local.scope") then
+        scope = v
+      end
+    end
+
+    if node and vim.startswith(kind, "local.definition") then
+      table.insert(definitions, { kind = kind, node = node, scope = scope })
+    end
+
+    if node and kind == "local.scope" then
+      table.insert(scopes, node)
+    end
+
+    if node and kind == "local.reference" then
+      table.insert(references, { kind = kind, node = node, scope = scope })
+    end
+  end
+
+  return definitions, references, scopes
+end, function(bufnr)
+  local root = get_root(bufnr)
+  if not root then
+    return tostring(bufnr)
+  end
+  return tostring(root:id())
+end)
+
+return M