+salsa = { version = "0.24.0", default-features = false, features = [

+ "inventory",

+

+ pub fn contains_key(&self, arg: &str) -> bool {

+ self.entries.contains_key(arg)

+ }

+ lang_item::{LangItem, crate_lang_items},

+ let cancelled = Cancelled::catch(|| {

+ _ = hir::crate_def_map(&db, crate_id);

+ // we compute the lang items here as the work for them is also highly recursive and will be trigger by the module symbols query

+ // slowing down leaf crate analysis tremendously as we go back to being blocked on a single thread

+ _ = hir::crate_lang_items(&db, crate_id);

+ });

+pub(crate) fn inject_cargo_env(env: &mut Env, cargo_path: &Utf8Path) {

+ env.set("CARGO", cargo_path.as_str());

+use base_db::Env;

+ pub fn tool_path(&self, tool: Tool, current_dir: impl AsRef<Path>, envs: &Env) -> Utf8PathBuf {

+ match self.root() {

+ Some(root) => {

+ let mut cmd = toolchain::command(

+ Tool::Rustup.path(),

+ current_dir,

+ &envs

+ .into_iter()

+ .map(|(k, v)| (k.clone(), Some(v.clone())))

+ .collect::<FxHashMap<_, _>>(),

+ );

+ if !envs.contains_key("RUSTUP_TOOLCHAIN")

+ && std::env::var_os("RUSTUP_TOOLCHAIN").is_none()

+ {

+ cmd.env("RUSTUP_TOOLCHAIN", AsRef::<std::path::Path>::as_ref(root));

+ }

+

+ cmd.arg("which");

+ cmd.arg(tool.name());

+ (|| Some(Utf8PathBuf::from(String::from_utf8(cmd.output().ok()?.stdout).ok()?)))()

+ .unwrap_or_else(|| Utf8PathBuf::from(tool.name()))

+ }

+ _ => tool.path(),

+ }

+ }

+

+use std::thread::Builder;

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

+ let rustc_cfg = Builder::new()

+ .name("ProjectWorkspace::rustc_cfg".to_owned())

+ .spawn_scoped(s, || {

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

+ .expect("failed to spawn thread");

+ let target_data = Builder::new()

+ .name("ProjectWorkspace::target_data".to_owned())

+ .spawn_scoped(s, || {

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

+ .inspect_err(|e| {

+ tracing::error!(%e,

+ "failed fetching data layout for \

+ {cargo_toml:?} workspace"

+ )

+ })

+ .expect("failed to spawn thread");

+

+ let rustc_dir = Builder::new()

+ .name("ProjectWorkspace::rustc_dir".to_owned())

+ .spawn_scoped(s, || {

+ let rustc_dir = match rustc_source {

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

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

+ Some(RustLibSource::Discover) => {

+ sysroot.discover_rustc_src().ok_or_else(|| {

+ Some("Failed to discover rustc source for sysroot.".to_owned())

+ })

+ }

+ None => Err(None),

+ };

+ rustc_dir.and_then(|rustc_dir| {

+ "Failed to read Cargo metadata from rustc source \

+ at {rustc_dir}",

+ "Failed to read Cargo metadata from rustc source \

+ at {rustc_dir}: {e}"

+ })

+ .expect("failed to spawn thread");

+

+ let cargo_metadata = Builder::new()

+ .name("ProjectWorkspace::cargo_metadata".to_owned())

+ .spawn_scoped(s, || fetch_metadata.exec(false, progress))

+ .expect("failed to spawn thread");

+ let loaded_sysroot = Builder::new()

+ .name("ProjectWorkspace::loaded_sysroot".to_owned())

+ .spawn_scoped(s, || {

+ sysroot.load_workspace(

+ &RustSourceWorkspaceConfig::CargoMetadata(sysroot_metadata_config(

+ config,

+ workspace_dir,

+ &targets,

+ toolchain.clone(),

+ )),

+ config.no_deps,

+ progress,

+ )

+ })

+ .expect("failed to spawn thread");

+ let cargo_env = Builder::new()

+ .name("ProjectWorkspace::cargo_env".to_owned())

+ .spawn_scoped(s, move || {

+ cargo_config_env(cargo_toml, &config_file, &config.extra_env)

+ })

+ .expect("failed to spawn thread");

+ let cargo_path = sysroot.tool_path(Tool::Cargo, cargo.workspace_root(), cargo.env());

+ &cargo_path,

+ &cargo_path,

+ cargo_path: &Utf8Path,

+ cargo_path,

+ cargo_crate_name: &str,

+ cargo_path: &Utf8Path,

+ inject_cargo_env(&mut env, cargo_path);

+ inject_rustc_tool_env(&mut env, cargo_crate_name, kind);

+ Some(CrateDisplayName::from_canonical_name(cargo_crate_name)),

+ ProcMacroDylibPath::Path(path) => {

+ Ok((cargo_crate_name.to_owned(), path.clone()))

+ }

+ rayon::ThreadPoolBuilder::new()

+ .thread_name(|ix| format!("RayonWorker{}", ix))

+ .build_global()

+ .unwrap();

+

+ // delay initial cache priming until proc macros are loaded, or we will load up a bunch of garbage into salsa

+ let proc_macros_loaded = self.config.prefill_caches()

+ && !self.config.expand_proc_macros()

+ || self.fetch_proc_macros_queue.last_op_result().copied().unwrap_or(false);

+ if proc_macros_loaded {

+impl<S> Drop for SpanMap<S> {

+ fn drop(&mut self) {

+ struct SendPtr(*mut [()]);

+ unsafe impl Send for SendPtr {}

+ static SPAN_MAP_DROP_THREAD: std::sync::OnceLock<

+ std::sync::mpsc::Sender<(SendPtr, fn(SendPtr))>,

+ > = std::sync::OnceLock::new();

+ SPAN_MAP_DROP_THREAD

+ .get_or_init(|| {

+ let (sender, receiver) = std::sync::mpsc::channel::<(SendPtr, fn(SendPtr))>();

+ std::thread::Builder::new()

+ .name("SpanMapDropper".to_owned())

+ .spawn(move || receiver.iter().for_each(|(b, drop)| drop(b)))

+ .unwrap();

+ sender

+ })

+ .send((

+ unsafe {

+ SendPtr(std::mem::transmute::<*mut [(TextSize, SpanData<S>)], *mut [()]>(

+ Box::<[(TextSize, SpanData<S>)]>::into_raw(

+ std::mem::take(&mut self.spans).into_boxed_slice(),

+ ),

+ ))

+ },

+ |b: SendPtr| {

+ _ = unsafe {

+ Box::from_raw(std::mem::transmute::<

+ *mut [()],

+ *mut [(TextSize, SpanData<S>)],

+ >(b.0))

+ }

+ },

+ ))

+ .unwrap();

+ }

+}

+

+ green: Option<GreenNode>,

+ green: Some(green),

+ SyntaxNode::new_root(self.green.as_ref().unwrap().clone())

+ pub fn to_syntax(mut self) -> Parse<SyntaxNode> {

+ let green = self.green.take();

+ let errors = self.errors.take();

+ Parse { green, errors, _ty: PhantomData }

+ pub fn cast<N: AstNode>(mut self) -> Option<Parse<N>> {

+ Some(Parse { green: self.green.take(), errors: self.errors.take(), _ty: PhantomData })

+ green: Some(green_node),

+impl<T> Drop for Parse<T> {

+ fn drop(&mut self) {

+ let Some(green) = self.green.take() else {

+ return;

+ };

+ static PARSE_DROP_THREAD: std::sync::OnceLock<std::sync::mpsc::Sender<GreenNode>> =

+ std::sync::OnceLock::new();

+ PARSE_DROP_THREAD

+ .get_or_init(|| {

+ let (sender, receiver) = std::sync::mpsc::channel::<GreenNode>();

+ std::thread::Builder::new()

+ .name("ParseNodeDropper".to_owned())

+ .spawn(move || receiver.iter().for_each(drop))

+ .unwrap();

+ sender

+ })

+ .send(green)

+ .unwrap();

+ }

+}

+