use toolchain::Tool;

use crate::{CfgOverrides, InvocationStrategy};

/// [`CargoWorkspace`] represents the logical structure of, well, a Cargo

/// workspace. It pretty closely mirrors `cargo metadata` output.

pub target: Option<String>,

/// Sysroot loading behavior

pub sysroot: Option<RustLibSource>,

pub sysroot_src: Option<AbsPathBuf>,

/// rustc private crate source

pub rustc_source: Option<RustLibSource>,

}

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

CargoMetadata(CargoMetadataConfig),

}

fn default() -> Self {

}

}

//! but we can't process `.rlib` and need source code instead. The source code

//! is typically installed with `rustup component add rust-src` command.

use anyhow::{format_err, Result};

use base_db::CrateName;

use la_arena::{Arena, Idx};

use paths::{AbsPath, AbsPathBuf, Utf8PathBuf};

use rustc_hash::FxHashMap;

use toolchain::{probe_for_binary, Tool};

use crate::{

cargo_workspace::CargoMetadataConfig, utf8_stdout, CargoWorkspace, ManifestPath,

};

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

pub struct Sysroot {

root: Option<AbsPathBuf>,

src_root: Option<AbsPathBuf>,

error: Option<String>,

}

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

Workspace(CargoWorkspace),

Stitched(Stitched),

Empty,

impl Sysroot {

pub const fn empty() -> Sysroot {

}

/// Returns sysroot "root" directory, where `bin/`, `etc/`, `lib/`, `libexec/`

}

pub fn is_empty(&self) -> bool {

}

}

}

pub fn num_packages(&self) -> usize {

}

}

}

}

impl Sysroot {

/// Attempts to discover the toolchain's sysroot from the given `dir`.

let sysroot_dir = discover_sysroot_dir(dir, extra_env);

let sysroot_src_dir = sysroot_dir.as_ref().ok().map(|sysroot_dir| {

discover_sysroot_src_dir_or_add_component(sysroot_dir, dir, extra_env)

});

}

pub fn discover_with_src_override(

current_dir: &AbsPath,

extra_env: &FxHashMap<String, String>,

sysroot_src_dir: AbsPathBuf,

) -> Sysroot {

let sysroot_dir = discover_sysroot_dir(current_dir, extra_env);

}

let sysroot_src_dir = discover_sysroot_src_dir(&sysroot_dir)

.ok_or_else(|| format_err!("can't find standard library sources in {sysroot_dir}"));

}

pub fn discover_rustc_src(&self) -> Option<ManifestPath> {

get_rustc_src(self.root()?)

}

/// Returns a command to run a tool preferring the cargo proxies if the sysroot exists.

pub fn tool(&self, tool: Tool, current_dir: impl AsRef<Path>) -> Command {

match self.root() {

})

}

sysroot_dir: Option<Result<AbsPathBuf, anyhow::Error>>,

sysroot_src_dir: Option<Result<AbsPathBuf, anyhow::Error>>,

) -> Sysroot {

Some(Ok(sysroot_dir)) => Some(sysroot_dir),

Some(Err(e)) => {

}

None => None,

};

Some(Err(e)) => {

}

};

if fs::metadata(&library_manifest).is_ok() {

}

}

}

let mut stitched = Stitched { crates: Arena::default() };

let name = path.split('/').last().unwrap();

let root = [format!("{path}/src/lib.rs"), format!("lib{path}/lib.rs")]

.into_iter()

.filter_map(|it| ManifestPath::try_from(it).ok())

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

}

}

}

}

}

fn load_library_via_cargo(

library_manifest: ManifestPath,

sysroot_src_dir: &AbsPathBuf,

cargo_config: &CargoMetadataConfig,

tracing::debug!("Loading library metadata: {library_manifest}");

let mut cargo_config = cargo_config.clone();

// the sysroot uses `public-dependency`, so we make cargo think it's a nightly

});

let cargo_workspace = CargoWorkspace::new(res, library_manifest, Default::default());

}

}

use triomphe::Arc;

use crate::{

};

fn load_cargo(file: &str) -> (CrateGraph, ProcMacroPaths) {

// fake sysroot, so we give them both the same path:

let sysroot_dir = AbsPathBuf::assert(sysroot_path);

let sysroot_src_dir = sysroot_dir.clone();

}

fn rooted_project_json(data: ProjectJsonData) -> ProjectJson {

let manifest_path =

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

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

AbsPath::assert(Utf8Path::new(env!("CARGO_MANIFEST_DIR"))),

&Default::default(),

);

let project_workspace = ProjectWorkspace {

kind: ProjectWorkspaceKind::Cargo {

cargo: cargo_workspace,

cargo_workspace::{CargoMetadataConfig, DepKind, PackageData, RustLibSource},

env::{cargo_config_env, inject_cargo_env, inject_cargo_package_env, inject_rustc_tool_env},

project_json::{Crate, CrateArrayIdx},

toolchain_info::{rustc_cfg, target_data_layout, target_triple, QueryConfig},

utf8_stdout, CargoConfig, CargoWorkspace, CfgOverrides, InvocationStrategy, ManifestPath,

};

use tracing::{debug, error, info};

config: &CargoConfig,

progress: &dyn Fn(String),

) -> Result<ProjectWorkspace, anyhow::Error> {

(Some(RustLibSource::Discover), Some(sysroot_src)) => {

Sysroot::discover_with_src_override(

cargo_toml.parent(),

&config.extra_env,

sysroot_src.clone(),

)

}

(Some(RustLibSource::Path(path)), None) => {

}

(None, _) => Sysroot::empty(),

};

let rustc_dir = match &config.rustc_source {

Some(RustLibSource::Path(path)) => ManifestPath::try_from(path.clone())

.map_err(|p| Some(format!("rustc source path is not absolute: {p}"))),

&config.extra_env,

)

.unwrap_or_default();

let rustc = rustc_dir.and_then(|rustc_dir| {

info!(workspace = %cargo_toml, rustc_dir = %rustc_dir, "Using rustc source");

match CargoWorkspace::fetch_metadata(

}

pub fn load_inline(project_json: ProjectJson, config: &CargoConfig) -> ProjectWorkspace {

let query_config = QueryConfig::Rustc(&sysroot, project_json.path().as_ref());

let toolchain = match get_toolchain_version(

project_json.path(),

config: &CargoConfig,

) -> anyhow::Result<ProjectWorkspace> {

let dir = detached_file.parent();

None => Sysroot::empty(),

};

&config.extra_env,

)

.unwrap_or_default();

let query_config = QueryConfig::Rustc(&sysroot, dir.as_ref());

let rustc_cfg = rustc_cfg::get(query_config, None, &config.extra_env);

let data_layout = target_data_layout::get(query_config, None, &config.extra_env);

/// the root is a member of the current workspace

pub fn to_roots(&self) -> Vec<PackageRoot> {

let mk_sysroot = || {

.packages()

.filter_map(|pkg| {

if ws[pkg].is_local {

Some(PackageRoot { is_local: false, include, exclude })

})

.collect(),

};

r.push(PackageRoot {

load: FileLoader<'_>,

) -> (SysrootPublicDeps, Option<CrateId>) {

let _p = tracing::info_span!("sysroot_to_crate_graph").entered();

let (mut cg, mut pm) = cargo_to_crate_graph(

load,

None,

(SysrootPublicDeps { deps: pub_deps }, libproc_macro)

}

let cfg_options = Arc::new({

let mut cfg_options = CfgOptions::default();

cfg_options.extend(rustc_cfg);

stitched.proc_macro().and_then(|it| sysroot_crates.get(&it).copied());

(public_deps, libproc_macro)

}

}

}

tracing::warn!("{}", err)

}

}

use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice};

use oorandom::Rand32;

use profile::{Bytes, StopWatch};

use rayon::prelude::*;

use rustc_hash::{FxHashMap, FxHashSet};

use syntax::{AstNode, SyntaxNode};

true => None,

false => Some(RustLibSource::Discover),

},

all_targets: true,

set_test: !self.no_test,

cfg_overrides: CfgOverrides {

optional --with-deps

/// Don't load sysroot crates (`std`, `core` & friends).

optional --no-sysroot

/// Don't set #[cfg(test)].

optional --no-test

pub only: Option<String>,

pub with_deps: bool,

pub no_sysroot: bool,

pub no_test: bool,

pub disable_build_scripts: bool,

pub disable_proc_macros: bool,

use project_model::toolchain_info::{target_data_layout, QueryConfig};

use project_model::{

CargoConfig, ManifestPath, ProjectWorkspace, ProjectWorkspaceKind, RustLibSource, Sysroot,

};

use load_cargo::{load_workspace, LoadCargoConfig, ProcMacroServerChoice};

..Default::default()

};

let data_layout = target_data_layout::get(

QueryConfig::Rustc(&sysroot, tmp_file.parent().unwrap().as_ref()),

None,

use itertools::Itertools;

use paths::{Utf8Path, Utf8PathBuf};

use project_model::{

};

use rustc_hash::{FxHashMap, FxHashSet};

use semver::Version;

///

/// This option does not take effect until rust-analyzer is restarted.

cargo_sysroot: Option<String> = Some("discover".to_owned()),

/// Relative path to the sysroot library sources. If left unset, this will default to

/// `{cargo.sysroot}/lib/rustlib/src/rust/library`.

///

},

target: self.cargo_target(source_root).clone(),

sysroot,

sysroot_src,

rustc_source,

cfg_overrides: project_model::CfgOverrides {

Concrete(usize),

}

macro_rules! _default_val {

(@verbatim: $s:literal, $ty:ty) => {{

let default_: $ty = serde_json::from_str(&$s).unwrap();

}

]

},

"Option<MaxSubstitutionLength>" => set! {

"anyOf": [

{

return;

}

&AbsPathBuf::assert_utf8(std::env::current_dir().unwrap()),

&Default::default(),

);

let proc_macro_server_path = sysroot.discover_proc_macro_srv().unwrap();

This option does not take effect until rust-analyzer is restarted.

--

[[rust-analyzer.cargo.sysrootSrc]]rust-analyzer.cargo.sysrootSrc (default: `null`)::

+

--

{

"title": "cargo",

"properties": {

"rust-analyzer.cargo.sysrootSrc": {

"markdownDescription": "Relative path to the sysroot library sources. If left unset, this will default to\n`{cargo.sysroot}/lib/rustlib/src/rust/library`.\n\nThis option does not take effect until rust-analyzer is restarted.",

"default": null,