rust analyzer issues: not showing completion

[esn89]

Make sure you have done the following

• I have updated to the latest version of blink.cmp
• I have read the README

Bug Description

For LS like pyright, lua_ls and gopls autocomplete suggestions work.

Except rust-analyzer. Which I have installed via rustup.

Relevant configuration

lspconfig['rust_analyzer'].setup({
            capabilities = capabilities,
            settings = {
                ['rust-analyzer'] = {
                    check = {
                        command = 'clippy',
                    },
                    imports = {
                        granularity = {
                            group = 'module',
                        },
                        prefix = 'self',
                    },
                    cargo = {
                        buildScripts = {
                            enable = true,
                        },
                    },
                    procMacro = {
                        enable = true,
                    },
                },
            },
        })

return {
    'saghen/blink.cmp',
    dependencies = {
    },
    lazy = false,
    version = 'v0.*',
    opts = {
        keymap = { preset = 'enter' },
        completion = {
            keyword = {
                range = 'full',
                exclude_from_prefix_regex = '[\\-]',
            },

            trigger = {
                show_in_snippet = true,
                show_on_keyword = true,
                show_on_trigger_character = true,
                show_on_blocked_trigger_characters = { ' ', '\n', '\t' },
                show_on_accept_on_trigger_character = true,
                show_on_insert_on_trigger_character = true,
                show_on_x_blocked_trigger_characters = { "'", '"', '(' },
            },

            list = {
                max_items = 200,
                selection = 'auto_insert',
                cycle = {
                    from_bottom = true,
                    from_top = true,
                },
            },

            accept = {
                create_undo_point = true,
                auto_brackets = {
                    enabled = true,
                    default_brackets = { '(', ')' },
                    override_brackets_for_filetypes = {},
                    kind_resolution = {
                        enabled = true,
                        blocked_filetypes = { 'typescriptreact', 'javascriptreact', 'vue' },
                    },
                    semantic_token_resolution = {
                        enabled = true,
                        blocked_filetypes = {},
                        timeout_ms = 400,
                    },
                },
            },

            menu = {
                enabled = true,
                min_width = 15,
                max_height = 10,
                border = 'rounded',
                winblend = vim.o.pumblend,
                scrolloff = 2,
                scrollbar = true,
                direction_priority = { 's', 'n' },
                draw = {
                    padding = 1,
                    gap = 1,

                    columns = { { 'kind_icon' }, { 'label', 'label_description', gap = 1 } },

                    components = {
                        kind_icon = {
                            ellipsis = false,
                            text = function(ctx)
                                return ctx.kind_icon .. ctx.icon_gap
                            end,
                            highlight = function(ctx)
                                return require('blink.cmp.completion.windows.render.tailwind').get_hl(ctx)
                                    or 'BlinkCmpKind' .. ctx.kind
                            end,
                        },

                        kind = {
                            ellipsis = false,
                            width = { fill = true },
                            text = function(ctx)
                                return ctx.kind
                            end,
                            highlight = function(ctx)
                                return require('blink.cmp.completion.windows.render.tailwind').get_hl(ctx)
                                    or 'BlinkCmpKind' .. ctx.kind
                            end,
                        },

                        label = {
                            width = { fill = true, max = 60 },
                            text = function(ctx)
                                return ctx.label .. ctx.label_detail
                            end,
                            highlight = function(ctx)
                                local highlights = {
                                    {
                                        0,
                                        #ctx.label,
                                        group = ctx.deprecated and 'BlinkCmpLabelDeprecated' or 'BlinkCmpLabel',
                                    },
                                }
                                if ctx.label_detail then
                                    table.insert(
                                        highlights,
                                        { #ctx.label, #ctx.label + #ctx.label_detail, group = 'BlinkCmpLabelDetail' }
                                    )
                                end

                                for _, idx in ipairs(ctx.label_matched_indices) do
                                    table.insert(highlights, { idx, idx + 1, group = 'BlinkCmpLabelMatch' })
                                end

                                return highlights
                            end,
                        },

                        label_description = {
                            width = { max = 30 },
                            text = function(ctx)
                                return ctx.label_description
                            end,
                            highlight = 'BlinkCmpLabelDescription',
                        },

                        source_name = {
                            width = { max = 30 },
                            text = function(ctx)
                                return ctx.source_name
                            end,
                            highlight = 'BlinkCmpSource',
                        },
                    },
                },
            },

            documentation = {
                auto_show = true,
                auto_show_delay_ms = 500,
                update_delay_ms = 50,
                treesitter_highlighting = true,
                window = {
                    min_width = 10,
                    max_width = 60,
                    max_height = 20,
                    border = 'rounded',
                    winblend = vim.o.pumblend,
                    scrollbar = true,
                    direction_priority = {
                        menu_north = { 'e', 'w', 'n', 's' },
                        menu_south = { 'e', 'w', 's', 'n' },
                    },
                },
            },
            ghost_text = {
                enabled = false,
            },
        },

        signature = {
            enabled = true,
            trigger = {
                blocked_trigger_characters = {},
                blocked_retrigger_characters = {},
                show_on_insert_on_trigger_character = true,
            },
            window = {
                min_width = 1,
                max_width = 100,
                max_height = 10,
                border = 'rounded',
                winblend = vim.o.pumblend,
                direction_priority = { 'n', 's' },
                treesitter_highlighting = true,
            },
        },

        fuzzy = {
            use_typo_resistance = true,
            use_frecency = true,
            use_proximity = true,
            max_items = 200,
            sorts = { 'label', 'kind', 'score' },

            prebuilt_binaries = {
                download = true,
                force_version = nil,
                force_system_triple = nil,
            },
        },

        sources = {
            completion = {
                enabled_providers = { 'lsp', 'path', 'buffer' },
            },

            providers = {
                lsp = {
                    name = 'LSP',
                    module = 'blink.cmp.sources.lsp',

                },
                path = {
                    name = 'Path',
                    module = 'blink.cmp.sources.path',
                    score_offset = 3,
                    opts = {
                        trailing_slash = false,
                        label_trailing_slash = true,
                        get_cwd = function(context)
                            return vim.fn.expand(('#%d:p:h'):format(context.bufnr))
                        end,
                        show_hidden_files_by_default = false,
                    },
                },
                buffer = {
                    name = 'Buffer',
                    module = 'blink.cmp.sources.buffer',
                    fallback_for = { 'lsp' },
                    opts = {
                        get_bufnrs = function()
                            return vim.iter(vim.api.nvim_list_wins())
                                :map(function(win)
                                    return vim.api.nvim_win_get_buf(win)
                                end)
                                :filter(function(buf)
                                    return vim.bo[buf].buftype ~= 'nofile'
                                end)
                                :totable()
                        end,
                    },
                },
            },
        },
    },
}

:LspInfo:

lspconfig: require("lspconfig.health").check()

LSP configs active in this session (globally) ~
- Configured servers: gopls, basedpyright, rust_analyzer, yamlls, helm_ls, lua_ls, terraformls
- OK Deprecated servers: (none)

LSP configs active in this buffer (bufnr: 5) ~
- Language client log: ~/.local/state/nvim/lsp.log
- Detected filetype: `rust`
- 1 client(s) attached to this buffer
- Client: `rust_analyzer` (id: 1, bufnr: [5])
  root directory:    ~/rust/advent_day6/
  filetypes:         rust
  cmd:               ~/.cargo/bin/rust-analyzer
  version:           `rust-analyzer 1.83.0 (90b35a62 2024-11-26)`
  executable:        true
  autostart:         true

Docs for active configs: ~
- rust_analyzer docs: >markdown
  
  https://github.com/rust-lang/rust-analyzer
  
  rust-analyzer (aka rls 2.0), a language server for Rust
  
  
  See [docs](https://github.com/rust-lang/rust-analyzer/blob/master/docs/user/generated_config.adoc) for extra settings. The settings can be used like this:
  ```lua
  require'lspconfig'.rust_analyzer.setup{
    settings = {
      ['rust-analyzer'] = {
        diagnostics = {
          enable = false;
        }
      }
    }
  }

Note: do not set init_options for this LS config, it will be automatically populated by the contents of settings["rust-analyzer"] per
https://github.com/rust-lang/rust-analyzer/blob/eb5da56d839ae0a9e9f50774fa3eb78eb0964550/docs/dev/lsp-extensions.md?plain=1#L26.

neovim version

NVIM v0.10.2 Build type: Release LuaJIT 2.1.1720049189

blink.cmp version: branch, tag, or commit

v0.*

[Saghen]

This seems to be an issue with your configuration so I moved it to a discussion. I use rustaceanvim personally, but maybe someone using rust-analyzer directly can post their configuration

{
  'mrcjkb/rustaceanvim',
  ft = 'rust',
  dependencies = { 'saghen/blink.cmp' },
  init = function()
    vim.g.rustaceanvim = {
      server = {
        capabilities = require('blink.cmp').get_lsp_capabilities(),
      },
    }
  end,
},

[GiyoMoon]

@esn89 I'm using rust-analyzer which is configured with lspconfig. You probably forgot to get the capabilities from blink.cmp:

local capabilities = require("blink.cmp").get_lsp_capabilities()

If you want to include the default nvim capabilities, you can pass true as the second param: get_lsp_capabilities(nil, true)

[esn89]

I got that capabilities part :)

What's weirder now is that, between opening this issue and now, nothing has changed, but now the autocomplete is working the way it should!