Add to_stringified_ident_guess to Symbol and suggest correct raw identifier in notes and help messages

Author: olegnn

src/librustc/infer/error_reporting/need_type_info.rs

@@ -9,8 +9,8 @@ use rustc_hir::def::{DefKind, Namespace};
 use rustc_hir::intravisit::{self, NestedVisitorMap, Visitor};
 use rustc_hir::{Body, Expr, ExprKind, FunctionRetTy, HirId, Local, Pat};
 use rustc_span::source_map::DesugaringKind;
-use rustc_span::symbol::kw;
 use rustc_span::Span;
+use rustc_span::{symbol::kw, Symbol};
 use std::borrow::Cow;
 
 struct FindLocalByTypeVisitor<'a, 'tcx> {
@@ -108,7 +108,7 @@ fn closure_return_type_suggestion(
     output: &FunctionRetTy<'_>,
     body: &Body<'_>,
     descr: &str,
-    name: &str,
+    name: Symbol,
     ret: &str,
     parent_name: Option<String>,
     parent_descr: Option<&str>,
@@ -129,7 +129,7 @@ fn closure_return_type_suggestion(
         suggestion,
         Applicability::HasPlaceholders,
     );
-    err.span_label(span, InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr));
+    err.span_label(span, InferCtxt::missing_type_msg(name, &descr, parent_name, parent_descr));
 }
 
 /// Given a closure signature, return a `String` containing a list of all its argument types.
@@ -320,7 +320,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                             &decl.output,
                             &body,
                             &descr,
-                            &name,
+                            Symbol::intern(&name),
                             &ret,
                             parent_name,
                             parent_descr,
@@ -444,7 +444,12 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             // Avoid multiple labels pointing at `span`.
             err.span_label(
                 span,
-                InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr),
+                InferCtxt::missing_type_msg(
+                    Symbol::intern(&name),
+                    &descr,
+                    parent_name,
+                    parent_descr,
+                ),
             );
         }
 
@@ -518,17 +523,20 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             "type inside {} must be known in this context",
             kind,
         );
-        err.span_label(span, InferCtxt::missing_type_msg(&name, &descr, parent_name, parent_descr));
+        err.span_label(
+            span,
+            InferCtxt::missing_type_msg(Symbol::intern(&name), &descr, parent_name, parent_descr),
+        );
         err
     }
 
     fn missing_type_msg(
-        type_name: &str,
+        type_name: Symbol,
         descr: &str,
         parent_name: Option<String>,
         parent_descr: Option<&str>,
     ) -> Cow<'static, str> {
-        if type_name == "_" {
+        if type_name == kw::Underscore {
             "cannot infer type".into()
         } else {
             let parent_desc = if let Some(parent_name) = parent_name {

src/librustc/infer/error_reporting/note.rs

@@ -36,7 +36,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
             }
             infer::ReborrowUpvar(span, ref upvar_id) => {
                 let var_name = self.tcx.hir().name(upvar_id.var_path.hir_id);
-                err.span_note(span, &format!("...so that closure can access `{}`", var_name));
+                err.span_note(
+                    span,
+                    &format!(
+                        "...so that closure can access `{}`",
+                        var_name.to_stringified_ident_guess()
+                    ),
+                );
             }
             infer::InfStackClosure(span) => {
                 err.span_note(span, "...so that closure does not outlive its stack frame");
@@ -53,7 +59,7 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                     &format!(
                         "...so that captured variable `{}` does not outlive the \
                                         enclosing closure",
-                        self.tcx.hir().name(id)
+                        self.tcx.hir().name(id).to_stringified_ident_guess()
                     ),
                 );
             }

src/librustc/middle/stability.rs

@@ -161,7 +161,7 @@ pub fn deprecation_suggestion(
         diag.span_suggestion(
             span,
             "replace the use of the deprecated item",
-            suggestion.to_string(),
+            suggestion.to_stringified_ident_guess(),
             Applicability::MachineApplicable,
         );
     }

src/librustc/traits/error_reporting/suggestions.rs

@@ -17,7 +17,7 @@ use rustc_hir::def_id::DefId;
 use rustc_hir::intravisit::Visitor;
 use rustc_hir::Node;
 use rustc_span::source_map::SourceMap;
-use rustc_span::symbol::{kw, sym};
+use rustc_span::symbol::{kw, sym, Symbol};
 use rustc_span::{MultiSpan, Span, DUMMY_SP};
 use std::fmt;
 
@@ -143,12 +143,13 @@ impl<'a, 'tcx> InferCtxt<'a, 'tcx> {
                 {
                     // Missing generic type parameter bound.
                     let param_name = self_ty.to_string();
+                    let param = Symbol::intern(&param_name);
                     let constraint = trait_ref.print_only_trait_path().to_string();
                     if suggest_constraining_type_param(
                         self.tcx,
                         generics,
                         &mut err,
-                        &param_name,
+                        param,
                         &constraint,
                         self.tcx.sess.source_map(),
                         *span,
@@ -1657,30 +1658,30 @@ pub fn suggest_constraining_type_param(
     tcx: TyCtxt<'_>,
     generics: &hir::Generics<'_>,
     err: &mut DiagnosticBuilder<'_>,
-    param_name: &str,
+    param_name: Symbol,
     constraint: &str,
     source_map: &SourceMap,
     span: Span,
     def_id: Option<DefId>,
 ) -> bool {
     let restrict_msg = "consider further restricting this bound";
     if let Some(param) =
-        generics.params.iter().filter(|p| p.name.ident().as_str() == param_name).next()
+        generics.params.iter().filter(|p| p.name.ident().as_str() == param_name.as_str()).next()
     {
         if def_id == tcx.lang_items().sized_trait() {
             // Type parameters are already `Sized` by default.
             err.span_label(
                 param.span,
                 &format!("this type parameter needs to be `{}`", constraint),
             );
-        } else if param_name.starts_with("impl ") {
+        } else if param_name.as_str().starts_with("impl ") {
             // `impl Trait` in argument:
             // `fn foo(x: impl Trait) {}` → `fn foo(t: impl Trait + Trait2) {}`
             err.span_suggestion(
                 param.span,
                 restrict_msg,
                 // `impl CurrentTrait + MissingTrait`
-                format!("{} + {}", param_name, constraint),
+                format!("{} + {}", param_name.to_stringified_ident_guess(), constraint),
                 Applicability::MachineApplicable,
             );
         } else if generics.where_clause.predicates.is_empty() && param.bounds.is_empty() {
@@ -1690,7 +1691,7 @@ pub fn suggest_constraining_type_param(
             err.span_suggestion(
                 param.span,
                 "consider restricting this bound",
-                format!("{}: {}", param_name, constraint),
+                format!("{}: {}", param_name.to_stringified_ident_guess(), constraint),
                 Applicability::MachineApplicable,
             );
         } else if !generics.where_clause.predicates.is_empty() {
@@ -1699,8 +1700,11 @@ pub fn suggest_constraining_type_param(
             // `fn foo<T>(t: T) where T: Debug, T: Trait {}`
             err.span_suggestion(
                 generics.where_clause.span().unwrap().shrink_to_hi(),
-                &format!("consider further restricting type parameter `{}`", param_name),
-                format!(", {}: {}", param_name, constraint),
+                &format!(
+                    "consider further restricting type parameter `{}`",
+                    param_name.to_stringified_ident_guess()
+                ),
+                format!(", {}: {}", param_name.to_stringified_ident_guess(), constraint),
                 Applicability::MachineApplicable,
             );
         } else {
@@ -1716,13 +1720,17 @@ pub fn suggest_constraining_type_param(
                 err.span_suggestion(
                     span,
                     restrict_msg,
-                    format!("{}: {} + ", param_name, constraint),
+                    format!("{}: {} + ", param_name.to_stringified_ident_guess(), constraint),
                     Applicability::MachineApplicable,
                 );
             } else {
                 err.span_label(
                     param.span,
-                    &format!("consider adding a `where {}: {}` bound", param_name, constraint),
+                    &format!(
+                        "consider adding a `where {}: {}` bound",
+                        param_name.to_stringified_ident_guess(),
+                        constraint
+                    ),
                 );
             }
         }

src/librustc_lint/nonstandard_style.rs

@@ -107,7 +107,8 @@ impl NonCamelCaseTypes {
         let name = &ident.name.as_str();
 
         if !is_camel_case(name) {
-            let msg = format!("{} `{}` should have an upper camel case name", sort, name);
+            let msg =
+                format!("{} `{}` should have an upper camel case name", sort, name.to_string());
             cx.struct_span_lint(NON_CAMEL_CASE_TYPES, ident.span, &msg)
                 .span_suggestion(
                     ident.span,

src/librustc_mir/borrow_check/diagnostics/conflict_errors.rs

@@ -220,7 +220,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                             tcx,
                             generics,
                             &mut err,
-                            &param.name.as_str(),
+                            param.name,
                             "Copy",
                             tcx.sess.source_map(),
                             span,

src/librustc_mir/borrow_check/diagnostics/mod.rs

@@ -107,7 +107,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                             &format!(
                                 "closure cannot be invoked more than once because it moves the \
                                  variable `{}` out of its environment",
-                                name,
+                                name.to_stringified_ident_guess(),
                             ),
                         );
                         return;
@@ -129,7 +129,7 @@ impl<'cx, 'tcx> MirBorrowckCtxt<'cx, 'tcx> {
                         &format!(
                             "closure cannot be moved more than once as it is not `Copy` due to \
                              moving the variable `{}` out of its environment",
-                            name
+                            name.to_stringified_ident_guess()
                         ),
                     );
                 }

src/librustc_parse/parser/module.rs

@@ -6,7 +6,7 @@ use crate::{new_sub_parser_from_file, DirectoryOwnership};
 
 use rustc_errors::PResult;
 use rustc_span::source_map::{FileName, SourceMap, Span, DUMMY_SP};
-use rustc_span::symbol::sym;
+use rustc_span::symbol::{sym, Symbol};
 use syntax::ast::{self, Attribute, Crate, Ident, ItemKind, Mod};
 use syntax::attr;
 use syntax::token::{self, TokenKind};
@@ -170,7 +170,7 @@ impl<'a> Parser<'a> {
                         &format!(
                             "... or maybe `use` the module `{}` instead \
                                             of possibly redeclaring it",
-                            paths.name
+                            Symbol::intern(&paths.name).to_stringified_ident_guess()
                         ),
                     );
                 }