Warnings and errors not showing for no_std targets with `allTargets = false`

[jkelleyrtp]

rust-analyzer version: rust-analyzer version: faaec86ff 2022-04-12 nightly

rustc version: rustc 1.60.0 (7737e0b5c 2022-04-04)

An embedded project of mine has run into a regression with RA in the most recent version that breaks all warning and error reporting.

To get the "no crate found for test" error disabled, I added a .vscode/settings.json with the following item:

{
    "rust-analyzer.checkOnSave.allTargets": false,
}

However, once I've enabled this feature, error and warning reporting completely stops for the entire project.

If I enable all targets, the examples start to report warnings but the lib.rs throws an error about "no crate found for test".

My project is configured with a .cargo/config.toml:

[build]
target = "thumbv7em-none-eabihf"

[ia0]

Are there any updates? I also have this issue.

[ia0]

Actually, thinking about it, although annoying, I think this is working as expected and the issue could be closed. Here is the explanation: cargo check --all-targets --target=thumbv7em-none-eabihf fails with "can't find crate for test" so it's normal (and expected) that rust-analyzer reports the same issue. Here is how I "work around" this issue (but it's actually a fix since the issue is expected) for such projects (i.e. no-std crates with tests):

• When I'm editing the code, I configure rust-analyzer as if cargo check --target=thumbv7em-none-eabi is used.
• When I'm editing the tests, I configure rust-analyzer as if cargo test is used.
• (Note that by default rust-analyzer is configured as if cargo check --all-targets is used.)

Switching between configuration is not yet easily supported AFAICT. I have a custom emacs macro for that, where I can edit the cargo command line I want to simulate and it restarts rust-analyzer with the updated config. There's one config per workspace. Here's the code if it can help:

;; Maps variable(symbol) to value
(setq ia0-lsp-default (make-hash-table))
(puthash 'lsp-rust-analyzer-cargo-watch-command "check" ia0-lsp-default)
(puthash 'lsp-rust-analyzer-cargo-all-targets t ia0-lsp-default)
(puthash 'lsp-rust-analyzer-cargo-target nil ia0-lsp-default)
(puthash 'lsp-rust-no-default-features nil ia0-lsp-default)
(puthash 'lsp-rust-features [] ia0-lsp-default)
;; Maps directory(string) to variable(symbol) to value
(setq ia0-lsp (make-hash-table :test 'equal))
(defun ia0-lsp-get (k)
  (gethash k (gethash (lsp-workspace-root) ia0-lsp ia0-lsp-default)))
(defun ia0-lsp-put (k v)
  (let* ((w (lsp-workspace-root))
         (h (gethash w ia0-lsp)))
    (unless h
      (setq h (copy-hash-table ia0-lsp-default))
      (puthash w h ia0-lsp))
    (puthash k v h)))
(defun ia0-lsp-load (k)
  (set k (ia0-lsp-get k)))

(defun print-lsp-cargo ()
  "Returns the initialization options for rust-analyzer as a cargo command."
  (let* ((command (ia0-lsp-get 'lsp-rust-analyzer-cargo-watch-command))
         (all-targets (ia0-lsp-get 'lsp-rust-analyzer-cargo-all-targets))
         (target (ia0-lsp-get 'lsp-rust-analyzer-cargo-target))
         (no-default (ia0-lsp-get 'lsp-rust-no-default-features))
         (features (ia0-lsp-get 'lsp-rust-features))
         (cargo (concat "cargo " command)))
    (when all-targets (setq cargo (concat cargo " --all-targets")))
    (when target (setq cargo (concat cargo " --target=" target)))
    (when no-default (setq cargo (concat cargo " --no-default-features")))
    (setq features (mapconcat 'identity features ","))
    (unless (string= features "")
      (setq cargo (concat cargo " --features=" features)))
    cargo))

;; This is the main macro to interactively edit the cargo command line that rust-analyzer should simulate.
(defun edit-lsp-cargo ()
  "Edit lsp initialization options for rust-analyzer to mimic cargo."
  (interactive)
  (let ((cargo (read-string "Analyze: " (print-lsp-cargo))))
    (setq cargo (split-string cargo " " t))
    (ia0-lsp-put 'lsp-rust-analyzer-cargo-watch-command (nth 1 cargo))
    (setq cargo (mapcar (lambda (x) (split-string x "=")) (nthcdr 2 cargo)))
    (ia0-lsp-put 'lsp-rust-analyzer-cargo-all-targets
      (if (assoc "--all-targets" cargo) t))
    (let ((target (assoc "--target" cargo)))
      (if target (ia0-lsp-put 'lsp-rust-analyzer-cargo-target (cadr target))
        (ia0-lsp-put 'lsp-rust-analyzer-cargo-target nil)))
    (ia0-lsp-put 'lsp-rust-no-default-features
      (if (assoc "--no-default-features" cargo) t))
    (let ((features (assoc "--features" cargo)))
      (if features (ia0-lsp-put 'lsp-rust-features
                     (vconcat (split-string (cadr features) ",")))
        (ia0-lsp-put 'lsp-rust-features [])))
    (lsp-workspace-restart (car (lsp-workspaces)))))

;; This function should be used for lsp-workspace-folders-changed-functions
(defun ia0-lsp-workspace-folders-changed-functions (added removed)
  (maphash (lambda (k v) (ia0-lsp-load k)) ia0-lsp-default))

;; This function should be used for lsp-after-initialize-hook
(defun ia0-lsp-after-initialize-hook ()
  (maphash (lambda (k v) (set k v)) ia0-lsp-default))

[maor1993]

For some reason, running with this settings.json got it working:

{
    "rust-analyzer.checkOnSave": true,
    "rust-analyzer.check.command": "clippy"
}

[Veykril]

Sorry that there has been no input from our side, this feel off my radar. Are there any reproduction repos?

[ia0]

I would not consider this a rust-analyzer bug as stated in #11982 (comment) but rather a usability issue (my workaround being documented here in the experimental setup section). However, if you want reproduction steps, here is an example:

#![no_std]

pub fn good() -> bool {
    true
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn good_is_true() {
        assert_eq!(good(), true);
    }
}

Steps

• Open the file defined above. There is no issue because rust-analyzer has check.allTargets set to true and cargo.target set to null by default. This is equivalent of running cargo check --all-targets.
• Now let's say you want to analyze with cargo.target set to thumbv7em-none-eabi. This would be equivalent to running cargo check --all-targets --target=thumbv7em-none-eabi.
• Suddenly you get errors, and so for legitimate reasons, because you forgot to set check.allTargets to false, so rust is trying to check the test with an architecture that doesn't have a test crate.
• When setting check.allTargets to false, it suddenly all works again. Because that's equivalent of running cargo check --target=thumbv7em-none-eabi which is a command that makes sense.

I see you merged #14912 which seems related. But I'm not sure I understand what it does. I've run the steps above with rust-analyzer 1.71.0-nightly (4a59ba4 2023-05-12) and rust-analyzer 1.72.0-nightly (2d0aa57 2023-06-18). In both cases the behavior is as described above (which again is the expected behavior and shouldn't be changed).

If rust-analyzer wants to address this issue, it could print a more useful error message when cargo.target is defined to something that doesn't have a test crate and check.allTargets is true. And say something like: "You're trying to run cargo check --all-targets with a --target that doesn't support tests, try setting check.allTargets to false".