user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

rustc_metadata: Use CrateSource where appropriate

Browse source
This commit is contained in:
Vadim Petrochenkov 2019-10-06 16:42:14 +03:00
parent e8c28e24b9
commit b476f2fa4e
3 changed files with 43 additions and 67 deletions
Download patch file Download diff file Expand all files Collapse all files

6
src/librustc/middle/cstore.rs
View file

@ -32,6 +32,12 @@ pub struct CrateSource {
pub rmeta: Option<(PathBuf, PathKind)>,
}
impl CrateSource {
pub fn paths(&self) -> impl Iterator<Item = &PathBuf> {
self.dylib.iter().chain(self.rlib.iter()).chain(self.rmeta.iter()).map(|p| &p.0)
}
}
#[derive(RustcEncodable, RustcDecodable, Copy, Clone,
Ord, PartialOrd, Eq, PartialEq, Debug, HashStable)]
pub enum DepKind {

34
src/librustc_metadata/creader.rs
View file

@ -34,9 +34,7 @@ use log::{debug, info, log_enabled};
use proc_macro::bridge::client::ProcMacro;
crate struct Library {
pub dylib: Option<(PathBuf, PathKind)>,
pub rlib: Option<(PathBuf, PathKind)>,
pub rmeta: Option<(PathBuf, PathKind)>,
pub source: CrateSource,
pub metadata: MetadataBlob,
}
@ -197,10 +195,10 @@ impl<'a> CrateLoader<'a> {
dep_kind: DepKind,
name: Symbol
) -> (CrateNum, Lrc<cstore::CrateMetadata>) {
let _prof_timer =
self.sess.prof.generic_activity("metadata_register_crate");
let _prof_timer = self.sess.prof.generic_activity("metadata_register_crate");
let crate_root = lib.metadata.get_root();
let Library { source, metadata } = lib;
let crate_root = metadata.get_root();
self.verify_no_symbol_conflicts(span, &crate_root);
let private_dep = self.sess.opts.externs.get(&name.as_str())
@ -218,28 +216,22 @@ impl<'a> CrateLoader<'a> {
let root = if let Some(root) = root {
root
} else {
crate_paths = CratePaths {
ident: crate_root.name.to_string(),
dylib: lib.dylib.clone().map(|p| p.0),
rlib: lib.rlib.clone().map(|p| p.0),
rmeta: lib.rmeta.clone().map(|p| p.0),
};
crate_paths = CratePaths { name: crate_root.name, source: source.clone() };
&crate_paths
};
let Library { dylib, rlib, rmeta, metadata } = lib;
let cnum_map = self.resolve_crate_deps(root, &crate_root, &metadata, cnum, span, dep_kind);
let dependencies: Vec<CrateNum> = cnum_map.iter().cloned().collect();
let raw_proc_macros = crate_root.proc_macro_data.map(|_| {
let temp_root;
let (dlsym_dylib, dlsym_root) = match &host_lib {
let (dlsym_source, dlsym_root) = match &host_lib {
Some(host_lib) =>
(&host_lib.dylib, { temp_root = host_lib.metadata.get_root(); &temp_root }),
None => (&dylib, &crate_root),
(&host_lib.source, { temp_root = host_lib.metadata.get_root(); &temp_root }),
None => (&source, &crate_root),
};
let dlsym_dylib = dlsym_dylib.as_ref().expect("no dylib for a proc-macro crate");
let dlsym_dylib = dlsym_source.dylib.as_ref().expect("no dylib for a proc-macro crate");
self.dlsym_proc_macros(&dlsym_dylib.0, dlsym_root.disambiguator, span)
});
@ -268,11 +260,7 @@ impl<'a> CrateLoader<'a> {
source_map_import_info: RwLock::new(vec![]),
alloc_decoding_state: AllocDecodingState::new(interpret_alloc_index),
dep_kind: Lock::new(dep_kind),
source: CrateSource {
dylib,
rlib,
rmeta,
},
source,
private_dep,
raw_proc_macros,
dep_node_index: AtomicCell::new(DepNodeIndex::INVALID),
@ -558,7 +546,7 @@ impl<'a> CrateLoader<'a> {
(data.source.dylib.clone(), PMDSource::Registered(data))
}
LoadResult::Loaded(library) => {
let dylib = library.dylib.clone();
let dylib = library.source.dylib.clone();
let metadata = PMDSource::Owned(library);
(dylib, metadata)
}

70
src/librustc_metadata/locator.rs
View file

@ -219,7 +219,7 @@ use crate::schema::{METADATA_HEADER, rustc_version};
use rustc_data_structures::fx::FxHashSet;
use rustc_data_structures::svh::Svh;
use rustc_data_structures::sync::MetadataRef;
use rustc::middle::cstore::MetadataLoader;
use rustc::middle::cstore::{CrateSource, MetadataLoader};
use rustc::session::{config, Session};
use rustc::session::filesearch::{FileSearch, FileMatches, FileDoesntMatch};
use rustc::session::search_paths::PathKind;
@ -274,10 +274,8 @@ crate struct Context<'a> {
}
crate struct CratePaths {
pub ident: String,
pub dylib: Option<PathBuf>,
pub rlib: Option<PathBuf>,
pub rmeta: Option<PathBuf>,
pub name: Symbol,
pub source: CrateSource,
}
#[derive(Copy, Clone, PartialEq)]
@ -297,12 +295,6 @@ impl fmt::Display for CrateFlavor {
}
}
impl CratePaths {
fn paths(&self) -> Vec<PathBuf> {
self.dylib.iter().chain(self.rlib.iter()).chain(self.rmeta.iter()).cloned().collect()
}
}
impl<'a> Context<'a> {
crate fn reset(&mut self) {
self.rejected_via_hash.clear();
@ -324,7 +316,7 @@ impl<'a> Context<'a> {
crate fn report_errs(self) -> ! {
let add = match self.root {
None => String::new(),
Some(r) => format!(" which `{}` depends on", r.ident),
Some(r) => format!(" which `{}` depends on", r.name),
};
let mut msg = "the following crate versions were found:".to_string();
let mut err = if !self.rejected_via_hash.is_empty() {
@ -342,8 +334,8 @@ impl<'a> Context<'a> {
match self.root {
None => {}
Some(r) => {
for path in r.paths().iter() {
msg.push_str(&format!("\ncrate `{}`: {}", r.ident, path.display()));
for path in r.source.paths() {
msg.push_str(&format!("\ncrate `{}`: {}", r.name, path.display()));
}
}
}
@ -535,18 +527,8 @@ impl<'a> Context<'a> {
// search is being performed for.
let mut libraries = FxHashMap::default();
for (_hash, (rlibs, rmetas, dylibs)) in candidates {
let mut slot = None;
let rlib = self.extract_one(rlibs, CrateFlavor::Rlib, &mut slot);
let rmeta = self.extract_one(rmetas, CrateFlavor::Rmeta, &mut slot);
let dylib = self.extract_one(dylibs, CrateFlavor::Dylib, &mut slot);
if let Some((h, m)) = slot {
libraries.insert(h,
Library {
dylib,
rlib,
rmeta,
metadata: m,
});
if let Some((svh, lib)) = self.extract_lib(rlibs, rmetas, dylibs) {
libraries.insert(svh, lib);
}
}
@ -564,7 +546,7 @@ impl<'a> Context<'a> {
self.crate_name);
let candidates = libraries.iter().filter_map(|(_, lib)| {
let crate_name = &lib.metadata.get_root().name.as_str();
match &(&lib.dylib, &lib.rlib) {
match &(&lib.source.dylib, &lib.source.rlib) {
&(&Some((ref pd, _)), &Some((ref pr, _))) => {
Some(format!("\ncrate `{}`: {}\n{:>padding$}",
crate_name,
@ -585,6 +567,21 @@ impl<'a> Context<'a> {
}
}
fn extract_lib(
&mut self,
rlibs: FxHashMap<PathBuf, PathKind>,
rmetas: FxHashMap<PathBuf, PathKind>,
dylibs: FxHashMap<PathBuf, PathKind>,
) -> Option<(Svh, Library)> {
let mut slot = None;
let source = CrateSource {
rlib: self.extract_one(rlibs, CrateFlavor::Rlib, &mut slot),
rmeta: self.extract_one(rmetas, CrateFlavor::Rmeta, &mut slot),
dylib: self.extract_one(dylibs, CrateFlavor::Dylib, &mut slot),
};
slot.map(|(svh, metadata)| (svh, Library { source, metadata }))
}
// Attempts to extract *one* library from the set `m`. If the set has no
// elements, `None` is returned. If the set has more than one element, then
// the errors and notes are emitted about the set of libraries.
@ -829,23 +826,8 @@ impl<'a> Context<'a> {
}
};
// Extract the rlib/dylib pair.
let mut slot = None;
let rlib = self.extract_one(rlibs, CrateFlavor::Rlib, &mut slot);
let rmeta = self.extract_one(rmetas, CrateFlavor::Rmeta, &mut slot);
let dylib = self.extract_one(dylibs, CrateFlavor::Dylib, &mut slot);
if rlib.is_none() && rmeta.is_none() && dylib.is_none() {
return None;
}
slot.map(|(_, metadata)|
Library {
dylib,
rlib,
rmeta,
metadata,
}
)
// Extract the dylib/rlib/rmeta triple.
self.extract_lib(rlibs, rmetas, dylibs).map(|(_, lib)| lib)
}
}