chore: replace usage of table.insert with list[#list + 1]

Author: MeanderingProgrammer

doc/custom-handlers.md

@@ -92,7 +92,7 @@ local function parse_python(ctx)
         local capture = query.captures[id]
         local start_row, _, _, _ = node:range()
         if capture == 'def' then
-            table.insert(marks, {
+            marks[#marks + 1] = {
                 conceal = true,
                 start_row = start_row,
                 start_col = 0,

lua/render-markdown/command.lua

@@ -53,7 +53,7 @@ function M.matches(prefix, values)
     local result = {}
     for _, value in ipairs(values) do
         if vim.startswith(value, prefix) then
-            table.insert(result, value)
+            result[#result + 1] = value
         end
     end
     return result

lua/render-markdown/core/conceal.lua

@@ -53,7 +53,7 @@ function Conceal:add(row, entry)
     else
         -- If the section is covered by an existing one don't add it
         if entry.width > 0 and not self:has(line, entry) then
-            table.insert(line.sections, entry)
+            line.sections[#line.sections + 1] = entry
         end
     end
 end

lua/render-markdown/core/context.lua

@@ -37,7 +37,7 @@ function Context.new(props, offset)
 
     local ranges = {}
     for _, window in ipairs(Env.buf.windows(props.buf)) do
-        table.insert(ranges, Context.compute_range(props.buf, window, offset))
+        ranges[#ranges + 1] = Context.compute_range(props.buf, window, offset)
     end
     self.ranges = Range.coalesce(ranges)
     self.callouts = {}
@@ -137,7 +137,8 @@ function Context:add_offset(row, offset)
     if self.offsets[row] == nil then
         self.offsets[row] = {}
     end
-    table.insert(self.offsets[row], offset)
+    local offsets = self.offsets[row]
+    offsets[#offsets + 1] = offset
 end
 
 ---@private

lua/render-markdown/core/log.lua

@@ -84,7 +84,7 @@ function M.add(level, name, ...)
     for i = 1, select('#', ...) do
         local value = select(i, ...)
         local message = type(value) == 'string' and value or vim.inspect(value)
-        table.insert(messages, message)
+        messages[#messages + 1] = message
     end
     ---@type render.md.log.Entry
     local entry = {
@@ -93,7 +93,7 @@ function M.add(level, name, ...)
         name = name,
         message = table.concat(messages, ' | '),
     }
-    table.insert(M.entries, entry)
+    M.entries[#M.entries + 1] = entry
     -- Periodically flush logs to disk
     if #M.entries > 1000 then
         M.flush()

lua/render-markdown/core/range.lua

@@ -52,7 +52,7 @@ function Range.coalesce(ranges)
         if range.top <= current.bottom + 1 then
             current.bottom = math.max(current.bottom, range.bottom)
         else
-            table.insert(result, range)
+            result[#result + 1] = range
         end
     end
     return result

lua/render-markdown/core/ui.lua

@@ -56,7 +56,7 @@ function M.get_row_marks(buf, win)
     local marks = {}
     for _, extmark in ipairs(buffer:get_marks()) do
         if extmark:inside(hidden) then
-            table.insert(marks, extmark:get())
+            marks[#marks + 1] = extmark:get()
         end
     end
     return row, marks
@@ -205,7 +205,7 @@ function M.parse_buffer(props)
     parser:for_each_tree(function(tree, language_tree)
         local language = language_tree:lang()
         if language == 'markdown' then
-            table.insert(markdown_roots, tree:root())
+            markdown_roots[#markdown_roots + 1] = tree:root()
         else
             vim.list_extend(marks, M.parse_tree({ buf = buf, root = tree:root() }, language))
         end

lua/render-markdown/debug/diff.lua

@@ -30,7 +30,7 @@ end
 function M.append_keys(keys, t)
     for key in pairs(t) do
         if not vim.tbl_contains(keys, key) then
-            table.insert(keys, key)
+            keys[#keys + 1] = key
         end
     end
 end

lua/render-markdown/debug/marks.lua

@@ -1,10 +1,14 @@
 local Iter = require('render-markdown.lib.iter')
 
+---@class render.md.debug.Range
+---@field [1] integer
+---@field [2]? integer
+
 ---@class render.md.debug.Mark
 ---@field conceal boolean
 ---@field opts render.md.MarkOpts
----@field row { [1]: integer, [2]: integer }
----@field col { [1]: integer, [2]: integer }
+---@field row render.md.debug.Range
+---@field col render.md.debug.Range
 local Mark = {}
 Mark.__index = Mark
 
@@ -13,126 +17,122 @@ Mark.__index = Mark
 function Mark.new(mark)
     local self = setmetatable({}, Mark)
     self.conceal, self.opts = mark.conceal, mark.opts
-    self.row = { mark.start_row, mark.opts.end_row or mark.start_row }
-    self.col = { mark.start_col, mark.opts.end_col or mark.start_col }
+    self.row = { mark.start_row, mark.opts.end_row }
+    self.col = { mark.start_col, mark.opts.end_col }
     return self
 end
 
+---@param a render.md.debug.Mark
+---@param b render.md.debug.Mark
+---@return boolean
+function Mark.__lt(a, b)
+    local as, bs = a:priorities(), b:priorities()
+    for i = 1, math.max(#as, #bs) do
+        if as[i] ~= bs[i] then
+            return as[i] < bs[i]
+        end
+    end
+    return false
+end
+
+---@private
 ---@return integer[]
 function Mark:priorities()
-    local row_offset = 0
+    local virt_row = 0
     if self.opts.virt_lines ~= nil then
-        row_offset = self.opts.virt_lines_above and -0.5 or 0.5
+        virt_row = self.opts.virt_lines_above and -0.5 or 0.5
     end
-    local col = self.opts.virt_text_win_col or 0
-    local result = { self.row[1] + row_offset, self.row[2] + row_offset }
-    return vim.list_extend(result, { math.max(self.col[1], col), math.max(self.col[2], col) })
+    local win_col = self.opts.virt_text_win_col or 0
+    return {
+        -- rows
+        self.row[1] + virt_row,
+        (self.row[2] or self.row[1]) + virt_row,
+        -- cols
+        math.max(self.col[1], win_col),
+        math.max((self.col[2] or self.col[1]), win_col),
+    }
 end
 
 ---@return string
 function Mark:__tostring()
-    ---@param text string
-    ---@return string
-    local function serialize_text(text)
-        local chars = vim.fn.str2list(text)
-        if #chars <= 1 then
-            return string.format('"%s"', text)
-        end
-        local first = chars[1]
-        for _, char in ipairs(chars) do
-            if first ~= char then
-                return string.format('"%s"', text)
-            end
-        end
-        return string.format('rep(%s, %d)', vim.fn.nr2char(first), #chars)
-    end
-
-    ---@param highlight number|string|string[]
-    ---@return string
-    local function serialize_highlight(highlight)
-        if type(highlight) == 'table' then
-            highlight = table.concat(highlight, '+')
-        end
-        local result, _ = highlight:gsub('RenderMarkdown_?', '')
-        result, _ = result:gsub('Inverse', 'I')
-        return string.format('(%s)', result)
-    end
-
-    ---@param line { [1]?: string, [2]?: number|string|string[] }[]
-    ---@return string[]?
-    local function virt_line(line)
-        local result = {}
-        for _, part in ipairs(line) do
-            local serialized, text, highlight = {}, part[1], part[2]
-            if text ~= nil then
-                table.insert(serialized, serialize_text(text))
-            end
-            if highlight ~= nil then
-                table.insert(serialized, serialize_highlight(highlight))
-            end
-            if #serialized > 0 then
-                table.insert(result, table.concat(serialized, '::'))
-            end
-        end
-        return #result > 0 and result or nil
-    end
-
-    ---@param vals { [1]: integer, [2]: integer }
-    ---@return string|integer
-    local function collapse(vals)
-        return vals[1] == vals[2] and vals[1] or string.format('%d -> %d', vals[1], vals[2])
-    end
-
-    local lines = {
-        string.rep('=', vim.o.columns - 10),
-        string.format('row: %s', collapse(self.row)),
-        string.format('column: %s', collapse(self.col)),
-        string.format('hide: %s', self.conceal),
-    }
+    local lines = {}
+    lines[#lines + 1] = string.rep('=', vim.o.columns - 10)
+    lines[#lines + 1] = string.format('row: %s', Mark.collapse(self.row))
+    lines[#lines + 1] = string.format('column: %s', Mark.collapse(self.col))
+    lines[#lines + 1] = string.format('hide: %s', vim.inspect(self.conceal))
 
     ---@param name string
     ---@param value any
-    local function append(name, value)
-        if type(value) == 'table' then
-            value = virt_line(value)
-        end
+    ---@param f fun(value: any): string
+    local function add(name, value, f)
         if value ~= nil then
-            if type(value) == 'table' then
-                value = table.concat(value, ' + ')
-            end
-            if type(value) == 'string' and #value == 0 then
-                value = vim.inspect(value)
-            end
-            table.insert(lines, string.format('  %s: %s', name, value))
+            lines[#lines + 1] = string.format('  %s: %s', name, f(value))
         end
     end
 
-    append('conceal', self.opts.conceal)
-    append('sign', { { self.opts.sign_text, self.opts.sign_hl_group } })
-    append('virt_text', self.opts.virt_text)
-    append('virt_text_pos', self.opts.virt_text_pos)
-    append('virt_text_win_col', self.opts.virt_text_win_col)
-    append('virt_text_repeat_linebreak', self.opts.virt_text_repeat_linebreak)
-    append('virt_line', (self.opts.virt_lines or {})[1])
-    append('virt_line_above', self.opts.virt_lines_above)
-    append('hl_group', { { nil, self.opts.hl_group } })
-    append('hl_eol', self.opts.hl_eol)
-    append('hl_mode', self.opts.hl_mode)
-    append('priority', self.opts.priority)
+    local opts = self.opts
+    add('conceal', opts.conceal, vim.inspect)
+    add('conceal_lines', opts.conceal_lines, vim.inspect)
+    add('sign_text', opts.sign_text, Mark.text)
+    add('sign_hl_group', opts.sign_hl_group, Mark.highlight)
+    add('virt_text', opts.virt_text, Mark.line)
+    add('virt_text_pos', opts.virt_text_pos, tostring)
+    add('virt_text_win_col', opts.virt_text_win_col, vim.inspect)
+    add('virt_text_repeat_linebreak', opts.virt_text_repeat_linebreak, vim.inspect)
+    add('virt_line', (opts.virt_lines or {})[1], Mark.line)
+    add('virt_line_above', opts.virt_lines_above, vim.inspect)
+    add('hl_group', opts.hl_group, Mark.highlight)
+    add('hl_eol', opts.hl_eol, vim.inspect)
+    add('hl_mode', opts.hl_mode, tostring)
+    add('priority', opts.priority, tostring)
     return table.concat(lines, '\n')
 end
 
----@param a render.md.debug.Mark
----@param b render.md.debug.Mark
----@return boolean
-function Mark.__lt(a, b)
-    local as, bs = a:priorities(), b:priorities()
-    for i = 1, math.max(#as, #bs) do
-        if as[i] ~= bs[i] then
-            return as[i] < bs[i]
-        end
+---@private
+---@param range render.md.debug.Range
+---@return string
+function Mark.collapse(range)
+    local s, e = range[1], range[2]
+    return e == nil and tostring(s) or string.format('%d -> %d', s, e)
+end
+
+---@private
+---@param line render.md.MarkLine
+---@return string
+function Mark.line(line)
+    local result = {}
+    for _, text in ipairs(line) do
+        result[#result + 1] = string.format('(%s, %s)', Mark.text(text[1]), Mark.highlight(text[2]))
+    end
+    return table.concat(result, ' + ')
+end
+
+---@private
+---@param text string
+---@return string
+function Mark.text(text)
+    local chars = vim.fn.str2list(text)
+    local first, same = chars[1], true
+    for _, char in ipairs(chars) do
+        same = same and (first == char)
+    end
+    if #chars > 1 and same then
+        local char = vim.fn.nr2char(first)
+        return string.format('rep(%s, %d)', char, #chars)
+    else
+        return text
     end
-    return false
+end
+
+---@private
+---@param highlight string|string[]
+---@return string
+function Mark.highlight(highlight)
+    if type(highlight) == 'table' then
+        highlight = table.concat(highlight, '+')
+    end
+    local result = highlight:gsub('RenderMarkdown', 'Rm')
+    return result
 end
 
 ---@class render.md.debug.Marks
@@ -141,14 +141,15 @@ local M = {}
 ---@param row integer
 ---@param marks render.md.Mark[]
 function M.debug(row, marks)
-    print(string.format('Decorations on row: %d', row))
+    vim.print(string.format('Row: %d', row))
     if #marks == 0 then
-        print('No decorations found')
-    end
-    local debug_marks = Iter.list.map(marks, Mark.new)
-    table.sort(debug_marks)
-    for _, mark in ipairs(debug_marks) do
-        print(mark)
+        vim.print('No decorations found')
+    else
+        local debug_marks = Iter.list.map(marks, Mark.new)
+        table.sort(debug_marks)
+        for _, mark in ipairs(debug_marks) do
+            vim.print(tostring(mark))
+        end
     end
 end
 

lua/render-markdown/debug/validator.lua

@@ -169,7 +169,7 @@ function Spec:handle_types(custom, ts)
         types = ts
     end
     if self.nilable and not vim.tbl_contains(types, 'nil') then
-        table.insert(types, 'nil')
+        types[#types + 1] = 'nil'
     end
     return types, table.concat(vim.list_extend(custom, types), ' or ')
 end
@@ -232,13 +232,13 @@ function Validator:check(path, config, specs)
             if info ~= nil then
                 message = message .. string.format(', info: %s', info)
             end
-            table.insert(self.errors, message)
+            self.errors[#self.errors + 1] = message
         end
     end
     for key, _ in pairs(config) do
         if specs[key] == nil then
             local message = string.format('%s.%s - invalid key', path, key)
-            table.insert(self.errors, message)
+            self.errors[#self.errors + 1] = message
         end
     end
 end