Update lspconfig, add indent-blanklineHEADmaster

indent-blankline is probably old because I've actually been using it for
ages, but I have a strict if-it-ain't-broke policy, so I'm not going to
update it.

lspconfig *was* broke though with nvim 0.10, so now it's fixed.

1 files changed, 341 insertions, 0 deletions

diff --git a/start/indent-blankline-2.20.4/lua/indent_blankline/utils.lua b/start/indent-blankline-2.20.4/lua/indent_blankline/utils.lua
new file mode 100644
index 0000000..e21a5c9
--- /dev/null
+++ b/start/indent-blankline-2.20.4/lua/indent_blankline/utils.lua
@@ -0,0 +1,341 @@
+local M = {}
+
+M.memo = setmetatable({
+    put = function(cache, params, result)
+        local node = cache
+        for i = 1, #params do
+            local param = vim.inspect(params[i])
+            node.children = node.children or {}
+            node.children[param] = node.children[param] or {}
+            node = node.children[param]
+        end
+        node.result = result
+    end,
+    get = function(cache, params)
+        local node = cache
+        for i = 1, #params do
+            local param = vim.inspect(params[i])
+            node = node.children and node.children[param]
+            if not node then
+                return nil
+            end
+        end
+        return node.result
+    end,
+}, {
+    __call = function(memo, func)
+        local cache = {}
+
+        return function(...)
+            local params = { ... }
+            local result = memo.get(cache, params)
+            if not result then
+                result = { func(...) }
+                memo.put(cache, params, result)
+            end
+            return unpack(result)
+        end
+    end,
+})
+
+M.error_handler = function(err, level)
+    if err:match "Invalid buffer id.*" then
+        return
+    end
+    if not pcall(require, "notify") then
+        err = string.format("indent-blankline: %s", err)
+    end
+    vim.notify_once(err, level or vim.log.levels.DEBUG, {
+        title = "indent-blankline",
+    })
+end
+
+M.is_indent_blankline_enabled = M.memo(
+    function(
+        b_enabled,
+        g_enabled,
+        disable_with_nolist,
+        opt_list,
+        filetype,
+        filetype_include,
+        filetype_exclude,
+        buftype,
+        buftype_exclude,
+        bufname_exclude,
+        bufname
+    )
+        if b_enabled ~= nil then
+            return b_enabled
+        end
+        if g_enabled ~= true then
+            return false
+        end
+        if disable_with_nolist and not opt_list then
+            return false
+        end
+
+        local plain = M._if(vim.fn.has "nvim-0.6.0" == 1, { plain = true }, true)
+        local undotted_filetypes = vim.split(filetype, ".", plain)
+        table.insert(undotted_filetypes, filetype)
+
+        for _, ft in ipairs(filetype_exclude) do
+            for _, undotted_filetype in ipairs(undotted_filetypes) do
+                if undotted_filetype == ft then
+                    return false
+                end
+            end
+        end
+
+        for _, bt in ipairs(buftype_exclude) do
+            if bt == buftype then
+                return false
+            end
+        end
+
+        for _, bn in ipairs(bufname_exclude) do
+            if vim.fn["matchstr"](bufname, bn) == bufname then
+                return false
+            end
+        end
+
+        if #filetype_include > 0 then
+            for _, ft in ipairs(filetype_include) do
+                if ft == filetype then
+                    return true
+                end
+            end
+            return false
+        end
+
+        return true
+    end
+)
+
+M.clear_line_indent = function(buf, lnum)
+    xpcall(vim.api.nvim_buf_clear_namespace, M.error_handler, buf, vim.g.indent_blankline_namespace, lnum - 1, lnum)
+end
+
+M.clear_buf_indent = function(buf)
+    xpcall(vim.api.nvim_buf_clear_namespace, M.error_handler, buf, vim.g.indent_blankline_namespace, 0, -1)
+end
+
+M.get_from_list = function(list, i, default)
+    if not list or #list == 0 then
+        return default
+    end
+    return list[((i - 1) % #list) + 1]
+end
+
+M._if = function(bool, a, b)
+    if bool then
+        return a
+    else
+        return b
+    end
+end
+
+M.find_indent = function(whitespace, only_whitespace, shiftwidth, strict_tabs, list_chars)
+    local indent = 0
+    local spaces = 0
+    local tab_width
+    local virtual_string = {}
+
+    if whitespace then
+        for ch in whitespace:gmatch "." do
+            if ch == "\t" then
+                if strict_tabs and indent == 0 and spaces ~= 0 then
+                    return 0, false, {}
+                end
+                indent = indent + math.floor(spaces / shiftwidth) + 1
+                spaces = 0
+                -- replace dynamic-width tab with fixed-width string (ta..ab)
+                tab_width = shiftwidth - table.maxn(virtual_string) % shiftwidth
+                -- check if tab_char_end is set, see :help listchars
+                if list_chars["tab_char_end"] then
+                    if tab_width == 1 then
+                        table.insert(virtual_string, list_chars["tab_char_end"])
+                    else
+                        table.insert(virtual_string, list_chars["tab_char_start"])
+                        for _ = 1, (tab_width - 2) do
+                            table.insert(virtual_string, list_chars["tab_char_fill"])
+                        end
+                        table.insert(virtual_string, list_chars["tab_char_end"])
+                    end
+                else
+                    table.insert(virtual_string, list_chars["tab_char_start"])
+                    for _ = 1, (tab_width - 1) do
+                        table.insert(virtual_string, list_chars["tab_char_fill"])
+                    end
+                end
+            else
+                if strict_tabs and indent ~= 0 then
+                    -- return early when no more tabs are found
+                    return indent, true, virtual_string
+                end
+                if only_whitespace then
+                    -- if the entire line is only whitespace use trail_char instead of lead_char
+                    table.insert(virtual_string, list_chars["trail_char"])
+                else
+                    table.insert(virtual_string, list_chars["lead_char"])
+                end
+                spaces = spaces + 1
+            end
+        end
+    end
+
+    return indent + math.floor(spaces / shiftwidth), table.maxn(virtual_string) % shiftwidth ~= 0, virtual_string
+end
+
+M.get_current_context = function(type_patterns, use_treesitter_scope)
+    local ts_utils_status, ts_utils = pcall(require, "nvim-treesitter.ts_utils")
+    if not ts_utils_status then
+        vim.schedule_wrap(function()
+            M.error_handler("nvim-treesitter not found. Context will not work", vim.log.levels.WARN)
+        end)()
+        return false
+    end
+    local locals = require "nvim-treesitter.locals"
+    local cursor_node = ts_utils.get_node_at_cursor()
+
+    if use_treesitter_scope then
+        local current_scope = locals.containing_scope(cursor_node, 0)
+        if not current_scope then
+            return false
+        end
+        local node_start, _, node_end, _ = current_scope:range()
+        if node_start == node_end then
+            return false
+        end
+        return true, node_start + 1, node_end + 1, current_scope:type()
+    end
+
+    while cursor_node do
+        local node_type = cursor_node:type()
+        for _, rgx in ipairs(type_patterns) do
+            if node_type:find(rgx) then
+                local node_start, _, node_end, _ = cursor_node:range()
+                if node_start ~= node_end then
+                    return true, node_start + 1, node_end + 1, rgx
+                end
+            end
+        end
+        cursor_node = cursor_node:parent()
+    end
+
+    return false
+end
+
+M.reset_highlights = function()
+    local whitespace_highlight = vim.fn.synIDtrans(vim.fn.hlID "Whitespace")
+    local label_highlight = vim.fn.synIDtrans(vim.fn.hlID "Label")
+
+    local whitespace_fg = {
+        vim.fn.synIDattr(whitespace_highlight, "fg", "gui"),
+        vim.fn.synIDattr(whitespace_highlight, "fg", "cterm"),
+    }
+    local label_fg = {
+        vim.fn.synIDattr(label_highlight, "fg", "gui"),
+        vim.fn.synIDattr(label_highlight, "fg", "cterm"),
+    }
+
+    for highlight_name, highlight in pairs {
+        IndentBlanklineChar = whitespace_fg,
+        IndentBlanklineSpaceChar = whitespace_fg,
+        IndentBlanklineSpaceCharBlankline = whitespace_fg,
+        IndentBlanklineContextChar = label_fg,
+        IndentBlanklineContextStart = label_fg,
+    } do
+        local current_highlight = vim.fn.synIDtrans(vim.fn.hlID(highlight_name))
+        if
+            vim.fn.synIDattr(current_highlight, "fg") == ""
+            and vim.fn.synIDattr(current_highlight, "bg") == ""
+            and vim.fn.synIDattr(current_highlight, "sp") == ""
+        then
+            if highlight_name == "IndentBlanklineContextStart" then
+                vim.cmd(
+                    string.format(
+                        "highlight %s guisp=%s gui=underline cterm=underline",
+                        highlight_name,
+                        M._if(highlight[1] == "", "NONE", highlight[1])
+                    )
+                )
+            else
+                vim.cmd(
+                    string.format(
+                        "highlight %s guifg=%s ctermfg=%s gui=nocombine cterm=nocombine",
+                        highlight_name,
+                        M._if(highlight[1] == "", "NONE", highlight[1]),
+                        M._if(highlight[2] == "", "NONE", highlight[2])
+                    )
+                )
+            end
+        end
+    end
+end
+
+M.first_not_nil = function(...)
+    for _, value in pairs { ... } do -- luacheck: ignore
+        return value
+    end
+end
+
+M.get_variable = function(key)
+    if vim.b[key] ~= nil then
+        return vim.b[key]
+    end
+    if vim.t[key] ~= nil then
+        return vim.t[key]
+    end
+    return vim.g[key]
+end
+
+M.merge_ranges = function(ranges)
+    local merged_ranges = { { unpack(ranges[1]) } }
+
+    for i = 2, #ranges do
+        local current_end = merged_ranges[#merged_ranges][2]
+        local next_start, next_end = unpack(ranges[i])
+        if current_end >= next_start - 1 then
+            if current_end < next_end then
+                merged_ranges[#merged_ranges][2] = next_end
+            end
+        else
+            table.insert(merged_ranges, { next_start, next_end })
+        end
+    end
+
+    return merged_ranges
+end
+
+M.binary_search_ranges = function(ranges, target_range)
+    local exact_match = false
+    local idx_start = 1
+    local idx_end = #ranges
+    local idx_mid
+
+    local range_start
+    local target_start = target_range[1]
+
+    while idx_start < idx_end do
+        idx_mid = math.ceil((idx_start + idx_end) / 2)
+        range_start = ranges[idx_mid][1]
+
+        if range_start == target_start then
+            exact_match = true
+            break
+        elseif range_start < target_start then
+            idx_start = idx_mid -- it's important to make the low-end inclusive
+        else
+            idx_end = idx_mid - 1
+        end
+    end
+
+    -- if we don't have an exact match, choose the smallest index
+    if not exact_match then
+        idx_mid = idx_start
+    end
+
+    return idx_mid
+end
+
+return M