Porting my first trait_selection diagnostics

Author: gabrielbusta

compiler/rustc_error_messages/locales/en-US/trait_selection.ftl

@@ -0,0 +1,7 @@
+dump_vtable_entries = vtable entries for `{$trait_ref}`: {$entries}
+
+unable_to_construct_constant_value_unevaluated_constant = unable to construct a constant value for the unevaluated constant {$unevaluated}
+
+reached_recursion_limit_auto_deref = reached the recursion limit while auto-dereferencing `{$ty}`
+deref_recursion_limit_reached = deref recursion limit reached
+deref_recursion_limit_reached_help = consider increasing the recursion limit by adding a `#![recursion_limit = "{$suggested_limit}"]` attribute to your crate (`{$crate_name}`)

compiler/rustc_error_messages/src/lib.rs

@@ -41,6 +41,7 @@ fluent_messages! {
     parser => "../locales/en-US/parser.ftl",
     passes => "../locales/en-US/passes.ftl",
     privacy => "../locales/en-US/privacy.ftl",
+    trait_selection => "../locales/en-US/trait_selection.ftl",
     typeck => "../locales/en-US/typeck.ftl",
 }
 

compiler/rustc_trait_selection/src/autoderef.rs

@@ -1,6 +1,6 @@
 use crate::traits::query::evaluate_obligation::InferCtxtExt;
 use crate::traits::{self, TraitEngine};
-use rustc_errors::struct_span_err;
+use crate::errors::ReachedRecursionLimitDeref;
 use rustc_hir as hir;
 use rustc_infer::infer::InferCtxt;
 use rustc_middle::ty::{self, TraitRef, Ty, TyCtxt};
@@ -222,19 +222,10 @@ pub fn report_autoderef_recursion_limit_error<'tcx>(tcx: TyCtxt<'tcx>, span: Spa
         Limit(0) => Limit(2),
         limit => limit * 2,
     };
-    struct_span_err!(
-        tcx.sess,
+    tcx.sess.emit_err(ReachedRecursionLimitDeref {
         span,
-        E0055,
-        "reached the recursion limit while auto-dereferencing `{:?}`",
-        ty
-    )
-    .span_label(span, "deref recursion limit reached")
-    .help(&format!(
-        "consider increasing the recursion limit by adding a \
-             `#![recursion_limit = \"{}\"]` attribute to your crate (`{}`)",
-        suggested_limit,
-        tcx.crate_name(LOCAL_CRATE),
-    ))
-    .emit();
+        ty: format!("{:?}", ty),
+        suggested_limit: suggested_limit.to_string(),
+        crate_name: tcx.crate_name(LOCAL_CRATE).to_string(),
+    });
 }

compiler/rustc_trait_selection/src/errors.rs

@@ -0,0 +1,31 @@
+use rustc_span::Span;
+use rustc_macros::SessionDiagnostic;
+
+#[derive(SessionDiagnostic)]
+#[error(trait_selection::dump_vtable_entries)]
+pub struct DumpVTableEntries {
+    #[primary_span]
+    pub span: Span,
+    pub trait_ref: String,
+    pub entries: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[error(trait_selection::unable_to_construct_constant_value_unevaluated_constant)]
+pub struct UnableToConstructConstantValueUnevaluatedConstant {
+    #[primary_span]
+    pub span: Span,
+    pub unevaluated: String,
+}
+
+#[derive(SessionDiagnostic)]
+#[help(trait_selection::deref_recursion_limit_reached_help)]
+#[error(trait_selection::reached_recursion_limit_auto_deref, code = "E0055")]
+pub struct ReachedRecursionLimitDeref {
+    #[primary_span]
+    #[label(trait_selection::deref_recursion_limit_reached)]
+    pub span: Span,
+    pub ty: String,
+    pub suggested_limit: String,
+    pub crate_name: String,
+}

compiler/rustc_trait_selection/src/lib.rs

@@ -21,6 +21,8 @@
 #![feature(if_let_guard)]
 #![feature(never_type)]
 #![recursion_limit = "512"] // For rustdoc
+#![deny(rustc::untranslatable_diagnostic)]
+#![deny(rustc::diagnostic_outside_of_impl)]
 
 #[macro_use]
 extern crate rustc_macros;
@@ -35,5 +37,6 @@ extern crate rustc_middle;
 extern crate smallvec;
 
 pub mod autoderef;
+pub mod errors;
 pub mod infer;
 pub mod traits;

compiler/rustc_trait_selection/src/traits/auto_trait.rs

@@ -3,6 +3,7 @@
 
 use super::*;
 
+use crate::errors::UnableToConstructConstantValueUnevaluatedConstant;
 use crate::infer::region_constraints::{Constraint, RegionConstraintData};
 use crate::infer::InferCtxt;
 use crate::traits::project::ProjectAndUnifyResult;
@@ -830,8 +831,12 @@ impl<'tcx> AutoTraitFinder<'tcx> {
                                 Ok(None) => {
                                     let tcx = self.tcx;
                                     let def_id = unevaluated.def.did;
-                                    let reported = tcx.sess.struct_span_err(tcx.def_span(def_id), &format!("unable to construct a constant value for the unevaluated constant {:?}", unevaluated)).emit();
-
+                                    let reported = tcx.sess.emit_err(
+                                        UnableToConstructConstantValueUnevaluatedConstant {
+                                            span: tcx.def_span(def_id),
+                                            unevaluated: format!("{:?}", unevaluated),
+                                        },
+                                    );
                                     Err(ErrorHandled::Reported(reported))
                                 }
                                 Err(err) => Err(err),

compiler/rustc_trait_selection/src/traits/mod.rs

@@ -22,6 +22,7 @@ mod structural_match;
 mod util;
 pub mod wf;
 
+use crate::errors::DumpVTableEntries;
 use crate::infer::outlives::env::OutlivesEnvironment;
 use crate::infer::{InferCtxt, TyCtxtInferExt};
 use crate::traits::error_reporting::InferCtxtExt as _;
@@ -748,8 +749,11 @@ fn dump_vtable_entries<'tcx>(
     trait_ref: ty::PolyTraitRef<'tcx>,
     entries: &[VtblEntry<'tcx>],
 ) {
-    let msg = format!("vtable entries for `{}`: {:#?}", trait_ref, entries);
-    tcx.sess.struct_span_err(sp, &msg).emit();
+    tcx.sess.emit_err(DumpVTableEntries {
+        span: sp,
+        trait_ref: trait_ref.to_string(),
+        entries: format!("{:#?}", entries),
+    });
 }
 
 fn own_existential_vtable_entries<'tcx>(