feat(tags): enable treesitter

Author: ibhagwan

.emmyrc.json

@@ -24,6 +24,10 @@
       "deps/nvim-web-devicons",
       "deps/nvim-cmp",
       "deps/nvim-dap",
+      "$XDG_DATA_HOME/nvim/site/pack/core/opt/mini.nvim",
+      "$XDG_DATA_HOME/nvim/site/pack/core/opt/nvim-web-devicons",
+      "$XDG_DATA_HOME/nvim/site/pack/core/opt/nvim-cmp",
+      "$XDG_DATA_HOME/nvim/site/pack/core/opt/nvim-dap",
       "$XDG_DATA_HOME/nvim/lazy/mini.nvim",
       "$XDG_DATA_HOME/nvim/lazy/nvim-web-devicons",
       "$XDG_DATA_HOME/nvim/lazy/nvim-cmp",

lua/fzf-lua/defaults.lua

@@ -1319,6 +1319,36 @@ M.defaults.spellcheck = {
   },
 }
 
+---@param line string
+---@param include_file boolean?
+---@return string?, string?, { start_col: integer, end_col: integer, text: string? }?
+local function ctag_line_parser(line, include_file)
+  local start_col, end_col = utils.ctag_match(line)
+  if not start_col or not end_col then return end
+  -- remove tag's wrapping slashes
+  start_col = start_col + 1
+  end_col = end_col - 1
+  local tag = line:sub(start_col, end_col)
+  local text, had_caret, had_dollar = utils.regex_strip_anchors(tag)
+  local file = (function()
+    if not include_file then return "" end
+    -- NOTE: since fzf expands tabs to space(s) we cannot extract the
+    -- file deterministically, we therefore do a "best effort" backwards
+    -- search for "<foo.bar><space(s)>/<tag>/", while this can fail it is
+    -- somewhat acceptable as filenames without extensions are irrelevant
+    -- as treesitter won't be able to determine the filetype anyways
+    return line:sub(1, start_col - 2):match("([^%s]+%.[^%s]+)%s+$")
+  end)()
+  -- include_file was requested but file wasn't found (tags), bail
+  if not file then return end
+  return file, nil, {
+    -- NOTE: ts indexes are zero based
+    start_col = start_col + had_caret - 1,
+    end_col = end_col - had_dollar,
+    text = text
+  }
+end
+
 ---@class fzf-lua.config.TagsBase: fzf-lua.config.Base
 ---Path to the tags file, default: auto-detect.
 ---@field ctags_file? string
@@ -1348,6 +1378,7 @@ M.defaults.tags = {
   -- field_index_expr = "{}", -- For `_fmt.from` to work with `bat_native`
   _actions      = function() return M.globals.actions.files end,
   actions       = { ["ctrl-g"] = { actions.grep_lgrep } },
+  _treesitter   = function(line) return ctag_line_parser(line, true) end,
 }
 
 ---Search current buffer ctags.
@@ -1370,6 +1401,7 @@ M.defaults.btags = vim.tbl_deep_extend("force", M.defaults.tags, {
   fzf_opts       = { ["--with-nth"] = "1,3.." },
   actions        = { ["ctrl-g"] = false },
   _resume_reload = true,
+  _treesitter    = function(line) return ctag_line_parser(line) end,
 })
 
 ---Installed colorschemes.

lua/fzf-lua/make_entry.lua

@@ -714,7 +714,7 @@ M.tag = function(x, opts)
     name,
     M.file(file, opts),
     line and utils.ansi_codes.green(tostring(line)) .. ";" or "",
-    tag and utils.ansi_codes.blue(tag) or ""
+    tag or ""
   )
 end
 

lua/fzf-lua/path.lua

@@ -411,7 +411,9 @@ function M.entry_to_ctag(raw, opts)
     ctag = tag,
     line = line or 0,
     col = 0,
-    stripped = string.format("%s:%s %s", file, line and line .. ":" or "", tag or ""),
+    stripped = string.format("%s:%s %s", file, line and line .. ":" or "",
+      -- remove ctag ^$ prefix/postfix so qflist can have ts highlights
+      utils.regex_strip_anchors(tag) or ""),
     debug = opts.debug and raw:match("^%[DEBUG]") and raw or nil,
   } ---@as fzf-lua.path.Entry
 end

lua/fzf-lua/types.lua

@@ -202,7 +202,7 @@ local FzfLua = require("fzf-lua")
 ---@field _actions? fun():fzf-lua.config.Actions?
 ---@field __ACT_TO? function
 ---@field _start? boolean
----@field _treesitter? (fun(line: string):string?,string?,string?,string?)|boolean?
+---@field _treesitter? (fun(line: string):string?,string?,string|table?,string?)|boolean?
 ---@field help_open_win? fun(buf: integer, enter: boolean, config: vim.api.keyset.win_config): integer
 ---Auto close fzf-lua interface when a terminal is opened, set to `false` to keep the interface open.
 ---@field autoclose? boolean

lua/fzf-lua/utils.lua

@@ -254,6 +254,63 @@ function M.regex_to_magic(str)
       :gsub("([@])", "[%1]")
 end
 
+---Remove ^ $ regex anchors if they appear at start/end respectively
+-- used with ctags to convert the tag to a valid code block
+---@param s string?
+---@return string?, integer, integer
+function M.regex_strip_anchors(s)
+  local had_caret, had_dollar = 0, 0
+  if not s then return nil, had_caret, had_dollar end
+  ---@format disable
+  if string.byte(s, 1) == 94 then s = s:sub(2); had_caret = 1 end -- remove starting ^
+  -- remove ending $ only if not escaped (none/even number of backslashes)
+  if string.byte(s, #s) == 36 then
+    local bs_count, i = 0, #s - 1
+    while i > 0 and string.byte(s, i) == 92 do
+      bs_count = bs_count + 1
+      i = i - 1
+    end
+    if bs_count % 2 == 0 then
+      s = s:sub(1, #s - 1)
+      had_dollar = 1
+    end
+  end
+  return s, had_caret, had_dollar
+end
+
+---@param str string
+---@return integer?, integer?
+function M.ctag_match(str)
+  ---@param s string
+  ---@param i integer?
+  ---@return integer?
+  local rfind_slash = function(s, i)
+    -- assert(string.byte("/", 1) == 47)
+    -- assert(string.byte([[\]], 1) == 92)
+    local SLASH, BSLASH = 47, 92
+    local len = #s
+    i = i or len
+    while i > 0 do
+      if string.byte(s, i) == SLASH then
+        local bs_count, j = 0, i - 1
+        while j > 0 and string.byte(s, j) == BSLASH do
+          bs_count = bs_count + 1
+          j = j - 1
+        end
+        if bs_count % 2 == 0 then
+          return i
+        end
+      end
+      i = i - 1
+    end
+  end
+  local start_col, end_col = nil, rfind_slash(str)
+  if end_col then
+    start_col = rfind_slash(str, end_col - 1)
+  end
+  if start_col then return start_col, end_col end
+end
+
 ---@param str string
 ---@return string
 function M.ctag_escape(str)
@@ -1298,7 +1355,7 @@ function M.getbufinfo(bufnr)
   if M.__HAS_AUTOLOAD_FNS then
     return vim.fn["fzf_lua#getbufinfo"](bufnr)
   else
-    return vim.fn.getbufinfo(bufnr)[1] or {}
+    return vim.fn.getbufinfo(bufnr)[1] or {} ---@as vim.fn.getbufinfo.ret.item
   end
 end
 

lua/fzf-lua/win/tsinjector.lua

@@ -127,13 +127,14 @@ end
 
 ---@param self fzf-lua.Win
 ---@param buf integer
----@param line_parser (fun(line: string):string?,string?,string?,string?)|boolean?
+---@param line_parser (fun(line: string):string?,string?,string|table?,string?)|boolean?
 ---@return function detach
 function M.attach(self, buf, line_parser)
   -- local utf8 = require("fzf-lua.lib.utf8")
   local function trim(s) return (string.gsub(s, "^%s*(.-)%s*$", "%1")) end
   ---@type fun(line: string):string?,string?,string?,string?
   local default_line_parser = function(line) return line:match("(.-):?(%d+)[: ](.+)$") end
+  ---@type (fun(line: string):string?,string?,string|table?,string?)
   line_parser = vim.is_callable(line_parser) and line_parser or default_line_parser
   M.cache[buf] = {}
   api.nvim_buf_attach(buf, false, {
@@ -171,13 +172,21 @@ function M.attach(self, buf, line_parser)
           -- file:line:text       (grep_project or missing "--column" flag)
           -- line:col:text        (grep_curbuf)
           -- line<U+00A0>text     (lines|blines)
-          local filepath, _lnum, text, _ft = line_parser(line:sub(min_col))
-          if not text or text == 0 then return end
+          local filepath, _lnum, info, _ft = line_parser(line:sub(min_col + 1))
+
+          -- info can be a string or `{ text = ..., start_col, end_col }`
+          info = type(info) == "table" and info or { text = info }
+
+          -- line_parser can return text with start_col/end_col
+          local text = info.text
+          if not text or #text == 0 then return end
 
           text = text:gsub("^%d+:", "") -- remove col nr if exists
           filepath = trim(filepath)     -- trim spaces
 
           local ft_bufnr = (function()
+            -- we only need this as fallback if _ft is nil
+            if _ft then return nil end
             -- blines|lines: U+00A0 (decimal: 160) follows the lnum
             -- grep_curbuf: formats as line:col:text` thus `#filepath == 0`
             if #filepath == 0 or string.byte(text, 1) == 160 then
@@ -190,6 +199,8 @@ function M.attach(self, buf, line_parser)
             end
           end)()
 
+          -- _ft should nullify ft_bufnr
+          assert(not _ft or not ft_bufnr)
           local ft = _ft or (ft_bufnr and vim.bo[ft_bufnr].ft
             or vim.filetype.match({ filename = path.tail(filepath) }))
           if not ft then return end
@@ -206,13 +217,18 @@ function M.attach(self, buf, line_parser)
           -- we use `max_col` instead (assuming our code isn't unicode)
           local line_idx = i - 1
           local line_len = #line
-          local start_col = math.max(min_col, line_len - #text)
-          local end_col = max_col and math.min(max_col, line_len) or (line_len - trim_right)
+          local start_col = info.start_col and (info.start_col + min_col) or (line_len - #text)
+          local end_col = info.end_col and (info.end_col + min_col) or (line_len - trim_right)
+          -- clamp min/max columns
+          start_col = math.max(min_col, start_col)
+          if max_col then end_col = math.min(max_col, end_col) end
           regions[lang] = regions[lang] or {}
           empty_regions[lang] = empty_regions[lang] or {}
           table.insert(regions[lang], { { line_idx, start_col, line_idx, end_col } })
-          -- print(lang, string.format("%d:%d  [%d] %d:%s",
-          --   start_col, end_col, line_idx, _lnum, line:sub(start_col + 1, end_col)))
+          -- uncomment to debug:
+          -- print(lang, string.format("%d:%d +%d  [%d] %s:%s",
+          --   start_col, end_col, min_col, line_idx, tostring(_lnum),
+          --   line:sub(start_col + 1, end_col)))
         end)()
       end
       attach(bufnr, empty_regions)

tests/utils_spec.lua

@@ -135,4 +135,82 @@ describe("Testing utils module", function()
     eq(utils.strsplit(",foo,bar,", ","), { "", "foo", "bar", "" })
     eq(utils.strsplit("foobar", ","), { "foobar" })
   end)
+
+  it("regex_strip_anchors", function()
+    -- nil input
+    eq({ utils.regex_strip_anchors(nil) }, { [2] = 0, [3] = 0 })
+    -- empty string
+    eq({ utils.regex_strip_anchors("") }, { "", 0, 0 })
+    -- no anchors
+    eq({ utils.regex_strip_anchors("foobar") }, { "foobar", 0, 0 })
+    -- only start anchor
+    eq({ utils.regex_strip_anchors("^foobar") }, { "foobar", 1, 0 })
+    -- only end anchor
+    eq({ utils.regex_strip_anchors("foobar$") }, { "foobar", 0, 1 })
+    -- both anchors
+    eq({ utils.regex_strip_anchors("^foobar$") }, { "foobar", 1, 1 })
+    -- anchors in middle (should not be stripped)
+    eq({ utils.regex_strip_anchors("foo^bar$baz") }, { "foo^bar$baz", 0, 0 })
+    -- only anchors
+    eq({ utils.regex_strip_anchors("^") }, { "", 1, 0 })
+    eq({ utils.regex_strip_anchors("$") }, { "", 0, 1 })
+    eq({ utils.regex_strip_anchors("^$") }, { "", 1, 1 })
+    -- single character with anchors
+    eq({ utils.regex_strip_anchors("^x$") }, { "x", 1, 1 })
+    -- should not strip escaped $ (prepended by odd number of backslashes)
+    eq({ utils.regex_strip_anchors([[x\$]]) }, { [[x\$]], 0, 0 })
+    eq({ utils.regex_strip_anchors([[x\\$]]) }, { [[x\\]], 0, 1 })
+    eq({ utils.regex_strip_anchors([[x\\\$]]) }, { [[x\\\$]], 0, 0 })
+  end)
+
+  it("ctag_match", function()
+    -- no slashes
+    eq(utils.ctag_match("foobar"), nil)
+    -- single slash (needs at least 2 slashes)
+    eq(utils.ctag_match("foo/bar"), nil)
+    -- anchored slahes
+    eq({ utils.ctag_match("/foo/") }, { 1, 5 })
+    -- two slashes (finds the two rightmost unescaped slashes)
+    eq({ utils.ctag_match("/foo/bar/baz") }, { 5, 9 })
+    -- escaped slash only (should ignore escaped ones)
+    eq(utils.ctag_match([[/foo\/bar]]), nil)
+    eq(utils.ctag_match([[/foo\\\/bar]]), nil)
+    -- escaped slash backslash before slash
+    eq({ utils.ctag_match([[/foo\\/bar]]) }, { 1, 7 })
+    eq({ utils.ctag_match([[/foo\\\\/bar]]) }, { 1, 9 })
+    -- mixed escaped and unescaped
+    eq({ utils.ctag_match([[foo/bar\/baz/qux]]) }, { 4, 13 })
+    -- reverse search from end
+    eq({ utils.ctag_match("/a/b/c/d") }, { 5, 7 })
+  end)
+
+  it("ctag_escape", function()
+    -- empty string
+    eq(utils.ctag_escape(""), "")
+    -- no special characters
+    eq(utils.ctag_escape("foobar"), "foobar")
+    -- escaped backslash (\\ becomes \, then rg_escape doubles it back)
+    eq(utils.ctag_escape("foo\\bar"), "foo\\\\bar")
+    -- unescape escaped slash (\/ becomes /)
+    eq(utils.ctag_escape("foo\\/bar"), "foo/bar")
+    -- regex escape (rg_escape behavior)
+    eq(utils.ctag_escape("foo.bar"), "foo\\.bar")
+    eq(utils.ctag_escape("foo*bar"), "foo\\*bar")
+    -- ^ at start gets unescaped (was escaped by rg_escape)
+    eq(utils.ctag_escape("^foobar"), "^foobar")
+    -- $ at end gets unescaped (was escaped by rg_escape)
+    eq(utils.ctag_escape("foobar$"), "foobar$")
+    -- already escaped ^ at start stays escaped (rg_escape adds another backslash)
+    eq(utils.ctag_escape("\\^foobar"), "\\\\\\^foobar")
+    -- already escaped $ at end stays escaped
+    eq(utils.ctag_escape("foobar\\$"), "foobar\\\\$")
+    -- ^ in middle stays escaped
+    eq(utils.ctag_escape("foo^bar"), "foo\\^bar")
+    -- $ in middle stays escaped
+    eq(utils.ctag_escape("foo$bar"), "foo\\$bar")
+    -- combination of patterns
+    eq(utils.ctag_escape("^foo.bar$"), "^foo\\.bar$")
+    -- escaped backslash before dot (\. becomes ., then rg_escape escapes both)
+    eq(utils.ctag_escape("foo\\.bar"), "foo\\\\\\.bar")
+  end)
 end)