How can i enable rust-analyzer in a single-file rust project with only using neovim lsp

[KisNJ]

When using this plugin the lsp works with files that aren't in a cargo project. However when using only the built-in lsp the rust-analyzer won't work on non-project files. My question that how can i replicate the plugins behavior with only the built-in lsp.

In the source code i found a few lines that indicate which options the plugin sets (standalone = true,

 if not root_dir then
    --- No project root found. Start in detached/standalone mode.
    lsp_start_config.init_options = { detachedFiles = { vim.api.nvim_buf_get_name(bufnr) } }
  end

), but i still can't find the exact property i need.

My config:

["rust_analyzer"] = function()
	local lspconfig = require("lspconfig")
	lspconfig.rust_analyzer.setup({
		capabilities = capabilities,
		on_attach = on_attach,
		settings = {
			cargo = {
				allFeatures = true,
				loadOutDirsFromCheck = true,
				runBuildScripts = true,
			},
			-- Add clippy lints for Rust.
			checkOnSave = {
				allFeatures = true,
				command = "clippy",
				extraArgs = { "--no-deps" },
			},
		},
	})
end,

What properties do i need to add to capabilities or to settings, to enable "standalone" mode with neovim's lsp?

[mrcjkb]

Hey 👋

However when using only the built-in lsp

To clarify, this plugin uses Neovim's built-in LSP client. It just doesn't go through lspconfig to do so.

but i still can't find the exact property i need

If you're using lspconfig, you should be able to pass init_options as a field of the table you pass to lspconfig.rust_analyzer.setup.

A problem with lspconfig's setup approach is that it is called before you open any rust files. So there's no way to determine the file name you need to pass into the detached_files list.

You can, however, directly call vim.lsp.start in a ftplugin/rust.lua file (see :h ftplugin), where your can determine the file name.
You'd have to make sure it doesn't conflict with the lspconfig client though.
This is how it was done in rust-tools.nvim.

Related: neovim/nvim-lspconfig#1854

[KisNJ]

Thank you, the links for vim.lsp.start and the rust-tools.nvim implementaions were really helpful, i found a hacky way to initialize rust-analyzer with a keybind, maybe i could do an autocmd. I'll post the code later.

[KisNJ]

I created in my ~/.config/nvim/after/ftplugin/ directory a rust.lua file and inside I put

local capabilities = vim.tbl_deep_extend(
	"force",
	{},
	vim.lsp.protocol.make_client_capabilities(),
	require("cmp_nvim_lsp").default_capabilities()
)

vim.keymap.set("n", "<leader>sa", function()
	if not next(vim.lsp.get_clients()) then
		local config = {
			root_dir = vim.fn.expand("%s:h"),
			capabilities = capabilities,
			cmd = { "rust-analyzer" },
			filetypes = { "rust" },
			init_options = { detachedFiles = { vim.api.nvim_buf_get_name(0) } },
			name = "rust_analyzer-standalone",
		}
		vim.lsp.start(config)
	end
end)

This code will create a keymap for rust file and enables rust_analyzer in detached mode if there is no other lsp running.

Does anyone whether the rust_analyzer docs state somwhere the existance of detachedFiles in init_options (the Lsp reference only says that the type of initializeOptions is LspAny)?

[mrcjkb]

I don't think it's documented, no.
But it's definitely specific to rust-analyzer (LspAny means language servers can implement their own non-standard spec), which is why lspconfig doesn't support it.

[Andrew15-5]

I am shocked that this feature doesn't work out of the box, and a lot of people say that it works (but how?). And it's mostly VS Coders, which wasn't helpful at all. This solution actually did work, but I don't like the idea of triggering a keymap for something that should "just work". So I spend a bit of time and created another workaround that works as expected on cargo/single-file Rust projects, so it is good enough for me.

snippet

-- Standalone file mode
local default_config = require "plugins.configs.lspconfig"
local capabilities = default_config.capabilities
local standalone_config = {
  root_dir = vim.fn.expand "%s:h",
  capabilities = capabilities,
  cmd = { "rust-analyzer" },
  filetypes = { "rust" },
  init_options = { detachedFiles = { vim.api.nvim_buf_get_name(0) } },
  name = "rust-analyzer-standalone",
}

---@param list table list of items
---@param f function function that is called with each list's item and returns bool
---@return boolean `true` if any call of `f` returned `true`, `false` otherwise.
local function any(list, f)
  for _, client in ipairs(list) do
    if f(client) then
      return true
    end
  end
  return false
end

local timer = vim.loop.new_timer()
timer:start(
  100, -- delay
  100, -- repeat interval
  vim.schedule_wrap(function()
    if timer:is_closing() then
      return
    end
    local clients = vim.lsp.get_active_clients { bufnr = 0 }
    local client_name = standalone_config.name
    if #clients == 0 then
      return
    end
    -- If standalone file mode was already enabled.
    if
      any(clients, function(client)
        return client.name == client_name
      end)
    then
      timer:close()
      return
    end
    for _, client in ipairs(clients) do
      if client.name == "rust-analyzer" then
        -- If client is not in the standalone file mode.
        if client.workspace_folders ~= nil then
          timer:close()
          return
        end
        client.stop()
      end
    end
    vim.lsp.start(standalone_config)
  end)
)

I'm using nvchad config and put this snippet into the custom config file for this plugin:

  {
    "mrcjkb/rustaceanvim",
    -- enabled = false,
    version = "^3", -- Recommended
    dependencies = {
      "mfussenegger/nvim-dap",
      "neovim/nvim-lspconfig",
      { -- For Neovim < 0.10
        "lvimuser/lsp-inlayhints.nvim",
        init = function()
          -- vim.api.nvim_set_hl(0, "InlayHint", { fg = "#C3A369" })
          vim.api.nvim_set_hl(0, "InlayHint", { fg = "#A68B59" })
        end,
        -- opts = { inlay_hints = { highlight = "Type" } },
        opts = { inlay_hints = { highlight = "InlayHint" } },
      },
    },
    ft = { "rust" },
    config = function()
      require "custom.configs.rustaceanvim"
    end,
  },

And now when I open cargo project it just doesn't do anything, and when I open single-file project it removes the default useless rust-analyzer and creates the new one if wasn't already created.

[mrcjkb]

@Andrew15-5 thanks for your solution.

Regarding:

I am shocked that this feature doesn't work out of the box

I've played around with similar solutions in rustaceanvim, but decided not to add them, because they all have some quirks.

Some examples:

• Stopping the rustaceanvim LSP client is problematic if it's already attached to a cargo project, as it will need to be restarted when switching back to a buffer from that project. This is especially tedious if the cargo project is large.
• I've tried playing around with automatically restarting the client when switching buffers. This seems to work alright when switching between detached files, but not with cargo projects.

So I decided it's probably best to wait for a proper solution in rust-analyzer.

I just recently pushed a fix for a bug where it falsely identifies the project root of standalone files as the current project root if the current cwd is a cargo project. So I might pick this up again soon. No promises though 😃