nvim

https://git.tonybtw.com/nvim.git git://git.tonybtw.com/nvim.git

8,328 bytes raw

vim.lsp.config('*', {
    root_markers = { '.git' },
})

vim.diagnostic.config({
    virtual_text  = true,
    severity_sort = true,
    float         = {
        style  = 'minimal',
        border = 'rounded',
        source = 'if_many',
        header = '',
        prefix = '',
    },
    signs         = {
        text = {
            [vim.diagnostic.severity.ERROR] = '✘',
            [vim.diagnostic.severity.WARN]  = '▲',
            [vim.diagnostic.severity.HINT]  = '⚑',
            [vim.diagnostic.severity.INFO]  = '»',
        },
    },
})

local orig = vim.lsp.util.open_floating_preview
---@diagnostic disable-next-line: duplicate-set-field
function vim.lsp.util.open_floating_preview(contents, syntax, opts, ...)
    opts            = opts or {}
    opts.border     = opts.border or 'rounded'
    opts.max_width  = opts.max_width or 80
    opts.max_height = opts.max_height or 24
    opts.wrap       = opts.wrap ~= false
    return orig(contents, syntax, opts, ...)
end

vim.api.nvim_create_autocmd('LspAttach', {
    group = vim.api.nvim_create_augroup('my.lsp', {}),
    callback = function(args)
        local client = assert(vim.lsp.get_client_by_id(args.data.client_id))
        local buf    = args.buf
        local map    = function(mode, lhs, rhs) vim.keymap.set(mode, lhs, rhs, { buffer = buf }) end

        map('n', 'K', vim.lsp.buf.hover)
        map('n', 'gd', vim.lsp.buf.definition)
        map('n', 'gD', vim.lsp.buf.declaration)
        map('n', 'gi', vim.lsp.buf.implementation)
        map('n', 'go', vim.lsp.buf.type_definition)
        map('n', 'gr', vim.lsp.buf.references)
        map('n', 'gs', vim.lsp.buf.signature_help)
        map('n', 'gl', vim.diagnostic.open_float)
        map('n', '<F2>', vim.lsp.buf.rename)
        map({ 'n', 'x' }, '<F3>', function() vim.lsp.buf.format({ async = true }) end)
        map('n', '<F4>', vim.lsp.buf.code_action)

        if client:supports_method('textDocument/documentHighlight') then
            local highlight_augroup = vim.api.nvim_create_augroup('my.lsp.highlight', { clear = false })
            vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
                buffer = buf,
                group = highlight_augroup,
                callback = vim.lsp.buf.document_highlight,
            })
            vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {
                buffer = buf,
                group = highlight_augroup,
                callback = vim.lsp.buf.clear_references,
            })
        end

        local excluded_filetypes = { php = true, c = true, cpp = true }
        if not client:supports_method('textDocument/willSaveWaitUntil')
            and client:supports_method('textDocument/formatting')
            and not excluded_filetypes[vim.bo[buf].filetype]
        then
            vim.api.nvim_create_autocmd('BufWritePre', {
                group = vim.api.nvim_create_augroup('my.lsp.format', { clear = false }),
                buffer = buf,
                callback = function()
                    vim.lsp.buf.format({ bufnr = buf, id = client.id, timeout_ms = 1000 })
                end,
            })
        end
    end,
})
local caps = require("cmp_nvim_lsp").default_capabilities()
vim.lsp.config['luals'] = {
    cmd = { 'lua-language-server' },
    filetypes = { 'lua' },
    root_markers = { { '.luarc.json', '.luarc.jsonc' }, '.git' },
    capabilities = caps,
    settings = {
        Lua = {
            runtime = { version = 'LuaJIT' },
            diagnostics = { globals = { 'vim' } },
            workspace = {
                checkThirdParty = false,
                library = vim.api.nvim_get_runtime_file('', true),
            },
            telemetry = { enable = false },
        },
    },
}

vim.lsp.config['cssls'] = {
    cmd = { 'vscode-css-language-server', '--stdio' },
    filetypes = { 'css', 'scss', 'less' },
    root_markers = { 'package.json', '.git' },
    capabilities = caps,
    settings = {
        css = { validate = true },
        scss = { validate = true },
        less = { validate = true },
    },
}

vim.lsp.config['phpls'] = {
    cmd = { 'intelephense', '--stdio' },
    filetypes = { 'php' },
    root_markers = { 'composer.json', '.git' },
    capabilities = caps,
    settings = {
        intelephense = {
            files = {
                maxSize = 5000000, -- default 5MB
            },
        },
    },
}

vim.lsp.config['ts_ls'] = {
    cmd = { 'typescript-language-server', '--stdio' },
    filetypes = {
        'javascript', 'javascriptreact', 'javascript.jsx',
        'typescript', 'typescriptreact', 'typescript.tsx',
    },
    root_markers = { 'package.json', 'tsconfig.json', 'jsconfig.json', '.git' },
    capabilities = caps,
    settings = {
        completions = {
            completeFunctionCalls = true,
        },
    },
}

vim.lsp.config['zls'] = {
    cmd = { 'zls' },
    filetypes = { 'zig', 'zir' },
    root_markers = { 'zls.json', 'build.zig', '.git' },
    capabilities = caps,
    settings = {
        zls = {
            enable_build_on_save = true,
            build_on_save_step = "install",
            warn_style = false,
            enable_snippets = true,
        }
    }
}

vim.lsp.config['nil_ls'] = {
    cmd = { 'nil' },
    filetypes = { 'nix' },
    root_markers = { 'flake.nix', 'default.nix', '.git' },
    capabilities = caps,
    settings = {
        ['nil'] = {
            formatting = {
                command = { "alejandra" }
            }
        }
    }
}

vim.lsp.config['rust_analyzer'] = {
    cmd = { 'rust-analyzer' },
    filetypes = { 'rust' },
    root_markers = { 'Cargo.toml', 'rust-project.json', '.git' },
    capabilities = caps,
    settings = {
        ['rust-analyzer'] = {
            cargo = { allFeatures = true },
            formatting = {
                command = { "rustfmt" }
            },
        },
    },
}

-- C / C++ via clangd
vim.lsp.config['clangd'] = {
    cmd = {
        'clangd',
        '--background-index',
        '--clang-tidy',
        '--header-insertion=never',
        '--completion-style=detailed',
        '--query-driver=/nix/store/*-gcc-*/bin/gcc*,/nix/store/*-clang-*/bin/clang*,/run/current-system/sw/bin/cc*',
    },
    filetypes = { 'c', 'cpp', 'objc', 'objcpp' },
    root_markers = { 'compile_commands.json', '.clangd', 'configure.ac', 'Makefile', '.git' },
    capabilities = caps,
    init_options = {
        fallbackFlags = { '-std=c23' }, -- Default to C23
    },
}

vim.lsp.config['c3lsp'] = {
    cmd = { 'c3-lsp' },
    filetypes = { 'c3' },
    root_markers = { 'project.json', '.git' },
    capabilities = caps,
}

vim.lsp.config['serve_d'] = {
    cmd = { 'serve-d' },
    filetypes = { 'd' },
    root_markers = { 'dub.sdl', 'dub.json', '.git' },
    capabilities = caps,
}

vim.lsp.config['jsonls'] = {
    cmd = { 'vscode-json-languageserver', '--stdio' },
    filetypes = { 'json', 'jsonc' },
    root_markers = { 'package.json', '.git', 'config.jsonc' },
    capabilities = caps,
}

vim.lsp.config['hls'] = {
    cmd = { 'haskell-language-server-wrapper', '--lsp' },
    filetypes = { 'haskell', 'lhaskell' },
    root_markers = { 'stack.yaml', 'cabal.project', 'package.yaml', '*.cabal', 'hie.yaml', '.git' },
    capabilities = caps,
    settings = {
        haskell = {
            formattingProvider = 'fourmolu',
            plugin = {
                semanticTokens = { globalOn = false }
            },
        },
    },
}

vim.lsp.config['gopls'] = {
    cmd = { 'gopls' },
    filetypes = { 'go', 'gomod', 'gowork', 'gotmpl' },
    root_markers = { 'go.mod', 'go.work', '.git' },
    capabilities = caps,
    settings = {
        gopls = {
            analyses = {
                unusedparams = false,
                ST1003 = false,
                ST1000 = false,
            },
            staticcheck = true,
        },
    },
}

vim.lsp.config['templ'] = {
    cmd = { 'templ', 'lsp' },
    filetypes = { 'templ' },
    root_markers = { 'go.mod', '.git' },
    capabilities = caps,
}

vim.filetype.add({
    extension = {
        h = 'c',
        c3 = 'c3',
        d = 'd',
        templ = 'templ',
    },
})

---@diagnostic disable-next-line: invisible
for name, _ in pairs(vim.lsp.config._configs) do
    if name ~= '*' then
        vim.lsp.enable(name)
    end
end

1	`vim.lsp.config('*', {`
2	`root_markers = { '.git' },`
3	`})`
4
5	`vim.diagnostic.config({`
6	`virtual_text = true,`
7	`severity_sort = true,`
8	`float = {`
9	`style = 'minimal',`
10	`border = 'rounded',`
11	`source = 'if_many',`
12	`header = '',`
13	`prefix = '',`
14	`},`
15	`signs = {`
16	`text = {`
17	`[vim.diagnostic.severity.ERROR] = '✘',`
18	`[vim.diagnostic.severity.WARN] = '▲',`
19	`[vim.diagnostic.severity.HINT] = '⚑',`
20	`[vim.diagnostic.severity.INFO] = '»',`
21	`},`
22	`},`
23	`})`
24
25	`local orig = vim.lsp.util.open_floating_preview`
26	`---@diagnostic disable-next-line: duplicate-set-field`
27	`function vim.lsp.util.open_floating_preview(contents, syntax, opts, ...)`
28	`opts = opts or {}`
29	`opts.border = opts.border or 'rounded'`
30	`opts.max_width = opts.max_width or 80`
31	`opts.max_height = opts.max_height or 24`
32	`opts.wrap = opts.wrap ~= false`
33	`return orig(contents, syntax, opts, ...)`
34	`end`
35
36	`vim.api.nvim_create_autocmd('LspAttach', {`
37	`group = vim.api.nvim_create_augroup('my.lsp', {}),`
38	`callback = function(args)`
39	`local client = assert(vim.lsp.get_client_by_id(args.data.client_id))`
40	`local buf = args.buf`
41	`local map = function(mode, lhs, rhs) vim.keymap.set(mode, lhs, rhs, { buffer = buf }) end`
42
43	`map('n', 'K', vim.lsp.buf.hover)`
44	`map('n', 'gd', vim.lsp.buf.definition)`
45	`map('n', 'gD', vim.lsp.buf.declaration)`
46	`map('n', 'gi', vim.lsp.buf.implementation)`
47	`map('n', 'go', vim.lsp.buf.type_definition)`
48	`map('n', 'gr', vim.lsp.buf.references)`
49	`map('n', 'gs', vim.lsp.buf.signature_help)`
50	`map('n', 'gl', vim.diagnostic.open_float)`
51	`map('n', '<F2>', vim.lsp.buf.rename)`
52	`map({ 'n', 'x' }, '<F3>', function() vim.lsp.buf.format({ async = true }) end)`
53	`map('n', '<F4>', vim.lsp.buf.code_action)`
54
55	`if client:supports_method('textDocument/documentHighlight') then`
56	`local highlight_augroup = vim.api.nvim_create_augroup('my.lsp.highlight', { clear = false })`
57	`vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {`
58	`buffer = buf,`
59	`group = highlight_augroup,`
60	`callback = vim.lsp.buf.document_highlight,`
61	`})`
62	`vim.api.nvim_create_autocmd({ 'CursorMoved', 'CursorMovedI' }, {`
63	`buffer = buf,`
64	`group = highlight_augroup,`
65	`callback = vim.lsp.buf.clear_references,`
66	`})`
67	`end`
68
69	`local excluded_filetypes = { php = true, c = true, cpp = true }`
70	`if not client:supports_method('textDocument/willSaveWaitUntil')`
71	`and client:supports_method('textDocument/formatting')`
72	`and not excluded_filetypes[vim.bo[buf].filetype]`
73	`then`
74	`vim.api.nvim_create_autocmd('BufWritePre', {`
75	`group = vim.api.nvim_create_augroup('my.lsp.format', { clear = false }),`
76	`buffer = buf,`
77	`callback = function()`
78	`vim.lsp.buf.format({ bufnr = buf, id = client.id, timeout_ms = 1000 })`
79	`end,`
80	`})`
81	`end`
82	`end,`
83	`})`
84	`local caps = require("cmp_nvim_lsp").default_capabilities()`
85	`vim.lsp.config['luals'] = {`
86	`cmd = { 'lua-language-server' },`
87	`filetypes = { 'lua' },`
88	`root_markers = { { '.luarc.json', '.luarc.jsonc' }, '.git' },`
89	`capabilities = caps,`
90	`settings = {`
91	`Lua = {`
92	`runtime = { version = 'LuaJIT' },`
93	`diagnostics = { globals = { 'vim' } },`
94	`workspace = {`
95	`checkThirdParty = false,`
96	`library = vim.api.nvim_get_runtime_file('', true),`
97	`},`
98	`telemetry = { enable = false },`
99	`},`
100	`},`
101	`}`
102
103	`vim.lsp.config['cssls'] = {`
104	`cmd = { 'vscode-css-language-server', '--stdio' },`
105	`filetypes = { 'css', 'scss', 'less' },`
106	`root_markers = { 'package.json', '.git' },`
107	`capabilities = caps,`
108	`settings = {`
109	`css = { validate = true },`
110	`scss = { validate = true },`
111	`less = { validate = true },`
112	`},`
113	`}`
114
115	`vim.lsp.config['phpls'] = {`
116	`cmd = { 'intelephense', '--stdio' },`
117	`filetypes = { 'php' },`
118	`root_markers = { 'composer.json', '.git' },`
119	`capabilities = caps,`
120	`settings = {`
121	`intelephense = {`
122	`files = {`
123	`maxSize = 5000000, -- default 5MB`
124	`},`
125	`},`
126	`},`
127	`}`
128
129	`vim.lsp.config['ts_ls'] = {`
130	`cmd = { 'typescript-language-server', '--stdio' },`
131	`filetypes = {`
132	`'javascript', 'javascriptreact', 'javascript.jsx',`
133	`'typescript', 'typescriptreact', 'typescript.tsx',`
134	`},`
135	`root_markers = { 'package.json', 'tsconfig.json', 'jsconfig.json', '.git' },`
136	`capabilities = caps,`
137	`settings = {`
138	`completions = {`
139	`completeFunctionCalls = true,`
140	`},`
141	`},`
142	`}`
143
144	`vim.lsp.config['zls'] = {`
145	`cmd = { 'zls' },`
146	`filetypes = { 'zig', 'zir' },`
147	`root_markers = { 'zls.json', 'build.zig', '.git' },`
148	`capabilities = caps,`
149	`settings = {`
150	`zls = {`
151	`enable_build_on_save = true,`
152	`build_on_save_step = "install",`
153	`warn_style = false,`
154	`enable_snippets = true,`
155	`}`
156	`}`
157	`}`
158
159	`vim.lsp.config['nil_ls'] = {`
160	`cmd = { 'nil' },`
161	`filetypes = { 'nix' },`
162	`root_markers = { 'flake.nix', 'default.nix', '.git' },`
163	`capabilities = caps,`
164	`settings = {`
165	`['nil'] = {`
166	`formatting = {`
167	`command = { "alejandra" }`
168	`}`
169	`}`
170	`}`
171	`}`
172
173	`vim.lsp.config['rust_analyzer'] = {`
174	`cmd = { 'rust-analyzer' },`
175	`filetypes = { 'rust' },`
176	`root_markers = { 'Cargo.toml', 'rust-project.json', '.git' },`
177	`capabilities = caps,`
178	`settings = {`
179	`['rust-analyzer'] = {`
180	`cargo = { allFeatures = true },`
181	`formatting = {`
182	`command = { "rustfmt" }`
183	`},`
184	`},`
185	`},`
186	`}`
187
188	`-- C / C++ via clangd`
189	`vim.lsp.config['clangd'] = {`
190	`cmd = {`
191	`'clangd',`
192	`'--background-index',`
193	`'--clang-tidy',`
194	`'--header-insertion=never',`
195	`'--completion-style=detailed',`
196	`'--query-driver=/nix/store/-gcc-/bin/gcc,/nix/store/-clang-/bin/clang,/run/current-system/sw/bin/cc*',`
197	`},`
198	`filetypes = { 'c', 'cpp', 'objc', 'objcpp' },`
199	`root_markers = { 'compile_commands.json', '.clangd', 'configure.ac', 'Makefile', '.git' },`
200	`capabilities = caps,`
201	`init_options = {`
202	`fallbackFlags = { '-std=c23' }, -- Default to C23`
203	`},`
204	`}`
205
206	`vim.lsp.config['c3lsp'] = {`
207	`cmd = { 'c3-lsp' },`
208	`filetypes = { 'c3' },`
209	`root_markers = { 'project.json', '.git' },`
210	`capabilities = caps,`
211	`}`
212
213	`vim.lsp.config['serve_d'] = {`
214	`cmd = { 'serve-d' },`
215	`filetypes = { 'd' },`
216	`root_markers = { 'dub.sdl', 'dub.json', '.git' },`
217	`capabilities = caps,`
218	`}`
219
220	`vim.lsp.config['jsonls'] = {`
221	`cmd = { 'vscode-json-languageserver', '--stdio' },`
222	`filetypes = { 'json', 'jsonc' },`
223	`root_markers = { 'package.json', '.git', 'config.jsonc' },`
224	`capabilities = caps,`
225	`}`
226
227	`vim.lsp.config['hls'] = {`
228	`cmd = { 'haskell-language-server-wrapper', '--lsp' },`
229	`filetypes = { 'haskell', 'lhaskell' },`
230	`root_markers = { 'stack.yaml', 'cabal.project', 'package.yaml', '*.cabal', 'hie.yaml', '.git' },`
231	`capabilities = caps,`
232	`settings = {`
233	`haskell = {`
234	`formattingProvider = 'fourmolu',`
235	`plugin = {`
236	`semanticTokens = { globalOn = false }`
237	`},`
238	`},`
239	`},`
240	`}`
241
242	`vim.lsp.config['gopls'] = {`
243	`cmd = { 'gopls' },`
244	`filetypes = { 'go', 'gomod', 'gowork', 'gotmpl' },`
245	`root_markers = { 'go.mod', 'go.work', '.git' },`
246	`capabilities = caps,`
247	`settings = {`
248	`gopls = {`
249	`analyses = {`
250	`unusedparams = false,`
251	`ST1003 = false,`
252	`ST1000 = false,`
253	`},`
254	`staticcheck = true,`
255	`},`
256	`},`
257	`}`
258
259	`vim.lsp.config['templ'] = {`
260	`cmd = { 'templ', 'lsp' },`
261	`filetypes = { 'templ' },`
262	`root_markers = { 'go.mod', '.git' },`
263	`capabilities = caps,`
264	`}`
265
266	`vim.filetype.add({`
267	`extension = {`
268	`h = 'c',`
269	`c3 = 'c3',`
270	`d = 'd',`
271	`templ = 'templ',`
272	`},`
273	`})`
274
275	`---@diagnostic disable-next-line: invisible`
276	`for name, _ in pairs(vim.lsp.config._configs) do`
277	`if name ~= '*' then`
278	`vim.lsp.enable(name)`
279	`end`
280	`end`