Auto merge of rust-lang#80119 - GuillaumeGomez:str-to-symbol, r=jyn514

bors · bors · commit fee693d08e98 · 2020-12-18T05:55:24.000Z
Continue String to Symbol conversion in rustdoc Follow-up of rust-lang#80091. This PR is already big enough so I'll stop here before the next one. r? `@jyn514`
diff --git a/src/librustdoc/clean/auto_trait.rs b/src/librustdoc/clean/auto_trait.rs
@@ -61,10 +61,10 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
                             .params
                             .iter()
                             .filter_map(|param| match param.kind {
-                                ty::GenericParamDefKind::Lifetime => Some(param.name.to_string()),
+                                ty::GenericParamDefKind::Lifetime => Some(param.name),
                                 _ => None,
                             })
-                            .map(|name| (name.clone(), Lifetime(name)))
+                            .map(|name| (name, Lifetime(name)))
                             .collect();
                         let lifetime_predicates = self.handle_lifetimes(&region_data, &names_map);
                         let new_generics = self.param_env_to_generics(
@@ -145,21 +145,21 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
     fn get_lifetime(
         &self,
         region: Region<'_>,
-        names_map: &FxHashMap<String, Lifetime>,
+        names_map: &FxHashMap<Symbol, Lifetime>,
     ) -> Lifetime {
         self.region_name(region)
             .map(|name| {
                 names_map.get(&name).unwrap_or_else(|| {
-                    panic!("Missing lifetime with name {:?} for {:?}", name, region)
+                    panic!("Missing lifetime with name {:?} for {:?}", name.as_str(), region)
                 })
             })
             .unwrap_or(&Lifetime::statik())
             .clone()
     }
 
-    fn region_name(&self, region: Region<'_>) -> Option<String> {
+    fn region_name(&self, region: Region<'_>) -> Option<Symbol> {
         match region {
-            &ty::ReEarlyBound(r) => Some(r.name.to_string()),
+            &ty::ReEarlyBound(r) => Some(r.name),
             _ => None,
         }
     }
@@ -177,7 +177,7 @@ impl<'a, 'tcx> AutoTraitFinder<'a, 'tcx> {
     fn handle_lifetimes<'cx>(
         &self,
         regions: &RegionConstraintData<'cx>,
-        names_map: &FxHashMap<String, Lifetime>,
+        names_map: &FxHashMap<Symbol, Lifetime>,
     ) -> Vec<WherePredicate> {
         // Our goal is to 'flatten' the list of constraints by eliminating
         // all intermediate RegionVids. At the end, all constraints should
diff --git a/src/librustdoc/clean/inline.rs b/src/librustdoc/clean/inline.rs
@@ -486,13 +486,13 @@ fn build_module(cx: &DocContext<'_>, did: DefId, visited: &mut FxHashSet<DefId>)
                         const_stability: None,
                         deprecation: None,
                         kind: clean::ImportItem(clean::Import::new_simple(
-                            item.ident.to_string(),
+                            item.ident.name,
                             clean::ImportSource {
                                 path: clean::Path {
                                     global: false,
                                     res: item.res,
                                     segments: vec![clean::PathSegment {
-                                        name: clean::PrimitiveType::from(p).as_str().to_string(),
+                                        name: clean::PrimitiveType::from(p).as_sym(),
                                         args: clean::GenericArgs::AngleBracketed {
                                             args: Vec::new(),
                                             bindings: Vec::new(),
@@ -562,11 +562,11 @@ fn build_macro(cx: &DocContext<'_>, did: DefId, name: Symbol) -> clean::ItemKind
                     .collect::<String>()
             );
 
-            clean::MacroItem(clean::Macro { source, imported_from: Some(imported_from).clean(cx) })
+            clean::MacroItem(clean::Macro { source, imported_from: Some(imported_from) })
         }
         LoadedMacro::ProcMacro(ext) => clean::ProcMacroItem(clean::ProcMacro {
             kind: ext.macro_kind(),
-            helpers: ext.helper_attrs.clean(cx),
+            helpers: ext.helper_attrs,
         }),
     }
 }
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -379,7 +379,7 @@ impl Clean<Lifetime> for hir::Lifetime {
             }
             _ => {}
         }
-        Lifetime(self.name.ident().to_string())
+        Lifetime(self.name.ident().name)
     }
 }
 
@@ -397,9 +397,9 @@ impl Clean<Lifetime> for hir::GenericParam<'_> {
                     for bound in bounds {
                         s.push_str(&format!(" + {}", bound.name.ident()));
                     }
-                    Lifetime(s)
+                    Lifetime(Symbol::intern(&s))
                 } else {
-                    Lifetime(self.name.ident().to_string())
+                    Lifetime(self.name.ident().name)
                 }
             }
             _ => panic!(),
@@ -423,16 +423,16 @@ impl Clean<Constant> for hir::ConstArg {
 
 impl Clean<Lifetime> for ty::GenericParamDef {
     fn clean(&self, _cx: &DocContext<'_>) -> Lifetime {
-        Lifetime(self.name.to_string())
+        Lifetime(self.name)
     }
 }
 
 impl Clean<Option<Lifetime>> for ty::RegionKind {
-    fn clean(&self, cx: &DocContext<'_>) -> Option<Lifetime> {
+    fn clean(&self, _cx: &DocContext<'_>) -> Option<Lifetime> {
         match *self {
             ty::ReStatic => Some(Lifetime::statik()),
-            ty::ReLateBound(_, ty::BrNamed(_, name)) => Some(Lifetime(name.to_string())),
-            ty::ReEarlyBound(ref data) => Some(Lifetime(data.name.clean(cx))),
+            ty::ReLateBound(_, ty::BrNamed(_, name)) => Some(Lifetime(name)),
+            ty::ReEarlyBound(ref data) => Some(Lifetime(data.name)),
 
             ty::ReLateBound(..)
             | ty::ReFree(..)
@@ -897,7 +897,7 @@ fn clean_fn_or_proc_macro(
                     }
                 }
             }
-            ProcMacroItem(ProcMacro { kind, helpers: helpers.clean(cx) })
+            ProcMacroItem(ProcMacro { kind, helpers })
         }
         None => {
             let mut func = (sig, generics, body_id).clean(cx);
@@ -1914,7 +1914,7 @@ impl Clean<GenericArgs> for hir::GenericArgs<'_> {
 
 impl Clean<PathSegment> for hir::PathSegment<'_> {
     fn clean(&self, cx: &DocContext<'_>) -> PathSegment {
-        PathSegment { name: self.ident.name.clean(cx), args: self.generic_args().clean(cx) }
+        PathSegment { name: self.ident.name, args: self.generic_args().clean(cx) }
     }
 }
 
@@ -2132,7 +2132,6 @@ fn clean_extern_crate(
             return items;
         }
     }
-    let path = orig_name.map(|x| x.to_string());
     // FIXME: using `from_def_id_and_kind` breaks `rustdoc/masked` for some reason
     vec![Item {
         name: None,
@@ -2143,7 +2142,7 @@ fn clean_extern_crate(
         stability: None,
         const_stability: None,
         deprecation: None,
-        kind: ExternCrateItem(name.clean(cx), path),
+        kind: ExternCrateItem(name, orig_name),
     }]
 }
 
@@ -2215,15 +2214,15 @@ impl Clean<Vec<Item>> for doctree::Import<'_> {
                         const_stability: None,
                         deprecation: None,
                         kind: ImportItem(Import::new_simple(
-                            self.name.clean(cx),
+                            self.name,
                             resolve_use_source(cx, path),
                             false,
                         )),
                     });
                     return items;
                 }
             }
-            Import::new_simple(name.clean(cx), resolve_use_source(cx, path), true)
+            Import::new_simple(name, resolve_use_source(cx, path), true)
         };
 
         vec![Item {
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
@@ -295,7 +295,7 @@ impl Item {
 
 #[derive(Clone, Debug)]
 crate enum ItemKind {
-    ExternCrateItem(String, Option<String>),
+    ExternCrateItem(Symbol, Option<Symbol>),
     ImportItem(Import),
     StructItem(Struct),
     UnionItem(Union),
@@ -877,21 +877,19 @@ impl GenericBound {
 }
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
-crate struct Lifetime(pub String);
+crate struct Lifetime(pub Symbol);
 
 impl Lifetime {
-    crate fn get_ref<'a>(&'a self) -> &'a str {
-        let Lifetime(ref s) = *self;
-        let s: &'a str = s;
-        s
+    crate fn get_ref(&self) -> SymbolStr {
+        self.0.as_str()
     }
 
     crate fn statik() -> Lifetime {
-        Lifetime("'static".to_string())
+        Lifetime(kw::StaticLifetime)
     }
 
     crate fn elided() -> Lifetime {
-        Lifetime("'_".to_string())
+        Lifetime(kw::UnderscoreLifetime)
     }
 }
 
@@ -1675,13 +1673,17 @@ crate struct Path {
 }
 
 impl Path {
-    crate fn last_name(&self) -> &str {
+    crate fn last(&self) -> Symbol {
+        self.segments.last().expect("segments were empty").name
+    }
+
+    crate fn last_name(&self) -> SymbolStr {
         self.segments.last().expect("segments were empty").name.as_str()
     }
 
     crate fn whole_name(&self) -> String {
         String::from(if self.global { "::" } else { "" })
-            + &self.segments.iter().map(|s| s.name.clone()).collect::<Vec<_>>().join("::")
+            + &self.segments.iter().map(|s| s.name.to_string()).collect::<Vec<_>>().join("::")
     }
 }
 
@@ -1700,7 +1702,7 @@ crate enum GenericArgs {
 
 #[derive(Clone, PartialEq, Eq, Debug, Hash)]
 crate struct PathSegment {
-    crate name: String,
+    crate name: Symbol,
     crate args: GenericArgs,
 }
 
@@ -1777,7 +1779,7 @@ crate struct Import {
 }
 
 impl Import {
-    crate fn new_simple(name: String, source: ImportSource, should_be_displayed: bool) -> Self {
+    crate fn new_simple(name: Symbol, source: ImportSource, should_be_displayed: bool) -> Self {
         Self { kind: ImportKind::Simple(name), source, should_be_displayed }
     }
 
@@ -1789,7 +1791,7 @@ impl Import {
 #[derive(Clone, Debug)]
 crate enum ImportKind {
     // use source as str;
-    Simple(String),
+    Simple(Symbol),
     // use source::*;
     Glob,
 }
@@ -1803,13 +1805,13 @@ crate struct ImportSource {
 #[derive(Clone, Debug)]
 crate struct Macro {
     crate source: String,
-    crate imported_from: Option<String>,
+    crate imported_from: Option<Symbol>,
 }
 
 #[derive(Clone, Debug)]
 crate struct ProcMacro {
     crate kind: MacroKind,
-    crate helpers: Vec<String>,
+    crate helpers: Vec<Symbol>,
 }
 
 /// An type binding on an associated type (e.g., `A = Bar` in `Foo<A = Bar>` or
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
@@ -153,7 +153,7 @@ pub(super) fn external_path(
         global: false,
         res: Res::Err,
         segments: vec![PathSegment {
-            name: name.to_string(),
+            name,
             args: external_generic_args(cx, trait_did, has_self, bindings, substs),
         }],
     }
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
@@ -308,7 +308,7 @@ impl<'a> fmt::Display for WhereClause<'a> {
 }
 
 impl clean::Lifetime {
-    crate fn print(&self) -> &str {
+    crate fn print(&self) -> impl fmt::Display + '_ {
         self.get_ref()
     }
 }
@@ -445,11 +445,10 @@ impl clean::GenericArgs {
 impl clean::PathSegment {
     crate fn print(&self) -> impl fmt::Display + '_ {
         display_fn(move |f| {
-            f.write_str(&self.name)?;
             if f.alternate() {
-                write!(f, "{:#}", self.args.print())
+                write!(f, "{}{:#}", self.name, self.args.print())
             } else {
-                write!(f, "{}", self.args.print())
+                write!(f, "{}{}", self.name, self.args.print())
             }
         })
     }
@@ -544,7 +543,7 @@ fn resolved_path(
                 last.name.to_string()
             }
         } else {
-            anchor(did, &last.name).to_string()
+            anchor(did, &*last.name.as_str()).to_string()
         };
         write!(w, "{}{}", path, last.args.print())?;
     }
@@ -1159,11 +1158,11 @@ impl PrintWithSpace for hir::Mutability {
 impl clean::Import {
     crate fn print(&self) -> impl fmt::Display + '_ {
         display_fn(move |f| match self.kind {
-            clean::ImportKind::Simple(ref name) => {
-                if *name == self.source.path.last_name() {
+            clean::ImportKind::Simple(name) => {
+                if name == self.source.path.last() {
                     write!(f, "use {};", self.source.print())
                 } else {
-                    write!(f, "use {} as {};", self.source.print(), *name)
+                    write!(f, "use {} as {};", self.source.print(), name)
                 }
             }
             clean::ImportKind::Glob => {
@@ -1187,7 +1186,7 @@ impl clean::ImportSource {
                 }
                 let name = self.path.last_name();
                 if let hir::def::Res::PrimTy(p) = self.path.res {
-                    primitive_link(f, PrimitiveType::from(p), name)?;
+                    primitive_link(f, PrimitiveType::from(p), &*name)?;
                 } else {
                     write!(f, "{}", name)?;
                 }
diff --git a/src/librustdoc/html/render/cache.rs b/src/librustdoc/html/render/cache.rs
@@ -2,7 +2,7 @@ use std::collections::BTreeMap;
 use std::path::Path;
 
 use rustc_data_structures::fx::FxHashMap;
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{sym, Symbol};
 use serde::Serialize;
 
 use crate::clean::types::GetDefId;
@@ -191,12 +191,12 @@ fn get_index_type(clean_type: &clean::Type) -> RenderType {
     RenderType {
         ty: clean_type.def_id(),
         idx: None,
-        name: get_index_type_name(clean_type, true).map(|s| s.to_ascii_lowercase()),
+        name: get_index_type_name(clean_type, true).map(|s| s.as_str().to_ascii_lowercase()),
         generics: get_generics(clean_type),
     }
 }
 
-fn get_index_type_name(clean_type: &clean::Type, accept_generic: bool) -> Option<String> {
+fn get_index_type_name(clean_type: &clean::Type, accept_generic: bool) -> Option<Symbol> {
     match *clean_type {
         clean::ResolvedPath { ref path, .. } => {
             let segments = &path.segments;
@@ -206,10 +206,10 @@ fn get_index_type_name(clean_type: &clean::Type, accept_generic: bool) -> Option
                 clean_type, accept_generic
             )
             });
-            Some(path_segment.name.clone())
+            Some(path_segment.name)
         }
-        clean::Generic(s) if accept_generic => Some(s.to_string()),
-        clean::Primitive(ref p) => Some(format!("{:?}", p)),
+        clean::Generic(s) if accept_generic => Some(s),
+        clean::Primitive(ref p) => Some(p.as_sym()),
         clean::BorrowedRef { ref type_, .. } => get_index_type_name(type_, accept_generic),
         // FIXME: add all from clean::Type.
         _ => None,
@@ -222,7 +222,7 @@ fn get_generics(clean_type: &clean::Type) -> Option<Vec<Generic>> {
             .iter()
             .filter_map(|t| {
                 get_index_type_name(t, false).map(|name| Generic {
-                    name: name.to_ascii_lowercase(),
+                    name: name.as_str().to_ascii_lowercase(),
                     defid: t.def_id(),
                     idx: None,
                 })
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
diff --git a/src/librustdoc/json/conversions.rs b/src/librustdoc/json/conversions.rs

Original file line number	Diff line number	Diff line change
`@@ -379,7 +379,7 @@ impl Clean<Lifetime> for hir::Lifetime {`
`379`	`379`	`}`
`380`	`380`	`_ => {}`
`381`	`381`	`}`
`382`		`- Lifetime(self.name.ident().to_string())`
	`382`	`+ Lifetime(self.name.ident().name)`
`383`	`383`	`}`
`384`	`384`	`}`
`385`	`385`
`@@ -397,9 +397,9 @@ impl Clean<Lifetime> for hir::GenericParam<'_> {`
`397`	`397`	`for bound in bounds {`
`398`	`398`	`s.push_str(&format!(" + {}", bound.name.ident()));`
`399`	`399`	`}`
`400`		`- Lifetime(s)`
	`400`	`+ Lifetime(Symbol::intern(&s))`
`401`	`401`	`} else {`
`402`		`- Lifetime(self.name.ident().to_string())`
	`402`	`+ Lifetime(self.name.ident().name)`
`403`	`403`	`}`
`404`	`404`	`}`
`405`	`405`	`_ => panic!(),`
`@@ -423,16 +423,16 @@ impl Clean<Constant> for hir::ConstArg {`
`423`	`423`
`424`	`424`	`impl Clean<Lifetime> for ty::GenericParamDef {`
`425`	`425`	`fn clean(&self, _cx: &DocContext<'_>) -> Lifetime {`
`426`		`- Lifetime(self.name.to_string())`
	`426`	`+ Lifetime(self.name)`
`427`	`427`	`}`
`428`	`428`	`}`
`429`	`429`
`430`	`430`	`impl Clean<Option<Lifetime>> for ty::RegionKind {`
`431`		`- fn clean(&self, cx: &DocContext<'_>) -> Option<Lifetime> {`
	`431`	`+ fn clean(&self, _cx: &DocContext<'_>) -> Option<Lifetime> {`
`432`	`432`	`match *self {`
`433`	`433`	`ty::ReStatic => Some(Lifetime::statik()),`
`434`		`- ty::ReLateBound(_, ty::BrNamed(_, name)) => Some(Lifetime(name.to_string())),`
`435`		`- ty::ReEarlyBound(ref data) => Some(Lifetime(data.name.clean(cx))),`
	`434`	`+ ty::ReLateBound(_, ty::BrNamed(_, name)) => Some(Lifetime(name)),`
	`435`	`+ ty::ReEarlyBound(ref data) => Some(Lifetime(data.name)),`
`436`	`436`
`437`	`437`	`ty::ReLateBound(..)`
`438`	`438`	`\| ty::ReFree(..)`
`@@ -897,7 +897,7 @@ fn clean_fn_or_proc_macro(`
`897`	`897`	`}`
`898`	`898`	`}`
`899`	`899`	`}`
`900`		`- ProcMacroItem(ProcMacro { kind, helpers: helpers.clean(cx) })`
	`900`	`+ ProcMacroItem(ProcMacro { kind, helpers })`
`901`	`901`	`}`
`902`	`902`	`None => {`
`903`	`903`	`let mut func = (sig, generics, body_id).clean(cx);`
`@@ -1914,7 +1914,7 @@ impl Clean<GenericArgs> for hir::GenericArgs<'_> {`
`1914`	`1914`
`1915`	`1915`	`impl Clean<PathSegment> for hir::PathSegment<'_> {`
`1916`	`1916`	`fn clean(&self, cx: &DocContext<'_>) -> PathSegment {`
`1917`		`- PathSegment { name: self.ident.name.clean(cx), args: self.generic_args().clean(cx) }`
	`1917`	`+ PathSegment { name: self.ident.name, args: self.generic_args().clean(cx) }`
`1918`	`1918`	`}`
`1919`	`1919`	`}`
`1920`	`1920`
`@@ -2132,7 +2132,6 @@ fn clean_extern_crate(`
`2132`	`2132`	`return items;`
`2133`	`2133`	`}`
`2134`	`2134`	`}`
`2135`		`- let path = orig_name.map(\|x\| x.to_string());`
`2136`	`2135`	// FIXME: using `from_def_id_and_kind` breaks `rustdoc/masked` for some reason
`2137`	`2136`	`vec![Item {`
`2138`	`2137`	`name: None,`
`@@ -2143,7 +2142,7 @@ fn clean_extern_crate(`
`2143`	`2142`	`stability: None,`
`2144`	`2143`	`const_stability: None,`
`2145`	`2144`	`deprecation: None,`
`2146`		`- kind: ExternCrateItem(name.clean(cx), path),`
	`2145`	`+ kind: ExternCrateItem(name, orig_name),`
`2147`	`2146`	`}]`
`2148`	`2147`	`}`
`2149`	`2148`
`@@ -2215,15 +2214,15 @@ impl Clean<Vec<Item>> for doctree::Import<'_> {`
`2215`	`2214`	`const_stability: None,`
`2216`	`2215`	`deprecation: None,`
`2217`	`2216`	`kind: ImportItem(Import::new_simple(`
`2218`		`- self.name.clean(cx),`
	`2217`	`+ self.name,`
`2219`	`2218`	`resolve_use_source(cx, path),`
`2220`	`2219`	`false,`
`2221`	`2220`	`)),`
`2222`	`2221`	`});`
`2223`	`2222`	`return items;`
`2224`	`2223`	`}`
`2225`	`2224`	`}`
`2226`		`- Import::new_simple(name.clean(cx), resolve_use_source(cx, path), true)`
	`2225`	`+ Import::new_simple(name, resolve_use_source(cx, path), true)`
`2227`	`2226`	`};`
`2228`	`2227`
`2229`	`2228`	`vec![Item {`
Original file line number	Diff line number	Diff line change
`@@ -295,7 +295,7 @@ impl Item {`
`295`	`295`
`296`	`296`	`#[derive(Clone, Debug)]`
`297`	`297`	`crate enum ItemKind {`
`298`		`- ExternCrateItem(String, Option<String>),`
	`298`	`+ ExternCrateItem(Symbol, Option<Symbol>),`
`299`	`299`	`ImportItem(Import),`
`300`	`300`	`StructItem(Struct),`
`301`	`301`	`UnionItem(Union),`
`@@ -877,21 +877,19 @@ impl GenericBound {`
`877`	`877`	`}`
`878`	`878`
`879`	`879`	`#[derive(Clone, PartialEq, Eq, Debug, Hash)]`
`880`		`-crate struct Lifetime(pub String);`
	`880`	`+crate struct Lifetime(pub Symbol);`
`881`	`881`
`882`	`882`	`impl Lifetime {`
`883`		`- crate fn get_ref<'a>(&'a self) -> &'a str {`
`884`		`- let Lifetime(ref s) = *self;`
`885`		`- let s: &'a str = s;`
`886`		`- s`
	`883`	`+ crate fn get_ref(&self) -> SymbolStr {`
	`884`	`+ self.0.as_str()`
`887`	`885`	`}`
`888`	`886`
`889`	`887`	`crate fn statik() -> Lifetime {`
`890`		`- Lifetime("'static".to_string())`
	`888`	`+ Lifetime(kw::StaticLifetime)`
`891`	`889`	`}`
`892`	`890`
`893`	`891`	`crate fn elided() -> Lifetime {`
`894`		`- Lifetime("'_".to_string())`
	`892`	`+ Lifetime(kw::UnderscoreLifetime)`
`895`	`893`	`}`
`896`	`894`	`}`
`897`	`895`
`@@ -1675,13 +1673,17 @@ crate struct Path {`
`1675`	`1673`	`}`
`1676`	`1674`
`1677`	`1675`	`impl Path {`
`1678`		`- crate fn last_name(&self) -> &str {`
	`1676`	`+ crate fn last(&self) -> Symbol {`
	`1677`	`+ self.segments.last().expect("segments were empty").name`
	`1678`	`+ }`
	`1679`	`+`
	`1680`	`+ crate fn last_name(&self) -> SymbolStr {`
`1679`	`1681`	`self.segments.last().expect("segments were empty").name.as_str()`
`1680`	`1682`	`}`
`1681`	`1683`
`1682`	`1684`	`crate fn whole_name(&self) -> String {`
`1683`	`1685`	`String::from(if self.global { "::" } else { "" })`
`1684`		`- + &self.segments.iter().map(\|s\| s.name.clone()).collect::<Vec<_>>().join("::")`
	`1686`	`+ + &self.segments.iter().map(\|s\| s.name.to_string()).collect::<Vec<_>>().join("::")`
`1685`	`1687`	`}`
`1686`	`1688`	`}`
`1687`	`1689`
`@@ -1700,7 +1702,7 @@ crate enum GenericArgs {`
`1700`	`1702`
`1701`	`1703`	`#[derive(Clone, PartialEq, Eq, Debug, Hash)]`
`1702`	`1704`	`crate struct PathSegment {`
`1703`		`- crate name: String,`
	`1705`	`+ crate name: Symbol,`
`1704`	`1706`	`crate args: GenericArgs,`
`1705`	`1707`	`}`
`1706`	`1708`
`@@ -1777,7 +1779,7 @@ crate struct Import {`
`1777`	`1779`	`}`
`1778`	`1780`
`1779`	`1781`	`impl Import {`
`1780`		`- crate fn new_simple(name: String, source: ImportSource, should_be_displayed: bool) -> Self {`
	`1782`	`+ crate fn new_simple(name: Symbol, source: ImportSource, should_be_displayed: bool) -> Self {`
`1781`	`1783`	`Self { kind: ImportKind::Simple(name), source, should_be_displayed }`
`1782`	`1784`	`}`
`1783`	`1785`
`@@ -1789,7 +1791,7 @@ impl Import {`
`1789`	`1791`	`#[derive(Clone, Debug)]`
`1790`	`1792`	`crate enum ImportKind {`
`1791`	`1793`	`// use source as str;`
`1792`		`- Simple(String),`
	`1794`	`+ Simple(Symbol),`
`1793`	`1795`	`// use source::*;`
`1794`	`1796`	`Glob,`
`1795`	`1797`	`}`
`@@ -1803,13 +1805,13 @@ crate struct ImportSource {`
`1803`	`1805`	`#[derive(Clone, Debug)]`
`1804`	`1806`	`crate struct Macro {`
`1805`	`1807`	`crate source: String,`
`1806`		`- crate imported_from: Option<String>,`
	`1808`	`+ crate imported_from: Option<Symbol>,`
`1807`	`1809`	`}`
`1808`	`1810`
`1809`	`1811`	`#[derive(Clone, Debug)]`
`1810`	`1812`	`crate struct ProcMacro {`
`1811`	`1813`	`crate kind: MacroKind,`
`1812`		`- crate helpers: Vec<String>,`
	`1814`	`+ crate helpers: Vec<Symbol>,`
`1813`	`1815`	`}`
`1814`	`1816`
`1815`	`1817`	/// An type binding on an associated type (e.g., `A = Bar` in `Foo<A = Bar>` or
Original file line number	Diff line number	Diff line change
`@@ -153,7 +153,7 @@ pub(super) fn external_path(`
`153`	`153`	`global: false,`
`154`	`154`	`res: Res::Err,`
`155`	`155`	`segments: vec![PathSegment {`
`156`		`- name: name.to_string(),`
	`156`	`+ name,`
`157`	`157`	`args: external_generic_args(cx, trait_did, has_self, bindings, substs),`
`158`	`158`	`}],`
`159`	`159`	`}`
Original file line number	Diff line number	Diff line change
`@@ -308,7 +308,7 @@ impl<'a> fmt::Display for WhereClause<'a> {`
`308`	`308`	`}`
`309`	`309`
`310`	`310`	`impl clean::Lifetime {`
`311`		`- crate fn print(&self) -> &str {`
	`311`	`+ crate fn print(&self) -> impl fmt::Display + '_ {`
`312`	`312`	`self.get_ref()`
`313`	`313`	`}`
`314`	`314`	`}`
`@@ -445,11 +445,10 @@ impl clean::GenericArgs {`
`445`	`445`	`impl clean::PathSegment {`
`446`	`446`	`crate fn print(&self) -> impl fmt::Display + '_ {`
`447`	`447`	`display_fn(move \|f\| {`
`448`		`- f.write_str(&self.name)?;`
`449`	`448`	`if f.alternate() {`
`450`		`- write!(f, "{:#}", self.args.print())`
	`449`	`+ write!(f, "{}{:#}", self.name, self.args.print())`
`451`	`450`	`} else {`
`452`		`- write!(f, "{}", self.args.print())`
	`451`	`+ write!(f, "{}{}", self.name, self.args.print())`
`453`	`452`	`}`
`454`	`453`	`})`
`455`	`454`	`}`
`@@ -544,7 +543,7 @@ fn resolved_path(`
`544`	`543`	`last.name.to_string()`
`545`	`544`	`}`
`546`	`545`	`} else {`
`547`		`- anchor(did, &last.name).to_string()`
	`546`	`+ anchor(did, &*last.name.as_str()).to_string()`
`548`	`547`	`};`
`549`	`548`	`write!(w, "{}{}", path, last.args.print())?;`
`550`	`549`	`}`
`@@ -1159,11 +1158,11 @@ impl PrintWithSpace for hir::Mutability {`
`1159`	`1158`	`impl clean::Import {`
`1160`	`1159`	`crate fn print(&self) -> impl fmt::Display + '_ {`
`1161`	`1160`	`display_fn(move \|f\| match self.kind {`
`1162`		`- clean::ImportKind::Simple(ref name) => {`
`1163`		`- if *name == self.source.path.last_name() {`
	`1161`	`+ clean::ImportKind::Simple(name) => {`
	`1162`	`+ if name == self.source.path.last() {`
`1164`	`1163`	`write!(f, "use {};", self.source.print())`
`1165`	`1164`	`} else {`
`1166`		`- write!(f, "use {} as {};", self.source.print(), *name)`
	`1165`	`+ write!(f, "use {} as {};", self.source.print(), name)`
`1167`	`1166`	`}`
`1168`	`1167`	`}`
`1169`	`1168`	`clean::ImportKind::Glob => {`
`@@ -1187,7 +1186,7 @@ impl clean::ImportSource {`
`1187`	`1186`	`}`
`1188`	`1187`	`let name = self.path.last_name();`
`1189`	`1188`	`if let hir::def::Res::PrimTy(p) = self.path.res {`
`1190`		`- primitive_link(f, PrimitiveType::from(p), name)?;`
	`1189`	`+ primitive_link(f, PrimitiveType::from(p), &*name)?;`
`1191`	`1190`	`} else {`
`1192`	`1191`	`write!(f, "{}", name)?;`
`1193`	`1192`	`}`