+impl Default for ObligationCause {

+ #[inline]

+ fn default() -> Self {

+ Self::new()

+ }

+}

+

+impl std::ops::Index<CrateArrayIdx> for ProjectJson {

+ type Output = Crate;

+ fn index(&self, index: CrateArrayIdx) -> &Self::Output {

+ &self.crates[index.0]

+ }

+}

+

+ pub fn crate_by_root(&self, root: &AbsPath) -> Option<&Crate> {

+ .filter_map(|krate| krate.build.as_ref())

+ .cloned()

+ }

+

+ pub fn crate_by_label(&self, label: &str) -> Option<&Crate> {

+ // this is fast enough for now, but it's unfortunate that this is O(crates).

+ self.crates

+ .iter()

+ .filter(|krate| krate.is_workspace_member)

+ .find(|krate| krate.build.as_ref().is_some_and(|build| build.label == label))

+

+ pub fn runnable_template(&self, kind: RunnableKind) -> Option<&Runnable> {

+ self.runnables().iter().find(|r| r.kind == kind)

+ }

+impl Crate {

+ pub fn iter_deps(&self) -> impl ExactSizeIterator<Item = CrateArrayIdx> {

+ self.deps.iter().map(|dep| dep.krate)

+ }

+}

+

+ /// `cargo check`, basically, with human-readable output.

+ /// May include {label} which will get the label from the `build` section of a crate.

+ /// May include {label} which will get the label from the `build` section of a crate.

+ /// May include {test_id} which will get the test clicked on by the user.

+

+ /// Template for checking a target, emitting rustc JSON diagnostics.

+ /// May include {label} which will get the label from the `build` section of a crate.

+ Flycheck,

+ Flycheck,

+ RunnableKindData::Flycheck => RunnableKind::Flycheck,

+ /// [`DiscoverWorkspaceConfig`] also requires setting `progressLabel` and `filesToWatch`.

+ /// `progressLabel` is used for the title in progress indicators, whereas `filesToWatch`

+ /// "develop-json",

+ /// "{arg}"

+ /// "progressLabel": "buck2/rust-project",

+ /// ## Workspace Discovery Protocol

+ /// It supports two interpolation syntaxes, both mainly intended to be used with

+ /// [non-Cargo build systems](./non_cargo_based_projects.md):

+ ///

+ /// - If `{saved_file}` is part of the command, rust-analyzer will pass

+ /// the absolute path of the saved file to the provided command.

+ /// (A previous version, `$saved_file`, also works.)

+ /// - If `{label}` is part of the command, rust-analyzer will pass the

+ /// Cargo package ID, which can be used with `cargo check -p`, or a build label from

+ /// `rust-project.json`. If `{label}` is included, rust-analyzer behaves much like

+ /// [`"rust-analyzer.check.workspace": false`](#check.workspace).

+ ///

+ ///

+ // Might be nice to allow users to specify test_command = "nextest"

+ subcommand: "test".into(),

+ Some(_) | None => FlycheckConfig::Automatic {

+ cargo_options: CargoOptions {

+ subcommand: self.check_command(source_root).clone(),

+ FlycheckConfig::Automatic {

+ cargo_options: CargoOptions { target_dir_config: TargetDirectoryConfig::None, .. },

+ FlycheckConfig::Automatic {

+ cargo_options: CargoOptions { target_dir_config, .. },

+ FlycheckConfig::Automatic {

+ cargo_options: CargoOptions { target_dir_config, .. },

+use crate::{

+ flycheck::PackageSpecifier, global_state::GlobalStateSnapshot, lsp, lsp_ext,

+ main_loop::DiagnosticsTaskKind,

+};

+ Arc<Vec<FxHashMap<Option<PackageSpecifier>, FxHashMap<FileId, Vec<Fix>>>>>;

+ pub(crate) per_package: FxHashMap<Option<PackageSpecifier>, PackageFlycheckDiagnostic>,

+ package_id: PackageSpecifier,

+ package_id: PackageSpecifier,

+ package_id: &Option<PackageSpecifier>,

+use project_model::project_json;

+use toolchain::DISPLAY_COMMAND_IGNORE_ENVS;

+/// Data needed to construct a `cargo` command invocation, e.g. for flycheck or running a test.

+ /// The cargo subcommand to run, e.g. "check" or "clippy"

+ pub(crate) subcommand: String,

+/// The flycheck config from a rust-project.json file or discoverConfig JSON output.

+#[derive(Debug, Default)]

+pub(crate) struct FlycheckConfigJson {

+ /// The template with [project_json::RunnableKind::Flycheck]

+ pub single_template: Option<project_json::Runnable>,

+}

+

+impl FlycheckConfigJson {

+ pub(crate) fn any_configured(&self) -> bool {

+ // self.workspace_template.is_some() ||

+ self.single_template.is_some()

+ }

+}

+

+/// The flycheck config from rust-analyzer's own configuration.

+///

+/// We rely on this when rust-project.json does not specify a flycheck runnable

+///

+ /// Automatically use rust-project.json's flycheck runnable or just use cargo (the common case)

+ ///

+ /// We can't have a variant for ProjectJson because that is configured on the fly during

+ /// discoverConfig. We only know what we can read at config time.

+ Automatic {

+ /// If we do use cargo, how to build the check command

+ cargo_options: CargoOptions,

+ /// check_overrideCommand. This overrides both cargo and rust-project.json's flycheck runnable.

+ FlycheckConfig::Automatic { .. } => InvocationStrategy::PerWorkspace,

+ FlycheckConfig::Automatic { cargo_options, .. } => {

+ write!(f, "cargo {}", cargo_options.subcommand)

+ }

+ .map(|arg| if arg == SAVED_FILE_PLACEHOLDER_DOLLAR { "..." } else { arg })

+ config_json: FlycheckConfigJson,

+ config_json,

+ package: PackageSpecifier,

+ workspace_deps: Option<FxHashSet<PackageSpecifier>>,

+ saved_file: Option<AbsPathBuf>,

+ saved_file,

+ Package(PackageSpecifier),

+ package_id: Option<PackageSpecifier>,

+ DidStart {

+ /// The user sees this in VSCode, etc. May be a shortened version of the command we actually

+ /// executed, otherwise it is way too long.

+ user_facing_command: String,

+ },

+#[derive(Debug, Clone)]

+ Package {

+ // Either a cargo package or a $label in rust-project.check.overrideCommand

+ package: PackageSpecifier,

+ workspace_deps: Option<FxHashSet<PackageSpecifier>>,

+ },

+}

+

+#[derive(Debug, Hash, PartialEq, Eq, Clone)]

+pub(crate) enum PackageSpecifier {

+ Cargo {

+ /// The one in Cargo.toml, assumed to work with `cargo check -p {}` etc

+ package_id: Arc<PackageId>,

+ },

+ BuildInfo {

+ /// If a `build` field is present in rust-project.json, its label field

+ label: String,

+ },

+}

+

+impl PackageSpecifier {

+ pub(crate) fn as_str(&self) -> &str {

+ match self {

+ Self::Cargo { package_id } => &package_id.repr,

+ Self::BuildInfo { label } => label,

+ }

+ }

+}

+

+#[derive(Debug)]

+enum FlycheckCommandOrigin {

+ /// Regular cargo invocation

+ Cargo,

+ /// Configured via check_overrideCommand

+ CheckOverrideCommand,

+ /// From a runnable with [project_json::RunnableKind::Flycheck]

+ ProjectJsonRunnable,

+ config_json: FlycheckConfigJson,

+

+ diagnostics_cleared_for: FxHashSet<PackageSpecifier>,

+/// This is stable behaviour. Don't change.

+const SAVED_FILE_PLACEHOLDER_DOLLAR: &str = "$saved_file";

+const LABEL_INLINE: &str = "{label}";

+const SAVED_FILE_INLINE: &str = "{saved_file}";

+

+struct Substitutions<'a> {

+ label: Option<&'a str>,

+ saved_file: Option<&'a str>,

+}

+

+impl<'a> Substitutions<'a> {

+ /// If you have a runnable, and it has {label} in it somewhere, treat it as a template that

+ /// may be unsatisfied if you do not provide a label to substitute into it. Returns None in

+ /// that situation. Otherwise performs the requested substitutions.

+ ///

+ /// Same for {saved_file}.

+ ///

+ #[allow(clippy::disallowed_types)] /* generic parameter allows for FxHashMap */

+ fn substitute<H>(

+ self,

+ template: &project_json::Runnable,

+ extra_env: &std::collections::HashMap<String, Option<String>, H>,

+ ) -> Option<Command> {

+ let mut cmd = toolchain::command(&template.program, &template.cwd, extra_env);

+ for arg in &template.args {

+ if let Some(ix) = arg.find(LABEL_INLINE) {

+ if let Some(label) = self.label {

+ let mut arg = arg.to_string();

+ arg.replace_range(ix..ix + LABEL_INLINE.len(), label);

+ cmd.arg(arg);

+ continue;

+ } else {

+ return None;

+ }

+ }

+ if let Some(ix) = arg.find(SAVED_FILE_INLINE) {

+ if let Some(saved_file) = self.saved_file {

+ let mut arg = arg.to_string();

+ arg.replace_range(ix..ix + SAVED_FILE_INLINE.len(), saved_file);

+ cmd.arg(arg);

+ continue;

+ } else {

+ return None;

+ }

+ }

+ // Legacy syntax: full argument match

+ if arg == SAVED_FILE_PLACEHOLDER_DOLLAR {

+ if let Some(saved_file) = self.saved_file {

+ cmd.arg(saved_file);

+ continue;

+ } else {

+ return None;

+ }

+ }

+ cmd.arg(arg);

+ }

+ cmd.current_dir(&template.cwd);

+ Some(cmd)

+ }

+}

+ config_json: FlycheckConfigJson,

+ config_json,

+ self.scope = scope.clone();

+ let Some((command, origin)) = command else {

+ tracing::debug!(?scope, "failed to build flycheck command");

+ let debug_command = format!("{command:?}");

+ let user_facing_command = match origin {

+ // Don't show all the --format=json-with-blah-blah args, just the simple

+ // version

+ FlycheckCommandOrigin::Cargo => self.config.to_string(),

+ // show them the full command but pretty printed. advanced user

+ FlycheckCommandOrigin::ProjectJsonRunnable

+ | FlycheckCommandOrigin::CheckOverrideCommand => display_command(

+ &command,

+ Some(std::path::Path::new(self.root.as_path())),

+ ),

+ };

+ tracing::debug!(?origin, ?command, "will restart flycheck");

+ FlycheckConfig::Automatic { cargo_options, .. } => {

+ cargo_options.target_dir_config.target_dir(ws_target_dir);

+ tracing::debug!(?origin, command = %debug_command, "did restart flycheck");

+ self.report_progress(Progress::DidStart { user_facing_command });

+ "Failed to run the following command: {debug_command} origin={origin:?} error={error}"

+ if self

+ .diagnostics_cleared_for

+ .insert(PackageSpecifier::Cargo { package_id: package_id.clone() })

+ {

+ kind: ClearDiagnosticsKind::All(ClearScope::Package(

+ PackageSpecifier::Cargo { package_id },

+ )),

+ package_id = package_id.as_ref().map(|it| it.as_str()),

+ package_id = package_id.as_str(),

+ fn explicit_check_command(

+ &self,

+ scope: &FlycheckScope,

+ saved_file: Option<&AbsPath>,

+ ) -> Option<Command> {

+ let label = match scope {

+ // We could add a runnable like "RunnableKind::FlycheckWorkspace". But generally

+ // if you're not running cargo, it's because your workspace is too big to check

+ // all at once. You can always use `check_overrideCommand` with no {label}.

+ FlycheckScope::Workspace => return None,

+ FlycheckScope::Package { package: PackageSpecifier::BuildInfo { label }, .. } => {

+ label.as_str()

+ }

+ FlycheckScope::Package {

+ package: PackageSpecifier::Cargo { package_id: label },

+ ..

+ } => &label.repr,

+ };

+ let template = self.config_json.single_template.as_ref()?;

+ let subs = Substitutions { label: Some(label), saved_file: saved_file.map(|x| x.as_str()) };

+ subs.substitute(template, &FxHashMap::default())

+ }

+

+ ) -> Option<(Command, FlycheckCommandOrigin)> {

+ FlycheckConfig::Automatic { cargo_options, ansi_color_output } => {

+ // Only use the rust-project.json's flycheck config when no check_overrideCommand

+ // is configured. In the FlycheckConcig::CustomCommand branch we will still do

+ // label substitution, but on the overrideCommand instead.

+ //

+ // There needs to be SOME way to override what your discoverConfig tool says,

+ // because to change the flycheck runnable there you may have to literally

+ // recompile the tool.

+ if self.config_json.any_configured() {

+ // Completely handle according to rust-project.json.

+ // We don't consider this to be "using cargo" so we will not apply any of the

+ // CargoOptions to the command.

+ let cmd = self.explicit_check_command(scope, saved_file)?;

+ return Some((cmd, FlycheckCommandOrigin::ProjectJsonRunnable));

+ }

+

+ toolchain::command(Tool::Cargo.path(), &*self.root, &cargo_options.extra_env);

+ && !cargo_options.extra_env.contains_key("RUSTUP_TOOLCHAIN")

+ cmd.arg(&cargo_options.subcommand);

+ FlycheckScope::Package {

+ package: PackageSpecifier::Cargo { package_id },

+ ..

+ } => cmd.arg("-p").arg(&package_id.repr),

+ FlycheckScope::Package {

+ package: PackageSpecifier::BuildInfo { .. }, ..

+ } => {

+ // No way to flycheck this single package. All we have is a build label.

+ // There's no way to really say whether this build label happens to be

+ // a cargo canonical name, so we won't try.

+ return None;

+ }

+ cargo_options.apply_on_command(

+ cmd.args(&cargo_options.extra_args);

+ Some((cmd, FlycheckCommandOrigin::Cargo))

+ let runnable = project_json::Runnable {

+ program: command.clone(),

+ cwd: Utf8Path::to_owned(root.as_ref()),

+ args: args.clone(),

+ kind: project_json::RunnableKind::Flycheck,

+ };

+ let label = match scope {

+ FlycheckScope::Workspace => None,

+ // We support substituting both build labels (e.g. buck, bazel) and cargo package ids.

+ // With cargo package ids, you get `cargo check -p path+file:///path/to/rust-analyzer/crates/hir#0.0.0`.

+ // That does work!

+ FlycheckScope::Package { package, .. } => Some(package.as_str()),

+ };

+ let subs = Substitutions { label, saved_file: saved_file.map(|x| x.as_str()) };

+ let cmd = subs.substitute(&runnable, extra_env)?;

+

+ Some((cmd, FlycheckCommandOrigin::CheckOverrideCommand))

+ Diagnostic { diagnostic: Diagnostic, package_id: Option<PackageSpecifier> },

+ package_id: Some(PackageSpecifier::Cargo {

+ package_id: Arc::new(msg.package_id),

+ }),

+

+/// Not good enough to execute in a shell, but good enough to show the user without all the noisy

+/// quotes

+///

+/// Pass implicit_cwd if there is one regarded as the obvious by the user, so we can skip showing it.

+/// Compactness is the aim of the game, the output typically gets truncated quite a lot.

+fn display_command(c: &Command, implicit_cwd: Option<&std::path::Path>) -> String {

+ let mut o = String::new();

+ use std::fmt::Write;

+ let lossy = std::ffi::OsStr::to_string_lossy;

+ if let Some(dir) = c.get_current_dir() {

+ if Some(dir) == implicit_cwd.map(std::path::Path::new) {

+ // pass

+ } else if dir.to_string_lossy().contains(" ") {

+ write!(o, "cd {:?} && ", dir).unwrap();

+ } else {

+ write!(o, "cd {} && ", dir.display()).unwrap();

+ }

+ }

+ for (env, val) in c.get_envs() {

+ let (env, val) = (lossy(env), val.map(lossy).unwrap_or(std::borrow::Cow::Borrowed("")));

+ if DISPLAY_COMMAND_IGNORE_ENVS.contains(&env.as_ref()) {

+ continue;

+ }

+ if env.contains(" ") {

+ write!(o, "\"{}={}\" ", env, val).unwrap();

+ } else if val.contains(" ") {

+ write!(o, "{}=\"{}\" ", env, val).unwrap();

+ } else {

+ write!(o, "{}={} ", env, val).unwrap();

+ }

+ }

+ let prog = lossy(c.get_program());

+ if prog.contains(" ") {

+ write!(o, "{:?}", prog).unwrap();

+ } else {

+ write!(o, "{}", prog).unwrap();

+ }

+ for arg in c.get_args() {

+ let arg = lossy(arg);

+ if arg.contains(" ") {

+ write!(o, " \"{}\"", arg).unwrap();

+ } else {

+ write!(o, " {}", arg).unwrap();

+ }

+ }

+ o

+}

+

+#[cfg(test)]

+mod tests {

+ use ide_db::FxHashMap;

+ use itertools::Itertools;

+ use paths::Utf8Path;

+ use project_model::project_json;

+

+ use crate::flycheck::Substitutions;

+ use crate::flycheck::display_command;

+

+ #[test]

+ fn test_substitutions() {

+ let label = ":label";

+ let saved_file = "file.rs";

+

+ // Runnable says it needs both; you need both.

+ assert_eq!(test_substitute(None, None, "{label} {saved_file}").as_deref(), None);

+ assert_eq!(test_substitute(Some(label), None, "{label} {saved_file}").as_deref(), None);

+ assert_eq!(

+ test_substitute(None, Some(saved_file), "{label} {saved_file}").as_deref(),

+ None

+ );

+ assert_eq!(

+ test_substitute(Some(label), Some(saved_file), "{label} {saved_file}").as_deref(),

+ Some("build :label file.rs")

+ );

+

+ // Only need label? only need label.

+ assert_eq!(test_substitute(None, None, "{label}").as_deref(), None);

+ assert_eq!(test_substitute(Some(label), None, "{label}").as_deref(), Some("build :label"),);

+ assert_eq!(test_substitute(None, Some(saved_file), "{label}").as_deref(), None,);

+ assert_eq!(

+ test_substitute(Some(label), Some(saved_file), "{label}").as_deref(),

+ Some("build :label"),

+ );

+

+ // Only need saved_file

+ assert_eq!(test_substitute(None, None, "{saved_file}").as_deref(), None);

+ assert_eq!(test_substitute(Some(label), None, "{saved_file}").as_deref(), None);

+ assert_eq!(

+ test_substitute(None, Some(saved_file), "{saved_file}").as_deref(),

+ Some("build file.rs")

+ );

+ assert_eq!(

+ test_substitute(Some(label), Some(saved_file), "{saved_file}").as_deref(),

+ Some("build file.rs")

+ );

+

+ // Need neither

+ assert_eq!(test_substitute(None, None, "xxx").as_deref(), Some("build xxx"));

+ assert_eq!(test_substitute(Some(label), None, "xxx").as_deref(), Some("build xxx"));

+ assert_eq!(test_substitute(None, Some(saved_file), "xxx").as_deref(), Some("build xxx"));

+ assert_eq!(

+ test_substitute(Some(label), Some(saved_file), "xxx").as_deref(),

+ Some("build xxx")

+ );

+

+ // {label} mid-argument substitution

+ assert_eq!(

+ test_substitute(Some(label), None, "--label={label}").as_deref(),

+ Some("build --label=:label")

+ );

+

+ // {saved_file} mid-argument substitution

+ assert_eq!(

+ test_substitute(None, Some(saved_file), "--saved={saved_file}").as_deref(),

+ Some("build --saved=file.rs")

+ );

+

+ // $saved_file legacy support (no mid-argument substitution, we never supported that)

+ assert_eq!(

+ test_substitute(None, Some(saved_file), "$saved_file").as_deref(),

+ Some("build file.rs")

+ );

+

+ fn test_substitute(

+ label: Option<&str>,

+ saved_file: Option<&str>,

+ args: &str,

+ ) -> Option<String> {

+ Substitutions { label, saved_file }

+ .substitute(

+ &project_json::Runnable {

+ program: "build".to_owned(),

+ args: Vec::from_iter(args.split_whitespace().map(ToOwned::to_owned)),

+ cwd: Utf8Path::new("/path").to_owned(),

+ kind: project_json::RunnableKind::Flycheck,

+ },

+ &FxHashMap::default(),

+ )

+ .map(|command| {

+ command.get_args().map(|x| x.to_string_lossy()).collect_vec().join(" ")

+ })

+ .map(|args| format!("build {}", args))

+ }

+ }

+

+ #[test]

+ fn test_display_command() {

+ use std::path::Path;

+ let workdir = Path::new("workdir");

+ let mut cmd = toolchain::command("command", workdir, &FxHashMap::default());

+ assert_eq!(display_command(cmd.arg("--arg"), Some(workdir)), "command --arg");

+ assert_eq!(

+ display_command(cmd.arg("spaced arg"), Some(workdir)),

+ "command --arg \"spaced arg\""

+ );

+ assert_eq!(

+ display_command(cmd.env("ENVIRON", "yeah"), Some(workdir)),

+ "ENVIRON=yeah command --arg \"spaced arg\""

+ );

+ assert_eq!(

+ display_command(cmd.env("OTHER", "spaced env"), Some(workdir)),

+ "ENVIRON=yeah OTHER=\"spaced env\" command --arg \"spaced arg\""

+ );

+ assert_eq!(

+ display_command(cmd.current_dir("/tmp"), Some(workdir)),

+ "cd /tmp && ENVIRON=yeah OTHER=\"spaced env\" command --arg \"spaced arg\""

+ );

+ assert_eq!(

+ display_command(cmd.current_dir("/tmp and/thing"), Some(workdir)),

+ "cd \"/tmp and/thing\" && ENVIRON=yeah OTHER=\"spaced env\" command --arg \"spaced arg\""

+ );

+ assert_eq!(

+ display_command(cmd.current_dir("/tmp and/thing"), Some(Path::new("/tmp and/thing"))),

+ "ENVIRON=yeah OTHER=\"spaced env\" command --arg \"spaced arg\""

+ );

+ }

+}

+ flycheck::{FlycheckHandle, FlycheckMessage, PackageSpecifier},

+ pub(crate) flycheck_formatted_commands: Vec<String>,

+ flycheck_formatted_commands: vec![],

+ let Some(build) = krate.build.clone() else {

+ project_root: project.project_root().to_owned(),

+ package: &PackageSpecifier,

+ ) -> Option<FxHashSet<PackageSpecifier>> {

+ match package {

+ PackageSpecifier::Cargo { package_id } => {

+ self.workspaces.iter().find_map(|workspace| match &workspace.kind {

+ ProjectWorkspaceKind::Cargo { cargo, .. }

+ | ProjectWorkspaceKind::DetachedFile { cargo: Some((cargo, _, _)), .. } => {

+ let package = cargo.packages().find(|p| cargo[*p].id == *package_id)?;

+

+ cargo[package].all_member_deps.as_ref().map(|deps| {

+ deps.iter()

+ .map(|dep| cargo[*dep].id.clone())

+ .map(|p| PackageSpecifier::Cargo { package_id: p })

+ .collect()

+ })

+ }

+ _ => None,

+ })

+ }

+ PackageSpecifier::BuildInfo { label } => {

+ self.workspaces.iter().find_map(|workspace| match &workspace.kind {

+ ProjectWorkspaceKind::Json(p) => {

+ let krate = p.crate_by_label(label)?;

+ Some(

+ krate

+ .iter_deps()

+ .filter_map(|dep| p[dep].build.as_ref())

+ .map(|build| PackageSpecifier::BuildInfo {

+ label: build.label.clone(),

+ })

+ .collect(),

+ )

+ }

+ _ => None,

+ })

+ flycheck::{InvocationStrategy, PackageSpecifier, Target},

+ let saved_file = vfs_path.as_path().map(ToOwned::to_owned);

+ let target = TargetSpec::for_file(&world, file_id)?.map(|it| {

+ TargetSpec::Cargo(c) => (

+ Some(c.target),

+ c.workspace_root,

+ PackageSpecifier::Cargo { package_id: c.package_id },

+ ),

+ TargetSpec::ProjectJson(p) => (

+ None,

+ p.project_root,

+ PackageSpecifier::BuildInfo { label: p.label.clone() },

+ ),

+ let tgt = tgt_name.and_then(|tgt_name| {

+ Some(match tgt_kind {

+ project_model::TargetKind::Bin => Target::Bin(tgt_name),

+ project_model::TargetKind::Example => Target::Example(tgt_name),

+ project_model::TargetKind::Test => Target::Test(tgt_name),

+ project_model::TargetKind::Bench => Target::Benchmark(tgt_name),

+ _ => return None,

+ })

+ });

+ (tgt, root, package)

+ // the user opted into package checks then OR if this is not cargo.

+ let package_check_allowed = target.is_some()

+ || !may_flycheck_workspace

+ || matches!(package, PackageSpecifier::BuildInfo { .. });

+ project_model::ProjectWorkspaceKind::Json(p) => {

+ *p.project_root() == root

+ }

+ project_model::ProjectWorkspaceKind::DetachedFile {

+ cargo: None,

+ ..

+ } => false,

+ saved_file.clone(),

+ let format_with_id = |user_facing_command: String| {

+ if self.flycheck.len() == 1 {

+ user_facing_command

+ } else {

+ format!("{user_facing_command} (#{})", id + 1)

+ }

+ };

+

+ self.flycheck_formatted_commands

+ .resize_with(self.flycheck.len().max(id + 1), || {

+ format_with_id(self.config.flycheck(None).to_string())

+ });

+

+ flycheck::Progress::DidStart { user_facing_command } => {

+ self.flycheck_formatted_commands[id] = format_with_id(user_facing_command);

+ (Progress::Begin, None)

+ }

+ // Clone because we &mut self for report_progress

+ let title = self.flycheck_formatted_commands[id].clone();

+use project_model::{

+ ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, WorkspaceBuildScripts, project_json,

+};

+ crate::flycheck::FlycheckConfigJson::default(),

+ crate::flycheck::FlycheckConfigJson::default(),

+ let config_json = crate::flycheck::FlycheckConfigJson {

+ single_template: project

+ .runnable_template(project_json::RunnableKind::Flycheck)

+ .cloned(),

+ };

+ _ if config_json.any_configured() => {

+ (config_json, project.path(), None, None)

+ }

+ (config_json, project.path(), None, None)

+ .map(|(id, (config_json, root, manifest_path, target_dir), sysroot_root)| {

+ config_json,

+ self.flycheck_formatted_commands = vec![];

+ pub(crate) project_root: AbsPathBuf,

+ let mut runnable = runnable.clone();

+

+ let replaced_args: Vec<_> = runnable

+ .args

+ .iter()

+ .map(|arg| arg.replace("{label}", &self.label))

+ .collect();

+ runnable.args = replaced_args;

+

+ return Some(runnable);

+ cmd.arg(&options.subcommand); // test, usually

+// These get ignored when displaying what command is running in LSP status messages.

+pub const DISPLAY_COMMAND_IGNORE_ENVS: &[&str] = &[NO_RUSTUP_AUTO_INSTALL_ENV.0];

+

+It supports two interpolation syntaxes, both mainly intended to be used with

+[non-Cargo build systems](./non_cargo_based_projects.md):

+

+- If `{saved_file}` is part of the command, rust-analyzer will pass

+ the absolute path of the saved file to the provided command.

+ (A previous version, `$saved_file`, also works.)

+- If `{label}` is part of the command, rust-analyzer will pass the

+ Cargo package ID, which can be used with `cargo check -p`, or a build label from

+ `rust-project.json`. If `{label}` is included, rust-analyzer behaves much like

+ [`"rust-analyzer.check.workspace": false`](#check.workspace).

+

+

+[`DiscoverWorkspaceConfig`] also requires setting `progressLabel` and `filesToWatch`.

+`progressLabel` is used for the title in progress indicators, whereas `filesToWatch`

+ "develop-json",

+ "{arg}"

+ "progressLabel": "buck2/rust-project",

+## Workspace Discovery Protocol

+ /// Maps a runnable to a piece of rust-analyzer functionality.

+ /// - `testOne`: This runnable will be used when the user clicks the 'Run Test'

+ /// CodeLens above a test.

+ /// - `run`: This runnable will be used when the user clicks the 'Run' CodeLens

+ /// above a main function or triggers a run command.

+ /// - `flycheck`: This is run to provide check-on-save diagnostics when the user

+ /// saves a file. It must emit rustc JSON diagnostics that rust-analyzer can

+ /// parse. If this runnable is not specified, we may try to use `cargo check -p`.

+ /// This is only run for a single crate that the user saved a file in. The

+ /// {label} syntax is replaced with `BuildInfo::label`.

+ /// Alternatively, you may use `{saved_file}` and figure out which crate

+ /// to produce diagnostics for based on that.

+ /// with the `BuildInfo::label` and `{test_id}` will be replaced

+ kind: 'testOne' | 'run' | 'flycheck' | string;

+### Providing a JSON project to rust-analyzer

+

+There are four ways to feed `rust-project.json` to rust-analyzer:

+

+- Use

+ [`"rust-analyzer.workspace.discoverConfig": … }`](./configuration.md#workspace.discoverConfig)

+ to specify a workspace discovery command to generate project descriptions

+ on-the-fly. Please note that the command output is message-oriented and must

+ follow [the discovery protocol](./configuration.md#workspace-discovery-protocol).

+### Flycheck support

+

+Rust-analyzer has functionality to run an actual build of a crate when the user saves a file, to

+fill in diagnostics it does not implement natively. This is known as "flycheck".

+

+**Flycheck is disabled when using `rust-project.json` unless explicitly configured**, so compilation

+errors and warnings will no longer be sent to your LSP client by default. To enable these

+compilation errors you will need to specify explicitly what command rust-analyzer should run to

+perform the checks. There are two ways to do this:

+

+- `rust-project.json` may contain a `runnables` field. The `flycheck` runnable may be used to

+ configure a check command. See above for documentation.

+

+- Using the [`rust-analyzer.check.overrideCommand`](./configuration.md#check.overrideCommand)

+ configuration. This will also override anything in `rust-project.json`. As an example, the

+ following configuration explicitly sets `cargo check` as the `check` command.

+

+ ```json

+ { "rust-analyzer.check.overrideCommand": ["cargo", "check", "--message-format=json"] }

+ ```

+

+ Note also that this works with cargo projects.

+

+Either option requires the command specified to output JSON error messages for rust-analyzer to

+consume. The `--message-format=json` flag does this for `cargo check` so whichever command you use

+must also output errors in this format.

+

+Either option also supports two syntaxes within each argument:

+

+- `{label}` will be replaced with the `BuildInfo::label` of the crate

+ containing a saved file, if `BuildInfo` is provided. In the case of `check.overrideCommand` being

+ used in a Cargo project, this will be the cargo package ID, which can be used with `cargo check -p`.

+- `{saved_file}` will be replaced with an absolute path to the saved file. This can be queried against a

+ build system to find targets that include the file.

+

+For example:

+

+```json

+{ "rust-analyzer.check.overrideCommand": ["custom_crate_checker", "{label}"] }

+```

+

+If you do use `{label}` or `{saved_file}`, the command will not be run unless the relevant value can

+be substituted.

+

+

+#### Flycheck considerations

+

+##### Diagnostic output on error

+

+A flycheck command using a complex build orchestrator like `"bazel", "build", "{label}"`, even with

+a tweak to return JSON messages, is often insufficient. Such a command will typically succeed if

+there are warnings, but if there are errors, it might "fail to compile" the diagnostics and not

+produce any output. You must build a package in such a way that the build succeeds even if `rustc`

+exits with an error, and prints the JSON build messages in every case.

+

+##### Diagnostics for upstream crates

+

+`cargo check -p` re-prints any errors and warnings in crates higher up in the dependency graph

+than the one requested. We do clear all diagnostics when flychecking, so if you manage to

+replicate this behaviour, diagnostics for crates other than the one being checked will show up in

+the editor. If you do not, then users may be confused that diagnostics are "stuck" or disappear

+entirely when there is a build error in an upstream crate.

+

+##### Compiler options

+

+`cargo check` invokes rustc differently from `cargo build`. It turns off codegen (with `rustc

+--emit=metadata`), which results in lower latency to get to diagnostics. If your build system can

+configure this, it is recommended.

+

+If your build tool can configure rustc for incremental compiles, this is also recommended.

+

+##### Locking and pre-emption

+

+In any good build system, including Cargo, build commands sometimes block each other. Running a

+flycheck will (by default) frequently block you from running other build commands. Generally this is

+undesirable. Users will have to (unintuitively) press save again in the editor to cancel a

+flycheck, so that some other command may proceed.

+

+If your build system has the ability to isolate any rust-analyzer-driven flychecks and prevent lock

+contention, for example a separate build output directory and/or daemon instance, this is

+recommended. Alternatively, consider using a feature if available that can set the priority of

+various build invocations and automatically cancel lower-priority ones when needed. Flychecks should

+be set to a lower priority than general direct build invocations.

+ "markdownDescription": "Override the command rust-analyzer uses instead of `cargo check` for\ndiagnostics on save. The command is required to output json and\nshould therefore include `--message-format=json` or a similar option\n(if your client supports the `colorDiagnosticOutput` experimental\ncapability, you can use `--message-format=json-diagnostic-rendered-ansi`).\n\nIf you're changing this because you're using some tool wrapping\nCargo, you might also want to change\n`#rust-analyzer.cargo.buildScripts.overrideCommand#`.\n\nIf there are multiple linked projects/workspaces, this command is invoked for\neach of them, with the working directory being the workspace root\n(i.e., the folder containing the `Cargo.toml`). This can be overwritten\nby changing `#rust-analyzer.check.invocationStrategy#`.\n\nIt supports two interpolation syntaxes, both mainly intended to be used with\n[non-Cargo build systems](./non_cargo_based_projects.md):\n\n- If `{saved_file}` is part of the command, rust-analyzer will pass\n the absolute path of the saved file to the provided command.\n (A previous version, `$saved_file`, also works.)\n- If `{label}` is part of the command, rust-analyzer will pass the\n Cargo package ID, which can be used with `cargo check -p`, or a build label from\n `rust-project.json`. If `{label}` is included, rust-analyzer behaves much like\n [`\"rust-analyzer.check.workspace\": false`](#check.workspace).\n\n\n\nAn example command would be:\n\n```bash\ncargo check --workspace --message-format=json --all-targets\n```\n\nNote: The option must be specified as an array of command line arguments, with\nthe first argument being the name of the command to run.",

+ "markdownDescription": "Enables automatic discovery of projects using [`DiscoverWorkspaceConfig::command`].\n\n[`DiscoverWorkspaceConfig`] also requires setting `progressLabel` and `filesToWatch`.\n`progressLabel` is used for the title in progress indicators, whereas `filesToWatch`\nis used to determine which build system-specific files should be watched in order to\nreload rust-analyzer.\n\nBelow is an example of a valid configuration:\n```json\n\"rust-analyzer.workspace.discoverConfig\": {\n \"command\": [\n \"rust-project\",\n \"develop-json\",\n \"{arg}\"\n ],\n \"progressLabel\": \"buck2/rust-project\",\n \"filesToWatch\": [\n \"BUCK\"\n ]\n}\n```\n\n## Workspace Discovery Protocol\n\n**Warning**: This format is provisional and subject to change.\n\n[`DiscoverWorkspaceConfig::command`] *must* return a JSON object corresponding to\n`DiscoverProjectData::Finished`:\n\n```norun\n#[derive(Debug, Clone, Deserialize, Serialize)]\n#[serde(tag = \"kind\")]\n#[serde(rename_all = \"snake_case\")]\nenum DiscoverProjectData {\n Finished { buildfile: Utf8PathBuf, project: ProjectJsonData },\n Error { error: String, source: Option<String> },\n Progress { message: String },\n}\n```\n\nAs JSON, `DiscoverProjectData::Finished` is:\n\n```json\n{\n // the internally-tagged representation of the enum.\n \"kind\": \"finished\",\n // the file used by a non-Cargo build system to define\n // a package or target.\n \"buildfile\": \"rust-analyzer/BUILD\",\n // the contents of a rust-project.json, elided for brevity\n \"project\": {\n \"sysroot\": \"foo\",\n \"crates\": []\n }\n}\n```\n\nIt is encouraged, but not required, to use the other variants on `DiscoverProjectData`\nto provide a more polished end-user experience.\n\n`DiscoverWorkspaceConfig::command` may *optionally* include an `{arg}`, which will be\nsubstituted with the JSON-serialized form of the following enum:\n\n```norun\n#[derive(PartialEq, Clone, Debug, Serialize)]\n#[serde(rename_all = \"camelCase\")]\npub enum DiscoverArgument {\n Path(AbsPathBuf),\n Buildfile(AbsPathBuf),\n}\n```\n\nThe JSON representation of `DiscoverArgument::Path` is:\n\n```json\n{\n \"path\": \"src/main.rs\"\n}\n```\n\nSimilarly, the JSON representation of `DiscoverArgument::Buildfile` is:\n\n```json\n{\n \"buildfile\": \"BUILD\"\n}\n```\n\n`DiscoverArgument::Path` is used to find and generate a `rust-project.json`, and\ntherefore, a workspace, whereas `DiscoverArgument::buildfile` is used to to update an\nexisting workspace. As a reference for implementors, buck2's `rust-project` will likely\nbe useful: <https://github.com/facebook/buck2/tree/main/integrations/rust-project>.",