use super::*;
use dep_graph::{DepGraph, DepKind, DepNodeIndex};
+use ich::Fingerprint;
use hir::intravisit::{Visitor, NestedVisitorMap};
use std::iter::repeat;
use syntax::ast::{NodeId, CRATE_NODE_ID};
}
pub(super) fn finalize_and_compute_crate_hash(self,
- crate_disambiguator: &str)
+ crate_disambiguator: &Fingerprint)
-> Vec<MapEntry<'hir>> {
let mut node_hashes: Vec<_> = self
.hir_body_nodes
hcx);
intravisit::walk_crate(&mut collector, &forest.krate);
- let crate_disambiguator = sess.local_crate_disambiguator().as_str();
+ let crate_disambiguator = sess.local_crate_disambiguator();
collector.finalize_and_compute_crate_hash(&crate_disambiguator)
};
fn export_macros_untracked(&self, cnum: CrateNum);
fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind;
fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol;
- fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> Symbol;
+ fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> ich::Fingerprint;
fn crate_hash_untracked(&self, cnum: CrateNum) -> Svh;
fn struct_field_names_untracked(&self, def: DefId) -> Vec<ast::Name>;
fn item_children_untracked(&self, did: DefId, sess: &Session) -> Vec<def::Export>;
fn dep_kind_untracked(&self, cnum: CrateNum) -> DepKind { bug!("is_explicitly_linked") }
fn export_macros_untracked(&self, cnum: CrateNum) { bug!("export_macros") }
fn crate_name_untracked(&self, cnum: CrateNum) -> Symbol { bug!("crate_name") }
- fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> Symbol {
+ fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> ich::Fingerprint {
bug!("crate_disambiguator")
}
fn crate_hash_untracked(&self, cnum: CrateNum) -> Svh { bug!("crate_hash") }
pub use self::code_stats::{SizeKind, TypeSizeInfo, VariantInfo};
use hir::def_id::{CrateNum, DefIndex};
+use ich::Fingerprint;
use lint;
use middle::allocator::AllocatorKind;
use syntax::feature_gate;
use syntax::parse;
use syntax::parse::ParseSess;
-use syntax::symbol::Symbol;
use syntax::{ast, codemap};
use syntax::feature_gate::AttributeType;
use syntax_pos::{Span, MultiSpan};
/// forms a unique global identifier for the crate. It is used to allow
/// multiple crates with the same name to coexist. See the
/// trans::back::symbol_names module for more information.
- pub crate_disambiguator: RefCell<Option<Symbol>>,
+ pub crate_disambiguator: RefCell<Option<Fingerprint>>,
pub features: RefCell<feature_gate::Features>,
/// The maximum recursion limit for potentially infinitely recursive
}
impl Session {
- pub fn local_crate_disambiguator(&self) -> Symbol {
+ pub fn local_crate_disambiguator(&self) -> Fingerprint {
match *self.crate_disambiguator.borrow() {
Some(sym) => sym,
None => bug!("accessing disambiguator before initialization"),
/// Returns the symbol name for the registrar function,
/// given the crate Svh and the function DefIndex.
- pub fn generate_plugin_registrar_symbol(&self, disambiguator: Symbol, index: DefIndex)
+ pub fn generate_plugin_registrar_symbol(&self, disambiguator: Fingerprint,
+ index: DefIndex)
-> String {
- format!("__rustc_plugin_registrar__{}_{}", disambiguator, index.as_usize())
+ format!("__rustc_plugin_registrar__{}_{}", disambiguator.to_hex(),
+ index.as_usize())
}
- pub fn generate_derive_registrar_symbol(&self, disambiguator: Symbol, index: DefIndex)
+ pub fn generate_derive_registrar_symbol(&self, disambiguator: Fingerprint, index: DefIndex)
-> String {
- format!("__rustc_derive_registrar__{}_{}", disambiguator, index.as_usize())
+ format!("__rustc_derive_registrar__{}_{}", disambiguator.to_hex(),
+ index.as_usize())
}
pub fn sysroot<'a>(&'a self) -> &'a Path {
crate_name,
// Don't print the whole crate disambiguator. That's just
// annoying in debug output.
- &(crate_disambiguator.as_str())[..4],
+ &(crate_disambiguator.to_hex())[..4],
self.def_path(def_id).to_string_no_crate())
}
use dep_graph::{DepConstructor, DepNode};
use errors::DiagnosticBuilder;
+use ich::Fingerprint;
use hir::def_id::{CrateNum, DefId, DefIndex};
use hir::def::{Def, Export};
use hir::{self, TraitCandidate, ItemLocalId};
[] fn native_libraries: NativeLibraries(CrateNum) -> Rc<Vec<NativeLibrary>>,
[] fn plugin_registrar_fn: PluginRegistrarFn(CrateNum) -> Option<DefId>,
[] fn derive_registrar_fn: DeriveRegistrarFn(CrateNum) -> Option<DefId>,
- [] fn crate_disambiguator: CrateDisambiguator(CrateNum) -> Symbol,
+ [] fn crate_disambiguator: CrateDisambiguator(CrateNum) -> Fingerprint,
[] fn crate_hash: CrateHash(CrateNum) -> Svh,
[] fn original_crate_name: OriginalCrateName(CrateNum) -> Symbol,
use hir::def::{Def, CtorKind, ExportMap};
use hir::def_id::{CrateNum, DefId, DefIndex, CRATE_DEF_INDEX, LOCAL_CRATE};
use hir::map::DefPathData;
-use ich::StableHashingContext;
+use ich::{Fingerprint, StableHashingContext};
use middle::const_val::ConstVal;
use middle::lang_items::{FnTraitLangItem, FnMutTraitLangItem, FnOnceTraitLangItem};
use middle::privacy::AccessLevels;
}
fn crate_disambiguator<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
- crate_num: CrateNum) -> Symbol {
+ crate_num: CrateNum) -> Fingerprint {
assert_eq!(crate_num, LOCAL_CRATE);
tcx.sess.local_crate_disambiguator()
}
use syntax::attr;
use syntax::ext::base::ExtCtxt;
use syntax::parse::{self, PResult};
-use syntax::symbol::Symbol;
use syntax::util::node_count::NodeCounter;
use syntax;
use syntax_ext;
*sess.crate_types.borrow_mut() = collect_crate_types(sess, &krate.attrs);
- let disambiguator = Symbol::intern(&compute_crate_disambiguator(sess));
+ let disambiguator = compute_crate_disambiguator(sess);
*sess.crate_disambiguator.borrow_mut() = Some(disambiguator);
rustc_incremental::prepare_session_directory(
sess,
&crate_name,
- &disambiguator.as_str(),
+ &disambiguator,
);
let dep_graph = if sess.opts.build_dep_graph() {
.collect()
}
-pub fn compute_crate_disambiguator(session: &Session) -> String {
+pub fn compute_crate_disambiguator(session: &Session) -> Fingerprint {
use std::hash::Hasher;
// The crate_disambiguator is a 128 bit hash. The disambiguator is fed
// into various other hashes quite a bit (symbol hashes, incr. comp. hashes,
// debuginfo type IDs, etc), so we don't want it to be too wide. 128 bits
// should still be safe enough to avoid collisions in practice.
- // FIXME(mw): It seems that the crate_disambiguator is used everywhere as
- // a hex-string instead of raw bytes. We should really use the
- // smaller representation.
let mut hasher = StableHasher::<Fingerprint>::new();
let mut metadata = session.opts.cg.metadata.clone();
hasher.write(s.as_bytes());
}
- // If this is an executable, add a special suffix, so that we don't get
- // symbol conflicts when linking against a library of the same name.
+ // Also incorporate crate type, so that we don't get symbol conflicts when
+ // linking against a library of the same name, if this is an executable.
let is_exe = session.crate_types.borrow().contains(&config::CrateTypeExecutable);
+ hasher.write(if is_exe { b"exe" } else { b"lib" });
+
+ hasher.finish()
- format!("{}{}", hasher.finish().to_hex(), if is_exe { "-exe" } else {""})
}
pub fn build_output_filenames(input: &Input,
//! unsupported file system and emit a warning in that case. This is not yet
//! implemented.
+use rustc::ich::Fingerprint;
use rustc::hir::svh::Svh;
use rustc::session::Session;
use rustc::util::fs as fs_util;
/// The garbage collection will take care of it.
pub fn prepare_session_directory(sess: &Session,
crate_name: &str,
- crate_disambiguator: &str) {
+ crate_disambiguator: &Fingerprint) {
if sess.opts.incremental.is_none() {
return
}
fn crate_path(sess: &Session,
crate_name: &str,
- crate_disambiguator: &str)
+ crate_disambiguator: &Fingerprint)
-> PathBuf {
- use std::hash::{Hasher, Hash};
- use std::collections::hash_map::DefaultHasher;
let incr_dir = sess.opts.incremental.as_ref().unwrap().clone();
- // The full crate disambiguator is really long. A hash of it should be
- // sufficient.
- let mut hasher = DefaultHasher::new();
- crate_disambiguator.hash(&mut hasher);
-
+ let crate_disambiguator = crate_disambiguator.to_smaller_hash();
let crate_name = format!("{}-{}",
crate_name,
- base_n::encode(hasher.finish(), INT_ENCODE_BASE));
+ base_n::encode(crate_disambiguator, INT_ENCODE_BASE));
incr_dir.join(crate_name)
}
use native_libs::relevant_lib;
use schema::CrateRoot;
+use rustc::ich::Fingerprint;
use rustc::hir::def_id::{CrateNum, DefIndex, CRATE_DEF_INDEX};
use rustc::hir::svh::Svh;
use rustc::middle::allocator::AllocatorKind;
pub fn find_plugin_registrar(&mut self,
span: Span,
name: &str)
- -> Option<(PathBuf, Symbol, DefIndex)> {
+ -> Option<(PathBuf, Fingerprint, DefIndex)> {
let ekrate = self.read_extension_crate(span, &ExternCrateInfo {
name: Symbol::intern(name),
ident: Symbol::intern(name),
use schema;
+use rustc::ich::Fingerprint;
use rustc::hir::def_id::{CRATE_DEF_INDEX, CrateNum, DefIndex};
use rustc::hir::map::definitions::DefPathTable;
use rustc::hir::svh::Svh;
pub fn hash(&self) -> Svh {
self.root.hash
}
- pub fn disambiguator(&self) -> Symbol {
+ pub fn disambiguator(&self) -> Fingerprint {
self.root.disambiguator
}
LoadedMacro, EncodedMetadata,
EncodedMetadataHashes, NativeLibraryKind};
use rustc::middle::stability::DeprecationEntry;
+use rustc::ich::Fingerprint;
use rustc::hir::def;
use rustc::session::Session;
use rustc::ty::{self, TyCtxt};
self.get_crate_data(cnum).name
}
- fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> Symbol
+ fn crate_disambiguator_untracked(&self, cnum: CrateNum) -> Fingerprint
{
self.get_crate_data(cnum).disambiguator()
}
use rustc::hir;
use rustc::hir::def::{self, CtorKind};
use rustc::hir::def_id::{DefIndex, DefId, CrateNum};
-use rustc::ich::StableHashingContext;
+use rustc::ich::{Fingerprint, StableHashingContext};
use rustc::middle::cstore::{DepKind, LinkagePreference, NativeLibrary};
use rustc::middle::lang_items;
use rustc::mir;
pub name: Symbol,
pub triple: String,
pub hash: hir::svh::Svh,
- pub disambiguator: Symbol,
+ pub disambiguator: Fingerprint,
pub panic_strategy: PanicStrategy,
pub has_global_allocator: bool,
pub has_default_lib_allocator: bool,
let mut definitions = Definitions::new();
DefCollector::new(&mut definitions, Mark::root())
- .collect_root(crate_name, &session.local_crate_disambiguator().as_str());
+ .collect_root(crate_name, &session.local_crate_disambiguator().to_hex());
let mut invocations = FxHashMap();
invocations.insert(Mark::root(),
pub fn metadata_symbol_name(tcx: TyCtxt) -> String {
format!("rust_metadata_{}_{}",
tcx.crate_name(LOCAL_CRATE),
- tcx.crate_disambiguator(LOCAL_CRATE))
+ tcx.crate_disambiguator(LOCAL_CRATE).to_hex())
}
fn crate_export_threshold(crate_type: config::CrateType) -> SymbolExportLevel {
if avoid_cross_crate_conflicts {
hasher.hash(tcx.crate_name.as_str());
- hasher.hash(tcx.sess.local_crate_disambiguator().as_str());
+ hasher.hash(tcx.sess.local_crate_disambiguator());
}
});