feat(perf): Improve speed of table parsing by storing state

## Details

When handling a pipe_table there are 2 slower parts. For each cell
we compute the amount of space that is concealed & that amount of
inline text added back so we can pad things nicely.

For the amount of concealed space, this was improved earlier by
pre-computing all the concealed nodes at the start of the parse
method. However we can further improve this by implementing our
own node contains logic. I am unsure why this ends up being faster,
but it is quite substantial. We further improve this by storing only
the column range for each node in the cache, and not the entire node.

For the latter we had yet to do anything. The computation here involved
running a treesitter query and essentially computing exactly what we
think the inline parser would add to each cell. Instead what we can do is
store some metadata when the inline parser runs and use this information
to check what was added within a cell. This avoids a lot of parsing for
each cell and substantially improves how quickly things run. However we
needed to hack the top level for loop to guarantee that we parse
markdown trees after all others. It's not the most elegant thing but
seems to do the job.

Since we are doing a good amount of contains range type logic I'm sure
there will be some errors, those will be good to add to unit tests
anyway, currently everything passes.

Author: MeanderingProgrammer

README.md

@@ -168,8 +168,6 @@ require('render-markdown').setup({
 
         [(inline_link) (full_reference_link) (image)] @link
     ]],
-    -- Query to be able to identify links in nodes
-    inline_link_query = '[(inline_link) (full_reference_link) (image)] @link',
     -- The level of logs to write to file: vim.fn.stdpath('state') .. '/render-markdown.log'
     -- Only intended to be used for plugin development / debugging
     log_level = 'error',

doc/render-markdown.txt

@@ -200,8 +200,6 @@ Full Default Configuration ~
 
             [(inline_link) (full_reference_link) (image)] @link
         ]],
-        -- Query to be able to identify links in nodes
-        inline_link_query = '[(inline_link) (full_reference_link) (image)] @link',
         -- The level of logs to write to file: vim.fn.stdpath('state') .. '/render-markdown.log'
         -- Only intended to be used for plugin development / debugging
         log_level = 'error',

doc/todo.md

@@ -4,24 +4,3 @@
   alignment info.
 - Figure out how to display the many configuration options & impact
 - Potentially change LuaRocks icon dependency to [mini.icons](https://luarocks.org/modules/neorocks/mini.icons)
-- Force non-markdown handlers to run first in `ui.lua`. Cache information
-  at buffer level from inline parser to avoid computing it:
-
-```lua
--- Parse marks
-local marks = {}
--- Parse markdown after all other nodes to take advantage of state
-local markdown_roots = {}
-parser:for_each_tree(function(tree, language_tree)
-    local language = language_tree:lang()
-    if language == 'markdown' then
-        table.insert(markdown_roots, tree:root())
-    else
-        vim.list_extend(marks, M.parse_tree(buf, language, tree:root()))
-    end
-end)
-for _, root in ipairs(markdown_roots) do
-    vim.list_extend(marks, M.parse_tree(buf, 'markdown', root))
-end
-return marks
-```

lua/render-markdown/handler/markdown.lua

@@ -4,7 +4,7 @@ local icons = require('render-markdown.icons')
 local list = require('render-markdown.list')
 local logger = require('render-markdown.logger')
 local pipe_table_parser = require('render-markdown.parser.pipe_table')
-local shared = require('render-markdown.handler.shared')
+local request = require('render-markdown.request')
 local state = require('render-markdown.state')
 local str = require('render-markdown.str')
 local ts = require('render-markdown.ts')
@@ -98,7 +98,7 @@ function M.heading(config, buf, info)
     -- Available width is level + 1 - concealed, where level = number of `#` characters, one
     -- is added to account for the space after the last `#` but before the heading title,
     -- and concealed text is subtracted since that space is not usable
-    local padding = level + 1 - ts.concealed(buf, info) - str.width(icon)
+    local padding = level + 1 - M.concealed(buf, info) - str.width(icon)
     if heading.position == 'inline' or padding < 0 then
         -- Requires inline extmarks to place when there is not enough space available
         if util.has_10 then
@@ -205,7 +205,7 @@ function M.code(config, buf, info)
 
     if code.border == 'thin' then
         local code_start = ts.child(buf, info, 'fenced_code_block_delimiter', info.start_row)
-        if #marks == 0 and ts.hidden(buf, code_info) and ts.hidden(buf, code_start) then
+        if #marks == 0 and M.hidden(buf, code_info) and M.hidden(buf, code_start) then
             start_row = start_row + 1
             ---@type render.md.Mark
             local start_mark = {
@@ -220,7 +220,7 @@ function M.code(config, buf, info)
             list.add_mark(marks, start_mark)
         end
         local code_end = ts.child(buf, info, 'fenced_code_block_delimiter', info.end_row - 1)
-        if ts.hidden(buf, code_end) then
+        if M.hidden(buf, code_end) then
             end_row = end_row - 1
             ---@type render.md.Mark
             local end_mark = {
@@ -317,7 +317,7 @@ function M.language(config, buf, info, code_block)
         return marks
     end
     local icon_text = icon .. ' '
-    if ts.hidden(buf, info) then
+    if M.hidden(buf, info) then
         -- Code blocks will pick up varying amounts of leading white space depending on the
         -- context they are in. This gets lumped into the delimiter node and as a result,
         -- after concealing, the extmark will be left shifted. Logic below accounts for this.
@@ -606,7 +606,7 @@ function M.table_row(config, buf, row, highlight)
             elseif cell.type == 'pipe_table_cell' then
                 -- Requires inline extmarks
                 if pipe_table.cell == 'padded' and util.has_10 then
-                    local offset = M.table_visual_offset(config, buf, cell)
+                    local offset = M.table_visual_offset(buf, cell)
                     if offset > 0 then
                         ---@type render.md.Mark
                         local padding_mark = {
@@ -659,7 +659,7 @@ function M.table_full(config, buf, parsed_table)
         if pipe_table.cell == 'raw' then
             -- For the raw cell style we want the lengths to match after
             -- concealing & inlined elements
-            result = result - M.table_visual_offset(config, buf, info)
+            result = result - M.table_visual_offset(buf, info)
         end
         return result
     end
@@ -710,18 +710,51 @@ function M.table_full(config, buf, parsed_table)
 end
 
 ---@private
----@param config render.md.BufferConfig
+---@param buf integer
+---@param info? render.md.NodeInfo
+---@return boolean
+function M.hidden(buf, info)
+    -- Missing nodes are considered hidden
+    if info == nil then
+        return true
+    end
+    return str.width(info.text) == M.concealed(buf, info)
+end
+
+---@private
+---@param buf integer
+---@param info render.md.NodeInfo
+---@return integer
+function M.concealed(buf, info)
+    local ranges = request.concealed(buf, info.start_row)
+    if #ranges == 0 then
+        return 0
+    end
+    local result = 0
+    local col = info.start_col
+    for _, index in ipairs(vim.fn.str2list(info.text)) do
+        local ch = vim.fn.nr2char(index)
+        for _, range in ipairs(ranges) do
+            -- Essentially vim.treesitter.is_in_node_range but only care about column
+            if col >= range[1] and col + 1 <= range[2] then
+                result = result + str.width(ch)
+            end
+        end
+        col = col + #ch
+    end
+    return result
+end
+
+---@private
 ---@param buf integer
 ---@param info render.md.NodeInfo
 ---@return integer
-function M.table_visual_offset(config, buf, info)
-    local result = ts.concealed(buf, info)
-    local query = state.inline_link_query
-    local tree = vim.treesitter.get_string_parser(info.text, 'markdown_inline')
-    for id, node in query:iter_captures(tree:parse()[1]:root(), info.text) do
-        if query.captures[id] == 'link' then
-            local link_info = ts.info(node, info.text)
-            result = result - str.width(shared.link_icon(config, link_info))
+function M.table_visual_offset(buf, info)
+    local result = M.concealed(buf, info)
+    local icon_ranges = request.inline_links(buf, info.start_row)
+    for _, icon_range in ipairs(icon_ranges) do
+        if info.start_col < icon_range[2] and info.end_col > icon_range[1] then
+            result = result - str.width(icon_range[3])
         end
     end
     return result

lua/render-markdown/handler/markdown_inline.lua

@@ -1,7 +1,7 @@
 local component = require('render-markdown.component')
 local list = require('render-markdown.list')
 local logger = require('render-markdown.logger')
-local shared = require('render-markdown.handler.shared')
+local request = require('render-markdown.request')
 local state = require('render-markdown.state')
 local str = require('render-markdown.str')
 local ts = require('render-markdown.ts')
@@ -26,7 +26,7 @@ function M.parse(root, buf)
         elseif capture == 'callout' then
             list.add_mark(marks, M.callout(config, info))
         elseif capture == 'link' then
-            list.add_mark(marks, M.link(config, info))
+            list.add_mark(marks, M.link(config, buf, info))
         else
             logger.unhandled_capture('inline', capture)
         end
@@ -111,13 +111,28 @@ end
 
 ---@private
 ---@param config render.md.BufferConfig
+---@param buf integer
 ---@param info render.md.NodeInfo
 ---@return render.md.Mark?
-function M.link(config, info)
-    local icon = shared.link_icon(config, info)
+function M.link(config, buf, info)
+    local link = config.link
+    if not link.enabled then
+        return nil
+    end
+    -- Requires inline extmarks
+    if not util.has_10 then
+        return nil
+    end
+    local icon = nil
+    if vim.tbl_contains({ 'inline_link', 'full_reference_link' }, info.type) then
+        icon = link.hyperlink
+    elseif info.type == 'image' then
+        icon = link.image
+    end
     if icon == nil then
         return nil
     end
+    request.add_inline_link(buf, info, icon)
     ---@type render.md.Mark
     return {
         conceal = true,

lua/render-markdown/handler/shared.lua

@@ -124,7 +124,6 @@ local M = {}
 ---@field public markdown_query? string
 ---@field public markdown_quote_query? string
 ---@field public inline_query? string
----@field public inline_link_query? string
 ---@field public log_level? 'debug'|'error'
 ---@field public file_types? string[]
 ---@field public acknowledge_conflicts? boolean
@@ -183,8 +182,6 @@ M.default_config = {
 
         [(inline_link) (full_reference_link) (image)] @link
     ]],
-    -- Query to be able to identify links in nodes
-    inline_link_query = '[(inline_link) (full_reference_link) (image)] @link',
     -- The level of logs to write to file: vim.fn.stdpath('state') .. '/render-markdown.log'
     -- Only intended to be used for plugin development / debugging
     log_level = 'error',

lua/render-markdown/init.lua

@@ -2,8 +2,10 @@ local util = require('render-markdown.util')
 
 ---@class render.md.RequestCache
 local cache = {
-    ---@type table<integer, table<integer, TSNode[]>>
+    ---@type table<integer, table<integer, { [1]: integer, [2]: integer }[]>>
     conceal = {},
+    ---@type table<integer, table<integer, { [1]: integer, [2]: integer, [3]: string }[]>>
+    inline_links = {},
 }
 
 ---@class render.md.Request
@@ -12,6 +14,7 @@ local M = {}
 ---@param buf integer
 function M.reset_buf(buf)
     cache.conceal[buf] = {}
+    cache.inline_links[buf] = {}
 end
 
 ---@param buf integer
@@ -30,11 +33,11 @@ function M.compute_conceal(buf, parser)
             if query ~= nil then
                 for _, node, metadata in query:iter_captures(tree:root(), buf, 0, -1) do
                     if metadata.conceal ~= nil then
-                        local row = node:range()
+                        local row, start_col, _, end_col = node:range()
                         if nodes[row] == nil then
                             nodes[row] = {}
                         end
-                        table.insert(nodes[row], node)
+                        table.insert(nodes[row], { start_col, end_col })
                     end
                 end
             end
@@ -45,15 +48,28 @@ end
 
 ---@param buf integer
 ---@param row integer
----@param col integer
----@return boolean
-function M.concealed(buf, row, col)
-    for _, node in ipairs(cache.conceal[buf][row] or {}) do
-        if vim.treesitter.is_in_node_range(node, row, col) then
-            return true
-        end
+---@return { [1]: integer, [2]: integer }[]
+function M.concealed(buf, row)
+    return cache.conceal[buf][row] or {}
+end
+
+---@param buf integer
+---@param info render.md.NodeInfo
+---@param icon string
+function M.add_inline_link(buf, info, icon)
+    local inline_links = cache.inline_links[buf]
+    local row = info.start_row
+    if inline_links[row] == nil then
+        inline_links[row] = {}
     end
-    return false
+    table.insert(inline_links[row], { info.start_col, info.end_col, icon })
+end
+
+---@param buf integer
+---@param row integer
+---@return { [1]: integer, [2]: integer, [3]: string }[]
+function M.inline_links(buf, row)
+    return cache.inline_links[buf][row] or {}
 end
 
 return M

lua/render-markdown/request.lua

@@ -14,7 +14,6 @@ local configs = {}
 ---@field markdown_query vim.treesitter.Query
 ---@field markdown_quote_query vim.treesitter.Query
 ---@field inline_query vim.treesitter.Query
----@field inline_link_query vim.treesitter.Query
 local M = {}
 
 ---@param default_config render.md.Config
@@ -36,7 +35,6 @@ function M.setup(default_config, user_config)
         M.markdown_query = vim.treesitter.query.parse('markdown', config.markdown_query)
         M.markdown_quote_query = vim.treesitter.query.parse('markdown', config.markdown_quote_query)
         M.inline_query = vim.treesitter.query.parse('markdown_inline', config.inline_query)
-        M.inline_link_query = vim.treesitter.query.parse('markdown_inline', config.inline_link_query)
     end)
 end
 
@@ -324,7 +322,6 @@ function M.validate()
         markdown_query = { config.markdown_query, 'string' },
         markdown_quote_query = { config.markdown_quote_query, 'string' },
         inline_query = { config.inline_query, 'string' },
-        inline_link_query = { config.inline_link_query, 'string' },
         log_level = one_of(config.log_level, { 'debug', 'error' }, {}, false),
         file_types = string_array(config.file_types, false),
         acknowledge_conflicts = { config.acknowledge_conflicts, 'boolean' },

lua/render-markdown/state.lua

@@ -1,6 +1,3 @@
-local request = require('render-markdown.request')
-local str = require('render-markdown.str')
-
 ---@param node TSNode
 ---@return boolean
 local function in_section(node)
@@ -95,31 +92,4 @@ function M.child(buf, info, target_type, target_row)
     return nil
 end
 
----@param buf integer
----@param info? render.md.NodeInfo
----@return boolean
-function M.hidden(buf, info)
-    -- Missing nodes are considered hidden
-    if info == nil then
-        return true
-    end
-    return str.width(info.text) == M.concealed(buf, info)
-end
-
----@param buf integer
----@param info render.md.NodeInfo
----@return integer
-function M.concealed(buf, info)
-    local result = 0
-    local col = info.start_col
-    for _, index in ipairs(vim.fn.str2list(info.text)) do
-        local ch = vim.fn.nr2char(index)
-        if request.concealed(buf, info.start_row, col) then
-            result = result + str.width(ch)
-        end
-        col = col + #ch
-    end
-    return result
-end
-
 return M