Switch nvim-cmp for blink.cmp and change LSP Keybindings for Neovim 0.11

nvim/lazy-lock.json

@@ -1,10 +1,7 @@
 {
   "LuaSnip": { "branch": "master", "commit": "c9b9a22904c97d0eb69ccb9bab76037838326817" },
+  "blink.cmp": { "branch": "main", "commit": "cb5e346d9e0efa7a3eee7fd4da0b690c48d2a98e" },
   "catppuccin": { "branch": "main", "commit": "5b5e3aef9ad7af84f463d17b5479f06b87d5c429" },
-  "cmp-nvim-lsp": { "branch": "main", "commit": "99290b3ec1322070bcfb9e846450a46f6efa50f0" },
-  "cmp-nvim-lsp-signature-help": { "branch": "main", "commit": "031e6ba70b0ad5eee49fd2120ff7a2e325b17fa7" },
-  "cmp-path": { "branch": "main", "commit": "91ff86cd9c29299a64f968ebb45846c485725f23" },
-  "cmp_luasnip": { "branch": "master", "commit": "98d9cb5c2c38532bd9bdb481067b20fea8f32e90" },
   "conform.nvim": { "branch": "master", "commit": "db8a4a9edb217067b1d7a2e0362c74bfe9cc944d" },
   "diffview.nvim": { "branch": "main", "commit": "4516612fe98ff56ae0415a259ff6361a89419b0a" },
   "edge": { "branch": "master", "commit": "04b2e25fa08b81e071ad512bdec6e5af114b01b3" },
@@ -34,7 +31,6 @@
   "nordic.nvim": { "branch": "main", "commit": "62acfd4eb008153180670daf81874eb47dd37739" },
   "nui.nvim": { "branch": "main", "commit": "8d3bce9764e627b62b07424e0df77f680d47ffdb" },
   "nvim-autopairs": { "branch": "master", "commit": "68f0e5c3dab23261a945272032ee6700af86227a" },
-  "nvim-cmp": { "branch": "main", "commit": "1e1900b0769324a9675ef85b38f99cca29e203b3" },
   "nvim-colorizer.lua": { "branch": "master", "commit": "517df88cf2afb36652830df2c655df2da416a0ae" },
   "nvim-dap": { "branch": "master", "commit": "a720d4966f758ab22e8ec28812b6df90a53e0f02" },
   "nvim-dap-go": { "branch": "main", "commit": "8763ced35b19c8dc526e04a70ab07c34e11ad064" },

nvim/lua/kickstart/plugins/autoformat.lua

@@ -27,16 +27,14 @@ return {
                 -- have a well standardized coding style. You can add additional
                 -- languages here or re-enable it for the disabled ones.
                 local disable_filetypes = { c = true, cpp = true }
-                local lsp_format_opt
                 if disable_filetypes[vim.bo[bufnr].filetype] then
-                    lsp_format_opt = 'never'
+                    return nil
                 else
-                    lsp_format_opt = 'fallback'
+                    return {
+                        timeout_ms = 5000,
+                        lsp_format = 'fallback',
+                    }
                 end
-                return {
-                    timeout_ms = 5000,
-                    lsp_format = lsp_format_opt,
-                }
             end,
             formatters_by_ft = {
                 lua = { 'stylua' },

nvim/lua/kickstart/plugins/autopairs.lua

@@ -4,13 +4,5 @@
 return {
     'windwp/nvim-autopairs',
     event = 'InsertEnter',
-    -- Optional dependency
-    dependencies = { 'hrsh7th/nvim-cmp' },
-    config = function()
-        require('nvim-autopairs').setup {}
-        -- If you want to automatically add `(` after selecting a function or method
-        local cmp_autopairs = require 'nvim-autopairs.completion.cmp'
-        local cmp = require 'cmp'
-        cmp.event:on('confirm_done', cmp_autopairs.on_confirm_done())
-    end,
+    opts = {},
 }

nvim/lua/kickstart/plugins/completion.lua

@@ -2,12 +2,14 @@
 
 return {
     {
-        'hrsh7th/nvim-cmp',
-        event = 'InsertEnter',
+        'saghen/blink.cmp',
+        event = 'VimEnter',
+        version = '1.*',
         dependencies = {
-            -- Snippet Engine & its associated nvim-cmp source
+            -- Snippet Engine
             {
                 'L3MON4D3/LuaSnip',
+                version = '2.*',
                 build = (function()
                     -- Build Step is needed for regex support in snippets.
                     -- This step is not supported in many windows environments.
@@ -28,108 +30,96 @@ return {
                         end,
                     },
                 },
+                opts = {},
             },
-            'saadparwaiz1/cmp_luasnip',
-
-            -- Adds other completion capabilities.
-            --  nvim-cmp does not ship with all sources by default. They are split
-            --  into multiple repos for maintenance purposes.
-            'hrsh7th/cmp-nvim-lsp',
-            'hrsh7th/cmp-path',
-            'hrsh7th/cmp-nvim-lsp-signature-help',
+            'folke/lazydev.nvim',
         },
-        config = function()
-            -- See `:help cmp`
-            local cmp = require 'cmp'
-            local luasnip = require 'luasnip'
-            luasnip.config.setup {}
-
-            cmp.setup {
-                preselect = cmp.PreselectMode.None,
-                snippet = {
-                    expand = function(args)
-                        luasnip.lsp_expand(args.body)
-                    end,
-                },
-                completion = { completeopt = 'menu,menuone,noinsert' },
-
-                -- For an understanding of why these mappings were
-                -- chosen, you will need to read `:help ins-completion`
-                --
+        --- @module 'blink.cmp'
+        --- @type blink.cmp.Config
+        opts = {
+            keymap = {
                 -- No, but seriously. Please read `:help ins-completion`, it is really good!
-                mapping = cmp.mapping.preset.insert {
-                    -- (enabled by default in nvim-cmp)
-                    -- Select the [n]ext item
-                    -- ['<C-n>'] = cmp.mapping.select_next_item(),
-                    -- Select the [p]revious item
-                    -- ['<C-p>'] = cmp.mapping.select_prev_item(),
+                --
+                -- All presets have the following mappings:
+                -- <tab>/<s-tab>: move to right/left of your snippet expansion
+                -- <c-space>: Open menu or open docs if already open
+                -- <c-n>/<c-p> or <up>/<down>: Select next/previous item
+                -- <c-e>: Hide menu
+                -- <c-k>: Toggle signature help
+                --
+                -- See :h blink-cmp-config-keymap for defining your own keymap
+                -- preset = 'default',
 
-                    -- Accept ([y]es) the completion.
-                    --  This will auto-import if your LSP supports it.
-                    --  This will expand snippets if the LSP sent a snippet.
-                    -- ['<C-y>'] = cmp.mapping.confirm { select = true },
+                -- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see:
+                --   https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps
 
-                    -- If you prefer more traditional completion keymaps,
-                    -- you can uncomment the following lines
-                    -- ['<CR>'] = cmp.mapping.confirm { select = true },
-                    ['<Tab>'] = cmp.mapping.select_next_item(),
-                    ['<S-Tab>'] = cmp.mapping.select_prev_item(),
+                -- Удалил все сток бинды и добавил сам что надо
+                -- https://cmp.saghen.dev/configuration/keymap.html
+                preset = 'none',
 
-                    -- Allows Up arrow to fall back without interacting with cmp
-                    ['<Up>'] = cmp.mapping(function(fallback)
-                        cmp.close()
-                        fallback()
-                    end, { 'i', 'c' }),
+                -- Open menu or open docs if already open
+                ['<C-space>'] = { 'show', 'show_documentation', 'hide_documentation' },
+                -- Hide menu
+                ['<C-e>'] = { 'hide' },
+                -- Accept the completion
+                ['<C-y>'] = { 'select_and_accept' },
+                ['<C-Tab>'] = { 'select_and_accept' },
 
-                    -- Allows Up arrow to fall back without interacting with cmp
-                    ['<Down>'] = cmp.mapping(function(fallback)
-                        cmp.close()
-                        fallback()
-                    end, { 'i', 'c' }),
+                -- Select next/previous item
+                ['<Tab>'] = { 'select_next', 'fallback' },
+                ['<S-Tab>'] = { 'select_prev', 'fallback' },
 
-                    -- Scroll the documentation window [b]ack / [f]orward
-                    ['<C-b>'] = cmp.mapping.scroll_docs(-4),
-                    ['<C-f>'] = cmp.mapping.scroll_docs(4),
+                -- Scroll the documentation window [b]ack / [f]orward
+                ['<C-b>'] = { 'scroll_documentation_up', 'fallback' },
+                ['<C-f>'] = { 'scroll_documentation_down', 'fallback' },
 
-                    -- Manually trigger a completion from nvim-cmp.
-                    --  Generally you don't need this, because nvim-cmp will display
-                    --  completions whenever it has completion options available.
-                    ['<C-Space>'] = cmp.mapping.complete {},
+                -- Think of <c-l> as moving to the right of your snippet expansion.
+                --  So if you have a snippet that's like:
+                --  function $name($args)
+                --    $body
+                --  end
+                --
+                -- <c-l> will move you to the right of each of the expansion locations.
+                -- <c-h> is similar, except moving you backwards.
+                ['<C-l>'] = { 'snippet_forward', 'fallback' },
+                ['<C-h>'] = { 'snippet_backward', 'fallback' },
 
-                    -- Think of <c-l> as moving to the right of your snippet expansion.
-                    --  So if you have a snippet that's like:
-                    --  function $name($args)
-                    --    $body
-                    --  end
-                    --
-                    -- <c-l> will move you to the right of each of the expansion locations.
-                    -- <c-h> is similar, except moving you backwards.
-                    ['<C-l>'] = cmp.mapping(function()
-                        if luasnip.expand_or_locally_jumpable() then
-                            luasnip.expand_or_jump()
-                        end
-                    end, { 'i', 's' }),
-                    ['<C-h>'] = cmp.mapping(function()
-                        if luasnip.locally_jumpable(-1) then
-                            luasnip.jump(-1)
-                        end
-                    end, { 'i', 's' }),
+                -- Toggle signature help
+                ['<C-k>'] = { 'show_signature', 'hide_signature', 'fallback' },
+            },
 
-                    -- For more advanced Luasnip keymaps (e.g. selecting choice nodes, expansion) see:
-                    --    https://github.com/L3MON4D3/LuaSnip?tab=readme-ov-file#keymaps
+            appearance = {
+                -- 'mono' (default) for 'Nerd Font Mono' or 'normal' for 'Nerd Font'
+                -- Adjusts spacing to ensure icons are aligned
+                nerd_font_variant = 'mono',
+            },
+
+            completion = {
+                -- By default, you may press `<c-space>` to show the documentation.
+                -- Optionally, set `auto_show = true` to show the documentation after a delay.
+                documentation = { auto_show = false, auto_show_delay_ms = 500 },
+            },
+
+            sources = {
+                default = { 'lsp', 'path', 'snippets', 'lazydev' },
+                providers = {
+                    lazydev = { module = 'lazydev.integrations.blink', score_offset = 100 },
                 },
-                sources = {
-                    {
-                        name = 'lazydev',
-                        -- set group index to 0 to skip loading LuaLS completions as lazydev recommends it
-                        group_index = 0,
-                    },
-                    { name = 'nvim_lsp' },
-                    { name = 'luasnip' },
-                    { name = 'path' },
-                    { name = 'nvim_lsp_signature_help' },
-                },
-            }
-        end,
+            },
+
+            snippets = { preset = 'luasnip' },
+
+            -- Blink.cmp includes an optional, recommended rust fuzzy matcher,
+            -- which automatically downloads a prebuilt binary when enabled.
+            --
+            -- By default, we use the Lua implementation instead, but you may enable
+            -- the rust implementation via `'prefer_rust_with_warning'`
+            --
+            -- See :h blink-cmp-config-fuzzy for more information
+            fuzzy = { implementation = 'lua' },
+
+            -- Shows a signature help window while you type arguments for a function
+            signature = { enabled = true },
+        },
     },
 }

nvim/lua/kickstart/plugins/lsp.lua

@@ -27,8 +27,8 @@ return {
             -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})`
             { 'j-hui/fidget.nvim', opts = {} },
 
-            -- Allows extra capabilities provided by nvim-cmp
-            'hrsh7th/cmp-nvim-lsp',
+            -- Allows extra capabilities provided by blink.cmp
+            'saghen/blink.cmp',
         },
         config = function()
             -- Brief aside: **What is LSP?**
@@ -73,43 +73,57 @@ return {
                         vim.keymap.set(mode, keys, func, { buffer = event.buf, desc = 'LSP: ' .. desc })
                     end
 
-                    -- Jump to the definition of the word under your cursor.
-                    --  This is where a variable was first declared, or where a function is defined, etc.
-                    --  To jump back, press <C-t>.
-                    map('gd', require('telescope.builtin').lsp_definitions, '[G]oto [D]efinition')
+                    -- Rename the variable under your cursor.
+                    --  Most Language Servers support renaming across files, etc.
+                    map('grn', vim.lsp.buf.rename, '[R]e[n]ame')
+
+                    -- Execute a code action, usually your cursor needs to be on top of an error
+                    -- or a suggestion from your LSP for this to activate.
+                    map('gra', vim.lsp.buf.code_action, '[G]oto Code [A]ction', { 'n', 'x' })
 
                     -- Find references for the word under your cursor.
-                    map('gr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')
+                    map('grr', require('telescope.builtin').lsp_references, '[G]oto [R]eferences')
 
                     -- Jump to the implementation of the word under your cursor.
                     --  Useful when your language has ways of declaring types without an actual implementation.
-                    map('gI', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation')
+                    map('gri', require('telescope.builtin').lsp_implementations, '[G]oto [I]mplementation')
+
+                    -- Jump to the definition of the word under your cursor.
+                    --  This is where a variable was first declared, or where a function is defined, etc.
+                    --  To jump back, press <C-t>.
+                    map('grd', require('telescope.builtin').lsp_definitions, '[G]oto [D]efinition')
+
+                    -- WARN: This is not Goto Definition, this is Goto Declaration.
+                    -- For example, in C this would take you to the header.
+                    map('grD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')
+
+                    -- Fuzzy find all the symbols in your current document.
+                    --  Symbols are things like variables, functions, types, etc.
+                    map('gO', require('telescope.builtin').lsp_document_symbols, 'Open Document Symbols')
+                    --  Было <leader>ds [D]ocument [S]ymbols
+                    -- map('<leader>ss', require('telescope.builtin').lsp_document_symbols, 'Document [S]ymbols')
+
+                    -- Fuzzy find all the symbols in your current workspace.
+                    --  Similar to document symbols, except searches over your entire project.
+                    map('gW', require('telescope.builtin').lsp_dynamic_workspace_symbols, 'Open Workspace Symbols')
 
                     -- Jump to the type of the word under your cursor.
                     --  Useful when you're not sure what type a variable is and you want to see
                     --  the definition of its *type*, not where it was *defined*.
-                    map('<leader>D', require('telescope.builtin').lsp_type_definitions, 'Type [D]efinition')
+                    map('grt', require('telescope.builtin').lsp_type_definitions, '[G]oto [T]ype Definition')
 
-                    -- Fuzzy find all the symbols in your current document.
-                    --  Symbols are things like variables, functions, types, etc.
-                    --  Было <leader>ds [D]ocument [S]ymbols
-                    map('<leader>ss', require('telescope.builtin').lsp_document_symbols, 'Document [S]ymbols')
-
-                    -- Fuzzy find all the symbols in your current workspace.
-                    --  Similar to document symbols, except searches over your entire project.
-                    map('<leader>ws', require('telescope.builtin').lsp_dynamic_workspace_symbols, '[W]orkspace [S]ymbols')
-
-                    -- Rename the variable under your cursor.
-                    --  Most Language Servers support renaming across files, etc.
-                    map('<leader>rn', vim.lsp.buf.rename, '[R]e[n]ame')
-
-                    -- Execute a code action, usually your cursor needs to be on top of an error
-                    -- or a suggestion from your LSP for this to activate.
-                    map('<leader>ca', vim.lsp.buf.code_action, '[C]ode [A]ction', { 'n', 'x' })
-
-                    -- WARN: This is not Goto Definition, this is Goto Declaration.
-                    --  For example, in C this would take you to the header.
-                    map('gD', vim.lsp.buf.declaration, '[G]oto [D]eclaration')
+                    -- This function resolves a difference between neovim nightly (version 0.11) and stable (version 0.10)
+                    ---@param client vim.lsp.Client
+                    ---@param method vim.lsp.protocol.Method
+                    ---@param bufnr? integer some lsp support methods only in specific files
+                    ---@return boolean
+                    local function client_supports_method(client, method, bufnr)
+                        if vim.fn.has 'nvim-0.11' == 1 then
+                            return client:supports_method(method, bufnr)
+                        else
+                            return client.supports_method(method, { bufnr = bufnr })
+                        end
+                    end
 
                     -- The following two autocommands are used to highlight references of the
                     -- word under your cursor when your cursor rests there for a little while.
@@ -117,7 +131,8 @@ return {
                     --
                     -- When you move your cursor, the highlights will be cleared (the second autocommand).
                     local client = vim.lsp.get_client_by_id(event.data.client_id)
-                    if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_documentHighlight) then
+                    -- if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_documentHighlight) then
+                    if client and client_supports_method(client, vim.lsp.protocol.Methods.textDocument_documentHighlight, event.buf) then
                         local highlight_augroup = vim.api.nvim_create_augroup('kickstart-lsp-highlight', { clear = false })
                         vim.api.nvim_create_autocmd({ 'CursorHold', 'CursorHoldI' }, {
                             buffer = event.buf,
@@ -144,7 +159,8 @@ return {
                     -- code, if the language server you are using supports them
                     --
                     -- This may be unwanted, since they displace some of your code
-                    if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
+                    -- if client and client.supports_method(vim.lsp.protocol.Methods.textDocument_inlayHint) then
+                    if client and client_supports_method(client, vim.lsp.protocol.Methods.textDocument_inlayHint, event.buf) then
                         map('<leader>th', function()
                             vim.lsp.inlay_hint.enable(not vim.lsp.inlay_hint.is_enabled { bufnr = event.buf })
                         end, '[T]oggle Inlay [H]ints')
@@ -164,10 +180,9 @@ return {
 
             -- LSP servers and clients are able to communicate to each other what features they support.
             --  By default, Neovim doesn't support everything that is in the LSP specification.
-            --  When you add nvim-cmp, luasnip, etc. Neovim now has *more* capabilities.
-            --  So, we create new capabilities with nvim cmp, and then broadcast that to the servers.
-            local capabilities = vim.lsp.protocol.make_client_capabilities()
-            capabilities = vim.tbl_deep_extend('force', capabilities, require('cmp_nvim_lsp').default_capabilities())
+            --  When you add blink.cmp, luasnip, etc. Neovim now has *more* capabilities.
+            --  So, we create new capabilities with blink.cmp, and then broadcast that to the servers.
+            local capabilities = require('blink.cmp').get_lsp_capabilities()
 
             -- Enable the following language servers
             --  Feel free to add/remove any LSPs that you want here. They will automatically be installed.
@@ -322,6 +337,8 @@ return {
             require('mason-tool-installer').setup { ensure_installed = ensure_installed }
 
             require('mason-lspconfig').setup {
+                ensure_installed = {}, -- explicitly set to an empty table (Kickstart populates installs via mason-tool-installer)
+                automatic_installation = false,
                 handlers = {
                     function(server_name)
                         local server = servers[server_name] or {}

nvim/lua/kickstart/plugins/telescope.lua

@@ -11,7 +11,6 @@ return {
     {
         'nvim-telescope/telescope.nvim',
         event = 'VimEnter',
-        branch = '0.1.x',
         dependencies = {
             'nvim-lua/plenary.nvim',
             { -- If encountering errors, see telescope-fzf-native README for installation instructions

nvim/lua/kickstart/plugins/which-key.lua

@@ -59,12 +59,12 @@ return {
 
             -- Document existing key chains
             spec = {
-                { '<leader>c', group = '[C]ode', mode = { 'n', 'x' } },
+                -- { '<leader>c', group = '[C]ode', mode = { 'n', 'x' } },
                 -- { '<leader>d', group = '[D]ocument' },
-                { '<leader>r', group = '[R]ename' },
+                -- { '<leader>r', group = '[R]ename' },
                 { '<leader>s', group = '[S]earch' },
                 { '<leader>S', group = '[S]ession' },
-                { '<leader>w', group = '[W]orkspace' },
+                -- { '<leader>w', group = '[W]orkspace' },
                 { '<leader>t', group = '[T]oggle' },
                 { '<leader>g', group = '[G]olang' },
                 { '<leader>gt', group = '[G]olang [T]ag' },

nvim/lua/kickstart/settings.lua

@@ -45,6 +45,12 @@ vim.api.nvim_create_autocmd('FileType', {
     end,
 })
 
+-- Fix .sqlfluff highlight
+vim.api.nvim_create_autocmd({ 'BufRead', 'BufNewFile' }, {
+    pattern = '*.sqlfluff',
+    command = 'set filetype=toml',
+})
+
 -- Enable mouse mode, can be useful for resizing splits for example!
 vim.opt.mouse = 'a'
 
@@ -130,6 +136,11 @@ vim.opt.cursorline = true
 -- Minimal number of screen lines to keep above and below the cursor.
 vim.opt.scrolloff = 10
 
+-- if performing an operation that would fail due to unsaved changes in the buffer (like `:q`),
+-- instead raise a dialog asking if you wish to save the current file(s)
+-- See `:help 'confirm'`
+-- vim.opt.confirm = true
+
 -- [[ Basic Keymaps ]]
 --  See `:help vim.keymap.set()`
 
@@ -168,6 +179,12 @@ vim.keymap.set('n', '<C-Right>', '<C-w><C-l>', { desc = 'Move focus to the right
 vim.keymap.set('n', '<C-Down>', '<C-w><C-j>', { desc = 'Move focus to the lower window' })
 vim.keymap.set('n', '<C-Up>', '<C-w><C-k>', { desc = 'Move focus to the upper window' })
 
+-- NOTE: Some terminals have colliding keymaps or are not able to send distinct keycodes
+-- vim.keymap.set("n", "<C-S-h>", "<C-w>H", { desc = "Move window to the left" })
+-- vim.keymap.set("n", "<C-S-l>", "<C-w>L", { desc = "Move window to the right" })
+-- vim.keymap.set("n", "<C-S-j>", "<C-w>J", { desc = "Move window to the lower" })
+-- vim.keymap.set("n", "<C-S-k>", "<C-w>K", { desc = "Move window to the upper" })
+
 -- [[ Basic Autocommands ]]
 --  See `:help lua-guide-autocommands`