XXX: kw::PathRoot

nnethercote · nnethercote · commit 062451aa9e07 · 2024-12-13T22:17:31.000+11:00
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
@@ -92,7 +92,7 @@ impl fmt::Display for Lifetime {
 pub struct Path {
     pub span: Span,
     /// The segments in the path: the things separated by `::`.
-    /// Global paths begin with `kw::PathRoot`.
+    /// Global paths begin with `sym::path_root`.
     pub segments: ThinVec<PathSegment>,
     pub tokens: Option<LazyAttrTokenStream>,
 }
@@ -121,7 +121,7 @@ impl Path {
     }
 
     pub fn is_global(&self) -> bool {
-        !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot
+        !self.segments.is_empty() && self.segments[0].ident.name == sym::path_root
     }
 
     /// If this path is a single identifier with no arguments, does not ensure
@@ -156,7 +156,7 @@ impl PathSegment {
     }
 
     pub fn path_root(span: Span) -> Self {
-        PathSegment::from_ident(Ident::new(kw::PathRoot, span))
+        PathSegment::from_ident(Ident::new(sym::path_root, span))
     }
 
     pub fn span(&self) -> Span {
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
@@ -918,7 +918,7 @@ impl Token {
     }
 
     /// Returns true for reserved identifiers used internally for elided lifetimes,
-    /// unnamed method parameters, crate root module, error recovery etc.
+    /// unnamed method parameters, error recovery etc.
     pub fn is_special_ident(&self) -> bool {
         self.is_non_raw_ident_where(Ident::is_special)
     }
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
@@ -564,7 +564,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let path = if trees.is_empty()
                     && !(prefix.segments.is_empty()
                         || prefix.segments.len() == 1
-                            && prefix.segments[0].ident.name == kw::PathRoot)
+                            && prefix.segments[0].ident.name == sym::path_root)
                 {
                     // For empty lists we need to lower the prefix so it is checked for things
                     // like stability later.
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -834,7 +834,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere
     }
 
     fn print_path_segment(&mut self, segment: &ast::PathSegment, colons_before_params: bool) {
-        if segment.ident.name != kw::PathRoot {
+        if segment.ident.name != sym::path_root {
             self.print_ident(segment.ident);
             if let Some(args) = &segment.args {
                 self.print_generic_args(args, colons_before_params);
diff --git a/compiler/rustc_builtin_macros/src/standard_library_imports.rs b/compiler/rustc_builtin_macros/src/standard_library_imports.rs
@@ -75,7 +75,7 @@ pub fn inject(
     // the one with the prelude.
     let name = names[0];
 
-    let root = (edition == Edition2015).then_some(kw::PathRoot);
+    let root = (edition == Edition2015).then_some(sym::path_root);
 
     let import_path = root
         .iter()
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
@@ -17,7 +17,7 @@ use rustc_macros::{Decodable, Encodable, HashStable_Generic};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::hygiene::MacroKind;
 use rustc_span::source_map::Spanned;
-use rustc_span::symbol::{Ident, Symbol, kw, sym};
+use rustc_span::symbol::{Ident, Symbol, sym};
 use rustc_span::{BytePos, DUMMY_SP, ErrorGuaranteed, Span};
 use rustc_target::asm::InlineAsmRegOrRegClass;
 use smallvec::SmallVec;
@@ -199,7 +199,7 @@ pub type UsePath<'hir> = Path<'hir, SmallVec<[Res; 3]>>;
 
 impl Path<'_> {
     pub fn is_global(&self) -> bool {
-        !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot
+        !self.segments.is_empty() && self.segments[0].ident.name == sym::path_root
     }
 }
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
@@ -20,7 +20,7 @@ use rustc_hir::{
 };
 use rustc_span::FileName;
 use rustc_span::source_map::SourceMap;
-use rustc_span::symbol::{Ident, Symbol, kw};
+use rustc_span::symbol::{Ident, Symbol, sym};
 use {rustc_ast as ast, rustc_hir as hir};
 
 pub fn id_to_string(map: &dyn rustc_hir::intravisit::Map<'_>, hir_id: HirId) -> String {
@@ -1563,15 +1563,15 @@ impl<'a> State<'a> {
             if i > 0 {
                 self.word("::")
             }
-            if segment.ident.name != kw::PathRoot {
+            if segment.ident.name != sym::path_root {
                 self.print_ident(segment.ident);
                 self.print_generic_args(segment.args(), colons_before_params);
             }
         }
     }
 
     fn print_path_segment(&mut self, segment: &hir::PathSegment<'_>) {
-        if segment.ident.name != kw::PathRoot {
+        if segment.ident.name != sym::path_root {
             self.print_ident(segment.ident);
             self.print_generic_args(segment.args(), false);
         }
@@ -1590,7 +1590,7 @@ impl<'a> State<'a> {
                     if i > 0 {
                         self.word("::")
                     }
-                    if segment.ident.name != kw::PathRoot {
+                    if segment.ident.name != sym::path_root {
                         self.print_ident(segment.ident);
                         self.print_generic_args(segment.args(), colons_before_params);
                     }
diff --git a/compiler/rustc_resolve/src/build_reduced_graph.rs b/compiler/rustc_resolve/src/build_reduced_graph.rs
@@ -332,7 +332,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                     None
                 } else if ident.span.is_rust_2015() {
                     Some(Segment::from_ident(Ident::new(
-                        kw::PathRoot,
+                        sym::path_root,
                         path.span.shrink_to_lo().with_ctxt(ident.span.ctxt()),
                     )))
                 } else {
@@ -514,7 +514,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         }
         .map(|ctxt| {
             Segment::from_ident(Ident::new(
-                kw::PathRoot,
+                sym::path_root,
                 use_tree.prefix.span.shrink_to_lo().with_ctxt(ctxt),
             ))
         });
@@ -523,7 +523,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
         debug!("build_reduced_graph_for_use_tree: prefix={:?}", prefix);
 
         let empty_for_self = |prefix: &[Segment]| {
-            prefix.is_empty() || prefix.len() == 1 && prefix[0].ident.name == kw::PathRoot
+            prefix.is_empty() || prefix.len() == 1 && prefix[0].ident.name == sym::path_root
         };
         match use_tree.kind {
             ast::UseTreeKind::Simple(rename) => {
@@ -595,7 +595,7 @@ impl<'a, 'ra, 'tcx> BuildReducedGraphVisitor<'a, 'ra, 'tcx> {
                         if crate_name != sym::empty {
                             // `crate_name` should not be interpreted as relative.
                             module_path.push(Segment::from_ident_and_id(
-                                Ident { name: kw::PathRoot, span: source.ident.span },
+                                Ident { name: sym::path_root, span: source.ident.span },
                                 self.r.next_node_id(),
                             ));
                             source.ident.name = crate_name;
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
@@ -493,7 +493,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
         // We're only interested in `use` paths which should start with
         // `{{root}}` currently.
-        if first_name != kw::PathRoot {
+        if first_name != sym::path_root {
             return;
         }
 
@@ -1077,7 +1077,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     }
                 }
                 Scope::CrateRoot => {
-                    let root_ident = Ident::new(kw::PathRoot, ident.span);
+                    let root_ident = Ident::new(sym::path_root, ident.span);
                     let root_module = this.resolve_crate_root(root_ident);
                     this.add_module_candidates(root_module, &mut suggestions, filter_fn, None);
                 }
@@ -2059,10 +2059,10 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             let parent = match parent {
                 // ::foo is mounted at the crate root for 2015, and is the extern
                 // prelude for 2018+
-                kw::PathRoot if self.tcx.sess.edition() > Edition::Edition2015 => {
+                sym::path_root if self.tcx.sess.edition() > Edition::Edition2015 => {
                     "the list of imported crates".to_owned()
                 }
-                kw::PathRoot | kw::Crate => "the crate root".to_owned(),
+                sym::path_root | kw::Crate => "the crate root".to_owned(),
                 _ => format!("`{parent}`"),
             };
 
@@ -2244,7 +2244,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             // `{{root}}::ident::...` on both editions.
             // On 2015 `{{root}}` is usually added implicitly.
             (Some(fst), Some(snd))
-                if fst.ident.name == kw::PathRoot && !snd.ident.is_path_segment_keyword() => {}
+                if fst.ident.name == sym::path_root && !snd.ident.is_path_segment_keyword() => {}
             // `ident::...` on 2018.
             (Some(fst), _)
                 if fst.ident.span.at_least_rust_2018() && !fst.ident.is_path_segment_keyword() =>
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
@@ -498,7 +498,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         _ => Err(Determinacy::Determined),
                     },
                     Scope::CrateRoot => {
-                        let root_ident = Ident::new(kw::PathRoot, ident.span);
+                        let root_ident = Ident::new(sym::path_root, ident.span);
                         let root_module = this.resolve_crate_root(root_ident);
                         let binding = this.resolve_ident_in_module(
                             ModuleOrUniformRoot::Module(root_module),
@@ -1485,19 +1485,19 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         module = Some(ModuleOrUniformRoot::Module(self_mod));
                         continue;
                     }
-                    if name == kw::PathRoot && ident.span.at_least_rust_2018() {
+                    if name == sym::path_root && ident.span.at_least_rust_2018() {
                         module = Some(ModuleOrUniformRoot::ExternPrelude);
                         continue;
                     }
-                    if name == kw::PathRoot
+                    if name == sym::path_root
                         && ident.span.is_rust_2015()
                         && self.tcx.sess.at_least_rust_2018()
                     {
                         // `::a::b` from 2015 macro on 2018 global edition
                         module = Some(ModuleOrUniformRoot::CrateRootAndExternPrelude);
                         continue;
                     }
-                    if name == kw::PathRoot || name == kw::Crate || name == kw::DollarCrate {
+                    if name == sym::path_root || name == kw::Crate || name == kw::DollarCrate {
                         // `::a::b`, `crate::a::b` or `$crate::a::b`
                         let crate_root = self.resolve_crate_root(ident);
                         if let Some(res) = crate_root.res() {
@@ -1512,12 +1512,12 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             // Report special messages for path segment keywords in wrong positions.
             if ident.is_path_segment_keyword() && segment_idx != 0 {
                 return PathResult::failed(ident, false, finalize.is_some(), module, || {
-                    let name_str = if name == kw::PathRoot {
+                    let name_str = if name == sym::path_root {
                         "crate root".to_string()
                     } else {
                         format!("`{name}`")
                     };
-                    let label = if segment_idx == 1 && path[0].ident.name == kw::PathRoot {
+                    let label = if segment_idx == 1 && path[0].ident.name == sym::path_root {
                         format!("global paths cannot start with {name_str}")
                     } else {
                         format!("{name_str} in paths can only be used in start position")
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
@@ -20,7 +20,7 @@ use rustc_session::lint::builtin::{
 use rustc_span::Span;
 use rustc_span::edit_distance::find_best_match_for_name;
 use rustc_span::hygiene::LocalExpnId;
-use rustc_span::symbol::{Ident, Symbol, kw};
+use rustc_span::symbol::{Ident, Symbol, kw, sym};
 use smallvec::SmallVec;
 use tracing::debug;
 
@@ -1484,8 +1484,8 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 }
 
 fn import_path_to_string(names: &[Ident], import_kind: &ImportKind<'_>, span: Span) -> String {
-    let pos = names.iter().position(|p| span == p.span && p.name != kw::PathRoot);
-    let global = !names.is_empty() && names[0].name == kw::PathRoot;
+    let pos = names.iter().position(|p| span == p.span && p.name != sym::path_root);
+    let global = !names.is_empty() && names[0].name == sym::path_root;
     if let Some(pos) = pos {
         let names = if global { &names[1..pos + 1] } else { &names[..pos + 1] };
         names_to_string(&names.iter().map(|ident| ident.name).collect::<Vec<_>>())
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
@@ -458,7 +458,7 @@ impl<'a> PathSource<'a> {
                     // the case of `::some_crate()`
                     ExprKind::Path(_, path)
                         if let [segment, _] = path.segments.as_slice()
-                            && segment.ident.name == kw::PathRoot =>
+                            && segment.ident.name == sym::path_root =>
                     {
                         "external crate"
                     }
@@ -4913,7 +4913,7 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
     fn lint_unused_qualifications(&mut self, path: &[Segment], ns: Namespace, finalize: Finalize) {
         // Don't lint on global paths because the user explicitly wrote out the full path.
         if let Some(seg) = path.first()
-            && seg.ident.name == kw::PathRoot
+            && seg.ident.name == sym::path_root
         {
             return;
         }
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -300,7 +300,7 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
                     None
                 };
                 (String::new(), "this scope".to_string(), None, suggestion)
-            } else if path.len() == 2 && path[0].ident.name == kw::PathRoot {
+            } else if path.len() == 2 && path[0].ident.name == sym::path_root {
                 if self.r.tcx.sess.edition() > Edition::Edition2015 {
                     // In edition 2018 onwards, the `::foo` syntax may only pull from the extern prelude
                     // which overrides all other expectations of item type
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
@@ -2123,7 +2123,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             Vec::from_iter(path_str.split("::").map(Ident::from_str).map(Segment::from_ident));
         if let Some(segment) = segments.first_mut() {
             if segment.ident.name == sym::empty {
-                segment.ident.name = kw::PathRoot;
+                segment.ident.name = sym::path_root;
             }
         }
 
@@ -2230,7 +2230,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
 
 fn names_to_string(names: &[Symbol]) -> String {
     let mut result = String::new();
-    for (i, name) in names.iter().filter(|name| **name != kw::PathRoot).enumerate() {
+    for (i, name) in names.iter().filter(|name| **name != sym::path_root).enumerate() {
         if i > 0 {
             result.push_str("::");
         }
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
@@ -117,7 +117,7 @@ fn fast_print_path(path: &ast::Path) -> Symbol {
             if i != 0 {
                 path_str.push_str("::");
             }
-            if segment.ident.name != kw::PathRoot {
+            if segment.ident.name != sym::path_root {
                 path_str.push_str(segment.ident.as_str())
             }
         }
diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
@@ -1076,7 +1076,7 @@ pub enum ExpnKind {
 impl ExpnKind {
     pub fn descr(&self) -> String {
         match *self {
-            ExpnKind::Root => kw::PathRoot.to_string(),
+            ExpnKind::Root => sym::path_root.to_string(),
             ExpnKind::Macro(macro_kind, name) => match macro_kind {
                 MacroKind::Bang => format!("{name}!"),
                 MacroKind::Attr => format!("#[{name}]"),
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
@@ -25,8 +25,7 @@ symbols! {
     // But this should rarely be necessary if the keywords are kept in alphabetic order.
     Keywords {
         // Special reserved identifiers used internally for elided lifetimes,
-        // unnamed method parameters, crate root module, error recovery etc.
-        PathRoot:           "{{root}}",
+        // unnamed method parameters, error recovery etc.
         DollarCrate:        "$crate",
         Underscore:         "_",
 
@@ -1465,6 +1464,7 @@ symbols! {
         patchable_function_entry,
         path,
         path_main_separator,
+        path_root: "{{root}}",
         path_to_pathbuf,
         pathbuf_as_path,
         pattern_complexity,
@@ -2622,7 +2622,7 @@ impl Symbol {
             || self == kw::SelfLower
             || self == kw::SelfUpper
             || self == kw::Crate
-            || self == kw::PathRoot
+            || self == sym::path_root
             || self == kw::DollarCrate
     }
 
@@ -2644,7 +2644,7 @@ impl Symbol {
 
 impl Ident {
     /// Returns `true` for reserved identifiers used internally for elided lifetimes,
-    /// unnamed method parameters, crate root module, error recovery etc.
+    /// unnamed method parameters, error recovery etc.
     pub fn is_special(self) -> bool {
         self.name.is_special()
     }
@@ -2694,7 +2694,7 @@ impl AllKeywords {
     /// *Note:* Please update this if a new keyword is added beyond the current
     /// range.
     pub fn new() -> Self {
-        AllKeywords { curr_idx: kw::PathRoot.as_u32(), end_idx: kw::Yeet.as_u32() }
+        AllKeywords { curr_idx: kw::DollarCrate.as_u32(), end_idx: kw::Yeet.as_u32() }
     }
 
     /// Collect all the keywords in a given edition into a vector.
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
@@ -1557,7 +1557,7 @@ fn first_non_private<'tcx>(
             (cx.tcx.local_parent(hir_id.owner.def_id), leaf.ident)
         }
         // Crate paths are not. We start from the crate root.
-        [parent, leaf] if matches!(parent.ident.name, kw::Crate | kw::PathRoot) => {
+        [parent, leaf] if matches!(parent.ident.name, kw::Crate | sym::path_root) => {
             (LOCAL_CRATE.as_def_id().as_local()?, leaf.ident)
         }
         [parent, leaf] if parent.ident.name == kw::Super => {
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
@@ -2186,7 +2186,7 @@ impl Path {
     pub(crate) fn whole_name(&self) -> String {
         self.segments
             .iter()
-            .map(|s| if s.name == kw::PathRoot { "" } else { s.name.as_str() })
+            .map(|s| if s.name == sym::path_root { "" } else { s.name.as_str() })
             .intersperse("::")
             .collect()
     }
diff --git a/src/librustdoc/clean/utils.rs b/src/librustdoc/clean/utils.rs
@@ -255,7 +255,7 @@ pub(crate) fn qpath_to_string(p: &hir::QPath<'_>) -> String {
         if i > 0 {
             s.push_str("::");
         }
-        if seg.ident.name != kw::PathRoot {
+        if seg.ident.name != sym::path_root {
             s.push_str(seg.ident.as_str());
         }
     }
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
diff --git a/src/tools/clippy/clippy_lints/src/absolute_paths.rs b/src/tools/clippy/clippy_lints/src/absolute_paths.rs
diff --git a/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs b/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
diff --git a/src/tools/clippy/clippy_utils/src/check_proc_macro.rs b/src/tools/clippy/clippy_utils/src/check_proc_macro.rs
diff --git a/src/tools/rustfmt/src/parse/macros/mod.rs b/src/tools/rustfmt/src/parse/macros/mod.rs
diff --git a/src/tools/rustfmt/src/types.rs b/src/tools/rustfmt/src/types.rs

Original file line number	Diff line number	Diff line change
`@@ -92,7 +92,7 @@ impl fmt::Display for Lifetime {`
`92`	`92`	`pub struct Path {`
`93`	`93`	`pub span: Span,`
`94`	`94`	/// The segments in the path: the things separated by `::`.
`95`		- /// Global paths begin with `kw::PathRoot`.
	`95`	+ /// Global paths begin with `sym::path_root`.
`96`	`96`	`pub segments: ThinVec<PathSegment>,`
`97`	`97`	`pub tokens: Option<LazyAttrTokenStream>,`
`98`	`98`	`}`
`@@ -121,7 +121,7 @@ impl Path {`
`121`	`121`	`}`
`122`	`122`
`123`	`123`	`pub fn is_global(&self) -> bool {`
`124`		`- !self.segments.is_empty() && self.segments[0].ident.name == kw::PathRoot`
	`124`	`+ !self.segments.is_empty() && self.segments[0].ident.name == sym::path_root`
`125`	`125`	`}`
`126`	`126`
`127`	`127`	`/// If this path is a single identifier with no arguments, does not ensure`
`@@ -156,7 +156,7 @@ impl PathSegment {`
`156`	`156`	`}`
`157`	`157`
`158`	`158`	`pub fn path_root(span: Span) -> Self {`
`159`		`- PathSegment::from_ident(Ident::new(kw::PathRoot, span))`
	`159`	`+ PathSegment::from_ident(Ident::new(sym::path_root, span))`
`160`	`160`	`}`
`161`	`161`
`162`	`162`	`pub fn span(&self) -> Span {`
Original file line number	Diff line number	Diff line change
`@@ -918,7 +918,7 @@ impl Token {`
`918`	`918`	`}`
`919`	`919`
`920`	`920`	`/// Returns true for reserved identifiers used internally for elided lifetimes,`
`921`		`- /// unnamed method parameters, crate root module, error recovery etc.`
	`921`	`+ /// unnamed method parameters, error recovery etc.`
`922`	`922`	`pub fn is_special_ident(&self) -> bool {`
`923`	`923`	`self.is_non_raw_ident_where(Ident::is_special)`
`924`	`924`	`}`
Original file line number	Diff line number	Diff line change
`@@ -564,7 +564,7 @@ impl<'hir> LoweringContext<'_, 'hir> {`
`564`	`564`	`let path = if trees.is_empty()`
`565`	`565`	`&& !(prefix.segments.is_empty()`
`566`	`566`	`\|\| prefix.segments.len() == 1`
`567`		`- && prefix.segments[0].ident.name == kw::PathRoot)`
	`567`	`+ && prefix.segments[0].ident.name == sym::path_root)`
`568`	`568`	`{`
`569`	`569`	`// For empty lists we need to lower the prefix so it is checked for things`
`570`	`570`	`// like stability later.`
Original file line number	Diff line number	Diff line change
`@@ -834,7 +834,7 @@ pub trait PrintState<'a>: std::ops::Deref<Target = pp::Printer> + std::ops::Dere`
`834`	`834`	`}`
`835`	`835`
`836`	`836`	`fn print_path_segment(&mut self, segment: &ast::PathSegment, colons_before_params: bool) {`
`837`		`- if segment.ident.name != kw::PathRoot {`
	`837`	`+ if segment.ident.name != sym::path_root {`
`838`	`838`	`self.print_ident(segment.ident);`
`839`	`839`	`if let Some(args) = &segment.args {`
`840`	`840`	`self.print_generic_args(args, colons_before_params);`
Original file line number	Diff line number	Diff line change
`@@ -20,7 +20,7 @@ use rustc_hir::{`
`20`	`20`	`};`
`21`	`21`	`use rustc_span::FileName;`
`22`	`22`	`use rustc_span::source_map::SourceMap;`
`23`		`-use rustc_span::symbol::{Ident, Symbol, kw};`
	`23`	`+use rustc_span::symbol::{Ident, Symbol, sym};`
`24`	`24`	`use {rustc_ast as ast, rustc_hir as hir};`
`25`	`25`
`26`	`26`	`pub fn id_to_string(map: &dyn rustc_hir::intravisit::Map<'_>, hir_id: HirId) -> String {`
`@@ -1563,15 +1563,15 @@ impl<'a> State<'a> {`
`1563`	`1563`	`if i > 0 {`
`1564`	`1564`	`self.word("::")`
`1565`	`1565`	`}`
`1566`		`- if segment.ident.name != kw::PathRoot {`
	`1566`	`+ if segment.ident.name != sym::path_root {`
`1567`	`1567`	`self.print_ident(segment.ident);`
`1568`	`1568`	`self.print_generic_args(segment.args(), colons_before_params);`
`1569`	`1569`	`}`
`1570`	`1570`	`}`
`1571`	`1571`	`}`
`1572`	`1572`
`1573`	`1573`	`fn print_path_segment(&mut self, segment: &hir::PathSegment<'_>) {`
`1574`		`- if segment.ident.name != kw::PathRoot {`
	`1574`	`+ if segment.ident.name != sym::path_root {`
`1575`	`1575`	`self.print_ident(segment.ident);`
`1576`	`1576`	`self.print_generic_args(segment.args(), false);`
`1577`	`1577`	`}`
`@@ -1590,7 +1590,7 @@ impl<'a> State<'a> {`
`1590`	`1590`	`if i > 0 {`
`1591`	`1591`	`self.word("::")`
`1592`	`1592`	`}`
`1593`		`- if segment.ident.name != kw::PathRoot {`
	`1593`	`+ if segment.ident.name != sym::path_root {`
`1594`	`1594`	`self.print_ident(segment.ident);`
`1595`	`1595`	`self.print_generic_args(segment.args(), colons_before_params);`
`1596`	`1596`	`}`