From ef96a417a714855b3765a003d6d0055d1f570ba0 Mon Sep 17 00:00:00 2001 From: Michael Woerister Date: Tue, 5 Sep 2017 16:48:24 +0200 Subject: [PATCH] Remove the `cstore` reference from Session in order to prepare encapsulating CrateStore access in tcx. --- src/librustc/hir/lowering.rs | 9 +- src/librustc/infer/error_reporting/mod.rs | 2 +- src/librustc/middle/dependency_format.rs | 63 ++++++------ src/librustc/middle/lang_items.rs | 23 +++-- src/librustc/middle/resolve_lifetime.rs | 13 ++- src/librustc/middle/stability.rs | 4 +- src/librustc/middle/weak_lang_items.rs | 12 ++- src/librustc/session/config.rs | 17 ++-- src/librustc/session/mod.rs | 14 +-- src/librustc/traits/util.rs | 4 +- src/librustc/ty/context.rs | 23 +++-- src/librustc/ty/item_path.rs | 4 +- src/librustc/ty/mod.rs | 12 +-- src/librustc/ty/trait_def.rs | 2 +- src/librustc_const_eval/eval.rs | 4 +- src/librustc_const_eval/pattern.rs | 2 +- src/librustc_driver/driver.rs | 28 +++-- src/librustc_driver/lib.rs | 27 +++-- src/librustc_driver/pretty.rs | 9 ++ src/librustc_driver/test.rs | 8 +- src/librustc_incremental/persist/fs.rs | 2 +- src/librustc_incremental/persist/hash.rs | 2 +- src/librustc_lint/builtin.rs | 4 +- src/librustc_metadata/cstore_impl.rs | 2 +- src/librustc_metadata/encoder.rs | 5 +- src/librustc_privacy/lib.rs | 2 +- src/librustc_resolve/build_reduced_graph.rs | 26 ++--- src/librustc_resolve/lib.rs | 8 +- src/librustc_resolve/macros.rs | 2 +- src/librustc_resolve/resolve_imports.rs | 2 +- src/librustc_save_analysis/lib.rs | 4 +- src/librustc_trans/back/link.rs | 101 +++++++++++-------- src/librustc_trans/back/symbol_export.rs | 11 +- src/librustc_trans/back/write.rs | 9 +- src/librustc_trans/base.rs | 6 +- src/librustc_trans/callee.rs | 2 +- src/librustc_trans/consts.rs | 2 +- src/librustc_typeck/check/method/suggest.rs | 4 +- src/librustc_typeck/check_unused.rs | 2 +- src/librustdoc/clean/inline.rs | 10 +- src/librustdoc/clean/mod.rs | 4 +- src/librustdoc/core.rs | 3 +- src/librustdoc/test.rs | 4 +- src/librustdoc/visit_ast.rs | 6 +- src/librustdoc/visit_lib.rs | 2 +- src/test/run-make/issue-19371/foo.rs | 2 +- src/test/run-pass-fulldeps/compiler-calls.rs | 2 + 47 files changed, 291 insertions(+), 218 deletions(-) diff --git a/src/librustc/hir/lowering.rs b/src/librustc/hir/lowering.rs index 0f69c06c417a1..1dbe4517ab39e 100644 --- a/src/librustc/hir/lowering.rs +++ b/src/librustc/hir/lowering.rs @@ -46,6 +46,7 @@ use hir::map::definitions::DefPathData; use hir::def_id::{DefIndex, DefId, CRATE_DEF_INDEX}; use hir::def::{Def, PathResolution}; use lint::builtin::PARENTHESIZED_PARAMS_IN_TYPES_AND_MODULES; +use middle::cstore::CrateStore; use rustc_data_structures::indexed_vec::IndexVec; use session::Session; use util::common::FN_OUTPUT_NAME; @@ -75,6 +76,8 @@ pub struct LoweringContext<'a> { // Use to assign ids to hir nodes that do not directly correspond to an ast node sess: &'a Session, + cstore: &'a CrateStore, + // As we walk the AST we must keep track of the current 'parent' def id (in // the form of a DefIndex) so that if we create a new node which introduces // a definition, then we can properly create the def id. @@ -119,6 +122,7 @@ pub trait Resolver { } pub fn lower_crate(sess: &Session, + cstore: &CrateStore, krate: &Crate, resolver: &mut Resolver) -> hir::Crate { @@ -130,6 +134,7 @@ pub fn lower_crate(sess: &Session, LoweringContext { crate_root: std_inject::injected_crate_name(krate), sess, + cstore, parent_def: None, resolver, name_map: FxHashMap(), @@ -535,7 +540,7 @@ impl<'a> LoweringContext<'a> { if id.is_local() { self.resolver.definitions().def_key(id.index) } else { - self.sess.cstore.def_key(id) + self.cstore.def_key(id) } } @@ -787,7 +792,7 @@ impl<'a> LoweringContext<'a> { return n; } assert!(!def_id.is_local()); - let n = self.sess.cstore.item_generics_cloned(def_id).regions.len(); + let n = self.cstore.item_generics_cloned(def_id).regions.len(); self.type_def_lifetime_params.insert(def_id, n); n }); diff --git a/src/librustc/infer/error_reporting/mod.rs b/src/librustc/infer/error_reporting/mod.rs index 476bf94714268..2cd46ea383823 100644 --- a/src/librustc/infer/error_reporting/mod.rs +++ b/src/librustc/infer/error_reporting/mod.rs @@ -357,7 +357,7 @@ impl<'a, 'gcx, 'tcx> InferCtxt<'a, 'gcx, 'tcx> { // for imported and non-imported crates if exp_path == found_path || exp_abs_path == found_abs_path { - let crate_name = self.tcx.sess.cstore.crate_name(did1.krate); + let crate_name = self.tcx.cstore().crate_name(did1.krate); err.span_note(sp, &format!("Perhaps two different versions \ of crate `{}` are being used?", crate_name)); diff --git a/src/librustc/middle/dependency_format.rs b/src/librustc/middle/dependency_format.rs index 837ab4fd4a3cc..6022b5001c605 100644 --- a/src/librustc/middle/dependency_format.rs +++ b/src/librustc/middle/dependency_format.rs @@ -66,7 +66,7 @@ use hir::def_id::CrateNum; use session; use session::config; use ty::TyCtxt; -use middle::cstore::DepKind; +use middle::cstore::{CrateStore, DepKind}; use middle::cstore::LinkagePreference::{self, RequireStatic, RequireDynamic}; use util::nodemap::FxHashMap; use rustc_back::PanicStrategy; @@ -132,12 +132,12 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, if let Some(v) = attempt_static(tcx) { return v; } - for cnum in sess.cstore.crates() { - if sess.cstore.dep_kind(cnum).macros_only() { continue } - let src = sess.cstore.used_crate_source(cnum); + for cnum in tcx.cstore().crates() { + if tcx.cstore().dep_kind(cnum).macros_only() { continue } + let src = tcx.cstore().used_crate_source(cnum); if src.rlib.is_some() { continue } sess.err(&format!("dependency `{}` not found in rlib format", - sess.cstore.crate_name(cnum))); + tcx.cstore().crate_name(cnum))); } return Vec::new(); } @@ -165,24 +165,24 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // Sweep all crates for found dylibs. Add all dylibs, as well as their // dependencies, ensuring there are no conflicts. The only valid case for a // dependency to be relied upon twice is for both cases to rely on a dylib. - for cnum in sess.cstore.crates() { - if sess.cstore.dep_kind(cnum).macros_only() { continue } - let name = sess.cstore.crate_name(cnum); - let src = sess.cstore.used_crate_source(cnum); + for cnum in tcx.cstore().crates() { + if tcx.cstore().dep_kind(cnum).macros_only() { continue } + let name = tcx.cstore().crate_name(cnum); + let src = tcx.cstore().used_crate_source(cnum); if src.dylib.is_some() { info!("adding dylib: {}", name); - add_library(sess, cnum, RequireDynamic, &mut formats); + add_library(sess, tcx.cstore(), cnum, RequireDynamic, &mut formats); let deps = tcx.dylib_dependency_formats(cnum.as_def_id()); for &(depnum, style) in deps.iter() { info!("adding {:?}: {}", style, - sess.cstore.crate_name(depnum)); - add_library(sess, depnum, style, &mut formats); + tcx.cstore().crate_name(depnum)); + add_library(sess, tcx.cstore(), depnum, style, &mut formats); } } } // Collect what we've got so far in the return vector. - let last_crate = sess.cstore.crates().len(); + let last_crate = tcx.cstore().crates().len(); let mut ret = (1..last_crate+1).map(|cnum| { match formats.get(&CrateNum::new(cnum)) { Some(&RequireDynamic) => Linkage::Dynamic, @@ -196,14 +196,14 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // // If the crate hasn't been included yet and it's not actually required // (e.g. it's an allocator) then we skip it here as well. - for cnum in sess.cstore.crates() { - let src = sess.cstore.used_crate_source(cnum); + for cnum in tcx.cstore().crates() { + let src = tcx.cstore().used_crate_source(cnum); if src.dylib.is_none() && !formats.contains_key(&cnum) && - sess.cstore.dep_kind(cnum) == DepKind::Explicit { + tcx.cstore().dep_kind(cnum) == DepKind::Explicit { assert!(src.rlib.is_some() || src.rmeta.is_some()); - info!("adding staticlib: {}", sess.cstore.crate_name(cnum)); - add_library(sess, cnum, RequireStatic, &mut formats); + info!("adding staticlib: {}", tcx.cstore().crate_name(cnum)); + add_library(sess, tcx.cstore(), cnum, RequireStatic, &mut formats); ret[cnum.as_usize() - 1] = Linkage::Static; } } @@ -226,7 +226,7 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // making sure that everything is available in the requested format. for (cnum, kind) in ret.iter().enumerate() { let cnum = CrateNum::new(cnum + 1); - let src = sess.cstore.used_crate_source(cnum); + let src = tcx.cstore().used_crate_source(cnum); match *kind { Linkage::NotLinked | Linkage::IncludedFromDylib => {} @@ -237,7 +237,7 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, Linkage::Static => "rlib", _ => "dylib", }; - let name = sess.cstore.crate_name(cnum); + let name = tcx.cstore().crate_name(cnum); sess.err(&format!("crate `{}` required to be available in {}, \ but it was not available in this form", name, kind)); @@ -249,6 +249,7 @@ fn calculate_type<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, } fn add_library(sess: &session::Session, + cstore: &CrateStore, cnum: CrateNum, link: LinkagePreference, m: &mut FxHashMap) { @@ -263,7 +264,7 @@ fn add_library(sess: &session::Session, // can be refined over time. if link2 != link || link == RequireStatic { sess.struct_err(&format!("cannot satisfy dependencies so `{}` only \ - shows up once", sess.cstore.crate_name(cnum))) + shows up once", cstore.crate_name(cnum))) .help("having upstream crates all available in one format \ will likely make this go away") .emit(); @@ -275,16 +276,16 @@ fn add_library(sess: &session::Session, fn attempt_static<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Option { let sess = &tcx.sess; - let crates = sess.cstore.used_crates(RequireStatic); + let crates = tcx.cstore().used_crates(RequireStatic); if !crates.iter().by_ref().all(|&(_, ref p)| p.is_some()) { return None } // All crates are available in an rlib format, so we're just going to link // everything in explicitly so long as it's actually required. - let last_crate = sess.cstore.crates().len(); + let last_crate = tcx.cstore().crates().len(); let mut ret = (1..last_crate+1).map(|cnum| { - if sess.cstore.dep_kind(CrateNum::new(cnum)) == DepKind::Explicit { + if tcx.cstore().dep_kind(CrateNum::new(cnum)) == DepKind::Explicit { Linkage::Static } else { Linkage::NotLinked @@ -357,13 +358,13 @@ fn verify_ok<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, list: &[Linkage]) { if tcx.is_panic_runtime(cnum.as_def_id()) { if let Some((prev, _)) = panic_runtime { - let prev_name = sess.cstore.crate_name(prev); - let cur_name = sess.cstore.crate_name(cnum); + let prev_name = tcx.cstore().crate_name(prev); + let cur_name = tcx.cstore().crate_name(cnum); sess.err(&format!("cannot link together two \ panic runtimes: {} and {}", prev_name, cur_name)); } - panic_runtime = Some((cnum, sess.cstore.panic_strategy(cnum))); + panic_runtime = Some((cnum, tcx.cstore().panic_strategy(cnum))); } } @@ -379,7 +380,7 @@ fn verify_ok<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, list: &[Linkage]) { sess.err(&format!("the linked panic runtime `{}` is \ not compiled with this crate's \ panic strategy `{}`", - sess.cstore.crate_name(cnum), + tcx.cstore().crate_name(cnum), desired_strategy.desc())); } @@ -395,8 +396,8 @@ fn verify_ok<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, list: &[Linkage]) { continue } let cnum = CrateNum::new(i + 1); - let found_strategy = sess.cstore.panic_strategy(cnum); - let is_compiler_builtins = sess.cstore.is_compiler_builtins(cnum); + let found_strategy = tcx.cstore().panic_strategy(cnum); + let is_compiler_builtins = tcx.cstore().is_compiler_builtins(cnum); if is_compiler_builtins || desired_strategy == found_strategy { continue } @@ -405,7 +406,7 @@ fn verify_ok<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, list: &[Linkage]) { panic strategy `{}` which is \ incompatible with this crate's \ strategy of `{}`", - sess.cstore.crate_name(cnum), + tcx.cstore().crate_name(cnum), found_strategy.desc(), desired_strategy.desc())); } diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index ae3e3a30f371e..9d62991bd5c97 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -25,6 +25,7 @@ use hir::map as hir_map; use session::Session; use hir::def_id::DefId; use ty; +use middle::cstore::CrateStore; use middle::weak_lang_items; use util::nodemap::FxHashMap; @@ -115,11 +116,9 @@ impl LanguageItems { struct LanguageItemCollector<'a, 'tcx: 'a> { items: LanguageItems, - hir_map: &'a hir_map::Map<'tcx>, - session: &'a Session, - + cstore: &'a CrateStore, item_refs: FxHashMap<&'static str, usize>, } @@ -149,7 +148,9 @@ impl<'a, 'v, 'tcx> ItemLikeVisitor<'v> for LanguageItemCollector<'a, 'tcx> { } impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { - pub fn new(session: &'a Session, hir_map: &'a hir_map::Map<'tcx>) + pub fn new(session: &'a Session, + cstore: &'a CrateStore, + hir_map: &'a hir_map::Map<'tcx>) -> LanguageItemCollector<'a, 'tcx> { let mut item_refs = FxHashMap(); @@ -157,6 +158,7 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { LanguageItemCollector { session, + cstore, hir_map, items: LanguageItems::new(), item_refs, @@ -168,7 +170,7 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { // Check for duplicates. match self.items.items[item_index] { Some(original_def_id) if original_def_id != item_def_id => { - let cstore = &self.session.cstore; + let cstore = self.cstore; let name = LanguageItems::item_name(item_index); let mut err = match self.hir_map.span_if_local(item_def_id) { Some(span) => struct_span_err!( @@ -205,10 +207,8 @@ impl<'a, 'tcx> LanguageItemCollector<'a, 'tcx> { } pub fn collect_external_language_items(&mut self) { - let cstore = &self.session.cstore; - - for cnum in cstore.crates() { - for (index, item_index) in cstore.lang_items(cnum) { + for cnum in self.cstore.crates() { + for (index, item_index) in self.cstore.lang_items(cnum) { let def_id = DefId { krate: cnum, index: index }; self.collect_item(item_index, def_id); } @@ -234,13 +234,14 @@ pub fn extract(attrs: &[ast::Attribute]) -> Option { } pub fn collect_language_items(session: &Session, + cstore: &CrateStore, map: &hir_map::Map) -> LanguageItems { let krate: &hir::Crate = map.krate(); - let mut collector = LanguageItemCollector::new(session, map); + let mut collector = LanguageItemCollector::new(session, cstore, map); collector.collect(krate); let LanguageItemCollector { mut items, .. } = collector; - weak_lang_items::check_crate(krate, session, &mut items); + weak_lang_items::check_crate(krate, session, cstore, &mut items); items } diff --git a/src/librustc/middle/resolve_lifetime.rs b/src/librustc/middle/resolve_lifetime.rs index a8e98e53db394..2a6302407df68 100644 --- a/src/librustc/middle/resolve_lifetime.rs +++ b/src/librustc/middle/resolve_lifetime.rs @@ -16,9 +16,10 @@ //! way. Therefore we break lifetime name resolution into a separate pass. use hir::map::Map; -use session::Session; use hir::def::Def; use hir::def_id::DefId; +use middle::cstore::CrateStore; +use session::Session; use ty; use std::cell::Cell; @@ -160,6 +161,7 @@ pub struct NamedRegionMap { struct LifetimeContext<'a, 'tcx: 'a> { sess: &'a Session, + cstore: &'a CrateStore, hir_map: &'a Map<'tcx>, map: &'a mut NamedRegionMap, scope: ScopeRef<'a>, @@ -251,6 +253,7 @@ type ScopeRef<'a> = &'a Scope<'a>; const ROOT_SCOPE: ScopeRef<'static> = &Scope::Root; pub fn krate(sess: &Session, + cstore: &CrateStore, hir_map: &Map) -> Result { let krate = hir_map.krate(); @@ -262,6 +265,7 @@ pub fn krate(sess: &Session, sess.track_errors(|| { let mut visitor = LifetimeContext { sess, + cstore, hir_map, map: &mut map, scope: ROOT_SCOPE, @@ -765,12 +769,13 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { fn with(&mut self, wrap_scope: Scope, f: F) where F: for<'b> FnOnce(ScopeRef, &mut LifetimeContext<'b, 'tcx>), { - let LifetimeContext {sess, hir_map, ref mut map, ..} = *self; + let LifetimeContext {sess, cstore, hir_map, ref mut map, ..} = *self; let labels_in_fn = replace(&mut self.labels_in_fn, vec![]); let xcrate_object_lifetime_defaults = replace(&mut self.xcrate_object_lifetime_defaults, DefIdMap()); let mut this = LifetimeContext { sess, + cstore, hir_map, map: *map, scope: &wrap_scope, @@ -932,7 +937,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { let def_key = if def_id.is_local() { this.hir_map.def_key(def_id) } else { - this.sess.cstore.def_key(def_id) + this.cstore.def_key(def_id) }; DefId { krate: def_id.krate, @@ -976,7 +981,7 @@ impl<'a, 'tcx> LifetimeContext<'a, 'tcx> { let unsubst = if let Some(id) = self.hir_map.as_local_node_id(def_id) { &map.object_lifetime_defaults[&id] } else { - let cstore = &self.sess.cstore; + let cstore = self.cstore; self.xcrate_object_lifetime_defaults.entry(def_id).or_insert_with(|| { cstore.item_generics_cloned(def_id).types.into_iter().map(|def| { def.object_lifetime_default diff --git a/src/librustc/middle/stability.rs b/src/librustc/middle/stability.rs index d2ed29a3a0ff6..4664b2393d340 100644 --- a/src/librustc/middle/stability.rs +++ b/src/librustc/middle/stability.rs @@ -476,7 +476,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { _ => {} } - let visibility = self.sess.cstore.visibility(def_id); + let visibility = self.cstore().visibility(def_id); match visibility { // must check stability for pub items. @@ -610,7 +610,7 @@ impl<'a, 'tcx> Visitor<'tcx> for Checker<'a, 'tcx> { // compiler-generated `extern crate` items have a dummy span. if item.span == DUMMY_SP { return } - let cnum = match self.tcx.sess.cstore.extern_mod_stmt_cnum(item.id) { + let cnum = match self.tcx.cstore().extern_mod_stmt_cnum(item.id) { Some(cnum) => cnum, None => return, }; diff --git a/src/librustc/middle/weak_lang_items.rs b/src/librustc/middle/weak_lang_items.rs index acb506878e6b6..cdbd74dae274f 100644 --- a/src/librustc/middle/weak_lang_items.rs +++ b/src/librustc/middle/weak_lang_items.rs @@ -13,6 +13,7 @@ use session::config; use session::Session; use middle::lang_items; +use middle::cstore::CrateStore; use rustc_back::PanicStrategy; use syntax::ast; @@ -36,6 +37,7 @@ struct Context<'a> { /// language items required by this crate, but not defined yet. pub fn check_crate(krate: &hir::Crate, sess: &Session, + cstore: &CrateStore, items: &mut lang_items::LanguageItems) { // These are never called by user code, they're generated by the compiler. // They will never implicitly be added to the `missing` array unless we do @@ -52,7 +54,7 @@ pub fn check_crate(krate: &hir::Crate, let mut cx = Context { sess: sess, items: items }; krate.visit_all_item_likes(&mut cx.as_deep_visitor()); } - verify(sess, items); + verify(sess, cstore, items); } pub fn link_name(attrs: &[ast::Attribute]) -> Option { @@ -65,7 +67,9 @@ pub fn link_name(attrs: &[ast::Attribute]) -> Option { }) } -fn verify(sess: &Session, items: &lang_items::LanguageItems) { +fn verify(sess: &Session, + cstore: &CrateStore, + items: &lang_items::LanguageItems) { // We only need to check for the presence of weak lang items if we're // emitting something that's not an rlib. let needs_check = sess.crate_types.borrow().iter().any(|kind| { @@ -83,8 +87,8 @@ fn verify(sess: &Session, items: &lang_items::LanguageItems) { } let mut missing = HashSet::new(); - for cnum in sess.cstore.crates() { - for item in sess.cstore.missing_lang_items(cnum) { + for cnum in cstore.crates() { + for item in cstore.missing_lang_items(cnum) { missing.insert(item); } } diff --git a/src/librustc/session/config.rs b/src/librustc/session/config.rs index 99fe8e60ae52b..f967c4e9c5d83 100644 --- a/src/librustc/session/config.rs +++ b/src/librustc/session/config.rs @@ -1949,13 +1949,12 @@ mod tests { use errors; use getopts; use lint; - use middle::cstore::{self, DummyCrateStore}; + use middle::cstore; use session::config::{build_configuration, build_session_options_and_crate_config}; use session::build_session; use std::collections::{BTreeMap, BTreeSet}; use std::iter::FromIterator; use std::path::PathBuf; - use std::rc::Rc; use super::{OutputType, OutputTypes, Externs}; use rustc_back::{PanicStrategy, RelroLevel}; use syntax::symbol::Symbol; @@ -1987,7 +1986,7 @@ mod tests { }; let registry = errors::registry::Registry::new(&[]); let (sessopts, cfg) = build_session_options_and_crate_config(matches); - let sess = build_session(sessopts, &dep_graph, None, registry, Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); let cfg = build_configuration(&sess, cfg); assert!(cfg.contains(&(Symbol::intern("test"), None))); } @@ -2006,8 +2005,7 @@ mod tests { }; let registry = errors::registry::Registry::new(&[]); let (sessopts, cfg) = build_session_options_and_crate_config(matches); - let sess = build_session(sessopts, &dep_graph, None, registry, - Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); let cfg = build_configuration(&sess, cfg); let mut test_items = cfg.iter().filter(|&&(name, _)| name == "test"); assert!(test_items.next().is_some()); @@ -2023,8 +2021,7 @@ mod tests { ]).unwrap(); let registry = errors::registry::Registry::new(&[]); let (sessopts, _) = build_session_options_and_crate_config(&matches); - let sess = build_session(sessopts, &dep_graph, None, registry, - Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); assert!(!sess.diagnostic().can_emit_warnings); } @@ -2035,8 +2032,7 @@ mod tests { ]).unwrap(); let registry = errors::registry::Registry::new(&[]); let (sessopts, _) = build_session_options_and_crate_config(&matches); - let sess = build_session(sessopts, &dep_graph, None, registry, - Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); assert!(sess.diagnostic().can_emit_warnings); } @@ -2046,8 +2042,7 @@ mod tests { ]).unwrap(); let registry = errors::registry::Registry::new(&[]); let (sessopts, _) = build_session_options_and_crate_config(&matches); - let sess = build_session(sessopts, &dep_graph, None, registry, - Rc::new(DummyCrateStore)); + let sess = build_session(sessopts, &dep_graph, None, registry); assert!(sess.diagnostic().can_emit_warnings); } } diff --git a/src/librustc/session/mod.rs b/src/librustc/session/mod.rs index 823a637c7e0d4..87afdae116ed4 100644 --- a/src/librustc/session/mod.rs +++ b/src/librustc/session/mod.rs @@ -15,7 +15,6 @@ use dep_graph::DepGraph; use hir::def_id::{CrateNum, DefIndex}; use lint; -use middle::cstore::CrateStore; use middle::allocator::AllocatorKind; use middle::dependency_format; use session::search_paths::PathKind; @@ -63,7 +62,6 @@ pub struct Session { pub target: config::Config, pub host: Target, pub opts: config::Options, - pub cstore: Rc, pub parse_sess: ParseSess, // For a library crate, this is always none pub entry_fn: RefCell>, @@ -617,8 +615,7 @@ impl Session { pub fn build_session(sopts: config::Options, dep_graph: &DepGraph, local_crate_source_file: Option, - registry: errors::registry::Registry, - cstore: Rc) + registry: errors::registry::Registry) -> Session { let file_path_mapping = sopts.file_path_mapping(); @@ -626,7 +623,6 @@ pub fn build_session(sopts: config::Options, dep_graph, local_crate_source_file, registry, - cstore, Rc::new(codemap::CodeMap::new(file_path_mapping)), None) } @@ -635,7 +631,6 @@ pub fn build_session_with_codemap(sopts: config::Options, dep_graph: &DepGraph, local_crate_source_file: Option, registry: errors::registry::Registry, - cstore: Rc, codemap: Rc, emitter_dest: Option>) -> Session { @@ -676,16 +671,14 @@ pub fn build_session_with_codemap(sopts: config::Options, dep_graph, local_crate_source_file, diagnostic_handler, - codemap, - cstore) + codemap) } pub fn build_session_(sopts: config::Options, dep_graph: &DepGraph, local_crate_source_file: Option, span_diagnostic: errors::Handler, - codemap: Rc, - cstore: Rc) + codemap: Rc) -> Session { let host = match Target::search(config::host_triple()) { Ok(t) => t, @@ -722,7 +715,6 @@ pub fn build_session_(sopts: config::Options, target: target_cfg, host, opts: sopts, - cstore, parse_sess: p_s, // For a library crate, this is always none entry_fn: RefCell::new(None), diff --git a/src/librustc/traits/util.rs b/src/librustc/traits/util.rs index 28abd1577dade..1487698353799 100644 --- a/src/librustc/traits/util.rs +++ b/src/librustc/traits/util.rs @@ -537,9 +537,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } None => { - self.global_tcx() - .sess - .cstore + self.cstore() .impl_defaultness(node_item_def_id) .is_default() } diff --git a/src/librustc/ty/context.rs b/src/librustc/ty/context.rs index f475baf19949f..720b7fede40b0 100644 --- a/src/librustc/ty/context.rs +++ b/src/librustc/ty/context.rs @@ -21,6 +21,7 @@ use hir::map as hir_map; use hir::map::DefPathHash; use lint::{self, Lint}; use ich::{self, StableHashingContext, NodeIdHashingMode}; +use middle::cstore::CrateStore; use middle::free_region::FreeRegionMap; use middle::lang_items; use middle::resolve_lifetime; @@ -806,8 +807,11 @@ pub struct GlobalCtxt<'tcx> { global_arenas: &'tcx GlobalArenas<'tcx>, global_interners: CtxtInterners<'tcx>, + cstore: &'tcx CrateStore, + pub sess: &'tcx Session, + pub trans_trait_caches: traits::trans::TransTraitCaches<'tcx>, pub dep_graph: DepGraph, @@ -913,7 +917,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if cnum == LOCAL_CRATE { self.crate_name } else { - self.sess.cstore.crate_name(cnum) + self.cstore.crate_name(cnum) } } @@ -921,7 +925,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if cnum == LOCAL_CRATE { self.crate_name.clone() } else { - self.sess.cstore.original_crate_name(cnum) + self.cstore.original_crate_name(cnum) } } @@ -929,10 +933,14 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if cnum == LOCAL_CRATE { self.sess.local_crate_disambiguator() } else { - self.sess.cstore.crate_disambiguator(cnum) + self.cstore.crate_disambiguator(cnum) } } + pub fn cstore(&self) -> &CrateStore { + &*self.cstore + } + pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics { self.global_arenas.generics.alloc(generics) } @@ -1008,6 +1016,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { /// value (types, substs, etc.) can only be used while `ty::tls` has a valid /// reference to the context, to allow formatting values that need it. pub fn create_and_enter(s: &'tcx Session, + cstore: &'tcx CrateStore, local_providers: ty::maps::Providers<'tcx>, extern_providers: ty::maps::Providers<'tcx>, mir_passes: Rc, @@ -1026,16 +1035,15 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { let interners = CtxtInterners::new(arena); let common_types = CommonTypes::new(&interners); let dep_graph = hir.dep_graph.clone(); - let max_cnum = s.cstore.crates().iter().map(|c| c.as_usize()).max().unwrap_or(0); + let max_cnum = cstore.crates().iter().map(|c| c.as_usize()).max().unwrap_or(0); let mut providers = IndexVec::from_elem_n(extern_providers, max_cnum + 1); providers[LOCAL_CRATE] = local_providers; let def_path_hash_to_def_id = if s.opts.build_dep_graph() { - let upstream_def_path_tables: Vec<(CrateNum, Rc<_>)> = s - .cstore + let upstream_def_path_tables: Vec<(CrateNum, Rc<_>)> = cstore .crates() .iter() - .map(|&cnum| (cnum, s.cstore.def_path_table(cnum))) + .map(|&cnum| (cnum, cstore.def_path_table(cnum))) .collect(); let def_path_tables = || { @@ -1065,6 +1073,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { tls::enter_global(GlobalCtxt { sess: s, + cstore, trans_trait_caches: traits::trans::TransTraitCaches::new(dep_graph.clone()), global_arenas: arenas, global_interners: interners, diff --git a/src/librustc/ty/item_path.rs b/src/librustc/ty/item_path.rs index eadf80871fc95..4f0d30b996639 100644 --- a/src/librustc/ty/item_path.rs +++ b/src/librustc/ty/item_path.rs @@ -128,7 +128,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { pub fn try_push_visible_item_path(self, buffer: &mut T, external_def_id: DefId) -> bool where T: ItemPathBuffer { - let visible_parent_map = self.sess.cstore.visible_parent_map(self.sess); + let visible_parent_map = self.cstore().visible_parent_map(self.sess); let (mut cur_def, mut cur_path) = (external_def_id, Vec::::new()); loop { @@ -150,7 +150,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { } } - cur_path.push(self.sess.cstore.def_key(cur_def) + cur_path.push(self.cstore().def_key(cur_def) .disambiguated_data.data.get_opt_name().unwrap_or_else(|| Symbol::intern(""))); match visible_parent_map.get(&cur_def) { diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs index 1851e1b8d34bb..d73edc9ee7d7b 100644 --- a/src/librustc/ty/mod.rs +++ b/src/librustc/ty/mod.rs @@ -2180,7 +2180,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if id.is_local() { self.hir.def_key(id) } else { - self.sess.cstore.def_key(id) + self.cstore().def_key(id) } } @@ -2193,7 +2193,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if id.is_local() { self.hir.def_path(id) } else { - self.sess.cstore.def_path(id) + self.cstore().def_path(id) } } @@ -2202,7 +2202,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if def_id.is_local() { self.hir.definitions().def_path_hash(def_id.index) } else { - self.sess.cstore.def_path_hash(def_id) + self.cstore().def_path_hash(def_id) } } @@ -2210,9 +2210,9 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { if let Some(id) = self.hir.as_local_node_id(id) { self.hir.name(id) } else if id.index == CRATE_DEF_INDEX { - self.sess.cstore.original_crate_name(id.krate) + self.cstore().original_crate_name(id.krate) } else { - let def_key = self.sess.cstore.def_key(id); + let def_key = self.cstore().def_key(id); // The name of a StructCtor is that of its struct parent. if let hir_map::DefPathData::StructCtor = def_key.disambiguated_data.data { self.item_name(DefId { @@ -2315,7 +2315,7 @@ impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> { let node_id = self.hir.as_local_node_id(impl_did).unwrap(); Ok(self.hir.span(node_id)) } else { - Err(self.sess.cstore.crate_name(impl_did.krate)) + Err(self.cstore().crate_name(impl_did.krate)) } } diff --git a/src/librustc/ty/trait_def.rs b/src/librustc/ty/trait_def.rs index 9990472c6b4ca..39bb8c58f4866 100644 --- a/src/librustc/ty/trait_def.rs +++ b/src/librustc/ty/trait_def.rs @@ -146,7 +146,7 @@ pub(super) fn trait_impls_of_provider<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, // crates, so we don't bother querying the cstore. Vec::new() } else { - tcx.sess.cstore.implementations_of_trait(Some(trait_id)) + tcx.cstore().implementations_of_trait(Some(trait_id)) }; let mut blanket_impls = Vec::new(); diff --git a/src/librustc_const_eval/eval.rs b/src/librustc_const_eval/eval.rs index c7def0b834cfd..a0c57b823603b 100644 --- a/src/librustc_const_eval/eval.rs +++ b/src/librustc_const_eval/eval.rs @@ -354,7 +354,7 @@ fn eval_const_expr_partial<'a, 'tcx>(cx: &ConstContext<'a, 'tcx>, } } else { if tcx.is_const_fn(def_id) { - tcx.sess.cstore.item_body(tcx, def_id) + tcx.cstore().item_body(tcx, def_id) } else { signal!(e, TypeckError) } @@ -774,7 +774,7 @@ fn const_eval<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, tcx.mir_const_qualif(def_id); tcx.hir.body(tcx.hir.body_owned_by(id)) } else { - tcx.sess.cstore.item_body(tcx, def_id) + tcx.cstore().item_body(tcx, def_id) }; ConstContext::new(tcx, key.param_env.and(substs), tables).eval(&body.value) } diff --git a/src/librustc_const_eval/pattern.rs b/src/librustc_const_eval/pattern.rs index ba79f775ef73d..04f0162f4b755 100644 --- a/src/librustc_const_eval/pattern.rs +++ b/src/librustc_const_eval/pattern.rs @@ -609,7 +609,7 @@ impl<'a, 'tcx> PatternContext<'a, 'tcx> { let body = if let Some(id) = self.tcx.hir.as_local_node_id(def_id) { self.tcx.hir.body(self.tcx.hir.body_owned_by(id)) } else { - self.tcx.sess.cstore.item_body(self.tcx, def_id) + self.tcx.cstore().item_body(self.tcx, def_id) }; let pat = self.lower_const_expr(&body.value, pat_id, span); self.tables = old_tables; diff --git a/src/librustc_driver/driver.rs b/src/librustc_driver/driver.rs index 000d89241a427..811f061f7b7c6 100644 --- a/src/librustc_driver/driver.rs +++ b/src/librustc_driver/driver.rs @@ -21,6 +21,7 @@ use rustc::session::config::{self, Input, OutputFilenames, OutputType}; use rustc::session::search_paths::PathKind; use rustc::lint; use rustc::middle::{self, stability, reachable}; +use rustc::middle::cstore::CrateStore; use rustc::middle::privacy::AccessLevels; use rustc::mir::transform::{MIR_CONST, MIR_VALIDATED, MIR_OPTIMIZED, Passes}; use rustc::ty::{self, TyCtxt, Resolutions, GlobalArenas}; @@ -200,6 +201,7 @@ pub fn compile_input(sess: &Session, }; phase_3_run_analysis_passes(sess, + cstore, hir_map, analysis, resolutions, @@ -272,7 +274,7 @@ pub fn compile_input(sess: &Session, phase5_result); phase5_result?; - phase_6_link_output(sess, &trans, &outputs); + phase_6_link_output(sess, cstore, &trans, &outputs); // Now that we won't touch anything in the incremental compilation directory // any more, we can finalize it (which involves renaming it) @@ -385,7 +387,7 @@ pub struct CompileState<'a, 'tcx: 'a> { pub session: &'tcx Session, pub krate: Option, pub registry: Option>, - pub cstore: Option<&'a CStore>, + pub cstore: Option<&'tcx CStore>, pub crate_name: Option<&'a str>, pub output_filenames: Option<&'a OutputFilenames>, pub out_dir: Option<&'a Path>, @@ -433,7 +435,7 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> { out_dir: &'a Option, out_file: &'a Option, krate: ast::Crate, - cstore: &'a CStore) + cstore: &'tcx CStore) -> Self { CompileState { // Initialize the registry before moving `krate` @@ -449,7 +451,7 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> { session: &'tcx Session, out_dir: &'a Option, out_file: &'a Option, - cstore: &'a CStore, + cstore: &'tcx CStore, expanded_crate: &'a ast::Crate, crate_name: &'a str) -> Self { @@ -468,7 +470,7 @@ impl<'a, 'tcx> CompileState<'a, 'tcx> { out_file: &'a Option, arena: &'tcx DroplessArena, arenas: &'tcx GlobalArenas<'tcx>, - cstore: &'a CStore, + cstore: &'tcx CStore, hir_map: &'a hir_map::Map<'tcx>, analysis: &'a ty::CrateAnalysis, resolutions: &'a Resolutions, @@ -697,6 +699,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, crate_loader.preprocess(&krate); let resolver_arenas = Resolver::arenas(); let mut resolver = Resolver::new(sess, + cstore, &krate, crate_name, make_glob_map, @@ -845,7 +848,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, // Lower ast -> hir. let hir_forest = time(time_passes, "lowering ast -> hir", || { - let hir_crate = lower_crate(sess, &krate, &mut resolver); + let hir_crate = lower_crate(sess, cstore, &krate, &mut resolver); if sess.opts.debugging_opts.hir_stats { hir_stats::print_hir_stats(&hir_crate); @@ -887,6 +890,7 @@ pub fn phase_2_configure_and_expand(sess: &Session, /// miscellaneous analysis passes on the crate. Return various /// structures carrying the results of the analysis. pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, + cstore: &'tcx CrateStore, hir_map: hir_map::Map<'tcx>, mut analysis: ty::CrateAnalysis, resolutions: Resolutions, @@ -916,13 +920,13 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, let lang_items = time(time_passes, "language item collection", || { sess.track_errors(|| { - middle::lang_items::collect_language_items(&sess, &hir_map) + middle::lang_items::collect_language_items(&sess, cstore, &hir_map) }) })?; let named_region_map = time(time_passes, "lifetime resolution", - || middle::resolve_lifetime::krate(sess, &hir_map))?; + || middle::resolve_lifetime::krate(sess, cstore, &hir_map))?; time(time_passes, "looking for entry point", @@ -1021,6 +1025,7 @@ pub fn phase_3_run_analysis_passes<'tcx, F, R>(sess: &'tcx Session, passes.push_pass(MIR_OPTIMIZED, mir::transform::dump_mir::Marker("PreTrans")); TyCtxt::create_and_enter(sess, + cstore, local_providers, extern_providers, Rc::new(passes), @@ -1163,10 +1168,15 @@ pub fn phase_5_run_llvm_passes(sess: &Session, /// This should produce either a finished executable or library. #[cfg(feature="llvm")] pub fn phase_6_link_output(sess: &Session, + cstore: &CrateStore, trans: &trans::CrateTranslation, outputs: &OutputFilenames) { time(sess.time_passes(), "linking", || { - ::rustc_trans::back::link::link_binary(sess, trans, outputs, &trans.crate_name.as_str()) + ::rustc_trans::back::link::link_binary(sess, + cstore, + trans, + outputs, + &trans.crate_name.as_str()) }); } diff --git a/src/librustc_driver/lib.rs b/src/librustc_driver/lib.rs index 1915a1c86484a..d3355f2ade450 100644 --- a/src/librustc_driver/lib.rs +++ b/src/librustc_driver/lib.rs @@ -72,6 +72,7 @@ use rustc::session::config::nightly_options; use rustc::session::{early_error, early_warn}; use rustc::lint::Lint; use rustc::lint; +use rustc::middle::cstore::CrateStore; use rustc_metadata::locator; use rustc_metadata::cstore::CStore; use rustc::util::common::{time, ErrorReported}; @@ -299,7 +300,7 @@ pub fn run_compiler<'a>(args: &[String], let loader = file_loader.unwrap_or(box RealFileLoader); let codemap = Rc::new(CodeMap::with_file_loader(loader, sopts.file_path_mapping())); let mut sess = session::build_session_with_codemap( - sopts, &dep_graph, input_file_path, descriptions, cstore.clone(), codemap, emitter_dest, + sopts, &dep_graph, input_file_path, descriptions, codemap, emitter_dest, ); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); @@ -308,7 +309,12 @@ pub fn run_compiler<'a>(args: &[String], target_features::add_configuration(&mut cfg, &sess); sess.parse_sess.config = cfg; - do_or_return!(callbacks.late_callback(&matches, &sess, &input, &odir, &ofile), Some(sess)); + do_or_return!(callbacks.late_callback(&matches, + &sess, + &*cstore, + &input, + &odir, + &ofile), Some(sess)); let plugins = sess.opts.debugging_opts.extra_plugins.clone(); let control = callbacks.build_controller(&sess, &matches); @@ -400,6 +406,7 @@ pub trait CompilerCalls<'a> { fn late_callback(&mut self, _: &getopts::Matches, _: &Session, + _: &CrateStore, _: &Input, _: &Option, _: &Option) @@ -574,12 +581,10 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { return None; } let dep_graph = DepGraph::new(sopts.build_dep_graph()); - let cstore = Rc::new(CStore::new(&dep_graph, box ::MetadataLoader)); let mut sess = build_session(sopts.clone(), &dep_graph, None, - descriptions.clone(), - cstore.clone()); + descriptions.clone()); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); let mut cfg = config::build_configuration(&sess, cfg.clone()); @@ -601,12 +606,13 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { fn late_callback(&mut self, matches: &getopts::Matches, sess: &Session, + cstore: &CrateStore, input: &Input, odir: &Option, ofile: &Option) -> Compilation { RustcDefaultCalls::print_crate_info(sess, Some(input), odir, ofile) - .and_then(|| RustcDefaultCalls::list_metadata(sess, matches, input)) + .and_then(|| RustcDefaultCalls::list_metadata(sess, cstore, matches, input)) } fn build_controller(&mut self, @@ -627,6 +633,7 @@ impl<'a> CompilerCalls<'a> for RustcDefaultCalls { }; control.after_hir_lowering.callback = box move |state| { pretty::print_after_hir_lowering(state.session, + state.cstore.unwrap(), state.hir_map.unwrap(), state.analysis.unwrap(), state.resolutions.unwrap(), @@ -711,7 +718,11 @@ fn save_analysis(sess: &Session) -> bool { } impl RustcDefaultCalls { - pub fn list_metadata(sess: &Session, matches: &getopts::Matches, input: &Input) -> Compilation { + pub fn list_metadata(sess: &Session, + cstore: &CrateStore, + matches: &getopts::Matches, + input: &Input) + -> Compilation { let r = matches.opt_strs("Z"); if r.contains(&("ls".to_string())) { match input { @@ -720,7 +731,7 @@ impl RustcDefaultCalls { let mut v = Vec::new(); locator::list_file_metadata(&sess.target.target, path, - sess.cstore.metadata_loader(), + cstore.metadata_loader(), &mut v) .unwrap(); println!("{}", String::from_utf8(v).unwrap()); diff --git a/src/librustc_driver/pretty.rs b/src/librustc_driver/pretty.rs index 6a58b7fb75360..82dda2d2aa162 100644 --- a/src/librustc_driver/pretty.rs +++ b/src/librustc_driver/pretty.rs @@ -21,6 +21,7 @@ use rustc::ty::{self, TyCtxt, GlobalArenas, Resolutions}; use rustc::cfg; use rustc::cfg::graphviz::LabelledCFG; use rustc::dep_graph::DepGraph; +use rustc::middle::cstore::CrateStore; use rustc::session::Session; use rustc::session::config::Input; use rustc_borrowck as borrowck; @@ -198,6 +199,7 @@ impl PpSourceMode { } fn call_with_pp_support_hir<'tcx, A, F>(&self, sess: &'tcx Session, + cstore: &'tcx CrateStore, hir_map: &hir_map::Map<'tcx>, analysis: &ty::CrateAnalysis, resolutions: &Resolutions, @@ -226,6 +228,7 @@ impl PpSourceMode { } PpmTyped => { abort_on_err(driver::phase_3_run_analysis_passes(sess, + cstore, hir_map.clone(), analysis.clone(), resolutions.clone(), @@ -875,6 +878,7 @@ pub fn print_after_parsing(sess: &Session, } pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, + cstore: &'tcx CrateStore, hir_map: &hir_map::Map<'tcx>, analysis: &ty::CrateAnalysis, resolutions: &Resolutions, @@ -891,6 +895,7 @@ pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, if ppm.needs_analysis() { print_with_analysis(sess, + cstore, hir_map, analysis, resolutions, @@ -929,6 +934,7 @@ pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, (PpmHir(s), None) => { let out: &mut Write = &mut out; s.call_with_pp_support_hir(sess, + cstore, hir_map, analysis, resolutions, @@ -952,6 +958,7 @@ pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, (PpmHir(s), Some(uii)) => { let out: &mut Write = &mut out; s.call_with_pp_support_hir(sess, + cstore, hir_map, analysis, resolutions, @@ -993,6 +1000,7 @@ pub fn print_after_hir_lowering<'tcx, 'a: 'tcx>(sess: &'a Session, // with a different callback than the standard driver, so that isn't easy. // Instead, we call that function ourselves. fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session, + cstore: &'a CrateStore, hir_map: &hir_map::Map<'tcx>, analysis: &ty::CrateAnalysis, resolutions: &Resolutions, @@ -1013,6 +1021,7 @@ fn print_with_analysis<'tcx, 'a: 'tcx>(sess: &'a Session, let mut out = Vec::new(); abort_on_err(driver::phase_3_run_analysis_passes(sess, + cstore, hir_map.clone(), analysis.clone(), resolutions.clone(), diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs index 552130e8a4703..e996cd2276fa5 100644 --- a/src/librustc_driver/test.rs +++ b/src/librustc_driver/test.rs @@ -111,8 +111,7 @@ fn test_env(source_string: &str, &dep_graph, None, diagnostic_handler, - Rc::new(CodeMap::new(FilePathMapping::empty())), - cstore.clone()); + Rc::new(CodeMap::new(FilePathMapping::empty()))); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); let input = config::Input::Str { @@ -140,10 +139,11 @@ fn test_env(source_string: &str, let hir_map = hir_map::map_crate(&mut hir_forest, defs); // run just enough stuff to build a tcx: - let lang_items = lang_items::collect_language_items(&sess, &hir_map); - let named_region_map = resolve_lifetime::krate(&sess, &hir_map); + let lang_items = lang_items::collect_language_items(&sess, &*cstore, &hir_map); + let named_region_map = resolve_lifetime::krate(&sess, &*cstore, &hir_map); let index = stability::Index::new(&sess); TyCtxt::create_and_enter(&sess, + &*cstore, ty::maps::Providers::default(), ty::maps::Providers::default(), Rc::new(Passes::new()), diff --git a/src/librustc_incremental/persist/fs.rs b/src/librustc_incremental/persist/fs.rs index 28d33d9528692..7adcbdcd17a75 100644 --- a/src/librustc_incremental/persist/fs.rs +++ b/src/librustc_incremental/persist/fs.rs @@ -632,7 +632,7 @@ pub fn find_metadata_hashes_for(tcx: TyCtxt, cnum: CrateNum) -> Option } }; - let target_svh = tcx.sess.cstore.crate_hash(cnum); + let target_svh = tcx.cstore().crate_hash(cnum); let target_svh = base_n::encode(target_svh.as_u64(), INT_ENCODE_BASE); let sub_dir = find_metadata_hashes_iter(&target_svh, dir_entries.filter_map(|e| { diff --git a/src/librustc_incremental/persist/hash.rs b/src/librustc_incremental/persist/hash.rs index 9d762a74bfe67..439bf11f2724d 100644 --- a/src/librustc_incremental/persist/hash.rs +++ b/src/librustc_incremental/persist/hash.rs @@ -133,7 +133,7 @@ impl<'a, 'tcx> HashContext<'a, 'tcx> { fn load_data(&mut self, cnum: CrateNum) { debug!("load_data(cnum={})", cnum); - let svh = self.tcx.sess.cstore.crate_hash(cnum); + let svh = self.tcx.cstore().crate_hash(cnum); let old = self.crate_hashes.insert(cnum, svh); debug!("load_data: svh={}", svh); assert!(old.is_none(), "loaded data for crate {:?} twice", cnum); diff --git a/src/librustc_lint/builtin.rs b/src/librustc_lint/builtin.rs index 52b645638b86f..6593753eb3135 100644 --- a/src/librustc_lint/builtin.rs +++ b/src/librustc_lint/builtin.rs @@ -1061,8 +1061,8 @@ impl<'a, 'tcx> LateLintPass<'a, 'tcx> for PluginAsLibrary { _ => return, }; - let prfn = match cx.sess().cstore.extern_mod_stmt_cnum(it.id) { - Some(cnum) => cx.sess().cstore.plugin_registrar_fn(cnum), + let prfn = match cx.tcx.cstore().extern_mod_stmt_cnum(it.id) { + Some(cnum) => cx.tcx.cstore().plugin_registrar_fn(cnum), None => { // Probably means we aren't linking the crate for some reason. // diff --git a/src/librustc_metadata/cstore_impl.rs b/src/librustc_metadata/cstore_impl.rs index 537e12086141c..2ef91bf007c30 100644 --- a/src/librustc_metadata/cstore_impl.rs +++ b/src/librustc_metadata/cstore_impl.rs @@ -55,7 +55,7 @@ macro_rules! provide { $tcx.dep_graph.read(dep_node); - let $cdata = $tcx.sess.cstore.crate_data_as_rc_any($def_id.krate); + let $cdata = $tcx.cstore().crate_data_as_rc_any($def_id.krate); let $cdata = $cdata.downcast_ref::() .expect("CrateStore crated ata is not a CrateMetadata"); $compute diff --git a/src/librustc_metadata/encoder.rs b/src/librustc_metadata/encoder.rs index d36aebe38eb0b..ceae5c598be56 100644 --- a/src/librustc_metadata/encoder.rs +++ b/src/librustc_metadata/encoder.rs @@ -1283,12 +1283,13 @@ impl<'a, 'b: 'a, 'tcx: 'b> IsolatedEncoder<'a, 'b, 'tcx> { } fn encode_native_libraries(&mut self, _: ()) -> LazySeq { - let used_libraries = self.tcx.sess.cstore.used_libraries(); + let used_libraries = self.tcx.cstore().used_libraries(); self.lazy_seq(used_libraries) } fn encode_crate_deps(&mut self, _: ()) -> LazySeq { - let cstore = &*self.tcx.sess.cstore; + let tcx = self.tcx; + let cstore = tcx.cstore(); let crates = cstore.crates(); let mut deps = crates diff --git a/src/librustc_privacy/lib.rs b/src/librustc_privacy/lib.rs index 872a29e7bc0c5..ff11f74cbc422 100644 --- a/src/librustc_privacy/lib.rs +++ b/src/librustc_privacy/lib.rs @@ -630,7 +630,7 @@ impl<'a, 'tcx> TypePrivacyVisitor<'a, 'tcx> { }; ty::Visibility::from_hir(vis, node_id, self.tcx) } - None => self.tcx.sess.cstore.visibility(did), + None => self.tcx.cstore().visibility(did), } } diff --git a/src/librustc_resolve/build_reduced_graph.rs b/src/librustc_resolve/build_reduced_graph.rs index 47fa5357abf0d..686b0769adc06 100644 --- a/src/librustc_resolve/build_reduced_graph.rs +++ b/src/librustc_resolve/build_reduced_graph.rs @@ -253,7 +253,7 @@ impl<'a> Resolver<'a> { self.crate_loader.process_item(item, &self.definitions); // n.b. we don't need to look at the path option here, because cstore already did - let crate_id = self.session.cstore.extern_mod_stmt_cnum(item.id).unwrap(); + let crate_id = self.cstore.extern_mod_stmt_cnum(item.id).unwrap(); let module = self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX }); self.populate_module_if_necessary(module); @@ -449,7 +449,7 @@ impl<'a> Resolver<'a> { let ident = child.ident; let def = child.def; let def_id = def.def_id(); - let vis = self.session.cstore.visibility(def_id); + let vis = self.cstore.visibility(def_id); let span = child.span; let expansion = Mark::root(); // FIXME(jseyfried) intercrate hygiene match def { @@ -471,7 +471,7 @@ impl<'a> Resolver<'a> { self.define(parent, ident, ValueNS, (def, vis, DUMMY_SP, expansion)); if let Some(struct_def_id) = - self.session.cstore.def_key(def_id).parent + self.cstore.def_key(def_id).parent .map(|index| DefId { krate: def_id.krate, index: index }) { self.struct_constructors.insert(struct_def_id, (def, vis)); } @@ -485,12 +485,12 @@ impl<'a> Resolver<'a> { span); self.define(parent, ident, TypeNS, (module, vis, DUMMY_SP, expansion)); - for child in self.session.cstore.item_children(def_id, self.session) { + for child in self.cstore.item_children(def_id, self.session) { let ns = if let Def::AssociatedTy(..) = child.def { TypeNS } else { ValueNS }; self.define(module, child.ident, ns, (child.def, ty::Visibility::Public, DUMMY_SP, expansion)); - if self.session.cstore.associated_item_cloned(child.def.def_id()) + if self.cstore.associated_item_cloned(child.def.def_id()) .method_has_self_argument { self.has_self.insert(child.def.def_id()); } @@ -501,7 +501,7 @@ impl<'a> Resolver<'a> { self.define(parent, ident, TypeNS, (def, vis, DUMMY_SP, expansion)); // Record field names for error reporting. - let field_names = self.session.cstore.struct_field_names(def_id); + let field_names = self.cstore.struct_field_names(def_id); self.insert_field_names(def_id, field_names); } Def::Macro(..) => { @@ -516,15 +516,15 @@ impl<'a> Resolver<'a> { return self.module_map[&def_id] } - let macros_only = self.session.cstore.dep_kind(def_id.krate).macros_only(); + let macros_only = self.cstore.dep_kind(def_id.krate).macros_only(); if let Some(&module) = self.extern_module_map.get(&(def_id, macros_only)) { return module; } let (name, parent) = if def_id.index == CRATE_DEF_INDEX { - (self.session.cstore.crate_name(def_id.krate), None) + (self.cstore.crate_name(def_id.krate), None) } else { - let def_key = self.session.cstore.def_key(def_id); + let def_key = self.cstore.def_key(def_id); (def_key.disambiguated_data.data.get_opt_name().unwrap(), Some(self.get_module(DefId { index: def_key.parent.unwrap(), ..def_id }))) }; @@ -558,7 +558,7 @@ impl<'a> Resolver<'a> { return ext.clone(); } - let macro_def = match self.session.cstore.load_macro(def_id, &self.session) { + let macro_def = match self.cstore.load_macro(def_id, &self.session) { LoadedMacro::MacroDef(macro_def) => macro_def, LoadedMacro::ProcMacro(ext) => return ext, }; @@ -574,7 +574,7 @@ impl<'a> Resolver<'a> { /// is built, building it if it is not. pub fn populate_module_if_necessary(&mut self, module: Module<'a>) { if module.populated.get() { return } - for child in self.session.cstore.item_children(module.def_id().unwrap(), self.session) { + for child in self.cstore.item_children(module.def_id().unwrap(), self.session) { self.build_reduced_graph_for_external_crate_def(module, child); } module.populated.set(true) @@ -605,7 +605,7 @@ impl<'a> Resolver<'a> { span_err!(self.session, item.span, E0468, "an `extern crate` loading macros must be at the crate root"); } else if !self.use_extern_macros && !used && - self.session.cstore.dep_kind(module.def_id().unwrap().krate).macros_only() { + self.cstore.dep_kind(module.def_id().unwrap().krate).macros_only() { let msg = "proc macro crates and `#[no_link]` crates have no effect without \ `#[macro_use]`"; self.session.span_warn(item.span, msg); @@ -648,7 +648,7 @@ impl<'a> Resolver<'a> { } } for (name, span) in legacy_imports.reexports { - self.session.cstore.export_macros(module.def_id().unwrap().krate); + self.cstore.export_macros(module.def_id().unwrap().krate); let ident = Ident::with_empty_ctxt(name); let result = self.resolve_ident_in_module(module, ident, MacroNS, false, false, span); if let Ok(binding) = result { diff --git a/src/librustc_resolve/lib.rs b/src/librustc_resolve/lib.rs index 2183c9124e7f4..ee97002f6be56 100644 --- a/src/librustc_resolve/lib.rs +++ b/src/librustc_resolve/lib.rs @@ -31,7 +31,7 @@ use self::RibKind::*; use rustc::hir::map::{Definitions, DefCollector}; use rustc::hir::{self, PrimTy, TyBool, TyChar, TyFloat, TyInt, TyUint, TyStr}; -use rustc::middle::cstore::CrateLoader; +use rustc::middle::cstore::{CrateStore, CrateLoader}; use rustc::session::Session; use rustc::lint; use rustc::hir::def::*; @@ -1176,6 +1176,7 @@ impl PrimitiveTypeTable { /// The main resolver class. pub struct Resolver<'a> { session: &'a Session, + cstore: &'a CrateStore, pub definitions: Definitions, @@ -1343,7 +1344,7 @@ impl<'a, 'b: 'a> ty::DefIdTree for &'a Resolver<'b> { fn parent(self, id: DefId) -> Option { match id.krate { LOCAL_CRATE => self.definitions.def_key(id.index).parent, - _ => self.session.cstore.def_key(id).parent, + _ => self.cstore.def_key(id).parent, }.map(|index| DefId { index: index, ..id }) } } @@ -1383,6 +1384,7 @@ impl<'a> hir::lowering::Resolver for Resolver<'a> { impl<'a> Resolver<'a> { pub fn new(session: &'a Session, + cstore: &'a CrateStore, krate: &Crate, crate_name: &str, make_glob_map: MakeGlobMap, @@ -1414,6 +1416,8 @@ impl<'a> Resolver<'a> { Resolver { session, + cstore, + definitions, // The outermost module has def ID 0; this is not reflected in the diff --git a/src/librustc_resolve/macros.rs b/src/librustc_resolve/macros.rs index 9531c8baa0bc1..f269e37cfafa1 100644 --- a/src/librustc_resolve/macros.rs +++ b/src/librustc_resolve/macros.rs @@ -778,7 +778,7 @@ impl<'a> Resolver<'a> { _ => return, }; - let crate_name = self.session.cstore.crate_name(krate); + let crate_name = self.cstore.crate_name(krate); self.session.struct_span_err(use_span, warn_msg) .help(&format!("instead, import the procedural macro like any other item: \ diff --git a/src/librustc_resolve/resolve_imports.rs b/src/librustc_resolve/resolve_imports.rs index 71bcee56ecc51..6e379d17399d8 100644 --- a/src/librustc_resolve/resolve_imports.rs +++ b/src/librustc_resolve/resolve_imports.rs @@ -844,7 +844,7 @@ impl<'a, 'b:'a> ImportResolver<'a, 'b> { let def = binding.def(); if def != Def::Err { if !def.def_id().is_local() { - self.session.cstore.export_macros(def.def_id().krate); + self.cstore.export_macros(def.def_id().krate); } if let Def::Macro(..) = def { if let Some(&span) = exported_macro_names.get(&ident.modern()) { diff --git a/src/librustc_save_analysis/lib.rs b/src/librustc_save_analysis/lib.rs index 9ee38dd86c1b5..27caa49a52c6c 100644 --- a/src/librustc_save_analysis/lib.rs +++ b/src/librustc_save_analysis/lib.rs @@ -109,7 +109,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { pub fn get_external_crates(&self) -> Vec { let mut result = Vec::new(); - for n in self.tcx.sess.cstore.crates() { + for n in self.tcx.cstore().crates() { let span = match *self.tcx.extern_crate(n.as_def_id()) { Some(ref c) => c.span, None => { @@ -119,7 +119,7 @@ impl<'l, 'tcx: 'l> SaveContext<'l, 'tcx> { }; let lo_loc = self.span_utils.sess.codemap().lookup_char_pos(span.lo()); result.push(ExternalCrateData { - name: self.tcx.sess.cstore.crate_name(n).to_string(), + name: self.tcx.cstore().crate_name(n).to_string(), num: n.as_u32(), file_name: SpanUtils::make_path_string(&lo_loc.file.name), }); diff --git a/src/librustc_trans/back/link.rs b/src/librustc_trans/back/link.rs index 4e211d83cff3e..0cb7f255dbbb2 100644 --- a/src/librustc_trans/back/link.rs +++ b/src/librustc_trans/back/link.rs @@ -20,7 +20,7 @@ use rustc::session::filesearch; use rustc::session::search_paths::PathKind; use rustc::session::Session; use rustc::middle::cstore::{LinkMeta, NativeLibrary, LibSource, LinkagePreference, - NativeLibraryKind}; + NativeLibraryKind, CrateStore}; use rustc::middle::dependency_format::Linkage; use CrateTranslation; use rustc::util::common::time; @@ -163,6 +163,7 @@ pub fn remove(sess: &Session, path: &Path) { /// Perform the linkage portion of the compilation phase. This will generate all /// of the requested outputs for this compilation session. pub fn link_binary(sess: &Session, + cstore: &CrateStore, trans: &CrateTranslation, outputs: &OutputFilenames, crate_name: &str) -> Vec { @@ -179,7 +180,12 @@ pub fn link_binary(sess: &Session, bug!("invalid output type `{:?}` for target os `{}`", crate_type, sess.opts.target_triple); } - let mut out_files = link_binary_output(sess, trans, crate_type, outputs, crate_name); + let mut out_files = link_binary_output(sess, + cstore, + trans, + crate_type, + outputs, + crate_name); out_filenames.append(&mut out_files); } @@ -216,8 +222,9 @@ fn filename_for_metadata(sess: &Session, crate_name: &str, outputs: &OutputFilen } pub fn each_linked_rlib(sess: &Session, + cstore: &CrateStore, f: &mut FnMut(CrateNum, &Path)) -> Result<(), String> { - let crates = sess.cstore.used_crates(LinkagePreference::RequireStatic).into_iter(); + let crates = cstore.used_crates(LinkagePreference::RequireStatic).into_iter(); let fmts = sess.dependency_formats.borrow(); let fmts = fmts.get(&config::CrateTypeExecutable) .or_else(|| fmts.get(&config::CrateTypeStaticlib)) @@ -234,7 +241,7 @@ pub fn each_linked_rlib(sess: &Session, Some(_) => {} None => return Err(format!("could not find formats for rlibs")) } - let name = sess.cstore.crate_name(cnum).clone(); + let name = cstore.crate_name(cnum).clone(); let path = match path { LibSource::Some(p) => p, LibSource::MetadataOnly => { @@ -260,12 +267,12 @@ pub fn each_linked_rlib(sess: &Session, /// It's unusual for a crate to not participate in LTO. Typically only /// compiler-specific and unstable crates have a reason to not participate in /// LTO. -pub fn ignored_for_lto(sess: &Session, cnum: CrateNum) -> bool { +pub fn ignored_for_lto(cstore: &CrateStore, cnum: CrateNum) -> bool { // `#![no_builtins]` crates don't participate in LTO because the state // of builtins gets messed up (our crate isn't tagged with no builtins). // Similarly `#![compiler_builtins]` doesn't participate because we want // those builtins! - sess.cstore.is_no_builtins(cnum) || sess.cstore.is_compiler_builtins(cnum) + cstore.is_no_builtins(cnum) || cstore.is_compiler_builtins(cnum) } fn out_filename(sess: &Session, @@ -295,6 +302,7 @@ fn check_file_is_writeable(file: &Path, sess: &Session) { } fn link_binary_output(sess: &Session, + cstore: &CrateStore, trans: &CrateTranslation, crate_type: config::CrateType, outputs: &OutputFilenames, @@ -323,6 +331,7 @@ fn link_binary_output(sess: &Session, match crate_type { config::CrateTypeRlib => { link_rlib(sess, + cstore, trans, RlibFlavor::Normal, &objects, @@ -332,6 +341,7 @@ fn link_binary_output(sess: &Session, } config::CrateTypeStaticlib => { link_staticlib(sess, + cstore, trans, outputs, &objects, @@ -339,8 +349,8 @@ fn link_binary_output(sess: &Session, tmpdir.path()); } _ => { - link_natively(sess, crate_type, &objects, &out_filename, trans, - outputs, tmpdir.path()); + link_natively(sess, cstore, crate_type, &objects, &out_filename, + trans, outputs, tmpdir.path()); } } out_filenames.push(out_filename); @@ -402,6 +412,7 @@ enum RlibFlavor { // all of the object files from native libraries. This is done by unzipping // native libraries and inserting all of the contents into this archive. fn link_rlib<'a>(sess: &'a Session, + cstore: &CrateStore, trans: &CrateTranslation, flavor: RlibFlavor, objects: &[PathBuf], @@ -431,7 +442,7 @@ fn link_rlib<'a>(sess: &'a Session, // feature then we'll need to figure out how to record what objects were // loaded from the libraries found here and then encode that into the // metadata of the rlib we're generating somehow. - for lib in sess.cstore.used_libraries() { + for lib in cstore.used_libraries() { match lib.kind { NativeLibraryKind::NativeStatic => {} NativeLibraryKind::NativeStaticNobundle | @@ -597,12 +608,14 @@ fn write_rlib_bytecode_object_v1(writer: &mut Write, // link in the metadata object file (and also don't prepare the archive with a // metadata file). fn link_staticlib(sess: &Session, + cstore: &CrateStore, trans: &CrateTranslation, outputs: &OutputFilenames, objects: &[PathBuf], out_filename: &Path, tempdir: &Path) { let mut ab = link_rlib(sess, + cstore, trans, RlibFlavor::StaticlibBase, objects, @@ -611,9 +624,9 @@ fn link_staticlib(sess: &Session, tempdir); let mut all_native_libs = vec![]; - let res = each_linked_rlib(sess, &mut |cnum, path| { - let name = sess.cstore.crate_name(cnum); - let native_libs = sess.cstore.native_libraries(cnum); + let res = each_linked_rlib(sess, cstore, &mut |cnum, path| { + let name = cstore.crate_name(cnum); + let native_libs = cstore.native_libraries(cnum); // Here when we include the rlib into our staticlib we need to make a // decision whether to include the extra object files along the way. @@ -634,10 +647,10 @@ fn link_staticlib(sess: &Session, }); ab.add_rlib(path, &name.as_str(), - sess.lto() && !ignored_for_lto(sess, cnum), + sess.lto() && !ignored_for_lto(cstore, cnum), skip_object_files).unwrap(); - all_native_libs.extend(sess.cstore.native_libraries(cnum)); + all_native_libs.extend(cstore.native_libraries(cnum)); }); if let Err(e) = res { sess.fatal(&e); @@ -670,6 +683,7 @@ fn link_staticlib(sess: &Session, // This will invoke the system linker/cc to create the resulting file. This // links to all upstream files as well. fn link_natively(sess: &Session, + cstore: &CrateStore, crate_type: config::CrateType, objects: &[PathBuf], out_filename: &Path, @@ -713,7 +727,7 @@ fn link_natively(sess: &Session, { let mut linker = trans.linker_info.to_linker(cmd, &sess); - link_args(&mut *linker, sess, crate_type, tmpdir, + link_args(&mut *linker, sess, cstore, crate_type, tmpdir, objects, out_filename, outputs, trans); cmd = linker.finalize(); } @@ -839,6 +853,7 @@ fn link_natively(sess: &Session, fn link_args(cmd: &mut Linker, sess: &Session, + cstore: &CrateStore, crate_type: config::CrateType, tmpdir: &Path, objects: &[PathBuf], @@ -892,7 +907,7 @@ fn link_args(cmd: &mut Linker, cmd.gc_sections(keep_metadata); } - let used_link_args = sess.cstore.used_link_args(); + let used_link_args = cstore.used_link_args(); if crate_type == config::CrateTypeExecutable && t.options.position_independent_executables { @@ -962,9 +977,9 @@ fn link_args(cmd: &mut Linker, // link line. And finally upstream native libraries can't depend on anything // in this DAG so far because they're only dylibs and dylibs can only depend // on other dylibs (e.g. other native deps). - add_local_native_libraries(cmd, sess); - add_upstream_rust_crates(cmd, sess, crate_type, tmpdir); - add_upstream_native_libraries(cmd, sess, crate_type); + add_local_native_libraries(cmd, sess, cstore); + add_upstream_rust_crates(cmd, sess, cstore, crate_type, tmpdir); + add_upstream_native_libraries(cmd, sess, cstore, crate_type); // Tell the linker what we're doing. if crate_type != config::CrateTypeExecutable { @@ -989,7 +1004,7 @@ fn link_args(cmd: &mut Linker, path }; let mut rpath_config = RPathConfig { - used_crates: sess.cstore.used_crates(LinkagePreference::RequireDynamic), + used_crates: cstore.used_crates(LinkagePreference::RequireDynamic), out_filename: out_filename.to_path_buf(), has_rpath: sess.target.target.options.has_rpath, is_like_osx: sess.target.target.options.is_like_osx, @@ -1019,7 +1034,7 @@ fn link_args(cmd: &mut Linker, // Also note that the native libraries linked here are only the ones located // in the current crate. Upstream crates with native library dependencies // may have their native library pulled in above. -fn add_local_native_libraries(cmd: &mut Linker, sess: &Session) { +fn add_local_native_libraries(cmd: &mut Linker, sess: &Session, cstore: &CrateStore) { sess.target_filesearch(PathKind::All).for_each_lib_search_path(|path, k| { match k { PathKind::Framework => { cmd.framework_path(path); } @@ -1027,7 +1042,7 @@ fn add_local_native_libraries(cmd: &mut Linker, sess: &Session) { } }); - let relevant_libs = sess.cstore.used_libraries().into_iter().filter(|l| { + let relevant_libs = cstore.used_libraries().into_iter().filter(|l| { relevant_lib(sess, l) }); @@ -1050,6 +1065,7 @@ fn add_local_native_libraries(cmd: &mut Linker, sess: &Session) { // the intermediate rlib version) fn add_upstream_rust_crates(cmd: &mut Linker, sess: &Session, + cstore: &CrateStore, crate_type: config::CrateType, tmpdir: &Path) { // All of the heavy lifting has previously been accomplished by the @@ -1065,7 +1081,7 @@ fn add_upstream_rust_crates(cmd: &mut Linker, // Invoke get_used_crates to ensure that we get a topological sorting of // crates. - let deps = sess.cstore.used_crates(LinkagePreference::RequireDynamic); + let deps = cstore.used_crates(LinkagePreference::RequireDynamic); let mut compiler_builtins = None; @@ -1073,24 +1089,24 @@ fn add_upstream_rust_crates(cmd: &mut Linker, // We may not pass all crates through to the linker. Some crates may // appear statically in an existing dylib, meaning we'll pick up all the // symbols from the dylib. - let src = sess.cstore.used_crate_source(cnum); + let src = cstore.used_crate_source(cnum); match data[cnum.as_usize() - 1] { - _ if sess.cstore.is_profiler_runtime(cnum) => { - add_static_crate(cmd, sess, tmpdir, crate_type, cnum); + _ if cstore.is_profiler_runtime(cnum) => { + add_static_crate(cmd, sess, cstore, tmpdir, crate_type, cnum); } - _ if sess.cstore.is_sanitizer_runtime(cnum) => { - link_sanitizer_runtime(cmd, sess, tmpdir, cnum); + _ if cstore.is_sanitizer_runtime(cnum) => { + link_sanitizer_runtime(cmd, sess, cstore, tmpdir, cnum); } // compiler-builtins are always placed last to ensure that they're // linked correctly. - _ if sess.cstore.is_compiler_builtins(cnum) => { + _ if cstore.is_compiler_builtins(cnum) => { assert!(compiler_builtins.is_none()); compiler_builtins = Some(cnum); } Linkage::NotLinked | Linkage::IncludedFromDylib => {} Linkage::Static => { - add_static_crate(cmd, sess, tmpdir, crate_type, cnum); + add_static_crate(cmd, sess, cstore, tmpdir, crate_type, cnum); } Linkage::Dynamic => { add_dynamic_crate(cmd, sess, &src.dylib.unwrap().0) @@ -1104,7 +1120,7 @@ fn add_upstream_rust_crates(cmd: &mut Linker, // was already "included" in a dylib (e.g. `libstd` when `-C prefer-dynamic` // is used) if let Some(cnum) = compiler_builtins { - add_static_crate(cmd, sess, tmpdir, crate_type, cnum); + add_static_crate(cmd, sess, cstore, tmpdir, crate_type, cnum); } // Converts a library file-stem into a cc -l argument @@ -1122,9 +1138,10 @@ fn add_upstream_rust_crates(cmd: &mut Linker, // linking it. fn link_sanitizer_runtime(cmd: &mut Linker, sess: &Session, + cstore: &CrateStore, tmpdir: &Path, cnum: CrateNum) { - let src = sess.cstore.used_crate_source(cnum); + let src = cstore.used_crate_source(cnum); let cratepath = &src.rlib.unwrap().0; if sess.target.target.options.is_like_osx { @@ -1190,21 +1207,22 @@ fn add_upstream_rust_crates(cmd: &mut Linker, // we're at the end of the dependency chain. fn add_static_crate(cmd: &mut Linker, sess: &Session, + cstore: &CrateStore, tmpdir: &Path, crate_type: config::CrateType, cnum: CrateNum) { - let src = sess.cstore.used_crate_source(cnum); + let src = cstore.used_crate_source(cnum); let cratepath = &src.rlib.unwrap().0; // See the comment above in `link_staticlib` and `link_rlib` for why if // there's a static library that's not relevant we skip all object // files. - let native_libs = sess.cstore.native_libraries(cnum); + let native_libs = cstore.native_libraries(cnum); let skip_native = native_libs.iter().any(|lib| { lib.kind == NativeLibraryKind::NativeStatic && !relevant_lib(sess, lib) }); - if (!sess.lto() || ignored_for_lto(sess, cnum)) && + if (!sess.lto() || ignored_for_lto(cstore, cnum)) && crate_type != config::CrateTypeDylib && !skip_native { cmd.link_rlib(&fix_windows_verbatim_for_gcc(cratepath)); @@ -1246,7 +1264,7 @@ fn add_upstream_rust_crates(cmd: &mut Linker, // LTO module. Note that `#![no_builtins]` is excluded from LTO, // though, so we let that object file slide. let skip_because_lto = sess.lto() && is_rust_object && - !sess.cstore.is_no_builtins(cnum); + !cstore.is_no_builtins(cnum); if skip_because_cfg_say_so || skip_because_lto { archive.remove_file(&f); @@ -1268,7 +1286,7 @@ fn add_upstream_rust_crates(cmd: &mut Linker, // compiler-builtins crate (e.g. compiler-rt) because it'll get // repeatedly linked anyway. if crate_type == config::CrateTypeDylib && - !sess.cstore.is_compiler_builtins(cnum) { + !cstore.is_compiler_builtins(cnum) { cmd.link_whole_rlib(&fix_windows_verbatim_for_gcc(&dst)); } else { cmd.link_rlib(&fix_windows_verbatim_for_gcc(&dst)); @@ -1312,7 +1330,10 @@ fn add_upstream_rust_crates(cmd: &mut Linker, // generic function calls a native function, then the generic function must // be instantiated in the target crate, meaning that the native symbol must // also be resolved in the target crate. -fn add_upstream_native_libraries(cmd: &mut Linker, sess: &Session, crate_type: config::CrateType) { +fn add_upstream_native_libraries(cmd: &mut Linker, + sess: &Session, + cstore: &CrateStore, + crate_type: config::CrateType) { // Be sure to use a topological sorting of crates because there may be // interdependencies between native libraries. When passing -nodefaultlibs, // for example, almost all native libraries depend on libc, so we have to @@ -1325,9 +1346,9 @@ fn add_upstream_native_libraries(cmd: &mut Linker, sess: &Session, crate_type: c let formats = sess.dependency_formats.borrow(); let data = formats.get(&crate_type).unwrap(); - let crates = sess.cstore.used_crates(LinkagePreference::RequireStatic); + let crates = cstore.used_crates(LinkagePreference::RequireStatic); for (cnum, _) in crates { - for lib in sess.cstore.native_libraries(cnum) { + for lib in cstore.native_libraries(cnum) { if !relevant_lib(sess, &lib) { continue } diff --git a/src/librustc_trans/back/symbol_export.rs b/src/librustc_trans/back/symbol_export.rs index 971483e91b6f3..c049ebfd7a34e 100644 --- a/src/librustc_trans/back/symbol_export.rs +++ b/src/librustc_trans/back/symbol_export.rs @@ -110,13 +110,13 @@ impl ExportedSymbols { let mut exports = FxHashMap(); exports.insert(LOCAL_CRATE, local_crate); - for cnum in tcx.sess.cstore.crates() { + for cnum in tcx.cstore().crates() { debug_assert!(cnum != LOCAL_CRATE); // If this crate is a plugin and/or a custom derive crate, then // we're not even going to link those in so we skip those crates. - if tcx.sess.cstore.plugin_registrar_fn(cnum).is_some() || - tcx.sess.cstore.derive_registrar_fn(cnum).is_some() { + if tcx.cstore().plugin_registrar_fn(cnum).is_some() || + tcx.cstore().derive_registrar_fn(cnum).is_some() { continue; } @@ -129,11 +129,10 @@ impl ExportedSymbols { // level instead. let special_runtime_crate = tcx.is_panic_runtime(cnum.as_def_id()) || - tcx.sess.cstore.is_compiler_builtins(cnum); + tcx.cstore().is_compiler_builtins(cnum); let crate_exports = tcx - .sess - .cstore + .cstore() .exported_symbols(cnum) .iter() .map(|&def_id| { diff --git a/src/librustc_trans/back/write.rs b/src/librustc_trans/back/write.rs index 3f9b28d3d610c..214b2b7e2e565 100644 --- a/src/librustc_trans/back/write.rs +++ b/src/librustc_trans/back/write.rs @@ -13,7 +13,7 @@ use back::link::{self, get_linker, remove}; use back::linker::LinkerInfo; use back::symbol_export::ExportedSymbols; use rustc_incremental::{save_trans_partition, in_incr_comp_dir}; -use rustc::middle::cstore::{LinkMeta, EncodedMetadata}; +use rustc::middle::cstore::{CrateStore, LinkMeta, EncodedMetadata}; use rustc::session::config::{self, OutputFilenames, OutputType, OutputTypes, Passes, SomePasses, AllPasses, Sanitizer}; use rustc::session::Session; @@ -666,6 +666,7 @@ fn need_crate_bitcode_for_rlib(sess: &Session) -> bool { } pub fn start_async_translation(sess: &Session, + cstore: &CrateStore, crate_output: &OutputFilenames, time_graph: Option, crate_name: Symbol, @@ -774,6 +775,7 @@ pub fn start_async_translation(sess: &Session, let (coordinator_send, coordinator_receive) = channel(); let coordinator_thread = start_executing_work(sess, + cstore, shared_emitter, trans_worker_send, coordinator_send.clone(), @@ -1101,6 +1103,7 @@ enum MainThreadWorkerState { } fn start_executing_work(sess: &Session, + cstore: &CrateStore, shared_emitter: SharedEmitter, trans_worker_send: Sender, coordinator_send: Sender, @@ -1125,8 +1128,8 @@ fn start_executing_work(sess: &Session, }).expect("failed to spawn helper thread"); let mut each_linked_rlib_for_lto = Vec::new(); - drop(link::each_linked_rlib(sess, &mut |cnum, path| { - if link::ignored_for_lto(sess, cnum) { + drop(link::each_linked_rlib(sess, cstore, &mut |cnum, path| { + if link::ignored_for_lto(cstore, cnum) { return } each_linked_rlib_for_lto.push((cnum, path.to_path_buf())); diff --git a/src/librustc_trans/base.rs b/src/librustc_trans/base.rs index a6c6b0efcfa8c..c4918336a9326 100644 --- a/src/librustc_trans/base.rs +++ b/src/librustc_trans/base.rs @@ -774,7 +774,7 @@ fn write_metadata<'a, 'gcx>(tcx: TyCtxt<'a, 'gcx, 'gcx>, EncodedMetadataHashes::new()); } - let cstore = &tcx.sess.cstore; + let cstore = tcx.cstore(); let (metadata, hashes) = cstore.encode_metadata(tcx, &link_meta, exported_symbols); @@ -904,7 +904,7 @@ pub fn find_exported_symbols(tcx: TyCtxt, reachable: &NodeSet) -> NodeSet { match tcx.hir.get(id) { hir_map::NodeForeignItem(..) => { let def_id = tcx.hir.local_def_id(id); - tcx.sess.cstore.is_statically_included_foreign_item(def_id) + tcx.cstore().is_statically_included_foreign_item(def_id) } // Only consider nodes that actually have exported symbols. @@ -978,6 +978,7 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let linker_info = LinkerInfo::new(&shared_ccx, &empty_exported_symbols); let ongoing_translation = write::start_async_translation( tcx.sess, + tcx.cstore(), output_filenames, time_graph.clone(), tcx.crate_name(LOCAL_CRATE), @@ -1030,6 +1031,7 @@ pub fn trans_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>, let ongoing_translation = write::start_async_translation( tcx.sess, + tcx.cstore(), output_filenames, time_graph.clone(), tcx.crate_name(LOCAL_CRATE), diff --git a/src/librustc_trans/callee.rs b/src/librustc_trans/callee.rs index 76f94565bae51..5104cc792ab4e 100644 --- a/src/librustc_trans/callee.rs +++ b/src/librustc_trans/callee.rs @@ -125,7 +125,7 @@ pub fn get_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, } if ccx.use_dll_storage_attrs() && - ccx.sess().cstore.is_dllimport_foreign_item(instance_def_id) + ccx.tcx().cstore().is_dllimport_foreign_item(instance_def_id) { unsafe { llvm::LLVMSetDLLStorageClass(llfn, llvm::DLLStorageClass::DllImport); diff --git a/src/librustc_trans/consts.rs b/src/librustc_trans/consts.rs index 310cd6fe9559d..c018cd8b48711 100644 --- a/src/librustc_trans/consts.rs +++ b/src/librustc_trans/consts.rs @@ -211,7 +211,7 @@ pub fn get_static(ccx: &CrateContext, def_id: DefId) -> ValueRef { g }; - if ccx.use_dll_storage_attrs() && ccx.sess().cstore.is_dllimport_foreign_item(def_id) { + if ccx.use_dll_storage_attrs() && ccx.tcx().cstore().is_dllimport_foreign_item(def_id) { // For foreign (native) libs we know the exact storage type to use. unsafe { llvm::LLVMSetDLLStorageClass(g, llvm::DLLStorageClass::DllImport); diff --git a/src/librustc_typeck/check/method/suggest.rs b/src/librustc_typeck/check/method/suggest.rs index f2d7842e473f6..5342c5ca84635 100644 --- a/src/librustc_typeck/check/method/suggest.rs +++ b/src/librustc_typeck/check/method/suggest.rs @@ -552,14 +552,14 @@ pub fn all_traits<'a, 'gcx, 'tcx>(tcx: TyCtxt<'a, 'gcx, 'tcx>) -> AllTraits<'a> if !external_mods.insert(def_id) { return; } - for child in tcx.sess.cstore.item_children(def_id, tcx.sess) { + for child in tcx.cstore().item_children(def_id, tcx.sess) { handle_external_def(tcx, traits, external_mods, child.def) } } _ => {} } } - for cnum in tcx.sess.cstore.crates() { + for cnum in tcx.cstore().crates() { let def_id = DefId { krate: cnum, index: CRATE_DEF_INDEX, diff --git a/src/librustc_typeck/check_unused.rs b/src/librustc_typeck/check_unused.rs index 3da154e0689ad..e5e5b11e044d4 100644 --- a/src/librustc_typeck/check_unused.rs +++ b/src/librustc_typeck/check_unused.rs @@ -74,7 +74,7 @@ pub fn check_crate<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>) { tcx.hir.krate().visit_all_item_likes(&mut visitor); for &(id, span) in &tcx.maybe_unused_extern_crates { - let cnum = tcx.sess.cstore.extern_mod_stmt_cnum(id).unwrap().as_def_id(); + let cnum = tcx.cstore().extern_mod_stmt_cnum(id).unwrap().as_def_id(); if !tcx.is_compiler_builtins(cnum) && !tcx.is_panic_runtime(cnum) && !tcx.has_global_allocator(cnum) { diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs index 5d39d1d27f4c3..957169e6c781e 100644 --- a/src/librustdoc/clean/inline.rs +++ b/src/librustdoc/clean/inline.rs @@ -120,7 +120,7 @@ pub fn load_attrs(cx: &DocContext, did: DefId) -> clean::Attributes { /// These names are used later on by HTML rendering to generate things like /// source links back to the original item. pub fn record_extern_fqn(cx: &DocContext, did: DefId, kind: clean::TypeKind) { - let crate_name = cx.tcx.sess.cstore.crate_name(did.krate).to_string(); + let crate_name = cx.tcx.cstore().crate_name(did.krate).to_string(); let relative = cx.tcx.def_path(did).data.into_iter().filter_map(|elem| { // extern blocks have an empty name let s = elem.data.to_string(); @@ -236,7 +236,7 @@ pub fn build_impls(cx: &DocContext, did: DefId) -> Vec { cx.populated_all_crate_impls.set(true); - for did in tcx.sess.cstore.implementations_of_trait(None) { + for did in tcx.cstore().implementations_of_trait(None) { build_impl(cx, did, &mut impls); } @@ -443,9 +443,9 @@ fn build_module(cx: &DocContext, did: DefId) -> clean::Module { // two namespaces, so the target may be listed twice. Make sure we only // visit each node at most once. let mut visited = FxHashSet(); - for item in cx.tcx.sess.cstore.item_children(did, cx.tcx.sess) { + for item in cx.tcx.cstore().item_children(did, cx.tcx.sess) { let def_id = item.def.def_id(); - if cx.tcx.sess.cstore.visibility(def_id) == ty::Visibility::Public { + if cx.tcx.cstore().visibility(def_id) == ty::Visibility::Public { if !visited.insert(def_id) { continue } if let Some(i) = try_inline(cx, item.def, item.ident.name) { items.extend(i) @@ -471,7 +471,7 @@ impl hir::print::PpAnn for InlinedConst { } fn print_inlined_const(cx: &DocContext, did: DefId) -> String { - let body = cx.tcx.sess.cstore.item_body(cx.tcx, did); + let body = cx.tcx.cstore().item_body(cx.tcx, did); let inlined = InlinedConst { nested_bodies: cx.tcx.item_body_nested_bodies(did) }; diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs index aab44ddce0e6a..2869dd452d1be 100644 --- a/src/librustdoc/clean/mod.rs +++ b/src/librustdoc/clean/mod.rs @@ -131,7 +131,7 @@ impl<'a, 'tcx> Clean for visit_ast::RustdocVisitor<'a, 'tcx> { } let mut externs = Vec::new(); - for cnum in cx.sess().cstore.crates() { + for cnum in cx.tcx.cstore().crates() { externs.push((cnum, cnum.clean(cx))); // Analyze doc-reachability for extern items LibEmbargoVisitor::new(cx).visit_lib(cnum); @@ -244,7 +244,7 @@ impl Clean for CrateNum { } }).collect() } else { - cx.tcx.sess.cstore.item_children(root, cx.tcx.sess).iter().map(|item| item.def) + cx.tcx.cstore().item_children(root, cx.tcx.sess).iter().map(|item| item.def) .filter_map(as_primitive).collect() }; diff --git a/src/librustdoc/core.rs b/src/librustdoc/core.rs index 58de0e1caecdb..93f7230ab406d 100644 --- a/src/librustdoc/core.rs +++ b/src/librustdoc/core.rs @@ -148,7 +148,7 @@ pub fn run_core(search_paths: SearchPaths, let _ignore = dep_graph.in_ignore(); let cstore = Rc::new(CStore::new(&dep_graph, box rustc_trans::LlvmMetadataLoader)); let mut sess = session::build_session_( - sessopts, &dep_graph, cpath, diagnostic_handler, codemap, cstore.clone() + sessopts, &dep_graph, cpath, diagnostic_handler, codemap ); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); @@ -181,6 +181,7 @@ pub fn run_core(search_paths: SearchPaths, let hir_map = hir_map::map_crate(&mut hir_forest, defs); abort_on_err(driver::phase_3_run_analysis_passes(&sess, + &*cstore, hir_map, analysis, resolutions, diff --git a/src/librustdoc/test.rs b/src/librustdoc/test.rs index 5d74cbdf56a19..38d59dbb944c6 100644 --- a/src/librustdoc/test.rs +++ b/src/librustdoc/test.rs @@ -87,7 +87,7 @@ pub fn run(input: &str, let _ignore = dep_graph.in_ignore(); let cstore = Rc::new(CStore::new(&dep_graph, box rustc_trans::LlvmMetadataLoader)); let mut sess = session::build_session_( - sessopts, &dep_graph, Some(input_path.clone()), handler, codemap.clone(), cstore.clone(), + sessopts, &dep_graph, Some(input_path.clone()), handler, codemap.clone() ); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); @@ -240,7 +240,7 @@ fn run_test(test: &str, cratename: &str, filename: &str, cfgs: Vec, libs let dep_graph = DepGraph::new(false); let cstore = Rc::new(CStore::new(&dep_graph, box rustc_trans::LlvmMetadataLoader)); let mut sess = session::build_session_( - sessopts, &dep_graph, None, diagnostic_handler, codemap, cstore.clone(), + sessopts, &dep_graph, None, diagnostic_handler, codemap ); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); diff --git a/src/librustdoc/visit_ast.rs b/src/librustdoc/visit_ast.rs index 1f33cd7765164..27de8cc5d4f42 100644 --- a/src/librustdoc/visit_ast.rs +++ b/src/librustdoc/visit_ast.rs @@ -207,8 +207,8 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { continue // These are `krate.exported_macros`, handled in `self.visit()`. } - let imported_from = self.cx.sess().cstore.original_crate_name(def_id.krate); - let def = match self.cx.sess().cstore.load_macro(def_id, self.cx.sess()) { + let imported_from = self.cx.tcx.cstore().original_crate_name(def_id.krate); + let def = match self.cx.tcx.cstore().load_macro(def_id, self.cx.sess()) { LoadedMacro::MacroDef(macro_def) => macro_def, // FIXME(jseyfried): document proc macro reexports LoadedMacro::ProcMacro(..) => continue, @@ -371,7 +371,7 @@ impl<'a, 'tcx> RustdocVisitor<'a, 'tcx> { _ if self.inlining && item.vis != hir::Public => {} hir::ItemGlobalAsm(..) => {} hir::ItemExternCrate(ref p) => { - let cstore = &self.cx.sess().cstore; + let cstore = &self.cx.tcx.cstore(); om.extern_crates.push(ExternCrate { cnum: cstore.extern_mod_stmt_cnum(item.id) .unwrap_or(LOCAL_CRATE), diff --git a/src/librustdoc/visit_lib.rs b/src/librustdoc/visit_lib.rs index 7b5b27c5565cb..a84cd6d0181e6 100644 --- a/src/librustdoc/visit_lib.rs +++ b/src/librustdoc/visit_lib.rs @@ -38,7 +38,7 @@ impl<'a, 'b, 'tcx> LibEmbargoVisitor<'a, 'b, 'tcx> { pub fn new(cx: &'a ::core::DocContext<'b, 'tcx>) -> LibEmbargoVisitor<'a, 'b, 'tcx> { LibEmbargoVisitor { cx, - cstore: &*cx.sess().cstore, + cstore: cx.tcx.cstore(), access_levels: cx.access_levels.borrow_mut(), prev_level: Some(AccessLevel::Public), visited_mods: FxHashSet() diff --git a/src/test/run-make/issue-19371/foo.rs b/src/test/run-make/issue-19371/foo.rs index e96588c6e5aea..4040c8495473e 100644 --- a/src/test/run-make/issue-19371/foo.rs +++ b/src/test/run-make/issue-19371/foo.rs @@ -60,7 +60,7 @@ fn basic_sess(sysroot: PathBuf) -> (Session, Rc) { let descriptions = Registry::new(&rustc::DIAGNOSTICS); let dep_graph = DepGraph::new(opts.build_dep_graph()); let cstore = Rc::new(CStore::new(&dep_graph, Box::new(rustc_trans::LlvmMetadataLoader))); - let sess = build_session(opts, &dep_graph, None, descriptions, cstore.clone()); + let sess = build_session(opts, &dep_graph, None, descriptions); rustc_trans::init(&sess); rustc_lint::register_builtins(&mut sess.lint_store.borrow_mut(), Some(&sess)); (sess, cstore) diff --git a/src/test/run-pass-fulldeps/compiler-calls.rs b/src/test/run-pass-fulldeps/compiler-calls.rs index 4a397621ceb53..b5c1ee099037c 100644 --- a/src/test/run-pass-fulldeps/compiler-calls.rs +++ b/src/test/run-pass-fulldeps/compiler-calls.rs @@ -21,6 +21,7 @@ extern crate rustc_driver; extern crate syntax; extern crate rustc_errors as errors; +use rustc::middle::cstore::CrateStore; use rustc::session::Session; use rustc::session::config::{self, Input}; use rustc_driver::{driver, CompilerCalls, Compilation}; @@ -47,6 +48,7 @@ impl<'a> CompilerCalls<'a> for TestCalls { fn late_callback(&mut self, _: &getopts::Matches, _: &Session, + _: &CrateStore, _: &Input, _: &Option, _: &Option)