Refactor locals.lua:

- shared query group stuff -> query.lua
- local-specific stuff from ts_utils -> locals.lua

1 files changed, 0 insertions, 195 deletions

diff --git a/lua/nvim-treesitter/ts_utils.lua b/lua/nvim-treesitter/ts_utils.lua
index 0882155c..b01783d1 100644
--- a/lua/nvim-treesitter/ts_utils.lua
+++ b/lua/nvim-treesitter/ts_utils.lua
@@ -1,6 +1,5 @@
 local api = vim.api
 
-local locals = require'nvim-treesitter.locals'
 local parsers = require'nvim-treesitter.parsers'
 
 local M = {}
@@ -105,40 +104,6 @@ function M.get_previous_node(node, allow_switch_parents, allow_previous_parent)
   return destination_node
 end
 
-function M.parent_scope(node, cursor_pos)
-  local bufnr = api.nvim_get_current_buf()
-
-  local scopes = locals.get_scopes(bufnr)
-  if not node or not scopes then return end
-
-  local row = cursor_pos.row
-  local col = cursor_pos.col
-  local iter_node = node
-
-  while iter_node ~= nil do
-    local row_, col_ = iter_node:start()
-    if vim.tbl_contains(scopes, iter_node) and (row_+1 ~= row or col_ ~= col) then
-      return iter_node
-    end
-    iter_node = iter_node:parent()
-  end
-end
-
-function M.containing_scope(node, bufnr)
-  local bufnr = bufnr or api.nvim_get_current_buf()
-
-  local scopes = locals.get_scopes(bufnr)
-  if not node or not scopes then return end
-
-  local iter_node = node
-
-  while iter_node ~= nil and not vim.tbl_contains(scopes, iter_node) do
-    iter_node = iter_node:parent()
-  end
-
-  return iter_node or node
-end
-
 function M.get_named_children(node)
   local nodes = {}
   for i=0,node:named_child_count() - 1,1 do
@@ -147,172 +112,12 @@ function M.get_named_children(node)
   return nodes
 end
 
-function M.nested_scope(node, cursor_pos)
-  local bufnr = api.nvim_get_current_buf()
-
-  local scopes = locals.get_scopes(bufnr)
-  if not node or not scopes then return end
-
-  local row = cursor_pos.row
-  local col = cursor_pos.col
-  local scope = M.containing_scope(node)
-
-  for _, child in ipairs(M.get_named_children(scope)) do
-    local row_, col_ = child:start()
-    if vim.tbl_contains(scopes, child) and ((row_+1 == row and col_ > col) or row_+1 > row) then
-      return child
-    end
-  end
-end
-
-function M.next_scope(node)
-  local bufnr = api.nvim_get_current_buf()
-
-  local scopes = locals.get_scopes(bufnr)
-  if not node or not scopes then return end
-
-  local scope = M.containing_scope(node)
-
-  local parent = scope:parent()
-  if not parent then return end
-
-  local is_prev = true
-  for _, child in ipairs(M.get_named_children(parent)) do
-    if child == scope then
-      is_prev = false
-    elseif not is_prev and vim.tbl_contains(scopes, child) then
-      return child
-    end
-  end
-end
-
-function M.previous_scope(node)
-  local bufnr = api.nvim_get_current_buf()
-
-  local scopes = locals.get_scopes(bufnr)
-  if not node or not scopes then return end
-
-  local scope = M.containing_scope(node)
-
-  local parent = scope:parent()
-  if not parent then return end
-
-  local is_prev = true
-  local children = M.get_named_children(parent)
-  for i=#children,1,-1 do
-    if children[i] == scope then
-      is_prev = false
-    elseif not is_prev and vim.tbl_contains(scopes, children[i]) then
-      return children[i]
-    end
-  end
-end
-
 function M.get_node_at_cursor(winnr)
   local cursor = api.nvim_win_get_cursor(winnr or 0)
   local root = parsers.get_parser():parse():root()
   return root:named_descendant_for_range(cursor[1]-1,cursor[2],cursor[1]-1,cursor[2])
 end
 
--- Finds the definition node and it's scope node of a node
--- @param node starting node
--- @param bufnr buffer
--- @returns the definition node and the definition nodes scope node
-function M.find_definition(node, bufnr)
-  local bufnr = bufnr or api.nvim_get_current_buf()
-  local node_text = M.get_node_text(node)[1]
-  local current_scope = M.containing_scope(node)
-  local matching_def_nodes = {}
-
-  -- If a scope wasn't found then use the root node
-  if current_scope == node then
-    current_scope = parsers.get_parser(bufnr).tree:root()
-  end
-
-  -- Get all definitions that match the node text
-  for _, def in ipairs(locals.get_definitions(bufnr)) do
-    for _, def_node in ipairs(M.get_local_nodes(def)) do
-      if M.get_node_text(def_node)[1] == node_text then
-        table.insert(matching_def_nodes, def_node)
-      end
-    end
-  end
-
-  -- Continue up each scope until we find the scope that contains the definition
-  while current_scope do
-    for _, def_node in ipairs(matching_def_nodes) do
-      if M.is_parent(current_scope, def_node) then
-        return def_node, current_scope
-      end
-    end
-    current_scope = M.containing_scope(current_scope:parent())
-  end
-
-  return node, parsers.get_parser(bufnr).tree:root()
-end
-
--- Gets all nodes from a local list result.
--- @param local_def the local list result
--- @returns a list of nodes
-function M.get_local_nodes(local_def)
-  local result = {}
-
-  M.recurse_local_nodes(local_def, function(_, node)
-    table.insert(result, node)
-  end)
-
-  return result
-end
-
--- Recurse locals results until a node is found.
--- The accumulator function is given
--- * The table of the node
--- * The node
--- * The full definition match `@definition.var.something` -> 'var.something'
--- * The last definition match `@definition.var.something` -> 'something'
--- @param The locals result
--- @param The accumulator function
--- @param The full match path to append to
--- @param The last match
-function M.recurse_local_nodes(local_def, accumulator, full_match, last_match)
-  if local_def.node then
-    accumulator(local_def, local_def.node, full_match, last_match)
-  else
-    for match_key, def in pairs(local_def) do
-      M.recurse_local_nodes(
-        def,
-        accumulator,
-        full_match and (full_match..'.'..match_key) or match_key,
-        match_key)
-    end
-  end
-end
-
--- Finds usages of a node in a given scope
--- @param node the node to find usages for
--- @param scope_node the node to look within
--- @returns a list of nodes
-function M.find_usages(node, scope_node, bufnr)
-  local bufnr = bufnr or api.nvim_get_current_buf()
-  local node_text = M.get_node_text(node)[1]
-
-  if not node_text or #node_text < 1 then return {} end
-
-  local scope_node = scope_node or parsers.get_parser(bufnr).tree:root()
-  local usages = {}
-
-  for match in locals.iter_locals(bufnr, scope_node) do
-    if match.reference
-      and match.reference.node
-      and M.get_node_text(match.reference.node)[1] == node_text
-    then
-      table.insert(usages, match.reference.node)
-    end
-  end
-
-  return usages
-end
-
 function M.highlight_node(node, buf, hl_namespace, hl_group)
   if not node then return end
   M.highlight_range({node:range()}, buf, hl_namespace, hl_group)