Introduce InternedString::intern.

nnethercote · nnethercote · commit 47656a3db799 · 2019-05-14T16:30:25.000+10:00
`InternedString::intern(x)` is preferable to
`Symbol::intern(x).as_interned_str()`, because the former involves one
call to `with_interner` while the latter involves two.

The case within InternedString::decode() is particularly hot, and this
change reduces the number of `with_interner` calls by up to 13%.
diff --git a/src/librustc/hir/map/definitions.rs b/src/librustc/hir/map/definitions.rs
@@ -593,7 +593,7 @@ impl DefPathData {
             ImplTrait => "{{opaque}}",
         };
 
-        Symbol::intern(s).as_interned_str()
+        InternedString::intern(s)
     }
 
     pub fn to_string(&self) -> String {
diff --git a/src/librustc/mir/mono.rs b/src/librustc/mir/mono.rs
@@ -1,6 +1,6 @@
 use crate::hir::def_id::{DefId, CrateNum, LOCAL_CRATE};
 use crate::hir::HirId;
-use syntax::symbol::{Symbol, InternedString};
+use syntax::symbol::InternedString;
 use crate::ty::{Instance, TyCtxt};
 use crate::util::nodemap::FxHashMap;
 use rustc_data_structures::base_n;
@@ -280,7 +280,7 @@ impl<'a, 'gcx: 'tcx, 'tcx: 'a> CodegenUnitNameBuilder<'a, 'gcx, 'tcx> {
             cgu_name
         } else {
             let cgu_name = &cgu_name.as_str()[..];
-            Symbol::intern(&CodegenUnit::mangle_name(cgu_name)).as_interned_str()
+            InternedString::intern(&CodegenUnit::mangle_name(cgu_name))
         }
     }
 
@@ -336,6 +336,6 @@ impl<'a, 'gcx: 'tcx, 'tcx: 'a> CodegenUnitNameBuilder<'a, 'gcx, 'tcx> {
             write!(cgu_name, ".{}", special_suffix).unwrap();
         }
 
-        Symbol::intern(&cgu_name[..]).as_interned_str()
+        InternedString::intern(&cgu_name[..])
     }
 }
diff --git a/src/librustc/ty/mod.rs b/src/librustc/ty/mod.rs
@@ -3405,7 +3405,7 @@ impl_stable_hash_for!(struct self::SymbolName {
 impl SymbolName {
     pub fn new(name: &str) -> SymbolName {
         SymbolName {
-            name: Symbol::intern(name).as_interned_str()
+            name: InternedString::intern(name)
         }
     }
 
diff --git a/src/librustc/ty/query/values.rs b/src/librustc/ty/query/values.rs
@@ -1,7 +1,7 @@
 use crate::ty::{self, Ty, TyCtxt, AdtSizedConstraint};
 use crate::ty::util::NeedsDrop;
 
-use syntax::symbol::Symbol;
+use syntax::symbol::InternedString;
 
 pub(super) trait Value<'tcx>: Sized {
     fn from_cycle_error<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Self;
@@ -28,7 +28,7 @@ impl<'tcx> Value<'tcx> for Ty<'tcx> {
 
 impl<'tcx> Value<'tcx> for ty::SymbolName {
     fn from_cycle_error<'a>(_: TyCtxt<'a, 'tcx, 'tcx>) -> Self {
-        ty::SymbolName { name: Symbol::intern("<error>").as_interned_str() }
+        ty::SymbolName { name: InternedString::intern("<error>") }
     }
 }
 
diff --git a/src/librustc_codegen_utils/symbol_names.rs b/src/librustc_codegen_utils/symbol_names.rs
@@ -322,7 +322,7 @@ fn compute_symbol_name(tcx: TyCtxt<'_, 'tcx, 'tcx>, instance: Instance<'tcx>) ->
         let _ = printer.write_str("{{vtable-shim}}");
     }
 
-    Symbol::intern(&printer.path.finish(hash)).as_interned_str()
+    InternedString::intern(&printer.path.finish(hash))
 }
 
 // Follow C++ namespace-mangling style, see
diff --git a/src/librustc_mir/monomorphize/item.rs b/src/librustc_mir/monomorphize/item.rs
@@ -10,7 +10,7 @@ use syntax::attr::InlineAttr;
 use std::fmt::{self, Write};
 use std::iter;
 use rustc::mir::mono::Linkage;
-use syntax_pos::symbol::Symbol;
+use syntax_pos::symbol::InternedString;
 use syntax::source_map::Span;
 pub use rustc::mir::mono::MonoItem;
 
@@ -61,7 +61,7 @@ pub trait MonoItemExt<'a, 'tcx>: fmt::Debug {
             MonoItem::GlobalAsm(hir_id) => {
                 let def_id = tcx.hir().local_def_id_from_hir_id(hir_id);
                 ty::SymbolName {
-                    name: Symbol::intern(&format!("global_asm_{:?}", def_id)).as_interned_str()
+                    name: InternedString::intern(&format!("global_asm_{:?}", def_id))
                 }
             }
         }
diff --git a/src/librustc_mir/transform/check_unsafety.rs b/src/librustc_mir/transform/check_unsafety.rs
@@ -12,7 +12,7 @@ use rustc::lint::builtin::{SAFE_EXTERN_STATICS, SAFE_PACKED_BORROWS, UNUSED_UNSA
 use rustc::mir::*;
 use rustc::mir::visit::{PlaceContext, Visitor, MutatingUseContext};
 
-use syntax::symbol::{Symbol, sym};
+use syntax::symbol::{InternedString, Symbol, sym};
 
 use std::ops::Bound;
 
@@ -167,7 +167,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
                     (CastTy::FnPtr, CastTy::Int(_)) => {
                         self.register_violations(&[UnsafetyViolation {
                             source_info: self.source_info,
-                            description: Symbol::intern("cast of pointer to int").as_interned_str(),
+                            description: InternedString::intern("cast of pointer to int"),
                             details: Symbol::intern("casting pointers to integers in constants")
                                      .as_interned_str(),
                             kind: UnsafetyViolationKind::General,
@@ -185,7 +185,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
                 if let ty::RawPtr(_) | ty::FnPtr(..) = lhs.ty(self.mir, self.tcx).sty {
                     self.register_violations(&[UnsafetyViolation {
                         source_info: self.source_info,
-                        description: Symbol::intern("pointer operation").as_interned_str(),
+                        description: InternedString::intern("pointer operation"),
                         details: Symbol::intern("operations on pointers in constants")
                                  .as_interned_str(),
                         kind: UnsafetyViolationKind::General,
@@ -212,7 +212,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
                             self.source_scope_local_data[source_info.scope].lint_root;
                         self.register_violations(&[UnsafetyViolation {
                             source_info,
-                            description: Symbol::intern("borrow of packed field").as_interned_str(),
+                            description: InternedString::intern("borrow of packed field"),
                             details:
                                 Symbol::intern("fields of packed structs might be misaligned: \
                                                 dereferencing a misaligned pointer or even just \
@@ -315,7 +315,7 @@ impl<'a, 'tcx> Visitor<'tcx> for UnsafetyChecker<'a, 'tcx> {
                         self.source_scope_local_data[source_info.scope].lint_root;
                     self.register_violations(&[UnsafetyViolation {
                         source_info,
-                        description: Symbol::intern("use of extern static").as_interned_str(),
+                        description: InternedString::intern("use of extern static"),
                         details:
                             Symbol::intern("extern statics are not controlled by the Rust type \
                                             system: invalid data, aliasing violations or data \
@@ -340,8 +340,8 @@ impl<'a, 'tcx> UnsafetyChecker<'a, 'tcx> {
         let source_info = self.source_info;
         self.register_violations(&[UnsafetyViolation {
             source_info,
-            description: Symbol::intern(description).as_interned_str(),
-            details: Symbol::intern(details).as_interned_str(),
+            description: InternedString::intern(description),
+            details: InternedString::intern(details),
             kind,
         }], &[]);
     }
@@ -441,8 +441,8 @@ impl<'a, 'tcx> UnsafetyChecker<'a, 'tcx> {
                                 let source_info = self.source_info;
                                 self.register_violations(&[UnsafetyViolation {
                                     source_info,
-                                    description: Symbol::intern(description).as_interned_str(),
-                                    details: Symbol::intern(details).as_interned_str(),
+                                    description: InternedString::intern(description),
+                                    details: InternedString::intern(details),
                                     kind: UnsafetyViolationKind::GeneralAndConstFn,
                                 }], &[]);
                             }
diff --git a/src/libsyntax_pos/symbol.rs b/src/libsyntax_pos/symbol.rs
@@ -1124,6 +1124,13 @@ pub struct InternedString {
 }
 
 impl InternedString {
+    /// Maps a string to its interned representation.
+    pub fn intern(string: &str) -> Self {
+        InternedString {
+            symbol: Symbol::intern(string)
+        }
+    }
+
     pub fn with<F: FnOnce(&str) -> R, R>(self, f: F) -> R {
         let str = with_interner(|interner| {
             interner.get(self.symbol) as *const str
@@ -1226,7 +1233,7 @@ impl fmt::Display for InternedString {
 
 impl Decodable for InternedString {
     fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> {
-        Ok(Symbol::intern(&d.read_str()?).as_interned_str())
+        Ok(InternedString::intern(&d.read_str()?))
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -593,7 +593,7 @@ impl DefPathData {`
`593`	`593`	`ImplTrait => "{{opaque}}",`
`594`	`594`	`};`
`595`	`595`
`596`		`- Symbol::intern(s).as_interned_str()`
	`596`	`+ InternedString::intern(s)`
`597`	`597`	`}`
`598`	`598`
`599`	`599`	`pub fn to_string(&self) -> String {`
Original file line number	Diff line number	Diff line change
`@@ -1,6 +1,6 @@`
`1`	`1`	`use crate::hir::def_id::{DefId, CrateNum, LOCAL_CRATE};`
`2`	`2`	`use crate::hir::HirId;`
`3`		`-use syntax::symbol::{Symbol, InternedString};`
	`3`	`+use syntax::symbol::InternedString;`
`4`	`4`	`use crate::ty::{Instance, TyCtxt};`
`5`	`5`	`use crate::util::nodemap::FxHashMap;`
`6`	`6`	`use rustc_data_structures::base_n;`
`@@ -280,7 +280,7 @@ impl<'a, 'gcx: 'tcx, 'tcx: 'a> CodegenUnitNameBuilder<'a, 'gcx, 'tcx> {`
`280`	`280`	`cgu_name`
`281`	`281`	`} else {`
`282`	`282`	`let cgu_name = &cgu_name.as_str()[..];`
`283`		`- Symbol::intern(&CodegenUnit::mangle_name(cgu_name)).as_interned_str()`
	`283`	`+ InternedString::intern(&CodegenUnit::mangle_name(cgu_name))`
`284`	`284`	`}`
`285`	`285`	`}`
`286`	`286`
`@@ -336,6 +336,6 @@ impl<'a, 'gcx: 'tcx, 'tcx: 'a> CodegenUnitNameBuilder<'a, 'gcx, 'tcx> {`
`336`	`336`	`write!(cgu_name, ".{}", special_suffix).unwrap();`
`337`	`337`	`}`
`338`	`338`
`339`		`- Symbol::intern(&cgu_name[..]).as_interned_str()`
	`339`	`+ InternedString::intern(&cgu_name[..])`
`340`	`340`	`}`
`341`	`341`	`}`
Original file line number	Diff line number	Diff line change
`@@ -3405,7 +3405,7 @@ impl_stable_hash_for!(struct self::SymbolName {`
`3405`	`3405`	`impl SymbolName {`
`3406`	`3406`	`pub fn new(name: &str) -> SymbolName {`
`3407`	`3407`	`SymbolName {`
`3408`		`- name: Symbol::intern(name).as_interned_str()`
	`3408`	`+ name: InternedString::intern(name)`
`3409`	`3409`	`}`
`3410`	`3410`	`}`
`3411`	`3411`
Original file line number	Diff line number	Diff line change
`@@ -1,7 +1,7 @@`
`1`	`1`	`use crate::ty::{self, Ty, TyCtxt, AdtSizedConstraint};`
`2`	`2`	`use crate::ty::util::NeedsDrop;`
`3`	`3`
`4`		`-use syntax::symbol::Symbol;`
	`4`	`+use syntax::symbol::InternedString;`
`5`	`5`
`6`	`6`	`pub(super) trait Value<'tcx>: Sized {`
`7`	`7`	`fn from_cycle_error<'a>(tcx: TyCtxt<'a, 'tcx, 'tcx>) -> Self;`
`@@ -28,7 +28,7 @@ impl<'tcx> Value<'tcx> for Ty<'tcx> {`
`28`	`28`
`29`	`29`	`impl<'tcx> Value<'tcx> for ty::SymbolName {`
`30`	`30`	`fn from_cycle_error<'a>(_: TyCtxt<'a, 'tcx, 'tcx>) -> Self {`
`31`		`- ty::SymbolName { name: Symbol::intern("<error>").as_interned_str() }`
	`31`	`+ ty::SymbolName { name: InternedString::intern("<error>") }`
`32`	`32`	`}`
`33`	`33`	`}`
`34`	`34`
Original file line number	Diff line number	Diff line change
`@@ -322,7 +322,7 @@ fn compute_symbol_name(tcx: TyCtxt<'_, 'tcx, 'tcx>, instance: Instance<'tcx>) ->`
`322`	`322`	`let _ = printer.write_str("{{vtable-shim}}");`
`323`	`323`	`}`
`324`	`324`
`325`		`- Symbol::intern(&printer.path.finish(hash)).as_interned_str()`
	`325`	`+ InternedString::intern(&printer.path.finish(hash))`
`326`	`326`	`}`
`327`	`327`
`328`	`328`	`// Follow C++ namespace-mangling style, see`
Original file line number	Diff line number	Diff line change
`@@ -10,7 +10,7 @@ use syntax::attr::InlineAttr;`
`10`	`10`	`use std::fmt::{self, Write};`
`11`	`11`	`use std::iter;`
`12`	`12`	`use rustc::mir::mono::Linkage;`
`13`		`-use syntax_pos::symbol::Symbol;`
	`13`	`+use syntax_pos::symbol::InternedString;`
`14`	`14`	`use syntax::source_map::Span;`
`15`	`15`	`pub use rustc::mir::mono::MonoItem;`
`16`	`16`
`@@ -61,7 +61,7 @@ pub trait MonoItemExt<'a, 'tcx>: fmt::Debug {`
`61`	`61`	`MonoItem::GlobalAsm(hir_id) => {`
`62`	`62`	`let def_id = tcx.hir().local_def_id_from_hir_id(hir_id);`
`63`	`63`	`ty::SymbolName {`
`64`		`- name: Symbol::intern(&format!("global_asm_{:?}", def_id)).as_interned_str()`
	`64`	`+ name: InternedString::intern(&format!("global_asm_{:?}", def_id))`
`65`	`65`	`}`
`66`	`66`	`}`
`67`	`67`	`}`
Original file line number	Diff line number	Diff line change
`@@ -1124,6 +1124,13 @@ pub struct InternedString {`
`1124`	`1124`	`}`
`1125`	`1125`
`1126`	`1126`	`impl InternedString {`
	`1127`	`+ /// Maps a string to its interned representation.`
	`1128`	`+ pub fn intern(string: &str) -> Self {`
	`1129`	`+ InternedString {`
	`1130`	`+ symbol: Symbol::intern(string)`
	`1131`	`+ }`
	`1132`	`+ }`
	`1133`	`+`
`1127`	`1134`	`pub fn with<F: FnOnce(&str) -> R, R>(self, f: F) -> R {`
`1128`	`1135`	`let str = with_interner(\|interner\| {`
`1129`	`1136`	`interner.get(self.symbol) as *const str`
`@@ -1226,7 +1233,7 @@ impl fmt::Display for InternedString {`
`1226`	`1233`
`1227`	`1234`	`impl Decodable for InternedString {`
`1228`	`1235`	`fn decode<D: Decoder>(d: &mut D) -> Result<InternedString, D::Error> {`
`1229`		`- Ok(Symbol::intern(&d.read_str()?).as_interned_str())`
	`1236`	`+ Ok(InternedString::intern(&d.read_str()?))`
`1230`	`1237`	`}`
`1231`	`1238`	`}`
`1232`	`1239`