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