Rollup merge of #138682 - Alexendoo:extra-symbols, r=fee1-dead

Allow drivers to supply a list of extra symbols to intern Allows adding new symbols as `const`s in external drivers, desirable in Clippy so we can use them in patterns to replace code like https://github.com/rust-lang/rust/blob/75530e9f72a1990ed2305e16fd51d02f47048f12/src/tools/clippy/clippy_lints/src/casts/cast_ptr_alignment.rs#L66 The Clippy change adds a couple symbols as a demo, the exact `clippy_utils` API and replacing other usages can be done on the Clippy side to minimise sync conflicts --- try-job: aarch64-gnu

Author: Zalathar

compiler/rustc_driver_impl/src/lib.rs

@@ -264,6 +264,7 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
  hash_untracked_state: None,
  register_lints: None,
  override_queries: None,
+ extra_symbols: Vec::new(),
  make_codegen_backend: None,
  registry: diagnostics_registry(),
  using_internal_features: &USING_INTERNAL_FEATURES,

compiler/rustc_hir/src/tests.rs

@@ -17,7 +17,7 @@ fn def_path_hash_depends_on_crate_id() {
  // the crate by changing the crate disambiguator (e.g. via bumping the
  // crate's version number).
 
- create_session_globals_then(Edition::Edition2024, None, || {
+ create_session_globals_then(Edition::Edition2024, &[], None, || {
  let id0 = StableCrateId::new(Symbol::intern("foo"), false, vec!["1".to_string()], "");
  let id1 = StableCrateId::new(Symbol::intern("foo"), false, vec!["2".to_string()], "");
 

compiler/rustc_interface/src/interface.rs

@@ -348,6 +348,10 @@ pub struct Config {
  /// the list of queries.
  pub override_queries: Option<fn(&Session, &mut Providers)>,
 
+ /// An extra set of symbols to add to the symbol interner, the symbol indices
+ /// will start at [`PREDEFINED_SYMBOLS_COUNT`](rustc_span::symbol::PREDEFINED_SYMBOLS_COUNT)
+ pub extra_symbols: Vec<&'static str>,
+
  /// This is a callback from the driver that is called to create a codegen backend.
  ///
  /// Has no uses within this repository, but is used by bjorn3 for "the
@@ -409,6 +413,7 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
  &early_dcx,
  config.opts.edition,
  config.opts.unstable_opts.threads,
+ &config.extra_symbols,
  SourceMapInputs { file_loader, path_mapping, hash_kind, checksum_hash_kind },
  |current_gcx| {
  // The previous `early_dcx` can't be reused here because it doesn't

compiler/rustc_interface/src/tests.rs

@@ -53,7 +53,7 @@ where
  checksum_hash_kind,
  });
 
- rustc_span::create_session_globals_then(DEFAULT_EDITION, sm_inputs, || {
+ rustc_span::create_session_globals_then(DEFAULT_EDITION, &[], sm_inputs, || {
  let temps_dir = sessopts.unstable_opts.temps_dir.as_deref().map(PathBuf::from);
  let io = CompilerIO {
  input: Input::Str { name: FileName::Custom(String::new()), input: String::new() },

compiler/rustc_interface/src/util.rs

@@ -117,6 +117,7 @@ fn run_in_thread_with_globals<F: FnOnce(CurrentGcx) -> R + Send, R: Send>(
  thread_stack_size: usize,
  edition: Edition,
  sm_inputs: SourceMapInputs,
+ extra_symbols: &[&'static str],
  f: F,
 ) -> R {
  // The "thread pool" is a single spawned thread in the non-parallel
@@ -134,9 +135,12 @@ fn run_in_thread_with_globals<F: FnOnce(CurrentGcx) -> R + Send, R: Send>(
  // name contains null bytes.
  let r = builder
  .spawn_scoped(s, move || {
- rustc_span::create_session_globals_then(edition, Some(sm_inputs), || {
- f(CurrentGcx::new())
- })
+ rustc_span::create_session_globals_then(
+ edition,
+ extra_symbols,
+ Some(sm_inputs),
+ || f(CurrentGcx::new()),
+ )
  })
  .unwrap()
  .join();
@@ -152,6 +156,7 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce(CurrentGcx) -> R + Send,
  thread_builder_diag: &EarlyDiagCtxt,
  edition: Edition,
  threads: usize,
+ extra_symbols: &[&'static str],
  sm_inputs: SourceMapInputs,
  f: F,
 ) -> R {
@@ -168,12 +173,18 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce(CurrentGcx) -> R + Send,
  let registry = sync::Registry::new(std::num::NonZero::new(threads).unwrap());
 
  if !sync::is_dyn_thread_safe() {
- return run_in_thread_with_globals(thread_stack_size, edition, sm_inputs, |current_gcx| {
- // Register the thread for use with the `WorkerLocal` type.
- registry.register();
-
- f(current_gcx)
- });
+ return run_in_thread_with_globals(
+ thread_stack_size,
+ edition,
+ sm_inputs,
+ extra_symbols,
+ |current_gcx| {
+ // Register the thread for use with the `WorkerLocal` type.
+ registry.register();
+
+ f(current_gcx)
+ },
+ );
  }
 
  let current_gcx = FromDyn::from(CurrentGcx::new());
@@ -230,7 +241,7 @@ pub(crate) fn run_in_thread_pool_with_globals<F: FnOnce(CurrentGcx) -> R + Send,
  // pool. Upon creation, each worker thread created gets a copy of the
  // session globals in TLS. This is possible because `SessionGlobals` impls
  // `Send` in the parallel compiler.
- rustc_span::create_session_globals_then(edition, Some(sm_inputs), || {
+ rustc_span::create_session_globals_then(edition, extra_symbols, Some(sm_inputs), || {
  rustc_span::with_session_globals(|session_globals| {
  let session_globals = FromDyn::from(session_globals);
  builder

compiler/rustc_macros/src/symbols.rs

@@ -142,13 +142,13 @@ pub(super) fn symbols(input: TokenStream) -> TokenStream {
  output
 }
 
-struct Preinterned {
+struct Predefined {
  idx: u32,
  span_of_name: Span,
 }
 
 struct Entries {
- map: HashMap<String, Preinterned>,
+ map: HashMap<String, Predefined>,
 }
 
 impl Entries {
@@ -163,7 +163,7 @@ impl Entries {
  prev.idx
  } else {
  let idx = self.len();
- self.map.insert(s.to_string(), Preinterned { idx, span_of_name: span });
+ self.map.insert(s.to_string(), Predefined { idx, span_of_name: span });
  idx
  }
  }
@@ -295,10 +295,14 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec<syn::Error>) {
  }
 
  let symbol_digits_base = entries.map["0"].idx;
- let preinterned_symbols_count = entries.len();
+ let predefined_symbols_count = entries.len();
  let output = quote! {
  const SYMBOL_DIGITS_BASE: u32 = #symbol_digits_base;
- const PREINTERNED_SYMBOLS_COUNT: u32 = #preinterned_symbols_count;
+
+ /// The number of predefined symbols; this is the the first index for
+ /// extra pre-interned symbols in an Interner created via
+ /// [`Interner::with_extra_symbols`].
+ pub const PREDEFINED_SYMBOLS_COUNT: u32 = #predefined_symbols_count;
 
  #[doc(hidden)]
  #[allow(non_upper_case_globals)]
@@ -315,10 +319,13 @@ fn symbols_with_errors(input: TokenStream) -> (TokenStream, Vec<syn::Error>) {
  }
 
  impl Interner {
- pub(crate) fn fresh() -> Self {
- Interner::prefill(&[
- #prefill_stream
- ])
+ /// Creates an `Interner` with the predefined symbols from the `symbols!` macro and
+ /// any extra symbols provided by external drivers such as Clippy
+ pub(crate) fn with_extra_symbols(extra_symbols: &[&'static str]) -> Self {
+ Interner::prefill(
+ &[#prefill_stream],
+ extra_symbols,
+ )
  }
  }
  };

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -562,9 +562,9 @@ impl<'a, 'tcx> SpanDecoder for DecodeContext<'a, 'tcx> {
  Symbol::intern(s)
  })
  }
- SYMBOL_PREINTERNED => {
+ SYMBOL_PREDEFINED => {
  let symbol_index = self.read_u32();
- Symbol::new_from_decoded(symbol_index)
+ Symbol::new(symbol_index)
  }
  _ => unreachable!(),
  }

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -201,9 +201,9 @@ impl<'a, 'tcx> SpanEncoder for EncodeContext<'a, 'tcx> {
  }
 
  fn encode_symbol(&mut self, symbol: Symbol) {
- // if symbol preinterned, emit tag and symbol index
- if symbol.is_preinterned() {
- self.opaque.emit_u8(SYMBOL_PREINTERNED);
+ // if symbol predefined, emit tag and symbol index
+ if symbol.is_predefined() {
+ self.opaque.emit_u8(SYMBOL_PREDEFINED);
  self.opaque.emit_u32(symbol.as_u32());
  } else {
  // otherwise write it as string or as offset to it

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -586,7 +586,7 @@ impl SpanTag {
 // Tags for encoding Symbol's
 const SYMBOL_STR: u8 = 0;
 const SYMBOL_OFFSET: u8 = 1;
-const SYMBOL_PREINTERNED: u8 = 2;
+const SYMBOL_PREDEFINED: u8 = 2;
 
 pub fn provide(providers: &mut Providers) {
  encoder::provide(providers);

compiler/rustc_middle/src/query/on_disk_cache.rs

@@ -46,7 +46,7 @@ const TAG_EXPN_DATA: u8 = 1;
 // Tags for encoding Symbol's
 const SYMBOL_STR: u8 = 0;
 const SYMBOL_OFFSET: u8 = 1;
-const SYMBOL_PREINTERNED: u8 = 2;
+const SYMBOL_PREDEFINED: u8 = 2;
 
 /// Provides an interface to incremental compilation data cached from the
 /// previous compilation session. This data will eventually include the results
@@ -674,9 +674,9 @@ impl<'a, 'tcx> SpanDecoder for CacheDecoder<'a, 'tcx> {
  Symbol::intern(s)
  })
  }
- SYMBOL_PREINTERNED => {
+ SYMBOL_PREDEFINED => {
  let symbol_index = self.read_u32();
- Symbol::new_from_decoded(symbol_index)
+ Symbol::new(symbol_index)
  }
  _ => unreachable!(),
  }
@@ -892,9 +892,9 @@ impl<'a, 'tcx> SpanEncoder for CacheEncoder<'a, 'tcx> {
 
  // copy&paste impl from rustc_metadata
  fn encode_symbol(&mut self, symbol: Symbol) {
- // if symbol preinterned, emit tag and symbol index
- if symbol.is_preinterned() {
- self.encoder.emit_u8(SYMBOL_PREINTERNED);
+ // if symbol predefined, emit tag and symbol index
+ if symbol.is_predefined() {
+ self.encoder.emit_u8(SYMBOL_PREDEFINED);
  self.encoder.emit_u32(symbol.as_u32());
  } else {
  // otherwise write it as string or as offset to it