fix: unify range handling by bundling WIP vim.range implementation

Author: TheLeoP

lua/refactoring/debug/cleanup.lua

@@ -1,6 +1,8 @@
 local api = vim.api
 local iter = vim.iter
 local async = require "async"
+local range = require "refactoring.range"
+local pos = require "refactoring.pos"
 local ts = vim.treesitter
 
 -- TODO: Search inside strings (using treesitter) on `printf` (and
@@ -26,15 +28,14 @@ end
 ---@param range_type 'v' | 'V' | ''
 ---@param config refactor.Config
 function M.cleanup(range_type, config)
-  local get_extracted_range = require("refactoring.range").get_extracted_range
+  local get_extracted_range = require("refactoring.utils").get_extracted_range
   local apply_text_edits = require("refactoring.utils").apply_text_edits
-  local contains_range = require("refactoring.range").contains_range
 
   local opts = config.debug.cleanup
 
   local buf = api.nvim_get_current_buf()
   local last_line = vim.fn.line "$"
-  local extracted_range = get_extracted_range(range_type)
+  local extracted_range = get_extracted_range(buf, range_type)
 
   local task = async.run(function()
     local lang_tree, err1 = ts.get_parser(buf, nil, { error = false })
@@ -44,7 +45,7 @@ function M.cleanup(range_type, config)
     end
     -- TODO: use async parsing
     lang_tree:parse(true)
-    local nested_lang_tree = lang_tree:language_for_range(extracted_range)
+    local nested_lang_tree = lang_tree:language_for_range { extracted_range:to_treesitter() }
     local lang = nested_lang_tree:lang()
     local query = ts.query.get(lang, "refactor")
     if not query then
@@ -64,13 +65,13 @@ function M.cleanup(range_type, config)
     end
 
     table.sort(comments, node_comp_asc)
-    ---@type Range4[]
+    ---@type vim.Range[]
     local ranges_to_cleanup = iter(comments)
       :filter(
         ---@param comment TSNode
         function(comment)
-          local comment_range = { comment:range() }
-          return contains_range(extracted_range, comment_range)
+          local comment_range = range.treesitter(buf, comment:range())
+          return extracted_range:has(comment_range)
         end
       )
       :map(
@@ -84,21 +85,14 @@ function M.cleanup(range_type, config)
               return text:find(opts.markers[name].start) ~= nil
             end
           )
-          if is_start then return "start", { comment:start() } end
-          local comment_end = { comment:end_() }
-          if comment_end[1] ~= last_line - 1 then
-            comment_end[1], comment_end[2] = comment_end[1] + 1, 0
-          end
+          if is_start then return "start", pos.treesitter(buf, "start", comment:start()) end
           local is_end = iter(opts.types):any(
             ---@param name 'print_var'|'print_loc'|'print_exp'
             function(name)
               return text:find(opts.markers[name]["end"]) ~= nil
             end
           )
-          if is_end then return "end", comment_end end
-          -- TODO: I'll need to generalize the handling of 0-based/1-based
-          -- end-exclusive/end-inclusive/end_row-inclusive_col-exclusive/end_row_exclusive-_col-0
-          -- ranges everywhere x2
+          if is_end then return "end", pos.treesitter(buf, "end", comment:end_()) end
         end
       )
       :filter(
@@ -109,13 +103,13 @@ function M.cleanup(range_type, config)
       )
       :fold(
         {},
-        ---@param acc Range4[]|{current_start: Range2}
+        ---@param acc vim.Range|{current_start: vim.Pos}
         ---@param kind 'start'|'end'
-        ---@param range Range2
-        function(acc, kind, range)
-          if kind == "start" then acc.current_start = range end
+        ---@param position vim.Pos
+        function(acc, kind, position)
+          if kind == "start" then acc.current_start = position end
           if kind == "end" and acc.current_start ~= nil then
-            table.insert(acc, { acc.current_start[1], acc.current_start[2], range[1], range[2] })
+            table.insert(acc, range(acc.current_start, position))
             acc.current_start = nil
           end
 
@@ -127,9 +121,9 @@ function M.cleanup(range_type, config)
     local text_edits_by_buf = {}
     text_edits_by_buf[buf] = {}
     iter(ipairs(ranges_to_cleanup)):each(
-      ---@param range Range4
-      function(_, range)
-        table.insert(text_edits_by_buf[buf], { range = range, lines = {} })
+      ---@param r vim.Range
+      function(_, r)
+        table.insert(text_edits_by_buf[buf], { range = r, lines = {} })
       end
     )
 

lua/refactoring/debug/print_var.lua

@@ -2,6 +2,8 @@ local api = vim.api
 local ts = vim.treesitter
 local iter = vim.iter
 local async = require "async"
+local range = require "refactoring.range"
+local pos = require "refactoring.pos"
 
 local M = {}
 
@@ -35,22 +37,19 @@ local M = {}
 ---@param range_type 'v' | 'V' | ''
 ---@param config refactor.Config
 function M.print_var(range_type, config)
-  local get_extracted_range = require("refactoring.range").get_extracted_range
-  local contains = require("refactoring.range").contains
+  local get_extracted_range = require("refactoring.utils").get_extracted_range
   local is_unique = require("refactoring.utils").is_unique
   local code_gen_error = require("refactoring.utils").code_gen_error
   local apply_text_edits = require("refactoring.utils").apply_text_edits
   local get_declarations_by_scope = require("refactoring.utils").get_declarations_by_scope
   local scopes_for_range = require("refactoring.utils").scopes_for_range
   local get_declaration_scope = require("refactoring.utils").get_declaration_scope
-  local compare = require("refactoring.range").compare
-  local comp_non_overlaping_ranges_asc = require("refactoring.range").comp_non_overlaping_ranges_asc
 
   local opts = config.debug.print_var
   local code_generation = opts.code_generation
 
   local buf = api.nvim_get_current_buf()
-  local extracted_range = get_extracted_range(range_type)
+  local extracted_range = get_extracted_range(buf, range_type)
 
   local task = async.run(function()
     local lang_tree, err1 = ts.get_parser(buf, nil, { error = false })
@@ -60,7 +59,7 @@ function M.print_var(range_type, config)
     end
     -- TODO: use async parsing
     lang_tree:parse(true)
-    local nested_lang_tree = lang_tree:language_for_range(extracted_range)
+    local nested_lang_tree = lang_tree:language_for_range { extracted_range:to_treesitter() }
     local lang = nested_lang_tree:lang()
     local query = ts.query.get(lang, "refactor")
     if not query then
@@ -99,19 +98,21 @@ function M.print_var(range_type, config)
       end
     end
 
+    local extracted_range_api = { extracted_range:to_api() }
     -- NOTE: treesitter nodes usualy do not include leading whitespace
-    local extracted_range_start_line = api.nvim_buf_get_lines(buf, extracted_range[1], extracted_range[1] + 1, true)[1]
+    local extracted_range_start_line =
+      api.nvim_buf_get_lines(buf, extracted_range_api[1], extracted_range_api[1] + 1, true)[1]
     local _, extracted_range_start_line_first_non_white = extracted_range_start_line:find "^%s*"
     extracted_range_start_line_first_non_white = extracted_range_start_line_first_non_white or 0
-    local extracted_reference_point = opts.output_location == "below" and { extracted_range[3], extracted_range[4] }
-      or { extracted_range[1], extracted_range_start_line_first_non_white }
+    local extracted_reference_pos = opts.output_location == "below" and extracted_range.end_
+      or pos(extracted_range.start.row, extracted_range_start_line_first_non_white)
     ---@type TSNode|nil
     local statement_for_range = iter(statements)
       :filter(
         ---@param s TSNode
         function(s)
-          local s_range = { s:range() }
-          return contains(s_range, extracted_reference_point)
+          local s_range = range.treesitter(buf, s:range())
+          return s_range:has_pos(extracted_reference_pos)
         end
       )
       :fold(
@@ -128,16 +129,16 @@ function M.print_var(range_type, config)
       return vim.notify("Couldn't find statement for extracted range using Treesitter", vim.log.levels.ERROR)
     end
 
-    local statement_range = { statement_for_range:range() }
+    local statement_range = range.treesitter(buf, statement_for_range:range())
+    local statement_srow, statement_scol, statement_erow, statement_ecol = statement_range:to_api()
     local output_range = opts.output_location == "below"
-        and { statement_range[3], statement_range[4], statement_range[3], statement_range[4] }
-      or { statement_range[1], statement_range[2], statement_range[1], statement_range[2] }
-    local output_start = { output_range[1], output_range[2] }
+        and range.api(buf, statement_erow, statement_ecol, statement_erow, statement_ecol)
+      or range.api(buf, statement_srow, statement_scol, statement_srow, statement_scol)
 
     -- TODO: I also compute `declarations_before_output_range` in
     -- `extract_func`. Is there a cleaner wat to do all this in both places?
     local declarations_by_scope = get_declarations_by_scope(references, scopes, buf)
-    local scopes_for_extracted_range = scopes_for_range(scopes, extracted_range)
+    local scopes_for_extracted_range = scopes_for_range(buf, scopes, extracted_range)
     local reference_to_text =
       ---@param reference refactor.Reference
       function(reference)
@@ -153,9 +154,6 @@ function M.print_var(range_type, config)
       :filter(
         ---@param r refactor.Reference
         function(r)
-          local start_node = { r.identifier:start() }
-          local end_node = { r.identifier:end_() }
-
           local declaration_scope = get_declaration_scope(declarations_by_scope, scopes, r, buf)
 
           local is_in_scope = declaration_scope
@@ -167,25 +165,24 @@ function M.print_var(range_type, config)
               )
             or false
 
-          return compare(start_node, output_start) ~= 1 and compare(end_node, output_start) ~= 1 and is_in_scope
+          local node_start = pos.treesitter(buf, "start", r.identifier:start())
+          local node_end = pos.treesitter(buf, "end", r.identifier:end_())
+          return node_start <= output_range.start and node_end <= output_range.start and is_in_scope
         end
       )
       :map(reference_to_text)
       :totable()
 
-    -- TODO: should I generalize/unify how ranges and range transformations are
-    -- handled everywhere? Some ranges are having a 1-off error because of no standar
-    -- handling of ranges (e.g. `extract_func` for a single word). Take a look
-    -- at how `vim.treesitter.get_node_text` handles treesitter ranges when doing this
-    local extracted_range_ts = { extracted_range[1], extracted_range[2], extracted_range[3], extracted_range[4] + 1 }
+    -- TODO: Some ranges are having a 1-off error because of no standar
+    -- handling of ranges (e.g. `extract_func` for a single word).
+
     ---@type {[string]: refactor.Reference}
     local selected_references_by_start = iter(references)
       :filter(
         ---@param r refactor.Reference
         function(r)
-          local r_start = { r.identifier:start() }
-          local r_end = { r.identifier:end_() }
-          return contains(extracted_range_ts, r_start) and contains(extracted_range_ts, r_end)
+          local r_range = range.treesitter(buf, r.identifier:range())
+          return extracted_range:has(r_range)
         end
       )
       :fold(
@@ -209,19 +206,18 @@ function M.print_var(range_type, config)
       end)
       :totable()
     table.sort(selected_references, function(a, b)
-      local a_range = { a.identifier:range() }
-      local b_range = { b.identifier:range() }
+      local a_range = range.treesitter(buf, a.identifier:range())
+      local b_range = range.treesitter(buf, b.identifier:range())
 
-      return comp_non_overlaping_ranges_asc(a_range, b_range)
+      return a_range < b_range
     end)
     ---@type string[]
     local print_lines = iter(selected_references)
       :filter(
         ---@param r refactor.Reference
         function(r)
-          local r_start = { r.identifier:start() }
-          local r_end = { r.identifier:end_() }
-          return contains(extracted_range_ts, r_start) and contains(extracted_range_ts, r_end)
+          local r_range = range.treesitter(buf, r.identifier:range())
+          return extracted_range:has(r_range)
         end
       )
       :map(