/// Describes how to set the rustc source directory.

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

/// Explicit path for the rustc source directory.

Path(AbsPathBuf),

/// Try to automatically detect where the rustc source directory is.

/// rustc target

pub target: Option<String>,

/// Sysroot loading behavior

pub sysroot_src: Option<AbsPathBuf>,

/// rustc private crate source

/// crates to disable `#[cfg(test)]` on

pub unset_test_crates: UnsetTestCrates,

/// Invoke `cargo check` through the RUSTC_WRAPPER.

build_scripts::WorkspaceBuildScripts,

cargo_workspace::{

CargoConfig, CargoFeatures, CargoWorkspace, Package, PackageData, PackageDependency,

},

manifest_path::ManifestPath,

project_json::{ProjectJson, ProjectJsonData},

let project_workspace = ProjectWorkspace::Cargo {

cargo: cargo_workspace,

build_scripts: WorkspaceBuildScripts::default(),

rustc_cfg: Vec::new(),

cfg_overrides,

toolchain: None,

fn load_rust_project(file: &str) -> CrateGraph {

let data = get_test_json_file(file);

let project = rooted_project_json(data);

let project_workspace = ProjectWorkspace::Json { project, sysroot, rustc_cfg: Vec::new() };

to_crate_graph(project_workspace)

}

use crate::{

build_scripts::BuildScriptOutput,

cfg_flag::CfgFlag,

rustc_cfg,

sysroot::SysrootCrate,

Cargo {

cargo: CargoWorkspace,

build_scripts: WorkspaceBuildScripts,

/// Holds cfg flags for the current target. We get those by running

/// `rustc --print cfg`.

///

target_layout: Result<String, String>,

},

/// Project workspace was manually specified using a `rust-project.json` file.

// FIXME: The primary limitation of this approach is that the set of detached files needs to be fixed at the beginning.

// That's not the end user experience we should strive for.

// Ideally, you should be able to just open a random detached file in existing cargo projects, and get the basic features working.

// //

/// Project with a set of disjoint files, not belonging to any particular workspace.

/// Backed by basic sysroot crates for basic completion and highlighting.

}

impl fmt::Debug for ProjectWorkspace {

.debug_struct("Cargo")

.field("root", &cargo.workspace_root().file_name())

.field("n_packages", &cargo.packages().len())

.field(

"n_rustc_compiler_crates",

&rustc.as_ref().map_or(0, |(rc, _)| rc.packages().len()),

ProjectWorkspace::Json { project, sysroot, rustc_cfg } => {

let mut debug_struct = f.debug_struct("Json");

debug_struct.field("n_crates", &project.n_crates());

debug_struct.field("n_sysroot_crates", &sysroot.crates().len());

}

debug_struct.field("n_rustc_cfg", &rustc_cfg.len());

ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => f

.debug_struct("DetachedFiles")

.field("n_files", &files.len())

.field("n_rustc_cfg", &rustc_cfg.len())

.finish(),

}

let cargo = CargoWorkspace::new(meta);

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

}

}

}

cargo_toml.parent(),

&config.extra_env,

sysroot_src.clone(),

}

};

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

}

let rustc_dir = match &config.rustc_source {

}

};

}

}

let rustc_cfg =

rustc_cfg::get(Some(&cargo_toml), config.target.as_deref(), &config.extra_env);

extra_env: &FxHashMap<String, String>,

) -> ProjectWorkspace {

let sysroot = match (project_json.sysroot.clone(), project_json.sysroot_src.clone()) {

(Some(sysroot), None) => {

// assume sysroot is structured like rustup's and guess `sysroot_src`

let sysroot_src =

sysroot.join("lib").join("rustlib").join("src").join("rust").join("library");

}

(None, Some(sysroot_src)) => {

// assume sysroot is structured like rustup's and guess `sysroot`

for _ in 0..5 {

sysroot.pop();

}

}

};

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

}

config: &CargoConfig,

) -> Result<ProjectWorkspace> {

let sysroot = match &config.sysroot {

let dir = &detached_files

.first()

.and_then(|it| it.parent())

.ok_or_else(|| format_err!("No detached files to load"))?;

}

};

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

}

let rustc_cfg = rustc_cfg::get(None, None, &Default::default());

pub fn find_sysroot_proc_macro_srv(&self) -> Option<AbsPathBuf> {

match self {

let standalone_server_name =

format!("rust-analyzer-proc-macro-srv{}", std::env::consts::EXE_SUFFIX);

["libexec", "lib"]

/// The return type contains the path and whether or not

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

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

sysroot.map(|sysroot| PackageRoot {

// mark the sysroot as mutable if it is located inside of the project

is_local: project_root

load_proc_macro,

load,

project,

extra_env,

Err("rust-project.json projects have no target layout set".into()),

),

} => cargo_to_crate_graph(

load_proc_macro,

load,

cargo,

rustc_cfg.clone(),

cfg_overrides,

build_scripts,

rustc_cfg.clone(),

load,

files,

Err("detached file projects have no target layout set".into()),

)

}

fn cargo_to_crate_graph(

load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult,

load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,

cargo: &CargoWorkspace,

sysroot: Option<&Sysroot>,

rustc_cfg: Vec<CfgFlag>,

rustc_cfg: Vec<CfgFlag>,

load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,

detached_files: &[AbsPathBuf],

target_layout: TargetLayoutLoadResult,

) -> CrateGraph {

let _p = profile::span("detached_files_to_crate_graph");

use itertools::Itertools;

use oorandom::Rand32;

use profile::{Bytes, StopWatch};

use rayon::prelude::*;

use rustc_hash::FxHashSet;

use stdx::format_to;

let mut cargo_config = CargoConfig::default();

cargo_config.sysroot = match self.no_sysroot {

true => None,

};

let no_progress = &|_| ();

//! Analyze all modules in a project for diagnostics. Exits with a non-zero

//! status code if any errors are found.

use rustc_hash::FxHashSet;

use hir::{db::HirDatabase, Crate, Module};

impl flags::Diagnostics {

pub fn run(self) -> anyhow::Result<()> {

let mut cargo_config = CargoConfig::default();

let load_cargo_config = LoadCargoConfig {

load_out_dirs_from_check: !self.disable_build_scripts,

with_proc_macro_server: ProcMacroServerChoice::Sysroot,

use ide_db::base_db::salsa::{self, ParallelDatabase};

use ide_db::line_index::WideEncoding;

use lsp_types::{self, lsif};

use vfs::{AbsPathBuf, Vfs};

use crate::cli::load_cargo::ProcMacroServerChoice;

eprintln!("Generating LSIF started...");

let now = Instant::now();

let mut cargo_config = CargoConfig::default();

let no_progress = &|_| ();

let load_cargo_config = LoadCargoConfig {

load_out_dirs_from_check: true,

TokenStaticData,

};

use ide_db::LineIndexDatabase;

use scip::types as scip_types;

use std::env;

eprintln!("Generating SCIP start...");

let now = Instant::now();

let mut cargo_config = CargoConfig::default();

let no_progress = &|s| (eprintln!("rust-analyzer: Loading {s}"));

let load_cargo_config = LoadCargoConfig {

//! Applies structured search replace rules from the command line.

use ide_ssr::MatchFinder;

use crate::cli::{

flags,

pub fn run(self) -> Result<()> {

use ide_db::base_db::SourceDatabaseExt;

let mut cargo_config = CargoConfig::default();

let load_cargo_config = LoadCargoConfig {

load_out_dirs_from_check: true,

with_proc_macro_server: ProcMacroServerChoice::Sysroot,

use itertools::Itertools;

use lsp_types::{ClientCapabilities, MarkupKind};

use project_model::{

UnsetTestCrates,

};

use rustc_hash::{FxHashMap, FxHashSet};

pub fn cargo(&self) -> CargoConfig {

let rustc_source = self.data.rustc_source.as_ref().map(|rustc_src| {

if rustc_src == "discover" {

} else {

}

});

let sysroot = self.data.cargo_sysroot.as_ref().map(|sysroot| {

if sysroot == "discover" {

} else {

}

});

let sysroot_src =

&& self.fetch_workspaces_queue.op_requested()

{

status.health = lsp_ext::Health::Warning;

}

if self.config.linked_projects().is_empty()

&& self.config.detached_files().is_empty()

message.push_str("Failed to discover workspace.\n\n");

}

if let Err(_) = self.fetch_workspace_error() {

status.health = lsp_ext::Health::Error;

}

if !message.is_empty() {