use span::Edition;

use toolchain::Tool;

use crate::{CfgOverrides, InvocationStrategy};

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

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>,

};

Ok(res)

}

use rustc_hash::FxHashMap;

use toolchain::{probe_for_binary, Tool};

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

pub struct Sysroot {

// FIXME: Expose a builder api as loading the sysroot got way too modular and complicated.

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> {

})

}

}

fn load_core_check(

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

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

) -> Sysroot {

if sysroot.error.is_none() {

if let Some(src_root) = &sysroot.src_root {

let has_core = match &sysroot.mode {

fn load_(

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

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

) -> Sysroot {

let sysroot_dir = match sysroot_dir {

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

}

}

};

}

}

tracing::debug!("Stitching sysroot library: {sysroot_src_dir}");

use crate::{

sysroot::SysrootMode, workspace::ProjectWorkspaceKind, CargoWorkspace, CfgOverrides,

};

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 sysroot = Sysroot::discover(

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

&Default::default(),

);

assert!(matches!(sysroot.mode(), SysrootMode::Workspace(_)));

let project_workspace = ProjectWorkspace {

let project_location = project_json.parent().to_path_buf();

let project_json: ProjectJson =

ProjectJson::new(Some(project_json.clone()), &project_location, data);

}

ProjectManifest::CargoScript(rust_file) => {

ProjectWorkspace::load_detached_file(rust_file, config)?

}

ProjectManifest::CargoToml(cargo_toml) => {

let sysroot = match (&config.sysroot, &config.sysroot_src) {

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

Sysroot::discover_with_src_override(

cargo_toml.parent(),

&config.extra_env,

sysroot_src.clone(),

)

}

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

};

tracing::info!(workspace = %cargo_toml, src_root = ?sysroot.src_root(), root = ?sysroot.root(), "Using sysroot");

Ok(res)

}

let cfg_config = RustcCfgConfig::Rustc(&sysroot);

let data_layout_config = RustcDataLayoutConfig::Rustc(&sysroot);

let toolchain = match get_toolchain_version(

project_json.path(),

&sysroot,

Tool::Rustc,

"rustc ",

) {

Ok(it) => it,

}

};

ProjectWorkspace {

kind: ProjectWorkspaceKind::Json(project_json),

sysroot,

rustc_cfg,

toolchain,

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

}

}

) -> anyhow::Result<ProjectWorkspace> {

let dir = detached_file.parent();

let sysroot = match &config.sysroot {

None => Sysroot::empty(),

};

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::target_data_layout::RustcDataLayoutConfig;

use project_model::{

target_data_layout, CargoConfig, ManifestPath, ProjectWorkspace, ProjectWorkspaceKind,

};

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

..Default::default()

};

let data_layout = target_data_layout::get(

RustcDataLayoutConfig::Rustc(&sysroot),

None,

///

/// 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();

}

]

},

_ => panic!("missing entry for {ty}: {default} (field {field})"),

}

LinkedProject::InlineJsonProject(it) => {

let workspace = project_model::ProjectWorkspace::load_inline(

it.clone(),

);

Ok(workspace)

}

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,