}
};
a.add_rlib(&p, name, sess.lto()).unwrap();
- let native_libs = csearch::get_native_libraries(sess.cstore, cnum);
+ let native_libs = csearch::get_native_libraries(&sess.cstore, cnum);
for &(kind, ref lib) in native_libs.iter() {
let name = match kind {
cstore::NativeStatic => "static library",
// * If one form of linking fails, the second is also attempted
// * If both forms fail, then we emit an error message
- let dynamic = get_deps(sess.cstore, cstore::RequireDynamic);
- let statik = get_deps(sess.cstore, cstore::RequireStatic);
+ let dynamic = get_deps(&sess.cstore, cstore::RequireDynamic);
+ let statik = get_deps(&sess.cstore, cstore::RequireStatic);
match (dynamic, statik, sess.opts.cg.prefer_dynamic, dylib) {
(_, Some(deps), false, false) => {
add_static_crates(args, sess, tmpdir, deps)
// be instantiated in the target crate, meaning that the native symbol must
// also be resolved in the target crate.
fn add_upstream_native_libraries(args: &mut Vec<~str>, sess: &Session) {
- let cstore = sess.cstore;
+ let cstore = &sess.cstore;
cstore.iter_crate_data(|cnum, _| {
let libs = csearch::get_native_libraries(cstore, cnum);
for &(kind, ref lib) in libs.iter() {
-> Session {
let target_cfg = build_target_config(sopts);
let p_s = parse::new_parse_sess_special_handler(span_diagnostic_handler, codemap);
- let cstore = @CStore::new(token::get_ident_interner());
let default_sysroot = match sopts.maybe_sysroot {
Some(_) => None,
None => Some(filesearch::get_or_default_sysroot())
Session {
targ_cfg: target_cfg,
opts: sopts,
- cstore: cstore,
+ cstore: CStore::new(token::get_ident_interner()),
parse_sess: p_s,
codemap: codemap,
// For a library crate, this is always none
pub struct Session {
targ_cfg: @Config,
opts: @Options,
- cstore: @metadata::cstore::CStore,
+ cstore: metadata::cstore::CStore,
parse_sess: @ParseSess,
codemap: @codemap::CodeMap,
// For a library crate, this is always none
}
fn visit_crate(e: &Env, c: &ast::Crate) {
- let cstore = e.sess.cstore;
-
for a in c.attrs.iter().filter(|m| m.name().equiv(&("link_args"))) {
match a.value_str() {
- Some(ref linkarg) => cstore.add_used_link_args(linkarg.get()),
- None => { /* fallthrough */ }
+ Some(ref linkarg) => e.sess.cstore.add_used_link_args(linkarg.get()),
+ None => { /* fallthrough */ }
}
}
}
}
// First, add all of the custom link_args attributes
- let cstore = e.sess.cstore;
let link_args = i.attrs.iter()
.filter_map(|at| if at.name().equiv(&("link_args")) {
Some(at)
.to_owned_vec();
for m in link_args.iter() {
match m.value_str() {
- Some(linkarg) => cstore.add_used_link_args(linkarg.get()),
+ Some(linkarg) => e.sess.cstore.add_used_link_args(linkarg.get()),
None => { /* fallthrough */ }
}
}
// Next, process all of the #[link(..)]-style arguments
- let cstore = e.sess.cstore;
let link_args = i.attrs.iter()
.filter_map(|at| if at.name().equiv(&("link")) {
Some(at)
if n.get().is_empty() {
e.sess.span_err(m.span, "#[link(name = \"\")] given with empty name");
} else {
- cstore.add_used_library(n.get().to_owned(), kind);
+ e.sess.cstore.add_used_library(n.get().to_owned(), kind);
}
}
None => {}
cnum: cnum
};
- let cstore = e.sess.cstore;
- cstore.set_crate_data(cnum, cmeta);
- cstore.add_used_crate_source(cstore::CrateSource {
+ e.sess.cstore.set_crate_data(cnum, cmeta);
+ e.sess.cstore.add_used_crate_source(cstore::CrateSource {
dylib: dylib,
rlib: rlib,
cnum: cnum,
});
- return cnum;
- }
- Some(cnum) => {
- return cnum;
+ cnum
}
+ Some(cnum) => cnum
}
}
}
fn get_exported_macros(&mut self, cnum: ast::CrateNum) -> Vec<~str> {
- csearch::get_exported_macros(self.env.sess.cstore, cnum).move_iter()
- .collect()
+ csearch::get_exported_macros(&self.env.sess.cstore, cnum).move_iter()
+ .collect()
}
fn get_registrar_symbol(&mut self, cnum: ast::CrateNum) -> Option<~str> {
- let cstore = self.env.sess.cstore;
+ let cstore = &self.env.sess.cstore;
csearch::get_macro_registrar_fn(cstore, cnum)
.map(|did| csearch::get_symbol(cstore, did))
}
vis: ast::Visibility,
}
-pub fn get_symbol(cstore: @cstore::CStore, def: ast::DefId) -> ~str {
+pub fn get_symbol(cstore: &cstore::CStore, def: ast::DefId) -> ~str {
let cdata = cstore.get_crate_data(def.krate).data();
return decoder::get_symbol(cdata, def.node);
}
-pub fn get_type_param_count(cstore: @cstore::CStore, def: ast::DefId)
+pub fn get_type_param_count(cstore: &cstore::CStore, def: ast::DefId)
-> uint {
let cdata = cstore.get_crate_data(def.krate).data();
return decoder::get_type_param_count(cdata, def.node);
}
/// Iterates over all the language items in the given crate.
-pub fn each_lang_item(cstore: @cstore::CStore,
+pub fn each_lang_item(cstore: &cstore::CStore,
cnum: ast::CrateNum,
f: |ast::NodeId, uint| -> bool)
-> bool {
}
/// Iterates over each child of the given item.
-pub fn each_child_of_item(cstore: @cstore::CStore,
+pub fn each_child_of_item(cstore: &cstore::CStore,
def_id: ast::DefId,
callback: |decoder::DefLike,
ast::Ident,
}
/// Iterates over each top-level crate item.
-pub fn each_top_level_item_of_crate(cstore: @cstore::CStore,
+pub fn each_top_level_item_of_crate(cstore: &cstore::CStore,
cnum: ast::CrateNum,
callback: |decoder::DefLike,
ast::Ident,
}
pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec<ast_map::PathElem> {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
let path = decoder::get_item_path(cdata, def.node);
pub fn maybe_get_item_ast(tcx: &ty::ctxt, def: ast::DefId,
decode_inlined_item: decoder::DecodeInlinedItem)
-> found_ast {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
decoder::maybe_get_item_ast(cdata, tcx, def.node, decode_inlined_item)
}
pub fn get_enum_variants(tcx: &ty::ctxt, def: ast::DefId)
-> Vec<@ty::VariantInfo> {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
return decoder::get_enum_variants(cstore.intr, cdata, def.node, tcx)
}
/// Returns information about the given implementation.
pub fn get_impl(tcx: &ty::ctxt, impl_def_id: ast::DefId)
-> ty::Impl {
- let cdata = tcx.cstore.get_crate_data(impl_def_id.krate);
- decoder::get_impl(tcx.cstore.intr, cdata, impl_def_id.node, tcx)
+ let cdata = tcx.sess.cstore.get_crate_data(impl_def_id.krate);
+ decoder::get_impl(tcx.sess.cstore.intr, cdata, impl_def_id.node, tcx)
}
pub fn get_method(tcx: &ty::ctxt, def: ast::DefId) -> ty::Method {
- let cdata = tcx.cstore.get_crate_data(def.krate);
- decoder::get_method(tcx.cstore.intr, cdata, def.node, tcx)
+ let cdata = tcx.sess.cstore.get_crate_data(def.krate);
+ decoder::get_method(tcx.sess.cstore.intr, cdata, def.node, tcx)
}
-pub fn get_method_name_and_explicit_self(cstore: @cstore::CStore,
+pub fn get_method_name_and_explicit_self(cstore: &cstore::CStore,
def: ast::DefId)
-> (ast::Ident, ast::ExplicitSelf_)
{
decoder::get_method_name_and_explicit_self(cstore.intr, cdata, def.node)
}
-pub fn get_trait_method_def_ids(cstore: @cstore::CStore,
+pub fn get_trait_method_def_ids(cstore: &cstore::CStore,
def: ast::DefId) -> Vec<ast::DefId> {
let cdata = cstore.get_crate_data(def.krate);
decoder::get_trait_method_def_ids(cdata, def.node)
}
-pub fn get_item_variances(cstore: @cstore::CStore,
+pub fn get_item_variances(cstore: &cstore::CStore,
def: ast::DefId) -> ty::ItemVariances {
let cdata = cstore.get_crate_data(def.krate);
decoder::get_item_variances(cdata, def.node)
pub fn get_provided_trait_methods(tcx: &ty::ctxt,
def: ast::DefId)
-> Vec<@ty::Method> {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
decoder::get_provided_trait_methods(cstore.intr, cdata, def.node, tcx)
}
pub fn get_supertraits(tcx: &ty::ctxt, def: ast::DefId) -> Vec<@ty::TraitRef> {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
decoder::get_supertraits(cdata, def.node, tcx)
}
-pub fn get_type_name_if_impl(cstore: @cstore::CStore, def: ast::DefId)
+pub fn get_type_name_if_impl(cstore: &cstore::CStore, def: ast::DefId)
-> Option<ast::Ident> {
let cdata = cstore.get_crate_data(def.krate);
decoder::get_type_name_if_impl(cdata, def.node)
}
-pub fn get_static_methods_if_impl(cstore: @cstore::CStore,
+pub fn get_static_methods_if_impl(cstore: &cstore::CStore,
def: ast::DefId)
-> Option<Vec<StaticMethodInfo> > {
let cdata = cstore.get_crate_data(def.krate);
decoder::get_static_methods_if_impl(cstore.intr, cdata, def.node)
}
-pub fn get_item_attrs(cstore: @cstore::CStore,
+pub fn get_item_attrs(cstore: &cstore::CStore,
def_id: ast::DefId,
f: |Vec<@ast::MetaItem> |) {
let cdata = cstore.get_crate_data(def_id.krate);
decoder::get_item_attrs(cdata, def_id.node, f)
}
-pub fn get_struct_fields(cstore: @cstore::CStore,
+pub fn get_struct_fields(cstore: &cstore::CStore,
def: ast::DefId)
-> Vec<ty::field_ty> {
let cdata = cstore.get_crate_data(def.krate);
pub fn get_type(tcx: &ty::ctxt,
def: ast::DefId)
-> ty::ty_param_bounds_and_ty {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
decoder::get_type(cdata, def.node, tcx)
}
pub fn get_trait_def(tcx: &ty::ctxt, def: ast::DefId) -> ty::TraitDef {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
decoder::get_trait_def(cdata, def.node, tcx)
}
pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId,
def: ast::DefId) -> ty::ty_param_bounds_and_ty {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(class_id.krate);
let all_items = reader::get_doc(reader::Doc(cdata.data()), tag_items);
let class_doc = expect(tcx.diag,
// if there is one.
pub fn get_impl_trait(tcx: &ty::ctxt,
def: ast::DefId) -> Option<@ty::TraitRef> {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
decoder::get_impl_trait(cdata, def.node, tcx)
}
// Given a def_id for an impl, return information about its vtables
pub fn get_impl_vtables(tcx: &ty::ctxt,
def: ast::DefId) -> typeck::impl_res {
- let cstore = tcx.cstore;
+ let cstore = &tcx.sess.cstore;
let cdata = cstore.get_crate_data(def.krate);
decoder::get_impl_vtables(cdata, def.node, tcx)
}
-pub fn get_impl_method(cstore: @cstore::CStore,
+pub fn get_impl_method(cstore: &cstore::CStore,
def: ast::DefId,
mname: ast::Ident)
-> Option<ast::DefId> {
decoder::get_impl_method(cstore.intr, cdata, def.node, mname)
}
-pub fn get_item_visibility(cstore: @cstore::CStore,
+pub fn get_item_visibility(cstore: &cstore::CStore,
def_id: ast::DefId)
-> ast::Visibility {
let cdata = cstore.get_crate_data(def_id.krate);
decoder::get_item_visibility(cdata, def_id.node)
}
-pub fn get_native_libraries(cstore: @cstore::CStore,
+pub fn get_native_libraries(cstore: &cstore::CStore,
crate_num: ast::CrateNum)
-> Vec<(cstore::NativeLibaryKind, ~str)> {
let cdata = cstore.get_crate_data(crate_num);
decoder::get_native_libraries(cdata)
}
-pub fn each_impl(cstore: @cstore::CStore,
+pub fn each_impl(cstore: &cstore::CStore,
crate_num: ast::CrateNum,
callback: |ast::DefId|) {
let cdata = cstore.get_crate_data(crate_num);
decoder::each_impl(cdata, callback)
}
-pub fn each_implementation_for_type(cstore: @cstore::CStore,
+pub fn each_implementation_for_type(cstore: &cstore::CStore,
def_id: ast::DefId,
callback: |ast::DefId|) {
let cdata = cstore.get_crate_data(def_id.krate);
decoder::each_implementation_for_type(cdata, def_id.node, callback)
}
-pub fn each_implementation_for_trait(cstore: @cstore::CStore,
+pub fn each_implementation_for_trait(cstore: &cstore::CStore,
def_id: ast::DefId,
callback: |ast::DefId|) {
let cdata = cstore.get_crate_data(def_id.krate);
/// If the given def ID describes a method belonging to a trait (either a
/// default method or an implementation of a trait method), returns the ID of
/// the trait that the method belongs to. Otherwise, returns `None`.
-pub fn get_trait_of_method(cstore: @cstore::CStore,
+pub fn get_trait_of_method(cstore: &cstore::CStore,
def_id: ast::DefId,
tcx: &ty::ctxt)
-> Option<ast::DefId> {
decoder::get_trait_of_method(cdata, def_id.node, tcx)
}
-pub fn get_macro_registrar_fn(cstore: @cstore::CStore,
+pub fn get_macro_registrar_fn(cstore: &cstore::CStore,
crate_num: ast::CrateNum)
-> Option<ast::DefId> {
let cdata = cstore.get_crate_data(crate_num);
decoder::get_macro_registrar_fn(cdata)
}
-pub fn get_exported_macros(cstore: @cstore::CStore,
+pub fn get_exported_macros(cstore: &cstore::CStore,
crate_num: ast::CrateNum)
-> Vec<~str> {
let cdata = cstore.get_crate_data(crate_num);
item_symbols: &'a RefCell<NodeMap<~str>>,
non_inlineable_statics: &'a RefCell<NodeSet>,
link_meta: &'a LinkMeta,
- cstore: @cstore::CStore,
+ cstore: &'a cstore::CStore,
encode_inlined_item: EncodeInlinedItem<'a>,
}
}
pub fn collect_external_language_items(&mut self) {
- let crate_store = self.session.cstore;
+ let crate_store = &self.session.cstore;
crate_store.iter_crate_data(|crate_number, _crate_metadata| {
each_lang_item(crate_store, crate_number, |node_id, item_index| {
let def_id = ast::DefId { krate: crate_number, node: node_id };
_ => {}
}
} else {
- csearch::get_item_attrs(cx.tcx.sess.cstore, did, |attrs| {
+ csearch::get_item_attrs(&cx.tcx.sess.cstore, did, |attrs| {
if attr::contains_name(attrs.as_slice(), "must_use") {
cx.span_lint(UnusedMustUse, s.span,
"unused result which must be used");
let mut s = None;
// run through all the attributes and take the first
// stability one.
- csearch::get_item_attrs(cx.tcx.cstore, id, |meta_items| {
+ csearch::get_item_attrs(&cx.tcx.sess.cstore, id, |meta_items| {
if s.is_none() {
s = attr::find_stability(meta_items.move_iter())
}
}
}
} else {
- let cstore = self.tcx.sess.cstore;
+ let cstore = &self.tcx.sess.cstore;
match enum_id {
Some(enum_id) => {
let v = csearch::get_enum_variants(self.tcx, enum_id);
// to the trait info.
let method_def_ids =
- csearch::get_trait_method_def_ids(self.session.cstore, def_id);
+ csearch::get_trait_method_def_ids(&self.session.cstore, def_id);
let mut interned_method_names = HashSet::new();
for &method_def_id in method_def_ids.iter() {
let (method_name, explicit_self) =
- csearch::get_method_name_and_explicit_self(self.session.cstore,
+ csearch::get_method_name_and_explicit_self(&self.session.cstore,
method_def_id);
debug!("(building reduced graph for \
crate) building type and value for {}",
final_ident);
child_name_bindings.define_type(def, DUMMY_SP, is_public);
- if csearch::get_struct_fields(self.session.cstore, def_id).len() == 0 {
+ if csearch::get_struct_fields(&self.session.cstore, def_id).len() == 0 {
child_name_bindings.define_value(def, DUMMY_SP, is_public);
}
self.structs.insert(def_id);
DefForeignMod(def_id) => {
// Foreign modules have no names. Recur and populate
// eagerly.
- csearch::each_child_of_item(self.session.cstore,
+ csearch::each_child_of_item(&self.session.cstore,
def_id,
|def_like,
child_ident,
}
DlImpl(def) => {
// We only process static methods of impls here.
- match csearch::get_type_name_if_impl(self.session.cstore, def) {
+ match csearch::get_type_name_if_impl(&self.session.cstore, def) {
None => {}
Some(final_ident) => {
let static_methods_opt =
- csearch::get_static_methods_if_impl(self.session.cstore, def);
+ csearch::get_static_methods_if_impl(&self.session.cstore, def);
match static_methods_opt {
Some(ref static_methods) if
static_methods.len() >= 1 => {
Some(def_id) => def_id,
};
- csearch::each_child_of_item(self.session.cstore,
+ csearch::each_child_of_item(&self.session.cstore,
def_id,
|def_like, child_ident, visibility| {
debug!("(populating external module) ... found ident: {}",
/// crate.
fn build_reduced_graph_for_external_crate(&mut self,
root: @Module) {
- csearch::each_top_level_item_of_crate(self.session.cstore,
+ csearch::each_top_level_item_of_crate(&self.session.cstore,
root.def_id
.get()
.unwrap()
}
let f = decl_rust_fn(ccx, false, inputs, output, name);
- csearch::get_item_attrs(ccx.tcx.cstore, did, |meta_items| {
+ csearch::get_item_attrs(&ccx.sess().cstore, did, |meta_items| {
set_llvm_fn_attrs(meta_items.iter().map(|&x| attr::mk_attr(x)).to_owned_vec(), f)
});
get_item_val(ccx, did.node)
} else {
let tcx = ccx.tcx;
- let name = csearch::get_symbol(ccx.sess().cstore, did);
+ let name = csearch::get_symbol(&ccx.sess().cstore, did);
let class_ty = ty::subst_tps(tcx,
substs,
None,
}
pub fn trans_external_path(ccx: &CrateContext, did: ast::DefId, t: ty::t) -> ValueRef {
- let name = csearch::get_symbol(ccx.sess().cstore, did);
+ let name = csearch::get_symbol(&ccx.sess().cstore, did);
match ty::get(t).sty {
ty::ty_bare_fn(ref fn_ty) => {
match fn_ty.abis.for_target(ccx.sess().targ_cfg.os,
match external_srcs.get().find(&i.id) {
Some(&did) => {
debug!("but found in other crate...");
- (csearch::get_symbol(ccx.sess().cstore,
+ (csearch::get_symbol(&ccx.sess().cstore,
did), false)
}
None => (sym, true)
let targ_cfg = sess.targ_cfg;
let int_type = Type::int(targ_cfg.arch);
let mut n_subcrates = 1;
- let cstore = sess.cstore;
+ let cstore = &sess.cstore;
while cstore.have_crate_data(n_subcrates) { n_subcrates += 1; }
let is_top = !sess.building_library.get() || sess.opts.cg.gen_crate_map;
let sym_name = if is_top {
llvm::LLVMConstPointerCast(get_item_val(ccx, did.node),
ccx.int_type.ptr_to().to_ref())
} else {
- let name = csearch::get_symbol(ccx.sess().cstore, did);
+ let name = csearch::get_symbol(&ccx.sess().cstore, did);
let global = name.with_c_str(|buf| {
llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type.to_ref(), buf)
});
item_symbols: item_symbols,
non_inlineable_statics: &cx.non_inlineable_statics,
link_meta: link_meta,
- cstore: cx.sess().cstore,
+ cstore: &cx.sess().cstore,
encode_inlined_item: ie,
}
}
unsafe {
let llty = type_of::type_of(bcx.ccx(), const_ty);
let symbol = csearch::get_symbol(
- bcx.ccx().sess().cstore,
+ &bcx.ccx().sess().cstore,
did);
let llval = symbol.with_c_str(|buf| {
llvm::LLVMAddGlobal(bcx.ccx().llmod,
use back::svh::Svh;
use driver::session::Session;
use metadata::csearch;
-use metadata;
use middle::const_eval;
use middle::lang_items::{ExchangeHeapLangItem, OpaqueStructLangItem};
use middle::lang_items::{TyDescStructLangItem, TyVisitorTraitLangItem};
// quite often.
interner: RefCell<FnvHashMap<intern_key, ~t_box_>>,
next_id: Cell<uint>,
- cstore: @metadata::cstore::CStore,
sess: Session,
def_map: resolve::DefMap,
diag: s.diagnostic(),
interner: RefCell::new(FnvHashMap::new()),
next_id: Cell::new(primitives::LAST_PRIMITIVE_ID),
- cstore: s.cstore,
sess: s,
def_map: dm,
region_maps: region_maps,
id,
trait_method_def_ids.get(),
|| {
- @csearch::get_trait_method_def_ids(cx.cstore, id)
+ @csearch::get_trait_method_def_ids(&cx.sess.cstore, id)
})
}
item.attrs.iter().advance(|attr| f(attr.node.value))
} else {
let mut cont = true;
- csearch::get_item_attrs(tcx.cstore, did, |meta_items| {
+ csearch::get_item_attrs(&tcx.sess.cstore, did, |meta_items| {
if cont {
cont = meta_items.iter().advance(|ptrptr| f(*ptrptr));
}
// Look up the list of field names and IDs for a given struct
// Fails if the id is not bound to a struct.
pub fn lookup_struct_fields(cx: &ctxt, did: ast::DefId) -> Vec<field_ty> {
- if did.krate == ast::LOCAL_CRATE {
- {
- match cx.map.find(did.node) {
- Some(ast_map::NodeItem(i)) => {
- match i.node {
- ast::ItemStruct(struct_def, _) => {
- struct_field_tys(struct_def.fields.as_slice())
- }
- _ => cx.sess.bug("struct ID bound to non-struct")
- }
- }
- Some(ast_map::NodeVariant(ref variant)) => {
- match (*variant).node.kind {
- ast::StructVariantKind(struct_def) => {
- struct_field_tys(struct_def.fields.as_slice())
+ if did.krate == ast::LOCAL_CRATE {
+ match cx.map.find(did.node) {
+ Some(ast_map::NodeItem(i)) => {
+ match i.node {
+ ast::ItemStruct(struct_def, _) => {
+ struct_field_tys(struct_def.fields.as_slice())
+ }
+ _ => cx.sess.bug("struct ID bound to non-struct")
}
- _ => {
- cx.sess.bug("struct ID bound to enum variant that isn't \
- struct-like")
+ }
+ Some(ast_map::NodeVariant(ref variant)) => {
+ match (*variant).node.kind {
+ ast::StructVariantKind(struct_def) => {
+ struct_field_tys(struct_def.fields.as_slice())
+ }
+ _ => {
+ cx.sess.bug("struct ID bound to enum variant that \
+ isn't struct-like")
+ }
}
- }
- }
- _ => {
- cx.sess.bug(
- format!("struct ID not bound to an item: {}",
+ }
+ _ => {
+ cx.sess.bug(
+ format!("struct ID not bound to an item: {}",
cx.map.node_to_str(did.node)));
- }
- }
- }
- } else {
- return csearch::get_struct_fields(cx.sess.cstore, did);
- }
+ }
+ }
+ } else {
+ csearch::get_struct_fields(&cx.sess.cstore, did)
+ }
}
pub fn lookup_struct_field(cx: &ctxt,
let mut item_variance_map = tcx.item_variance_map.borrow_mut();
lookup_locally_or_in_crate_store(
"item_variance_map", item_id, item_variance_map.get(),
- || @csearch::get_item_variances(tcx.cstore, item_id))
+ || @csearch::get_item_variances(&tcx.sess.cstore, item_id))
}
/// Records a trait-to-implementation mapping.
}
}
- csearch::each_implementation_for_type(tcx.sess.cstore, type_id,
+ csearch::each_implementation_for_type(&tcx.sess.cstore, type_id,
|implementation_def_id| {
let implementation = @csearch::get_impl(tcx, implementation_def_id);
}
}
- csearch::each_implementation_for_trait(tcx.sess.cstore, trait_id,
+ csearch::each_implementation_for_trait(&tcx.sess.cstore, trait_id,
|implementation_def_id| {
let implementation = @csearch::get_impl(tcx, implementation_def_id);
pub fn trait_of_method(tcx: &ctxt, def_id: ast::DefId)
-> Option<ast::DefId> {
if def_id.krate != LOCAL_CRATE {
- return csearch::get_trait_of_method(tcx.cstore, def_id, tcx);
+ return csearch::get_trait_of_method(&tcx.sess.cstore, def_id, tcx);
}
let method;
{
session.span_note(self.span_of_impl(implementation_b),
"note conflicting implementation here");
} else {
- let crate_store = self.crate_context.tcx.sess.cstore;
+ let crate_store = &self.crate_context.tcx.sess.cstore;
let cdata = crate_store.get_crate_data(implementation_b.did.krate);
session.note(
"conflicting implementation in crate `" + cdata.name + "`");
return;
}
- let crate_store = self.crate_context.tcx.sess.cstore;
+ let crate_store = &self.crate_context.tcx.sess.cstore;
csearch::each_implementation_for_trait(crate_store, trait_def_id, |impl_def_id| {
let implementation = @csearch::get_impl(self.crate_context.tcx, impl_def_id);
let _ = lookup_item_type(self.crate_context.tcx, implementation.did);
fn add_external_crates(&self) {
let mut impls_seen = HashSet::new();
- let crate_store = self.crate_context.tcx.sess.cstore;
+ let crate_store = &self.crate_context.tcx.sess.cstore;
crate_store.iter_crate_data(|crate_number, _crate_metadata| {
each_impl(crate_store, crate_number, |def_id| {
assert_eq!(crate_number, def_id.krate);
projects / rust.git / commitdiff