Use Symbol instead of strings.

Author: cjgillot

compiler/rustc_mir_transform/src/errors.rs

@@ -121,20 +121,20 @@ pub(crate) struct FnItemRef {
 #[diag(mir_transform_unused_capture_maybe_capture_ref)]
 #[help]
 pub(crate) struct UnusedCaptureMaybeCaptureRef {
-    pub name: String,
+    pub name: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(mir_transform_unused_var_assigned_only)]
 #[note]
 pub(crate) struct UnusedVarAssignedOnly {
-    pub name: String,
+    pub name: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(mir_transform_unused_assign)]
 pub(crate) struct UnusedAssign {
-    pub name: String,
+    pub name: Symbol,
     #[subdiagnostic]
     pub suggestion: Option<UnusedAssignSuggestion>,
     #[help]
@@ -159,13 +159,13 @@ pub(crate) struct UnusedAssignSuggestion {
 #[diag(mir_transform_unused_assign_passed)]
 #[help]
 pub(crate) struct UnusedAssignPassed {
-    pub name: String,
+    pub name: Symbol,
 }
 
 #[derive(LintDiagnostic)]
 #[diag(mir_transform_unused_variable)]
 pub(crate) struct UnusedVariable {
-    pub name: String,
+    pub name: Symbol,
     #[subdiagnostic]
     pub string_interp: Vec<UnusedVariableStringInterp>,
     #[subdiagnostic]
@@ -183,7 +183,7 @@ pub(crate) enum UnusedVariableSugg {
         shorthands: Vec<Span>,
         #[suggestion_part(code = "_")]
         non_shorthands: Vec<Span>,
-        name: String,
+        name: Symbol,
     },
 
     #[multipart_suggestion(
@@ -193,14 +193,14 @@ pub(crate) enum UnusedVariableSugg {
     TryPrefix {
         #[suggestion_part(code = "_{name}")]
         spans: Vec<Span>,
-        name: String,
+        name: Symbol,
     },
 
     #[help(mir_transform_unused_variable_args_in_macro)]
     NoSugg {
         #[primary_span]
         span: Span,
-        name: String,
+        name: Symbol,
     },
 }
 

compiler/rustc_mir_transform/src/liveness.rs

@@ -16,6 +16,7 @@ use rustc_mir_dataflow::fmt::DebugWithContext;
 use rustc_mir_dataflow::{Analysis, Backward, ResultsCursor};
 use rustc_session::lint;
 use rustc_span::Span;
+use rustc_span::symbol::{Symbol, kw};
 
 use crate::errors;
 
@@ -162,7 +163,7 @@ fn is_capture(place: PlaceRef<'_>) -> bool {
 /// interpolate our dead local.
 fn maybe_suggest_literal_matching_name(
     body: &Body<'_>,
-    name: &str,
+    name: Symbol,
 ) -> Vec<errors::UnusedVariableStringInterp> {
     struct LiteralFinder<'body, 'tcx> {
         body: &'body Body<'tcx>,
@@ -426,7 +427,7 @@ fn find_self_assignments<'tcx>(
 #[derive(Default, Debug)]
 struct PlaceSet<'tcx> {
     places: IndexVec<PlaceIndex, PlaceRef<'tcx>>,
-    names: IndexVec<PlaceIndex, Option<(String, Span)>>,
+    names: IndexVec<PlaceIndex, Option<(Symbol, Span)>>,
 
     /// Places corresponding to locals, common case.
     locals: IndexVec<Local, Option<PlaceIndex>>,
@@ -488,7 +489,10 @@ impl<'tcx> PlaceSet<'tcx> {
 
             // Record a variable name from the capture, because it is much friendlier than the
             // debuginfo name.
-            self.names.insert(index, (capture.to_string(tcx), capture.get_path_span(tcx)));
+            self.names.insert(
+                index,
+                (Symbol::intern(&capture.to_string(tcx)), capture.get_path_span(tcx)),
+            );
         }
     }
 
@@ -498,7 +502,7 @@ impl<'tcx> PlaceSet<'tcx> {
                 && let Some(index) = self.locals[place.local]
             {
                 self.names.get_or_insert_with(index, || {
-                    (var_debug_info.name.to_string(), var_debug_info.source_info.span)
+                    (var_debug_info.name, var_debug_info.source_info.span)
                 });
             }
         }
@@ -790,8 +794,8 @@ impl AssignmentResult {
                 continue;
             }
 
-            let Some((ref name, def_span)) = checked_places.names[index] else { continue };
-            if name.is_empty() || name.starts_with('_') || name == "self" {
+            let Some((name, def_span)) = checked_places.names[index] else { continue };
+            if name.is_empty() || name.as_str().starts_with('_') || name == kw::SelfLower {
                 continue;
             }
 
@@ -818,19 +822,16 @@ impl AssignmentResult {
             let statements = &mut self.assignments[index];
             if statements.is_empty() {
                 let sugg = if from_macro {
-                    errors::UnusedVariableSugg::NoSugg { span: def_span, name: name.clone() }
+                    errors::UnusedVariableSugg::NoSugg { span: def_span, name }
                 } else {
-                    errors::UnusedVariableSugg::TryPrefix {
-                        spans: vec![def_span],
-                        name: name.clone(),
-                    }
+                    errors::UnusedVariableSugg::TryPrefix { spans: vec![def_span], name }
                 };
                 tcx.emit_node_span_lint(
                     lint::builtin::UNUSED_VARIABLES,
                     hir_id,
                     def_span,
                     errors::UnusedVariable {
-                        name: name.clone(),
+                        name,
                         string_interp: maybe_suggest_literal_matching_name(body, name),
                         sugg,
                     },
@@ -868,7 +869,7 @@ impl AssignmentResult {
                     lint::builtin::UNUSED_VARIABLES,
                     hir_id,
                     def_span,
-                    errors::UnusedVarAssignedOnly { name: name.clone() },
+                    errors::UnusedVarAssignedOnly { name },
                 );
                 continue;
             }
@@ -880,7 +881,7 @@ impl AssignmentResult {
 
             let sugg = if any_shorthand {
                 errors::UnusedVariableSugg::TryIgnore {
-                    name: name.clone(),
+                    name,
                     shorthands: introductions
                         .iter()
                         .filter_map(
@@ -897,19 +898,19 @@ impl AssignmentResult {
                         .collect(),
                 }
             } else if from_macro {
-                errors::UnusedVariableSugg::NoSugg { span: def_span, name: name.clone() }
+                errors::UnusedVariableSugg::NoSugg { span: def_span, name }
             } else if !introductions.is_empty() {
-                errors::UnusedVariableSugg::TryPrefix { name: name.clone(), spans: spans.clone() }
+                errors::UnusedVariableSugg::TryPrefix { name, spans: spans.clone() }
             } else {
-                errors::UnusedVariableSugg::TryPrefix { name: name.clone(), spans: vec![def_span] }
+                errors::UnusedVariableSugg::TryPrefix { name, spans: vec![def_span] }
             };
 
             tcx.emit_node_span_lint(
                 lint::builtin::UNUSED_VARIABLES,
                 hir_id,
                 spans,
                 errors::UnusedVariable {
-                    name: name.clone(),
+                    name,
                     string_interp: maybe_suggest_literal_matching_name(body, name),
                     sugg,
                 },
@@ -931,8 +932,8 @@ impl AssignmentResult {
                 continue;
             }
 
-            let Some((ref name, decl_span)) = checked_places.names[index] else { continue };
-            if name.is_empty() || name.starts_with('_') || name == "self" {
+            let Some((name, decl_span)) = checked_places.names[index] else { continue };
+            if name.is_empty() || name.as_str().starts_with('_') || name == kw::SelfLower {
                 continue;
             }
 
@@ -967,24 +968,20 @@ impl AssignmentResult {
                             lint::builtin::UNUSED_ASSIGNMENTS,
                             hir_id,
                             source_info.span,
-                            errors::UnusedAssign {
-                                name: name.clone(),
-                                help: suggestion.is_none(),
-                                suggestion,
-                            },
+                            errors::UnusedAssign { name, help: suggestion.is_none(), suggestion },
                         )
                     }
                     AccessKind::Param => tcx.emit_node_span_lint(
                         lint::builtin::UNUSED_ASSIGNMENTS,
                         hir_id,
                         source_info.span,
-                        errors::UnusedAssignPassed { name: name.clone() },
+                        errors::UnusedAssignPassed { name },
                     ),
                     AccessKind::Capture => tcx.emit_node_span_lint(
                         lint::builtin::UNUSED_ASSIGNMENTS,
                         hir_id,
                         decl_span,
-                        errors::UnusedCaptureMaybeCaptureRef { name: name.clone() },
+                        errors::UnusedCaptureMaybeCaptureRef { name },
                     ),
                 }
             }