Hard code the error code registry for custom drivers

compiler/rustc_codegen_ssa/src/back/write.rs

@@ -1981,11 +1981,7 @@ impl SharedEmitter {
 }
 
 impl Emitter for SharedEmitter {
-    fn emit_diagnostic(
-        &mut self,
-        mut diag: rustc_errors::DiagInner,
-        _registry: &rustc_errors::registry::Registry,
-    ) {
+    fn emit_diagnostic(&mut self, mut diag: rustc_errors::DiagInner) {
         // Check that we aren't missing anything interesting when converting to
         // the cut-down local `DiagInner`.
         assert!(!diag.span.has_span_labels());

compiler/rustc_driver_impl/src/lib.rs

@@ -34,7 +34,6 @@ use rustc_data_structures::profiling::{
 };
 pub use rustc_errors::catch_fatal_errors;
 use rustc_errors::emitter::stderr_destination;
-use rustc_errors::registry::Registry;
 use rustc_errors::translation::Translator;
 use rustc_errors::{ColorConfig, DiagCtxt, ErrCode, PResult, markdown};
 use rustc_feature::find_gated_cfg;
@@ -197,10 +196,6 @@ impl Callbacks for TimePassesCallbacks {
     }
 }
 
-pub fn diagnostics_registry() -> Registry {
-    Registry::new(rustc_errors::codes::DIAGNOSTICS)
-}
-
 /// This is the primary entry point for rustc.
 pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send)) {
     let mut default_early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default());
@@ -228,7 +223,7 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
     let ice_file = ice_path_with_config(Some(&sopts.unstable_opts)).clone();
 
     if let Some(ref code) = matches.opt_str("explain") {
-        handle_explain(&default_early_dcx, diagnostics_registry(), code, sopts.color);
+        handle_explain(&default_early_dcx, code, sopts.color);
         return;
     }
 
@@ -255,7 +250,6 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
         override_queries: None,
         extra_symbols: Vec::new(),
         make_codegen_backend: None,
-        registry: diagnostics_registry(),
         using_internal_features: &USING_INTERNAL_FEATURES,
     };
 
@@ -455,12 +449,12 @@ pub enum Compilation {
     Continue,
 }
 
-fn handle_explain(early_dcx: &EarlyDiagCtxt, registry: Registry, code: &str, color: ColorConfig) {
+fn handle_explain(early_dcx: &EarlyDiagCtxt, code: &str, color: ColorConfig) {
     // Allow "E0123" or "0123" form.
     let upper_cased_code = code.to_ascii_uppercase();
     if let Ok(code) = upper_cased_code.trim_prefix('E').parse::<u32>()
         && code <= ErrCode::MAX_AS_U32
-        && let Ok(description) = registry.try_find_description(ErrCode::from_u32(code))
+        && let Ok(description) = rustc_errors::codes::try_find_description(ErrCode::from_u32(code))
     {
         let mut is_in_code_block = false;
         let mut text = String::new();

compiler/rustc_errors/src/annotate_snippet_emitter_writer.rs

@@ -27,7 +27,6 @@ use crate::emitter::{
     ConfusionType, Destination, MAX_SUGGESTIONS, OutputTheme, detect_confusion_type, is_different,
     normalize_whitespace, should_show_source_code,
 };
-use crate::registry::Registry;
 use crate::translation::{Translator, to_fluent_args};
 use crate::{
     CodeSuggestion, DiagInner, DiagMessage, Emitter, ErrCode, Level, MultiSpan, Style, Subdiag,
@@ -73,7 +72,7 @@ impl Debug for AnnotateSnippetEmitter {
 
 impl Emitter for AnnotateSnippetEmitter {
     /// The entry point for the diagnostics generation
-    fn emit_diagnostic(&mut self, mut diag: DiagInner, _registry: &Registry) {
+    fn emit_diagnostic(&mut self, mut diag: DiagInner) {
         let fluent_args = to_fluent_args(diag.args.iter());
 
         if self.track_diagnostics && diag.span.has_primary_spans() && !diag.span.is_dummy() {

compiler/rustc_errors/src/codes.rs

@@ -5,6 +5,9 @@
 //!   long description text.
 
 use std::fmt;
+use std::sync::LazyLock;
+
+use rustc_data_structures::fx::FxHashMap;
 
 rustc_index::newtype_index! {
     #[max = 9999] // Because all error codes have four digits.
@@ -27,15 +30,28 @@ macro_rules! define_error_code_constants_and_diagnostics_table {
         $(
             pub const ${concat(E, $num)}: $crate::ErrCode = $crate::ErrCode::from_u32($num);
         )*
-        pub static DIAGNOSTICS: &[($crate::ErrCode, &str)] = &[
-            $( (
-                ${concat(E, $num)},
-                include_str!(
-                    concat!("../../rustc_error_codes/src/error_codes/E", stringify!($num), ".md")
-                )
-            ), )*
-        ];
+        static DIAGNOSTICS: LazyLock<FxHashMap<ErrCode, &'static str>> = LazyLock::new(|| {
+            [
+                $( (
+                    ${concat(E, $num)},
+                    include_str!(
+                        concat!("../../rustc_error_codes/src/error_codes/E", stringify!($num), ".md")
+                    )
+                ), )*
+            ]
+            .iter()
+            .copied()
+            .collect()
+        });
     )
 }
 
 rustc_error_codes::error_codes!(define_error_code_constants_and_diagnostics_table);
+
+#[derive(Debug)]
+pub struct InvalidErrorCode;
+
+/// Returns `InvalidErrorCode` if the code requested does not exist.
+pub fn try_find_description(code: ErrCode) -> Result<&'static str, InvalidErrorCode> {
+    DIAGNOSTICS.get(&code).copied().ok_or(InvalidErrorCode)
+}

compiler/rustc_errors/src/emitter.rs

@@ -24,7 +24,6 @@ use rustc_span::source_map::SourceMap;
 use rustc_span::{FileName, SourceFile, Span};
 use tracing::{debug, warn};
 
-use crate::registry::Registry;
 use crate::timings::TimingRecord;
 use crate::translation::Translator;
 use crate::{
@@ -54,7 +53,7 @@ pub type DynEmitter = dyn Emitter + DynSend;
 /// Emitter trait for emitting errors and other structured information.
 pub trait Emitter {
     /// Emit a structured diagnostic.
-    fn emit_diagnostic(&mut self, diag: DiagInner, registry: &Registry);
+    fn emit_diagnostic(&mut self, diag: DiagInner);
 
     /// Emit a notification that an artifact has been output.
     /// Currently only supported for the JSON format.
@@ -66,7 +65,7 @@ pub trait Emitter {
 
     /// Emit a report about future breakage.
     /// Currently only supported for the JSON format.
-    fn emit_future_breakage_report(&mut self, _diags: Vec<DiagInner>, _registry: &Registry) {}
+    fn emit_future_breakage_report(&mut self, _diags: Vec<DiagInner>) {}
 
     /// Emit list of unused externs.
     /// Currently only supported for the JSON format.
@@ -380,9 +379,9 @@ impl Emitter for EmitterWithNote {
         None
     }
 
-    fn emit_diagnostic(&mut self, mut diag: DiagInner, registry: &Registry) {
+    fn emit_diagnostic(&mut self, mut diag: DiagInner) {
         diag.sub(Level::Note, self.note.clone(), MultiSpan::new());
-        self.emitter.emit_diagnostic(diag, registry);
+        self.emitter.emit_diagnostic(diag);
     }
 
     fn translator(&self) -> &Translator {
@@ -399,7 +398,7 @@ impl Emitter for SilentEmitter {
         None
     }
 
-    fn emit_diagnostic(&mut self, _diag: DiagInner, _registry: &Registry) {}
+    fn emit_diagnostic(&mut self, _diag: DiagInner) {}
 
     fn translator(&self) -> &Translator {
         &self.translator

compiler/rustc_errors/src/json.rs

@@ -31,7 +31,6 @@ use crate::emitter::{
     ColorConfig, Destination, Emitter, HumanReadableErrorType, OutputTheme, TimingEvent,
     should_show_source_code,
 };
-use crate::registry::Registry;
 use crate::timings::{TimingRecord, TimingSection};
 use crate::translation::{Translator, to_fluent_args};
 use crate::{CodeSuggestion, MultiSpan, SpanLabel, Subdiag, Suggestions, TerminalUrl};
@@ -107,8 +106,8 @@ enum EmitTyped<'a> {
 }
 
 impl Emitter for JsonEmitter {
-    fn emit_diagnostic(&mut self, diag: crate::DiagInner, registry: &Registry) {
-        let data = Diagnostic::from_errors_diagnostic(diag, self, registry);
+    fn emit_diagnostic(&mut self, diag: crate::DiagInner) {
+        let data = Diagnostic::from_errors_diagnostic(diag, self);
         let result = self.emit(EmitTyped::Diagnostic(data));
         if let Err(e) = result {
             panic!("failed to print diagnostics: {e:?}");
@@ -139,7 +138,7 @@ impl Emitter for JsonEmitter {
         }
     }
 
-    fn emit_future_breakage_report(&mut self, diags: Vec<crate::DiagInner>, registry: &Registry) {
+    fn emit_future_breakage_report(&mut self, diags: Vec<crate::DiagInner>) {
         let data: Vec<FutureBreakageItem<'_>> = diags
             .into_iter()
             .map(|mut diag| {
@@ -153,7 +152,7 @@ impl Emitter for JsonEmitter {
                 }
                 FutureBreakageItem {
                     diagnostic: EmitTyped::Diagnostic(Diagnostic::from_errors_diagnostic(
-                        diag, self, registry,
+                        diag, self,
                     )),
                 }
             })
@@ -307,11 +306,7 @@ struct UnusedExterns<'a> {
 
 impl Diagnostic {
     /// Converts from `rustc_errors::DiagInner` to `Diagnostic`.
-    fn from_errors_diagnostic(
-        diag: crate::DiagInner,
-        je: &JsonEmitter,
-        registry: &Registry,
-    ) -> Diagnostic {
+    fn from_errors_diagnostic(diag: crate::DiagInner, je: &JsonEmitter) -> Diagnostic {
         let args = to_fluent_args(diag.args.iter());
         let sugg_to_diag = |sugg: &CodeSuggestion| {
             let translated_message =
@@ -351,7 +346,7 @@ impl Diagnostic {
         let code = if let Some(code) = diag.code {
             Some(DiagnosticCode {
                 code: code.to_string(),
-                explanation: registry.try_find_description(code).ok(),
+                explanation: crate::codes::try_find_description(code).ok(),
             })
         } else if let Some(IsLint { name, .. }) = &diag.is_lint {
             Some(DiagnosticCode { code: name.to_string(), explanation: None })
@@ -388,7 +383,7 @@ impl Diagnostic {
             .ui_testing(je.ui_testing)
             .ignored_directories_in_source_blocks(je.ignored_directories_in_source_blocks.clone())
             .theme(if je.json_rendered.unicode { OutputTheme::Unicode } else { OutputTheme::Ascii })
-            .emit_diagnostic(diag, registry);
+            .emit_diagnostic(diag);
 
         let buf = Arc::try_unwrap(buf.0).unwrap().into_inner().unwrap();
         let buf = String::from_utf8(buf).unwrap();

compiler/rustc_errors/src/lib.rs

@@ -71,7 +71,6 @@ use rustc_span::{DUMMY_SP, Span};
 use tracing::debug;
 
 use crate::emitter::TimingEvent;
-use crate::registry::Registry;
 use crate::timings::TimingRecord;
 
 pub mod annotate_snippet_emitter_writer;
@@ -84,7 +83,6 @@ pub mod error;
 pub mod json;
 mod lock;
 pub mod markdown;
-pub mod registry;
 #[cfg(test)]
 mod tests;
 pub mod timings;
@@ -299,8 +297,6 @@ impl<'a> std::ops::Deref for DiagCtxtHandle<'a> {
 struct DiagCtxtInner {
     flags: DiagCtxtFlags,
 
-    registry: Registry,
-
     /// The error guarantees from all emitted errors. The length gives the error count.
     err_guars: Vec<ErrorGuaranteed>,
     /// The error guarantee from all emitted lint errors. The length gives the
@@ -482,11 +478,6 @@ impl DiagCtxt {
         self
     }
 
-    pub fn with_registry(mut self, registry: Registry) -> Self {
-        self.inner.get_mut().registry = registry;
-        self
-    }
-
     pub fn new(emitter: Box<DynEmitter>) -> Self {
         Self { inner: Lock::new(DiagCtxtInner::new(emitter)) }
     }
@@ -539,7 +530,6 @@ impl DiagCtxt {
         let mut inner = self.inner.borrow_mut();
         let DiagCtxtInner {
             flags: _,
-            registry: _,
             err_guars,
             lint_err_guars,
             delayed_bugs,
@@ -813,7 +803,7 @@ impl<'a> DiagCtxtHandle<'a> {
                 .emitted_diagnostic_codes
                 .iter()
                 .filter_map(|&code| {
-                    if inner.registry.try_find_description(code).is_ok() {
+                    if crate::codes::try_find_description(code).is_ok() {
                         Some(code.to_string())
                     } else {
                         None
@@ -885,7 +875,7 @@ impl<'a> DiagCtxtHandle<'a> {
         let inner = &mut *self.inner.borrow_mut();
         let diags = std::mem::take(&mut inner.future_breakage_diagnostics);
         if !diags.is_empty() {
-            inner.emitter.emit_future_breakage_report(diags, &inner.registry);
+            inner.emitter.emit_future_breakage_report(diags);
         }
     }
 
@@ -1186,7 +1176,6 @@ impl DiagCtxtInner {
     fn new(emitter: Box<DynEmitter>) -> Self {
         Self {
             flags: DiagCtxtFlags { can_emit_warnings: true, ..Default::default() },
-            registry: Registry::new(&[]),
             err_guars: Vec::new(),
             lint_err_guars: Vec::new(),
             delayed_bugs: Vec::new(),
@@ -1362,7 +1351,7 @@ impl DiagCtxtInner {
                 }
                 self.has_printed = true;
 
-                self.emitter.emit_diagnostic(diagnostic, &self.registry);
+                self.emitter.emit_diagnostic(diagnostic);
             }
 
             if is_error {

compiler/rustc_interface/src/interface.rs

@@ -7,7 +7,6 @@ use rustc_codegen_ssa::traits::CodegenBackend;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::jobserver::{self, Proxy};
 use rustc_data_structures::stable_hasher::StableHasher;
-use rustc_errors::registry::Registry;
 use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed};
 use rustc_lint::LintStore;
 use rustc_middle::ty;
@@ -374,9 +373,6 @@ pub struct Config {
     pub make_codegen_backend:
         Option<Box<dyn FnOnce(&config::Options, &Target) -> Box<dyn CodegenBackend> + Send>>,
 
-    /// Registry of diagnostics codes.
-    pub registry: Registry,
-
     /// The inner atomic value is set to true when a feature marked as `internal` is
     /// enabled. Makes it so that "please report a bug" is hidden, as ICEs with
     /// internal features are wontfix, and they are usually the cause of the ICEs.
@@ -464,7 +460,6 @@ pub fn run_compiler<R: Send>(config: Config, f: impl FnOnce(&Compiler) -> R + Se
                     temps_dir,
                 },
                 bundle,
-                config.registry,
                 config.locale_resources,
                 config.lint_caps,
                 target,

compiler/rustc_interface/src/tests.rs

@@ -6,8 +6,8 @@ use std::sync::atomic::AtomicBool;
 
 use rustc_abi::Align;
 use rustc_data_structures::profiling::TimePassesFormat;
+use rustc_errors::ColorConfig;
 use rustc_errors::emitter::HumanReadableErrorType;
-use rustc_errors::{ColorConfig, registry};
 use rustc_hir::attrs::{CollapseMacroDebuginfo, NativeLibKind};
 use rustc_session::config::{
     AnnotateMoves, AutoDiff, BranchProtection, CFGuard, Cfg, CoverageLevel, CoverageOptions,
@@ -72,7 +72,6 @@ where
             sessopts,
             io,
             None,
-            registry::Registry::new(&[]),
             vec![],
             Default::default(),
             target,