Best method of changing target during runtime?

[FlippingBinary]

Hello all! I'm migrating over from simrat39/rust-tools.nvim and trying to replicate something I was doing before. I'm actually not sure if it was the best approach, but it was working.

Within a single rust workspace, I'm sometimes looking at it in terms of building for wasm32-unknown-unknown and other times for x86_64-unknown-linux-gnu. This involves different dependencies and other conditional compilation options. To switch rust-analyzer to a different target, I had keymaps configured that would call custom functions for setting or printing the current target.

Here are those functions:

local lspconfig = require("lspconfig")

-- This function makes it easy to switch the build target during runtime
local function set_rust_target(target)
  lspconfig.rust_analyzer.setup(vim.tbl_deep_extend("force", lspconfig.rust_analyzer.manager.config, {
    settings = {
      ["rust-analyzer"] = {
        cargo = {
          target = target,
        },
      },
    },
  }))
end

local function print_rust_target()
  local target = lspconfig.rust_analyzer.manager.config.settings["rust-analyzer"].cargo.target

  -- Check if target was set during runtime
  if target ~= nil then
    print(target)
    return
  end

  -- Otherwise, check the default target
  local handle = io.popen("rustc -vV")
  if handle ~= nil then
    local result = handle:read("*a")
    handle:close()
    for line in result:gmatch("[^\r\n]+") do
      if line:find("host:") then
        target = line:match("^%s*(.-)%s*$"):gsub("host: ", "")
      end
    end
  else
    print("Unable to run `rustc -vV` to get rust target")
  end

  -- Print the results
  if target ~= nil then
    print(target)
  else
    print("Unable to find the rust target in `rustc -vV` output")
  end
end

Unfortunately, that method doesn't work with rustaceanvim. I'm trying to figure out what to modify, but I'm not a very advanced lua programmer. I'm probably making a mistake somewhere, so I'm reaching out to you all with this question.

How can I modify the target during runtime?

I've tried modifying vim.g.rustaceanvim, but it doesn't change to the value I set. Perhaps I'm doing that wrong. Here is the function I'm using:

local function set_rust_target(target)
  print("Setting target to " .. target)
  local settings = vim.g.rustaceanvim.server.settings
  settings["rust-analyzer"] =
    vim.tbl_deep_extend("force", settings["rust-analyzer"], { cargo = { target = target } })
  vim.g.rustaceanvim.server.settings = settings
end

The message prints, but the value returned by print(vim.inspect(vim.g.rustaceanvim.server.settings['rust-analyzer'])) is unchanged.

What am I doing wrong?

[mrcjkb]

Hey 👋

This plugin evaluates vim.g.rustaceanvim only once, during initialization.
It's not meant to be modified at runtime.

It does, however, allow the settings field to be a function.
For example:

vim.g.rustaceanvim = {
  server = {
    ---@param project_root string
    settings = function(project_root)
      return {
        if type(vim.g.rust_analyzer_cargo_target) ~= 'string' then
          -- Fall back to the default implementation if no valid target has been set
          return require('rustaceanvim.config.server').load_rust_analyzer_settings(project_root)
        end
        ["rust-analyzer"] = {
          cargo = {
            target = vim.g.rust_analyzer_cargo_target, -- set this variable with your keymap
          },
        },
      }
    end,
  },
}

The settings function will be evaluated every time you call :RustAnalyzer start, or whenever rustaceanvim spins up a new LSP client.

Your set_rust_target function could then be simplified to just setting the vim.g.rust_analyzer_cargo_target variable.

If your build target is project-dependent (doesn't change for an individual project), you could also
use a rust-analyzer.json file to set the target on a per-project basis.

A third option would be to write the settings function in a way that it prompts you to select from a list of targets every time it's evaluated,
using :h vim.ui.select, under a certain condition.

By the way, you can find a complete documentation of all rustaceanvim configuration options with :h rustaceanvim.config.

[FlippingBinary]

Thank you! That does work, but is there a way to restart the server automatically when setting a new target? :RustAnalyzer start does nothing if I call it too soon after calling :RustAnalyzer stop. A two second delay makes it work, but it would be nice if there was an event I could hook into or a RustAnalyzer restart command that does it automatically.

Here's what I'm using now:

local function set_rust_target(target)
  print("Setting target to " .. target)
  vim.g.rust_analyzer_cargo_target = target
  vim.cmd.RustAnalyzer("stop")
  local timer = vim.loop.new_timer()
  timer:start(
    2000,
    0,
    vim.schedule_wrap(function()
      vim.cmd.RustAnalyzer("start")
    end)
  )
end

With this settings function:

        settings = function(project_root)
          local default_settings = {
            -- rust-analyzer language server configuration
            ["rust-analyzer"] = {
              cargo = {
                allFeatures = true,
                loadOutDirsFromCheck = true,
                runBuildScripts = true,
              },
              -- Add clippy lints for Rust.
              checkOnSave = {
                allFeatures = true,
                command = "clippy",
                extraArgs = { "--no-deps" },
              },
              procMacro = {
                enable = true,
                ignored = {
                  ["async-trait"] = { "async_trait" },
                  ["napi-derive"] = { "napi" },
                  ["async-recursion"] = { "async_recursion" },
                },
              },
            },
          }
          if vim.g.rust_analyzer_cargo_target ~= nil then
            default_settings["rust-analyzer"].cargo.target = vim.g.rust_analyzer_cargo_target
          end
          local local_settings = require("rustaceanvim.config.server").load_rust_analyzer_settings(project_root)

          return vim.tbl_deep_extend("force", default_settings, local_settings)
        end,

[mrcjkb]

I've played around with a RustAnalyzer restart command before, but couldn't get it working (it ended up spinning up lots of clients) - which is strange, because with my haskell-tools plugin, it works fine.

[mrcjkb]

#148

[FlippingBinary]

Awesome! I see how you poll the attached clients, so I used a similar method. I don't see how your timer ever stops, so I wonder if that's what was causing it to spin up lots of clients. It looks like it would run every 500ms until you close NeoVim. I used timer:close() to stop my timer and checked with print statements to make sure that it does stop when it's supposed to.

Here's what my function looks like now:

local function set_rust_target(target)
  print("Setting target to " .. target)
  vim.g.rust_analyzer_cargo_target = target
  vim.cmd.RustAnalyzer("stop")
  local bufnr = vim.api.nvim_get_current_buf()
  local timer = vim.loop.new_timer()
  if not timer then
    vim.loop.sleep(5000)
    vim.cmd.RustAnalyzer("start")
  else
    local time_to_live = 50
    timer:start(
      200,
      100,
      vim.schedule_wrap(function()
        local clients = vim.lsp.get_active_clients({ bufnr = bufnr, name = "rust-analyzer" })
        if #clients == 0 or time_to_live <= 0 then
          -- rust-analyzer has stopped running or we've waited too long
          vim.cmd.RustAnalyzer("start")
          timer:close()
          time_to_live = 0
        end
        time_to_live = time_to_live - 1
      end)
    )
  end
end

This works exactly like I had hoped. Thank you for your help!

[mrcjkb]

That was it. Thanks 🙏

I've added the :RustAnalyzer restart command.