bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

rustc_metadata: group the tags into root tags and item tags.

Browse source
This commit is contained in:
Eduard Burtescu 2016-09-05 12:18:45 +03:00
parent 89736e8671
commit d2ea3daad1
5 changed files with 205 additions and 312 deletions
Download patch file Download diff file Expand all files Collapse all files

2
src/librustc_metadata/astencode.rs
View file

@ -33,7 +33,7 @@ use rustc_serialize::{Decodable, Encodable};
// Top-level methods.
pub fn encode_inlined_item(ecx: &mut EncodeContext, ii: InlinedItemRef) {
ecx.tag(::common::tag_ast, |ecx| {
ecx.tag(::common::item_tag::ast, |ecx| {
let mut visitor = IdRangeComputingVisitor::new();
match ii {
InlinedItemRef::Item(_, i) => visitor.visit_item(i),

226
src/librustc_metadata/common.rs
View file

@ -35,164 +35,12 @@ pub enum Family {
AssociatedConst,
}
// GAP 0x00...0x19
pub const tag_items: usize = 0x100; // top-level only
pub const tag_paths_data_name: usize = 0x20;
pub const tag_def_index: usize = 0x21;
pub const tag_items_data: usize = 0x22;
pub const tag_items_data_item: usize = 0x23;
pub const tag_items_data_item_family: usize = 0x24;
pub const tag_items_data_item_type: usize = 0x25;
// GAP 0x26, 0x27
pub const tag_items_data_parent_item: usize = 0x28;
pub const tag_items_data_item_is_tuple_struct_ctor: usize = 0x29;
pub const tag_items_closure_kind: usize = 0x2a;
pub const tag_items_closure_ty: usize = 0x2b;
pub const tag_def_key: usize = 0x2c;
// GAP 0x2d 0x34
pub const tag_index: usize = 0x110; // top-level only
pub const tag_xref_index: usize = 0x111; // top-level only
pub const tag_xref_data: usize = 0x112; // top-level only
pub const tag_attributes: usize = 0x101; // top-level only
// The list of crates that this crate depends on
pub const tag_crate_deps: usize = 0x102; // top-level only
pub const tag_crate_hash: usize = 0x103; // top-level only
pub const tag_crate_crate_name: usize = 0x104; // top-level only
pub const tag_crate_disambiguator: usize = 0x113; // top-level only
// GAP 0x35, 0x36, 0x37, 0x38, 0x39, 0x3a
pub const tag_item_trait_ref: usize = 0x3b;
// discriminator value for variants
pub const tag_disr_val: usize = 0x3c;
// GAP 0x3d, 0x3e, 0x3f, 0x40
pub const tag_item_fields: usize = 0x41;
// GAP 0x42
pub const tag_item_variances: usize = 0x43;
// GAP 0x44
pub const tag_item_trait_method_explicit_self: usize = 0x45;
// GAP 0x46, 0x47, 0x48
// used to encode crate_ctxt side tables
pub const tag_ast: usize = 0x50;
// GAP 0x51
pub const tag_mir: usize = 0x52;
// GAP 0x53...0x6a
pub const tag_item_trait_item_has_body: usize = 0x70;
pub const tag_crate_triple: usize = 0x105; // top-level only
pub const tag_dylib_dependency_formats: usize = 0x106; // top-level only
pub const tag_lang_items: usize = 0x107; // top-level only
// GAP 0x73, 0x74, 0x75
pub const tag_lang_items_missing: usize = 0x76; // top-level only
// GAP 0x77
pub const tag_items_data_item_visibility: usize = 0x78;
pub const tag_items_data_item_inherent_impls: usize = 0x79;
// GAP 0x7a
// NB: increment this if you change the format of metadata such that
// rustc_version can't be found.
pub const metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 2];
// GAP 0x7c
pub const tag_mod_children: usize = 0x7b;
// GAP 0x108 // top-level only
// GAP 0x7c
// GAP 0x108
pub const tag_impls: usize = 0x109; // top-level only
// GAP 0x7d, 0x7e, 0x7f, 0x80, 0x81
pub const tag_native_libraries: usize = 0x10a; // top-level only
// GAP 0x82, 0x83, 0x84
pub const tag_plugin_registrar_fn: usize = 0x10b; // top-level only
pub const tag_method_argument_names: usize = 0x85;
// GAP 0x86
pub const tag_reachable_ids: usize = 0x10c; // top-level only
// GAP 0x87
pub const tag_items_data_item_stability: usize = 0x88;
pub const tag_items_data_item_repr: usize = 0x89;
// GAP 0x10d // top-level only
// GAP 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_item_generics: usize = 0x8f;
// GAP 0x90, 0x91, 0x92, 0x93, 0x94
pub const tag_item_predicates: usize = 0x95;
// GAP 0x96, 0x97, 0x98, 0x99
pub const tag_unsafety: usize = 0x9a;
pub const tag_polarity: usize = 0x9d;
pub const tag_macro_defs: usize = 0x10e; // top-level only
// GAP 0x9e, 0x9f
pub const tag_paren_sugar: usize = 0xa0;
pub const tag_codemap: usize = 0xa1;
// GAP 0xa2
pub const tag_item_super_predicates: usize = 0xa3;
pub const tag_defaulted_trait: usize = 0xa4;
pub const tag_impl_coerce_unsized_kind: usize = 0xa5;
pub const tag_items_data_item_constness: usize = 0xa6;
pub const tag_items_data_item_deprecation: usize = 0xa7;
pub const tag_items_data_item_defaultness: usize = 0xa8;
pub const tag_items_data_parent_impl: usize = 0xa9;
pub const tag_rustc_version: usize = 0x10f;
pub fn rustc_version() -> String {
format!(
"rustc {}",
@ -200,13 +48,69 @@ pub fn rustc_version() -> String {
)
}
pub const tag_panic_strategy: usize = 0x114;
pub mod root_tag {
pub const rustc_version: usize = 0x10f;
pub const crate_deps: usize = 0x102;
pub const crate_hash: usize = 0x103;
pub const crate_crate_name: usize = 0x104;
pub const crate_disambiguator: usize = 0x113;
pub const items: usize = 0x100;
pub const index: usize = 0x110;
pub const xref_index: usize = 0x111;
pub const xref_data: usize = 0x112;
pub const crate_triple: usize = 0x105;
pub const dylib_dependency_formats: usize = 0x106;
pub const lang_items: usize = 0x107;
pub const lang_items_missing: usize = 0x76;
pub const impls: usize = 0x109;
pub const native_libraries: usize = 0x10a;
pub const plugin_registrar_fn: usize = 0x10b;
pub const panic_strategy: usize = 0x114;
pub const macro_derive_registrar: usize = 0x115;
pub const reachable_ids: usize = 0x10c;
pub const macro_defs: usize = 0x10e;
pub const codemap: usize = 0xa1;
}
pub const tag_macro_derive_registrar: usize = 0x115;
// NB: increment this if you change the format of metadata such that
// rustc_version can't be found.
pub const metadata_encoding_version : &'static [u8] = &[b'r', b'u', b's', b't', 0, 0, 0, 2];
pub mod item_tag {
pub const name: usize = 0x20;
pub const def_index: usize = 0x21;
pub const family: usize = 0x24;
pub const ty: usize = 0x25;
pub const parent_item: usize = 0x28;
pub const is_tuple_struct_ctor: usize = 0x29;
pub const closure_kind: usize = 0x2a;
pub const closure_ty: usize = 0x2b;
pub const def_key: usize = 0x2c;
pub const attributes: usize = 0x101;
pub const trait_ref: usize = 0x3b;
pub const disr_val: usize = 0x3c;
pub const fields: usize = 0x41;
pub const variances: usize = 0x43;
pub const trait_method_explicit_self: usize = 0x45;
pub const ast: usize = 0x50;
pub const mir: usize = 0x52;
pub const trait_item_has_body: usize = 0x70;
pub const visibility: usize = 0x78;
pub const inherent_impls: usize = 0x79;
pub const children: usize = 0x7b;
pub const method_argument_names: usize = 0x85;
pub const stability: usize = 0x88;
pub const repr: usize = 0x89;
pub const struct_ctor: usize = 0x8b;
pub const generics: usize = 0x8f;
pub const predicates: usize = 0x95;
pub const unsafety: usize = 0x9a;
pub const polarity: usize = 0x9d;
pub const paren_sugar: usize = 0xa0;
pub const super_predicates: usize = 0xa3;
pub const defaulted_trait: usize = 0xa4;
pub const impl_coerce_unsized_kind: usize = 0xa5;
pub const constness: usize = 0xa6;
pub const deprecation: usize = 0xa7;
pub const defaultness: usize = 0xa8;
pub const parent_impl: usize = 0xa9;
}
/// The shorthand encoding of `Ty` uses `TypeVariants`' variant `usize`
/// and is offset by this value so it never matches a real variant.

151
src/librustc_metadata/decoder.rs
View file

@ -324,53 +324,53 @@ impl CrateMetadata {
}
pub fn load_index(data: &[u8]) -> index::Index {
index::Index::from_rbml(rbml::Doc::new(data).get(tag_index))
index::Index::from_rbml(rbml::Doc::new(data).get(root_tag::index))
}
pub fn crate_rustc_version(data: &[u8]) -> Option<String> {
let doc = rbml::Doc::new(data);
reader::maybe_get_doc(doc, tag_rustc_version).map(|s| {
reader::maybe_get_doc(doc, root_tag::rustc_version).map(|s| {
str::from_utf8(&s.data[s.start..s.end]).unwrap().to_string()
})
}
pub fn load_xrefs(data: &[u8]) -> index::DenseIndex {
let index = rbml::Doc::new(data).get(tag_xref_index);
let index = rbml::Doc::new(data).get(root_tag::xref_index);
index::DenseIndex::from_buf(index.data, index.start, index.end)
}
// Go through each item in the metadata and create a map from that
// item's def-key to the item's DefIndex.
pub fn load_key_map(data: &[u8]) -> FnvHashMap<DefKey, DefIndex> {
rbml::Doc::new(data).get(tag_items).get(tag_items_data).children().map(|item_doc| {
rbml::Doc::new(data).get(root_tag::items).children().map(|item_doc| {
// load def-key from item
let key = item_def_key(item_doc);
// load def-index from item
(key, item_doc.get(tag_def_index).decoder().decode())
(key, item_doc.get(item_tag::def_index).decoder().decode())
}).collect()
}
fn item_family(item: rbml::Doc) -> Family {
item.get(tag_items_data_item_family).decoder().decode()
item.get(item_tag::family).decoder().decode()
}
fn item_visibility(item: rbml::Doc) -> ty::Visibility {
match reader::maybe_get_doc(item, tag_items_data_item_visibility) {
match reader::maybe_get_doc(item, item_tag::visibility) {
None => ty::Visibility::Public,
Some(visibility_doc) => visibility_doc.decoder().decode()
}
}
fn item_defaultness(item: rbml::Doc) -> hir::Defaultness {
match reader::maybe_get_doc(item, tag_items_data_item_defaultness) {
match reader::maybe_get_doc(item, item_tag::defaultness) {
None => hir::Defaultness::Default, // should occur only for default impls on traits
Some(defaultness_doc) => defaultness_doc.decoder().decode()
}
}
fn item_parent_item(cdata: Cmd, d: rbml::Doc) -> Option<DefId> {
reader::maybe_get_doc(d, tag_items_data_parent_item).map(|did| {
reader::maybe_get_doc(d, item_tag::parent_item).map(|did| {
let mut dcx = did.decoder();
dcx.cdata = Some(cdata);
dcx.decode()
@ -378,7 +378,7 @@ fn item_parent_item(cdata: Cmd, d: rbml::Doc) -> Option<DefId> {
}
fn item_require_parent_item(cdata: Cmd, d: rbml::Doc) -> DefId {
let mut dcx = d.get(tag_items_data_parent_item).decoder();
let mut dcx = d.get(item_tag::parent_item).decoder();
dcx.cdata = Some(cdata);
dcx.decode()
}
@ -386,17 +386,17 @@ fn item_require_parent_item(cdata: Cmd, d: rbml::Doc) -> DefId {
fn item_def_id(d: rbml::Doc, cdata: Cmd) -> DefId {
DefId {
krate: cdata.cnum,
index: d.get(tag_def_index).decoder().decode()
index: d.get(item_tag::def_index).decoder().decode()
}
}
fn doc_type<'a, 'tcx>(doc: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>, cdata: Cmd) -> Ty<'tcx> {
maybe_doc_type(doc, tcx, cdata).expect("missing tag_items_data_item_type")
maybe_doc_type(doc, tcx, cdata).expect("missing item_tag::ty")
}
fn maybe_doc_type<'a, 'tcx>(doc: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>, cdata: Cmd)
-> Option<Ty<'tcx>> {
reader::maybe_get_doc(doc, tag_items_data_item_type).map(|tp| {
reader::maybe_get_doc(doc, item_tag::ty).map(|tp| {
let mut dcx = tp.decoder();
dcx.tcx = Some(tcx);
dcx.cdata = Some(cdata);
@ -417,7 +417,7 @@ fn item_name(item: rbml::Doc) -> ast::Name {
}
fn maybe_item_name(item: rbml::Doc) -> Option<ast::Name> {
reader::maybe_get_doc(item, tag_paths_data_name).map(|name| {
reader::maybe_get_doc(item, item_tag::name).map(|name| {
name.decoder().decode()
})
}
@ -459,9 +459,9 @@ pub fn get_trait_def<'a, 'tcx>(cdata: Cmd,
{
let item_doc = cdata.lookup_item(item_id);
let generics = doc_generics(item_doc, tcx, cdata);
let unsafety = item_doc.get(tag_unsafety).decoder().decode();
let paren_sugar = item_doc.get(tag_paren_sugar).decoder().decode();
let trait_ref = doc_trait_ref(item_doc.get(tag_item_trait_ref), tcx, cdata);
let unsafety = item_doc.get(item_tag::unsafety).decoder().decode();
let paren_sugar = item_doc.get(item_tag::paren_sugar).decoder().decode();
let trait_ref = doc_trait_ref(item_doc.get(item_tag::trait_ref), tcx, cdata);
let def_path = def_path(cdata, item_id).unwrap();
ty::TraitDef::new(unsafety, paren_sugar, generics, trait_ref,
@ -481,12 +481,12 @@ pub fn get_adt_def<'a, 'tcx>(cdata: Cmd,
}
}
fn get_enum_variants<'tcx>(cdata: Cmd, doc: rbml::Doc) -> Vec<ty::VariantDefData<'tcx, 'tcx>> {
let mut dcx = doc.get(tag_mod_children).decoder();
let mut dcx = doc.get(item_tag::children).decoder();
dcx.cdata = Some(cdata);
dcx.seq().map(|did: DefId| {
let item = cdata.lookup_item(did.index);
let disr = item.get(tag_disr_val).decoder().decode();
let disr = item.get(item_tag::disr_val).decoder().decode();
ty::VariantDefData {
did: did,
name: item_name(item),
@ -497,7 +497,7 @@ pub fn get_adt_def<'a, 'tcx>(cdata: Cmd,
}).collect()
}
fn get_variant_fields<'tcx>(cdata: Cmd, doc: rbml::Doc) -> Vec<ty::FieldDefData<'tcx, 'tcx>> {
let mut dcx = doc.get(tag_item_fields).decoder();
let mut dcx = doc.get(item_tag::fields).decoder();
dcx.cdata = Some(cdata);
dcx.seq().map(|did: DefId| {
@ -531,7 +531,7 @@ pub fn get_adt_def<'a, 'tcx>(cdata: Cmd,
}
Struct(..) => {
// Use separate constructor id for unit/tuple structs and reuse did for braced structs.
ctor_did = reader::maybe_get_doc(doc, tag_items_data_item_struct_ctor).map(|ctor_doc| {
ctor_did = reader::maybe_get_doc(doc, item_tag::struct_ctor).map(|ctor_doc| {
let mut dcx = ctor_doc.decoder();
dcx.cdata = Some(cdata);
dcx.decode()
@ -595,7 +595,7 @@ pub fn get_predicates<'a, 'tcx>(cdata: Cmd,
-> ty::GenericPredicates<'tcx>
{
let item_doc = cdata.lookup_item(item_id);
doc_predicates(item_doc, tcx, cdata, tag_item_predicates)
doc_predicates(item_doc, tcx, cdata, item_tag::predicates)
}
pub fn get_super_predicates<'a, 'tcx>(cdata: Cmd,
@ -604,7 +604,7 @@ pub fn get_super_predicates<'a, 'tcx>(cdata: Cmd,
-> ty::GenericPredicates<'tcx>
{
let item_doc = cdata.lookup_item(item_id);
doc_predicates(item_doc, tcx, cdata, tag_item_super_predicates)
doc_predicates(item_doc, tcx, cdata, item_tag::super_predicates)
}
pub fn get_generics<'a, 'tcx>(cdata: Cmd,
@ -625,14 +625,14 @@ pub fn get_type<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
pub fn get_stability(cdata: Cmd, id: DefIndex) -> Option<attr::Stability> {
let item = cdata.lookup_item(id);
reader::maybe_get_doc(item, tag_items_data_item_stability).map(|doc| {
reader::maybe_get_doc(item, item_tag::stability).map(|doc| {
doc.decoder().decode()
})
}
pub fn get_deprecation(cdata: Cmd, id: DefIndex) -> Option<attr::Deprecation> {
let item = cdata.lookup_item(id);
reader::maybe_get_doc(item, tag_items_data_item_deprecation).map(|doc| {
reader::maybe_get_doc(item, item_tag::deprecation).map(|doc| {
doc.decoder().decode()
})
}
@ -643,7 +643,7 @@ pub fn get_visibility(cdata: Cmd, id: DefIndex) -> ty::Visibility {
pub fn get_parent_impl(cdata: Cmd, id: DefIndex) -> Option<DefId> {
let item = cdata.lookup_item(id);
reader::maybe_get_doc(item, tag_items_data_parent_impl).map(|doc| {
reader::maybe_get_doc(item, item_tag::parent_impl).map(|doc| {
let mut dcx = doc.decoder();
dcx.cdata = Some(cdata);
dcx.decode()
@ -652,13 +652,13 @@ pub fn get_parent_impl(cdata: Cmd, id: DefIndex) -> Option<DefId> {
pub fn get_repr_attrs(cdata: Cmd, id: DefIndex) -> Vec<attr::ReprAttr> {
let item = cdata.lookup_item(id);
reader::maybe_get_doc(item, tag_items_data_item_repr).map_or(vec![], |doc| {
reader::maybe_get_doc(item, item_tag::repr).map_or(vec![], |doc| {
doc.decoder().decode()
})
}
pub fn get_impl_polarity(cdata: Cmd, id: DefIndex) -> hir::ImplPolarity {
cdata.lookup_item(id).get(tag_polarity).decoder().decode()
cdata.lookup_item(id).get(item_tag::polarity).decoder().decode()
}
pub fn get_custom_coerce_unsized_kind(
@ -667,7 +667,7 @@ pub fn get_custom_coerce_unsized_kind(
-> Option<ty::adjustment::CustomCoerceUnsized>
{
let item_doc = cdata.lookup_item(id);
reader::maybe_get_doc(item_doc, tag_impl_coerce_unsized_kind).map(|kind_doc| {
reader::maybe_get_doc(item_doc, item_tag::impl_coerce_unsized_kind).map(|kind_doc| {
kind_doc.decoder().decode()
})
}
@ -678,14 +678,14 @@ pub fn get_impl_trait<'a, 'tcx>(cdata: Cmd,
-> Option<ty::TraitRef<'tcx>>
{
let item_doc = cdata.lookup_item(id);
reader::maybe_get_doc(item_doc, tag_item_trait_ref).map(|tp| {
reader::maybe_get_doc(item_doc, item_tag::trait_ref).map(|tp| {
doc_trait_ref(tp, tcx, cdata)
})
}
/// Iterates over the language items in the given crate.
pub fn get_lang_items(cdata: Cmd) -> Vec<(DefIndex, usize)> {
rbml::Doc::new(cdata.data()).get(tag_lang_items).decoder().decode()
rbml::Doc::new(cdata.data()).get(root_tag::lang_items).decoder().decode()
}
@ -702,7 +702,7 @@ pub fn each_child_of_item<F, G>(cdata: Cmd, id: DefIndex,
Some(item_doc) => item_doc,
};
let mut dcx = match reader::maybe_get_doc(item_doc, tag_mod_children) {
let mut dcx = match reader::maybe_get_doc(item_doc, item_tag::children) {
Some(doc) => doc.decoder(),
None => return
};
@ -782,7 +782,7 @@ pub fn maybe_get_item_ast<'a, 'tcx>(cdata: Cmd, tcx: TyCtxt<'a, 'tcx, 'tcx>, id:
};
let mut parent_def_path = def_path(cdata, id).unwrap();
parent_def_path.data.pop();
if let Some(ast_doc) = reader::maybe_get_doc(item_doc, tag_ast as usize) {
if let Some(ast_doc) = reader::maybe_get_doc(item_doc, item_tag::ast as usize) {
let ii = decode_inlined_item(cdata,
tcx,
parent_def_path,
@ -800,7 +800,7 @@ pub fn maybe_get_item_ast<'a, 'tcx>(cdata: Cmd, tcx: TyCtxt<'a, 'tcx, 'tcx>, id:
let mut grandparent_def_path = parent_def_path;
grandparent_def_path.data.pop();
let parent_doc = cdata.lookup_item(parent_did.index);
if let Some(ast_doc) = reader::maybe_get_doc(parent_doc, tag_ast as usize) {
if let Some(ast_doc) = reader::maybe_get_doc(parent_doc, item_tag::ast as usize) {
let ii = decode_inlined_item(cdata,
tcx,
grandparent_def_path,
@ -817,7 +817,7 @@ pub fn maybe_get_item_ast<'a, 'tcx>(cdata: Cmd, tcx: TyCtxt<'a, 'tcx, 'tcx>, id:
pub fn is_item_mir_available<'tcx>(cdata: Cmd, id: DefIndex) -> bool {
if let Some(item_doc) = cdata.get_item(id) {
return reader::maybe_get_doc(item_doc, tag_mir as usize).is_some();
return reader::maybe_get_doc(item_doc, item_tag::mir as usize).is_some();
}
false
@ -829,7 +829,7 @@ pub fn maybe_get_item_mir<'a, 'tcx>(cdata: Cmd,
-> Option<Mir<'tcx>> {
let item_doc = cdata.lookup_item(id);
reader::maybe_get_doc(item_doc, tag_mir).map(|mir_doc| {
reader::maybe_get_doc(item_doc, item_tag::mir).map(|mir_doc| {
let mut dcx = mir_doc.decoder();
dcx.tcx = Some(tcx);
dcx.cdata = Some(cdata);
@ -839,7 +839,7 @@ pub fn maybe_get_item_mir<'a, 'tcx>(cdata: Cmd,
fn get_explicit_self<'a, 'tcx>(cdata: Cmd, item: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>)
-> ty::ExplicitSelfCategory<'tcx> {
let mut dcx = item.get(tag_item_trait_method_explicit_self).decoder();
let mut dcx = item.get(item_tag::trait_method_explicit_self).decoder();
dcx.cdata = Some(cdata);
dcx.tcx = Some(tcx);
@ -881,12 +881,12 @@ pub fn get_impl_or_trait_item<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a
defaultness: defaultness,
def_id: def_id,
container: container,
has_value: item_doc.get(tag_item_trait_item_has_body).decoder().decode(),
has_value: item_doc.get(item_tag::trait_item_has_body).decoder().decode(),
}))
}
Family::Method => {
let generics = doc_generics(item_doc, tcx, cdata);
let predicates = doc_predicates(item_doc, tcx, cdata, tag_item_predicates);
let predicates = doc_predicates(item_doc, tcx, cdata, item_tag::predicates);
let ity = tcx.lookup_item_type(def_id).ty;
let fty = match ity.sty {
ty::TyFnDef(.., fty) => fty,
@ -904,7 +904,7 @@ pub fn get_impl_or_trait_item<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a
explicit_self: explicit_self,
vis: vis,
defaultness: defaultness,
has_body: item_doc.get(tag_item_trait_item_has_body).decoder().decode(),
has_body: item_doc.get(item_tag::trait_item_has_body).decoder().decode(),
def_id: def_id,
container: container,
}))
@ -926,13 +926,13 @@ pub fn get_impl_or_trait_item<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a
pub fn get_item_variances(cdata: Cmd, id: DefIndex) -> Vec<ty::Variance> {
let item_doc = cdata.lookup_item(id);
item_doc.get(tag_item_variances).decoder().decode()
item_doc.get(item_tag::variances).decoder().decode()
}
pub fn get_struct_ctor_def_id(cdata: Cmd, node_id: DefIndex) -> Option<DefId>
{
let item = cdata.lookup_item(node_id);
reader::maybe_get_doc(item, tag_items_data_item_struct_ctor).map(|ctor_doc| {
reader::maybe_get_doc(item, item_tag::struct_ctor).map(|ctor_doc| {
let mut dcx = ctor_doc.decoder();
dcx.cdata = Some(cdata);
dcx.decode()
@ -946,7 +946,7 @@ pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd,
-> Option<DefId>
{
let item = cdata.lookup_item(node_id);
reader::maybe_get_doc(item, tag_items_data_item_is_tuple_struct_ctor).and_then(|doc| {
reader::maybe_get_doc(item, item_tag::is_tuple_struct_ctor).and_then(|doc| {
if doc.decoder().decode() {
Some(item_require_parent_item(cdata, item))
} else {
@ -968,7 +968,7 @@ pub fn get_item_attrs(cdata: Cmd,
}
pub fn get_struct_field_names(cdata: Cmd, id: DefIndex) -> Vec<ast::Name> {
let mut dcx = cdata.lookup_item(id).get(tag_item_fields).decoder();
let mut dcx = cdata.lookup_item(id).get(item_tag::fields).decoder();
dcx.cdata = Some(cdata);
dcx.seq().map(|did: DefId| {
@ -977,7 +977,7 @@ pub fn get_struct_field_names(cdata: Cmd, id: DefIndex) -> Vec<ast::Name> {
}
fn get_attributes(md: rbml::Doc) -> Vec<ast::Attribute> {
reader::maybe_get_doc(md, tag_attributes).map_or(vec![], |attrs_doc| {
reader::maybe_get_doc(md, item_tag::attributes).map_or(vec![], |attrs_doc| {
let mut attrs = attrs_doc.decoder().decode::<Vec<ast::Attribute>>();
// Need new unique IDs: old thread-local IDs won't map to new threads.
@ -998,7 +998,7 @@ pub struct CrateDep {
}
pub fn get_crate_deps(data: &[u8]) -> Vec<CrateDep> {
let dcx = rbml::Doc::new(data).get(tag_crate_deps).decoder();
let dcx = rbml::Doc::new(data).get(root_tag::crate_deps).decoder();
dcx.seq().enumerate().map(|(crate_num, (name, hash, explicitly_linked))| {
CrateDep {
@ -1021,29 +1021,29 @@ fn list_crate_deps(data: &[u8], out: &mut io::Write) -> io::Result<()> {
pub fn maybe_get_crate_hash(data: &[u8]) -> Option<Svh> {
let cratedoc = rbml::Doc::new(data);
reader::maybe_get_doc(cratedoc, tag_crate_hash).map(|doc| {
reader::maybe_get_doc(cratedoc, root_tag::crate_hash).map(|doc| {
doc.decoder().decode()
})
}
pub fn get_crate_hash(data: &[u8]) -> Svh {
rbml::Doc::new(data).get(tag_crate_hash).decoder().decode()
rbml::Doc::new(data).get(root_tag::crate_hash).decoder().decode()
}
pub fn maybe_get_crate_name(data: &[u8]) -> Option<String> {
let cratedoc = rbml::Doc::new(data);
reader::maybe_get_doc(cratedoc, tag_crate_crate_name).map(|doc| {
reader::maybe_get_doc(cratedoc, root_tag::crate_crate_name).map(|doc| {
doc.decoder().decode()
})
}
pub fn get_crate_disambiguator(data: &[u8]) -> String {
rbml::Doc::new(data).get(tag_crate_disambiguator).decoder().decode()
rbml::Doc::new(data).get(root_tag::crate_disambiguator).decoder().decode()
}
pub fn get_crate_triple(data: &[u8]) -> Option<String> {
let cratedoc = rbml::Doc::new(data);
let triple_doc = reader::maybe_get_doc(cratedoc, tag_crate_triple);
let triple_doc = reader::maybe_get_doc(cratedoc, root_tag::crate_triple);
triple_doc.map(|s| s.decoder().decode())
}
@ -1073,7 +1073,7 @@ pub fn each_inherent_implementation_for_type<F>(cdata: Cmd,
where F: FnMut(DefId),
{
let item_doc = cdata.lookup_item(id);
let mut dcx = item_doc.get(tag_items_data_item_inherent_impls).decoder();
let mut dcx = item_doc.get(item_tag::inherent_impls).decoder();
dcx.cdata = Some(cdata);
for impl_def_id in dcx.seq() {
@ -1095,7 +1095,7 @@ pub fn each_implementation_for_trait<F>(cdata: Cmd,
};
// FIXME(eddyb) Make this O(1) instead of O(n).
for trait_doc in rbml::Doc::new(cdata.data()).get(tag_impls).children() {
for trait_doc in rbml::Doc::new(cdata.data()).get(root_tag::impls).children() {
let mut dcx = trait_doc.decoder();
dcx.cdata = Some(cdata);
@ -1128,18 +1128,18 @@ pub fn get_trait_of_item(cdata: Cmd, id: DefIndex) -> Option<DefId> {
pub fn get_native_libraries(cdata: Cmd)
-> Vec<(cstore::NativeLibraryKind, String)> {
rbml::Doc::new(cdata.data()).get(tag_native_libraries).decoder().decode()
rbml::Doc::new(cdata.data()).get(root_tag::native_libraries).decoder().decode()
}
pub fn get_plugin_registrar_fn(data: &[u8]) -> Option<DefIndex> {
reader::maybe_get_doc(rbml::Doc::new(data), tag_plugin_registrar_fn)
reader::maybe_get_doc(rbml::Doc::new(data), root_tag::plugin_registrar_fn)
.map(|doc| doc.decoder().decode())
}
pub fn each_exported_macro<F>(data: &[u8], mut f: F) where
F: FnMut(ast::Name, Vec<ast::Attribute>, Span, String) -> bool,
{
let dcx = rbml::Doc::new(data).get(tag_macro_defs).decoder();
let dcx = rbml::Doc::new(data).get(root_tag::macro_defs).decoder();
for (name, attrs, span, body) in dcx.seq() {
if !f(name, attrs, span, body) {
break;
@ -1148,14 +1148,14 @@ pub fn each_exported_macro<F>(data: &[u8], mut f: F) where
}
pub fn get_derive_registrar_fn(data: &[u8]) -> Option<DefIndex> {
reader::maybe_get_doc(rbml::Doc::new(data), tag_macro_derive_registrar)
reader::maybe_get_doc(rbml::Doc::new(data), root_tag::macro_derive_registrar)
.map(|doc| doc.decoder().decode())
}
pub fn get_dylib_dependency_formats(cdata: Cmd)
-> Vec<(CrateNum, LinkagePreference)>
{
let dcx = rbml::Doc::new(cdata.data()).get(tag_dylib_dependency_formats).decoder();
let dcx = rbml::Doc::new(cdata.data()).get(root_tag::dylib_dependency_formats).decoder();
dcx.seq::<Option<_>>().enumerate().flat_map(|(i, link)| {
let cnum = CrateNum::new(i + 1);
@ -1164,19 +1164,19 @@ pub fn get_dylib_dependency_formats(cdata: Cmd)
}
pub fn get_missing_lang_items(cdata: Cmd) -> Vec<lang_items::LangItem> {
rbml::Doc::new(cdata.data()).get(tag_lang_items_missing).decoder().decode()
rbml::Doc::new(cdata.data()).get(root_tag::lang_items_missing).decoder().decode()
}
pub fn get_method_arg_names(cdata: Cmd, id: DefIndex) -> Vec<String> {
let method_doc = cdata.lookup_item(id);
match reader::maybe_get_doc(method_doc, tag_method_argument_names) {
match reader::maybe_get_doc(method_doc, item_tag::method_argument_names) {
Some(args_doc) => args_doc.decoder().decode(),
None => vec![],
}
}
pub fn get_reachable_ids(cdata: Cmd) -> Vec<DefId> {
let dcx = rbml::Doc::new(cdata.data()).get(tag_reachable_ids).decoder();
let dcx = rbml::Doc::new(cdata.data()).get(root_tag::reachable_ids).decoder();
dcx.seq().map(|index| {
DefId {
@ -1187,7 +1187,7 @@ pub fn get_reachable_ids(cdata: Cmd) -> Vec<DefId> {
}
pub fn is_const_fn(cdata: Cmd, id: DefIndex) -> bool {
match reader::maybe_get_doc(cdata.lookup_item(id), tag_items_data_item_constness) {
match reader::maybe_get_doc(cdata.lookup_item(id), item_tag::constness) {
None => false,
Some(doc) => {
match doc.decoder().decode() {
@ -1235,7 +1235,7 @@ fn doc_generics<'a, 'tcx>(base_doc: rbml::Doc,
cdata: Cmd)
-> &'tcx ty::Generics<'tcx>
{
let mut dcx = base_doc.get(tag_item_generics).decoder();
let mut dcx = base_doc.get(item_tag::generics).decoder();
dcx.tcx = Some(tcx);
dcx.cdata = Some(cdata);
tcx.alloc_generics(dcx.decode())
@ -1268,7 +1268,7 @@ fn doc_predicates<'a, 'tcx>(base_doc: rbml::Doc,
}
pub fn is_defaulted_trait(cdata: Cmd, trait_id: DefIndex) -> bool {
cdata.lookup_item(trait_id).get(tag_defaulted_trait).decoder().decode()
cdata.lookup_item(trait_id).get(item_tag::defaulted_trait).decoder().decode()
}
pub fn is_default_impl(cdata: Cmd, impl_id: DefIndex) -> bool {
@ -1276,17 +1276,17 @@ pub fn is_default_impl(cdata: Cmd, impl_id: DefIndex) -> bool {
}
pub fn get_imported_filemaps(metadata: &[u8]) -> Vec<syntax_pos::FileMap> {
rbml::Doc::new(metadata).get(tag_codemap).decoder().decode()
rbml::Doc::new(metadata).get(root_tag::codemap).decoder().decode()
}
pub fn closure_kind(cdata: Cmd, closure_id: DefIndex) -> ty::ClosureKind {
cdata.lookup_item(closure_id).get(tag_items_closure_kind).decoder().decode()
cdata.lookup_item(closure_id).get(item_tag::closure_kind).decoder().decode()
}
pub fn closure_ty<'a, 'tcx>(cdata: Cmd, closure_id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
-> ty::ClosureTy<'tcx> {
let closure_doc = cdata.lookup_item(closure_id);
let closure_ty_doc = closure_doc.get(tag_items_closure_ty);
let closure_ty_doc = closure_doc.get(item_tag::closure_ty);
let mut dcx = closure_ty_doc.decoder();
dcx.tcx = Some(tcx);
dcx.cdata = Some(cdata);
@ -1300,18 +1300,9 @@ pub fn def_key(cdata: Cmd, id: DefIndex) -> hir_map::DefKey {
}
fn item_def_key(item_doc: rbml::Doc) -> hir_map::DefKey {
match reader::maybe_get_doc(item_doc, tag_def_key) {
Some(def_key_doc) => {
let simple_key = def_key_doc.decoder().decode();
let name = maybe_item_name(item_doc).map(|name| name.as_str());
def_key::recover_def_key(simple_key, name)
}
None => {
bug!("failed to find block with tag {:?} for item with family {:?}",
tag_def_key,
item_family(item_doc))
}
}
let simple_key = item_doc.get(item_tag::def_key).decoder().decode();
let name = maybe_item_name(item_doc).map(|name| name.as_str());
def_key::recover_def_key(simple_key, name)
}
// Returns the path leading to the thing with this `id`. Note that
@ -1327,5 +1318,5 @@ pub fn def_path(cdata: Cmd, id: DefIndex) -> Option<hir_map::DefPath> {
}
pub fn get_panic_strategy(data: &[u8]) -> PanicStrategy {
rbml::Doc::new(data).get(tag_panic_strategy).decoder().decode()
rbml::Doc::new(data).get(root_tag::panic_strategy).decoder().decode()
}

134
src/librustc_metadata/encoder.rs
View file

@ -169,21 +169,21 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
}
fn encode_name(ecx: &mut EncodeContext, name: Name) {
ecx.start_tag(tag_paths_data_name);
ecx.start_tag(item_tag::name);
name.encode(ecx).unwrap();
ecx.end_tag();
}
fn encode_def_id(ecx: &mut EncodeContext, def_id: DefId) {
assert!(def_id.is_local());
ecx.start_tag(tag_def_index);
ecx.start_tag(item_tag::def_index);
def_id.index.encode(ecx).unwrap();
ecx.end_tag();
}
fn encode_def_key(ecx: &mut EncodeContext, key: DefKey) {
let simple_key = def_key::simplify_def_key(key);
ecx.start_tag(tag_def_key);
ecx.start_tag(item_tag::def_key);
simple_key.encode(ecx);
ecx.end_tag();
}
@ -206,14 +206,14 @@ fn encode_trait_ref<'a, 'tcx>(ecx: &mut EncodeContext<'a, 'tcx>,
// Item info table encoding
fn encode_family(ecx: &mut EncodeContext, f: Family) {
ecx.start_tag(tag_items_data_item_family);
ecx.start_tag(item_tag::family);
f.encode(ecx).unwrap();
ecx.end_tag();
}
fn encode_item_variances(ecx: &mut EncodeContext, id: NodeId) {
let v = ecx.tcx.item_variances(ecx.tcx.map.local_def_id(id));
ecx.start_tag(tag_item_variances);
ecx.start_tag(item_tag::variances);
v.encode(ecx);
ecx.end_tag();
}
@ -233,27 +233,27 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
}
fn encode_type(&mut self, typ: Ty<'tcx>) {
self.start_tag(tag_items_data_item_type);
self.start_tag(item_tag::ty);
typ.encode(self).unwrap();
self.end_tag();
}
fn encode_disr_val(&mut self,
disr_val: ty::Disr) {
self.start_tag(tag_disr_val);
self.start_tag(item_tag::disr_val);
disr_val.to_u64_unchecked().encode(self).unwrap();
self.end_tag();
}
fn encode_parent_item(&mut self, id: DefId) {
self.start_tag(tag_items_data_parent_item);
self.start_tag(item_tag::parent_item);
id.encode(self).unwrap();
self.end_tag();
}
fn encode_variant_fields(&mut self,
variant: ty::VariantDef) {
self.start_tag(tag_item_fields);
self.start_tag(item_tag::fields);
self.seq(&variant.fields, |_, f| f.did);
self.end_tag();
}
@ -321,7 +321,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
debug!("(encoding info for module) encoding info for module ID {}", id);
// Encode info about all the module children.
self.start_tag(tag_mod_children);
self.start_tag(item_tag::children);
self.seq(&md.item_ids, |_, item_id| {
tcx.map.local_def_id(item_id.id)
});
@ -358,7 +358,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
} else {
ty::Visibility::PrivateExternal
};
self.start_tag(tag_items_data_item_visibility);
self.start_tag(item_tag::visibility);
vis.encode(self).unwrap();
self.end_tag();
}
@ -381,13 +381,13 @@ impl HasVisibility for ty::Visibility {
}
fn encode_constness(ecx: &mut EncodeContext, constness: hir::Constness) {
ecx.start_tag(tag_items_data_item_constness);
ecx.start_tag(item_tag::constness);
constness.encode(ecx).unwrap();
ecx.end_tag();
}
fn encode_defaultness(ecx: &mut EncodeContext, defaultness: hir::Defaultness) {
ecx.start_tag(tag_items_data_item_defaultness);
ecx.start_tag(item_tag::defaultness);
defaultness.encode(ecx).unwrap();
ecx.end_tag();
}
@ -463,7 +463,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
// definition, but without this there is no way for them
// to tell that they actually have a ctor rather than a
// normal function
self.start_tag(tag_items_data_item_is_tuple_struct_ctor);
self.start_tag(item_tag::is_tuple_struct_ctor);
true.encode(self).unwrap();
self.end_tag();
}
@ -472,10 +472,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
generics: &ty::Generics<'tcx>,
predicates: &ty::GenericPredicates<'tcx>)
{
self.start_tag(tag_item_generics);
self.start_tag(item_tag::generics);
generics.encode(self).unwrap();
self.end_tag();
self.encode_predicates(predicates, tag_item_predicates);
self.encode_predicates(predicates, item_tag::predicates);
}
fn encode_predicates(&mut self,
@ -495,7 +495,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
self.encode_generics(&method_ty.generics, &method_ty.predicates);
self.encode_visibility(method_ty.vis);
self.start_tag(tag_item_trait_method_explicit_self);
self.start_tag(item_tag::trait_method_explicit_self);
method_ty.explicit_self.encode(self).unwrap();
self.end_tag();
@ -541,7 +541,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
encode_attributes(self, &trait_item.attrs);
match trait_item.node {
hir::ConstTraitItem(_, ref default) => {
self.start_tag(tag_item_trait_item_has_body);
self.start_tag(item_tag::trait_item_has_body);
default.is_some().encode(self).unwrap();
self.end_tag();
@ -550,7 +550,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
self.encode_mir(item_def_id);
}
hir::MethodTraitItem(ref sig, ref body) => {
self.start_tag(tag_item_trait_item_has_body);
self.start_tag(item_tag::trait_item_has_body);
body.is_some().encode(self).unwrap();
self.end_tag();
@ -600,7 +600,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
self.encode_parent_item(tcx.map.local_def_id(parent_id));
self.start_tag(tag_item_trait_item_has_body);
self.start_tag(item_tag::trait_item_has_body);
true.encode(self).unwrap();
self.end_tag();
@ -632,7 +632,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
self.encode_method_ty_fields(m);
self.encode_parent_item(tcx.map.local_def_id(parent_id));
self.start_tag(tag_item_trait_item_has_body);
self.start_tag(item_tag::trait_item_has_body);
true.encode(self).unwrap();
self.end_tag();
@ -697,7 +697,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
fn encode_method_argument_names(&mut self,
decl: &hir::FnDecl) {
self.start_tag(tag_method_argument_names);
self.start_tag(item_tag::method_argument_names);
self.seq(&decl.inputs, |_, arg| {
if let PatKind::Binding(_, ref path1, _) = arg.pat.node {
@ -717,14 +717,14 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
repr_attrs.extend(attr::find_repr_attrs(self.tcx.sess.diagnostic(),
attr));
}
self.start_tag(tag_items_data_item_repr);
self.start_tag(item_tag::repr);
repr_attrs.encode(self);
self.end_tag();
}
fn encode_mir(&mut self, def_id: DefId) {
if let Some(mir) = self.mir_map.map.get(&def_id) {
self.start_tag(tag_mir as usize);
self.start_tag(item_tag::mir as usize);
mir.encode(self);
self.end_tag();
}
@ -734,7 +734,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
// Encodes the inherent implementations of a structure, enumeration, or trait.
fn encode_inherent_implementations(ecx: &mut EncodeContext,
def_id: DefId) {
ecx.start_tag(tag_items_data_item_inherent_impls);
ecx.start_tag(item_tag::inherent_impls);
match ecx.tcx.inherent_impls.borrow().get(&def_id) {
None => <[DefId]>::encode(&[], ecx).unwrap(),
Some(implementations) => implementations.encode(ecx).unwrap()
@ -744,7 +744,7 @@ fn encode_inherent_implementations(ecx: &mut EncodeContext,
fn encode_stability(ecx: &mut EncodeContext, stab_opt: Option<&attr::Stability>) {
stab_opt.map(|stab| {
ecx.start_tag(tag_items_data_item_stability);
ecx.start_tag(item_tag::stability);
stab.encode(ecx).unwrap();
ecx.end_tag();
});
@ -752,7 +752,7 @@ fn encode_stability(ecx: &mut EncodeContext, stab_opt: Option<&attr::Stability>)
fn encode_deprecation(ecx: &mut EncodeContext, depr_opt: Option<attr::Deprecation>) {
depr_opt.map(|depr| {
ecx.start_tag(tag_items_data_item_deprecation);
ecx.start_tag(item_tag::deprecation);
depr.encode(ecx).unwrap();
ecx.end_tag();
});
@ -772,7 +772,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let mut sorted_xrefs: Vec<_> = xrefs.into_iter().collect();
sorted_xrefs.sort_by_key(|&(_, id)| id);
self.start_tag(tag_xref_data);
self.start_tag(root_tag::xref_data);
for (xref, id) in sorted_xrefs.into_iter() {
xref_positions[id as usize] = self.mark_stable_position() as u32;
match xref {
@ -782,7 +782,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
self.mark_stable_position();
self.end_tag();
self.start_tag(tag_xref_index);
self.start_tag(root_tag::xref_index);
index::write_dense_index(xref_positions, &mut self.opaque.cursor);
self.end_tag();
}
@ -857,7 +857,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
encode_name(self, item.name);
// Encode all the items in self module.
self.start_tag(tag_mod_children);
self.start_tag(item_tag::children);
self.seq(&fm.items, |_, foreign_item| {
tcx.map.local_def_id(foreign_item.id)
});
@ -886,7 +886,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
encode_attributes(self, &item.attrs);
self.encode_repr_attrs(&item.attrs);
self.start_tag(tag_mod_children);
self.start_tag(item_tag::children);
self.seq(&enum_definition.variants, |_, v| {
tcx.map.local_def_id(v.node.data.id())
});
@ -928,7 +928,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
if !struct_def.is_struct() {
let ctor_did = tcx.map.local_def_id(struct_def.id());
self.start_tag(tag_items_data_item_struct_ctor);
self.start_tag(item_tag::struct_ctor);
ctor_did.encode(self).unwrap();
self.end_tag();
}
@ -966,7 +966,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
encode_name(self, item.name);
let trait_ref = tcx.impl_trait_ref(tcx.map.local_def_id(item.id)).unwrap();
encode_trait_ref(self, trait_ref, tag_item_trait_ref);
encode_trait_ref(self, trait_ref, item_tag::trait_ref);
}
hir::ItemImpl(_, polarity, ..) => {
encode_def_id_and_key(self, def_id);
@ -975,7 +975,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
encode_name(self, item.name);
encode_attributes(self, &item.attrs);
self.start_tag(tag_polarity);
self.start_tag(item_tag::polarity);
polarity.encode(self).unwrap();
self.end_tag();
@ -985,21 +985,21 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
.get(&tcx.map.local_def_id(item.id))
{
Some(&kind) => {
self.start_tag(tag_impl_coerce_unsized_kind);
self.start_tag(item_tag::impl_coerce_unsized_kind);
kind.encode(self);
self.end_tag();
}
None => {}
}
self.start_tag(tag_mod_children);
self.start_tag(item_tag::children);
tcx.impl_or_trait_items(def_id).encode(self).unwrap();
<[def::Export]>::encode(&[], self).unwrap();
self.end_tag();
let did = tcx.map.local_def_id(item.id);
if let Some(trait_ref) = tcx.impl_trait_ref(did) {
encode_trait_ref(self, trait_ref, tag_item_trait_ref);
encode_trait_ref(self, trait_ref, item_tag::trait_ref);
let trait_def = tcx.lookup_trait_def(trait_ref.def_id);
let parent = trait_def.ancestors(did)
@ -1011,7 +1011,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
_ => None,
});
parent.map(|parent| {
self.start_tag(tag_items_data_parent_impl);
self.start_tag(item_tag::parent_impl);
parent.encode(self).unwrap();
self.end_tag();
});
@ -1026,29 +1026,29 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
let trait_def = tcx.lookup_trait_def(def_id);
let trait_predicates = tcx.lookup_predicates(def_id);
self.start_tag(tag_unsafety);
self.start_tag(item_tag::unsafety);
trait_def.unsafety.encode(self).unwrap();
self.end_tag();
self.start_tag(tag_paren_sugar);
self.start_tag(item_tag::paren_sugar);
trait_def.paren_sugar.encode(self).unwrap();
self.end_tag();
self.start_tag(tag_defaulted_trait);
self.start_tag(item_tag::defaulted_trait);
tcx.trait_has_default_impl(def_id).encode(self).unwrap();
self.end_tag();
self.encode_generics(&trait_def.generics, &trait_predicates);
self.encode_predicates(&tcx.lookup_super_predicates(def_id),
tag_item_super_predicates);
encode_trait_ref(self, trait_def.trait_ref, tag_item_trait_ref);
item_tag::super_predicates);
encode_trait_ref(self, trait_def.trait_ref, item_tag::trait_ref);
encode_name(self, item.name);
encode_attributes(self, &item.attrs);
self.encode_visibility(vis);
encode_stability(self, stab);
encode_deprecation(self, depr);
self.start_tag(tag_mod_children);
self.start_tag(item_tag::children);
tcx.impl_or_trait_items(def_id).encode(self).unwrap();
<[def::Export]>::encode(&[], self).unwrap();
self.end_tag();
@ -1276,11 +1276,11 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
encode_def_id_and_key(self, def_id);
encode_name(self, syntax::parse::token::intern("<closure>"));
self.start_tag(tag_items_closure_ty);
self.start_tag(item_tag::closure_ty);
tcx.tables.borrow().closure_tys[&def_id].encode(self).unwrap();
self.end_tag();
self.start_tag(tag_items_closure_kind);
self.start_tag(item_tag::closure_kind);
tcx.closure_kind(def_id).encode(self).unwrap();
self.end_tag();
@ -1292,7 +1292,7 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
fn encode_info_for_items(ecx: &mut EncodeContext) -> IndexData {
let krate = ecx.tcx.map.krate();
ecx.start_tag(tag_items_data);
ecx.start_tag(root_tag::items);
let items = {
let mut index = IndexBuilder::new(ecx);
@ -1315,13 +1315,13 @@ fn encode_info_for_items(ecx: &mut EncodeContext) -> IndexData {
}
fn encode_item_index(ecx: &mut EncodeContext, index: IndexData) {
ecx.start_tag(tag_index);
ecx.start_tag(root_tag::index);
index.write_index(&mut ecx.opaque.cursor);
ecx.end_tag();
}
fn encode_attributes(ecx: &mut EncodeContext, attrs: &[ast::Attribute]) {
ecx.start_tag(tag_attributes);
ecx.start_tag(item_tag::attributes);
attrs.encode(ecx).unwrap();
ecx.end_tag();
}
@ -1352,7 +1352,7 @@ fn encode_crate_deps(ecx: &mut EncodeContext, cstore: &cstore::CStore) {
// the assumption that they are numbered 1 to n.
// FIXME (#2166): This is not nearly enough to support correct versioning
// but is enough to get transitive crate dependencies working.
ecx.start_tag(tag_crate_deps);
ecx.start_tag(root_tag::crate_deps);
ecx.seq(&get_ordered_deps(cstore), |_, &(_, ref dep)| {
(dep.name(), decoder::get_crate_hash(dep.data()),
dep.explicitly_linked.get())
@ -1376,11 +1376,11 @@ fn encode_lang_items(ecx: &mut EncodeContext) {
let count = lang_items().count();
let mut lang_items = lang_items();
ecx.start_tag(tag_lang_items);
ecx.start_tag(root_tag::lang_items);
ecx.seq(0..count, |_, _| lang_items.next().unwrap());
ecx.end_tag();
ecx.start_tag(tag_lang_items_missing);
ecx.start_tag(root_tag::lang_items_missing);
tcx.lang_items.missing.encode(ecx).unwrap();
ecx.end_tag();
}
@ -1401,7 +1401,7 @@ fn encode_native_libraries(ecx: &mut EncodeContext) {
let count = libs().count();
let mut libs = libs();
ecx.start_tag(tag_native_libraries);
ecx.start_tag(root_tag::native_libraries);
ecx.seq(0..count, |_, _| libs.next().unwrap());
ecx.end_tag();
}
@ -1410,7 +1410,7 @@ fn encode_plugin_registrar_fn(ecx: &mut EncodeContext) {
match ecx.tcx.sess.plugin_registrar_fn.get() {
Some(id) => {
let def_id = ecx.tcx.map.local_def_id(id);
ecx.start_tag(tag_plugin_registrar_fn);
ecx.start_tag(root_tag::plugin_registrar_fn);
def_id.index.encode(ecx).unwrap();
ecx.end_tag();
}
@ -1434,7 +1434,7 @@ fn encode_codemap(ecx: &mut EncodeContext) {
let count = filemaps().count();
let mut filemaps = filemaps();
ecx.start_tag(tag_codemap);
ecx.start_tag(root_tag::codemap);
ecx.seq(0..count, |_, _| filemaps.next().unwrap());
ecx.end_tag();
}
@ -1442,7 +1442,7 @@ fn encode_codemap(ecx: &mut EncodeContext) {
/// Serialize the text of the exported macros
fn encode_macro_defs(ecx: &mut EncodeContext) {
let tcx = ecx.tcx;
ecx.start_tag(tag_macro_defs);
ecx.start_tag(root_tag::macro_defs);
ecx.seq(&tcx.map.krate().exported_macros, |_, def| {
let body = ::syntax::print::pprust::tts_to_string(&def.body);
(def.name, &def.attrs, def.span, body)
@ -1453,7 +1453,7 @@ fn encode_macro_defs(ecx: &mut EncodeContext) {
let id = ecx.tcx.sess.derive_registrar_fn.get().unwrap();
let did = ecx.tcx.map.local_def_id(id);
ecx.start_tag(tag_macro_derive_registrar);
ecx.start_tag(root_tag::macro_derive_registrar);
did.index.encode(ecx).unwrap();
ecx.end_tag();
}
@ -1485,7 +1485,7 @@ fn encode_impls(ecx: &mut EncodeContext) {
};
ecx.tcx.map.krate().visit_all_items(&mut visitor);
ecx.start_tag(tag_impls);
ecx.start_tag(root_tag::impls);
for (trait_def_id, trait_impls) in visitor.impls {
// FIXME(eddyb) Avoid wrapping the entries in docs.
ecx.start_tag(0);
@ -1503,7 +1503,7 @@ fn encode_impls(ecx: &mut EncodeContext) {
// symbol associated with them (they weren't translated) or if they're an FFI
// definition (as that's not defined in this crate).
fn encode_reachable(ecx: &mut EncodeContext) {
ecx.start_tag(tag_reachable_ids);
ecx.start_tag(root_tag::reachable_ids);
let reachable = ecx.reachable;
ecx.seq(reachable, |ecx, &id| ecx.tcx.map.local_def_id(id).index);
@ -1512,7 +1512,7 @@ fn encode_reachable(ecx: &mut EncodeContext) {
}
fn encode_dylib_dependency_formats(ecx: &mut EncodeContext) {
ecx.start_tag(tag_dylib_dependency_formats);
ecx.start_tag(root_tag::dylib_dependency_formats);
match ecx.tcx.sess.dependency_formats.borrow().get(&config::CrateTypeDylib) {
Some(arr) => {
ecx.seq(arr, |_, slot| {
@ -1596,30 +1596,30 @@ pub fn encode_metadata<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
}
fn encode_metadata_inner(ecx: &mut EncodeContext) {
ecx.wr_tagged_str(tag_rustc_version, &rustc_version());
ecx.wr_tagged_str(root_tag::rustc_version, &rustc_version());
let tcx = ecx.tcx;
let link_meta = ecx.link_meta;
ecx.start_tag(tag_crate_crate_name);
ecx.start_tag(root_tag::crate_crate_name);
link_meta.crate_name.encode(ecx).unwrap();
ecx.end_tag();
ecx.start_tag(tag_crate_triple);
ecx.start_tag(root_tag::crate_triple);
tcx.sess.opts.target_triple.encode(ecx).unwrap();
ecx.end_tag();
ecx.start_tag(tag_crate_hash);
ecx.start_tag(root_tag::crate_hash);
link_meta.crate_hash.encode(ecx).unwrap();
ecx.end_tag();
ecx.start_tag(tag_crate_disambiguator);
ecx.start_tag(root_tag::crate_disambiguator);
tcx.sess.local_crate_disambiguator().encode(ecx).unwrap();
ecx.end_tag();
encode_dylib_dependency_formats(ecx);
ecx.start_tag(tag_panic_strategy);
ecx.start_tag(root_tag::panic_strategy);
ecx.tcx.sess.opts.cg.panic.encode(ecx);
ecx.end_tag();
@ -1663,11 +1663,9 @@ fn encode_metadata_inner(ecx: &mut EncodeContext) {
let reachable_bytes = ecx.position() - i;
// Encode and index the items.
ecx.start_tag(tag_items);
i = ecx.position();
let items = encode_info_for_items(ecx);
let item_bytes = ecx.position() - i;
ecx.end_tag();
i = ecx.position();
encode_item_index(ecx, items);

4
src/librustc_metadata/index_builder.rs
View file

@ -55,7 +55,6 @@
//! give a callback fn, rather than taking a closure: it allows us to
//! easily control precisely what data is given to that fn.
use common::tag_items_data_item;
use encoder::EncodeContext;
use index::IndexData;
use rustc::dep_graph::DepNode;
@ -120,7 +119,8 @@ impl<'a, 'b, 'tcx> IndexBuilder<'a, 'b, 'tcx> {
let position = self.ecx.mark_stable_position();
self.items.record(id, position);
let _task = self.tcx.dep_graph.in_task(DepNode::MetaData(id));
self.ecx.start_tag(tag_items_data_item).unwrap();
// FIXME(eddyb) Avoid wrapping the entries in docs.
self.ecx.start_tag(0).unwrap();
data.read(self.tcx);
op(&mut self.ecx, data);
self.ecx.end_tag().unwrap();