src/librustc_metadata/decoder.rs

   1 // Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 // Decoding metadata from a single crate's metadata
  12
  13 #![allow(non_camel_case_types)]
  14
  15 use self::Family::*;
  16
  17 use astencode::decode_inlined_item;
  18 use cstore::{self, CrateMetadata};
  19 use common::*;
  20 use def_key;
  21 use encoder::def_to_u64;
  22 use index;
  23 use tls_context;
  24 use tydecode::TyDecoder;
  25
  26 use rustc::hir::svh::Svh;
  27 use rustc::hir::map as hir_map;
  28 use rustc::hir::map::DefKey;
  29 use rustc::util::nodemap::FnvHashMap;
  30 use rustc::hir;
  31 use rustc::session::config::PanicStrategy;
  32
  33 use middle::cstore::{InlinedItem, LinkagePreference};
  34 use middle::cstore::{DefLike, DlDef, DlField, DlImpl, tls};
  35 use rustc::hir::def::Def;
  36 use rustc::hir::def_id::{DefId, DefIndex};
  37 use middle::lang_items;
  38 use rustc::ty::{ImplContainer, TraitContainer};
  39 use rustc::ty::{self, Ty, TyCtxt, TypeFoldable, VariantKind};
  40
  41 use rustc_const_math::ConstInt;
  42
  43 use rustc::mir;
  44 use rustc::mir::visit::MutVisitor;
  45 use rustc::mir::repr::Location;
  46
  47 use std::cell::Cell;
  48 use std::io;
  49 use std::rc::Rc;
  50 use std::str;
  51
  52 use rbml::reader;
  53 use rbml;
  54 use rustc_serialize::Decodable;
  55 use syntax::attr;
  56 use syntax::parse::token;
  57 use syntax::ast;
  58 use syntax::codemap;
  59 use syntax::print::pprust;
  60 use syntax_pos::{self, Span, BytePos, NO_EXPANSION};
  61
  62 pub type Cmd<'a> = &'a CrateMetadata;
  63
  64 impl CrateMetadata {
  65     fn get_item(&self, item_id: DefIndex) -> Option<rbml::Doc> {
  66         self.index.lookup_item(self.data(), item_id).map(|pos| {
  67             reader::doc_at(self.data(), pos as usize).unwrap().doc
  68         })
  69     }
  70
  71     fn lookup_item(&self, item_id: DefIndex) -> rbml::Doc {
  72         match self.get_item(item_id) {
  73             None => bug!("lookup_item: id not found: {:?} in crate {:?} with number {}",
  74                          item_id,
  75                          self.name,
  76                          self.cnum),
  77             Some(d) => d
  78         }
  79     }
  80 }
  81
  82 pub fn load_index(data: &[u8]) -> index::Index {
  83     let index = reader::get_doc(rbml::Doc::new(data), tag_index);
  84     index::Index::from_rbml(index)
  85 }
  86
  87 pub fn crate_rustc_version(data: &[u8]) -> Option<String> {
  88     let doc = rbml::Doc::new(data);
  89     reader::maybe_get_doc(doc, tag_rustc_version).map(|s| s.to_string())
  90 }
  91
  92 pub fn load_xrefs(data: &[u8]) -> index::DenseIndex {
  93     let index = reader::get_doc(rbml::Doc::new(data), tag_xref_index);
  94     index::DenseIndex::from_buf(index.data, index.start, index.end)
  95 }
  96
  97 // Go through each item in the metadata and create a map from that
  98 // item's def-key to the item's DefIndex.
  99 pub fn load_key_map(data: &[u8]) -> FnvHashMap<DefKey, DefIndex> {
 100     let root_doc = rbml::Doc::new(data);
 101     let items_doc = reader::get_doc(root_doc, tag_items);
 102     let items_data_doc = reader::get_doc(items_doc, tag_items_data);
 103     reader::docs(items_data_doc)
 104         .filter(|&(tag, _)| tag == tag_items_data_item)
 105         .map(|(_, item_doc)| {
 106             // load def-key from item
 107             let key = item_def_key(item_doc);
 108
 109             // load def-index from item; we only encode the full def-id,
 110             // so just pull out the index
 111             let def_id_doc = reader::get_doc(item_doc, tag_def_id);
 112             let def_id = untranslated_def_id(def_id_doc);
 113             assert!(def_id.is_local()); // local to the crate we are decoding, that is
 114
 115             (key, def_id.index)
 116         })
 117         .collect()
 118 }
 119
 120 #[derive(Clone, Copy, Debug, PartialEq)]
 121 enum Family {
 122     ImmStatic,             // c
 123     MutStatic,             // b
 124     Fn,                    // f
 125     StaticMethod,          // F
 126     Method,                // h
 127     Type,                  // y
 128     Mod,                   // m
 129     ForeignMod,            // n
 130     Enum,                  // t
 131     Variant(VariantKind),  // V, v, w
 132     Impl,                  // i
 133     DefaultImpl,           // d
 134     Trait,                 // I
 135     Struct(VariantKind),   // S, s, u
 136     PublicField,           // g
 137     InheritedField,        // N
 138     Constant,              // C
 139 }
 140
 141 fn item_family(item: rbml::Doc) -> Family {
 142     let fam = reader::get_doc(item, tag_items_data_item_family);
 143     match reader::doc_as_u8(fam) as char {
 144       'C' => Constant,
 145       'c' => ImmStatic,
 146       'b' => MutStatic,
 147       'f' => Fn,
 148       'F' => StaticMethod,
 149       'h' => Method,
 150       'y' => Type,
 151       'm' => Mod,
 152       'n' => ForeignMod,
 153       't' => Enum,
 154       'V' => Variant(VariantKind::Struct),
 155       'v' => Variant(VariantKind::Tuple),
 156       'w' => Variant(VariantKind::Unit),
 157       'i' => Impl,
 158       'd' => DefaultImpl,
 159       'I' => Trait,
 160       'S' => Struct(VariantKind::Struct),
 161       's' => Struct(VariantKind::Tuple),
 162       'u' => Struct(VariantKind::Unit),
 163       'g' => PublicField,
 164       'N' => InheritedField,
 165        c => bug!("unexpected family char: {}", c)
 166     }
 167 }
 168
 169 fn item_visibility(item: rbml::Doc) -> ty::Visibility {
 170     match reader::maybe_get_doc(item, tag_items_data_item_visibility) {
 171         None => ty::Visibility::Public,
 172         Some(visibility_doc) => {
 173             match reader::doc_as_u8(visibility_doc) as char {
 174                 'y' => ty::Visibility::Public,
 175                 'i' => ty::Visibility::PrivateExternal,
 176                 _ => bug!("unknown visibility character")
 177             }
 178         }
 179     }
 180 }
 181
 182 fn fn_constness(item: rbml::Doc) -> hir::Constness {
 183     match reader::maybe_get_doc(item, tag_items_data_item_constness) {
 184         None => hir::Constness::NotConst,
 185         Some(constness_doc) => {
 186             match reader::doc_as_u8(constness_doc) as char {
 187                 'c' => hir::Constness::Const,
 188                 'n' => hir::Constness::NotConst,
 189                 _ => bug!("unknown constness character")
 190             }
 191         }
 192     }
 193 }
 194
 195 fn item_defaultness(item: rbml::Doc) -> hir::Defaultness {
 196     match reader::maybe_get_doc(item, tag_items_data_item_defaultness) {
 197         None => hir::Defaultness::Default, // should occur only for default impls on traits
 198         Some(defaultness_doc) => {
 199             match reader::doc_as_u8(defaultness_doc) as char {
 200                 'd' => hir::Defaultness::Default,
 201                 'f' => hir::Defaultness::Final,
 202                 _ => bug!("unknown defaultness character")
 203             }
 204         }
 205     }
 206 }
 207
 208 fn item_sort(item: rbml::Doc) -> Option<char> {
 209     reader::tagged_docs(item, tag_item_trait_item_sort).nth(0).map(|doc| {
 210         doc.as_str().as_bytes()[0] as char
 211     })
 212 }
 213
 214 fn untranslated_def_id(d: rbml::Doc) -> DefId {
 215     let id = reader::doc_as_u64(d);
 216     let index = DefIndex::new((id & 0xFFFF_FFFF) as usize);
 217     DefId { krate: (id >> 32) as u32, index: index }
 218 }
 219
 220 fn translated_def_id(cdata: Cmd, d: rbml::Doc) -> DefId {
 221     let def_id = untranslated_def_id(d);
 222     translate_def_id(cdata, def_id)
 223 }
 224
 225 fn item_parent_item(cdata: Cmd, d: rbml::Doc) -> Option<DefId> {
 226     reader::tagged_docs(d, tag_items_data_parent_item).nth(0).map(|did| {
 227         translated_def_id(cdata, did)
 228     })
 229 }
 230
 231 fn item_require_parent_item(cdata: Cmd, d: rbml::Doc) -> DefId {
 232     translated_def_id(cdata, reader::get_doc(d, tag_items_data_parent_item))
 233 }
 234
 235 fn item_def_id(d: rbml::Doc, cdata: Cmd) -> DefId {
 236     translated_def_id(cdata, reader::get_doc(d, tag_def_id))
 237 }
 238
 239 fn reexports<'a>(d: rbml::Doc<'a>) -> reader::TaggedDocsIterator<'a> {
 240     reader::tagged_docs(d, tag_items_data_item_reexport)
 241 }
 242
 243 fn variant_disr_val(d: rbml::Doc) -> u64 {
 244     let val_doc = reader::get_doc(d, tag_disr_val);
 245     reader::with_doc_data(val_doc, |data| {
 246         str::from_utf8(data).unwrap().parse().unwrap()
 247     })
 248 }
 249
 250 fn doc_type<'a, 'tcx>(doc: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>, cdata: Cmd) -> Ty<'tcx> {
 251     let tp = reader::get_doc(doc, tag_items_data_item_type);
 252     TyDecoder::with_doc(tcx, cdata.cnum, tp,
 253                         &mut |did| translate_def_id(cdata, did))
 254         .parse_ty()
 255 }
 256
 257 fn maybe_doc_type<'a, 'tcx>(doc: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>, cdata: Cmd)
 258                             -> Option<Ty<'tcx>> {
 259     reader::maybe_get_doc(doc, tag_items_data_item_type).map(|tp| {
 260         TyDecoder::with_doc(tcx, cdata.cnum, tp,
 261                             &mut |did| translate_def_id(cdata, did))
 262             .parse_ty()
 263     })
 264 }
 265
 266 fn doc_trait_ref<'a, 'tcx>(doc: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>, cdata: Cmd)
 267                            -> ty::TraitRef<'tcx> {
 268     TyDecoder::with_doc(tcx, cdata.cnum, doc,
 269                         &mut |did| translate_def_id(cdata, did))
 270         .parse_trait_ref()
 271 }
 272
 273 fn item_trait_ref<'a, 'tcx>(doc: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>, cdata: Cmd)
 274                             -> ty::TraitRef<'tcx> {
 275     let tp = reader::get_doc(doc, tag_item_trait_ref);
 276     doc_trait_ref(tp, tcx, cdata)
 277 }
 278
 279 fn item_name(item: rbml::Doc) -> ast::Name {
 280     maybe_item_name(item).expect("no item in item_name")
 281 }
 282
 283 fn maybe_item_name(item: rbml::Doc) -> Option<ast::Name> {
 284     reader::maybe_get_doc(item, tag_paths_data_name).map(|name| {
 285         let string = name.as_str();
 286         token::intern(string)
 287     })
 288 }
 289
 290 fn family_to_variant_kind<'tcx>(family: Family) -> Option<ty::VariantKind> {
 291     match family {
 292         Struct(VariantKind::Struct) | Variant(VariantKind::Struct) =>
 293             Some(ty::VariantKind::Struct),
 294         Struct(VariantKind::Tuple) | Variant(VariantKind::Tuple) =>
 295             Some(ty::VariantKind::Tuple),
 296         Struct(VariantKind::Unit) | Variant(VariantKind::Unit) =>
 297             Some(ty::VariantKind::Unit),
 298         _ => None,
 299     }
 300 }
 301
 302 fn item_to_def_like(cdata: Cmd, item: rbml::Doc, did: DefId) -> DefLike {
 303     let fam = item_family(item);
 304     match fam {
 305         Constant  => {
 306             // Check whether we have an associated const item.
 307             match item_sort(item) {
 308                 Some('C') | Some('c') => {
 309                     DlDef(Def::AssociatedConst(did))
 310                 }
 311                 _ => {
 312                     // Regular const item.
 313                     DlDef(Def::Const(did))
 314                 }
 315             }
 316         }
 317         ImmStatic => DlDef(Def::Static(did, false)),
 318         MutStatic => DlDef(Def::Static(did, true)),
 319         Struct(..) => DlDef(Def::Struct(did)),
 320         Fn        => DlDef(Def::Fn(did)),
 321         Method | StaticMethod => {
 322             DlDef(Def::Method(did))
 323         }
 324         Type => {
 325             if item_sort(item) == Some('t') {
 326                 let trait_did = item_require_parent_item(cdata, item);
 327                 DlDef(Def::AssociatedTy(trait_did, did))
 328             } else {
 329                 DlDef(Def::TyAlias(did))
 330             }
 331         }
 332         Mod => DlDef(Def::Mod(did)),
 333         ForeignMod => DlDef(Def::ForeignMod(did)),
 334         Variant(..) => {
 335             let enum_did = item_require_parent_item(cdata, item);
 336             DlDef(Def::Variant(enum_did, did))
 337         }
 338         Trait => DlDef(Def::Trait(did)),
 339         Enum => DlDef(Def::Enum(did)),
 340         Impl | DefaultImpl => DlImpl(did),
 341         PublicField | InheritedField => DlField,
 342     }
 343 }
 344
 345 fn parse_unsafety(item_doc: rbml::Doc) -> hir::Unsafety {
 346     let unsafety_doc = reader::get_doc(item_doc, tag_unsafety);
 347     if reader::doc_as_u8(unsafety_doc) != 0 {
 348         hir::Unsafety::Unsafe
 349     } else {
 350         hir::Unsafety::Normal
 351     }
 352 }
 353
 354 fn parse_paren_sugar(item_doc: rbml::Doc) -> bool {
 355     let paren_sugar_doc = reader::get_doc(item_doc, tag_paren_sugar);
 356     reader::doc_as_u8(paren_sugar_doc) != 0
 357 }
 358
 359 fn parse_polarity(item_doc: rbml::Doc) -> hir::ImplPolarity {
 360     let polarity_doc = reader::get_doc(item_doc, tag_polarity);
 361     if reader::doc_as_u8(polarity_doc) != 0 {
 362         hir::ImplPolarity::Negative
 363     } else {
 364         hir::ImplPolarity::Positive
 365     }
 366 }
 367
 368 fn parse_associated_type_names(item_doc: rbml::Doc) -> Vec<ast::Name> {
 369     let names_doc = reader::get_doc(item_doc, tag_associated_type_names);
 370     reader::tagged_docs(names_doc, tag_associated_type_name)
 371         .map(|name_doc| token::intern(name_doc.as_str()))
 372         .collect()
 373 }
 374
 375 pub fn get_trait_def<'a, 'tcx>(cdata: Cmd,
 376                                item_id: DefIndex,
 377                                tcx: TyCtxt<'a, 'tcx, 'tcx>) -> ty::TraitDef<'tcx>
 378 {
 379     let item_doc = cdata.lookup_item(item_id);
 380     let generics = doc_generics(item_doc, tcx, cdata);
 381     let unsafety = parse_unsafety(item_doc);
 382     let associated_type_names = parse_associated_type_names(item_doc);
 383     let paren_sugar = parse_paren_sugar(item_doc);
 384
 385     ty::TraitDef::new(unsafety,
 386                       paren_sugar,
 387                       generics,
 388                       item_trait_ref(item_doc, tcx, cdata),
 389                       associated_type_names)
 390 }
 391
 392 pub fn get_adt_def<'a, 'tcx>(cdata: Cmd,
 393                              item_id: DefIndex,
 394                              tcx: TyCtxt<'a, 'tcx, 'tcx>)
 395                              -> ty::AdtDefMaster<'tcx>
 396 {
 397     fn expect_variant_kind(family: Family) -> ty::VariantKind {
 398         match family_to_variant_kind(family) {
 399             Some(kind) => kind,
 400             _ => bug!("unexpected family: {:?}", family),
 401         }
 402     }
 403     fn get_enum_variants<'tcx>(cdata: Cmd, doc: rbml::Doc) -> Vec<ty::VariantDefData<'tcx, 'tcx>> {
 404         reader::tagged_docs(doc, tag_items_data_item_variant).map(|p| {
 405             let did = translated_def_id(cdata, p);
 406             let item = cdata.lookup_item(did.index);
 407             let disr = variant_disr_val(item);
 408             ty::VariantDefData {
 409                 did: did,
 410                 name: item_name(item),
 411                 fields: get_variant_fields(cdata, item),
 412                 disr_val: ConstInt::Infer(disr),
 413                 kind: expect_variant_kind(item_family(item)),
 414             }
 415         }).collect()
 416     }
 417     fn get_variant_fields<'tcx>(cdata: Cmd, doc: rbml::Doc) -> Vec<ty::FieldDefData<'tcx, 'tcx>> {
 418         let mut index = 0;
 419         reader::tagged_docs(doc, tag_item_field).map(|f| {
 420             let ff = item_family(f);
 421             match ff {
 422                 PublicField | InheritedField => {},
 423                 _ => bug!("expected field, found {:?}", ff)
 424             };
 425             ty::FieldDefData::new(item_def_id(f, cdata),
 426                                   item_name(f),
 427                                   struct_field_family_to_visibility(ff))
 428         }).chain(reader::tagged_docs(doc, tag_item_unnamed_field).map(|f| {
 429             let ff = item_family(f);
 430             let name = token::with_ident_interner(|interner| interner.intern(index.to_string()));
 431             index += 1;
 432             ty::FieldDefData::new(item_def_id(f, cdata), name,
 433                                   struct_field_family_to_visibility(ff))
 434         })).collect()
 435     }
 436     fn get_struct_variant<'tcx>(cdata: Cmd,
 437                                 doc: rbml::Doc,
 438                                 did: DefId) -> ty::VariantDefData<'tcx, 'tcx> {
 439         ty::VariantDefData {
 440             did: did,
 441             name: item_name(doc),
 442             fields: get_variant_fields(cdata, doc),
 443             disr_val: ConstInt::Infer(0),
 444             kind: expect_variant_kind(item_family(doc)),
 445         }
 446     }
 447
 448     let doc = cdata.lookup_item(item_id);
 449     let did = DefId { krate: cdata.cnum, index: item_id };
 450     let mut ctor_did = None;
 451     let (kind, variants) = match item_family(doc) {
 452         Enum => {
 453             (ty::AdtKind::Enum,
 454              get_enum_variants(cdata, doc))
 455         }
 456         Struct(..) => {
 457             // Use separate constructor id for unit/tuple structs and reuse did for braced structs.
 458             ctor_did = reader::maybe_get_doc(doc, tag_items_data_item_struct_ctor).map(|ctor_doc| {
 459                 translated_def_id(cdata, ctor_doc)
 460             });
 461             (ty::AdtKind::Struct,
 462              vec![get_struct_variant(cdata, doc, ctor_did.unwrap_or(did))])
 463         }
 464         _ => bug!("get_adt_def called on a non-ADT {:?} - {:?}",
 465                   item_family(doc), did)
 466     };
 467
 468     let adt = tcx.intern_adt_def(did, kind, variants);
 469     if let Some(ctor_did) = ctor_did {
 470         // Make adt definition available through constructor id as well.
 471         tcx.insert_adt_def(ctor_did, adt);
 472     }
 473
 474     // this needs to be done *after* the variant is interned,
 475     // to support recursive structures
 476     for variant in &adt.variants {
 477         if variant.kind == ty::VariantKind::Tuple &&
 478             adt.adt_kind() == ty::AdtKind::Enum {
 479             // tuple-like enum variant fields aren't real items - get the types
 480             // from the ctor.
 481             debug!("evaluating the ctor-type of {:?}",
 482                    variant.name);
 483             let ctor_ty = get_type(cdata, variant.did.index, tcx);
 484             debug!("evaluating the ctor-type of {:?}.. {:?}",
 485                    variant.name,
 486                    ctor_ty);
 487             let field_tys = match ctor_ty.sty {
 488                 ty::TyFnDef(_, _, &ty::BareFnTy { sig: ty::Binder(ty::FnSig {
 489                     ref inputs, ..
 490                 }), ..}) => {
 491                     // tuple-struct constructors don't have escaping regions
 492                     assert!(!inputs.has_escaping_regions());
 493                     inputs
 494                 },
 495                 _ => bug!("tuple-variant ctor is not an ADT")
 496             };
 497             for (field, &ty) in variant.fields.iter().zip(field_tys.iter()) {
 498                 field.fulfill_ty(ty);
 499             }
 500         } else {
 501             for field in &variant.fields {
 502                 debug!("evaluating the type of {:?}::{:?}", variant.name, field.name);
 503                 let ty = get_type(cdata, field.did.index, tcx);
 504                 field.fulfill_ty(ty);
 505                 debug!("evaluating the type of {:?}::{:?}: {:?}",
 506                        variant.name, field.name, ty);
 507             }
 508         }
 509     }
 510
 511     adt
 512 }
 513
 514 pub fn get_predicates<'a, 'tcx>(cdata: Cmd,
 515                                 item_id: DefIndex,
 516                                 tcx: TyCtxt<'a, 'tcx, 'tcx>)
 517                                 -> ty::GenericPredicates<'tcx>
 518 {
 519     let item_doc = cdata.lookup_item(item_id);
 520     doc_predicates(item_doc, tcx, cdata, tag_item_predicates)
 521 }
 522
 523 pub fn get_super_predicates<'a, 'tcx>(cdata: Cmd,
 524                                       item_id: DefIndex,
 525                                       tcx: TyCtxt<'a, 'tcx, 'tcx>)
 526                                       -> ty::GenericPredicates<'tcx>
 527 {
 528     let item_doc = cdata.lookup_item(item_id);
 529     doc_predicates(item_doc, tcx, cdata, tag_item_super_predicates)
 530 }
 531
 532 pub fn get_generics<'a, 'tcx>(cdata: Cmd,
 533                               item_id: DefIndex,
 534                               tcx: TyCtxt<'a, 'tcx, 'tcx>)
 535                               -> &'tcx ty::Generics<'tcx>
 536 {
 537     let item_doc = cdata.lookup_item(item_id);
 538     doc_generics(item_doc, tcx, cdata)
 539 }
 540
 541 pub fn get_type<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
 542                           -> Ty<'tcx>
 543 {
 544     let item_doc = cdata.lookup_item(id);
 545     doc_type(item_doc, tcx, cdata)
 546 }
 547
 548 pub fn get_stability(cdata: Cmd, id: DefIndex) -> Option<attr::Stability> {
 549     let item = cdata.lookup_item(id);
 550     reader::maybe_get_doc(item, tag_items_data_item_stability).map(|doc| {
 551         let mut decoder = reader::Decoder::new(doc);
 552         Decodable::decode(&mut decoder).unwrap()
 553     })
 554 }
 555
 556 pub fn get_deprecation(cdata: Cmd, id: DefIndex) -> Option<attr::Deprecation> {
 557     let item = cdata.lookup_item(id);
 558     reader::maybe_get_doc(item, tag_items_data_item_deprecation).map(|doc| {
 559         let mut decoder = reader::Decoder::new(doc);
 560         Decodable::decode(&mut decoder).unwrap()
 561     })
 562 }
 563
 564 pub fn get_visibility(cdata: Cmd, id: DefIndex) -> ty::Visibility {
 565     item_visibility(cdata.lookup_item(id))
 566 }
 567
 568 pub fn get_parent_impl(cdata: Cmd, id: DefIndex) -> Option<DefId> {
 569     let item = cdata.lookup_item(id);
 570     reader::maybe_get_doc(item, tag_items_data_parent_impl).map(|doc| {
 571         translated_def_id(cdata, doc)
 572     })
 573 }
 574
 575 pub fn get_repr_attrs(cdata: Cmd, id: DefIndex) -> Vec<attr::ReprAttr> {
 576     let item = cdata.lookup_item(id);
 577     match reader::maybe_get_doc(item, tag_items_data_item_repr).map(|doc| {
 578         let mut decoder = reader::Decoder::new(doc);
 579         Decodable::decode(&mut decoder).unwrap()
 580     }) {
 581         Some(attrs) => attrs,
 582         None => Vec::new(),
 583     }
 584 }
 585
 586 pub fn get_impl_polarity<'tcx>(cdata: Cmd,
 587                                id: DefIndex)
 588                                -> Option<hir::ImplPolarity>
 589 {
 590     let item_doc = cdata.lookup_item(id);
 591     let fam = item_family(item_doc);
 592     match fam {
 593         Family::Impl => {
 594             Some(parse_polarity(item_doc))
 595         }
 596         _ => None
 597     }
 598 }
 599
 600 pub fn get_custom_coerce_unsized_kind<'tcx>(
 601     cdata: Cmd,
 602     id: DefIndex)
 603     -> Option<ty::adjustment::CustomCoerceUnsized>
 604 {
 605     let item_doc = cdata.lookup_item(id);
 606     reader::maybe_get_doc(item_doc, tag_impl_coerce_unsized_kind).map(|kind_doc| {
 607         let mut decoder = reader::Decoder::new(kind_doc);
 608         Decodable::decode(&mut decoder).unwrap()
 609     })
 610 }
 611
 612 pub fn get_impl_trait<'a, 'tcx>(cdata: Cmd,
 613                                 id: DefIndex,
 614                                 tcx: TyCtxt<'a, 'tcx, 'tcx>)
 615                                 -> Option<ty::TraitRef<'tcx>>
 616 {
 617     let item_doc = cdata.lookup_item(id);
 618     let fam = item_family(item_doc);
 619     match fam {
 620         Family::Impl | Family::DefaultImpl => {
 621             reader::maybe_get_doc(item_doc, tag_item_trait_ref).map(|tp| {
 622                 doc_trait_ref(tp, tcx, cdata)
 623             })
 624         }
 625         _ => None
 626     }
 627 }
 628
 629 /// Iterates over the language items in the given crate.
 630 pub fn each_lang_item<F>(cdata: Cmd, mut f: F) -> bool where
 631     F: FnMut(DefIndex, usize) -> bool,
 632 {
 633     let root = rbml::Doc::new(cdata.data());
 634     let lang_items = reader::get_doc(root, tag_lang_items);
 635     reader::tagged_docs(lang_items, tag_lang_items_item).all(|item_doc| {
 636         let id_doc = reader::get_doc(item_doc, tag_lang_items_item_id);
 637         let id = reader::doc_as_u32(id_doc) as usize;
 638         let index_doc = reader::get_doc(item_doc, tag_lang_items_item_index);
 639         let index = DefIndex::from_u32(reader::doc_as_u32(index_doc));
 640
 641         f(index, id)
 642     })
 643 }
 644
 645 fn each_child_of_item_or_crate<F, G>(cdata: Cmd,
 646                                      item_doc: rbml::Doc,
 647                                      mut get_crate_data: G,
 648                                      mut callback: F) where
 649     F: FnMut(DefLike, ast::Name, ty::Visibility),
 650     G: FnMut(ast::CrateNum) -> Rc<CrateMetadata>,
 651 {
 652     // Iterate over all children.
 653     for child_info_doc in reader::tagged_docs(item_doc, tag_mod_child) {
 654         let child_def_id = translated_def_id(cdata, child_info_doc);
 655
 656         // This item may be in yet another crate if it was the child of a
 657         // reexport.
 658         let crate_data = if child_def_id.krate == cdata.cnum {
 659             None
 660         } else {
 661             Some(get_crate_data(child_def_id.krate))
 662         };
 663         let crate_data = match crate_data {
 664             Some(ref cdata) => &**cdata,
 665             None => cdata
 666         };
 667
 668         // Get the item.
 669         if let Some(child_item_doc) = crate_data.get_item(child_def_id.index) {
 670             // Hand off the item to the callback.
 671             let child_name = item_name(child_item_doc);
 672             let def_like = item_to_def_like(crate_data, child_item_doc, child_def_id);
 673             let visibility = item_visibility(child_item_doc);
 674             callback(def_like, child_name, visibility);
 675         }
 676     }
 677
 678     for reexport_doc in reexports(item_doc) {
 679         let def_id_doc = reader::get_doc(reexport_doc,
 680                                          tag_items_data_item_reexport_def_id);
 681         let child_def_id = translated_def_id(cdata, def_id_doc);
 682
 683         let name_doc = reader::get_doc(reexport_doc,
 684                                        tag_items_data_item_reexport_name);
 685         let name = name_doc.as_str();
 686
 687         // This reexport may be in yet another crate.
 688         let crate_data = if child_def_id.krate == cdata.cnum {
 689             None
 690         } else {
 691             Some(get_crate_data(child_def_id.krate))
 692         };
 693         let crate_data = match crate_data {
 694             Some(ref cdata) => &**cdata,
 695             None => cdata
 696         };
 697
 698         // Get the item.
 699         if let Some(child_item_doc) = crate_data.get_item(child_def_id.index) {
 700             // Hand off the item to the callback.
 701             let def_like = item_to_def_like(crate_data, child_item_doc, child_def_id);
 702             // These items have a public visibility because they're part of
 703             // a public re-export.
 704             callback(def_like, token::intern(name), ty::Visibility::Public);
 705         }
 706     }
 707 }
 708
 709 /// Iterates over each child of the given item.
 710 pub fn each_child_of_item<F, G>(cdata: Cmd, id: DefIndex, get_crate_data: G, callback: F)
 711     where F: FnMut(DefLike, ast::Name, ty::Visibility),
 712           G: FnMut(ast::CrateNum) -> Rc<CrateMetadata>,
 713 {
 714     // Find the item.
 715     let item_doc = match cdata.get_item(id) {
 716         None => return,
 717         Some(item_doc) => item_doc,
 718     };
 719
 720     each_child_of_item_or_crate(cdata, item_doc, get_crate_data, callback)
 721 }
 722
 723 /// Iterates over all the top-level crate items.
 724 pub fn each_top_level_item_of_crate<F, G>(cdata: Cmd, get_crate_data: G, callback: F)
 725     where F: FnMut(DefLike, ast::Name, ty::Visibility),
 726           G: FnMut(ast::CrateNum) -> Rc<CrateMetadata>,
 727 {
 728     let root_doc = rbml::Doc::new(cdata.data());
 729     let misc_info_doc = reader::get_doc(root_doc, tag_misc_info);
 730     let crate_items_doc = reader::get_doc(misc_info_doc,
 731                                           tag_misc_info_crate_items);
 732
 733     each_child_of_item_or_crate(cdata,
 734                                 crate_items_doc,
 735                                 get_crate_data,
 736                                 callback)
 737 }
 738
 739 pub fn get_item_name(cdata: Cmd, id: DefIndex) -> ast::Name {
 740     item_name(cdata.lookup_item(id))
 741 }
 742
 743 pub fn maybe_get_item_name(cdata: Cmd, id: DefIndex) -> Option<ast::Name> {
 744     maybe_item_name(cdata.lookup_item(id))
 745 }
 746
 747 pub enum FoundAst<'ast> {
 748     Found(&'ast InlinedItem),
 749     FoundParent(DefId, &'ast hir::Item),
 750     NotFound,
 751 }
 752
 753 pub fn maybe_get_item_ast<'a, 'tcx>(cdata: Cmd, tcx: TyCtxt<'a, 'tcx, 'tcx>, id: DefIndex)
 754                                     -> FoundAst<'tcx> {
 755     debug!("Looking up item: {:?}", id);
 756     let item_doc = cdata.lookup_item(id);
 757     let item_did = item_def_id(item_doc, cdata);
 758     let parent_def_id = DefId {
 759         krate: cdata.cnum,
 760         index: def_key(cdata, id).parent.unwrap()
 761     };
 762     let mut parent_def_path = def_path(cdata, id);
 763     parent_def_path.data.pop();
 764     if let Some(ast_doc) = reader::maybe_get_doc(item_doc, tag_ast as usize) {
 765         let ii = decode_inlined_item(cdata,
 766                                      tcx,
 767                                      parent_def_path,
 768                                      parent_def_id,
 769                                      ast_doc,
 770                                      item_did);
 771         return FoundAst::Found(ii);
 772     } else if let Some(parent_did) = item_parent_item(cdata, item_doc) {
 773         // Remove the last element from the paths, since we are now
 774         // trying to inline the parent.
 775         let grandparent_def_id = DefId {
 776             krate: cdata.cnum,
 777             index: def_key(cdata, parent_def_id.index).parent.unwrap()
 778         };
 779         let mut grandparent_def_path = parent_def_path;
 780         grandparent_def_path.data.pop();
 781         let parent_doc = cdata.lookup_item(parent_did.index);
 782         if let Some(ast_doc) = reader::maybe_get_doc(parent_doc, tag_ast as usize) {
 783             let ii = decode_inlined_item(cdata,
 784                                          tcx,
 785                                          grandparent_def_path,
 786                                          grandparent_def_id,
 787                                          ast_doc,
 788                                          parent_did);
 789             if let &InlinedItem::Item(_, ref i) = ii {
 790                 return FoundAst::FoundParent(parent_did, i);
 791             }
 792         }
 793     }
 794     FoundAst::NotFound
 795 }
 796
 797 pub fn is_item_mir_available<'tcx>(cdata: Cmd, id: DefIndex) -> bool {
 798     if let Some(item_doc) = cdata.get_item(id) {
 799         return reader::maybe_get_doc(item_doc, tag_mir as usize).is_some();
 800     }
 801
 802     false
 803 }
 804
 805 pub fn maybe_get_item_mir<'a, 'tcx>(cdata: Cmd,
 806                                     tcx: TyCtxt<'a, 'tcx, 'tcx>,
 807                                     id: DefIndex)
 808                                     -> Option<mir::repr::Mir<'tcx>> {
 809     let item_doc = cdata.lookup_item(id);
 810
 811     return reader::maybe_get_doc(item_doc, tag_mir as usize).map(|mir_doc| {
 812         let dcx = tls_context::DecodingContext {
 813             crate_metadata: cdata,
 814             tcx: tcx,
 815         };
 816         let mut decoder = reader::Decoder::new(mir_doc);
 817
 818         let mut mir = decoder.read_opaque(|opaque_decoder, _| {
 819             tls::enter_decoding_context(&dcx, opaque_decoder, |_, opaque_decoder| {
 820                 Decodable::decode(opaque_decoder)
 821             })
 822         }).unwrap();
 823
 824         assert!(decoder.position() == mir_doc.end);
 825
 826         let mut def_id_and_span_translator = MirDefIdAndSpanTranslator {
 827             crate_metadata: cdata,
 828             codemap: tcx.sess.codemap(),
 829             last_filemap_index_hint: Cell::new(0),
 830         };
 831
 832         def_id_and_span_translator.visit_mir(&mut mir);
 833         for promoted in &mut mir.promoted {
 834             def_id_and_span_translator.visit_mir(promoted);
 835         }
 836
 837         mir
 838     });
 839
 840     struct MirDefIdAndSpanTranslator<'cdata, 'codemap> {
 841         crate_metadata: Cmd<'cdata>,
 842         codemap: &'codemap codemap::CodeMap,
 843         last_filemap_index_hint: Cell<usize>
 844     }
 845
 846     impl<'v, 'cdata, 'codemap> mir::visit::MutVisitor<'v>
 847         for MirDefIdAndSpanTranslator<'cdata, 'codemap>
 848     {
 849         fn visit_def_id(&mut self, def_id: &mut DefId, _: Location) {
 850             *def_id = translate_def_id(self.crate_metadata, *def_id);
 851         }
 852
 853         fn visit_span(&mut self, span: &mut Span) {
 854             *span = translate_span(self.crate_metadata,
 855                                    self.codemap,
 856                                    &self.last_filemap_index_hint,
 857                                    *span);
 858         }
 859     }
 860 }
 861
 862 fn get_explicit_self<'a, 'tcx>(item: rbml::Doc, tcx: TyCtxt<'a, 'tcx, 'tcx>)
 863                                -> ty::ExplicitSelfCategory<'tcx> {
 864     fn get_mutability(ch: u8) -> hir::Mutability {
 865         match ch as char {
 866             'i' => hir::MutImmutable,
 867             'm' => hir::MutMutable,
 868             _ => bug!("unknown mutability character: `{}`", ch as char),
 869         }
 870     }
 871
 872     let explicit_self_doc = reader::get_doc(item, tag_item_trait_method_explicit_self);
 873     let string = explicit_self_doc.as_str();
 874
 875     let explicit_self_kind = string.as_bytes()[0];
 876     match explicit_self_kind as char {
 877         's' => ty::ExplicitSelfCategory::Static,
 878         'v' => ty::ExplicitSelfCategory::ByValue,
 879         '~' => ty::ExplicitSelfCategory::ByBox,
 880         // FIXME(#4846) expl. region
 881         '&' => {
 882             ty::ExplicitSelfCategory::ByReference(
 883                 tcx.mk_region(ty::ReEmpty),
 884                 get_mutability(string.as_bytes()[1]))
 885         }
 886         _ => bug!("unknown self type code: `{}`", explicit_self_kind as char)
 887     }
 888 }
 889
 890 /// Returns the def IDs of all the items in the given implementation.
 891 pub fn get_impl_items(cdata: Cmd, impl_id: DefIndex)
 892                       -> Vec<ty::ImplOrTraitItemId> {
 893     reader::tagged_docs(cdata.lookup_item(impl_id), tag_item_impl_item).map(|doc| {
 894         let def_id = item_def_id(doc, cdata);
 895         match item_sort(doc) {
 896             Some('C') | Some('c') => ty::ConstTraitItemId(def_id),
 897             Some('r') | Some('p') => ty::MethodTraitItemId(def_id),
 898             Some('t') => ty::TypeTraitItemId(def_id),
 899             _ => bug!("unknown impl item sort"),
 900         }
 901     }).collect()
 902 }
 903
 904 pub fn get_trait_name(cdata: Cmd, id: DefIndex) -> ast::Name {
 905     let doc = cdata.lookup_item(id);
 906     item_name(doc)
 907 }
 908
 909 pub fn get_impl_or_trait_item<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
 910                                         -> Option<ty::ImplOrTraitItem<'tcx>> {
 911     let item_doc = cdata.lookup_item(id);
 912
 913     let def_id = item_def_id(item_doc, cdata);
 914
 915     let container_id = if let Some(id) = item_parent_item(cdata, item_doc) {
 916         id
 917     } else {
 918         return None;
 919     };
 920     let container_doc = cdata.lookup_item(container_id.index);
 921     let container = match item_family(container_doc) {
 922         Trait => TraitContainer(container_id),
 923         _ => ImplContainer(container_id),
 924     };
 925
 926     let name = item_name(item_doc);
 927     let vis = item_visibility(item_doc);
 928     let defaultness = item_defaultness(item_doc);
 929
 930     Some(match item_sort(item_doc) {
 931         sort @ Some('C') | sort @ Some('c') => {
 932             let ty = doc_type(item_doc, tcx, cdata);
 933             ty::ConstTraitItem(Rc::new(ty::AssociatedConst {
 934                 name: name,
 935                 ty: ty,
 936                 vis: vis,
 937                 defaultness: defaultness,
 938                 def_id: def_id,
 939                 container: container,
 940                 has_value: sort == Some('C')
 941             }))
 942         }
 943         Some('r') | Some('p') => {
 944             let generics = doc_generics(item_doc, tcx, cdata);
 945             let predicates = doc_predicates(item_doc, tcx, cdata, tag_item_predicates);
 946             let ity = tcx.lookup_item_type(def_id).ty;
 947             let fty = match ity.sty {
 948                 ty::TyFnDef(_, _, fty) => fty,
 949                 _ => bug!(
 950                     "the type {:?} of the method {:?} is not a function?",
 951                     ity, name)
 952             };
 953             let explicit_self = get_explicit_self(item_doc, tcx);
 954
 955             ty::MethodTraitItem(Rc::new(ty::Method::new(name,
 956                                                         generics,
 957                                                         predicates,
 958                                                         fty,
 959                                                         explicit_self,
 960                                                         vis,
 961                                                         defaultness,
 962                                                         def_id,
 963                                                         container)))
 964         }
 965         Some('t') => {
 966             let ty = maybe_doc_type(item_doc, tcx, cdata);
 967             ty::TypeTraitItem(Rc::new(ty::AssociatedType {
 968                 name: name,
 969                 ty: ty,
 970                 vis: vis,
 971                 defaultness: defaultness,
 972                 def_id: def_id,
 973                 container: container,
 974             }))
 975         }
 976         _ => return None
 977     })
 978 }
 979
 980 pub fn get_trait_item_def_ids(cdata: Cmd, id: DefIndex)
 981                               -> Vec<ty::ImplOrTraitItemId> {
 982     let item = cdata.lookup_item(id);
 983     reader::tagged_docs(item, tag_item_trait_item).map(|mth| {
 984         let def_id = item_def_id(mth, cdata);
 985         match item_sort(mth) {
 986             Some('C') | Some('c') => ty::ConstTraitItemId(def_id),
 987             Some('r') | Some('p') => ty::MethodTraitItemId(def_id),
 988             Some('t') => ty::TypeTraitItemId(def_id),
 989             _ => bug!("unknown trait item sort"),
 990         }
 991     }).collect()
 992 }
 993
 994 pub fn get_item_variances(cdata: Cmd, id: DefIndex) -> Vec<ty::Variance> {
 995     let item_doc = cdata.lookup_item(id);
 996     let variance_doc = reader::get_doc(item_doc, tag_item_variances);
 997     let mut decoder = reader::Decoder::new(variance_doc);
 998     Decodable::decode(&mut decoder).unwrap()
 999 }
1000
1001 pub fn get_provided_trait_methods<'a, 'tcx>(cdata: Cmd,
1002                                             id: DefIndex,
1003                                             tcx: TyCtxt<'a, 'tcx, 'tcx>)
1004                                             -> Vec<Rc<ty::Method<'tcx>>> {
1005     let item = cdata.lookup_item(id);
1006
1007     reader::tagged_docs(item, tag_item_trait_item).filter_map(|mth_id| {
1008         let did = item_def_id(mth_id, cdata);
1009         let mth = cdata.lookup_item(did.index);
1010
1011         if item_sort(mth) == Some('p') {
1012             let trait_item = get_impl_or_trait_item(cdata, did.index, tcx);
1013             if let Some(ty::MethodTraitItem(ref method)) = trait_item {
1014                 Some((*method).clone())
1015             } else {
1016                 None
1017             }
1018         } else {
1019             None
1020         }
1021     }).collect()
1022 }
1023
1024 pub fn get_associated_consts<'a, 'tcx>(cdata: Cmd, id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
1025                                        -> Vec<Rc<ty::AssociatedConst<'tcx>>> {
1026     let item = cdata.lookup_item(id);
1027
1028     [tag_item_trait_item, tag_item_impl_item].iter().flat_map(|&tag| {
1029         reader::tagged_docs(item, tag).filter_map(|ac_id| {
1030             let did = item_def_id(ac_id, cdata);
1031             let ac_doc = cdata.lookup_item(did.index);
1032
1033             match item_sort(ac_doc) {
1034                 Some('C') | Some('c') => {
1035                     let trait_item = get_impl_or_trait_item(cdata, did.index, tcx);
1036                     if let Some(ty::ConstTraitItem(ref ac)) = trait_item {
1037                         Some((*ac).clone())
1038                     } else {
1039                         None
1040                     }
1041                 }
1042                 _ => None
1043             }
1044         })
1045     }).collect()
1046 }
1047
1048 pub fn get_variant_kind(cdata: Cmd, node_id: DefIndex) -> Option<VariantKind>
1049 {
1050     let item = cdata.lookup_item(node_id);
1051     family_to_variant_kind(item_family(item))
1052 }
1053
1054 pub fn get_struct_ctor_def_id(cdata: Cmd, node_id: DefIndex) -> Option<DefId>
1055 {
1056     let item = cdata.lookup_item(node_id);
1057     reader::maybe_get_doc(item, tag_items_data_item_struct_ctor).
1058         map(|ctor_doc| translated_def_id(cdata, ctor_doc))
1059 }
1060
1061 /// If node_id is the constructor of a tuple struct, retrieve the NodeId of
1062 /// the actual type definition, otherwise, return None
1063 pub fn get_tuple_struct_definition_if_ctor(cdata: Cmd,
1064                                            node_id: DefIndex)
1065     -> Option<DefId>
1066 {
1067     let item = cdata.lookup_item(node_id);
1068     reader::tagged_docs(item, tag_items_data_item_is_tuple_struct_ctor).next().map(|_| {
1069         item_require_parent_item(cdata, item)
1070     })
1071 }
1072
1073 pub fn get_item_attrs(cdata: Cmd,
1074                       orig_node_id: DefIndex)
1075                       -> Vec<ast::Attribute> {
1076     // The attributes for a tuple struct are attached to the definition, not the ctor;
1077     // we assume that someone passing in a tuple struct ctor is actually wanting to
1078     // look at the definition
1079     let node_id = get_tuple_struct_definition_if_ctor(cdata, orig_node_id);
1080     let node_id = node_id.map(|x| x.index).unwrap_or(orig_node_id);
1081     let item = cdata.lookup_item(node_id);
1082     get_attributes(item)
1083 }
1084
1085 pub fn get_struct_field_attrs(cdata: Cmd) -> FnvHashMap<DefId, Vec<ast::Attribute>> {
1086     let data = rbml::Doc::new(cdata.data());
1087     let fields = reader::get_doc(data, tag_struct_fields);
1088     reader::tagged_docs(fields, tag_struct_field).map(|field| {
1089         let def_id = translated_def_id(cdata, reader::get_doc(field, tag_def_id));
1090         let attrs = get_attributes(field);
1091         (def_id, attrs)
1092     }).collect()
1093 }
1094
1095 fn struct_field_family_to_visibility(family: Family) -> ty::Visibility {
1096     match family {
1097         PublicField => ty::Visibility::Public,
1098         InheritedField => ty::Visibility::PrivateExternal,
1099         _ => bug!()
1100     }
1101 }
1102
1103 pub fn get_struct_field_names(cdata: Cmd, id: DefIndex) -> Vec<ast::Name> {
1104     let item = cdata.lookup_item(id);
1105     let mut index = 0;
1106     reader::tagged_docs(item, tag_item_field).map(|an_item| {
1107         item_name(an_item)
1108     }).chain(reader::tagged_docs(item, tag_item_unnamed_field).map(|_| {
1109         let name = token::with_ident_interner(|interner| interner.intern(index.to_string()));
1110         index += 1;
1111         name
1112     })).collect()
1113 }
1114
1115 fn get_attributes(md: rbml::Doc) -> Vec<ast::Attribute> {
1116     reader::maybe_get_doc(md, tag_attributes).map_or(vec![], |attrs_doc| {
1117         let mut decoder = reader::Decoder::new(attrs_doc);
1118         let mut attrs: Vec<ast::Attribute> = decoder.read_opaque(|opaque_decoder, _| {
1119             Decodable::decode(opaque_decoder)
1120         }).unwrap();
1121
1122         // Need new unique IDs: old thread-local IDs won't map to new threads.
1123         for attr in attrs.iter_mut() {
1124             attr.node.id = attr::mk_attr_id();
1125         }
1126
1127         attrs
1128     })
1129 }
1130
1131 fn list_crate_attributes(md: rbml::Doc, hash: &Svh,
1132                          out: &mut io::Write) -> io::Result<()> {
1133     write!(out, "=Crate Attributes ({})=\n", *hash)?;
1134
1135     let r = get_attributes(md);
1136     for attr in &r {
1137         write!(out, "{}\n", pprust::attribute_to_string(attr))?;
1138     }
1139
1140     write!(out, "\n\n")
1141 }
1142
1143 pub fn get_crate_attributes(data: &[u8]) -> Vec<ast::Attribute> {
1144     get_attributes(rbml::Doc::new(data))
1145 }
1146
1147 #[derive(Clone)]
1148 pub struct CrateDep {
1149     pub cnum: ast::CrateNum,
1150     pub name: String,
1151     pub hash: Svh,
1152     pub explicitly_linked: bool,
1153 }
1154
1155 pub fn get_crate_deps(data: &[u8]) -> Vec<CrateDep> {
1156     let cratedoc = rbml::Doc::new(data);
1157     let depsdoc = reader::get_doc(cratedoc, tag_crate_deps);
1158
1159     fn docstr(doc: rbml::Doc, tag_: usize) -> String {
1160         let d = reader::get_doc(doc, tag_);
1161         d.as_str().to_string()
1162     }
1163
1164     reader::tagged_docs(depsdoc, tag_crate_dep).enumerate().map(|(crate_num, depdoc)| {
1165         let name = docstr(depdoc, tag_crate_dep_crate_name);
1166         let hash = Svh::new(reader::doc_as_u64(reader::get_doc(depdoc, tag_crate_dep_hash)));
1167         let doc = reader::get_doc(depdoc, tag_crate_dep_explicitly_linked);
1168         let explicitly_linked = reader::doc_as_u8(doc) != 0;
1169         CrateDep {
1170             cnum: crate_num as u32 + 1,
1171             name: name,
1172             hash: hash,
1173             explicitly_linked: explicitly_linked,
1174         }
1175     }).collect()
1176 }
1177
1178 fn list_crate_deps(data: &[u8], out: &mut io::Write) -> io::Result<()> {
1179     write!(out, "=External Dependencies=\n")?;
1180     for dep in &get_crate_deps(data) {
1181         write!(out, "{} {}-{}\n", dep.cnum, dep.name, dep.hash)?;
1182     }
1183     write!(out, "\n")?;
1184     Ok(())
1185 }
1186
1187 pub fn maybe_get_crate_hash(data: &[u8]) -> Option<Svh> {
1188     let cratedoc = rbml::Doc::new(data);
1189     reader::maybe_get_doc(cratedoc, tag_crate_hash).map(|doc| {
1190         Svh::new(reader::doc_as_u64(doc))
1191     })
1192 }
1193
1194 pub fn get_crate_hash(data: &[u8]) -> Svh {
1195     let cratedoc = rbml::Doc::new(data);
1196     let hashdoc = reader::get_doc(cratedoc, tag_crate_hash);
1197     Svh::new(reader::doc_as_u64(hashdoc))
1198 }
1199
1200 pub fn maybe_get_crate_name(data: &[u8]) -> Option<&str> {
1201     let cratedoc = rbml::Doc::new(data);
1202     reader::maybe_get_doc(cratedoc, tag_crate_crate_name).map(|doc| {
1203         doc.as_str()
1204     })
1205 }
1206
1207 pub fn get_crate_disambiguator<'a>(data: &'a [u8]) -> &'a str {
1208     let crate_doc = rbml::Doc::new(data);
1209     let disambiguator_doc = reader::get_doc(crate_doc, tag_crate_disambiguator);
1210     let slice: &'a str = disambiguator_doc.as_str();
1211     slice
1212 }
1213
1214 pub fn get_crate_triple(data: &[u8]) -> Option<String> {
1215     let cratedoc = rbml::Doc::new(data);
1216     let triple_doc = reader::maybe_get_doc(cratedoc, tag_crate_triple);
1217     triple_doc.map(|s| s.as_str().to_string())
1218 }
1219
1220 pub fn get_crate_name(data: &[u8]) -> &str {
1221     maybe_get_crate_name(data).expect("no crate name in crate")
1222 }
1223
1224 pub fn list_crate_metadata(bytes: &[u8], out: &mut io::Write) -> io::Result<()> {
1225     let hash = get_crate_hash(bytes);
1226     let md = rbml::Doc::new(bytes);
1227     list_crate_attributes(md, &hash, out)?;
1228     list_crate_deps(bytes, out)
1229 }
1230
1231 // Translates a def_id from an external crate to a def_id for the current
1232 // compilation environment. We use this when trying to load types from
1233 // external crates - if those types further refer to types in other crates
1234 // then we must translate the crate number from that encoded in the external
1235 // crate to the correct local crate number.
1236 pub fn translate_def_id(cdata: Cmd, did: DefId) -> DefId {
1237     if did.is_local() {
1238         return DefId { krate: cdata.cnum, index: did.index };
1239     }
1240
1241     DefId {
1242         krate: cdata.cnum_map.borrow()[did.krate],
1243         index: did.index
1244     }
1245 }
1246
1247 // Translate a DefId from the current compilation environment to a DefId
1248 // for an external crate.
1249 fn reverse_translate_def_id(cdata: Cmd, did: DefId) -> Option<DefId> {
1250     for (local, &global) in cdata.cnum_map.borrow().iter_enumerated() {
1251         if global == did.krate {
1252             return Some(DefId { krate: local, index: did.index });
1253         }
1254     }
1255
1256     None
1257 }
1258
1259 /// Translates a `Span` from an extern crate to the corresponding `Span`
1260 /// within the local crate's codemap.
1261 pub fn translate_span(cdata: Cmd,
1262                       codemap: &codemap::CodeMap,
1263                       last_filemap_index_hint: &Cell<usize>,
1264                       span: syntax_pos::Span)
1265                       -> syntax_pos::Span {
1266     let span = if span.lo > span.hi {
1267         // Currently macro expansion sometimes produces invalid Span values
1268         // where lo > hi. In order not to crash the compiler when trying to
1269         // translate these values, let's transform them into something we
1270         // can handle (and which will produce useful debug locations at
1271         // least some of the time).
1272         // This workaround is only necessary as long as macro expansion is
1273         // not fixed. FIXME(#23480)
1274         syntax_pos::mk_sp(span.lo, span.lo)
1275     } else {
1276         span
1277     };
1278
1279     let imported_filemaps = cdata.imported_filemaps(&codemap);
1280     let filemap = {
1281         // Optimize for the case that most spans within a translated item
1282         // originate from the same filemap.
1283         let last_filemap_index = last_filemap_index_hint.get();
1284         let last_filemap = &imported_filemaps[last_filemap_index];
1285
1286         if span.lo >= last_filemap.original_start_pos &&
1287            span.lo <= last_filemap.original_end_pos &&
1288            span.hi >= last_filemap.original_start_pos &&
1289            span.hi <= last_filemap.original_end_pos {
1290             last_filemap
1291         } else {
1292             let mut a = 0;
1293             let mut b = imported_filemaps.len();
1294
1295             while b - a > 1 {
1296                 let m = (a + b) / 2;
1297                 if imported_filemaps[m].original_start_pos > span.lo {
1298                     b = m;
1299                 } else {
1300                     a = m;
1301                 }
1302             }
1303
1304             last_filemap_index_hint.set(a);
1305             &imported_filemaps[a]
1306         }
1307     };
1308
1309     let lo = (span.lo - filemap.original_start_pos) +
1310               filemap.translated_filemap.start_pos;
1311     let hi = (span.hi - filemap.original_start_pos) +
1312               filemap.translated_filemap.start_pos;
1313
1314     syntax_pos::mk_sp(lo, hi)
1315 }
1316
1317 pub fn each_inherent_implementation_for_type<F>(cdata: Cmd,
1318                                                 id: DefIndex,
1319                                                 mut callback: F)
1320     where F: FnMut(DefId),
1321 {
1322     let item_doc = cdata.lookup_item(id);
1323     for impl_doc in reader::tagged_docs(item_doc, tag_items_data_item_inherent_impl) {
1324         if reader::maybe_get_doc(impl_doc, tag_item_trait_ref).is_none() {
1325             callback(item_def_id(impl_doc, cdata));
1326         }
1327     }
1328 }
1329
1330 pub fn each_implementation_for_trait<F>(cdata: Cmd,
1331                                         def_id: DefId,
1332                                         mut callback: F) where
1333     F: FnMut(DefId),
1334 {
1335     // Do a reverse lookup beforehand to avoid touching the crate_num
1336     // hash map in the loop below.
1337     if let Some(crate_local_did) = reverse_translate_def_id(cdata, def_id) {
1338         let def_id_u64 = def_to_u64(crate_local_did);
1339
1340         let impls_doc = reader::get_doc(rbml::Doc::new(cdata.data()), tag_impls);
1341         for trait_doc in reader::tagged_docs(impls_doc, tag_impls_trait) {
1342             let trait_def_id = reader::get_doc(trait_doc, tag_def_id);
1343             if reader::doc_as_u64(trait_def_id) != def_id_u64 {
1344                 continue;
1345             }
1346             for impl_doc in reader::tagged_docs(trait_doc, tag_impls_trait_impl) {
1347                 callback(translated_def_id(cdata, impl_doc));
1348             }
1349         }
1350     }
1351 }
1352
1353 pub fn get_trait_of_item(cdata: Cmd, id: DefIndex) -> Option<DefId> {
1354     let item_doc = cdata.lookup_item(id);
1355     let parent_item_id = match item_parent_item(cdata, item_doc) {
1356         None => return None,
1357         Some(item_id) => item_id,
1358     };
1359     let parent_item_doc = cdata.lookup_item(parent_item_id.index);
1360     match item_family(parent_item_doc) {
1361         Trait => Some(item_def_id(parent_item_doc, cdata)),
1362         _ => None
1363     }
1364 }
1365
1366
1367 pub fn get_native_libraries(cdata: Cmd)
1368                             -> Vec<(cstore::NativeLibraryKind, String)> {
1369     let libraries = reader::get_doc(rbml::Doc::new(cdata.data()),
1370                                     tag_native_libraries);
1371     reader::tagged_docs(libraries, tag_native_libraries_lib).map(|lib_doc| {
1372         let kind_doc = reader::get_doc(lib_doc, tag_native_libraries_kind);
1373         let name_doc = reader::get_doc(lib_doc, tag_native_libraries_name);
1374         let kind: cstore::NativeLibraryKind =
1375             cstore::NativeLibraryKind::from_u32(reader::doc_as_u32(kind_doc)).unwrap();
1376         let name = name_doc.as_str().to_string();
1377         (kind, name)
1378     }).collect()
1379 }
1380
1381 pub fn get_plugin_registrar_fn(data: &[u8]) -> Option<DefIndex> {
1382     reader::maybe_get_doc(rbml::Doc::new(data), tag_plugin_registrar_fn)
1383         .map(|doc| DefIndex::from_u32(reader::doc_as_u32(doc)))
1384 }
1385
1386 pub fn each_exported_macro<F>(data: &[u8], mut f: F) where
1387     F: FnMut(ast::Name, Vec<ast::Attribute>, Span, String) -> bool,
1388 {
1389     let macros = reader::get_doc(rbml::Doc::new(data), tag_macro_defs);
1390     for macro_doc in reader::tagged_docs(macros, tag_macro_def) {
1391         let name = item_name(macro_doc);
1392         let attrs = get_attributes(macro_doc);
1393         let span = get_macro_span(macro_doc);
1394         let body = reader::get_doc(macro_doc, tag_macro_def_body);
1395         if !f(name, attrs, span, body.as_str().to_string()) {
1396             break;
1397         }
1398     }
1399 }
1400
1401 pub fn get_macro_span(doc: rbml::Doc) -> Span {
1402     let lo_doc = reader::get_doc(doc, tag_macro_def_span_lo);
1403     let lo = BytePos(reader::doc_as_u32(lo_doc));
1404     let hi_doc = reader::get_doc(doc, tag_macro_def_span_hi);
1405     let hi = BytePos(reader::doc_as_u32(hi_doc));
1406     return Span { lo: lo, hi: hi, expn_id: NO_EXPANSION };
1407 }
1408
1409 pub fn get_dylib_dependency_formats(cdata: Cmd)
1410     -> Vec<(ast::CrateNum, LinkagePreference)>
1411 {
1412     let formats = reader::get_doc(rbml::Doc::new(cdata.data()),
1413                                   tag_dylib_dependency_formats);
1414     let mut result = Vec::new();
1415
1416     debug!("found dylib deps: {}", formats.as_str());
1417     for spec in formats.as_str().split(',') {
1418         if spec.is_empty() { continue }
1419         let mut split = spec.split(':');
1420         let cnum = split.next().unwrap();
1421         let link = split.next().unwrap();
1422         let cnum: ast::CrateNum = cnum.parse().unwrap();
1423         let cnum = cdata.cnum_map.borrow()[cnum];
1424         result.push((cnum, if link == "d" {
1425             LinkagePreference::RequireDynamic
1426         } else {
1427             LinkagePreference::RequireStatic
1428         }));
1429     }
1430     return result;
1431 }
1432
1433 pub fn get_missing_lang_items(cdata: Cmd)
1434     -> Vec<lang_items::LangItem>
1435 {
1436     let items = reader::get_doc(rbml::Doc::new(cdata.data()), tag_lang_items);
1437     reader::tagged_docs(items, tag_lang_items_missing).map(|missing_docs| {
1438         lang_items::LangItem::from_u32(reader::doc_as_u32(missing_docs)).unwrap()
1439     }).collect()
1440 }
1441
1442 pub fn get_method_arg_names(cdata: Cmd, id: DefIndex) -> Vec<String> {
1443     let method_doc = cdata.lookup_item(id);
1444     match reader::maybe_get_doc(method_doc, tag_method_argument_names) {
1445         Some(args_doc) => {
1446             reader::tagged_docs(args_doc, tag_method_argument_name).map(|name_doc| {
1447                 name_doc.as_str().to_string()
1448             }).collect()
1449         },
1450         None => vec![],
1451     }
1452 }
1453
1454 pub fn get_reachable_ids(cdata: Cmd) -> Vec<DefId> {
1455     let items = reader::get_doc(rbml::Doc::new(cdata.data()),
1456                                 tag_reachable_ids);
1457     reader::tagged_docs(items, tag_reachable_id).map(|doc| {
1458         DefId {
1459             krate: cdata.cnum,
1460             index: DefIndex::from_u32(reader::doc_as_u32(doc)),
1461         }
1462     }).collect()
1463 }
1464
1465 pub fn is_typedef(cdata: Cmd, id: DefIndex) -> bool {
1466     let item_doc = cdata.lookup_item(id);
1467     match item_family(item_doc) {
1468         Type => true,
1469         _ => false,
1470     }
1471 }
1472
1473 pub fn is_const_fn(cdata: Cmd, id: DefIndex) -> bool {
1474     let item_doc = cdata.lookup_item(id);
1475     match fn_constness(item_doc) {
1476         hir::Constness::Const => true,
1477         hir::Constness::NotConst => false,
1478     }
1479 }
1480
1481 pub fn is_extern_item<'a, 'tcx>(cdata: Cmd,
1482                                 id: DefIndex,
1483                                 tcx: TyCtxt<'a, 'tcx, 'tcx>)
1484                                 -> bool {
1485     let item_doc = match cdata.get_item(id) {
1486         Some(doc) => doc,
1487         None => return false,
1488     };
1489     let applicable = match item_family(item_doc) {
1490         ImmStatic | MutStatic => true,
1491         Fn => get_generics(cdata, id, tcx).types.is_empty(),
1492         _ => false,
1493     };
1494
1495     if applicable {
1496         attr::contains_extern_indicator(tcx.sess.diagnostic(),
1497                                         &get_attributes(item_doc))
1498     } else {
1499         false
1500     }
1501 }
1502
1503 pub fn is_foreign_item(cdata: Cmd, id: DefIndex) -> bool {
1504     let item_doc = cdata.lookup_item(id);
1505     let parent_item_id = match item_parent_item(cdata, item_doc) {
1506         None => return false,
1507         Some(item_id) => item_id,
1508     };
1509     let parent_item_doc = cdata.lookup_item(parent_item_id.index);
1510     item_family(parent_item_doc) == ForeignMod
1511 }
1512
1513 pub fn is_impl(cdata: Cmd, id: DefIndex) -> bool {
1514     let item_doc = cdata.lookup_item(id);
1515     match item_family(item_doc) {
1516         Impl => true,
1517         _ => false,
1518     }
1519 }
1520
1521 fn doc_generics<'a, 'tcx>(base_doc: rbml::Doc,
1522                           tcx: TyCtxt<'a, 'tcx, 'tcx>,
1523                           cdata: Cmd)
1524                           -> &'tcx ty::Generics<'tcx>
1525 {
1526     let doc = reader::get_doc(base_doc, tag_item_generics);
1527     TyDecoder::with_doc(tcx, cdata.cnum, doc,
1528                         &mut |did| translate_def_id(cdata, did))
1529         .parse_generics()
1530 }
1531
1532 fn doc_predicate<'a, 'tcx>(cdata: Cmd,
1533                            doc: rbml::Doc,
1534                            tcx: TyCtxt<'a, 'tcx, 'tcx>)
1535                            -> ty::Predicate<'tcx>
1536 {
1537     let predicate_pos = cdata.xref_index.lookup(
1538         cdata.data(), reader::doc_as_u32(doc)).unwrap() as usize;
1539     TyDecoder::new(
1540         cdata.data(), cdata.cnum, predicate_pos, tcx,
1541         &mut |did| translate_def_id(cdata, did)
1542     ).parse_predicate()
1543 }
1544
1545 fn doc_predicates<'a, 'tcx>(base_doc: rbml::Doc,
1546                             tcx: TyCtxt<'a, 'tcx, 'tcx>,
1547                             cdata: Cmd,
1548                             tag: usize)
1549                             -> ty::GenericPredicates<'tcx>
1550 {
1551     let doc = reader::get_doc(base_doc, tag);
1552
1553     ty::GenericPredicates {
1554         parent: item_parent_item(cdata, doc),
1555         predicates: reader::tagged_docs(doc, tag_predicate).map(|predicate_doc| {
1556             doc_predicate(cdata, predicate_doc, tcx)
1557         }).collect()
1558     }
1559 }
1560
1561 pub fn is_defaulted_trait(cdata: Cmd, trait_id: DefIndex) -> bool {
1562     let trait_doc = cdata.lookup_item(trait_id);
1563     assert!(item_family(trait_doc) == Family::Trait);
1564     let defaulted_doc = reader::get_doc(trait_doc, tag_defaulted_trait);
1565     reader::doc_as_u8(defaulted_doc) != 0
1566 }
1567
1568 pub fn is_default_impl(cdata: Cmd, impl_id: DefIndex) -> bool {
1569     let impl_doc = cdata.lookup_item(impl_id);
1570     item_family(impl_doc) == Family::DefaultImpl
1571 }
1572
1573 pub fn get_imported_filemaps(metadata: &[u8]) -> Vec<syntax_pos::FileMap> {
1574     let crate_doc = rbml::Doc::new(metadata);
1575     let cm_doc = reader::get_doc(crate_doc, tag_codemap);
1576
1577     reader::tagged_docs(cm_doc, tag_codemap_filemap).map(|filemap_doc| {
1578         let mut decoder = reader::Decoder::new(filemap_doc);
1579         decoder.read_opaque(|opaque_decoder, _| {
1580             Decodable::decode(opaque_decoder)
1581         }).unwrap()
1582     }).collect()
1583 }
1584
1585 pub fn closure_kind(cdata: Cmd, closure_id: DefIndex) -> ty::ClosureKind {
1586     let closure_doc = cdata.lookup_item(closure_id);
1587     let closure_kind_doc = reader::get_doc(closure_doc, tag_items_closure_kind);
1588     let mut decoder = reader::Decoder::new(closure_kind_doc);
1589     ty::ClosureKind::decode(&mut decoder).unwrap()
1590 }
1591
1592 pub fn closure_ty<'a, 'tcx>(cdata: Cmd, closure_id: DefIndex, tcx: TyCtxt<'a, 'tcx, 'tcx>)
1593                             -> ty::ClosureTy<'tcx> {
1594     let closure_doc = cdata.lookup_item(closure_id);
1595     let closure_ty_doc = reader::get_doc(closure_doc, tag_items_closure_ty);
1596     TyDecoder::with_doc(tcx, cdata.cnum, closure_ty_doc, &mut |did| translate_def_id(cdata, did))
1597         .parse_closure_ty()
1598 }
1599
1600 pub fn def_key(cdata: Cmd, id: DefIndex) -> hir_map::DefKey {
1601     debug!("def_key: id={:?}", id);
1602     let item_doc = cdata.lookup_item(id);
1603     item_def_key(item_doc)
1604 }
1605
1606 fn item_def_key(item_doc: rbml::Doc) -> hir_map::DefKey {
1607     match reader::maybe_get_doc(item_doc, tag_def_key) {
1608         Some(def_key_doc) => {
1609             let mut decoder = reader::Decoder::new(def_key_doc);
1610             let simple_key = def_key::DefKey::decode(&mut decoder).unwrap();
1611             let name = reader::maybe_get_doc(item_doc, tag_paths_data_name).map(|name| {
1612                 token::intern(name.as_str()).as_str()
1613             });
1614             def_key::recover_def_key(simple_key, name)
1615         }
1616         None => {
1617             bug!("failed to find block with tag {:?} for item with family {:?}",
1618                    tag_def_key,
1619                    item_family(item_doc))
1620         }
1621     }
1622 }
1623
1624 pub fn def_path(cdata: Cmd, id: DefIndex) -> hir_map::DefPath {
1625     debug!("def_path(id={:?})", id);
1626     hir_map::DefPath::make(cdata.cnum, id, |parent| def_key(cdata, parent))
1627 }
1628
1629 pub fn get_panic_strategy(data: &[u8]) -> PanicStrategy {
1630     let crate_doc = rbml::Doc::new(data);
1631     let strat_doc = reader::get_doc(crate_doc, tag_panic_strategy);
1632     match reader::doc_as_u8(strat_doc) {
1633         b'U' => PanicStrategy::Unwind,
1634         b'A' => PanicStrategy::Abort,
1635         b => panic!("unknown panic strategy in metadata: {}", b),
1636     }
1637 }