language-servers/rust-analyzer
1
0
Fork 0
mirror of https://github.com/rust-lang/rust-analyzer.git synced 2025-10-01 06:11:35 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 3

Add proc-macro dependency to rustc_private crates

Browse source
This commit is contained in:
Lukas Wirth 2022-11-09 20:50:18 +01:00
parent b8b1951ee8
commit 3c35d44f55
1 changed files with 45 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

77
crates/project-model/src/workspace.rs
View file

@ -509,14 +509,14 @@ impl ProjectWorkspace {
build_scripts, build_scripts,
toolchain: _, toolchain: _,
} => cargo_to_crate_graph( } => cargo_to_crate_graph(
rustc_cfg.clone(),
cfg_overrides,
load_proc_macro, load_proc_macro,
load, load,
cargo,
build_scripts,
sysroot.as_ref(),
rustc, rustc,
cargo,
sysroot.as_ref(),
rustc_cfg.clone(),
cfg_overrides,
build_scripts,
), ),
ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => { ProjectWorkspace::DetachedFiles { files, sysroot, rustc_cfg } => {
detached_files_to_crate_graph(rustc_cfg.clone(), load, files, sysroot) detached_files_to_crate_graph(rustc_cfg.clone(), load, files, sysroot)
@ -602,7 +602,7 @@ fn project_json_to_crate_graph(
for (from, krate) in project.crates() { for (from, krate) in project.crates() {
if let Some(&from) = crates.get(&from) { if let Some(&from) = crates.get(&from) {
if let Some((public_deps, libproc_macro)) = &sysroot_deps { if let Some((public_deps, libproc_macro)) = &sysroot_deps {
public_deps.add(from, &mut crate_graph); public_deps.add_to_crate_graph(&mut crate_graph, from);
if krate.is_proc_macro { if krate.is_proc_macro {
if let Some(proc_macro) = libproc_macro { if let Some(proc_macro) = libproc_macro {
add_dep( add_dep(
@ -626,14 +626,14 @@ fn project_json_to_crate_graph(
} }
fn cargo_to_crate_graph( fn cargo_to_crate_graph(
rustc_cfg: Vec<CfgFlag>,
override_cfg: &CfgOverrides,
load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult, load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
cargo: &CargoWorkspace,
build_scripts: &WorkspaceBuildScripts,
sysroot: Option<&Sysroot>,
rustc: &Option<CargoWorkspace>, rustc: &Option<CargoWorkspace>,
cargo: &CargoWorkspace,
sysroot: Option<&Sysroot>,
rustc_cfg: Vec<CfgFlag>,
override_cfg: &CfgOverrides,
build_scripts: &WorkspaceBuildScripts,
) -> CrateGraph { ) -> CrateGraph {
let _p = profile::span("cargo_to_crate_graph"); let _p = profile::span("cargo_to_crate_graph");
let mut crate_graph = CrateGraph::default(); let mut crate_graph = CrateGraph::default();
@ -642,13 +642,15 @@ fn cargo_to_crate_graph(
None => (SysrootPublicDeps::default(), None), None => (SysrootPublicDeps::default(), None),
}; };
let mut cfg_options = CfgOptions::default(); let cfg_options = {
cfg_options.extend(rustc_cfg); let mut cfg_options = CfgOptions::default();
cfg_options.extend(rustc_cfg);
cfg_options.insert_atom("debug_assertions".into());
cfg_options
};
let mut pkg_to_lib_crate = FxHashMap::default(); let mut pkg_to_lib_crate = FxHashMap::default();
cfg_options.insert_atom("debug_assertions".into());
let mut pkg_crates = FxHashMap::default(); let mut pkg_crates = FxHashMap::default();
// Does any crate signal to rust-analyzer that they need the rustc_private crates? // Does any crate signal to rust-analyzer that they need the rustc_private crates?
let mut has_private = false; let mut has_private = false;
@ -723,7 +725,7 @@ fn cargo_to_crate_graph(
// Set deps to the core, std and to the lib target of the current package // Set deps to the core, std and to the lib target of the current package
for &(from, kind) in pkg_crates.get(&pkg).into_iter().flatten() { for &(from, kind) in pkg_crates.get(&pkg).into_iter().flatten() {
// Add sysroot deps first so that a lib target named `core` etc. can overwrite them. // Add sysroot deps first so that a lib target named `core` etc. can overwrite them.
public_deps.add(from, &mut crate_graph); public_deps.add_to_crate_graph(&mut crate_graph, from);
if let Some((to, name)) = lib_tgt.clone() { if let Some((to, name)) = lib_tgt.clone() {
if to != from && kind != TargetKind::BuildScript { if to != from && kind != TargetKind::BuildScript {
@ -767,15 +769,16 @@ fn cargo_to_crate_graph(
if let Some(rustc_workspace) = rustc { if let Some(rustc_workspace) = rustc {
handle_rustc_crates( handle_rustc_crates(
&mut crate_graph, &mut crate_graph,
rustc_workspace, &mut pkg_to_lib_crate,
load, load,
load_proc_macro,
rustc_workspace,
cargo,
&public_deps,
libproc_macro,
&pkg_crates,
&cfg_options, &cfg_options,
override_cfg, override_cfg,
load_proc_macro,
&mut pkg_to_lib_crate,
&public_deps,
cargo,
&pkg_crates,
build_scripts, build_scripts,
); );
} }
@ -825,28 +828,29 @@ fn detached_files_to_crate_graph(
}, },
); );
public_deps.add(detached_file_crate, &mut crate_graph); public_deps.add_to_crate_graph(&mut crate_graph, detached_file_crate);
} }
crate_graph crate_graph
} }
fn handle_rustc_crates( fn handle_rustc_crates(
crate_graph: &mut CrateGraph, crate_graph: &mut CrateGraph,
rustc_workspace: &CargoWorkspace, pkg_to_lib_crate: &mut FxHashMap<Package, CrateId>,
load: &mut dyn FnMut(&AbsPath) -> Option<FileId>, load: &mut dyn FnMut(&AbsPath) -> Option<FileId>,
load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult,
rustc_workspace: &CargoWorkspace,
cargo: &CargoWorkspace,
public_deps: &SysrootPublicDeps,
libproc_macro: Option<CrateId>,
pkg_crates: &FxHashMap<Package, Vec<(CrateId, TargetKind)>>,
cfg_options: &CfgOptions, cfg_options: &CfgOptions,
override_cfg: &CfgOverrides, override_cfg: &CfgOverrides,
load_proc_macro: &mut dyn FnMut(&str, &AbsPath) -> ProcMacroLoadResult,
pkg_to_lib_crate: &mut FxHashMap<Package, CrateId>,
public_deps: &SysrootPublicDeps,
cargo: &CargoWorkspace,
pkg_crates: &FxHashMap<Package, Vec<(CrateId, TargetKind)>>,
build_scripts: &WorkspaceBuildScripts, build_scripts: &WorkspaceBuildScripts,
) { ) {
let mut rustc_pkg_crates = FxHashMap::default(); let mut rustc_pkg_crates = FxHashMap::default();
// The root package of the rustc-dev component is rustc_driver, so we match that // The root package of the rustc-dev component is rustc_driver, so we match that
let root_pkg = let root_pkg =
rustc_workspace.packages().find(|package| rustc_workspace[*package].name == "rustc_driver"); rustc_workspace.packages().find(|&package| rustc_workspace[package].name == "rustc_driver");
// The rustc workspace might be incomplete (such as if rustc-dev is not // The rustc workspace might be incomplete (such as if rustc-dev is not
// installed for the current toolchain) and `rustc_source` is set to discover. // installed for the current toolchain) and `rustc_source` is set to discover.
if let Some(root_pkg) = root_pkg { if let Some(root_pkg) = root_pkg {
@ -901,7 +905,16 @@ fn handle_rustc_crates(
); );
pkg_to_lib_crate.insert(pkg, crate_id); pkg_to_lib_crate.insert(pkg, crate_id);
// Add dependencies on core / std / alloc for this crate // Add dependencies on core / std / alloc for this crate
public_deps.add(crate_id, crate_graph); public_deps.add_to_crate_graph(crate_graph, crate_id);
if let Some(proc_macro) = libproc_macro {
add_dep_with_prelude(
crate_graph,
crate_id,
CrateName::new("proc_macro").unwrap(),
proc_macro,
rustc_workspace[tgt].is_proc_macro,
);
}
rustc_pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id); rustc_pkg_crates.entry(pkg).or_insert_with(Vec::new).push(crate_id);
} }
} }
@ -1009,7 +1022,7 @@ struct SysrootPublicDeps {
impl SysrootPublicDeps { impl SysrootPublicDeps {
/// Makes `from` depend on the public sysroot crates. /// Makes `from` depend on the public sysroot crates.
fn add(&self, from: CrateId, crate_graph: &mut CrateGraph) { fn add_to_crate_graph(&self, crate_graph: &mut CrateGraph, from: CrateId) {
for (name, krate, prelude) in &self.deps { for (name, krate, prelude) in &self.deps {
add_dep_with_prelude(crate_graph, from, name.clone(), *krate, *prelude); add_dep_with_prelude(crate_graph, from, name.clone(), *krate, *prelude);
} }