Maak een Neovim-configuratie voor efficiënte Language Server Protocol (LSP) setup en beheer
description
Met deze prompt kan de gebruiker een Neovim-omgeving creëren die de voordelen van LSP-functies maximaliseert, waardoor codekwaliteit, navigatie en productiviteit verbeteren. Het behandelt de complexe setup van meerdere taalservers op een eenduidige manier, wat eenvoudiger is dan elke server handmatig configureren. De aangepaste sneltoetsen en pluginaanbevelingen stroomlijnen workflows en verminderen het schakelen tussen contexten.
prompt
Help me een Neovim-configuratie te maken die efficiënt Language Server Protocol (LSP)-servers instelt en beheert. Mijn belangrijkste programmeertalen zijn: <voer je belangrijkste programmeertalen in>. Ik wil ondersteuning ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Hier is een overzichtelijke en efficiënte Neovim-configuratie om LSP-servers voor Python en JavaScript te beheren, inclusief plugins, configuraties en sneltoetsen voor een naadloze ervaring.
1. **Benodigde plugins**
Gebruik bijvoorbeeld een pluginmanager zoals `packer.nvim`. Voeg de volgende plugins toe in je `init.lua` of `plugins.lua`:
```lua
require('packer').startup(function()
-- LSP Config en installer
use 'neovim/nvim-lspconfig'
use 'williamboman/mason.nvim' -- LSP-servers makkelijk installeren
use 'williamboman/mason-lspconfig.nvim'
-- Autocompletion framework
use 'hrsh7th/nvim-cmp'
use 'hrsh7th/cmp-nvim-lsp'
use 'hrsh7th/cmp-buffer'
use 'hrsh7th/cmp-path'
use 'L3MON4D3/LuaSnip' -- Snippets
use 'saadparwaiz1/cmp_luasnip'
-- Optional: UI voor diagnostics
use 'folke/trouble.nvim'
end)
```
2. **LSP- en autocompletion setup**
In je `init.lua` of een aparte configuratiebestanden:
```lua
-- Mason en LSP-instellingen
require('mason').setup()
require('mason-lspconfig').setup({
ensure_installed = { 'pyright', 'tsserver' },
})
local lspconfig = require('lspconfig')
local on_attach = function(client, bufnr)
-- Mappen van sneltoetsen
local bufopts = { noremap=true, silent=true, buffer=bufnr }
-- Navigatie en functies
vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gd', '<cmd>lua vim.lsp.buf.definition()<CR>', bufopts)
vim.api.nvim_buf_set_keymap(bufnr, 'n', 'K', '<cmd>lua vim.lsp.buf.hover()<CR>', bufopts)
vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gi', '<cmd>lua vim.lsp.buf.implementation()<CR>', bufopts)
vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>rn', '<cmd>lua vim.lsp.buf.rename()<CR>', bufopts)
vim.api.nvim_buf_set_keymap(bufnr, 'n', 'gr', '<cmd>lua vim.lsp.buf.references()<CR>', bufopts)
vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>ca', '<cmd>lua vim.lsp.buf.code_action()<CR>', bufopts)
vim.api.nvim_buf_set_keymap(bufnr, 'n', '<leader>f', '<cmd>lua vim.lsp.buf.format { async = true }<CR>', bufopts)
end
local capabilities = require('cmp_nvim_lsp').default_capabilities()
-- Python (Pyright)
lspconfig.pyright.setup{
on_attach = on_attach,
capabilities = capabilities,
}
-- JavaScript/TypeScript (tsserver)
lspconfig.tsserver.setup{
on_attach = on_attach,
capabilities = capabilities,
}
```
3. **Autocompletion en snippets**
Configure `nvim-cmp`:
```lua
local cmp = require'cmp'
local luasnip = require'LuASnip'
cmp.setup{
snippet = {
expand = function(args)
require'luasnip'.lsp_expand(args.body)
end,
},
mapping = {
['<C-d>'] = cmp.mapping.scroll_docs(-4),
['<C-f>'] = cmp.mapping.scroll_docs(4),
['<C-Space>'] = cmp.mapping.complete(),
['<CR>'] = cmp.mapping.confirm({ select = true }),
['<Tab>'] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_next_item()
elseif require('luasnip').expand_or_jumpable() then
require('luasnip').expand_or_jump()
else
fallback()
end
end, { 'i', 's' }),
},
sources = {
{ name = 'nvim_lsp' },
{ name = 'buffer' },
{ name = 'path' },
{ name = 'luasnip' },
},
}
```
4. **Formatteren en diagnostiek**
Gebruik bijvoorbeeld `null-ls.nvim` voor formattering (zoals `prettier` voor JS en `black` voor Python):
```lua
use 'jose-elias-alvarez/null-ls.nvim'
```
En configureer:
```lua
local null_ls = require("null-ls")
null_ls.setup({
sources = {
-- Python formatter
null_ls.builtins.formatting.black,
-- JavaScript formatter
null_ls.builtins.formatting.prettier,
-- Diagnostics (optioneel)
null_ls.builtins.diagnostics.flake8,
},
on_attach = function(client, bufnr)
if client.resolved_capabilities.document_formatting then
vim.cmd([[
autocmd BufWritePre <buffer> lua vim.lsp.buf.formatting_sync()
]])
end
end,
})
```
5. **Extra sneltoetsen en gebruiksgemak**
Voor een betere workflow kun je bijvoorbeeld een sneltoets toevoegen om alle LSP-info te bekijken:
```lua
vim.api.nvim_set_keymap('n', '<leader>e', '<cmd>TroubleToggle<CR>', { noremap=true, silent=true })
```
Voor Troubles.nvim installeer je de plugin en configureer je:
```lua
require("trouble").setup{}
```
---
**Samengevat**:
- Installeer en configureer `mason.nvim` en `nvim-lspconfig` voor automatische installatie en beheer van LSP-servers.
- Stel `nvim-cmp` in voor autocompletion, met snippets via `LuaSnip`.
- Gebruik `null-ls.nvim` voor formattering en aanvullende diagnostiek.
- Voeg handige sneltoetsen toe voor navigatie, code acties en diagnostics.
Met deze setup heb je een krachtige, geautomatiseerde en naadloze LSP-ervaring binnen Neovim voor Python en JavaScript.
provider: deepseek
model: deepseek-chat
Hier is een complete Neovim LSP-configuratie voor Python en JavaScript:
## Vereiste Plugins
Voeg deze toe aan je plugin manager (`lazy.nvim` aanbevolen):
```lua
-- plugins/lsp.lua
return {
-- LSP Configuratie
{
"neovim/nvim-lspconfig",
dependencies = {
-- Automatische LSP installatie
"williamboman/mason.nvim",
"williamboman/mason-lspconfig.nvim",
-- Completion engine
"hrsh7th/nvim-cmp",
"hrsh7th/cmp-nvim-lsp",
"hrsh7th/cmp-buffer",
"hrsh7th/cmp-path",
"hrsh7th/cmp-cmdline",
-- Snippet ondersteuning
"L3MON4D3/LuaSnip",
"saadparwaiz1/cmp_luasnip",
-- Extra LSP UI verbeteringen
"onsails/lspkind.nvim",
"j-hui/fidget.nvim",
}
}
}
```
## Hoofdconfiguratie
```lua
-- lua/config/lsp.lua
local lspconfig = require('lspconfig')
local mason = require('mason')
local mason_lspconfig = require('mason-lspconfig')
local cmp = require('cmp')
local luasnip = require('luasnip')
local lspkind = require('lspkind')
-- Mason setup (LSP package manager)
mason.setup({
ui = {
icons = {
package_installed = "✓",
package_pending = "➜",
package_uninstalled = "✗"
}
}
})
mason_lspconfig.setup({
ensure_installed = {
"pyright", -- Python
"tsserver", -- JavaScript/TypeScript
"eslint", -- JavaScript linting
"html",
"cssls",
"jsonls"
},
automatic_installation = true,
})
-- Completion setup
cmp.setup({
snippet = {
expand = function(args)
luasnip.lsp_expand(args.body)
end,
},
mapping = cmp.mapping.preset.insert({
['<C-b>'] = cmp.mapping.scroll_docs(-4),
['<C-f>'] = cmp.mapping.scroll_docs(4),
['<C-Space>'] = cmp.mapping.complete(),
['<C-e>'] = cmp.mapping.abort(),
['<CR>'] = cmp.mapping.confirm({ select = true }),
['<Tab>'] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_next_item()
elseif luasnip.expand_or_jumpable() then
luasnip.expand_or_jump()
else
fallback()
end
end, { 'i', 's' }),
['<S-Tab>'] = cmp.mapping(function(fallback)
if cmp.visible() then
cmp.select_prev_item()
elseif luasnip.jumpable(-1) then
luasnip.jump(-1)
else
fallback()
end
end, { 'i', 's' }),
}),
sources = cmp.config.sources({
{ name = 'nvim_lsp' },
{ name = 'luasnip' },
}, {
{ name = 'buffer' },
}),
formatting = {
format = lspkind.cmp_format({
mode = 'symbol_text',
maxwidth = 50,
ellipsis_char = '...',
})
},
})
-- LSP Handlers en configuratie
local capabilities = require('cmp_nvim_lsp').default_capabilities()
local on_attach = function(client, bufnr)
local opts = { buffer = bufnr, remap = false }
-- Sneltoetsen
vim.keymap.set("n", "gd", vim.lsp.buf.definition, opts)
vim.keymap.set("n", "K", vim.lsp.buf.hover, opts)
vim.keymap.set("n", "<leader>vws", vim.lsp.buf.workspace_symbol, opts)
vim.keymap.set("n", "<leader>vd", vim.diagnostic.open_float, opts)
vim.keymap.set("n", "[d", vim.diagnostic.goto_next, opts)
vim.keymap.set("n", "]d", vim.diagnostic.goto_prev, opts)
vim.keymap.set("n", "<leader>vca", vim.lsp.buf.code_action, opts)
vim.keymap.set("n", "<leader>vrr", vim.lsp.buf.references, opts)
vim.keymap.set("n", "<leader>vrn", vim.lsp.buf.rename, opts)
vim.keymap.set("i", "<C-h>", vim.lsp.buf.signature_help, opts)
-- Formattering
vim.keymap.set("n", "<leader>f", function()
vim.lsp.buf.format({ async = true })
end, opts)
end
-- LSP Server configuraties
mason_lspconfig.setup_handlers({
function(server_name)
lspconfig[server_name].setup({
capabilities = capabilities,
on_attach = on_attach,
})
end,
-- Python specifieke configuratie
["pyright"] = function()
lspconfig.pyright.setup({
capabilities = capabilities,
on_attach = on_attach,
settings = {
python = {
analysis = {
typeCheckingMode = "basic",
autoSearchPaths = true,
useLibraryCodeForTypes = true,
diagnosticMode = "workspace",
}
}
}
})
end,
-- TypeScript/JavaScript specifieke configuratie
["tsserver"] = function()
lspconfig.tsserver.setup({
capabilities = capabilities,
on_attach = on_attach,
settings = {
typescript = {
inlayHints = {
includeInlayParameterNameHints = "all",
includeInlayParameterNameHintsWhenArgumentMatchesName = false,
includeInlayFunctionParameterTypeHints = true,
includeInlayVariableTypeHints = true,
includeInlayPropertyDeclarationTypeHints = true,
includeInlayFunctionLikeReturnTypeHints = true,
includeInlayEnumMemberValueHints = true,
}
},
javascript = {
inlayHints = {
includeInlayParameterNameHints = "all",
includeInlayParameterNameHintsWhenArgumentMatchesName = false,
includeInlayFunctionParameterTypeHints = true,
includeInlayVariableTypeHints = true,
includeInlayPropertyDeclarationTypeHints = true,
includeInlayFunctionLikeReturnTypeHints = true,
includeInlayEnumMemberValueHints = true,
}
}
}
})
end,
-- ESLint configuratie
["eslint"] = function()
lspconfig.eslint.setup({
capabilities = capabilities,
on_attach = on_attach,
settings = {
packageManager = "npm"
}
})
end,
})
-- Diagnostische configuratie
vim.diagnostic.config({
virtual_text = true,
signs = true,
update_in_insert = false,
severity_sort = true,
float = {
focusable = false,
style = 'minimal',
border = 'rounded',
source = 'always',
header = '',
prefix = '',
},
})
-- Tekens voor diagnostiek
local signs = { Error = "", Warn = "", Hint = "", Info = "" }
for type, icon in pairs(signs) do
local hl = "DiagnosticSign" .. type
vim.fn.sign_define(hl, { text = icon, texthl = hl, numhl = hl })
end
-- Fidget.nvim voor LSP progress notificaties
require('fidget').setup({})
```
## Aanbevolen Sneltoetsen
```lua
-- Sneltoetsen in je init.lua
vim.g.mapleader = " "
-- LSP sneltoetsen (al geconfigureerd in on_attach)
-- gd: Ga naar definitie
-- K: Hover informatie
-- <leader>vca: Code acties
-- <leader>vrr: Referenties
-- <leader>vrn: Hernoemen
-- <leader>f: Formatteren
-- [d/]d: Navigeer door diagnostiek
```
## Extra Aanbevelingen
### Formattering Plugins:
```lua
-- Voeg toe aan je plugins
{
"jose-elias-alvarez/null-ls.nvim",
dependencies = { "nvim-lua/plenary.nvim" }
}
-- Configuratie
local null_ls = require("null-ls")
null_ls.setup({
sources = {
null_ls.builtins.formatting.black, -- Python
null_ls.builtins.formatting.prettier, -- JavaScript
null_ls.builtins.diagnostics.eslint,
},
})
```
### UI Verbeteringen:
```lua
{
"glepnir/lspsaga.nvim",
event = "LspAttach",
config = function()
require("lspsaga").setup({})
end,
dependencies = {
{"nvim-tree/nvim-web-devicons"},
{"nvim-treesitter/nvim-treesitter"}
}
}
```
## Installatie Stappen
1. Zorg dat je een plugin manager hebt (lazy.nvim aanbevolen)
2. Plaats bovenstaande configuratie in `lua/config/lsp.lua`
3. Importeer in je `init.lua`: `require('config.lsp')`
4. Open Neovim en run `:Lazy install`
5. LSP servers worden automatisch geïnstalleerd via Mason
Deze configuratie biedt complete LSP-ondersteuning voor Python en JavaScript met automatische installatie, slimme completion en alle gewenste functies geïntegreerd.