enhancement: add treesitter queries support for augend.user

[Mephistophiles]

Thanks for your great plugin! How about using treesitter for find function in augend.user (add a new helper)? treesitter can return textrange for found node via https://neovim.io/doc/user/treesitter.html#tsnode:range().

[monaqa]

Thanks for the suggestion.
The integration with nvim-treesitter is very appealing, but it would require a fundamental rethinking of the current dial.nvim design to make it work.
Even if we were to start implementing it, it would take a long time to support.

If you have a concrete example of a use case, it might be helpful in designing it.

[Mephistophiles]

Yep, my case is too complicated (perhaps this issue should be closed). While developing this example, I realized that it would not be very convenient:

   -- example for replacement
    if vim.g.option1 and vim.g.option2 then
        print("hello")
    end

local require = require('augend')
local replacement = augend.user.new {
	find = require('dial.augend.common').ts_query("(if_statement (binary_expression left: (_) @left right: (_) @right) @cond) @replacement"), -- https://tree-sitter.github.io/tree-sitter/playground for visualize
	add = function(text, _, cursor)
		local cond = node:child(1)
		local left = cond:field("left")[1]
		local right = cond:field("right")[1]
		print(vim.treesitter.get_node_text(left, bufnr))
		print(vim.treesitter.get_node_text(right, bufnr))
		print(text)

		return {
			text = string.format("%s or %s", vim.treesitter.get_node_text(left,·bufnr), vim.treesitter.get_node_text(right,·bufnr)),
			cursor = cursor,
		}
	end,
}

local bufnr = 1
local query = vim.treesitter.parse_query(
	"lua",
	"(if_statement (binary_expression left: (_) @op right: (_) @op) @cond) @replacement"
)
local parser = vim.treesitter.get_parser(bufnr, "lua", {})
local tree = parser:parse()[1]

for id, node, metadata in query:iter_captures(tree:root(), bufnr, 0, -1) do
	local name = query.captures[id]
	local text = vim.treesitter.get_node_text(node, bufnr)
	if name == "replacement" then -- user cb
		local cond = node:child(1)
		local left = cond:field("left")[1]
		local right = cond:field("right")[1]
		print(vim.treesitter.get_node_text(left, bufnr))
		print(vim.treesitter.get_node_text(right, bufnr))
		print(text)
	end
end

[monaqa]

Sorry for the late reply. Sounds interesting.
I thought about keeping the current dial.nvim structure as much as possible, but I think it is necessary to reconsider from the fundamental framework because the current structure is still too restrictive. Please give me some time.

[stevenxxiu]

I'm quite interested in this. I'd like to switch between different function definitions in JavaScript, which is offered by https://github.com/AndrewRadev/switch.vim. This would allow me to do so.

[stevenxxiu]

In trying to code this, I just saw that dial restricts replacements to a single line. This makes the above use case impossible. Function definitions can easily span multiple lines. Could this restriction be lifted? @monaqa

[stevenxxiu]

I did get it working, making workarounds of dial. Native support would be great.

---@param lang string Language
---@param node_name string *tree-sitter* node name
---@param query string *tree-sitter* node name
---@param fun(TSNode): string, number -- replacement, new relative offset of the cursor
---@return Augend
local function treesitter_augend(lang, node_name, query, cb)
  local augend = require('dial.augend')

  local MIN_FIND_RES = { from = -math.huge, to = math.huge } -- Minimize the score so this augend comes first

  return augend.user.new({
    find = function()
      if vim.treesitter.get_node():type() ~= node_name then
        return
      end

      local bufnr = 0
      local parsed_query = vim.treesitter.query.parse(lang, query .. ' @replacement')
      local parser = vim.treesitter.get_parser(bufnr, lang, {})
      if parser == nil then
        return
      end
      local tree = parser:parse()[1]

      local row, col = unpack(vim.api.nvim_win_get_cursor(0))
      for id, node, _metadata in parsed_query:iter_captures(tree:root(), bufnr, 0, -1) do
        local query_name = parsed_query.captures[id]
        if query_name == 'replacement' then
          local start_row, start_col, _len = node:start()
          if start_row > row - 1 or (start_row == row - 1 and start_col > col) then
            return
          end
          local end_row, end_col, _ = node:end_()
          if row - 1 < end_row or (end_row == row - 1 and end_col <= col) then
            local replacement, cur_pos = cb(node)
            -- Use a callback, as each augend's `find()` method is called multiple times
            vim.schedule(function()
              -- Replace here, as *dial* only supports single line replaces
              local lines = vim.split(replacement, '\n')
              vim.api.nvim_buf_set_text(bufnr, start_row, start_col, end_row, end_col, lines)
              local lines_before_cursor = vim.split(string.sub(replacement, 1, cur_pos), '\n')
              local cur_row, cur_col
              if start_row + cur_pos < string.len(lines_before_cursor[1]) then
                cur_row = start_row
                cur_col = start_row + cur_pos
              else
                cur_row = start_row + #lines_before_cursor - 1
                cur_col = #lines_before_cursor[#lines_before_cursor]
              end
              vim.api.nvim_win_set_cursor(0, { cur_row + 1, cur_col })
            end)
            return MIN_FIND_RES
          end
        end
      end
    end,
    add = function() return { text = nil, cursor = nil } end,
  })
end

treesitter_augend(
  'javascript',
  'function_declaration',
  [[
    (function_declaration
      name: (_) @identifier
      parameters: (_) @formal_parameters
      body: (_) @statement_block)
  ]],
  function(node)
    local before_arrow = string.format(
      'const %s = %s ',
      get_node_text(node:field('name')[1]),
      get_node_text(node:field('parameters')[1])
    )
    local after_arrow = string.format('=> %s', get_node_text(node:field('body')[1]))
    return before_arrow .. after_arrow, string.len(before_arrow)
  end
),
treesitter_augend(
  'javascript',
  'arrow_function',
  [[
    (lexical_declaration
      (variable_declarator
        name: (_) @identifier
        value: (arrow_function
          parameters: (_) @formal_parameters
          body: (_) @statement_block)))
  ]],
  function(node)
    local var_node = node:child(1)
    local arrow_node = var_node:child(2)
    return string.format(
      'function %s%s %s',
      get_node_text(var_node:field('name')[1]),
      get_node_text(arrow_node:field('parameters')[1]),
      get_node_text(arrow_node:field('body')[1])
    ),
      0
  end
),

[monaqa]

Currently, dial.nvim intentionally restricts replacements to a single line. This is by design.
dial.nvim is intended to extend the built-in ‎<C-a> and ‎<C-x> features, which only operate on the cursor line and do not use or affect other lines.
There are also performance concerns. dial.nvim performs searches for multiple pattern. If the search range were to cover the entire buffer, operations could become slow in large buffers. I believe that <C-a> and <C-x> should remain simple and lightweight.

While using tree-sitter could help with performance, supporting multi-line replacements would make the specification more complex (such as priority handling between augends). I’m also not sure if such functionality fits naturally as an extension of ‎<C-a> and ‎<C-x>. I would like to consider this carefully.