From 075ab306505ccaaf350a70a56130b45bab6f2a21 Mon Sep 17 00:00:00 2001 From: Eduard Burtescu Date: Thu, 17 Apr 2014 15:06:25 +0300 Subject: [PATCH] rustc: de-@ metadata::cstore. --- src/librustc/metadata/creader.rs | 12 +++--- src/librustc/metadata/csearch.rs | 64 ++++++++++++++++---------------- src/librustc/metadata/cstore.rs | 14 +++---- src/librustc/metadata/decoder.rs | 34 +++++++++++------ src/librustc/middle/astencode.rs | 32 ++++++++-------- 5 files changed, 83 insertions(+), 73 deletions(-) diff --git a/src/librustc/metadata/creader.rs b/src/librustc/metadata/creader.rs index a43c6ac594b..efbfce1b2bb 100644 --- a/src/librustc/metadata/creader.rs +++ b/src/librustc/metadata/creader.rs @@ -279,7 +279,7 @@ fn resolve_crate<'a>(e: &mut Env, hash: Option<&Svh>, should_link: bool, span: Span) - -> (ast::CrateNum, @cstore::crate_metadata, + -> (ast::CrateNum, Rc, cstore::CrateSource) { match existing_match(e, crate_id, hash) { None => { @@ -330,13 +330,13 @@ fn resolve_crate<'a>(e: &mut Env, -1 }; - let cmeta = @cstore::crate_metadata { + let cmeta = Rc::new(cstore::crate_metadata { name: load_ctxt.crate_id.name.to_owned(), data: metadata, cnum_map: cnum_map, cnum: cnum, span: span, - }; + }); let source = cstore::CrateSource { dylib: dylib, @@ -345,7 +345,7 @@ fn resolve_crate<'a>(e: &mut Env, }; if should_link { - e.sess.cstore.set_crate_data(cnum, cmeta); + e.sess.cstore.set_crate_data(cnum, cmeta.clone()); e.sess.cstore.add_used_crate_source(source.clone()); } (cnum, cmeta, source) @@ -402,8 +402,8 @@ impl<'a> CrateLoader for Loader<'a> { info.ident, &info.crate_id, None, info.should_link, krate.span); - let macros = decoder::get_exported_macros(data); - let registrar = decoder::get_macro_registrar_fn(data).map(|id| { + let macros = decoder::get_exported_macros(&*data); + let registrar = decoder::get_macro_registrar_fn(&*data).map(|id| { decoder::get_symbol(data.data.as_slice(), id) }); MacroCrate { diff --git a/src/librustc/metadata/csearch.rs b/src/librustc/metadata/csearch.rs index f02f9c61582..61caa0cf499 100644 --- a/src/librustc/metadata/csearch.rs +++ b/src/librustc/metadata/csearch.rs @@ -33,8 +33,8 @@ pub struct StaticMethodInfo { } 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); + let cdata = cstore.get_crate_data(def.krate); + decoder::get_symbol(cdata.data(), def.node) } /// Iterates over all the language items in the given crate. @@ -43,7 +43,7 @@ pub fn each_lang_item(cstore: &cstore::CStore, f: |ast::NodeId, uint| -> bool) -> bool { let crate_data = cstore.get_crate_data(cnum); - decoder::each_lang_item(crate_data, f) + decoder::each_lang_item(&*crate_data, f) } /// Iterates over each child of the given item. @@ -57,7 +57,7 @@ pub fn each_child_of_item(cstore: &cstore::CStore, cstore.get_crate_data(cnum) }; decoder::each_child_of_item(cstore.intr.clone(), - crate_data, + &*crate_data, def_id.node, get_crate_data, callback) @@ -74,7 +74,7 @@ pub fn each_top_level_item_of_crate(cstore: &cstore::CStore, cstore.get_crate_data(cnum) }; decoder::each_top_level_item_of_crate(cstore.intr.clone(), - crate_data, + &*crate_data, get_crate_data, callback) } @@ -82,7 +82,7 @@ pub fn each_top_level_item_of_crate(cstore: &cstore::CStore, pub fn get_item_path(tcx: &ty::ctxt, def: ast::DefId) -> Vec { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - let path = decoder::get_item_path(cdata, def.node); + let path = decoder::get_item_path(&*cdata, def.node); // FIXME #1920: This path is not always correct if the crate is not linked // into the root namespace. @@ -103,26 +103,26 @@ pub fn maybe_get_item_ast(tcx: &ty::ctxt, def: ast::DefId, -> found_ast { 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) + 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.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - return decoder::get_enum_variants(cstore.intr.clone(), cdata, def.node, tcx) + return decoder::get_enum_variants(cstore.intr.clone(), &*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.sess.cstore.get_crate_data(impl_def_id.krate); - decoder::get_impl(tcx.sess.cstore.intr.clone(), cdata, impl_def_id.node, tcx) + decoder::get_impl(tcx.sess.cstore.intr.clone(), &*cdata, impl_def_id.node, tcx) } pub fn get_method(tcx: &ty::ctxt, def: ast::DefId) -> ty::Method { let cdata = tcx.sess.cstore.get_crate_data(def.krate); - decoder::get_method(tcx.sess.cstore.intr.clone(), cdata, def.node, tcx) + decoder::get_method(tcx.sess.cstore.intr.clone(), &*cdata, def.node, tcx) } pub fn get_method_name_and_explicit_self(cstore: &cstore::CStore, @@ -130,19 +130,19 @@ pub fn get_method_name_and_explicit_self(cstore: &cstore::CStore, -> (ast::Ident, ast::ExplicitSelf_) { let cdata = cstore.get_crate_data(def.krate); - decoder::get_method_name_and_explicit_self(cstore.intr.clone(), cdata, def.node) + decoder::get_method_name_and_explicit_self(cstore.intr.clone(), &*cdata, def.node) } pub fn get_trait_method_def_ids(cstore: &cstore::CStore, def: ast::DefId) -> Vec { let cdata = cstore.get_crate_data(def.krate); - decoder::get_trait_method_def_ids(cdata, def.node) + decoder::get_trait_method_def_ids(&*cdata, def.node) } 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) + decoder::get_item_variances(&*cdata, def.node) } pub fn get_provided_trait_methods(tcx: &ty::ctxt, @@ -150,40 +150,40 @@ pub fn get_provided_trait_methods(tcx: &ty::ctxt, -> Vec<@ty::Method> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_provided_trait_methods(cstore.intr.clone(), cdata, def.node, tcx) + decoder::get_provided_trait_methods(cstore.intr.clone(), &*cdata, def.node, tcx) } pub fn get_supertraits(tcx: &ty::ctxt, def: ast::DefId) -> Vec<@ty::TraitRef> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_supertraits(cdata, def.node, tcx) + decoder::get_supertraits(&*cdata, def.node, tcx) } pub fn get_type_name_if_impl(cstore: &cstore::CStore, def: ast::DefId) -> Option { let cdata = cstore.get_crate_data(def.krate); - decoder::get_type_name_if_impl(cdata, def.node) + decoder::get_type_name_if_impl(&*cdata, def.node) } pub fn get_static_methods_if_impl(cstore: &cstore::CStore, def: ast::DefId) -> Option > { let cdata = cstore.get_crate_data(def.krate); - decoder::get_static_methods_if_impl(cstore.intr.clone(), cdata, def.node) + decoder::get_static_methods_if_impl(cstore.intr.clone(), &*cdata, def.node) } 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) + decoder::get_item_attrs(&*cdata, def_id.node, f) } pub fn get_struct_fields(cstore: &cstore::CStore, def: ast::DefId) -> Vec { let cdata = cstore.get_crate_data(def.krate); - decoder::get_struct_fields(cstore.intr.clone(), cdata, def.node) + decoder::get_struct_fields(cstore.intr.clone(), &*cdata, def.node) } pub fn get_type(tcx: &ty::ctxt, @@ -191,13 +191,13 @@ pub fn get_type(tcx: &ty::ctxt, -> ty::ty_param_bounds_and_ty { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_type(cdata, def.node, tcx) + decoder::get_type(&*cdata, def.node, tcx) } pub fn get_trait_def(tcx: &ty::ctxt, def: ast::DefId) -> ty::TraitDef { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_trait_def(cdata, def.node, tcx) + decoder::get_trait_def(&*cdata, def.node, tcx) } pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId, @@ -213,7 +213,7 @@ pub fn get_field_type(tcx: &ty::ctxt, class_id: ast::DefId, decoder::maybe_find_item(def.node, class_doc), || format!("get_field_type: in class {:?}, field ID {:?} not found", class_id, def) ); - let ty = decoder::item_type(def, the_field, tcx, cdata); + let ty = decoder::item_type(def, the_field, tcx, &*cdata); ty::ty_param_bounds_and_ty { generics: ty::Generics {type_param_defs: Rc::new(Vec::new()), region_param_defs: Rc::new(Vec::new())}, @@ -227,7 +227,7 @@ pub fn get_impl_trait(tcx: &ty::ctxt, def: ast::DefId) -> Option<@ty::TraitRef> { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_impl_trait(cdata, def.node, tcx) + decoder::get_impl_trait(&*cdata, def.node, tcx) } // Given a def_id for an impl, return information about its vtables @@ -235,35 +235,35 @@ pub fn get_impl_vtables(tcx: &ty::ctxt, def: ast::DefId) -> typeck::impl_res { let cstore = &tcx.sess.cstore; let cdata = cstore.get_crate_data(def.krate); - decoder::get_impl_vtables(cdata, def.node, tcx) + decoder::get_impl_vtables(&*cdata, def.node, tcx) } 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) + decoder::get_native_libraries(&*cdata) } 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) + decoder::each_impl(&*cdata, callback) } 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) + decoder::each_implementation_for_type(&*cdata, def_id.node, callback) } 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); - decoder::each_implementation_for_trait(cdata, def_id.node, callback) + decoder::each_implementation_for_trait(&*cdata, def_id.node, callback) } /// If the given def ID describes a method belonging to a trait (either a @@ -274,21 +274,21 @@ pub fn get_trait_of_method(cstore: &cstore::CStore, tcx: &ty::ctxt) -> Option { let cdata = cstore.get_crate_data(def_id.krate); - decoder::get_trait_of_method(cdata, def_id.node, tcx) + decoder::get_trait_of_method(&*cdata, def_id.node, tcx) } pub fn get_macro_registrar_fn(cstore: &cstore::CStore, crate_num: ast::CrateNum) -> Option { let cdata = cstore.get_crate_data(crate_num); - decoder::get_macro_registrar_fn(cdata) + decoder::get_macro_registrar_fn(&*cdata) } pub fn get_exported_macros(cstore: &cstore::CStore, crate_num: ast::CrateNum) -> Vec<~str> { let cdata = cstore.get_crate_data(crate_num); - decoder::get_exported_macros(cdata) + decoder::get_exported_macros(&*cdata) } pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore, @@ -296,5 +296,5 @@ pub fn get_tuple_struct_definition_if_ctor(cstore: &cstore::CStore, -> Option { let cdata = cstore.get_crate_data(def_id.krate); - decoder::get_tuple_struct_definition_if_ctor(cdata, def_id.node) + decoder::get_tuple_struct_definition_if_ctor(&*cdata, def_id.node) } diff --git a/src/librustc/metadata/cstore.rs b/src/librustc/metadata/cstore.rs index 537f3cf206d..8e731a98dd7 100644 --- a/src/librustc/metadata/cstore.rs +++ b/src/librustc/metadata/cstore.rs @@ -68,7 +68,7 @@ pub struct CrateSource { } pub struct CStore { - metas: RefCell>, + metas: RefCell>>, extern_mod_crate_map: RefCell, used_crate_sources: RefCell>, used_libraries: RefCell>, @@ -95,8 +95,8 @@ impl CStore { self.metas.borrow().len() as ast::CrateNum + 1 } - pub fn get_crate_data(&self, cnum: ast::CrateNum) -> @crate_metadata { - *self.metas.borrow().get(&cnum) + pub fn get_crate_data(&self, cnum: ast::CrateNum) -> Rc { + self.metas.borrow().get(&cnum).clone() } pub fn get_crate_hash(&self, cnum: ast::CrateNum) -> Svh { @@ -104,13 +104,13 @@ impl CStore { decoder::get_crate_hash(cdata.data()) } - pub fn set_crate_data(&self, cnum: ast::CrateNum, data: @crate_metadata) { + pub fn set_crate_data(&self, cnum: ast::CrateNum, data: Rc) { self.metas.borrow_mut().insert(cnum, data); } - pub fn iter_crate_data(&self, i: |ast::CrateNum, @crate_metadata|) { - for (&k, &v) in self.metas.borrow().iter() { - i(k, v); + pub fn iter_crate_data(&self, i: |ast::CrateNum, &crate_metadata|) { + for (&k, v) in self.metas.borrow().iter() { + i(k, &**v); } } diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index a83ef1f5a9f..9751ca3615f 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -45,7 +45,7 @@ use syntax::ast; use syntax::codemap; use syntax::crateid::CrateId; -pub type Cmd = @crate_metadata; +pub type Cmd<'a> = &'a crate_metadata; // A function that takes a def_id relative to the crate being searched and // returns a def_id relative to the compilation environment, i.e. if we hit a @@ -76,8 +76,6 @@ fn lookup_hash<'a>(d: ebml::Doc<'a>, eq_fn: |&[u8]| -> bool, ret } -pub type GetCrateDataCb<'a> = |ast::CrateNum|: 'a -> Cmd; - pub fn maybe_find_item<'a>(item_id: ast::NodeId, items: ebml::Doc<'a>) -> Option> { fn eq_item(bytes: &[u8], item_id: ast::NodeId) -> bool { @@ -462,6 +460,8 @@ pub fn each_lang_item(cdata: Cmd, f: |ast::NodeId, uint| -> bool) -> bool { }) } +pub type GetCrateDataCb<'a> = |ast::CrateNum|: 'a -> Rc; + fn each_child_of_item_or_crate(intr: Rc, cdata: Cmd, item_doc: ebml::Doc, @@ -477,12 +477,17 @@ fn each_child_of_item_or_crate(intr: Rc, // This item may be in yet another crate if it was the child of a // reexport. - let other_crates_items = if child_def_id.krate == cdata.cnum { - reader::get_doc(reader::Doc(cdata.data()), tag_items) + let crate_data = if child_def_id.krate == cdata.cnum { + None } else { - let crate_data = get_crate_data(child_def_id.krate); - reader::get_doc(reader::Doc(crate_data.data()), tag_items) + Some(get_crate_data(child_def_id.krate)) }; + let crate_data = match crate_data { + Some(ref cdata) => &**cdata, + None => cdata + }; + + let other_crates_items = reader::get_doc(reader::Doc(crate_data.data()), tag_items); // Get the item. match maybe_find_item(child_def_id.node, other_crates_items) { @@ -565,12 +570,17 @@ fn each_child_of_item_or_crate(intr: Rc, let name = name_doc.as_str_slice(); // This reexport may be in yet another crate. - let other_crates_items = if child_def_id.krate == cdata.cnum { - reader::get_doc(reader::Doc(cdata.data()), tag_items) + let crate_data = if child_def_id.krate == cdata.cnum { + None } else { - let crate_data = get_crate_data(child_def_id.krate); - reader::get_doc(reader::Doc(crate_data.data()), tag_items) + Some(get_crate_data(child_def_id.krate)) }; + let crate_data = match crate_data { + Some(ref cdata) => &**cdata, + None => cdata + }; + + let other_crates_items = reader::get_doc(reader::Doc(crate_data.data()), tag_items); // Get the item. match maybe_find_item(child_def_id.node, other_crates_items) { @@ -634,7 +644,7 @@ pub fn get_item_path(cdata: Cmd, id: ast::NodeId) -> Vec { item_path(lookup_item(id, cdata.data())) } -pub type DecodeInlinedItem<'a> = |cdata: @cstore::crate_metadata, +pub type DecodeInlinedItem<'a> = |cdata: Cmd, tcx: &ty::ctxt, path: Vec, par_doc: ebml::Doc|: 'a diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index ef33d984d16..08133a8b69e 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -59,7 +59,7 @@ pub struct Maps { } struct DecodeContext<'a> { - cdata: @cstore::crate_metadata, + cdata: &'a cstore::crate_metadata, tcx: &'a ty::ctxt, maps: &'a Maps } @@ -110,7 +110,7 @@ pub fn encode_inlined_item(ecx: &e::EncodeContext, ebml_w.writer.tell()); } -pub fn decode_inlined_item(cdata: @cstore::crate_metadata, +pub fn decode_inlined_item(cdata: &cstore::crate_metadata, tcx: &ty::ctxt, maps: &Maps, path: Vec, @@ -271,7 +271,7 @@ impl, E> def_id_encoder_helpers for S { trait def_id_decoder_helpers { fn read_def_id(&mut self, xcx: &ExtendedDecodeContext) -> ast::DefId; fn read_def_id_noxcx(&mut self, - cdata: @cstore::crate_metadata) -> ast::DefId; + cdata: &cstore::crate_metadata) -> ast::DefId; } impl, E> def_id_decoder_helpers for D { @@ -281,7 +281,7 @@ impl, E> def_id_decoder_helpers for D { } fn read_def_id_noxcx(&mut self, - cdata: @cstore::crate_metadata) -> ast::DefId { + cdata: &cstore::crate_metadata) -> ast::DefId { let did: ast::DefId = Decodable::decode(self).ok().unwrap(); decoder::translate_def_id(cdata, did) } @@ -725,23 +725,23 @@ pub fn encode_vtable_origin(ecx: &e::EncodeContext, pub trait vtable_decoder_helpers { fn read_vtable_res_with_key(&mut self, tcx: &ty::ctxt, - cdata: @cstore::crate_metadata) + cdata: &cstore::crate_metadata) -> (u32, typeck::vtable_res); fn read_vtable_res(&mut self, - tcx: &ty::ctxt, cdata: @cstore::crate_metadata) + tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> typeck::vtable_res; fn read_vtable_param_res(&mut self, - tcx: &ty::ctxt, cdata: @cstore::crate_metadata) + tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> typeck::vtable_param_res; fn read_vtable_origin(&mut self, - tcx: &ty::ctxt, cdata: @cstore::crate_metadata) + tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> typeck::vtable_origin; } impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { fn read_vtable_res_with_key(&mut self, tcx: &ty::ctxt, - cdata: @cstore::crate_metadata) + cdata: &cstore::crate_metadata) -> (u32, typeck::vtable_res) { self.read_struct("VtableWithKey", 2, |this| { let autoderef = this.read_struct_field("autoderef", 0, |this| { @@ -754,21 +754,21 @@ impl<'a> vtable_decoder_helpers for reader::Decoder<'a> { } fn read_vtable_res(&mut self, - tcx: &ty::ctxt, cdata: @cstore::crate_metadata) + tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> typeck::vtable_res { self.read_to_vec(|this| Ok(this.read_vtable_param_res(tcx, cdata))) .unwrap().move_iter().collect() } fn read_vtable_param_res(&mut self, - tcx: &ty::ctxt, cdata: @cstore::crate_metadata) + tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> typeck::vtable_param_res { self.read_to_vec(|this| Ok(this.read_vtable_origin(tcx, cdata))) .unwrap().move_iter().collect() } fn read_vtable_origin(&mut self, - tcx: &ty::ctxt, cdata: @cstore::crate_metadata) + tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> typeck::vtable_origin { self.read_enum("vtable_origin", |this| { this.read_enum_variant(["vtable_static", @@ -1140,15 +1140,15 @@ trait ebml_decoder_decoder_helpers { // Versions of the type reading functions that don't need the full // ExtendedDecodeContext. fn read_ty_noxcx(&mut self, - tcx: &ty::ctxt, cdata: @cstore::crate_metadata) -> ty::t; + tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> ty::t; fn read_tys_noxcx(&mut self, tcx: &ty::ctxt, - cdata: @cstore::crate_metadata) -> Vec; + cdata: &cstore::crate_metadata) -> Vec; } impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> { fn read_ty_noxcx(&mut self, - tcx: &ty::ctxt, cdata: @cstore::crate_metadata) -> ty::t { + tcx: &ty::ctxt, cdata: &cstore::crate_metadata) -> ty::t { self.read_opaque(|_, doc| { Ok(tydecode::parse_ty_data( doc.data, @@ -1161,7 +1161,7 @@ impl<'a> ebml_decoder_decoder_helpers for reader::Decoder<'a> { fn read_tys_noxcx(&mut self, tcx: &ty::ctxt, - cdata: @cstore::crate_metadata) -> Vec { + cdata: &cstore::crate_metadata) -> Vec { self.read_to_vec(|this| Ok(this.read_ty_noxcx(tcx, cdata)) ) .unwrap() .move_iter()