Decouple CrateNum of CrateInfo from the compilation session

src/librustc_codegen_llvm/back/lto.rs

@@ -68,7 +68,10 @@ fn prepare_lto(
     let exported_symbols = cgcx.exported_symbols.as_ref().expect("needs exported symbols for LTO");
     let mut symbol_white_list = {
         let _timer = cgcx.prof.generic_activity("LLVM_lto_generate_symbol_white_list");
-        exported_symbols[&LOCAL_CRATE].iter().filter_map(symbol_filter).collect::<Vec<CString>>()
+        exported_symbols[&LOCAL_CRATE.into()]
+            .iter()
+            .filter_map(symbol_filter)
+            .collect::<Vec<CString>>()
     };
     info!("{} symbols to preserve in this crate", symbol_white_list.len());
 

src/librustc_codegen_ssa/back/link.rs

@@ -9,7 +9,6 @@ use rustc::session::search_paths::PathKind;
 use rustc::session::{filesearch, Session};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_fs_util::fix_windows_verbatim_for_gcc;
-use rustc_hir::def_id::CrateNum;
 use rustc_span::symbol::Symbol;
 use rustc_target::spec::{LinkerFlavor, PanicStrategy, RelroLevel};
 
@@ -18,7 +17,7 @@ use super::command::Command;
 use super::linker::Linker;
 use super::rpath::{self, RPathConfig};
 use crate::{
-    looks_like_rust_object_file, CodegenResults, CrateInfo, METADATA_FILENAME,
+    looks_like_rust_object_file, CodegenResults, CrateInfo, CrateNum, METADATA_FILENAME,
     RLIB_BYTECODE_EXTENSION,
 };
 

src/librustc_codegen_ssa/back/rpath.rs

@@ -3,8 +3,8 @@ use std::env;
 use std::fs;
 use std::path::{Path, PathBuf};
 
+use crate::CrateNum;
 use rustc::middle::cstore::LibSource;
-use rustc_hir::def_id::CrateNum;
 
 pub struct RPathConfig<'a> {
     pub used_crates: &'a [(CrateNum, LibSource)],

src/librustc_codegen_ssa/back/symbol_export.rs

@@ -16,7 +16,7 @@ use rustc_hir::Node;
 use rustc_index::vec::IndexVec;
 use syntax::expand::allocator::ALLOCATOR_METHODS;
 
-pub type ExportedSymbols = FxHashMap<CrateNum, Arc<Vec<(String, SymbolExportLevel)>>>;
+pub type ExportedSymbols = FxHashMap<crate::CrateNum, Arc<Vec<(String, SymbolExportLevel)>>>;
 
 pub fn threshold(tcx: TyCtxt<'_>) -> SymbolExportLevel {
     crates_export_threshold(&tcx.sess.crate_types.borrow())

src/librustc_codegen_ssa/back/write.rs

@@ -9,6 +9,7 @@ use crate::{
 };
 
 use crate::traits::*;
+use crate::CrateNum;
 use jobserver::{Acquired, Client};
 use rustc::dep_graph::{WorkProduct, WorkProductFileKind, WorkProductId};
 use rustc::middle::cstore::EncodedMetadata;
@@ -25,7 +26,7 @@ use rustc_data_structures::sync::Lrc;
 use rustc_errors::emitter::Emitter;
 use rustc_errors::{DiagnosticId, FatalError, Handler, Level};
 use rustc_fs_util::link_or_copy;
-use rustc_hir::def_id::{CrateNum, LOCAL_CRATE};
+use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_incremental::{
     copy_cgu_workproducts_to_incr_comp_cache_dir, in_incr_comp_dir, in_incr_comp_dir_sess,
 };
@@ -964,13 +965,13 @@ fn start_executing_work<B: ExtraBackendMethods>(
         match sess.lto() {
             Lto::No => None,
             Lto::ThinLocal => {
-                exported_symbols.insert(LOCAL_CRATE, copy_symbols(LOCAL_CRATE));
+                exported_symbols.insert(LOCAL_CRATE.into(), copy_symbols(LOCAL_CRATE));
                 Some(Arc::new(exported_symbols))
             }
             Lto::Fat | Lto::Thin => {
-                exported_symbols.insert(LOCAL_CRATE, copy_symbols(LOCAL_CRATE));
+                exported_symbols.insert(LOCAL_CRATE.into(), copy_symbols(LOCAL_CRATE));
                 for &cnum in tcx.crates().iter() {
-                    exported_symbols.insert(cnum, copy_symbols(cnum));
+                    exported_symbols.insert(cnum.into(), copy_symbols(cnum));
                 }
                 Some(Arc::new(exported_symbols))
             }

src/librustc_codegen_ssa/base.rs

@@ -803,8 +803,14 @@ impl CrateInfo {
             used_libraries: tcx.native_libraries(LOCAL_CRATE),
             link_args: tcx.link_args(LOCAL_CRATE),
             crate_name: Default::default(),
-            used_crates_dynamic: cstore::used_crates(tcx, LinkagePreference::RequireDynamic),
-            used_crates_static: cstore::used_crates(tcx, LinkagePreference::RequireStatic),
+            used_crates_dynamic: cstore::used_crates(tcx, LinkagePreference::RequireDynamic)
+                .into_iter()
+                .map(|(cnum, lib)| (cnum.into(), lib))
+                .collect(),
+            used_crates_static: cstore::used_crates(tcx, LinkagePreference::RequireStatic)
+                .into_iter()
+                .map(|(cnum, lib)| (cnum.into(), lib))
+                .collect(),
             used_crate_source: Default::default(),
             lang_item_to_crate: Default::default(),
             missing_lang_items: Default::default(),
@@ -821,25 +827,25 @@ impl CrateInfo {
         info.missing_lang_items.reserve(n_crates);
 
         for &cnum in crates.iter() {
-            info.native_libraries.insert(cnum, tcx.native_libraries(cnum));
-            info.crate_name.insert(cnum, tcx.crate_name(cnum).to_string());
-            info.used_crate_source.insert(cnum, tcx.used_crate_source(cnum));
+            info.native_libraries.insert(cnum.into(), tcx.native_libraries(cnum));
+            info.crate_name.insert(cnum.into(), tcx.crate_name(cnum).to_string());
+            info.used_crate_source.insert(cnum.into(), tcx.used_crate_source(cnum));
             if tcx.is_panic_runtime(cnum) {
-                info.panic_runtime = Some(cnum);
+                info.panic_runtime = Some(cnum.into());
             }
             if tcx.is_compiler_builtins(cnum) {
-                info.compiler_builtins = Some(cnum);
+                info.compiler_builtins = Some(cnum.into());
             }
             if tcx.is_profiler_runtime(cnum) {
-                info.profiler_runtime = Some(cnum);
+                info.profiler_runtime = Some(cnum.into());
             }
             if tcx.is_no_builtins(cnum) {
-                info.is_no_builtins.insert(cnum);
+                info.is_no_builtins.insert(cnum.into());
             }
             let missing = tcx.missing_lang_items(cnum);
             for &item in missing.iter() {
                 if let Ok(id) = lang_items.require(item) {
-                    info.lang_item_to_crate.insert(item, id.krate);
+                    info.lang_item_to_crate.insert(item, id.krate.into());
                 }
             }
 
@@ -850,7 +856,7 @@ impl CrateInfo {
                 .cloned()
                 .filter(|&l| !weak_lang_items::whitelisted(tcx, l))
                 .collect();
-            info.missing_lang_items.insert(cnum, missing);
+            info.missing_lang_items.insert(cnum.into(), missing);
         }
 
         return info;

src/librustc_codegen_ssa/lib.rs

@@ -31,7 +31,7 @@ use rustc::ty::query::Providers;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::svh::Svh;
 use rustc_data_structures::sync::Lrc;
-use rustc_hir::def_id::CrateNum;
+use rustc_hir::def_id;
 use rustc_span::symbol::Symbol;
 use std::path::{Path, PathBuf};
 
@@ -116,6 +116,24 @@ bitflags::bitflags! {
     }
 }
 
+#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
+pub struct CrateNum(pub u32);
+impl CrateNum {
+    pub fn as_usize(self) -> usize {
+        self.0 as usize
+    }
+}
+impl From<def_id::CrateNum> for CrateNum {
+    fn from(crate_num: def_id::CrateNum) -> Self {
+        CrateNum(crate_num.as_u32())
+    }
+}
+impl ::std::fmt::Debug for CrateNum {
+    fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+        write!(fmt, "crate{}", self.0)
+    }
+}
+
 /// Misc info we load from metadata to persist beyond the tcx.
 #[derive(Debug)]
 pub struct CrateInfo {