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. // really show up for end-user.
let (str_name, kind) = match hir_name { let (str_name, kind) = match hir_name {
ParamName::Plain(ident) => ( ParamName::Plain(ident) => (
ident.as_interned_str(), ident.name,
hir::LifetimeParamKind::InBand, hir::LifetimeParamKind::InBand,
), ),
ParamName::Fresh(_) => ( ParamName::Fresh(_) => (
kw::UnderscoreLifetime.as_interned_str(), kw::UnderscoreLifetime,
hir::LifetimeParamKind::Elided, hir::LifetimeParamKind::Elided,
), ),
ParamName::Error => ( ParamName::Error => (
kw::UnderscoreLifetime.as_interned_str(), kw::UnderscoreLifetime,
hir::LifetimeParamKind::Error, hir::LifetimeParamKind::Error,
), ),
}; };
@ -1590,7 +1590,7 @@ impl<'a> LoweringContext<'a> {
self.context.resolver.definitions().create_def_with_parent( self.context.resolver.definitions().create_def_with_parent(
self.parent, self.parent,
def_node_id, def_node_id,
DefPathData::LifetimeNs(name.ident().as_interned_str()), DefPathData::LifetimeNs(name.ident().name),
ExpnId::root(), ExpnId::root(),
lifetime.span); 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 // For async functions, we need to create their inner defs inside of a
// closure to match their desugared representation. // 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); let fn_def = self.create_def(id, fn_def_data, span);
return self.with_parent(fn_def, |this| { return self.with_parent(fn_def, |this| {
this.create_def(return_impl_trait_id, DefPathData::ImplTrait, span); this.create_def(return_impl_trait_id, DefPathData::ImplTrait, span);
@ -83,8 +83,7 @@ impl<'a> DefCollector<'a> {
.unwrap_or_else(|| { .unwrap_or_else(|| {
let node_id = NodeId::placeholder_from_expn_id(self.expansion); let node_id = NodeId::placeholder_from_expn_id(self.expansion);
sym::integer(self.definitions.placeholder_field_indices[&node_id]) sym::integer(self.definitions.placeholder_field_indices[&node_id])
}) });
.as_interned_str();
let def = self.create_def(field.id, DefPathData::ValueNs(name), field.span); let def = self.create_def(field.id, DefPathData::ValueNs(name), field.span);
self.with_parent(def, |this| visit::walk_struct_field(this, field)); 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::Mod(..) | ItemKind::Trait(..) | ItemKind::TraitAlias(..) |
ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) | ItemKind::Enum(..) | ItemKind::Struct(..) | ItemKind::Union(..) |
ItemKind::OpaqueTy(..) | ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) | ItemKind::OpaqueTy(..) | ItemKind::ExternCrate(..) | ItemKind::ForeignMod(..) |
ItemKind::TyAlias(..) => DefPathData::TypeNs(i.ident.as_interned_str()), ItemKind::TyAlias(..) => DefPathData::TypeNs(i.ident.name),
ItemKind::Fn( ItemKind::Fn(
ref decl, ref decl,
ref header, ref header,
@ -127,8 +126,8 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
) )
} }
ItemKind::Static(..) | ItemKind::Const(..) | ItemKind::Fn(..) => ItemKind::Static(..) | ItemKind::Const(..) | ItemKind::Fn(..) =>
DefPathData::ValueNs(i.ident.as_interned_str()), DefPathData::ValueNs(i.ident.name),
ItemKind::MacroDef(..) => DefPathData::MacroNs(i.ident.as_interned_str()), ItemKind::MacroDef(..) => DefPathData::MacroNs(i.ident.name),
ItemKind::Mac(..) => return self.visit_macro_invoc(i.id), ItemKind::Mac(..) => return self.visit_macro_invoc(i.id),
ItemKind::GlobalAsm(..) => DefPathData::Misc, ItemKind::GlobalAsm(..) => DefPathData::Misc,
ItemKind::Use(..) => { ItemKind::Use(..) => {
@ -162,7 +161,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
} }
let def = self.create_def(foreign_item.id, 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); foreign_item.span);
self.with_parent(def, |this| { self.with_parent(def, |this| {
@ -175,7 +174,7 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
return self.visit_macro_invoc(v.id); return self.visit_macro_invoc(v.id);
} }
let def = self.create_def(v.id, let def = self.create_def(v.id,
DefPathData::TypeNs(v.ident.as_interned_str()), DefPathData::TypeNs(v.ident.name),
v.span); v.span);
self.with_parent(def, |this| { self.with_parent(def, |this| {
if let Some(ctor_hir_id) = v.data.ctor_id() { 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); self.visit_macro_invoc(param.id);
return; return;
} }
let name = param.ident.as_interned_str(); let name = param.ident.name;
let def_path_data = match param.kind { let def_path_data = match param.kind {
GenericParamKind::Lifetime { .. } => DefPathData::LifetimeNs(name), GenericParamKind::Lifetime { .. } => DefPathData::LifetimeNs(name),
GenericParamKind::Type { .. } => DefPathData::TypeNs(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) { fn visit_trait_item(&mut self, ti: &'a TraitItem) {
let def_data = match ti.kind { let def_data = match ti.kind {
TraitItemKind::Method(..) | TraitItemKind::Const(..) => TraitItemKind::Method(..) | TraitItemKind::Const(..) =>
DefPathData::ValueNs(ti.ident.as_interned_str()), DefPathData::ValueNs(ti.ident.name),
TraitItemKind::Type(..) => { TraitItemKind::Type(..) => {
DefPathData::TypeNs(ti.ident.as_interned_str()) DefPathData::TypeNs(ti.ident.name)
}, },
TraitItemKind::Macro(..) => return self.visit_macro_invoc(ti.id), TraitItemKind::Macro(..) => return self.visit_macro_invoc(ti.id),
}; };
@ -243,12 +242,10 @@ impl<'a> visit::Visitor<'a> for DefCollector<'a> {
body, body,
) )
} }
ImplItemKind::Method(..) | ImplItemKind::Const(..) => ImplItemKind::Method(..) |
DefPathData::ValueNs(ii.ident.as_interned_str()), ImplItemKind::Const(..) => DefPathData::ValueNs(ii.ident.name),
ImplItemKind::TyAlias(..) | ImplItemKind::TyAlias(..) |
ImplItemKind::OpaqueTy(..) => { ImplItemKind::OpaqueTy(..) => DefPathData::TypeNs(ii.ident.name),
DefPathData::TypeNs(ii.ident.as_interned_str())
},
ImplItemKind::Macro(..) => return self.visit_macro_invoc(ii.id), 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 std::hash::Hash;
use syntax::ast; use syntax::ast;
use syntax_expand::hygiene::ExpnId; use syntax_expand::hygiene::ExpnId;
use syntax::symbol::{Symbol, sym, InternedString}; use syntax::symbol::{Symbol, sym};
use syntax_pos::{Span, DUMMY_SP}; use syntax_pos::{Span, DUMMY_SP};
/// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa. /// The `DefPathTable` maps `DefIndex`es to `DefKey`s and vice versa.
@ -136,7 +136,9 @@ impl DefKey {
::std::mem::discriminant(data).hash(&mut hasher); ::std::mem::discriminant(data).hash(&mut hasher);
if let Some(name) = data.get_opt_name() { 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); disambiguator.hash(&mut hasher);
@ -218,7 +220,7 @@ impl DefPath {
for component in &self.data { for component in &self.data {
write!(s, write!(s,
"::{}[{}]", "::{}[{}]",
component.data.as_interned_str(), component.data.as_symbol(),
component.disambiguator) component.disambiguator)
.unwrap(); .unwrap();
} }
@ -238,11 +240,11 @@ impl DefPath {
for component in &self.data { for component in &self.data {
if component.disambiguator == 0 { if component.disambiguator == 0 {
write!(s, "::{}", component.data.as_interned_str()).unwrap(); write!(s, "::{}", component.data.as_symbol()).unwrap();
} else { } else {
write!(s, write!(s,
"{}[{}]", "{}[{}]",
component.data.as_interned_str(), component.data.as_symbol(),
component.disambiguator) component.disambiguator)
.unwrap(); .unwrap();
} }
@ -262,11 +264,11 @@ impl DefPath {
opt_delimiter.map(|d| s.push(d)); opt_delimiter.map(|d| s.push(d));
opt_delimiter = Some('-'); opt_delimiter = Some('-');
if component.disambiguator == 0 { if component.disambiguator == 0 {
write!(s, "{}", component.data.as_interned_str()).unwrap(); write!(s, "{}", component.data.as_symbol()).unwrap();
} else { } else {
write!(s, write!(s,
"{}[{}]", "{}[{}]",
component.data.as_interned_str(), component.data.as_symbol(),
component.disambiguator) component.disambiguator)
.unwrap(); .unwrap();
} }
@ -290,13 +292,13 @@ pub enum DefPathData {
/// An impl. /// An impl.
Impl, Impl,
/// Something in the type namespace. /// Something in the type namespace.
TypeNs(InternedString), TypeNs(Symbol),
/// Something in the value namespace. /// Something in the value namespace.
ValueNs(InternedString), ValueNs(Symbol),
/// Something in the macro namespace. /// Something in the macro namespace.
MacroNs(InternedString), MacroNs(Symbol),
/// Something in the lifetime namespace. /// Something in the lifetime namespace.
LifetimeNs(InternedString), LifetimeNs(Symbol),
/// A closure expression. /// A closure expression.
ClosureExpr, ClosureExpr,
@ -311,7 +313,7 @@ pub enum DefPathData {
/// Identifies a piece of crate metadata that is global to a whole crate /// Identifies a piece of crate metadata that is global to a whole crate
/// (as opposed to just one item). `GlobalMetaData` components are only /// (as opposed to just one item). `GlobalMetaData` components are only
/// supposed to show up right below the crate root. /// supposed to show up right below the crate root.
GlobalMetaData(InternedString), GlobalMetaData(Symbol),
} }
#[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug, #[derive(Copy, Clone, Hash, PartialEq, Eq, PartialOrd, Ord, Debug,
@ -545,7 +547,7 @@ impl Definitions {
} }
impl DefPathData { impl DefPathData {
pub fn get_opt_name(&self) -> Option<InternedString> { pub fn get_opt_name(&self) -> Option<Symbol> {
use self::DefPathData::*; use self::DefPathData::*;
match *self { match *self {
TypeNs(name) | TypeNs(name) |
@ -564,15 +566,15 @@ impl DefPathData {
} }
} }
pub fn as_interned_str(&self) -> InternedString { pub fn as_symbol(&self) -> Symbol {
use self::DefPathData::*; use self::DefPathData::*;
let s = match *self { match *self {
TypeNs(name) | TypeNs(name) |
ValueNs(name) | ValueNs(name) |
MacroNs(name) | MacroNs(name) |
LifetimeNs(name) | LifetimeNs(name) |
GlobalMetaData(name) => { GlobalMetaData(name) => {
return name name
} }
// Note that this does not show up in user print-outs. // Note that this does not show up in user print-outs.
CrateRoot => sym::double_braced_crate, CrateRoot => sym::double_braced_crate,
@ -582,13 +584,11 @@ impl DefPathData {
Ctor => sym::double_braced_constructor, Ctor => sym::double_braced_constructor,
AnonConst => sym::double_braced_constant, AnonConst => sym::double_braced_constant,
ImplTrait => sym::double_braced_opaque, ImplTrait => sym::double_braced_opaque,
}; }
s.as_interned_str()
} }
pub fn to_string(&self) -> String { 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( definitions.create_def_with_parent(
CRATE_DEF_INDEX, CRATE_DEF_INDEX,
ast::DUMMY_NODE_ID, ast::DUMMY_NODE_ID,
DefPathData::GlobalMetaData(instance.name().as_interned_str()), DefPathData::GlobalMetaData(instance.name()),
ExpnId::root(), ExpnId::root(),
DUMMY_SP DUMMY_SP
); );
@ -625,7 +625,7 @@ macro_rules! define_global_metadata_kind {
let def_key = DefKey { let def_key = DefKey {
parent: Some(CRATE_DEF_INDEX), parent: Some(CRATE_DEF_INDEX),
disambiguated_data: DisambiguatedDefPathData { disambiguated_data: DisambiguatedDefPathData {
data: DefPathData::GlobalMetaData(self.name().as_interned_str()), data: DefPathData::GlobalMetaData(self.name()),
disambiguator: 0, 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, disambiguated_data: &DisambiguatedDefPathData,
) -> Result<Self::Path, Self::Error> { ) -> Result<Self::Path, Self::Error> {
let mut path = print_prefix(self)?; 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) Ok(path)
} }
fn path_generic_args( 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) 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(|| { _ => def_key.disambiguated_data.data.get_opt_name().unwrap_or_else(|| {
bug!("item_name: no name for {:?}", self.def_path(id)); 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:: // foo::bar::ItemName::
for part in self.tcx.def_path(def_id).data { for part in self.tcx.def_path(def_id).data {
if self.omit_disambiguators { if self.omit_disambiguators {
write!(output, "{}::", part.data.as_interned_str()).unwrap(); write!(output, "{}::", part.data.as_symbol()).unwrap();
} else { } else {
write!(output, "{}[{}]::", part.data.as_interned_str(), part.disambiguator) write!(output, "{}[{}]::", part.data.as_symbol(), part.disambiguator)
.unwrap(); .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) let reexport = self.tcx().item_children(visible_parent)
.iter() .iter()
.find(|child| child.res.def_id() == def_id) .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 { if let Some(reexport) = reexport {
*name = reexport; *name = reexport;
} }
@ -392,7 +392,7 @@ pub trait PrettyPrinter<'tcx>:
// Re-exported `extern crate` (#43189). // Re-exported `extern crate` (#43189).
DefPathData::CrateRoot => { DefPathData::CrateRoot => {
data = DefPathData::TypeNs( 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 // FIXME(eddyb) `name` should never be empty, but it
// currently is for `extern { ... }` "foreign modules". // 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 !name.is_empty() {
if !self.empty_path { if !self.empty_path {
write!(self, "::")?; 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 { let namespace_name = match def_key.disambiguated_data.data {
DefPathData::CrateRoot => cx.tcx.crate_name(def_id.krate).as_str(), 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); 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()); output.push_str(&tcx.crate_name(def_id.krate).as_str());
for path_element in tcx.def_path(def_id).data { for path_element in tcx.def_path(def_id).data {
output.push_str("::"); 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 { } else {
output.push_str(&tcx.item_name(def_id).as_str()); 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.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) Ok(self)
} }
fn path_generic_args( fn path_generic_args(

2
src/librustc_metadata/cstore_impl.rs
View file

@ -460,7 +460,7 @@ impl cstore::CStore {
LoadedMacro::MacroDef(ast::Item { LoadedMacro::MacroDef(ast::Item {
// FIXME: cross-crate hygiene // 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, id: ast::DUMMY_NODE_ID,
span: local_span, span: local_span,
attrs: attrs.iter().cloned().collect(), 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::source_map::{self, respan, Spanned};
use syntax::symbol::{Symbol, sym}; use syntax::symbol::{Symbol, sym};
use syntax_expand::base::{MacroKind, SyntaxExtensionKind, SyntaxExtension}; 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 log::debug;
use proc_macro::bridge::client::ProcMacro; use proc_macro::bridge::client::ProcMacro;
use syntax_expand::proc_macro::{AttrProcMacro, ProcMacroDerive, BangProcMacro}; use syntax_expand::proc_macro::{AttrProcMacro, ProcMacroDerive, BangProcMacro};
@ -514,7 +514,6 @@ impl<'a, 'tcx> CrateMetadata {
.data .data
.get_opt_name() .get_opt_name()
.expect("no name in item_name") .expect("no name in item_name")
.as_symbol()
} else { } else {
Symbol::intern(self.raw_proc_macro(item_index).name()) 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); let span = self.get_span(child_index, sess);
if let (Some(kind), Some(name)) = if let (Some(kind), Some(name)) =
(self.def_kind(child_index), def_key.disambiguated_data.data.get_opt_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 vis = self.get_visibility(child_index);
let def_id = self.local_def_id(child_index); let def_id = self.local_def_id(child_index);
let res = Res::Def(kind, def_id); let res = Res::Def(kind, def_id);
@ -987,7 +986,7 @@ impl<'a, 'tcx> CrateMetadata {
}; };
ty::AssocItem { ty::AssocItem {
ident: Ident::from_interned_str(name), ident: Ident::with_dummy_span(name),
kind, kind,
vis: self.get_visibility(id), vis: self.get_visibility(id),
defaultness: container.defaultness(), defaultness: container.defaultness(),
@ -1262,7 +1261,7 @@ impl<'a, 'tcx> CrateMetadata {
let mut key = self.def_path_table.def_key(index); let mut key = self.def_path_table.def_key(index);
if self.is_proc_macro(index) { if self.is_proc_macro(index) {
let name = self.raw_proc_macro(index).name(); 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 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("::");
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) Ok(self)
} }

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

@ -762,7 +762,7 @@ fn compute_codegen_unit_name(
let components = def_path let components = def_path
.data .data
.iter() .iter()
.map(|part| part.data.as_interned_str()); .map(|part| part.data.as_symbol());
let volatile_suffix = if volatile { let volatile_suffix = if volatile {
Some("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 { 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 { } else {
let def_key = self.cstore.def_key(def_id); let def_key = self.cstore.def_key(def_id);
(def_key.disambiguated_data.data.get_opt_name().unwrap(), (def_key.disambiguated_data.data.get_opt_name().unwrap(),
Some(self.get_module(DefId { index: def_key.parent.unwrap(), ..def_id }))) 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( let module = self.arenas.alloc_module(ModuleData::new(
parent, kind, def_id, ExpnId::root(), DUMMY_SP parent, kind, def_id, ExpnId::root(), DUMMY_SP
)); ));