// 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),
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
-
-// GAP 0x7c
-pub const tag_mod_children: usize = 0x7b;
-
-// GAP 0x108 // top-level only
+// 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
-
// 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 {}",
)
}
-pub const tag_panic_strategy: usize = 0x114;
-
-pub const tag_macro_derive_registrar: usize = 0x115;
+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;
+}
-// 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.
}
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()
}
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()
}
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);
}
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()
})
}
{
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,
}
}
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),
}).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| {
}
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()
-> 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,
-> 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,
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()
})
}
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()
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(
-> 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()
})
}
-> 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()
}
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
};
};
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,
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,
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
-> 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);
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);
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,
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,
}))
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()
-> 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 {
}
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| {
}
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.
}
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 {
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())
}
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() {
};
// 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);
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;
}
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);
}
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 {
}
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() {
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())
}
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 {
}
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);
}
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
}
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()
}
}
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();
}
// 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();
}
}
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();
}
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)
});
} 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();
}
}
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();
}
// 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();
}
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,
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();
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();
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();
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();
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();
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 {
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();
}
// 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()
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();
});
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();
});
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 {
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();
}
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)
});
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())
});
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();
}
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);
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();
.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)
_ => 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();
});
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();
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();
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);
}
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();
}
// 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())
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();
}
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();
}
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();
}
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();
}
/// 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)
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();
}
};
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);
// 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);
}
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| {
}
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();
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);
//! 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;
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();
projects / rust.git / commitdiff