use anyhow::Context;

use base_db::{

CrateBuilderId, CrateDisplayName, CrateGraphBuilder, CrateName, CrateOrigin,

};

use cfg::{CfgAtom, CfgDiff, CfgOptions};

use intern::{Symbol, sym};

use rustc_hash::{FxHashMap, FxHashSet};

use semver::Version;

use span::{Edition, FileId};

use tracing::instrument;

use triomphe::Arc;

ProjectJson, ProjectManifest, RustSourceWorkspaceConfig, Sysroot, TargetData, TargetKind,

WorkspaceBuildScripts,

build_dependencies::BuildScriptOutput,

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

project_json::{Crate, CrateArrayIdx},

sysroot::RustLibSrcWorkspace,

toolchain_info::{QueryConfig, rustc_cfg, target_data_layout, target_tuple, version},

};

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

pub fn load(

manifest: ProjectManifest,

config: &CargoConfig,

) -> anyhow::Result<ProjectWorkspace> {

ProjectWorkspace::load_inner(&manifest, config, progress)

.with_context(|| format!("Failed to load the project at {manifest}"))

fn load_inner(

manifest: &ProjectManifest,

config: &CargoConfig,

) -> anyhow::Result<ProjectWorkspace> {

let res = match manifest {

ProjectManifest::ProjectJson(project_json) => {

fn load_cargo(

cargo_toml: &ManifestPath,

config: &CargoConfig,

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

let CargoConfig {

features,

rustc_source,

no_deps,

..

} = config;

let mut sysroot = match (sysroot, sysroot_src) {

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

}

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

Sysroot::discover_rust_lib_src_dir(path.clone())

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

};

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

let targets =

target_tuple::get(toolchain_config, target.as_deref(), extra_env).unwrap_or_default();

// We spawn a bunch of processes to query various information about the workspace's

// toolchain and sysroot

// We can speed up loading a bit by spawning all of these processes in parallel (especially

// on systems were process spawning is delayed)

let join = thread::scope(|s| {

let rustc_cfg = s.spawn(|| {

rustc_cfg::get(toolchain_config, targets.first().map(Deref::deref), extra_env)

});

};

rustc_dir.and_then(|rustc_dir| {

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

&rustc_dir,

workspace_dir,

&CargoMetadataConfig {

targets: targets.clone(),

extra_args: extra_args.clone(),

extra_env: extra_env.clone(),

},

&sysroot,

*no_deps,

Ok((meta, _error)) => {

let workspace = CargoWorkspace::new(

meta,

})

});

workspace_dir,

)

});

let cargo_config_extra_env =

thread::Result::Ok((

rustc_cfg.join()?,

data_layout.join()?,

rustc_dir.join()?,

});

let (

rustc_cfg,

data_layout,

loaded_sysroot,

cargo_metadata,

cargo_config_extra_env,

})?;

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

if let Some(loaded_sysroot) = loaded_sysroot {

sysroot.set_workspace(loaded_sysroot);

}

Ok(ProjectWorkspace {

kind: ProjectWorkspaceKind::Cargo {

cargo,

pub fn load_inline(

mut project_json: ProjectJson,

config: &CargoConfig,

) -> ProjectWorkspace {

let mut sysroot =

Sysroot::new(project_json.sysroot.clone(), project_json.sysroot_src.clone());

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

let sysroot_project = project_json.sysroot_project.take();

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

let targets = target_tuple::get(query_config, config.target.as_deref(), &config.extra_env)

.unwrap_or_default();

// We spawn a bunch of processes to query various information about the workspace's

// toolchain and sysroot

// We can speed up loading a bit by spawning all of these processes in parallel (especially

// on systems were process spawning is delayed)

let join = thread::scope(|s| {

let rustc_cfg = s.spawn(|| {

rustc_cfg::get(query_config, targets.first().map(Deref::deref), &config.extra_env)

});

});

let loaded_sysroot = s.spawn(|| {

if let Some(sysroot_project) = sysroot_project {

} else {

}

});

});

Ok(it) => it,

Err(e) => std::panic::resume_unwind(e),

};

None => Sysroot::empty(),

};

let toolchain = version::get(query_config, &config.extra_env).ok().flatten();

let targets = target_tuple::get(query_config, config.target.as_deref(), &config.extra_env)

.unwrap_or_default();

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

if let Some(loaded_sysroot) = loaded_sysroot {

sysroot.set_workspace(loaded_sysroot);

}

detached_file,

dir,

&CargoMetadataConfig {

targets,

extra_args: config.extra_args.clone(),

extra_env: config.extra_env.clone(),

},

&sysroot,

config.no_deps,

Ok(ProjectWorkspace {

kind: ProjectWorkspaceKind::DetachedFile {

match &self.kind {

ProjectWorkspaceKind::DetachedFile { cargo: Some((cargo, _, None)), .. }

| ProjectWorkspaceKind::Cargo { cargo, error: None, .. } => {

}

_ => Ok(WorkspaceBuildScripts::default()),

}

}

}

self.sysroot.discover_proc_macro_srv()

}

// Mapping of a package to its library target

let mut pkg_to_lib_crate = FxHashMap::default();

let mut pkg_crates = FxHashMap::default();

let workspace_proc_macro_cwd = Arc::new(cargo.workspace_root().to_path_buf());

// Next, create crates for each package, target pair

for pkg in cargo.packages() {

let cfg_options = {

let mut cfg_options = cfg_options.clone();

add_dep(crate_graph, from, name, to);

}

// If the user provided a path to rustc sources, we add all the rustc_private crates

// and create dependencies on them for the crates which opt-in to that

if let Some((rustc_workspace, rustc_build_scripts)) = rustc {

Some((BuildScriptOutput { proc_macro_dylib_path, .. }, has_errors)) => {

match proc_macro_dylib_path {

Some(path) => Ok((cargo_name.to_owned(), path.clone())),

}

}

};

proc_macros.insert(crate_id, proc_macro);

}

}

fn sysroot_metadata_config(

targets: &[String],

) -> CargoMetadataConfig {

CargoMetadataConfig {

features: Default::default(),

targets: targets.to_vec(),

extra_args: Default::default(),

}

}