Replace Symbol::intern calls with preinterned symbols

Author: clubby789

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -4,9 +4,9 @@ use rustc_ast::{NodeId, PatKind, attr, token};
 use rustc_feature::{AttributeGate, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute, Features, GateIssue};
 use rustc_session::Session;
 use rustc_session::parse::{feature_err, feature_err_issue, feature_warn};
+use rustc_span::Span;
 use rustc_span::source_map::Spanned;
 use rustc_span::symbol::sym;
-use rustc_span::{Span, Symbol};
 use rustc_target::spec::abi;
 use thin_vec::ThinVec;
 
@@ -692,7 +692,7 @@ fn check_new_solver_banned_features(sess: &Session, features: &Features) {
     {
         sess.dcx().emit_err(errors::IncompatibleFeatures {
             spans: vec![gce_span],
-            f1: Symbol::intern("-Znext-solver=globally"),
+            f1: sym::dash_z_next_dash_solver_equals_globally,
             f2: sym::generic_const_exprs,
         });
     }

compiler/rustc_borrowck/src/universal_regions.rs

@@ -33,8 +33,8 @@ use rustc_middle::ty::{
     TyCtxt, TypeVisitableExt,
 };
 use rustc_middle::{bug, span_bug};
+use rustc_span::ErrorGuaranteed;
 use rustc_span::symbol::{kw, sym};
-use rustc_span::{ErrorGuaranteed, Symbol};
 use tracing::{debug, instrument};
 
 use crate::BorrowckInferCtxt;
@@ -524,7 +524,7 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
 
                 let reg_vid = self
                     .infcx
-                    .next_nll_region_var(FR, || RegionCtxt::Free(Symbol::intern("c-variadic")))
+                    .next_nll_region_var(FR, || RegionCtxt::Free(sym::c_dash_variadic))
                     .as_var();
 
                 let region = ty::Region::new_var(self.infcx.tcx, reg_vid);
@@ -540,10 +540,8 @@ impl<'cx, 'tcx> UniversalRegionsBuilder<'cx, 'tcx> {
             }
         }
 
-        let fr_fn_body = self
-            .infcx
-            .next_nll_region_var(FR, || RegionCtxt::Free(Symbol::intern("fn_body")))
-            .as_var();
+        let fr_fn_body =
+            self.infcx.next_nll_region_var(FR, || RegionCtxt::Free(sym::fn_body)).as_var();
 
         let num_universals = self.infcx.num_region_vars();
 

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -419,7 +419,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
     if let Node::ConstBlock(_) = node {
         own_params.push(ty::GenericParamDef {
             index: next_index(),
-            name: Symbol::intern("<const_ty>"),
+            name: rustc_span::sym::lt_const_underscore_ty_rt,
             def_id: def_id.to_def_id(),
             pure_wrt_drop: false,
             kind: ty::GenericParamDefKind::Type { has_default: false, synthetic: false },

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -664,7 +664,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let is_write = sugg_span.ctxt().outer_expn_data().macro_def_id.is_some_and(|def_id| {
             tcx.is_diagnostic_item(sym::write_macro, def_id)
                 || tcx.is_diagnostic_item(sym::writeln_macro, def_id)
-        }) && item_name.name == Symbol::intern("write_fmt");
+        }) && item_name.name == sym::write_fmt;
         let mut err = if is_write && let SelfSource::MethodCall(rcvr_expr) = source {
             self.suggest_missing_writer(rcvr_ty, rcvr_expr)
         } else {

compiler/rustc_lint/src/unused.rs

@@ -1563,7 +1563,7 @@ impl UnusedImportBraces {
                     }
                     rename.unwrap_or(orig_ident).name
                 }
-                ast::UseTreeKind::Glob => Symbol::intern("*"),
+                ast::UseTreeKind::Glob => sym::asterisk,
                 ast::UseTreeKind::Nested { .. } => return,
             };
 

compiler/rustc_metadata/src/creader.rs

@@ -862,7 +862,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
         // and see what's a global allocator, including if we ourselves are a
         // global allocator.
         let mut global_allocator =
-            self.cstore.has_global_allocator.then(|| Symbol::intern("this crate"));
+            self.cstore.has_global_allocator.then_some(sym::this_space_crate);
         for (_, data) in self.cstore.iter_crate_data() {
             if data.has_global_allocator() {
                 match global_allocator {
@@ -877,7 +877,7 @@ impl<'a, 'tcx> CrateLoader<'a, 'tcx> {
             }
         }
         let mut alloc_error_handler =
-            self.cstore.has_alloc_error_handler.then(|| Symbol::intern("this crate"));
+            self.cstore.has_alloc_error_handler.then_some(sym::this_space_crate);
         for (_, data) in self.cstore.iter_crate_data() {
             if data.has_alloc_error_handler() {
                 match alloc_error_handler {

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -875,11 +875,9 @@ impl MetadataBlob {
                         let def_name = if item == CRATE_DEF_INDEX {
                             rustc_span::symbol::kw::Crate
                         } else {
-                            def_key
-                                .disambiguated_data
-                                .data
-                                .get_opt_name()
-                                .unwrap_or_else(|| Symbol::intern("???"))
+                            def_key.disambiguated_data.data.get_opt_name().unwrap_or(
+                                rustc_span::sym::question_mark_question_mark_question_mark,
+                            )
                         };
                         let visibility =
                             root.tables.visibility.get(blob, item).unwrap().decode(blob).map_id(

compiler/rustc_parse/src/parser/ty.rs

@@ -9,7 +9,7 @@ use rustc_ast::{
 };
 use rustc_errors::{Applicability, PResult};
 use rustc_span::symbol::{Ident, kw, sym};
-use rustc_span::{ErrorGuaranteed, Span, Symbol};
+use rustc_span::{ErrorGuaranteed, Span};
 use thin_vec::{ThinVec, thin_vec};
 
 use super::{Parser, PathStyle, SeqSep, TokenType, Trailing};
@@ -1139,7 +1139,7 @@ impl<'a> Parser<'a> {
                 Some(ast::Path {
                     span: fn_token_span.to(self.prev_token.span),
                     segments: thin_vec![ast::PathSegment {
-                        ident: Ident::new(Symbol::intern("Fn"), fn_token_span),
+                        ident: Ident::new(sym::Fn, fn_token_span),
                         id: DUMMY_NODE_ID,
                         args: Some(P(ast::GenericArgs::Parenthesized(ast::ParenthesizedArgs {
                             span: args_lo.to(self.prev_token.span),

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -3114,9 +3114,9 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
         }
 
         let existing_name = match &in_scope_lifetimes[..] {
-            [] => Symbol::intern("'a"),
+            [] => sym::apostrophe_a,
             [(existing, _)] => existing.name,
-            _ => Symbol::intern("'lifetime"),
+            _ => sym::apostrophe_lifetime,
         };
 
         let mut spans_suggs: Vec<_> = Vec::new();

compiler/rustc_resolve/src/lib.rs

@@ -2270,7 +2270,7 @@ fn module_to_string(module: Module<'_>) -> Option<String> {
                 collect_mod(names, parent);
             }
         } else {
-            names.push(Symbol::intern("<opaque>"));
+            names.push(sym::lt_opaque_gt);
             collect_mod(names, module.parent.unwrap());
         }
     }

compiler/rustc_session/src/output.rs

@@ -87,7 +87,7 @@ pub fn find_crate_name(sess: &Session, attrs: &[ast::Attribute]) -> Symbol {
         }
     }
 
-    Symbol::intern("rust_out")
+    sym::rust_out
 }
 
 pub fn validate_crate_name(sess: &Session, s: Symbol, sp: Option<Span>) {

compiler/rustc_span/src/symbol.rs

@@ -297,6 +297,7 @@ symbols! {
         Return,
         Right,
         Rust,
+        RustaceansAreAwesome,
         RustcDecodable,
         RustcEncodable,
         RwLock,
@@ -401,6 +402,8 @@ symbols! {
         anon_adt,
         anonymous_lifetime_in_impl_trait,
         any,
+        apostrophe_a: "'a",
+        apostrophe_lifetime: "'lifetime",
         append_const_msg,
         arbitrary_enum_discriminant,
         arbitrary_self_types,
@@ -439,6 +442,7 @@ symbols! {
         associated_types,
         assume,
         assume_init,
+        asterisk: "*",
         async_await,
         async_call,
         async_call_mut,
@@ -519,6 +523,7 @@ symbols! {
         btreeset_iter,
         builtin_syntax,
         c,
+        c_dash_variadic,
         c_str,
         c_str_literals,
         c_unwind,
@@ -703,6 +708,7 @@ symbols! {
         custom_test_frameworks,
         d,
         d32,
+        dash_z_next_dash_solver_equals_globally: "-Znext-solver=globally",
         dbg_macro,
         dead_code,
         dealloc,
@@ -921,6 +927,7 @@ symbols! {
         fmuladdf32,
         fmuladdf64,
         fn_align,
+        fn_body,
         fn_delegation,
         fn_must_use,
         fn_mut,
@@ -1176,6 +1183,8 @@ symbols! {
         loongarch_target_feature,
         loop_break_value,
         lt,
+        lt_const_underscore_ty_rt: "<const_ty>",
+        lt_opaque_gt: "<opaque>",
         macro_at_most_once_rep,
         macro_attributes_in_derive_output,
         macro_escape,
@@ -1558,6 +1567,7 @@ symbols! {
         qreg_low8,
         quad_precision_float,
         question_mark,
+        question_mark_question_mark_question_mark: "???",
         quote,
         range_inclusive_new,
         raw_dylib,
@@ -1652,6 +1662,7 @@ symbols! {
         rust_eh_catch_typeinfo,
         rust_eh_personality,
         rust_logo,
+        rust_out,
         rustc,
         rustc_abi,
         rustc_allocator,
@@ -1966,6 +1977,7 @@ symbols! {
         test_removed_feature,
         test_runner,
         test_unstable_lint,
+        this_space_crate: "this crate",
         thread,
         thread_local,
         thread_local_macro,
@@ -2173,6 +2185,7 @@ symbols! {
         wrapping_sub,
         wreg,
         write_bytes,
+        write_fmt,
         write_macro,
         write_str,
         write_via_move,

compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs

@@ -18,7 +18,6 @@ use rustc_middle::ty::{
     TypeVisitableExt, TypeVisitor, TypingMode, Upcast,
 };
 use rustc_span::Span;
-use rustc_span::symbol::Symbol;
 use smallvec::SmallVec;
 use tracing::{debug, instrument};
 
@@ -679,7 +678,7 @@ fn receiver_is_dispatchable<'tcx>(
     // FIXME(mikeyhew) this is a total hack. Once dyn_compatible_for_dispatch is stabilized, we can
     // replace this with `dyn Trait`
     let unsized_self_ty: Ty<'tcx> =
-        Ty::new_param(tcx, u32::MAX, Symbol::intern("RustaceansAreAwesome"));
+        Ty::new_param(tcx, u32::MAX, rustc_span::sym::RustaceansAreAwesome);
 
     // `Receiver[Self => U]`
     let unsized_receiver_ty =