bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Convert fields within DefPathData from InternedString to Symbol.

Browse source 
It's a full conversion, except in `DefKey::compute_stable_hash()` where
a `Symbol` now is converted to an `InternedString` before being hashed.
This was necessary to avoid test failures.
This commit is contained in:
Nicholas Nethercote 2019-10-21 14:25:08 +11:00
parent 78c3427308
commit b8214e9b44
16 changed files with 59 additions and 63 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/librustc/hir/lowering.rs
View file

@ -792,15 +792,15 @@ impl<'a> LoweringContext<'a> {
// really show up for end-user.
let (str_name, kind) = match hir_name {
ParamName::Plain(ident) => (
ident.as_interned_str(),
ident.name,
hir::LifetimeParamKind::InBand,
),
ParamName::Fresh(_) => (
kw::UnderscoreLifetime.as_interned_str(),
kw::UnderscoreLifetime,
hir::LifetimeParamKind::Elided,
),
ParamName::Error => (
kw::UnderscoreLifetime.as_interned_str(),
kw::UnderscoreLifetime,
hir::LifetimeParamKind::Error,
),
};
@ -1590,7 +1590,7 @@ impl<'a> LoweringContext<'a> {
self.context.resolver.definitions().create_def_with_parent(
self.parent,
def_node_id,
DefPathData::LifetimeNs(name.ident().as_interned_str()),
DefPathData::LifetimeNs(name.ident().name),
ExpnId::root(),
lifetime.span);

29
src/librustc/hir/map/def_collector.rs
View file

@ -57,7 +57,7 @@ impl<'a> DefCollector<'a> {
// For async functions, we need to create their inner defs inside of a
// closure to match their desugared representation.
let fn_def_data = DefPathData::ValueNs(name.as_interned_str());
let fn_def_data = DefPathData::ValueNs(name);
let fn_def = self.create_def(id, fn_def_data, span);
return self.with_parent(fn_def, |this| {
this.create_def(return_impl_trait_id, DefPathData::ImplTrait, span);
@ -83,8 +83,7 @@ impl<'a> DefCollector<'a> {
.unwrap_or_else(|| {
let node_id = NodeId::placeholder_from_expn_id(self.expansion);
sym::integer(self.definitions.placeholder_field_indices[&node_id])
})
.as_interned_str();
});
let def = self.create_def(field.id, DefPathData::ValueNs(name), field.span);
self.with_parent(def, |this| visit::walk_struct_field(this, field));
}
@ -109,7 +108,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
ItemKind::Mod(..) | ItemKind::Trait(..) | ItemKind::TraitAlias(..) |
ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) |
ItemKind::OpaqueTy(..) | ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) |
ItemKind::TyAlias(..) => DefPathData::TypeNs(i.ident.as_interned_str()),
ItemKind::TyAlias(..) => DefPathData::TypeNs(i.ident.name),
ItemKind::Fn(
ref decl,
ref header,
@ -127,8 +126,8 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
)
}
ItemKind::Static(..) | ItemKind::Const(..) | ItemKind::Fn(..) =>
DefPathData::ValueNs(i.ident.as_interned_str()),
ItemKind::MacroDef(..) => DefPathData::MacroNs(i.ident.as_interned_str()),
DefPathData::ValueNs(i.ident.name),
ItemKind::MacroDef(..) => DefPathData::MacroNs(i.ident.name),
ItemKind::Mac(..) => return self.visit_macro_invoc(i.id),
ItemKind::GlobalAsm(..) => DefPathData::Misc,
ItemKind::Use(..) => {
@ -162,7 +161,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
}
let def = self.create_def(foreign_item.id,
DefPathData::ValueNs(foreign_item.ident.as_interned_str()),
DefPathData::ValueNs(foreign_item.ident.name),
foreign_item.span);
self.with_parent(def, |this| {
@ -175,7 +174,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
return self.visit_macro_invoc(v.id);
}
let def = self.create_def(v.id,
DefPathData::TypeNs(v.ident.as_interned_str()),
DefPathData::TypeNs(v.ident.name),
v.span);
self.with_parent(def, |this| {
if let Some(ctor_hir_id) = v.data.ctor_id() {
@ -202,7 +201,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
self.visit_macro_invoc(param.id);
return;
}
let name = param.ident.as_interned_str();
let name = param.ident.name;
let def_path_data = match param.kind {
GenericParamKind::Lifetime { .. } => DefPathData::LifetimeNs(name),
GenericParamKind::Type { .. } => DefPathData::TypeNs(name),
@ -216,9 +215,9 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
fn visit_trait_item(&mut self, ti: &'a TraitItem) {
let def_data = match ti.kind {
TraitItemKind::Method(..) | TraitItemKind::Const(..) =>
DefPathData::ValueNs(ti.ident.as_interned_str()),
DefPathData::ValueNs(ti.ident.name),
TraitItemKind::Type(..) => {
DefPathData::TypeNs(ti.ident.as_interned_str())
DefPathData::TypeNs(ti.ident.name)
},
TraitItemKind::Macro(..) => return self.visit_macro_invoc(ti.id),
};
@ -243,12 +242,10 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
body,
)
}
ImplItemKind::Method(..) | ImplItemKind::Const(..) =>
DefPathData::ValueNs(ii.ident.as_interned_str()),
ImplItemKind::Method(..) |
ImplItemKind::Const(..) => DefPathData::ValueNs(ii.ident.name),
ImplItemKind::TyAlias(..) |
ImplItemKind::OpaqueTy(..) => {
DefPathData::TypeNs(ii.ident.as_interned_str())
},
ImplItemKind::OpaqueTy(..) => DefPathData::TypeNs(ii.ident.name),
ImplItemKind::Macro(..) => return self.visit_macro_invoc(ii.id),
};

44
src/librustc/hir/map/definitions.rs
View file

@ -18,7 +18,7 @@ use std::fmt::Write;
use std::hash::Hash;
use syntax::ast;
use syntax_expand::hygiene::ExpnId;
use syntax::symbol::{Symbol, sym, InternedString};
use syntax::symbol::{Symbol, sym};
use syntax_pos::{Span, DUMMY_SP};
/// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa.
@ -136,7 +136,9 @@ impl DefKey {
::std::mem::discriminant(data).hash(&mut hasher);
if let Some(name) = data.get_opt_name() {
name.hash(&mut hasher);
// Get a stable hash by considering the symbol chars rather than
// the symbol index.
name.as_str().hash(&mut hasher);
}
disambiguator.hash(&mut hasher);
@ -218,7 +220,7 @@ impl DefPath {
for component in &self.data {
write!(s,
"::{}[{}]",
component.data.as_interned_str(),
component.data.as_symbol(),
component.disambiguator)
.unwrap();
}
@ -238,11 +240,11 @@ impl DefPath {
for component in &self.data {
if component.disambiguator == 0 {
write!(s, "::{}", component.data.as_interned_str()).unwrap();
write!(s, "::{}", component.data.as_symbol()).unwrap();
} else {
write!(s,
"{}[{}]",
component.data.as_interned_str(),
component.data.as_symbol(),
component.disambiguator)
.unwrap();
}
@ -262,11 +264,11 @@ impl DefPath {
opt_delimiter.map(|d| s.push(d));
opt_delimiter = Some('-');
if component.disambiguator == 0 {
write!(s, "{}", component.data.as_interned_str()).unwrap();
write!(s, "{}", component.data.as_symbol()).unwrap();
} else {
write!(s,
"{}[{}]",
component.data.as_interned_str(),
component.data.as_symbol(),
component.disambiguator)
.unwrap();
}
@ -290,13 +292,13 @@ pub enum DefPathData {
/// An impl.
Impl,
/// Something in the type namespace.
TypeNs(InternedString),
TypeNs(Symbol),
/// Something in the value namespace.
ValueNs(InternedString),
ValueNs(Symbol),
/// Something in the macro namespace.
MacroNs(InternedString),
MacroNs(Symbol),
/// Something in the lifetime namespace.
LifetimeNs(InternedString),
LifetimeNs(Symbol),
/// A closure expression.
ClosureExpr,
@ -311,7 +313,7 @@ pub enum DefPathData {
/// Identifies a piece of crate metadata that is global to a whole crate
/// (as opposed to just one item). `GlobalMetaData` components are only
/// supposed to show up right below the crate root.
GlobalMetaData(InternedString),
GlobalMetaData(Symbol),
}
#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug,
@ -545,7 +547,7 @@ impl Definitions {
}
impl DefPathData {
pub fn get_opt_name(&self) -> Option<InternedString> {
pub fn get_opt_name(&self) -> Option<Symbol> {
use self::DefPathData::*;
match *self {
TypeNs(name) |
@ -564,15 +566,15 @@ impl DefPathData {
}
}
pub fn as_interned_str(&self) -> InternedString {
pub fn as_symbol(&self) -> Symbol {
use self::DefPathData::*;
let s = match *self {
match *self {
TypeNs(name) |
ValueNs(name) |
MacroNs(name) |
LifetimeNs(name) |
GlobalMetaData(name) => {
return name
name
}
// Note that this does not show up in user print-outs.
CrateRoot => sym::double_braced_crate,
@ -582,13 +584,11 @@ impl DefPathData {
Ctor => sym::double_braced_constructor,
AnonConst => sym::double_braced_constant,
ImplTrait => sym::double_braced_opaque,
};
s.as_interned_str()
}
}
pub fn to_string(&self) -> String {
self.as_interned_str().to_string()
self.as_symbol().to_string()
}
}
@ -611,7 +611,7 @@ macro_rules! define_global_metadata_kind {
definitions.create_def_with_parent(
CRATE_DEF_INDEX,
ast::DUMMY_NODE_ID,
DefPathData::GlobalMetaData(instance.name().as_interned_str()),
DefPathData::GlobalMetaData(instance.name()),
ExpnId::root(),
DUMMY_SP
);
@ -625,7 +625,7 @@ macro_rules! define_global_metadata_kind {
let def_key = DefKey {
parent: Some(CRATE_DEF_INDEX),
disambiguated_data: DisambiguatedDefPathData {
data: DefPathData::GlobalMetaData(self.name().as_interned_str()),
data: DefPathData::GlobalMetaData(self.name()),
disambiguator: 0,
}
};

2
src/librustc/infer/error_reporting/mod.rs
View file

@ -542,7 +542,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
disambiguated_data: &DisambiguatedDefPathData,
) -> Result<Self::Path, Self::Error> {
let mut path = print_prefix(self)?;
path.push(disambiguated_data.data.as_interned_str().to_string());
path.push(disambiguated_data.data.as_symbol().to_string());
Ok(path)
}
fn path_generic_args(

2
src/librustc/lint/context.rs
View file

@ -875,7 +875,7 @@ impl<'a, 'tcx> LateContext<'a, 'tcx> {
_ => {}
}
path.push(disambiguated_data.data.as_interned_str().as_symbol());
path.push(disambiguated_data.data.as_symbol());
Ok(path)
}

2
src/librustc/ty/mod.rs
View file

@ -3019,7 +3019,7 @@ impl<'tcx> TyCtxt<'tcx> {
}),
_ => def_key.disambiguated_data.data.get_opt_name().unwrap_or_else(|| {
bug!("item_name: no name for {:?}", self.def_path(id));
}).as_symbol(),
}),
}
}
}

4
src/librustc/ty/print/obsolete.rs
View file

@ -218,9 +218,9 @@ impl DefPathBasedNames<'tcx> {
// foo::bar::ItemName::
for part in self.tcx.def_path(def_id).data {
if self.omit_disambiguators {
write!(output, "{}::", part.data.as_interned_str()).unwrap();
write!(output, "{}::", part.data.as_symbol()).unwrap();
} else {
write!(output, "{}[{}]::", part.data.as_interned_str(), part.disambiguator)
write!(output, "{}[{}]::", part.data.as_symbol(), part.disambiguator)
.unwrap();
}
}

6
src/librustc/ty/print/pretty.rs
View file

@ -384,7 +384,7 @@ pub trait PrettyPrinter<'tcx>:
let reexport = self.tcx().item_children(visible_parent)
.iter()
.find(|child| child.res.def_id() == def_id)
.map(|child| child.ident.as_interned_str());
.map(|child| child.ident.name);
if let Some(reexport) = reexport {
*name = reexport;
}
@ -392,7 +392,7 @@ pub trait PrettyPrinter<'tcx>:
// Re-exported `extern crate` (#43189).
DefPathData::CrateRoot => {
data = DefPathData::TypeNs(
self.tcx().original_crate_name(def_id.krate).as_interned_str(),
self.tcx().original_crate_name(def_id.krate),
);
}
_ => {}
@ -1222,7 +1222,7 @@ impl<F: fmt::Write> Printer<'tcx> for FmtPrinter<'_, 'tcx, F> {
// FIXME(eddyb) `name` should never be empty, but it
// currently is for `extern { ... }` "foreign modules".
let name = disambiguated_data.data.as_interned_str().as_str();
let name = disambiguated_data.data.as_symbol().as_str();
if !name.is_empty() {
if !self.empty_path {
write!(self, "::")?;

2
src/librustc_codegen_llvm/debuginfo/namespace.rs
View file

@ -35,7 +35,7 @@ pub fn item_namespace(cx: &CodegenCx<'ll, '_>, def_id: DefId) -> &'ll DIScope {
let namespace_name = match def_key.disambiguated_data.data {
DefPathData::CrateRoot => cx.tcx.crate_name(def_id.krate).as_str(),
data => data.as_interned_str().as_str()
data => data.as_symbol().as_str()
};
let namespace_name = SmallCStr::new(&namespace_name);

2
src/librustc_codegen_ssa/debuginfo/type_names.rs
View file

@ -221,7 +221,7 @@ pub fn push_debuginfo_type_name<'tcx>(
output.push_str(&tcx.crate_name(def_id.krate).as_str());
for path_element in tcx.def_path(def_id).data {
output.push_str("::");
output.push_str(&path_element.data.as_interned_str().as_str());
output.push_str(&path_element.data.as_symbol().as_str());
}
} else {
output.push_str(&tcx.item_name(def_id).as_str());

2
src/librustc_codegen_utils/symbol_names/legacy.rs
View file

@ -335,7 +335,7 @@ impl Printer<'tcx> for SymbolPrinter<'tcx> {
self.path.finalize_pending_component();
}
self.write_str(&disambiguated_data.data.as_interned_str().as_str())?;
self.write_str(&disambiguated_data.data.as_symbol().as_str())?;
Ok(self)
}
fn path_generic_args(

2
src/librustc_metadata/cstore_impl.rs
View file

@ -460,7 +460,7 @@ impl cstore::CStore {
LoadedMacro::MacroDef(ast::Item {
// FIXME: cross-crate hygiene
ident: ast::Ident::with_dummy_span(name.as_symbol()),
ident: ast::Ident::with_dummy_span(name),
id: ast::DUMMY_NODE_ID,
span: local_span,
attrs: attrs.iter().cloned().collect(),

9
src/librustc_metadata/decoder.rs
View file

@ -35,7 +35,7 @@ use syntax::ast::{self, Ident};
use syntax::source_map::{self, respan, Spanned};
use syntax::symbol::{Symbol, sym};
use syntax_expand::base::{MacroKind, SyntaxExtensionKind, SyntaxExtension};
use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP, symbol::{InternedString}};
use syntax_pos::{self, Span, BytePos, Pos, DUMMY_SP};
use log::debug;
use proc_macro::bridge::client::ProcMacro;
use syntax_expand::proc_macro::{AttrProcMacro, ProcMacroDerive, BangProcMacro};
@ -514,7 +514,6 @@ impl<'a, 'tcx> CrateMetadata {
.data
.get_opt_name()
.expect("no name in item_name")
.as_symbol()
} else {
Symbol::intern(self.raw_proc_macro(item_index).name())
}
@ -864,7 +863,7 @@ impl<'a, 'tcx> CrateMetadata {
let span = self.get_span(child_index, sess);
if let (Some(kind), Some(name)) =
(self.def_kind(child_index), def_key.disambiguated_data.data.get_opt_name()) {
let ident = Ident::from_interned_str(name);
let ident = Ident::with_dummy_span(name);
let vis = self.get_visibility(child_index);
let def_id = self.local_def_id(child_index);
let res = Res::Def(kind, def_id);
@ -987,7 +986,7 @@ impl<'a, 'tcx> CrateMetadata {
};
ty::AssocItem {
ident: Ident::from_interned_str(name),
ident: Ident::with_dummy_span(name),
kind,
vis: self.get_visibility(id),
defaultness: container.defaultness(),
@ -1262,7 +1261,7 @@ impl<'a, 'tcx> CrateMetadata {
let mut key = self.def_path_table.def_key(index);
if self.is_proc_macro(index) {
let name = self.raw_proc_macro(index).name();
key.disambiguated_data.data = DefPathData::MacroNs(InternedString::intern(name));
key.disambiguated_data.data = DefPathData::MacroNs(Symbol::intern(name));
}
key
}

2
src/librustc_mir/interpret/intrinsics/type_name.rs
View file

@ -148,7 +148,7 @@ impl<'tcx> Printer<'tcx> for AbsolutePathPrinter<'tcx> {
self.path.push_str("::");
self.path.push_str(&disambiguated_data.data.as_interned_str().as_str());
self.path.push_str(&disambiguated_data.data.as_symbol().as_str());
Ok(self)
}

2
src/librustc_mir/monomorphize/partitioning.rs
View file

@ -762,7 +762,7 @@ fn compute_codegen_unit_name(
let components = def_path
.data
.iter()
.map(|part| part.data.as_interned_str());
.map(|part| part.data.as_symbol());
let volatile_suffix = if volatile {
Some("volatile")

4
src/librustc_resolve/build_reduced_graph.rs
View file

@ -110,14 +110,14 @@ impl<'a> Resolver<'a> {
}
let (name, parent) = if def_id.index == CRATE_DEF_INDEX {
(self.cstore.crate_name_untracked(def_id.krate).as_interned_str(), None)
(self.cstore.crate_name_untracked(def_id.krate), None)
} else {
let def_key = self.cstore.def_key(def_id);
(def_key.disambiguated_data.data.get_opt_name().unwrap(),
Some(self.get_module(DefId { index: def_key.parent.unwrap(), ..def_id })))
};
let kind = ModuleKind::Def(DefKind::Mod, def_id, name.as_symbol());
let kind = ModuleKind::Def(DefKind::Mod, def_id, name);
let module = self.arenas.alloc_module(ModuleData::new(
parent, kind, def_id, ExpnId::root(), DUMMY_SP
));