compiler/rustc_metadata/src/rmeta/decoder.rs

   1 // Decoding metadata from a single crate's metadata
   2
   3 use crate::creader::CrateMetadataRef;
   4 use crate::rmeta::table::{FixedSizeEncoding, Table};
   5 use crate::rmeta::*;
   6
   7 use rustc_ast as ast;
   8 use rustc_attr as attr;
   9 use rustc_data_structures::captures::Captures;
  10 use rustc_data_structures::fingerprint::{Fingerprint, FingerprintDecoder};
  11 use rustc_data_structures::fx::FxHashMap;
  12 use rustc_data_structures::svh::Svh;
  13 use rustc_data_structures::sync::{AtomicCell, Lock, LockGuard, Lrc, OnceCell};
  14 use rustc_errors::ErrorReported;
  15 use rustc_expand::base::{SyntaxExtension, SyntaxExtensionKind};
  16 use rustc_expand::proc_macro::{AttrProcMacro, BangProcMacro, ProcMacroDerive};
  17 use rustc_hir as hir;
  18 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
  19 use rustc_hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
  20 use rustc_hir::definitions::{DefKey, DefPath, DefPathData, DefPathHash};
  21 use rustc_hir::lang_items;
  22 use rustc_index::vec::{Idx, IndexVec};
  23 use rustc_middle::dep_graph::{self, DepNode, DepNodeExt, DepNodeIndex};
  24 use rustc_middle::hir::exports::Export;
  25 use rustc_middle::middle::cstore::{CrateSource, ExternCrate};
  26 use rustc_middle::middle::cstore::{ForeignModule, LinkagePreference, NativeLib};
  27 use rustc_middle::middle::exported_symbols::{ExportedSymbol, SymbolExportLevel};
  28 use rustc_middle::mir::interpret::{AllocDecodingSession, AllocDecodingState};
  29 use rustc_middle::mir::{self, Body, Promoted};
  30 use rustc_middle::ty::codec::TyDecoder;
  31 use rustc_middle::ty::{self, Ty, TyCtxt};
  32 use rustc_serialize::{opaque, Decodable, Decoder};
  33 use rustc_session::Session;
  34 use rustc_span::hygiene::ExpnDataDecodeMode;
  35 use rustc_span::source_map::{respan, Spanned};
  36 use rustc_span::symbol::{sym, Ident, Symbol};
  37 use rustc_span::{self, hygiene::MacroKind, BytePos, ExpnId, Pos, Span, SyntaxContext, DUMMY_SP};
  38
  39 use proc_macro::bridge::client::ProcMacro;
  40 use std::cell::Cell;
  41 use std::io;
  42 use std::mem;
  43 use std::num::NonZeroUsize;
  44 use std::path::Path;
  45 use tracing::debug;
  46
  47 pub use cstore_impl::{provide, provide_extern};
  48 use rustc_span::hygiene::HygieneDecodeContext;
  49
  50 mod cstore_impl;
  51
  52 crate struct MetadataBlob(MetadataRef);
  53
  54 // A map from external crate numbers (as decoded from some crate file) to
  55 // local crate numbers (as generated during this session). Each external
  56 // crate may refer to types in other external crates, and each has their
  57 // own crate numbers.
  58 crate type CrateNumMap = IndexVec<CrateNum, CrateNum>;
  59
  60 crate struct CrateMetadata {
  61     /// The primary crate data - binary metadata blob.
  62     blob: MetadataBlob,
  63
  64     // --- Some data pre-decoded from the metadata blob, usually for performance ---
  65     /// Properties of the whole crate.
  66     /// NOTE(eddyb) we pass `'static` to a `'tcx` parameter because this
  67     /// lifetime is only used behind `Lazy`, and therefore acts like an
  68     /// universal (`for<'tcx>`), that is paired up with whichever `TyCtxt`
  69     /// is being used to decode those values.
  70     root: CrateRoot<'static>,
  71     /// Trait impl data.
  72     /// FIXME: Used only from queries and can use query cache,
  73     /// so pre-decoding can probably be avoided.
  74     trait_impls:
  75         FxHashMap<(u32, DefIndex), Lazy<[(DefIndex, Option<ty::fast_reject::SimplifiedType>)]>>,
  76     /// Proc macro descriptions for this crate, if it's a proc macro crate.
  77     raw_proc_macros: Option<&'static [ProcMacro]>,
  78     /// Source maps for code from the crate.
  79     source_map_import_info: OnceCell<Vec<ImportedSourceFile>>,
  80     /// Used for decoding interpret::AllocIds in a cached & thread-safe manner.
  81     alloc_decoding_state: AllocDecodingState,
  82     /// The `DepNodeIndex` of the `DepNode` representing this upstream crate.
  83     /// It is initialized on the first access in `get_crate_dep_node_index()`.
  84     /// Do not access the value directly, as it might not have been initialized yet.
  85     /// The field must always be initialized to `DepNodeIndex::INVALID`.
  86     dep_node_index: AtomicCell<DepNodeIndex>,
  87     /// Caches decoded `DefKey`s.
  88     def_key_cache: Lock<FxHashMap<DefIndex, DefKey>>,
  89     /// Caches decoded `DefPathHash`es.
  90     def_path_hash_cache: Lock<FxHashMap<DefIndex, DefPathHash>>,
  91
  92     // --- Other significant crate properties ---
  93     /// ID of this crate, from the current compilation session's point of view.
  94     cnum: CrateNum,
  95     /// Maps crate IDs as they are were seen from this crate's compilation sessions into
  96     /// IDs as they are seen from the current compilation session.
  97     cnum_map: CrateNumMap,
  98     /// Same ID set as `cnum_map` plus maybe some injected crates like panic runtime.
  99     dependencies: Lock<Vec<CrateNum>>,
 100     /// How to link (or not link) this crate to the currently compiled crate.
 101     dep_kind: Lock<CrateDepKind>,
 102     /// Filesystem location of this crate.
 103     source: CrateSource,
 104     /// Whether or not this crate should be consider a private dependency
 105     /// for purposes of the 'exported_private_dependencies' lint
 106     private_dep: bool,
 107     /// The hash for the host proc macro. Used to support `-Z dual-proc-macro`.
 108     host_hash: Option<Svh>,
 109
 110     /// Additional data used for decoding `HygieneData` (e.g. `SyntaxContext`
 111     /// and `ExpnId`).
 112     /// Note that we store a `HygieneDecodeContext` for each `CrateMetadat`. This is
 113     /// because `SyntaxContext` ids are not globally unique, so we need
 114     /// to track which ids we've decoded on a per-crate basis.
 115     hygiene_context: HygieneDecodeContext,
 116
 117     // --- Data used only for improving diagnostics ---
 118     /// Information about the `extern crate` item or path that caused this crate to be loaded.
 119     /// If this is `None`, then the crate was injected (e.g., by the allocator).
 120     extern_crate: Lock<Option<ExternCrate>>,
 121 }
 122
 123 /// Holds information about a rustc_span::SourceFile imported from another crate.
 124 /// See `imported_source_files()` for more information.
 125 struct ImportedSourceFile {
 126     /// This SourceFile's byte-offset within the source_map of its original crate
 127     original_start_pos: rustc_span::BytePos,
 128     /// The end of this SourceFile within the source_map of its original crate
 129     original_end_pos: rustc_span::BytePos,
 130     /// The imported SourceFile's representation within the local source_map
 131     translated_source_file: Lrc<rustc_span::SourceFile>,
 132 }
 133
 134 pub(super) struct DecodeContext<'a, 'tcx> {
 135     opaque: opaque::Decoder<'a>,
 136     cdata: Option<CrateMetadataRef<'a>>,
 137     sess: Option<&'tcx Session>,
 138     tcx: Option<TyCtxt<'tcx>>,
 139
 140     // Cache the last used source_file for translating spans as an optimization.
 141     last_source_file_index: usize,
 142
 143     lazy_state: LazyState,
 144
 145     // Used for decoding interpret::AllocIds in a cached & thread-safe manner.
 146     alloc_decoding_session: Option<AllocDecodingSession<'a>>,
 147 }
 148
 149 /// Abstract over the various ways one can create metadata decoders.
 150 pub(super) trait Metadata<'a, 'tcx>: Copy {
 151     fn raw_bytes(self) -> &'a [u8];
 152     fn cdata(self) -> Option<CrateMetadataRef<'a>> {
 153         None
 154     }
 155     fn sess(self) -> Option<&'tcx Session> {
 156         None
 157     }
 158     fn tcx(self) -> Option<TyCtxt<'tcx>> {
 159         None
 160     }
 161
 162     fn decoder(self, pos: usize) -> DecodeContext<'a, 'tcx> {
 163         let tcx = self.tcx();
 164         DecodeContext {
 165             opaque: opaque::Decoder::new(self.raw_bytes(), pos),
 166             cdata: self.cdata(),
 167             sess: self.sess().or(tcx.map(|tcx| tcx.sess)),
 168             tcx,
 169             last_source_file_index: 0,
 170             lazy_state: LazyState::NoNode,
 171             alloc_decoding_session: self
 172                 .cdata()
 173                 .map(|cdata| cdata.cdata.alloc_decoding_state.new_decoding_session()),
 174         }
 175     }
 176 }
 177
 178 impl<'a, 'tcx> Metadata<'a, 'tcx> for &'a MetadataBlob {
 179     fn raw_bytes(self) -> &'a [u8] {
 180         &self.0
 181     }
 182 }
 183
 184 impl<'a, 'tcx> Metadata<'a, 'tcx> for (&'a MetadataBlob, &'tcx Session) {
 185     fn raw_bytes(self) -> &'a [u8] {
 186         let (blob, _) = self;
 187         &blob.0
 188     }
 189
 190     fn sess(self) -> Option<&'tcx Session> {
 191         let (_, sess) = self;
 192         Some(sess)
 193     }
 194 }
 195
 196 impl<'a, 'tcx> Metadata<'a, 'tcx> for &'a CrateMetadataRef<'a> {
 197     fn raw_bytes(self) -> &'a [u8] {
 198         self.blob.raw_bytes()
 199     }
 200     fn cdata(self) -> Option<CrateMetadataRef<'a>> {
 201         Some(*self)
 202     }
 203 }
 204
 205 impl<'a, 'tcx> Metadata<'a, 'tcx> for (&'a CrateMetadataRef<'a>, &'tcx Session) {
 206     fn raw_bytes(self) -> &'a [u8] {
 207         self.0.raw_bytes()
 208     }
 209     fn cdata(self) -> Option<CrateMetadataRef<'a>> {
 210         Some(*self.0)
 211     }
 212     fn sess(self) -> Option<&'tcx Session> {
 213         Some(&self.1)
 214     }
 215 }
 216
 217 impl<'a, 'tcx> Metadata<'a, 'tcx> for (&'a CrateMetadataRef<'a>, TyCtxt<'tcx>) {
 218     fn raw_bytes(self) -> &'a [u8] {
 219         self.0.raw_bytes()
 220     }
 221     fn cdata(self) -> Option<CrateMetadataRef<'a>> {
 222         Some(*self.0)
 223     }
 224     fn tcx(self) -> Option<TyCtxt<'tcx>> {
 225         Some(self.1)
 226     }
 227 }
 228
 229 impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Lazy<T> {
 230     fn decode<M: Metadata<'a, 'tcx>>(self, metadata: M) -> T {
 231         let mut dcx = metadata.decoder(self.position.get());
 232         dcx.lazy_state = LazyState::NodeStart(self.position);
 233         T::decode(&mut dcx).unwrap()
 234     }
 235 }
 236
 237 impl<'a: 'x, 'tcx: 'x, 'x, T: Decodable<DecodeContext<'a, 'tcx>>> Lazy<[T]> {
 238     fn decode<M: Metadata<'a, 'tcx>>(
 239         self,
 240         metadata: M,
 241     ) -> impl ExactSizeIterator<Item = T> + Captures<'a> + Captures<'tcx> + 'x {
 242         let mut dcx = metadata.decoder(self.position.get());
 243         dcx.lazy_state = LazyState::NodeStart(self.position);
 244         (0..self.meta).map(move |_| T::decode(&mut dcx).unwrap())
 245     }
 246 }
 247
 248 impl<'a, 'tcx> DecodeContext<'a, 'tcx> {
 249     fn tcx(&self) -> TyCtxt<'tcx> {
 250         self.tcx.expect("missing TyCtxt in DecodeContext")
 251     }
 252
 253     fn cdata(&self) -> CrateMetadataRef<'a> {
 254         self.cdata.expect("missing CrateMetadata in DecodeContext")
 255     }
 256
 257     fn read_lazy_with_meta<T: ?Sized + LazyMeta>(
 258         &mut self,
 259         meta: T::Meta,
 260     ) -> Result<Lazy<T>, <Self as Decoder>::Error> {
 261         let min_size = T::min_size(meta);
 262         let distance = self.read_usize()?;
 263         let position = match self.lazy_state {
 264             LazyState::NoNode => bug!("read_lazy_with_meta: outside of a metadata node"),
 265             LazyState::NodeStart(start) => {
 266                 let start = start.get();
 267                 assert!(distance + min_size <= start);
 268                 start - distance - min_size
 269             }
 270             LazyState::Previous(last_min_end) => last_min_end.get() + distance,
 271         };
 272         self.lazy_state = LazyState::Previous(NonZeroUsize::new(position + min_size).unwrap());
 273         Ok(Lazy::from_position_and_meta(NonZeroUsize::new(position).unwrap(), meta))
 274     }
 275 }
 276
 277 impl<'a, 'tcx> TyDecoder<'tcx> for DecodeContext<'a, 'tcx> {
 278     const CLEAR_CROSS_CRATE: bool = true;
 279
 280     #[inline]
 281     fn tcx(&self) -> TyCtxt<'tcx> {
 282         self.tcx.expect("missing TyCtxt in DecodeContext")
 283     }
 284
 285     #[inline]
 286     fn peek_byte(&self) -> u8 {
 287         self.opaque.data[self.opaque.position()]
 288     }
 289
 290     #[inline]
 291     fn position(&self) -> usize {
 292         self.opaque.position()
 293     }
 294
 295     fn cached_ty_for_shorthand<F>(
 296         &mut self,
 297         shorthand: usize,
 298         or_insert_with: F,
 299     ) -> Result<Ty<'tcx>, Self::Error>
 300     where
 301         F: FnOnce(&mut Self) -> Result<Ty<'tcx>, Self::Error>,
 302     {
 303         let tcx = self.tcx();
 304
 305         let key = ty::CReaderCacheKey { cnum: self.cdata().cnum, pos: shorthand };
 306
 307         if let Some(&ty) = tcx.ty_rcache.borrow().get(&key) {
 308             return Ok(ty);
 309         }
 310
 311         let ty = or_insert_with(self)?;
 312         tcx.ty_rcache.borrow_mut().insert(key, ty);
 313         Ok(ty)
 314     }
 315
 316     fn cached_predicate_for_shorthand<F>(
 317         &mut self,
 318         shorthand: usize,
 319         or_insert_with: F,
 320     ) -> Result<ty::Predicate<'tcx>, Self::Error>
 321     where
 322         F: FnOnce(&mut Self) -> Result<ty::Predicate<'tcx>, Self::Error>,
 323     {
 324         let tcx = self.tcx();
 325
 326         let key = ty::CReaderCacheKey { cnum: self.cdata().cnum, pos: shorthand };
 327
 328         if let Some(&pred) = tcx.pred_rcache.borrow().get(&key) {
 329             return Ok(pred);
 330         }
 331
 332         let pred = or_insert_with(self)?;
 333         tcx.pred_rcache.borrow_mut().insert(key, pred);
 334         Ok(pred)
 335     }
 336
 337     fn with_position<F, R>(&mut self, pos: usize, f: F) -> R
 338     where
 339         F: FnOnce(&mut Self) -> R,
 340     {
 341         let new_opaque = opaque::Decoder::new(self.opaque.data, pos);
 342         let old_opaque = mem::replace(&mut self.opaque, new_opaque);
 343         let old_state = mem::replace(&mut self.lazy_state, LazyState::NoNode);
 344         let r = f(self);
 345         self.opaque = old_opaque;
 346         self.lazy_state = old_state;
 347         r
 348     }
 349
 350     fn map_encoded_cnum_to_current(&self, cnum: CrateNum) -> CrateNum {
 351         if cnum == LOCAL_CRATE { self.cdata().cnum } else { self.cdata().cnum_map[cnum] }
 352     }
 353
 354     fn decode_alloc_id(&mut self) -> Result<rustc_middle::mir::interpret::AllocId, Self::Error> {
 355         if let Some(alloc_decoding_session) = self.alloc_decoding_session {
 356             alloc_decoding_session.decode_alloc_id(self)
 357         } else {
 358             bug!("Attempting to decode interpret::AllocId without CrateMetadata")
 359         }
 360     }
 361 }
 362
 363 impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for CrateNum {
 364     fn decode(d: &mut DecodeContext<'a, 'tcx>) -> Result<CrateNum, String> {
 365         let cnum = CrateNum::from_u32(d.read_u32()?);
 366         Ok(d.map_encoded_cnum_to_current(cnum))
 367     }
 368 }
 369
 370 impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for DefIndex {
 371     fn decode(d: &mut DecodeContext<'a, 'tcx>) -> Result<DefIndex, String> {
 372         Ok(DefIndex::from_u32(d.read_u32()?))
 373     }
 374 }
 375
 376 impl<'a, 'tcx> FingerprintDecoder for DecodeContext<'a, 'tcx> {
 377     fn decode_fingerprint(&mut self) -> Result<Fingerprint, String> {
 378         Fingerprint::decode_opaque(&mut self.opaque)
 379     }
 380 }
 381
 382 impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for SyntaxContext {
 383     fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<SyntaxContext, String> {
 384         let cdata = decoder.cdata();
 385         let sess = decoder.sess.unwrap();
 386         let cname = cdata.root.name;
 387         rustc_span::hygiene::decode_syntax_context(decoder, &cdata.hygiene_context, |_, id| {
 388             debug!("SpecializedDecoder<SyntaxContext>: decoding {}", id);
 389             Ok(cdata
 390                 .root
 391                 .syntax_contexts
 392                 .get(&cdata, id)
 393                 .unwrap_or_else(|| panic!("Missing SyntaxContext {:?} for crate {:?}", id, cname))
 394                 .decode((&cdata, sess)))
 395         })
 396     }
 397 }
 398
 399 impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for ExpnId {
 400     fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<ExpnId, String> {
 401         let local_cdata = decoder.cdata();
 402         let sess = decoder.sess.unwrap();
 403         let expn_cnum = Cell::new(None);
 404         let get_ctxt = |cnum| {
 405             expn_cnum.set(Some(cnum));
 406             if cnum == LOCAL_CRATE {
 407                 &local_cdata.hygiene_context
 408             } else {
 409                 &local_cdata.cstore.get_crate_data(cnum).cdata.hygiene_context
 410             }
 411         };
 412
 413         rustc_span::hygiene::decode_expn_id(
 414             decoder,
 415             ExpnDataDecodeMode::Metadata(get_ctxt),
 416             |_this, index| {
 417                 let cnum = expn_cnum.get().unwrap();
 418                 // Lookup local `ExpnData`s in our own crate data. Foreign `ExpnData`s
 419                 // are stored in the owning crate, to avoid duplication.
 420                 let crate_data = if cnum == LOCAL_CRATE {
 421                     local_cdata
 422                 } else {
 423                     local_cdata.cstore.get_crate_data(cnum)
 424                 };
 425                 Ok(crate_data
 426                     .root
 427                     .expn_data
 428                     .get(&crate_data, index)
 429                     .unwrap()
 430                     .decode((&crate_data, sess)))
 431             },
 432         )
 433     }
 434 }
 435
 436 impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for Span {
 437     fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Span, String> {
 438         let tag = u8::decode(decoder)?;
 439
 440         if tag == TAG_INVALID_SPAN {
 441             return Ok(DUMMY_SP);
 442         }
 443
 444         debug_assert!(tag == TAG_VALID_SPAN_LOCAL || tag == TAG_VALID_SPAN_FOREIGN);
 445
 446         let lo = BytePos::decode(decoder)?;
 447         let len = BytePos::decode(decoder)?;
 448         let ctxt = SyntaxContext::decode(decoder)?;
 449         let hi = lo + len;
 450
 451         let sess = if let Some(sess) = decoder.sess {
 452             sess
 453         } else {
 454             bug!("Cannot decode Span without Session.")
 455         };
 456
 457         // There are two possibilities here:
 458         // 1. This is a 'local span', which is located inside a `SourceFile`
 459         // that came from this crate. In this case, we use the source map data
 460         // encoded in this crate. This branch should be taken nearly all of the time.
 461         // 2. This is a 'foreign span', which is located inside a `SourceFile`
 462         // that came from a *different* crate (some crate upstream of the one
 463         // whose metadata we're looking at). For example, consider this dependency graph:
 464         //
 465         // A -> B -> C
 466         //
 467         // Suppose that we're currently compiling crate A, and start deserializing
 468         // metadata from crate B. When we deserialize a Span from crate B's metadata,
 469         // there are two posibilites:
 470         //
 471         // 1. The span references a file from crate B. This makes it a 'local' span,
 472         // which means that we can use crate B's serialized source map information.
 473         // 2. The span references a file from crate C. This makes it a 'foreign' span,
 474         // which means we need to use Crate *C* (not crate B) to determine the source
 475         // map information. We only record source map information for a file in the
 476         // crate that 'owns' it, so deserializing a Span may require us to look at
 477         // a transitive dependency.
 478         //
 479         // When we encode a foreign span, we adjust its 'lo' and 'high' values
 480         // to be based on the *foreign* crate (e.g. crate C), not the crate
 481         // we are writing metadata for (e.g. crate B). This allows us to
 482         // treat the 'local' and 'foreign' cases almost identically during deserialization:
 483         // we can call `imported_source_files` for the proper crate, and binary search
 484         // through the returned slice using our span.
 485         let imported_source_files = if tag == TAG_VALID_SPAN_LOCAL {
 486             decoder.cdata().imported_source_files(sess)
 487         } else {
 488             // When we encode a proc-macro crate, all `Span`s should be encoded
 489             // with `TAG_VALID_SPAN_LOCAL`
 490             if decoder.cdata().root.is_proc_macro_crate() {
 491                 // Decode `CrateNum` as u32 - using `CrateNum::decode` will ICE
 492                 // since we don't have `cnum_map` populated.
 493                 let cnum = u32::decode(decoder)?;
 494                 panic!(
 495                     "Decoding of crate {:?} tried to access proc-macro dep {:?}",
 496                     decoder.cdata().root.name,
 497                     cnum
 498                 );
 499             }
 500             // tag is TAG_VALID_SPAN_FOREIGN, checked by `debug_assert` above
 501             let cnum = CrateNum::decode(decoder)?;
 502             debug!(
 503                 "SpecializedDecoder<Span>::specialized_decode: loading source files from cnum {:?}",
 504                 cnum
 505             );
 506
 507             // Decoding 'foreign' spans should be rare enough that it's
 508             // not worth it to maintain a per-CrateNum cache for `last_source_file_index`.
 509             // We just set it to 0, to ensure that we don't try to access something out
 510             // of bounds for our initial 'guess'
 511             decoder.last_source_file_index = 0;
 512
 513             let foreign_data = decoder.cdata().cstore.get_crate_data(cnum);
 514             foreign_data.imported_source_files(sess)
 515         };
 516
 517         let source_file = {
 518             // Optimize for the case that most spans within a translated item
 519             // originate from the same source_file.
 520             let last_source_file = &imported_source_files[decoder.last_source_file_index];
 521
 522             if lo >= last_source_file.original_start_pos && lo <= last_source_file.original_end_pos
 523             {
 524                 last_source_file
 525             } else {
 526                 let index = imported_source_files
 527                     .binary_search_by_key(&lo, |source_file| source_file.original_start_pos)
 528                     .unwrap_or_else(|index| index - 1);
 529
 530                 // Don't try to cache the index for foreign spans,
 531                 // as this would require a map from CrateNums to indices
 532                 if tag == TAG_VALID_SPAN_LOCAL {
 533                     decoder.last_source_file_index = index;
 534                 }
 535                 &imported_source_files[index]
 536             }
 537         };
 538
 539         // Make sure our binary search above is correct.
 540         debug_assert!(
 541             lo >= source_file.original_start_pos && lo <= source_file.original_end_pos,
 542             "Bad binary search: lo={:?} source_file.original_start_pos={:?} source_file.original_end_pos={:?}",
 543             lo,
 544             source_file.original_start_pos,
 545             source_file.original_end_pos
 546         );
 547
 548         // Make sure we correctly filtered out invalid spans during encoding
 549         debug_assert!(
 550             hi >= source_file.original_start_pos && hi <= source_file.original_end_pos,
 551             "Bad binary search: hi={:?} source_file.original_start_pos={:?} source_file.original_end_pos={:?}",
 552             hi,
 553             source_file.original_start_pos,
 554             source_file.original_end_pos
 555         );
 556
 557         let lo =
 558             (lo + source_file.translated_source_file.start_pos) - source_file.original_start_pos;
 559         let hi =
 560             (hi + source_file.translated_source_file.start_pos) - source_file.original_start_pos;
 561
 562         Ok(Span::new(lo, hi, ctxt))
 563     }
 564 }
 565
 566 impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for &'tcx [mir::abstract_const::Node<'tcx>] {
 567     fn decode(d: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> {
 568         ty::codec::RefDecodable::decode(d)
 569     }
 570 }
 571
 572 impl<'a, 'tcx> Decodable<DecodeContext<'a, 'tcx>> for &'tcx [(ty::Predicate<'tcx>, Span)] {
 573     fn decode(d: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> {
 574         ty::codec::RefDecodable::decode(d)
 575     }
 576 }
 577
 578 impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>>
 579     for Lazy<T>
 580 {
 581     fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> {
 582         decoder.read_lazy_with_meta(())
 583     }
 584 }
 585
 586 impl<'a, 'tcx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>>
 587     for Lazy<[T]>
 588 {
 589     fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> {
 590         let len = decoder.read_usize()?;
 591         if len == 0 { Ok(Lazy::empty()) } else { decoder.read_lazy_with_meta(len) }
 592     }
 593 }
 594
 595 impl<'a, 'tcx, I: Idx, T: Decodable<DecodeContext<'a, 'tcx>>> Decodable<DecodeContext<'a, 'tcx>>
 596     for Lazy<Table<I, T>>
 597 where
 598     Option<T>: FixedSizeEncoding,
 599 {
 600     fn decode(decoder: &mut DecodeContext<'a, 'tcx>) -> Result<Self, String> {
 601         let len = decoder.read_usize()?;
 602         decoder.read_lazy_with_meta(len)
 603     }
 604 }
 605
 606 implement_ty_decoder!(DecodeContext<'a, 'tcx>);
 607
 608 impl MetadataBlob {
 609     crate fn new(metadata_ref: MetadataRef) -> MetadataBlob {
 610         MetadataBlob(metadata_ref)
 611     }
 612
 613     crate fn is_compatible(&self) -> bool {
 614         self.raw_bytes().starts_with(METADATA_HEADER)
 615     }
 616
 617     crate fn get_rustc_version(&self) -> String {
 618         Lazy::<String>::from_position(NonZeroUsize::new(METADATA_HEADER.len() + 4).unwrap())
 619             .decode(self)
 620     }
 621
 622     crate fn get_root(&self) -> CrateRoot<'tcx> {
 623         let slice = self.raw_bytes();
 624         let offset = METADATA_HEADER.len();
 625         let pos = (((slice[offset + 0] as u32) << 24)
 626             | ((slice[offset + 1] as u32) << 16)
 627             | ((slice[offset + 2] as u32) << 8)
 628             | ((slice[offset + 3] as u32) << 0)) as usize;
 629         Lazy::<CrateRoot<'tcx>>::from_position(NonZeroUsize::new(pos).unwrap()).decode(self)
 630     }
 631
 632     crate fn list_crate_metadata(&self, out: &mut dyn io::Write) -> io::Result<()> {
 633         write!(out, "=External Dependencies=\n")?;
 634         let root = self.get_root();
 635         for (i, dep) in root.crate_deps.decode(self).enumerate() {
 636             write!(out, "{} {}{}\n", i + 1, dep.name, dep.extra_filename)?;
 637         }
 638         write!(out, "\n")?;
 639         Ok(())
 640     }
 641 }
 642
 643 impl EntryKind {
 644     fn def_kind(&self) -> DefKind {
 645         match *self {
 646             EntryKind::AnonConst(..) => DefKind::AnonConst,
 647             EntryKind::Const(..) => DefKind::Const,
 648             EntryKind::AssocConst(..) => DefKind::AssocConst,
 649             EntryKind::ImmStatic
 650             | EntryKind::MutStatic
 651             | EntryKind::ForeignImmStatic
 652             | EntryKind::ForeignMutStatic => DefKind::Static,
 653             EntryKind::Struct(_, _) => DefKind::Struct,
 654             EntryKind::Union(_, _) => DefKind::Union,
 655             EntryKind::Fn(_) | EntryKind::ForeignFn(_) => DefKind::Fn,
 656             EntryKind::AssocFn(_) => DefKind::AssocFn,
 657             EntryKind::Type => DefKind::TyAlias,
 658             EntryKind::TypeParam => DefKind::TyParam,
 659             EntryKind::ConstParam => DefKind::ConstParam,
 660             EntryKind::OpaqueTy => DefKind::OpaqueTy,
 661             EntryKind::AssocType(_) => DefKind::AssocTy,
 662             EntryKind::Mod(_) => DefKind::Mod,
 663             EntryKind::Variant(_) => DefKind::Variant,
 664             EntryKind::Trait(_) => DefKind::Trait,
 665             EntryKind::TraitAlias => DefKind::TraitAlias,
 666             EntryKind::Enum(..) => DefKind::Enum,
 667             EntryKind::MacroDef(_) => DefKind::Macro(MacroKind::Bang),
 668             EntryKind::ForeignType => DefKind::ForeignTy,
 669             EntryKind::Impl(_) => DefKind::Impl,
 670             EntryKind::Closure => DefKind::Closure,
 671             EntryKind::ForeignMod => DefKind::ForeignMod,
 672             EntryKind::GlobalAsm => DefKind::GlobalAsm,
 673             EntryKind::Field => DefKind::Field,
 674             EntryKind::Generator(_) => DefKind::Generator,
 675         }
 676     }
 677 }
 678
 679 impl CrateRoot<'_> {
 680     crate fn is_proc_macro_crate(&self) -> bool {
 681         self.proc_macro_data.is_some()
 682     }
 683
 684     crate fn name(&self) -> Symbol {
 685         self.name
 686     }
 687
 688     crate fn disambiguator(&self) -> CrateDisambiguator {
 689         self.disambiguator
 690     }
 691
 692     crate fn hash(&self) -> Svh {
 693         self.hash
 694     }
 695
 696     crate fn triple(&self) -> &TargetTriple {
 697         &self.triple
 698     }
 699
 700     crate fn decode_crate_deps(
 701         &self,
 702         metadata: &'a MetadataBlob,
 703     ) -> impl ExactSizeIterator<Item = CrateDep> + Captures<'a> {
 704         self.crate_deps.decode(metadata)
 705     }
 706 }
 707
 708 impl<'a, 'tcx> CrateMetadataRef<'a> {
 709     fn is_proc_macro(&self, id: DefIndex) -> bool {
 710         self.root
 711             .proc_macro_data
 712             .as_ref()
 713             .and_then(|data| data.macros.decode(self).find(|x| *x == id))
 714             .is_some()
 715     }
 716
 717     fn maybe_kind(&self, item_id: DefIndex) -> Option<EntryKind> {
 718         self.root.tables.kind.get(self, item_id).map(|k| k.decode(self))
 719     }
 720
 721     fn kind(&self, item_id: DefIndex) -> EntryKind {
 722         assert!(!self.is_proc_macro(item_id));
 723         self.maybe_kind(item_id).unwrap_or_else(|| {
 724             bug!(
 725                 "CrateMetadata::kind({:?}): id not found, in crate {:?} with number {}",
 726                 item_id,
 727                 self.root.name,
 728                 self.cnum,
 729             )
 730         })
 731     }
 732
 733     fn raw_proc_macro(&self, id: DefIndex) -> &ProcMacro {
 734         // DefIndex's in root.proc_macro_data have a one-to-one correspondence
 735         // with items in 'raw_proc_macros'.
 736         let pos = self
 737             .root
 738             .proc_macro_data
 739             .as_ref()
 740             .unwrap()
 741             .macros
 742             .decode(self)
 743             .position(|i| i == id)
 744             .unwrap();
 745         &self.raw_proc_macros.unwrap()[pos]
 746     }
 747
 748     fn item_ident(&self, item_index: DefIndex, sess: &Session) -> Ident {
 749         if !self.is_proc_macro(item_index) {
 750             let name = self
 751                 .def_key(item_index)
 752                 .disambiguated_data
 753                 .data
 754                 .get_opt_name()
 755                 .expect("no name in item_ident");
 756             let span = self
 757                 .root
 758                 .tables
 759                 .ident_span
 760                 .get(self, item_index)
 761                 .map(|data| data.decode((self, sess)))
 762                 .unwrap_or_else(|| panic!("Missing ident span for {:?} ({:?})", name, item_index));
 763             Ident::new(name, span)
 764         } else {
 765             Ident::new(
 766                 Symbol::intern(self.raw_proc_macro(item_index).name()),
 767                 self.get_span(item_index, sess),
 768             )
 769         }
 770     }
 771
 772     fn def_kind(&self, index: DefIndex) -> DefKind {
 773         if !self.is_proc_macro(index) {
 774             self.kind(index).def_kind()
 775         } else {
 776             DefKind::Macro(macro_kind(self.raw_proc_macro(index)))
 777         }
 778     }
 779
 780     fn get_span(&self, index: DefIndex, sess: &Session) -> Span {
 781         self.root
 782             .tables
 783             .span
 784             .get(self, index)
 785             .unwrap_or_else(|| panic!("Missing span for {:?}", index))
 786             .decode((self, sess))
 787     }
 788
 789     fn load_proc_macro(&self, id: DefIndex, sess: &Session) -> SyntaxExtension {
 790         let (name, kind, helper_attrs) = match *self.raw_proc_macro(id) {
 791             ProcMacro::CustomDerive { trait_name, attributes, client } => {
 792                 let helper_attrs =
 793                     attributes.iter().cloned().map(Symbol::intern).collect::<Vec<_>>();
 794                 (
 795                     trait_name,
 796                     SyntaxExtensionKind::Derive(Box::new(ProcMacroDerive { client })),
 797                     helper_attrs,
 798                 )
 799             }
 800             ProcMacro::Attr { name, client } => {
 801                 (name, SyntaxExtensionKind::Attr(Box::new(AttrProcMacro { client })), Vec::new())
 802             }
 803             ProcMacro::Bang { name, client } => {
 804                 (name, SyntaxExtensionKind::Bang(Box::new(BangProcMacro { client })), Vec::new())
 805             }
 806         };
 807
 808         SyntaxExtension::new(
 809             sess,
 810             kind,
 811             self.get_span(id, sess),
 812             helper_attrs,
 813             self.root.edition,
 814             Symbol::intern(name),
 815             &self.get_item_attrs(id, sess),
 816         )
 817     }
 818
 819     fn get_trait_def(&self, item_id: DefIndex, sess: &Session) -> ty::TraitDef {
 820         match self.kind(item_id) {
 821             EntryKind::Trait(data) => {
 822                 let data = data.decode((self, sess));
 823                 ty::TraitDef::new(
 824                     self.local_def_id(item_id),
 825                     data.unsafety,
 826                     data.paren_sugar,
 827                     data.has_auto_impl,
 828                     data.is_marker,
 829                     data.specialization_kind,
 830                     self.def_path_hash(item_id),
 831                 )
 832             }
 833             EntryKind::TraitAlias => ty::TraitDef::new(
 834                 self.local_def_id(item_id),
 835                 hir::Unsafety::Normal,
 836                 false,
 837                 false,
 838                 false,
 839                 ty::trait_def::TraitSpecializationKind::None,
 840                 self.def_path_hash(item_id),
 841             ),
 842             _ => bug!("def-index does not refer to trait or trait alias"),
 843         }
 844     }
 845
 846     fn get_variant(
 847         &self,
 848         kind: &EntryKind,
 849         index: DefIndex,
 850         parent_did: DefId,
 851         sess: &Session,
 852     ) -> ty::VariantDef {
 853         let data = match kind {
 854             EntryKind::Variant(data) | EntryKind::Struct(data, _) | EntryKind::Union(data, _) => {
 855                 data.decode(self)
 856             }
 857             _ => bug!(),
 858         };
 859
 860         let adt_kind = match kind {
 861             EntryKind::Variant(_) => ty::AdtKind::Enum,
 862             EntryKind::Struct(..) => ty::AdtKind::Struct,
 863             EntryKind::Union(..) => ty::AdtKind::Union,
 864             _ => bug!(),
 865         };
 866
 867         let variant_did =
 868             if adt_kind == ty::AdtKind::Enum { Some(self.local_def_id(index)) } else { None };
 869         let ctor_did = data.ctor.map(|index| self.local_def_id(index));
 870
 871         ty::VariantDef::new(
 872             self.item_ident(index, sess),
 873             variant_did,
 874             ctor_did,
 875             data.discr,
 876             self.root
 877                 .tables
 878                 .children
 879                 .get(self, index)
 880                 .unwrap_or(Lazy::empty())
 881                 .decode(self)
 882                 .map(|index| ty::FieldDef {
 883                     did: self.local_def_id(index),
 884                     ident: self.item_ident(index, sess),
 885                     vis: self.get_visibility(index),
 886                 })
 887                 .collect(),
 888             data.ctor_kind,
 889             adt_kind,
 890             parent_did,
 891             false,
 892             data.is_non_exhaustive,
 893         )
 894     }
 895
 896     fn get_adt_def(&self, item_id: DefIndex, tcx: TyCtxt<'tcx>) -> &'tcx ty::AdtDef {
 897         let kind = self.kind(item_id);
 898         let did = self.local_def_id(item_id);
 899
 900         let (adt_kind, repr) = match kind {
 901             EntryKind::Enum(repr) => (ty::AdtKind::Enum, repr),
 902             EntryKind::Struct(_, repr) => (ty::AdtKind::Struct, repr),
 903             EntryKind::Union(_, repr) => (ty::AdtKind::Union, repr),
 904             _ => bug!("get_adt_def called on a non-ADT {:?}", did),
 905         };
 906
 907         let variants = if let ty::AdtKind::Enum = adt_kind {
 908             self.root
 909                 .tables
 910                 .children
 911                 .get(self, item_id)
 912                 .unwrap_or(Lazy::empty())
 913                 .decode(self)
 914                 .map(|index| self.get_variant(&self.kind(index), index, did, tcx.sess))
 915                 .collect()
 916         } else {
 917             std::iter::once(self.get_variant(&kind, item_id, did, tcx.sess)).collect()
 918         };
 919
 920         tcx.alloc_adt_def(did, adt_kind, variants, repr)
 921     }
 922
 923     fn get_explicit_predicates(
 924         &self,
 925         item_id: DefIndex,
 926         tcx: TyCtxt<'tcx>,
 927     ) -> ty::GenericPredicates<'tcx> {
 928         self.root.tables.explicit_predicates.get(self, item_id).unwrap().decode((self, tcx))
 929     }
 930
 931     fn get_inferred_outlives(
 932         &self,
 933         item_id: DefIndex,
 934         tcx: TyCtxt<'tcx>,
 935     ) -> &'tcx [(ty::Predicate<'tcx>, Span)] {
 936         self.root
 937             .tables
 938             .inferred_outlives
 939             .get(self, item_id)
 940             .map(|predicates| predicates.decode((self, tcx)))
 941             .unwrap_or_default()
 942     }
 943
 944     fn get_super_predicates(
 945         &self,
 946         item_id: DefIndex,
 947         tcx: TyCtxt<'tcx>,
 948     ) -> ty::GenericPredicates<'tcx> {
 949         self.root.tables.super_predicates.get(self, item_id).unwrap().decode((self, tcx))
 950     }
 951
 952     fn get_generics(&self, item_id: DefIndex, sess: &Session) -> ty::Generics {
 953         self.root.tables.generics.get(self, item_id).unwrap().decode((self, sess))
 954     }
 955
 956     fn get_type(&self, id: DefIndex, tcx: TyCtxt<'tcx>) -> Ty<'tcx> {
 957         self.root.tables.ty.get(self, id).unwrap().decode((self, tcx))
 958     }
 959
 960     fn get_stability(&self, id: DefIndex) -> Option<attr::Stability> {
 961         match self.is_proc_macro(id) {
 962             true => self.root.proc_macro_data.as_ref().unwrap().stability,
 963             false => self.root.tables.stability.get(self, id).map(|stab| stab.decode(self)),
 964         }
 965     }
 966
 967     fn get_const_stability(&self, id: DefIndex) -> Option<attr::ConstStability> {
 968         self.root.tables.const_stability.get(self, id).map(|stab| stab.decode(self))
 969     }
 970
 971     fn get_deprecation(&self, id: DefIndex) -> Option<attr::Deprecation> {
 972         self.root
 973             .tables
 974             .deprecation
 975             .get(self, id)
 976             .filter(|_| !self.is_proc_macro(id))
 977             .map(|depr| depr.decode(self))
 978     }
 979
 980     fn get_visibility(&self, id: DefIndex) -> ty::Visibility {
 981         match self.is_proc_macro(id) {
 982             true => ty::Visibility::Public,
 983             false => self.root.tables.visibility.get(self, id).unwrap().decode(self),
 984         }
 985     }
 986
 987     fn get_impl_data(&self, id: DefIndex) -> ImplData {
 988         match self.kind(id) {
 989             EntryKind::Impl(data) => data.decode(self),
 990             _ => bug!(),
 991         }
 992     }
 993
 994     fn get_parent_impl(&self, id: DefIndex) -> Option<DefId> {
 995         self.get_impl_data(id).parent_impl
 996     }
 997
 998     fn get_impl_polarity(&self, id: DefIndex) -> ty::ImplPolarity {
 999         self.get_impl_data(id).polarity
1000     }
1001
1002     fn get_impl_defaultness(&self, id: DefIndex) -> hir::Defaultness {
1003         self.get_impl_data(id).defaultness
1004     }
1005
1006     fn get_coerce_unsized_info(&self, id: DefIndex) -> Option<ty::adjustment::CoerceUnsizedInfo> {
1007         self.get_impl_data(id).coerce_unsized_info
1008     }
1009
1010     fn get_impl_trait(&self, id: DefIndex, tcx: TyCtxt<'tcx>) -> Option<ty::TraitRef<'tcx>> {
1011         self.root.tables.impl_trait_ref.get(self, id).map(|tr| tr.decode((self, tcx)))
1012     }
1013
1014     /// Iterates over all the stability attributes in the given crate.
1015     fn get_lib_features(&self, tcx: TyCtxt<'tcx>) -> &'tcx [(Symbol, Option<Symbol>)] {
1016         // FIXME: For a proc macro crate, not sure whether we should return the "host"
1017         // features or an empty Vec. Both don't cause ICEs.
1018         tcx.arena.alloc_from_iter(self.root.lib_features.decode(self))
1019     }
1020
1021     /// Iterates over the language items in the given crate.
1022     fn get_lang_items(&self, tcx: TyCtxt<'tcx>) -> &'tcx [(DefId, usize)] {
1023         if self.root.is_proc_macro_crate() {
1024             // Proc macro crates do not export any lang-items to the target.
1025             &[]
1026         } else {
1027             tcx.arena.alloc_from_iter(
1028                 self.root
1029                     .lang_items
1030                     .decode(self)
1031                     .map(|(def_index, index)| (self.local_def_id(def_index), index)),
1032             )
1033         }
1034     }
1035
1036     /// Iterates over the diagnostic items in the given crate.
1037     fn get_diagnostic_items(&self) -> FxHashMap<Symbol, DefId> {
1038         if self.root.is_proc_macro_crate() {
1039             // Proc macro crates do not export any diagnostic-items to the target.
1040             Default::default()
1041         } else {
1042             self.root
1043                 .diagnostic_items
1044                 .decode(self)
1045                 .map(|(name, def_index)| (name, self.local_def_id(def_index)))
1046                 .collect()
1047         }
1048     }
1049
1050     /// Iterates over each child of the given item.
1051     fn each_child_of_item<F>(&self, id: DefIndex, mut callback: F, sess: &Session)
1052     where
1053         F: FnMut(Export<hir::HirId>),
1054     {
1055         if let Some(data) = &self.root.proc_macro_data {
1056             /* If we are loading as a proc macro, we want to return the view of this crate
1057              * as a proc macro crate.
1058              */
1059             if id == CRATE_DEF_INDEX {
1060                 let macros = data.macros.decode(self);
1061                 for def_index in macros {
1062                     let raw_macro = self.raw_proc_macro(def_index);
1063                     let res = Res::Def(
1064                         DefKind::Macro(macro_kind(raw_macro)),
1065                         self.local_def_id(def_index),
1066                     );
1067                     let ident = self.item_ident(def_index, sess);
1068                     callback(Export { ident, res, vis: ty::Visibility::Public, span: ident.span });
1069                 }
1070             }
1071             return;
1072         }
1073
1074         // Find the item.
1075         let kind = match self.maybe_kind(id) {
1076             None => return,
1077             Some(kind) => kind,
1078         };
1079
1080         // Iterate over all children.
1081         let macros_only = self.dep_kind.lock().macros_only();
1082         let children = self.root.tables.children.get(self, id).unwrap_or(Lazy::empty());
1083         for child_index in children.decode((self, sess)) {
1084             if macros_only {
1085                 continue;
1086             }
1087
1088             // Get the item.
1089             if let Some(child_kind) = self.maybe_kind(child_index) {
1090                 match child_kind {
1091                     EntryKind::MacroDef(..) => {}
1092                     _ if macros_only => continue,
1093                     _ => {}
1094                 }
1095
1096                 // Hand off the item to the callback.
1097                 match child_kind {
1098                     // FIXME(eddyb) Don't encode these in children.
1099                     EntryKind::ForeignMod => {
1100                         let child_children = self
1101                             .root
1102                             .tables
1103                             .children
1104                             .get(self, child_index)
1105                             .unwrap_or(Lazy::empty());
1106                         for child_index in child_children.decode((self, sess)) {
1107                             let kind = self.def_kind(child_index);
1108                             callback(Export {
1109                                 res: Res::Def(kind, self.local_def_id(child_index)),
1110                                 ident: self.item_ident(child_index, sess),
1111                                 vis: self.get_visibility(child_index),
1112                                 span: self
1113                                     .root
1114                                     .tables
1115                                     .span
1116                                     .get(self, child_index)
1117                                     .unwrap()
1118                                     .decode((self, sess)),
1119                             });
1120                         }
1121                         continue;
1122                     }
1123                     EntryKind::Impl(_) => continue,
1124
1125                     _ => {}
1126                 }
1127
1128                 let def_key = self.def_key(child_index);
1129                 let span = self.get_span(child_index, sess);
1130                 if def_key.disambiguated_data.data.get_opt_name().is_some() {
1131                     let kind = self.def_kind(child_index);
1132                     let ident = self.item_ident(child_index, sess);
1133                     let vis = self.get_visibility(child_index);
1134                     let def_id = self.local_def_id(child_index);
1135                     let res = Res::Def(kind, def_id);
1136                     callback(Export { res, ident, vis, span });
1137                     // For non-re-export structs and variants add their constructors to children.
1138                     // Re-export lists automatically contain constructors when necessary.
1139                     match kind {
1140                         DefKind::Struct => {
1141                             if let Some(ctor_def_id) = self.get_ctor_def_id(child_index) {
1142                                 let ctor_kind = self.get_ctor_kind(child_index);
1143                                 let ctor_res =
1144                                     Res::Def(DefKind::Ctor(CtorOf::Struct, ctor_kind), ctor_def_id);
1145                                 let vis = self.get_visibility(ctor_def_id.index);
1146                                 callback(Export { res: ctor_res, vis, ident, span });
1147                             }
1148                         }
1149                         DefKind::Variant => {
1150                             // Braced variants, unlike structs, generate unusable names in
1151                             // value namespace, they are reserved for possible future use.
1152                             // It's ok to use the variant's id as a ctor id since an
1153                             // error will be reported on any use of such resolution anyway.
1154                             let ctor_def_id = self.get_ctor_def_id(child_index).unwrap_or(def_id);
1155                             let ctor_kind = self.get_ctor_kind(child_index);
1156                             let ctor_res =
1157                                 Res::Def(DefKind::Ctor(CtorOf::Variant, ctor_kind), ctor_def_id);
1158                             let mut vis = self.get_visibility(ctor_def_id.index);
1159                             if ctor_def_id == def_id && vis == ty::Visibility::Public {
1160                                 // For non-exhaustive variants lower the constructor visibility to
1161                                 // within the crate. We only need this for fictive constructors,
1162                                 // for other constructors correct visibilities
1163                                 // were already encoded in metadata.
1164                                 let attrs = self.get_item_attrs(def_id.index, sess);
1165                                 if sess.contains_name(&attrs, sym::non_exhaustive) {
1166                                     let crate_def_id = self.local_def_id(CRATE_DEF_INDEX);
1167                                     vis = ty::Visibility::Restricted(crate_def_id);
1168                                 }
1169                             }
1170                             callback(Export { res: ctor_res, ident, vis, span });
1171                         }
1172                         _ => {}
1173                     }
1174                 }
1175             }
1176         }
1177
1178         if let EntryKind::Mod(data) = kind {
1179             for exp in data.decode((self, sess)).reexports.decode((self, sess)) {
1180                 match exp.res {
1181                     Res::Def(DefKind::Macro(..), _) => {}
1182                     _ if macros_only => continue,
1183                     _ => {}
1184                 }
1185                 callback(exp);
1186             }
1187         }
1188     }
1189
1190     fn is_item_mir_available(&self, id: DefIndex) -> bool {
1191         !self.is_proc_macro(id) && self.root.tables.mir.get(self, id).is_some()
1192     }
1193
1194     fn module_expansion(&self, id: DefIndex, sess: &Session) -> ExpnId {
1195         if let EntryKind::Mod(m) = self.kind(id) {
1196             m.decode((self, sess)).expansion
1197         } else {
1198             panic!("Expected module, found {:?}", self.local_def_id(id))
1199         }
1200     }
1201
1202     fn get_optimized_mir(&self, tcx: TyCtxt<'tcx>, id: DefIndex) -> Body<'tcx> {
1203         self.root
1204             .tables
1205             .mir
1206             .get(self, id)
1207             .filter(|_| !self.is_proc_macro(id))
1208             .unwrap_or_else(|| {
1209                 bug!("get_optimized_mir: missing MIR for `{:?}`", self.local_def_id(id))
1210             })
1211             .decode((self, tcx))
1212     }
1213
1214     fn get_mir_abstract_const(
1215         &self,
1216         tcx: TyCtxt<'tcx>,
1217         id: DefIndex,
1218     ) -> Result<Option<&'tcx [mir::abstract_const::Node<'tcx>]>, ErrorReported> {
1219         self.root
1220             .tables
1221             .mir_abstract_consts
1222             .get(self, id)
1223             .filter(|_| !self.is_proc_macro(id))
1224             .map_or(Ok(None), |v| Ok(Some(v.decode((self, tcx)))))
1225     }
1226
1227     fn get_unused_generic_params(&self, id: DefIndex) -> FiniteBitSet<u32> {
1228         self.root
1229             .tables
1230             .unused_generic_params
1231             .get(self, id)
1232             .filter(|_| !self.is_proc_macro(id))
1233             .map(|params| params.decode(self))
1234             .unwrap_or_default()
1235     }
1236
1237     fn get_promoted_mir(&self, tcx: TyCtxt<'tcx>, id: DefIndex) -> IndexVec<Promoted, Body<'tcx>> {
1238         self.root
1239             .tables
1240             .promoted_mir
1241             .get(self, id)
1242             .filter(|_| !self.is_proc_macro(id))
1243             .unwrap_or_else(|| {
1244                 bug!("get_promoted_mir: missing MIR for `{:?}`", self.local_def_id(id))
1245             })
1246             .decode((self, tcx))
1247     }
1248
1249     fn mir_const_qualif(&self, id: DefIndex) -> mir::ConstQualifs {
1250         match self.kind(id) {
1251             EntryKind::AnonConst(qualif, _)
1252             | EntryKind::Const(qualif, _)
1253             | EntryKind::AssocConst(
1254                 AssocContainer::ImplDefault
1255                 | AssocContainer::ImplFinal
1256                 | AssocContainer::TraitWithDefault,
1257                 qualif,
1258                 _,
1259             ) => qualif,
1260             _ => bug!("mir_const_qualif: unexpected kind"),
1261         }
1262     }
1263
1264     fn get_associated_item(&self, id: DefIndex, sess: &Session) -> ty::AssocItem {
1265         let def_key = self.def_key(id);
1266         let parent = self.local_def_id(def_key.parent.unwrap());
1267         let ident = self.item_ident(id, sess);
1268
1269         let (kind, container, has_self) = match self.kind(id) {
1270             EntryKind::AssocConst(container, _, _) => (ty::AssocKind::Const, container, false),
1271             EntryKind::AssocFn(data) => {
1272                 let data = data.decode(self);
1273                 (ty::AssocKind::Fn, data.container, data.has_self)
1274             }
1275             EntryKind::AssocType(container) => (ty::AssocKind::Type, container, false),
1276             _ => bug!("cannot get associated-item of `{:?}`", def_key),
1277         };
1278
1279         ty::AssocItem {
1280             ident,
1281             kind,
1282             vis: self.get_visibility(id),
1283             defaultness: container.defaultness(),
1284             def_id: self.local_def_id(id),
1285             container: container.with_def_id(parent),
1286             fn_has_self_parameter: has_self,
1287         }
1288     }
1289
1290     fn get_item_variances(&self, id: DefIndex) -> Vec<ty::Variance> {
1291         self.root.tables.variances.get(self, id).unwrap_or(Lazy::empty()).decode(self).collect()
1292     }
1293
1294     fn get_ctor_kind(&self, node_id: DefIndex) -> CtorKind {
1295         match self.kind(node_id) {
1296             EntryKind::Struct(data, _) | EntryKind::Union(data, _) | EntryKind::Variant(data) => {
1297                 data.decode(self).ctor_kind
1298             }
1299             _ => CtorKind::Fictive,
1300         }
1301     }
1302
1303     fn get_ctor_def_id(&self, node_id: DefIndex) -> Option<DefId> {
1304         match self.kind(node_id) {
1305             EntryKind::Struct(data, _) => {
1306                 data.decode(self).ctor.map(|index| self.local_def_id(index))
1307             }
1308             EntryKind::Variant(data) => {
1309                 data.decode(self).ctor.map(|index| self.local_def_id(index))
1310             }
1311             _ => None,
1312         }
1313     }
1314
1315     fn get_item_attrs(&self, node_id: DefIndex, sess: &Session) -> Vec<ast::Attribute> {
1316         // The attributes for a tuple struct/variant are attached to the definition, not the ctor;
1317         // we assume that someone passing in a tuple struct ctor is actually wanting to
1318         // look at the definition
1319         let def_key = self.def_key(node_id);
1320         let item_id = if def_key.disambiguated_data.data == DefPathData::Ctor {
1321             def_key.parent.unwrap()
1322         } else {
1323             node_id
1324         };
1325
1326         self.root
1327             .tables
1328             .attributes
1329             .get(self, item_id)
1330             .unwrap_or(Lazy::empty())
1331             .decode((self, sess))
1332             .collect::<Vec<_>>()
1333     }
1334
1335     fn get_struct_field_names(&self, id: DefIndex, sess: &Session) -> Vec<Spanned<Symbol>> {
1336         self.root
1337             .tables
1338             .children
1339             .get(self, id)
1340             .unwrap_or(Lazy::empty())
1341             .decode(self)
1342             .map(|index| respan(self.get_span(index, sess), self.item_ident(index, sess).name))
1343             .collect()
1344     }
1345
1346     fn get_inherent_implementations_for_type(
1347         &self,
1348         tcx: TyCtxt<'tcx>,
1349         id: DefIndex,
1350     ) -> &'tcx [DefId] {
1351         tcx.arena.alloc_from_iter(
1352             self.root
1353                 .tables
1354                 .inherent_impls
1355                 .get(self, id)
1356                 .unwrap_or(Lazy::empty())
1357                 .decode(self)
1358                 .map(|index| self.local_def_id(index)),
1359         )
1360     }
1361
1362     fn get_implementations_for_trait(
1363         &self,
1364         tcx: TyCtxt<'tcx>,
1365         filter: Option<DefId>,
1366     ) -> &'tcx [(DefId, Option<ty::fast_reject::SimplifiedType>)] {
1367         if self.root.is_proc_macro_crate() {
1368             // proc-macro crates export no trait impls.
1369             return &[];
1370         }
1371
1372         // Do a reverse lookup beforehand to avoid touching the crate_num
1373         // hash map in the loop below.
1374         let filter = match filter.map(|def_id| self.reverse_translate_def_id(def_id)) {
1375             Some(Some(def_id)) => Some((def_id.krate.as_u32(), def_id.index)),
1376             Some(None) => return &[],
1377             None => None,
1378         };
1379
1380         if let Some(filter) = filter {
1381             if let Some(impls) = self.trait_impls.get(&filter) {
1382                 tcx.arena.alloc_from_iter(
1383                     impls.decode(self).map(|(idx, simplified_self_ty)| {
1384                         (self.local_def_id(idx), simplified_self_ty)
1385                     }),
1386                 )
1387             } else {
1388                 &[]
1389             }
1390         } else {
1391             tcx.arena.alloc_from_iter(self.trait_impls.values().flat_map(|impls| {
1392                 impls
1393                     .decode(self)
1394                     .map(|(idx, simplified_self_ty)| (self.local_def_id(idx), simplified_self_ty))
1395             }))
1396         }
1397     }
1398
1399     fn get_trait_of_item(&self, id: DefIndex) -> Option<DefId> {
1400         let def_key = self.def_key(id);
1401         match def_key.disambiguated_data.data {
1402             DefPathData::TypeNs(..) | DefPathData::ValueNs(..) => (),
1403             // Not an associated item
1404             _ => return None,
1405         }
1406         def_key.parent.and_then(|parent_index| match self.kind(parent_index) {
1407             EntryKind::Trait(_) | EntryKind::TraitAlias => Some(self.local_def_id(parent_index)),
1408             _ => None,
1409         })
1410     }
1411
1412     fn get_native_libraries(&self, sess: &Session) -> Vec<NativeLib> {
1413         if self.root.is_proc_macro_crate() {
1414             // Proc macro crates do not have any *target* native libraries.
1415             vec![]
1416         } else {
1417             self.root.native_libraries.decode((self, sess)).collect()
1418         }
1419     }
1420
1421     fn get_foreign_modules(&self, tcx: TyCtxt<'tcx>) -> &'tcx [ForeignModule] {
1422         if self.root.is_proc_macro_crate() {
1423             // Proc macro crates do not have any *target* foreign modules.
1424             &[]
1425         } else {
1426             tcx.arena.alloc_from_iter(self.root.foreign_modules.decode((self, tcx.sess)))
1427         }
1428     }
1429
1430     fn get_dylib_dependency_formats(
1431         &self,
1432         tcx: TyCtxt<'tcx>,
1433     ) -> &'tcx [(CrateNum, LinkagePreference)] {
1434         tcx.arena.alloc_from_iter(
1435             self.root.dylib_dependency_formats.decode(self).enumerate().flat_map(|(i, link)| {
1436                 let cnum = CrateNum::new(i + 1);
1437                 link.map(|link| (self.cnum_map[cnum], link))
1438             }),
1439         )
1440     }
1441
1442     fn get_missing_lang_items(&self, tcx: TyCtxt<'tcx>) -> &'tcx [lang_items::LangItem] {
1443         if self.root.is_proc_macro_crate() {
1444             // Proc macro crates do not depend on any target weak lang-items.
1445             &[]
1446         } else {
1447             tcx.arena.alloc_from_iter(self.root.lang_items_missing.decode(self))
1448         }
1449     }
1450
1451     fn get_fn_param_names(&self, tcx: TyCtxt<'tcx>, id: DefIndex) -> &'tcx [Ident] {
1452         let param_names = match self.kind(id) {
1453             EntryKind::Fn(data) | EntryKind::ForeignFn(data) => data.decode(self).param_names,
1454             EntryKind::AssocFn(data) => data.decode(self).fn_data.param_names,
1455             _ => Lazy::empty(),
1456         };
1457         tcx.arena.alloc_from_iter(param_names.decode((self, tcx)))
1458     }
1459
1460     fn exported_symbols(
1461         &self,
1462         tcx: TyCtxt<'tcx>,
1463     ) -> &'tcx [(ExportedSymbol<'tcx>, SymbolExportLevel)] {
1464         if self.root.is_proc_macro_crate() {
1465             // If this crate is a custom derive crate, then we're not even going to
1466             // link those in so we skip those crates.
1467             &[]
1468         } else {
1469             tcx.arena.alloc_from_iter(self.root.exported_symbols.decode((self, tcx)))
1470         }
1471     }
1472
1473     fn get_rendered_const(&self, id: DefIndex) -> String {
1474         match self.kind(id) {
1475             EntryKind::AnonConst(_, data)
1476             | EntryKind::Const(_, data)
1477             | EntryKind::AssocConst(_, _, data) => data.decode(self).0,
1478             _ => bug!(),
1479         }
1480     }
1481
1482     fn get_macro(&self, id: DefIndex, sess: &Session) -> MacroDef {
1483         match self.kind(id) {
1484             EntryKind::MacroDef(macro_def) => macro_def.decode((self, sess)),
1485             _ => bug!(),
1486         }
1487     }
1488
1489     // This replicates some of the logic of the crate-local `is_const_fn_raw` query, because we
1490     // don't serialize constness for tuple variant and tuple struct constructors.
1491     fn is_const_fn_raw(&self, id: DefIndex) -> bool {
1492         let constness = match self.kind(id) {
1493             EntryKind::AssocFn(data) => data.decode(self).fn_data.constness,
1494             EntryKind::Fn(data) => data.decode(self).constness,
1495             EntryKind::ForeignFn(data) => data.decode(self).constness,
1496             EntryKind::Variant(..) | EntryKind::Struct(..) => hir::Constness::Const,
1497             _ => hir::Constness::NotConst,
1498         };
1499         constness == hir::Constness::Const
1500     }
1501
1502     fn asyncness(&self, id: DefIndex) -> hir::IsAsync {
1503         match self.kind(id) {
1504             EntryKind::Fn(data) => data.decode(self).asyncness,
1505             EntryKind::AssocFn(data) => data.decode(self).fn_data.asyncness,
1506             EntryKind::ForeignFn(data) => data.decode(self).asyncness,
1507             _ => bug!("asyncness: expected function kind"),
1508         }
1509     }
1510
1511     fn is_foreign_item(&self, id: DefIndex) -> bool {
1512         match self.kind(id) {
1513             EntryKind::ForeignImmStatic | EntryKind::ForeignMutStatic | EntryKind::ForeignFn(_) => {
1514                 true
1515             }
1516             _ => false,
1517         }
1518     }
1519
1520     fn static_mutability(&self, id: DefIndex) -> Option<hir::Mutability> {
1521         match self.kind(id) {
1522             EntryKind::ImmStatic | EntryKind::ForeignImmStatic => Some(hir::Mutability::Not),
1523             EntryKind::MutStatic | EntryKind::ForeignMutStatic => Some(hir::Mutability::Mut),
1524             _ => None,
1525         }
1526     }
1527
1528     fn generator_kind(&self, id: DefIndex) -> Option<hir::GeneratorKind> {
1529         match self.kind(id) {
1530             EntryKind::Generator(data) => Some(data),
1531             _ => None,
1532         }
1533     }
1534
1535     fn fn_sig(&self, id: DefIndex, tcx: TyCtxt<'tcx>) -> ty::PolyFnSig<'tcx> {
1536         self.root.tables.fn_sig.get(self, id).unwrap().decode((self, tcx))
1537     }
1538
1539     #[inline]
1540     fn def_key(&self, index: DefIndex) -> DefKey {
1541         *self.def_key_cache.lock().entry(index).or_insert_with(|| {
1542             let mut key = self.root.tables.def_keys.get(self, index).unwrap().decode(self);
1543             if self.is_proc_macro(index) {
1544                 let name = self.raw_proc_macro(index).name();
1545                 key.disambiguated_data.data = DefPathData::MacroNs(Symbol::intern(name));
1546             }
1547             key
1548         })
1549     }
1550
1551     // Returns the path leading to the thing with this `id`.
1552     fn def_path(&self, id: DefIndex) -> DefPath {
1553         debug!("def_path(cnum={:?}, id={:?})", self.cnum, id);
1554         DefPath::make(self.cnum, id, |parent| self.def_key(parent))
1555     }
1556
1557     fn def_path_hash_unlocked(
1558         &self,
1559         index: DefIndex,
1560         def_path_hashes: &mut FxHashMap<DefIndex, DefPathHash>,
1561     ) -> DefPathHash {
1562         *def_path_hashes.entry(index).or_insert_with(|| {
1563             self.root.tables.def_path_hashes.get(self, index).unwrap().decode(self)
1564         })
1565     }
1566
1567     #[inline]
1568     fn def_path_hash(&self, index: DefIndex) -> DefPathHash {
1569         let mut def_path_hashes = self.def_path_hash_cache.lock();
1570         self.def_path_hash_unlocked(index, &mut def_path_hashes)
1571     }
1572
1573     fn all_def_path_hashes_and_def_ids(&self) -> Vec<(DefPathHash, DefId)> {
1574         let mut def_path_hashes = self.def_path_hash_cache.lock();
1575         let mut def_index_to_data = |index| {
1576             (self.def_path_hash_unlocked(index, &mut def_path_hashes), self.local_def_id(index))
1577         };
1578         if let Some(data) = &self.root.proc_macro_data {
1579             std::iter::once(CRATE_DEF_INDEX)
1580                 .chain(data.macros.decode(self))
1581                 .map(def_index_to_data)
1582                 .collect()
1583         } else {
1584             (0..self.num_def_ids())
1585                 .map(|index| def_index_to_data(DefIndex::from_usize(index)))
1586                 .collect()
1587         }
1588     }
1589
1590     /// Get the `DepNodeIndex` corresponding this crate. The result of this
1591     /// method is cached in the `dep_node_index` field.
1592     fn get_crate_dep_node_index(&self, tcx: TyCtxt<'tcx>) -> DepNodeIndex {
1593         let mut dep_node_index = self.dep_node_index.load();
1594
1595         if unlikely!(dep_node_index == DepNodeIndex::INVALID) {
1596             // We have not cached the DepNodeIndex for this upstream crate yet,
1597             // so use the dep-graph to find it out and cache it.
1598             // Note that multiple threads can enter this block concurrently.
1599             // That is fine because the DepNodeIndex remains constant
1600             // throughout the whole compilation session, and multiple stores
1601             // would always write the same value.
1602
1603             let def_path_hash = self.def_path_hash(CRATE_DEF_INDEX);
1604             let dep_node =
1605                 DepNode::from_def_path_hash(def_path_hash, dep_graph::DepKind::CrateMetadata);
1606
1607             dep_node_index = tcx.dep_graph.dep_node_index_of(&dep_node);
1608             assert!(dep_node_index != DepNodeIndex::INVALID);
1609             self.dep_node_index.store(dep_node_index);
1610         }
1611
1612         dep_node_index
1613     }
1614
1615     /// Imports the source_map from an external crate into the source_map of the crate
1616     /// currently being compiled (the "local crate").
1617     ///
1618     /// The import algorithm works analogous to how AST items are inlined from an
1619     /// external crate's metadata:
1620     /// For every SourceFile in the external source_map an 'inline' copy is created in the
1621     /// local source_map. The correspondence relation between external and local
1622     /// SourceFiles is recorded in the `ImportedSourceFile` objects returned from this
1623     /// function. When an item from an external crate is later inlined into this
1624     /// crate, this correspondence information is used to translate the span
1625     /// information of the inlined item so that it refers the correct positions in
1626     /// the local source_map (see `<decoder::DecodeContext as SpecializedDecoder<Span>>`).
1627     ///
1628     /// The import algorithm in the function below will reuse SourceFiles already
1629     /// existing in the local source_map. For example, even if the SourceFile of some
1630     /// source file of libstd gets imported many times, there will only ever be
1631     /// one SourceFile object for the corresponding file in the local source_map.
1632     ///
1633     /// Note that imported SourceFiles do not actually contain the source code of the
1634     /// file they represent, just information about length, line breaks, and
1635     /// multibyte characters. This information is enough to generate valid debuginfo
1636     /// for items inlined from other crates.
1637     ///
1638     /// Proc macro crates don't currently export spans, so this function does not have
1639     /// to work for them.
1640     fn imported_source_files(&self, sess: &Session) -> &'a [ImportedSourceFile] {
1641         // Translate the virtual `/rustc/$hash` prefix back to a real directory
1642         // that should hold actual sources, where possible.
1643         //
1644         // NOTE: if you update this, you might need to also update bootstrap's code for generating
1645         // the `rust-src` component in `Src::run` in `src/bootstrap/dist.rs`.
1646         let virtual_rust_source_base_dir = option_env!("CFG_VIRTUAL_RUST_SOURCE_BASE_DIR")
1647             .map(Path::new)
1648             .filter(|_| {
1649                 // Only spend time on further checks if we have what to translate *to*.
1650                 sess.real_rust_source_base_dir.is_some()
1651             })
1652             .filter(|virtual_dir| {
1653                 // Don't translate away `/rustc/$hash` if we're still remapping to it,
1654                 // since that means we're still building `std`/`rustc` that need it,
1655                 // and we don't want the real path to leak into codegen/debuginfo.
1656                 !sess.opts.remap_path_prefix.iter().any(|(_from, to)| to == virtual_dir)
1657             });
1658         let try_to_translate_virtual_to_real = |name: &mut rustc_span::FileName| {
1659             debug!(
1660                 "try_to_translate_virtual_to_real(name={:?}): \
1661                  virtual_rust_source_base_dir={:?}, real_rust_source_base_dir={:?}",
1662                 name, virtual_rust_source_base_dir, sess.real_rust_source_base_dir,
1663             );
1664
1665             if let Some(virtual_dir) = virtual_rust_source_base_dir {
1666                 if let Some(real_dir) = &sess.real_rust_source_base_dir {
1667                     if let rustc_span::FileName::Real(old_name) = name {
1668                         if let rustc_span::RealFileName::Named(one_path) = old_name {
1669                             if let Ok(rest) = one_path.strip_prefix(virtual_dir) {
1670                                 let virtual_name = one_path.clone();
1671
1672                                 // The std library crates are in
1673                                 // `$sysroot/lib/rustlib/src/rust/library`, whereas other crates
1674                                 // may be in `$sysroot/lib/rustlib/src/rust/` directly. So we
1675                                 // detect crates from the std libs and handle them specially.
1676                                 const STD_LIBS: &[&str] = &[
1677                                     "core",
1678                                     "alloc",
1679                                     "std",
1680                                     "test",
1681                                     "term",
1682                                     "unwind",
1683                                     "proc_macro",
1684                                     "panic_abort",
1685                                     "panic_unwind",
1686                                     "profiler_builtins",
1687                                     "rtstartup",
1688                                     "rustc-std-workspace-core",
1689                                     "rustc-std-workspace-alloc",
1690                                     "rustc-std-workspace-std",
1691                                     "backtrace",
1692                                 ];
1693                                 let is_std_lib = STD_LIBS.iter().any(|l| rest.starts_with(l));
1694
1695                                 let new_path = if is_std_lib {
1696                                     real_dir.join("library").join(rest)
1697                                 } else {
1698                                     real_dir.join(rest)
1699                                 };
1700
1701                                 debug!(
1702                                     "try_to_translate_virtual_to_real: `{}` -> `{}`",
1703                                     virtual_name.display(),
1704                                     new_path.display(),
1705                                 );
1706                                 let new_name = rustc_span::RealFileName::Devirtualized {
1707                                     local_path: new_path,
1708                                     virtual_name,
1709                                 };
1710                                 *old_name = new_name;
1711                             }
1712                         }
1713                     }
1714                 }
1715             }
1716         };
1717
1718         self.cdata.source_map_import_info.get_or_init(|| {
1719             let external_source_map = self.root.source_map.decode(self);
1720
1721             external_source_map
1722                 .map(|source_file_to_import| {
1723                     // We can't reuse an existing SourceFile, so allocate a new one
1724                     // containing the information we need.
1725                     let rustc_span::SourceFile {
1726                         mut name,
1727                         name_was_remapped,
1728                         src_hash,
1729                         start_pos,
1730                         end_pos,
1731                         mut lines,
1732                         mut multibyte_chars,
1733                         mut non_narrow_chars,
1734                         mut normalized_pos,
1735                         name_hash,
1736                         ..
1737                     } = source_file_to_import;
1738
1739                     // If this file's path has been remapped to `/rustc/$hash`,
1740                     // we might be able to reverse that (also see comments above,
1741                     // on `try_to_translate_virtual_to_real`).
1742                     // FIXME(eddyb) we could check `name_was_remapped` here,
1743                     // but in practice it seems to be always `false`.
1744                     try_to_translate_virtual_to_real(&mut name);
1745
1746                     let source_length = (end_pos - start_pos).to_usize();
1747
1748                     // Translate line-start positions and multibyte character
1749                     // position into frame of reference local to file.
1750                     // `SourceMap::new_imported_source_file()` will then translate those
1751                     // coordinates to their new global frame of reference when the
1752                     // offset of the SourceFile is known.
1753                     for pos in &mut lines {
1754                         *pos = *pos - start_pos;
1755                     }
1756                     for mbc in &mut multibyte_chars {
1757                         mbc.pos = mbc.pos - start_pos;
1758                     }
1759                     for swc in &mut non_narrow_chars {
1760                         *swc = *swc - start_pos;
1761                     }
1762                     for np in &mut normalized_pos {
1763                         np.pos = np.pos - start_pos;
1764                     }
1765
1766                     let local_version = sess.source_map().new_imported_source_file(
1767                         name,
1768                         name_was_remapped,
1769                         src_hash,
1770                         name_hash,
1771                         source_length,
1772                         self.cnum,
1773                         lines,
1774                         multibyte_chars,
1775                         non_narrow_chars,
1776                         normalized_pos,
1777                         start_pos,
1778                         end_pos,
1779                     );
1780                     debug!(
1781                         "CrateMetaData::imported_source_files alloc \
1782                          source_file {:?} original (start_pos {:?} end_pos {:?}) \
1783                          translated (start_pos {:?} end_pos {:?})",
1784                         local_version.name,
1785                         start_pos,
1786                         end_pos,
1787                         local_version.start_pos,
1788                         local_version.end_pos
1789                     );
1790
1791                     ImportedSourceFile {
1792                         original_start_pos: start_pos,
1793                         original_end_pos: end_pos,
1794                         translated_source_file: local_version,
1795                     }
1796                 })
1797                 .collect()
1798         })
1799     }
1800 }
1801
1802 impl CrateMetadata {
1803     crate fn new(
1804         sess: &Session,
1805         blob: MetadataBlob,
1806         root: CrateRoot<'static>,
1807         raw_proc_macros: Option<&'static [ProcMacro]>,
1808         cnum: CrateNum,
1809         cnum_map: CrateNumMap,
1810         dep_kind: CrateDepKind,
1811         source: CrateSource,
1812         private_dep: bool,
1813         host_hash: Option<Svh>,
1814     ) -> CrateMetadata {
1815         let trait_impls = root
1816             .impls
1817             .decode((&blob, sess))
1818             .map(|trait_impls| (trait_impls.trait_id, trait_impls.impls))
1819             .collect();
1820         let alloc_decoding_state =
1821             AllocDecodingState::new(root.interpret_alloc_index.decode(&blob).collect());
1822         let dependencies = Lock::new(cnum_map.iter().cloned().collect());
1823         CrateMetadata {
1824             blob,
1825             root,
1826             trait_impls,
1827             raw_proc_macros,
1828             source_map_import_info: OnceCell::new(),
1829             alloc_decoding_state,
1830             dep_node_index: AtomicCell::new(DepNodeIndex::INVALID),
1831             cnum,
1832             cnum_map,
1833             dependencies,
1834             dep_kind: Lock::new(dep_kind),
1835             source,
1836             private_dep,
1837             host_hash,
1838             extern_crate: Lock::new(None),
1839             hygiene_context: Default::default(),
1840             def_key_cache: Default::default(),
1841             def_path_hash_cache: Default::default(),
1842         }
1843     }
1844
1845     crate fn dependencies(&self) -> LockGuard<'_, Vec<CrateNum>> {
1846         self.dependencies.borrow()
1847     }
1848
1849     crate fn add_dependency(&self, cnum: CrateNum) {
1850         self.dependencies.borrow_mut().push(cnum);
1851     }
1852
1853     crate fn update_extern_crate(&self, new_extern_crate: ExternCrate) -> bool {
1854         let mut extern_crate = self.extern_crate.borrow_mut();
1855         let update = Some(new_extern_crate.rank()) > extern_crate.as_ref().map(ExternCrate::rank);
1856         if update {
1857             *extern_crate = Some(new_extern_crate);
1858         }
1859         update
1860     }
1861
1862     crate fn source(&self) -> &CrateSource {
1863         &self.source
1864     }
1865
1866     crate fn dep_kind(&self) -> CrateDepKind {
1867         *self.dep_kind.lock()
1868     }
1869
1870     crate fn update_dep_kind(&self, f: impl FnOnce(CrateDepKind) -> CrateDepKind) {
1871         self.dep_kind.with_lock(|dep_kind| *dep_kind = f(*dep_kind))
1872     }
1873
1874     crate fn panic_strategy(&self) -> PanicStrategy {
1875         self.root.panic_strategy
1876     }
1877
1878     crate fn needs_panic_runtime(&self) -> bool {
1879         self.root.needs_panic_runtime
1880     }
1881
1882     crate fn is_panic_runtime(&self) -> bool {
1883         self.root.panic_runtime
1884     }
1885
1886     crate fn is_profiler_runtime(&self) -> bool {
1887         self.root.profiler_runtime
1888     }
1889
1890     crate fn needs_allocator(&self) -> bool {
1891         self.root.needs_allocator
1892     }
1893
1894     crate fn has_global_allocator(&self) -> bool {
1895         self.root.has_global_allocator
1896     }
1897
1898     crate fn has_default_lib_allocator(&self) -> bool {
1899         self.root.has_default_lib_allocator
1900     }
1901
1902     crate fn is_proc_macro_crate(&self) -> bool {
1903         self.root.is_proc_macro_crate()
1904     }
1905
1906     crate fn name(&self) -> Symbol {
1907         self.root.name
1908     }
1909
1910     crate fn disambiguator(&self) -> CrateDisambiguator {
1911         self.root.disambiguator
1912     }
1913
1914     crate fn hash(&self) -> Svh {
1915         self.root.hash
1916     }
1917
1918     fn num_def_ids(&self) -> usize {
1919         self.root.tables.def_keys.size()
1920     }
1921
1922     fn local_def_id(&self, index: DefIndex) -> DefId {
1923         DefId { krate: self.cnum, index }
1924     }
1925
1926     // Translate a DefId from the current compilation environment to a DefId
1927     // for an external crate.
1928     fn reverse_translate_def_id(&self, did: DefId) -> Option<DefId> {
1929         for (local, &global) in self.cnum_map.iter_enumerated() {
1930             if global == did.krate {
1931                 return Some(DefId { krate: local, index: did.index });
1932             }
1933         }
1934
1935         None
1936     }
1937 }
1938
1939 // Cannot be implemented on 'ProcMacro', as libproc_macro
1940 // does not depend on librustc_ast
1941 fn macro_kind(raw: &ProcMacro) -> MacroKind {
1942     match raw {
1943         ProcMacro::CustomDerive { .. } => MacroKind::Derive,
1944         ProcMacro::Attr { .. } => MacroKind::Attr,
1945         ProcMacro::Bang { .. } => MacroKind::Bang,
1946     }
1947 }