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;
// 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.
}
pub fn lower_crate(sess: &Session,
+ cstore: &CrateStore,
krate: &Crate,
resolver: &mut Resolver)
-> hir::Crate {
LoweringContext {
crate_root: std_inject::injected_crate_name(krate),
sess,
+ cstore,
parent_def: None,
resolver,
name_map: FxHashMap(),
if id.is_local() {
self.resolver.definitions().def_key(id.index)
} else {
- self.sess.cstore.def_key(id)
+ self.cstore.def_key(id)
}
}
return n;
}
assert!(!def_id.is_local());
- let n = self.sess.cstore.item_generics_cloned_untracked(def_id).regions.len();
+ let n = self.cstore.item_generics_cloned_untracked(def_id).regions.len();
self.type_def_lifetime_params.insert(def_id, n);
n
});
//! 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;
struct LifetimeContext<'a, 'tcx: 'a> {
sess: &'a Session,
+ cstore: &'a CrateStore,
hir_map: &'a Map<'tcx>,
map: &'a mut NamedRegionMap,
scope: ScopeRef<'a>,
const ROOT_SCOPE: ScopeRef<'static> = &Scope::Root;
pub fn krate(sess: &Session,
+ cstore: &CrateStore,
hir_map: &Map)
-> Result<NamedRegionMap, ErrorReported> {
let krate = hir_map.krate();
sess.track_errors(|| {
let mut visitor = LifetimeContext {
sess,
+ cstore,
hir_map,
map: &mut map,
scope: ROOT_SCOPE,
fn with<F>(&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,
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,
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_untracked(def_id).types.into_iter().map(|def| {
def.object_lifetime_default
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;
};
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)));
}
};
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());
]).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);
}
]).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);
}
]).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);
}
}
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;
pub target: config::Config,
pub host: Target,
pub opts: config::Options,
- pub cstore: Rc<CrateStore>,
pub parse_sess: ParseSess,
// For a library crate, this is always none
pub entry_fn: RefCell<Option<(NodeId, Span)>>,
pub fn build_session(sopts: config::Options,
dep_graph: &DepGraph,
local_crate_source_file: Option<PathBuf>,
- registry: errors::registry::Registry,
- cstore: Rc<CrateStore>)
+ registry: errors::registry::Registry)
-> Session {
let file_path_mapping = sopts.file_path_mapping();
dep_graph,
local_crate_source_file,
registry,
- cstore,
Rc::new(codemap::CodeMap::new(file_path_mapping)),
None)
}
dep_graph: &DepGraph,
local_crate_source_file: Option<PathBuf>,
registry: errors::registry::Registry,
- cstore: Rc<CrateStore>,
codemap: Rc<codemap::CodeMap>,
emitter_dest: Option<Box<Write + Send>>)
-> Session {
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<PathBuf>,
span_diagnostic: errors::Handler,
- codemap: Rc<codemap::CodeMap>,
- cstore: Rc<CrateStore>)
+ codemap: Rc<codemap::CodeMap>)
-> Session {
let host = match Target::search(config::host_triple()) {
Ok(t) => t,
target: target_cfg,
host,
opts: sopts,
- cstore,
parse_sess: p_s,
// For a library crate, this is always none
entry_fn: RefCell::new(None),
use hir::map::DefPathHash;
use lint::{self, Lint};
use ich::{self, StableHashingContext, NodeIdHashingMode};
+<<<<<<< 817e1b81e230d599585f860cdcad96c5ed83b93e
use middle::const_val::ConstVal;
+=======
+use middle::cstore::CrateStore;
+>>>>>>> Remove the `cstore` reference from Session in order to prepare encapsulating CrateStore access in tcx.
use middle::free_region::FreeRegionMap;
use middle::lang_items;
use middle::resolve_lifetime::{self, ObjectLifetimeDefault};
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,
}
impl<'a, 'gcx, 'tcx> TyCtxt<'a, 'gcx, 'tcx> {
+ pub fn cstore_untracked(&self) -> &CrateStore {
+ &*self.cstore
+ }
+
pub fn alloc_generics(self, generics: ty::Generics) -> &'gcx ty::Generics {
self.global_arenas.generics.alloc(generics)
}
/// 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<F, R>(s: &'tcx Session,
+ cstore: &'tcx CrateStore,
local_providers: ty::maps::Providers<'tcx>,
extern_providers: ty::maps::Providers<'tcx>,
mir_passes: Rc<Passes>,
let interners = CtxtInterners::new(arena);
let common_types = CommonTypes::new(&interners);
let dep_graph = hir.dep_graph.clone();
- let max_cnum = s.cstore.crates_untracked().iter().map(|c| c.as_usize()).max().unwrap_or(0);
+ let max_cnum = cstore.crates_untracked().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_untracked()
.iter()
- .map(|&cnum| (cnum, s.cstore.def_path_table(cnum)))
+ .map(|&cnum| (cnum, cstore.def_path_table(cnum)))
.collect();
let def_path_tables = || {
tls::enter_global(GlobalCtxt {
sess: s,
+ cstore,
trans_trait_caches: traits::trans::TransTraitCaches::new(dep_graph.clone()),
global_arenas: arenas,
global_interners: interners,
}
}
- cur_path.push(self.sess.cstore.def_key(cur_def)
+ cur_path.push(self.cstore_untracked().def_key(cur_def)
.disambiguated_data.data.get_opt_name().unwrap_or_else(||
Symbol::intern("<unnamed>").as_str()));
match visible_parent_map.get(&cur_def) {
if id.is_local() {
self.hir.def_key(id)
} else {
- self.sess.cstore.def_key(id)
+ self.cstore_untracked().def_key(id)
}
}
if id.is_local() {
self.hir.def_path(id)
} else {
- self.sess.cstore.def_path(id)
+ self.cstore_untracked().def_path(id)
}
}
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_untracked().def_path_hash(def_id)
}
}
} else if id.index == CRATE_DEF_INDEX {
self.original_crate_name(id.krate).as_str()
} else {
- let def_key = self.sess.cstore.def_key(id);
+ let def_key = self.cstore_untracked().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 {
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};
};
phase_3_run_analysis_passes(sess,
+ cstore,
hir_map,
analysis,
resolutions,
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)
pub session: &'tcx Session,
pub krate: Option<ast::Crate>,
pub registry: Option<Registry<'a>>,
- 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>,
out_dir: &'a Option<PathBuf>,
out_file: &'a Option<PathBuf>,
krate: ast::Crate,
- cstore: &'a CStore)
+ cstore: &'tcx CStore)
-> Self {
CompileState {
// Initialize the registry before moving `krate`
session: &'tcx Session,
out_dir: &'a Option<PathBuf>,
out_file: &'a Option<PathBuf>,
- cstore: &'a CStore,
+ cstore: &'tcx CStore,
expanded_crate: &'a ast::Crate,
crate_name: &'a str)
-> Self {
out_file: &'a Option<PathBuf>,
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,
let mut crate_loader = CrateLoader::new(sess, &cstore, crate_name);
let resolver_arenas = Resolver::arenas();
let mut resolver = Resolver::new(sess,
+ cstore,
&krate,
crate_name,
make_glob_map,
// 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);
/// 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,
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",
passes.push_pass(MIR_OPTIMIZED, mir::transform::dump_mir::Marker("PreTrans"));
TyCtxt::create_and_enter(sess,
+ cstore,
local_providers,
extern_providers,
Rc::new(passes),
/// 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())
});
}
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};
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));
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);
fn late_callback(&mut self,
_: &getopts::Matches,
_: &Session,
+ _: &CrateStore,
_: &Input,
_: &Option<PathBuf>,
_: &Option<PathBuf>)
return None;
}
let dep_graph = DepGraph::new(sopts.build_dep_graph());
- let cstore = Rc::new(CStore::new(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());
fn late_callback(&mut self,
matches: &getopts::Matches,
sess: &Session,
+ cstore: &CrateStore,
input: &Input,
odir: &Option<PathBuf>,
ofile: &Option<PathBuf>)
-> 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,
};
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(),
}
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 {
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());
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;
}
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,
}
PpmTyped => {
abort_on_err(driver::phase_3_run_analysis_passes(sess,
+ cstore,
hir_map.clone(),
analysis.clone(),
resolutions.clone(),
}
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,
if ppm.needs_analysis() {
print_with_analysis(sess,
+ cstore,
hir_map,
analysis,
resolutions,
(PpmHir(s), None) => {
let out: &mut Write = &mut out;
s.call_with_pp_support_hir(sess,
+ cstore,
hir_map,
analysis,
resolutions,
(PpmHir(s), Some(uii)) => {
let out: &mut Write = &mut out;
s.call_with_pp_support_hir(sess,
+ cstore,
hir_map,
analysis,
resolutions,
// 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,
let mut out = Vec::new();
abort_on_err(driver::phase_3_run_analysis_passes(sess,
+ cstore,
hir_map.clone(),
analysis.clone(),
resolutions.clone(),
&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 {
let hir_map = hir_map::map_crate(&mut hir_forest, defs);
// run just enough stuff to build a tcx:
- let named_region_map = resolve_lifetime::krate(&sess, &hir_map);
+ let named_region_map = resolve_lifetime::krate(&sess, &*cstore, &hir_map);
TyCtxt::create_and_enter(&sess,
+ &*cstore,
ty::maps::Providers::default(),
ty::maps::Providers::default(),
Rc::new(Passes::new()),
$tcx.dep_graph.read(dep_node);
- let $cdata = $tcx.sess.cstore.crate_data_as_rc_any($def_id.krate);
+ let $cdata = $tcx.cstore_untracked().crate_data_as_rc_any($def_id.krate);
let $cdata = $cdata.downcast_ref::<cstore::CrateMetadata>()
.expect("CrateStore crated ata is not a CrateMetadata");
$compute
},
extern_mod_stmt_cnum: |tcx, id| {
let id = tcx.hir.as_local_node_id(id).unwrap();
- tcx.sess.cstore.extern_mod_stmt_cnum_untracked(id)
+ tcx.cstore_untracked().extern_mod_stmt_cnum_untracked(id)
},
all_crate_nums: |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
- Rc::new(tcx.sess.cstore.crates_untracked())
+ Rc::new(tcx.cstore_untracked().crates_untracked())
},
// Returns a map from a sufficiently visible external item (i.e. an
postorder_cnums: |tcx, cnum| {
assert_eq!(cnum, LOCAL_CRATE);
- Rc::new(tcx.sess.cstore.postorder_cnums_untracked())
+ Rc::new(tcx.cstore_untracked().postorder_cnums_untracked())
},
..*providers
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_untracked(item.id).unwrap();
+ let crate_id = self.cstore.extern_mod_stmt_cnum_untracked(item.id).unwrap();
let module =
self.get_module(DefId { krate: crate_id, index: CRATE_DEF_INDEX });
self.populate_module_if_necessary(module);
let ident = child.ident;
let def = child.def;
let def_id = def.def_id();
- let vis = self.session.cstore.visibility_untracked(def_id);
+ let vis = self.cstore.visibility_untracked(def_id);
let span = child.span;
let expansion = Mark::root(); // FIXME(jseyfried) intercrate hygiene
match def {
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));
}
span);
self.define(parent, ident, TypeNS, (module, vis, DUMMY_SP, expansion));
- for child in self.session.cstore.item_children_untracked(def_id, self.session) {
+ for child in self.cstore.item_children_untracked(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_untracked(child.def.def_id())
+ if self.cstore.associated_item_cloned_untracked(child.def.def_id())
.method_has_self_argument {
self.has_self.insert(child.def.def_id());
}
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_untracked(def_id);
+ let field_names = self.cstore.struct_field_names_untracked(def_id);
self.insert_field_names(def_id, field_names);
}
Def::Macro(..) => {
return self.module_map[&def_id]
}
- let macros_only = self.session.cstore.dep_kind_untracked(def_id.krate).macros_only();
+ let macros_only = self.cstore.dep_kind_untracked(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_untracked(def_id.krate).as_str(), None)
+ (self.cstore.crate_name_untracked(def_id.krate).as_str(), 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 })))
};
return ext.clone();
}
- let macro_def = match self.session.cstore.load_macro_untracked(def_id, &self.session) {
+ let macro_def = match self.cstore.load_macro_untracked(def_id, &self.session) {
LoadedMacro::MacroDef(macro_def) => macro_def,
LoadedMacro::ProcMacro(ext) => return ext,
};
pub fn populate_module_if_necessary(&mut self, module: Module<'a>) {
if module.populated.get() { return }
let def_id = module.def_id().unwrap();
- for child in self.session.cstore.item_children_untracked(def_id, self.session) {
+ for child in self.cstore.item_children_untracked(def_id, self.session) {
self.build_reduced_graph_for_external_crate_def(module, child);
}
module.populated.set(true)
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_untracked(module.def_id().unwrap().krate)
+ self.cstore.dep_kind_untracked(module.def_id().unwrap().krate)
.macros_only() {
let msg = "proc macro crates and `#[no_link]` crates have no effect without \
`#[macro_use]`";
}
}
for (name, span) in legacy_imports.reexports {
- self.session.cstore.export_macros_untracked(module.def_id().unwrap().krate);
+ self.cstore.export_macros_untracked(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 {
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::*;
/// The main resolver class.
pub struct Resolver<'a> {
session: &'a Session,
+ cstore: &'a CrateStore,
pub definitions: Definitions,
fn parent(self, id: DefId) -> Option<DefId> {
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 })
}
}
impl<'a> Resolver<'a> {
pub fn new(session: &'a Session,
+ cstore: &'a CrateStore,
krate: &Crate,
crate_name: &str,
make_glob_map: MakeGlobMap,
Resolver {
session,
+ cstore,
+
definitions,
// The outermost module has def ID 0; this is not reflected in the
_ => return,
};
- let crate_name = self.session.cstore.crate_name_untracked(krate);
+ let crate_name = self.cstore.crate_name_untracked(krate);
self.session.struct_span_err(use_span, warn_msg)
.help(&format!("instead, import the procedural macro like any other item: \
let def = binding.def();
if def != Def::Err {
if !def.def_id().is_local() {
- self.session.cstore.export_macros_untracked(def.def_id().krate);
+ self.cstore.export_macros_untracked(def.def_id().krate);
}
if let Def::Macro(..) = def {
if let Some(&span) = exported_macro_names.get(&ident.modern()) {
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,
+ trans,
+ crate_type,
+ outputs,
+ crate_name);
out_filenames.append(&mut out_files);
}
tmpdir.path());
}
_ => {
- link_natively(sess, crate_type, &objects, &out_filename, trans,
- outputs, tmpdir.path());
+ link_natively(sess, crate_type, &objects, &out_filename,
+ trans, outputs, tmpdir.path());
}
}
out_filenames.push(out_filename);
EncodedMetadataHashes::new());
}
- let cstore = &tcx.sess.cstore;
+ let cstore = tcx.cstore_untracked();
let (metadata, hashes) = cstore.encode_metadata(tcx,
&link_meta,
exported_symbols);
let _ignore = dep_graph.in_ignore();
let cstore = Rc::new(CStore::new(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));
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,
let _ignore = dep_graph.in_ignore();
let cstore = Rc::new(CStore::new(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));
let dep_graph = DepGraph::new(false);
let cstore = Rc::new(CStore::new(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));
let descriptions = Registry::new(&rustc::DIAGNOSTICS);
let dep_graph = DepGraph::new(opts.build_dep_graph());
let cstore = Rc::new(CStore::new(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)
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};
fn late_callback(&mut self,
_: &getopts::Matches,
_: &Session,
+ _: &CrateStore,
_: &Input,
_: &Option<PathBuf>,
_: &Option<PathBuf>)
projects / rust.git / commitdiff