+ /// Crates whose root's source root is the same as the source root of `file_id`

+ /// Crates whose root fool is in `id`.

+ // Note: `mod` declarations in block modules cannot be supported here

+ if mods.is_empty() {

+ // FIXME: detached file

+ }

+//! request takes longer to compute. This module implements prepopulation of

+ InvocationStrategy, ManifestPath, Package, Sysroot, TargetKind,

+ manifest_path: &ManifestPath,

+ cmd.arg(manifest_path.as_ref());

+ if manifest_path.extension().map_or(false, |ext| ext == "rs") {

+ cmd.arg("-Zscript");

+ }

+

+ let mut cmd =

+ Self::build_command(config, &allowed_features, workspace.manifest_path(), sysroot)?;

+ if toolchain.as_ref().map_or(false, |it| *it >= RUST_1_75) {

+ cmd.args(["--keep-going"]);

+ Self::run_per_ws(cmd, workspace, current_dir, progress)

+ let cmd = Self::build_command(

+ config,

+ &Default::default(),

+ // This is not gonna be used anyways, so just construct a dummy here

+ &ManifestPath::try_from(workspace_root.clone()).unwrap(),

+ None,

+ )?;

+ manifest_path: ManifestPath,

+ pub fn new(mut meta: cargo_metadata::Metadata, manifest_path: ManifestPath) -> CargoWorkspace {

+ CargoWorkspace { packages, targets, workspace_root, target_directory, manifest_path }

+ pub fn manifest_path(&self) -> &ManifestPath {

+ &self.manifest_path

+ }

+

+pub use cargo_metadata::Metadata;

+ CargoScript(ManifestPath),

+ if path.extension().unwrap_or_default() == "rs" {

+ return Ok(ProjectManifest::CargoScript(path));

+ }

+ bail!("project root must point to a Cargo.toml, rust-project.json or <script>.rs file: {path}");

+

+ pub fn manifest_path(&self) -> &ManifestPath {

+ match self {

+ ProjectManifest::ProjectJson(it)

+ | ProjectManifest::CargoToml(it)

+ | ProjectManifest::CargoScript(it) => it,

+ }

+ }

+ fmt::Display::fmt(self.manifest_path(), f)

+use std::{borrow::Borrow, fmt, ops};

+impl AsRef<AbsPath> for ManifestPath {

+ fn as_ref(&self) -> &AbsPath {

+

+impl Borrow<AbsPath> for ManifestPath {

+ fn borrow(&self) -> &AbsPath {

+ self.file.borrow()

+ }

+}

+ let cargo_workspace = CargoWorkspace::new(res, sysroot_cargo_toml);

+ .find(|it| fs::metadata(it.as_ref()).is_ok());

+ if fs::metadata(rustc_src.as_ref()).is_ok() {

+use cargo_metadata::Metadata;

+ CargoWorkspace, CfgOverrides, ManifestPath, ProjectJson, ProjectJsonData, ProjectWorkspace,

+ Sysroot, WorkspaceBuildScripts,

+ let meta: Metadata = get_test_json_file(file);

+ let manifest_path =

+ ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap();

+ let cargo_workspace = CargoWorkspace::new(meta, manifest_path);

+ let meta: Metadata = get_test_json_file(file);

+ let manifest_path =

+ ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap();

+ let cargo_workspace = CargoWorkspace::new(meta, manifest_path);

+ let meta: Metadata = get_test_json_file("hello-world-metadata.json");

+ let manifest_path =

+ ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap();

+ let cargo_workspace = CargoWorkspace::new(meta, manifest_path);

+use anyhow::Context;

+ file: ManifestPath,

+ cargo_script: Option<(CargoWorkspace, WorkspaceBuildScripts)>,

+ let file = fs::read_to_string(project_json.as_ref())

+ ProjectManifest::CargoScript(rust_file) => {

+ ProjectWorkspace::load_detached_file(rust_file, config)?

+ }

+ let workspace = CargoWorkspace::new(meta, cargo_toml.clone());

+ let cargo = CargoWorkspace::new(meta, cargo_toml.clone());

+ pub fn load_detached_file(

+ detached_file: &ManifestPath,

+ ) -> anyhow::Result<ProjectWorkspace> {

+ let dir = detached_file.parent();

+ let sysroot = match &config.sysroot {

+ Some(RustLibSource::Path(path)) => {

+ Sysroot::with_sysroot_dir(path.clone(), config.sysroot_query_metadata)

+ .map_err(|e| Some(format!("Failed to find sysroot at {path}:{e}")))

+ }

+ Some(RustLibSource::Discover) => Sysroot::discover(

+ dir,

+ &config.extra_env,

+ config.sysroot_query_metadata,

+ )

+ .map_err(|e| {

+ Some(format!("Failed to find sysroot for {dir}. Is rust-src installed? {e}"))

+ }),

+ None => Err(None),

+ };

+ let sysroot_ref = sysroot.as_ref().ok();

+ let toolchain =

+ match get_toolchain_version(dir, sysroot_ref, Tool::Rustc, &config.extra_env, "rustc ")

+ {

+ Ok(it) => it,

+ Err(e) => {

+ tracing::error!("{e}");

+ None

+ }

+ };

+ let rustc_cfg = rustc_cfg::get(None, &config.extra_env, RustcCfgConfig::Rustc(sysroot_ref));

+ let data_layout = target_data_layout::get(

+ RustcDataLayoutConfig::Rustc(sysroot_ref),

+ None,

+ &config.extra_env,

+ );

+ let cargo_script =

+ CargoWorkspace::fetch_metadata(detached_file, dir, config, sysroot_ref, &|_| ())

+ .ok()

+ .map(|ws| {

+ (

+ CargoWorkspace::new(ws, detached_file.clone()),

+ WorkspaceBuildScripts::default(),

+ )

+ });

+ Ok(ProjectWorkspace::DetachedFile {

+ file: detached_file.to_owned(),

+ sysroot,

+ rustc_cfg,

+ toolchain,

+ target_layout: data_layout.map(Arc::from).map_err(|it| Arc::from(it.to_string())),

+ cfg_overrides: config.cfg_overrides.clone(),

+ cargo_script,

+ })

+ }

+

+ pub fn load_detached_files(

+ detached_files: Vec<ManifestPath>,

+ config: &CargoConfig,

+ ) -> Vec<anyhow::Result<ProjectWorkspace>> {

+ detached_files.into_iter().map(|file| Self::load_detached_file(&file, config)).collect()

+ cargo_script: Some((cargo, _)),

+ ProjectWorkspace::Cargo { build_scripts, .. }

+ | ProjectWorkspace::DetachedFile { cargo_script: Some((_, build_scripts)), .. } => {

+ *build_scripts = bs

+ _ => assert_eq!(bs, WorkspaceBuildScripts::default()),

+ include: vec![file.as_ref().to_owned()],

+ .chain(cargo_script.iter().flat_map(|(cargo, build_scripts)| {

+ let out_dir =

+ build_scripts.get_output(pkg).and_then(|it| it.out_dir.clone());

+ include.extend(out_dir);

+ + cargo_script.as_ref().map_or(1, |(cargo, _)| cargo.packages().len())

+ if let Some((cargo, build_scripts)) = cargo_script {

+ build_scripts,

+ cargo_script: Some((cargo_script, _)),

+ cargo_script: Some((o_cargo_script, _)),

+ detached_file: &ManifestPath,

+ let _p = tracing::span!(tracing::Level::INFO, "detached_file_to_crate_graph").entered();

+ self.curr = value.clamp(0.0, 1.0);

+use project_model::{

+ target_data_layout, CargoConfig, ManifestPath, ProjectWorkspace, RustLibSource, Sysroot,

+};

+ file: ManifestPath::try_from(tmp_file).unwrap(),

+ /// `rust-project.json`, `.rs` files (which will be treated as standalone files) or JSON

+ /// objects in `rust-project.json` format.

+ .filter(|project| {

+ !exclude_dirs.iter().any(|p| project.manifest_path().starts_with(p))

+ })

+use project_model::{

+ CargoWorkspace, ManifestPath, ProjectWorkspace, Target, WorkspaceBuildScripts,

+};

+ pub(crate) detached_files: FxHashSet<ManifestPath>,

+ ProjectWorkspace::Cargo { cargo, sysroot, .. }

+ | ProjectWorkspace::DetachedFile { cargo_script: Some((cargo, _)), sysroot, .. } => {

+ Some((cargo, sysroot.as_ref().ok()))

+ ProjectWorkspace::Json { .. } => None,

+ ProjectWorkspace::DetachedFile { .. } => None,

+use project_model::{ManifestPath, ProjectWorkspace, WorkspaceBuildScripts};

+ let detached_files: Vec<_> = self

+ .config

+ .detached_files()

+ .iter()

+ .cloned()

+ .map(ManifestPath::try_from)

+ .filter_map(Result::ok)

+ .collect();

+use project_model::{

+ CargoWorkspace, ManifestPath, Metadata, ProjectWorkspace, Sysroot, WorkspaceBuildScripts,

+};

+ let meta: Metadata = get_test_json_file(file);

+ let manifest_path =

+ ManifestPath::try_from(AbsPathBuf::try_from(meta.workspace_root.clone()).unwrap()).unwrap();

+ let cargo_workspace = CargoWorkspace::new(meta, manifest_path);

+ "detachedFiles": ["/src/lib.rs"],

+ config.update(self.config).expect("invalid config");

+`rust-project.json`, `.rs` files (which will be treated as standalone files) or JSON

+objects in `rust-project.json` format.

+ "markdownDescription": "Disable project auto-discovery in favor of explicitly specified set\nof projects.\n\nElements must be paths pointing to `Cargo.toml`,\n`rust-project.json`, `.rs` files (which will be treated as standalone files) or JSON\nobjects in `rust-project.json` format.",