From eae41d3078562aef1cd4fc8a26f859c168ca4c4a Mon Sep 17 00:00:00 2001 From: Ariel Ben-Yehuda Date: Fri, 2 Oct 2015 16:44:26 +0300 Subject: [PATCH] unify the 2 impl indexes --- src/librustc/metadata/common.rs | 20 +++------ src/librustc/metadata/decoder.rs | 19 +++----- src/librustc/metadata/encoder.rs | 74 +++++++++++--------------------- src/librustc/middle/astencode.rs | 2 +- 4 files changed, 39 insertions(+), 76 deletions(-) diff --git a/src/librustc/metadata/common.rs b/src/librustc/metadata/common.rs index 85d589242426..a4fee5b7aa80 100644 --- a/src/librustc/metadata/common.rs +++ b/src/librustc/metadata/common.rs @@ -133,8 +133,7 @@ enum_from_u32! { tag_table_method_map = 0x5f, // GAP 0x60 tag_table_adjustments = 0x61, - // GAP 0x62, 0x63 - // GAP 0x64, 0x65 + // GAP 0x62, 0x63, 0x64, 0x65 tag_table_upvar_capture_map = 0x66, // GAP 0x67, 0x68 tag_table_const_qualif = 0x69, @@ -163,22 +162,17 @@ pub const tag_lang_items_missing: usize = 0x76; pub const tag_item_unnamed_field: usize = 0x77; pub const tag_items_data_item_visibility: usize = 0x78; - -// GAP 0x79, 0x7a - +pub const tag_items_data_item_inherent_impl: usize = 0x79; +// GAP 0x7a pub const tag_mod_child: usize = 0x7b; pub const tag_misc_info: usize = 0x108; // top-level only pub const tag_misc_info_crate_items: usize = 0x7c; -// GAP 0x7d -// GAP 0x7e - pub const tag_impls: usize = 0x109; // top-level only -pub const tag_impls_impl: usize = 0x7f; -pub const tag_impls_impl_trait_def_id: usize = 0x8d; +pub const tag_impls_trait: usize = 0x7d; +pub const tag_impls_trait_impl: usize = 0x7e; -pub const tag_items_data_item_inherent_impl: usize = 0x80; -pub const tag_items_data_item_extension_impl: usize = 0x81; +// GAP 0x7f, 0x80, 0x81 pub const tag_native_libraries: usize = 0x10a; // top-level only pub const tag_native_libraries_lib: usize = 0x82; @@ -208,7 +202,7 @@ pub const tag_struct_field: usize = 0x8a; pub const tag_items_data_item_struct_ctor: usize = 0x8b; pub const tag_attribute_is_sugared_doc: usize = 0x8c; - +// GAP 0x8d pub const tag_items_data_region: usize = 0x8e; pub const tag_region_param_def: usize = 0x8f; diff --git a/src/librustc/metadata/decoder.rs b/src/librustc/metadata/decoder.rs index 28d801bb8c98..8eea5b3553ad 100644 --- a/src/librustc/metadata/decoder.rs +++ b/src/librustc/metadata/decoder.rs @@ -1284,24 +1284,19 @@ pub fn each_implementation_for_trait(cdata: Cmd, mut callback: F) where F: FnMut(DefId), { - if cdata.cnum == def_id.krate { - let item_doc = cdata.lookup_item(def_id.index); - for impl_doc in reader::tagged_docs(item_doc, tag_items_data_item_extension_impl) { - callback(item_def_id(impl_doc, cdata)); - } - return; - } - // Do a reverse lookup beforehand to avoid touching the crate_num // hash map in the loop below. if let Some(crate_local_did) = reverse_translate_def_id(cdata, def_id) { let def_id_u64 = def_to_u64(crate_local_did); let impls_doc = reader::get_doc(rbml::Doc::new(cdata.data()), tag_impls); - for impl_doc in reader::tagged_docs(impls_doc, tag_impls_impl) { - let impl_trait = reader::get_doc(impl_doc, tag_impls_impl_trait_def_id); - if reader::doc_as_u64(impl_trait) == def_id_u64 { - callback(item_def_id(impl_doc, cdata)); + for trait_doc in reader::tagged_docs(impls_doc, tag_impls_trait) { + let trait_def_id = reader::get_doc(trait_doc, tag_def_id); + if reader::doc_as_u64(trait_def_id) != def_id_u64 { + continue; + } + for impl_doc in reader::tagged_docs(trait_doc, tag_impls_trait_impl) { + callback(translated_def_id(cdata, impl_doc)); } } } diff --git a/src/librustc/metadata/encoder.rs b/src/librustc/metadata/encoder.rs index caccdbd33826..9d2b1548f29d 100644 --- a/src/librustc/metadata/encoder.rs +++ b/src/librustc/metadata/encoder.rs @@ -865,20 +865,6 @@ fn encode_inherent_implementations(ecx: &EncodeContext, } } -// Encodes the implementations of a trait defined in this crate. -fn encode_extension_implementations(ecx: &EncodeContext, - rbml_w: &mut Encoder, - trait_def_id: DefId) { - assert!(trait_def_id.is_local()); - let def = ecx.tcx.lookup_trait_def(trait_def_id); - - def.for_each_impl(ecx.tcx, |impl_def_id| { - rbml_w.start_tag(tag_items_data_item_extension_impl); - encode_def_id(rbml_w, impl_def_id); - rbml_w.end_tag(); - }); -} - fn encode_stability(rbml_w: &mut Encoder, stab_opt: Option<&attr::Stability>) { stab_opt.map(|stab| { rbml_w.start_tag(tag_items_data_item_stability); @@ -1256,9 +1242,6 @@ fn encode_info_for_item<'a, 'tcx>(ecx: &EncodeContext<'a, 'tcx>, } encode_path(rbml_w, path.clone()); - // Encode the implementations of this trait. - encode_extension_implementations(ecx, rbml_w, def_id); - // Encode inherent implementations for this trait. encode_inherent_implementations(ecx, rbml_w, def_id); @@ -1763,53 +1746,44 @@ fn encode_struct_field_attrs(ecx: &EncodeContext, -struct ImplVisitor<'a, 'b:'a, 'c:'a, 'tcx:'b> { - ecx: &'a EncodeContext<'b, 'tcx>, - rbml_w: &'a mut Encoder<'c>, +struct ImplVisitor<'a, 'tcx:'a> { + tcx: &'a ty::ctxt<'tcx>, + impls: FnvHashMap> } -impl<'a, 'b, 'c, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'b, 'c, 'tcx> { +impl<'a, 'tcx, 'v> Visitor<'v> for ImplVisitor<'a, 'tcx> { fn visit_item(&mut self, item: &hir::Item) { - if let hir::ItemImpl(_, _, _, Some(ref trait_ref), _, _) = item.node { - let def_id = self.ecx.tcx.def_map.borrow().get(&trait_ref.ref_id).unwrap().def_id(); - - // Load eagerly if this is an implementation of the Drop trait - // or if the trait is not defined in this crate. - if Some(def_id) == self.ecx.tcx.lang_items.drop_trait() || - def_id.krate != LOCAL_CRATE { - self.rbml_w.start_tag(tag_impls_impl); - encode_def_id(self.rbml_w, self.ecx.tcx.map.local_def_id(item.id)); - self.rbml_w.wr_tagged_u64(tag_impls_impl_trait_def_id, def_to_u64(def_id)); - self.rbml_w.end_tag(); + if let hir::ItemImpl(..) = item.node { + let impl_id = self.tcx.map.local_def_id(item.id); + if let Some(trait_ref) = self.tcx.impl_trait_ref(impl_id) { + self.impls.entry(trait_ref.def_id) + .or_insert(vec![]) + .push(impl_id); } } visit::walk_item(self, item); } } -/// Encodes implementations that are eagerly loaded. -/// -/// None of this is necessary in theory; we can load all implementations -/// lazily. However, in two cases the optimizations to lazily load -/// implementations are not yet implemented. These two cases, which require us -/// to load implementations eagerly, are: -/// -/// * Destructors (implementations of the Drop trait). -/// -/// * Implementations of traits not defined in this crate. +/// Encodes an index, mapping each trait to its (local) implementations. fn encode_impls<'a>(ecx: &'a EncodeContext, krate: &hir::Crate, rbml_w: &'a mut Encoder) { + let mut visitor = ImplVisitor { + tcx: ecx.tcx, + impls: FnvHashMap() + }; + visit::walk_crate(&mut visitor, krate); + rbml_w.start_tag(tag_impls); - - { - let mut visitor = ImplVisitor { - ecx: ecx, - rbml_w: rbml_w, - }; - visit::walk_crate(&mut visitor, krate); + for (trait_, trait_impls) in visitor.impls { + rbml_w.start_tag(tag_impls_trait); + encode_def_id(rbml_w, trait_); + for impl_ in trait_impls { + rbml_w.wr_tagged_u64(tag_impls_trait_impl, def_to_u64(impl_)); + } + rbml_w.end_tag(); } - rbml_w.end_tag(); } diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 40e89b390888..6c23307c6777 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1319,7 +1319,7 @@ fn copy_item_types(dcx: &DecodeContext, ii: &InlinedItem, orig_did: DefId) { if let Some(ctor_id) = def.ctor_id { let ctor_did = dcx.tcx.lookup_adt_def(orig_did) .struct_variant().ctor_id; - println!("copying ctor {:?}", ctor_did); + debug!("copying ctor {:?}", ctor_did); copy_item_type(dcx, ctor_id, ctor_did); } }