diff --git a/lua/plugins/completions.lua b/lua/plugins/completions.lua new file mode 100644 index 0000000..3005caa --- /dev/null +++ b/lua/plugins/completions.lua @@ -0,0 +1,27 @@ +return { + { + "saghen/blink.cmp", + dependencies = { + "rafamadriz/friendly-snippets", + }, + version = "1.*", + + ---@module "blink.cmp" + ---@type blink.cmp.Config + opts = { + keymap = { + preset = "super-tab", + auto_show_delay_ms = 500, + }, + appearance = { + nerd_font_variant = "mono" + }, + completion = { documentation = { auto_show = false } }, + sources = { + default = { "lsp", "path", "snippets", "buffer" }, + }, + fuzzy = { implementation = "prefer_rust_with_warning" } + }, + opts_extend = { "sources.default" } + } +} diff --git a/lua/plugins/extras.lua b/lua/plugins/extras.lua index 2732e71..6ca608d 100644 --- a/lua/plugins/extras.lua +++ b/lua/plugins/extras.lua @@ -20,7 +20,6 @@ return { -- Non programming quality of life utilities go here }, }, completion = { - nvim_cmp = true, min_chars = 2, }, }, diff --git a/lua/plugins/lsp.lua b/lua/plugins/lsp.lua index 467cd4e..cd19260 100644 --- a/lua/plugins/lsp.lua +++ b/lua/plugins/lsp.lua @@ -6,46 +6,10 @@ return { -- LSP Config should be a standalone function, hence this module "williamboman/mason.nvim", "williamboman/mason-lspconfig.nvim", "WhoIsSethDaniel/mason-tool-installer.nvim", - - -- Useful status updates for LSP. - -- NOTE: `opts = {}` is the same as calling `require('fidget').setup({})` - { "j-hui/fidget.nvim", opts = {} }, - - -- `neodev` configures Lua LSP for your Neovim config, runtime and plugins - -- used for completion, annotations and signatures of Neovim apis + { "j-hui/fidget.nvim", opts = {} }, -- Useful status updates for LSP. { "folke/neodev.nvim", opts = {} }, }, config = function() - -- Brief Aside: **What is LSP?** - -- - -- LSP is an acronym you've probably heard, but might not understand what it is. - -- - -- LSP stands for Language Server Protocol. It's a protocol that helps editors - -- and language tooling communicate in a standardized fashion. - -- - -- In general, you have a "server" which is some tool built to understand a particular - -- language (such as `gopls`, `lua_ls`, `rust_analyzer`, etc). These Language Servers - -- (sometimes called LSP servers, but that's kind of like ATM Machine) are standalone - -- processes that communicate with some "client" - in this case, Neovim! - -- - -- LSP provides Neovim with features like: - -- - Go to definition - -- - Find references - -- - Autocompletion - -- - Symbol Search - -- - and more! - -- - -- Thus, Language Servers are external tools that must be installed separately from - -- Neovim. This is where `mason` and related plugins come into play. - -- - -- If you're wondering about lsp vs treesitter, you can check out the wonderfully - -- and elegantly composed help section, `:help lsp-vs-treesitter` - - -- This function gets run when an LSP attaches to a particular buffer. - -- That is to say, every time a new file is opened that is associated with - -- an lsp (for example, opening `main.rs` is associated with `rust_analyzer`) this - -- function will be executed to configure the current buffer - require("mason").setup({ PATH = "append", }) @@ -53,12 +17,6 @@ return { -- LSP Config should be a standalone function, hence this module vim.api.nvim_create_autocmd("LspAttach", { group = vim.api.nvim_create_augroup("kickstart-lsp-attach", { clear = true }), callback = function(event) - -- NOTE: Remember that lua is a real programming language, and as such it is possible - -- to define small helper and utility functions so you don't have to repeat yourself - -- many times. - -- - -- In this case, we create a function that lets us more easily define mappings specific - -- for LSP related items. It sets the mode, buffer and description for us each time. local map = function(keys, func, desc) vim.keymap.set( "n", @@ -67,69 +25,33 @@ return { -- LSP Config should be a standalone function, hence this module { 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 . map("gd", require("telescope.builtin").lsp_definitions, "[G]oto [D]efinition") - - -- Find references for the word under your cursor. map("gr", 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" ) - - -- 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( "D", require("telescope.builtin").lsp_type_definitions, "Type [D]efinition" ) - - -- Fuzzy find all the symbols in your current document. - -- Symbols are things like variables, functions, types, etc. map( "gs", require("telescope.builtin").lsp_document_symbols, "[G]oto [S]ymbols" ) - - -- Fuzzy find all the symbols in your current workspace - -- Similar to document symbols, except searches over your whole project. map( "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("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("ca", vim.lsp.buf.code_action, "[C]ode [A]ction") - - -- Opens a popup that displays documentation about the word under your cursor - -- See `:help K` for why this keymap map("K", vim.lsp.buf.hover, "Hover Documentation") - - -- 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") - -- The following two autocommands are used to highlight references of the - -- word under your cursor when your cursor rests there for a little while. - -- See `:help CursorHold` for information about when this is executed - -- - -- 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.server_capabilities.documentHighlightProvider then vim.api.nvim_create_autocmd({ "CursorHold", "CursorHoldI" }, { @@ -145,79 +67,20 @@ return { -- LSP Config should be a standalone function, hence this module end, }) - -- 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() - ) - - -- Enable the following language servers - -- Feel free to add/remove any LSPs that you want here. They will automatically be installed. - -- - -- Add any additional override configuration in the following tables. Available keys are: - -- - cmd (table): Override the default command used to start the server - -- - filetypes (table): Override the default list of associated filetypes for the server - -- - capabilities (table): Override fields in capabilities. Can be used to disable certain LSP features. - -- - settings (table): Override the default settings passed when initializing the server. - -- For example, to see the options for `lua_ls`, you could go to: https://luals.github.io/wiki/settings/ local servers = { - -- clangd = {}, - -- gopls = {}, - -- pyright = {}, - -- rust_analyzer = {}, - -- ... etc. See `:help lspconfig-all` for a list of all the pre-configured LSPs - -- - -- Some languages (like typescript) have entire language plugins that can be useful: - -- https://github.com/pmizio/typescript-tools.nvim - -- - -- But for many setups, the LSP (`tsserver`) will work just fine - -- tsserver = {}, - -- - lua_ls = { - -- cmd = {...}, - -- filetypes { ...}, - -- capabilities = {}, - settings = { - Lua = { - completion = { - callSnippet = "Replace", - }, - -- You can toggle below to ignore Lua_LS's noisy `missing-fields` warnings - -- diagnostics = { disable = { 'missing-fields' } }, - }, - }, + settings = { Lua = { completion = { callSnippet = "Replace" } } }, }, } - -- Ensure the servers and tools above are installed - -- To check the current status of installed tools and/or manually install - -- other tools, you can run - -- :Mason - -- - -- You can press `g?` for help in this menu require("mason").setup() - - -- You can add other tools here that you want Mason to install - -- for you, so that they are available from within Neovim. local ensure_installed = vim.tbl_keys(servers or {}) - -- vim.list_extend(ensure_installed, { - -- "stylua", -- Used to format lua code - -- }) require("mason-tool-installer").setup({ ensure_installed = ensure_installed }) - require("mason-lspconfig").setup({ handlers = { function(server_name) local server = servers[server_name] or {} - -- This handles overriding only values explicitly passed - -- by the server configuration above. Useful when disabling - -- certain features of an LSP (for example, turning off formatting for tsserver) server.capabilities = vim.tbl_deep_extend( "force", {}, @@ -230,7 +93,6 @@ return { -- LSP Config should be a standalone function, hence this module }) end, }, - -- Finally: add language and filetype specific plugins { "fladson/vim-kitty", ft = "kitty" }, { "scallop-lang/vim-scallop", ft = "scallop" }, } diff --git a/lua/plugins/utils.lua b/lua/plugins/utils.lua index 7bd6771..bc3effe 100644 --- a/lua/plugins/utils.lua +++ b/lua/plugins/utils.lua @@ -58,10 +58,6 @@ return { -- General programming utilities go here end, keys = require("config.keys").harpoon, }, - -- Snippets - "SirVer/ultisnips", - "honza/vim-snippets", - "rafamadriz/friendly-snippets", { -- Package and devenv plugins "danymat/neogen", event = "VimEnter", @@ -101,98 +97,6 @@ return { -- General programming utilities go here }, }, }, - { -- Autocompletion - "hrsh7th/nvim-cmp", - event = "InsertEnter", - dependencies = { - -- Snippet Engine & its associated nvim-cmp source - { - "L3MON4D3/LuaSnip", - build = (function() - -- Build Step is needed for regex support in snippets - -- This step is not supported in many windows environments - -- Remove the below condition to re-enable on windows - if vim.fn.has("win32") == 1 or vim.fn.executable("make") == 0 then - return - end - return "make install_jsregexp" - end)(), - }, - "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", - - -- If you want to add a bunch of pre-configured snippets, - -- you can use this plugin to help you. It even has snippets - -- for various frameworks/libraries/etc. but you will have to - -- set up the ones that are useful for you. - -- 'rafamadriz/friendly-snippets', - }, - config = function() - -- See `:help cmp` - local cmp = require("cmp") - local luasnip = require("luasnip") - luasnip.config.setup({}) - - cmp.setup({ - 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` - -- - -- No, but seriously. Please read `:help ins-completion`, it is really good! - mapping = cmp.mapping.preset.insert({ - -- Select the [n]ext item - [""] = cmp.mapping.select_next_item(), - -- Select the [p]revious item - [""] = cmp.mapping.select_prev_item(), - - -- Accept ([y]es) the completion. - -- This will auto-import if your LSP supports it. - -- This will expand snippets if the LSP sent a snippet. - [""] = cmp.mapping.confirm({ select = true }), - - -- 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. - [""] = cmp.mapping.complete({}), - - -- Think of as moving to the right of your snippet expansion. - -- So if you have a snippet that's like: - -- function $name($args) - -- $body - -- end - -- - -- will move you to the right of each of the expansion locations. - -- is similar, except moving you backwards. - [""] = cmp.mapping(function() - if luasnip.expand_or_locally_jumpable() then - luasnip.expand_or_jump() - end - end, { "i", "s" }), - [""] = cmp.mapping(function() - if luasnip.locally_jumpable(-1) then - luasnip.jump(-1) - end - end, { "i", "s" }), - }), - sources = { - { name = "nvim_lsp" }, - { name = "luasnip" }, - { name = "path" }, - }, - }) - end, - }, { -- Highlight, edit, and navigate code "nvim-treesitter/nvim-treesitter", build = ":TSUpdate",