perf: optimize target_arch switching

lua/rustaceanvim/lsp/init.lua

@@ -126,12 +126,12 @@ local function with_rustc_target_architectures(callback)
 end
 
 ---LSP restart internal implementations
----@param bufnr? number
+---@param exclude_rustc_target? string|nil Cargo target triple (e.g., 'x86_64-unknown-linux-gnu') to filter rust-analyzer clients
 ---@param callback? fun(client: vim.lsp.Client) Optional callback to run for each client before restarting.
 ---@return number|nil client_id
-local function restart(bufnr, callback)
-  bufnr = bufnr or vim.api.nvim_get_current_buf()
-  local clients = M.stop(bufnr)
+local function restart(exclude_rustc_target, callback)
+  local bufnr = vim.api.nvim_get_current_buf()
+  local clients = M.stop(bufnr, exclude_rustc_target)
   local timer, _, _ = vim.uv.new_timer()
   if not timer then
     vim.notify('Failed to init timer for LSP client restart.', vim.log.levels.ERROR)
@@ -285,10 +285,14 @@ end
 
 ---Stop the LSP client.
 ---@param bufnr? number The buffer number, defaults to the current buffer
+---@param exclude_rustc_target? string|nil Cargo target triple (e.g., 'x86_64-unknown-linux-gnu') to filter rust-analyzer clients
 ---@return vim.lsp.Client[] clients A list of clients that will be stopped
-M.stop = function(bufnr)
+M.stop = function(bufnr, exclude_rustc_target)
   bufnr = bufnr or vim.api.nvim_get_current_buf()
-  local clients = rust_analyzer.get_active_rustaceanvim_clients(bufnr)
+  local clients = rust_analyzer.get_active_rustaceanvim_clients(
+    bufnr,
+    { exclude_rustc_target = exclude_rustc_target or DEFAULT_RUSTC_TARGET }
+  )
   vim.lsp.stop_client(clients)
   if type(clients) == 'table' then
     ---@cast clients vim.lsp.Client[]
@@ -303,10 +307,9 @@ M.stop = function(bufnr)
 end
 
 ---Reload settings for the LSP client.
----@param bufnr? number The buffer number, defaults to the current buffer
 ---@return vim.lsp.Client[] clients A list of clients that will be have their settings reloaded
-M.reload_settings = function(bufnr)
-  bufnr = bufnr or vim.api.nvim_get_current_buf()
+M.reload_settings = function()
+  local bufnr = vim.api.nvim_get_current_buf()
   local clients = rust_analyzer.get_active_rustaceanvim_clients(bufnr)
   ---@cast clients vim.lsp.Client[]
   for _, client in ipairs(clients) do
@@ -320,32 +323,19 @@ M.reload_settings = function(bufnr)
   return clients
 end
 
----Updates the target architecture setting for the LSP client associated with the given buffer.
----@param bufnr? number The buffer number, defaults to the current buffer
----@param target? string The target architecture. Defaults to nil(the current buffer's target if not provided).
-M.set_target_arch = function(bufnr, target)
+---Updates LSP client target architecture setting.
+---@param exclude_rustc_target? string|nil Cargo target triple (e.g., 'x86_64-unknown-linux-gnu') to filter rust-analyzer clients
+M.set_target_arch = function(exclude_rustc_target)
   ---@param client vim.lsp.Client
-  restart(bufnr, function(client)
-    -- Get current user's rust-analyzer target
-    local current_target = vim.tbl_get(client, 'config', 'settings', 'rust-analyzer', 'cargo', 'target')
-
-    if not target then
-      if not current_target then
-        vim.notify('Using default OS target architecture.', vim.log.levels.INFO)
-      else
-        vim.notify('Target architecture is already set to the default OS target.', vim.log.levels.INFO)
-      end
-      return
-    end
-
+  restart(exclude_rustc_target, function(client)
     with_rustc_target_architectures(function(rustc_targets)
-      if target == nil or rustc_targets[target] then
-        client.settings['rust-analyzer'].cargo.target = target
-        client.notify('workspace/didChangeConfiguration', { settings = client.config.settings })
-        vim.notify('Target architecture updated successfully to: ' .. target, vim.log.levels.INFO)
+      if rustc_targets[exclude_rustc_target] then
+        client.settings['rust-analyzer'].cargo.target = exclude_rustc_target
+        client.notify('workspace/didchangeconfiguration', { settings = client.config.settings })
+        vim.notify('target architecture updated successfully to: ' .. exclude_rustc_target, vim.log.levels.info)
         return
       else
-        vim.notify('Invalid target architecture provided: ' .. tostring(target), vim.log.levels.ERROR)
+        vim.notify('invalid target architecture provided: ' .. tostring(exclude_rustc_target), vim.log.levels.error)
         return
       end
     end)
@@ -354,10 +344,9 @@ end
 
 ---Restart the LSP client.
 ---Fails silently if the buffer's filetype is not one of the filetypes specified in the config.
----@param bufnr? number The buffer number (optional), defaults to the current buffer
 ---@return number|nil client_id The LSP client ID after restart
-M.restart = function(bufnr)
-  M.restart(bufnr)
+M.restart = function()
+  return restart()
 end
 
 ---@enum RustAnalyzerCmd
@@ -372,7 +361,6 @@ local RustAnalyzerCmd = {
 local function rust_analyzer_cmd(opts)
   local fargs = opts.fargs
   local cmd = fargs[1]
-  local arch = fargs[2]
   ---@cast cmd RustAnalyzerCmd
   if cmd == RustAnalyzerCmd.start then
     M.start()
@@ -383,7 +371,8 @@ local function rust_analyzer_cmd(opts)
   elseif cmd == RustAnalyzerCmd.reload_settings then
     M.reload_settings()
   elseif cmd == RustAnalyzerCmd.target then
-    M.set_target_arch(nil, arch)
+    local target_arch = fargs[2]
+    M.set_target_arch(target_arch)
   end
 end
 

lua/rustaceanvim/rust_analyzer.lua

@@ -5,18 +5,82 @@ local os = require('rustaceanvim.os')
 ---@class rustaceanvim.rust-analyzer.ClientAdapter
 local M = {}
 
+--- Default target value for rustc when no specific target is provided.
+--- Used as a fallback to let rustc determine the appropriate target based on the OS.
+DEFAULT_RUSTC_TARGET = 'OS'
+
+---Local rustc targets cache
+local rustc_targets_cache = nil
+
+M.load_os_rustc_target = function()
+  vim.system({ 'rustc', '-Vv' }, { text = true }, function(result)
+    if result.code == 0 then
+      for line in result.stdout:gmatch('[^\r\n]+') do
+        local host = line:match('^host:%s*(.+)$')
+        if host then
+          M.os_rustc_target = host
+          break
+        end
+      end
+    end
+  end)
+end
+
+---Handles retrieving rustc target architectures and running the passed in callback
+---to perform certain actions using the retrieved targets.
+---@param callback fun(targets: string[])
+M.with_rustc_target_architectures = function(callback)
+  if rustc_targets_cache then
+    return callback(rustc_targets_cache)
+  end
+  vim.system(
+    { 'rustc', '--print', 'target-list' },
+    { text = true },
+    ---@param result vim.SystemCompleted
+    function(result)
+      if result.code ~= 0 then
+        error('Failed to retrieve rustc targets: ' .. result.stderr)
+      end
+      rustc_targets_cache = vim.iter(result.stdout:gmatch('[^\r\n]+')):fold(
+        {},
+        ---@param acc table<string, boolean>
+        ---@param target string
+        function(acc, target)
+          acc[target] = true
+          return acc
+        end
+      )
+      return callback(rustc_targets_cache)
+    end
+  )
+end
+
+---@class rustaceanvim.lsp.get_clients.Filter: vim.lsp.get_clients.Filter
+---@field exclude_rustc_target? string Cargo target triple (e.g., 'x86_64-unknown-linux-gnu') to filter rust-analyzer clients
+
 ---@param bufnr number | nil 0 for the current buffer, `nil` for no buffer filter
----@param filter? vim.lsp.get_clients.Filter
+---@param filter? rustaceanvim.lsp.get_clients.Filter
 ---@return vim.lsp.Client[]
 M.get_active_rustaceanvim_clients = function(bufnr, filter)
   ---@type vim.lsp.get_clients.Filter
-  filter = vim.tbl_deep_extend('force', filter or {}, {
+  local client_filter = vim.tbl_deep_extend('force', filter or {}, {
     name = 'rust-analyzer',
   })
   if bufnr then
-    filter.bufnr = bufnr
+    client_filter.bufnr = bufnr
   end
-  return vim.lsp.get_clients(filter)
+  local clients = vim.lsp.get_clients(client_filter)
+  if filter and filter.exclude_rustc_target then
+    clients = vim.tbl_filter(function(client)
+      local cargo_target = vim.tbl_get(client, 'config', 'settings', 'rust-analyzer', 'cargo', 'target')
+      if filter.exclude_rustc_target == DEFAULT_RUSTC_TARGET and cargo_target == nil then
+        return false
+      end
+      return cargo_target ~= filter.exclude_rustc_target
+    end, clients)
+  end
+
+  return clients
 end
 
 ---@param method string LSP method name
@@ -64,7 +128,6 @@ M.get_client_for_file = function(file_path, method)
     end
   end
 end
-
 ---@param method string LSP method name
 ---@param params table|nil Parameters to send to the server
 M.notify = function(method, params)