Convert to inline diagnostics in rustc_trait_selection

Cargo.lock

@@ -3797,7 +3797,6 @@ dependencies = [
  "rustc_session",
  "rustc_span",
  "rustc_target",
- "rustc_trait_selection",
  "serde_json",
  "shlex",
  "tracing",
@@ -4724,7 +4723,6 @@ dependencies = [
  "rustc_ast",
  "rustc_data_structures",
  "rustc_errors",
- "rustc_fluent_macro",
  "rustc_hir",
  "rustc_infer",
  "rustc_macros",

compiler/rustc_driver_impl/Cargo.toml

@@ -36,7 +36,6 @@ rustc_resolve = { path = "../rustc_resolve" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
-rustc_trait_selection = { path = "../rustc_trait_selection" }
 serde_json = "1.0.59"
 shlex = "1.0"
 tracing = { version = "0.1.35" }

compiler/rustc_driver_impl/src/lib.rs

@@ -121,7 +121,6 @@ pub static DEFAULT_LOCALE_RESOURCES: &[&str] = &[
     rustc_mir_build::DEFAULT_LOCALE_RESOURCE,
     rustc_parse::DEFAULT_LOCALE_RESOURCE,
     rustc_passes::DEFAULT_LOCALE_RESOURCE,
-    rustc_trait_selection::DEFAULT_LOCALE_RESOURCE,
     // tidy-alphabetical-end
 ];
 

compiler/rustc_error_messages/src/lib.rs

@@ -192,7 +192,7 @@ pub fn fluent_bundle(
     Ok(Some(bundle))
 }
 
-fn register_functions(bundle: &mut FluentBundle) {
+pub fn register_functions<R, M>(bundle: &mut fluent_bundle::bundle::FluentBundle<R, M>) {
     bundle
         .add_function("STREQ", |positional, _named| match positional {
             [FluentValue::String(a), FluentValue::String(b)] => format!("{}", (a == b)).into(),

compiler/rustc_errors/src/translation.rs

@@ -3,8 +3,8 @@ use std::env;
 use std::error::Report;
 use std::sync::Arc;
 
-use rustc_error_messages::langid;
 pub use rustc_error_messages::{FluentArgs, LazyFallbackBundle};
+use rustc_error_messages::{langid, register_functions};
 use tracing::{debug, trace};
 
 use crate::error::{TranslateError, TranslateErrorKind};
@@ -91,6 +91,7 @@ impl Translator {
                 let mut bundle = fluent_bundle::FluentBundle::new(vec![langid!("en-US")]);
                 bundle.set_use_isolating(false);
                 bundle.add_resource(resource).unwrap();
+                register_functions(&mut bundle);
                 let message = bundle.get_message(GENERATED_MSG_ID).unwrap();
                 let value = message.value().unwrap();
 

compiler/rustc_trait_selection/Cargo.toml

@@ -10,7 +10,6 @@ rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
-rustc_fluent_macro = { path = "../rustc_fluent_macro" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_infer = { path = "../rustc_infer" }
 rustc_macros = { path = "../rustc_macros" }

compiler/rustc_trait_selection/src/error_reporting/infer/region.rs

@@ -2,7 +2,8 @@ use std::iter;
 
 use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::{
-    Applicability, Diag, E0309, E0310, E0311, E0803, Subdiagnostic, struct_span_code_err,
+    Applicability, Diag, E0309, E0310, E0311, E0803, Subdiagnostic, inline_fluent,
+    struct_span_code_err,
 };
 use rustc_hir::def::DefKind;
 use rustc_hir::def_id::{DefId, LocalDefId};
@@ -25,7 +26,6 @@ use crate::errors::{
     self, FulfillReqLifetime, LfBoundNotSatisfied, OutlivesBound, OutlivesContent,
     RefLongerThanData, RegionOriginNote, WhereClauseSuggestions, note_and_explain,
 };
-use crate::fluent_generated as fluent;
 use crate::infer::region_constraints::GenericKind;
 use crate::infer::{
     BoundRegionConversionTime, InferCtxt, RegionResolutionError, RegionVariableOrigin,
@@ -228,18 +228,22 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 expected_found: self.values_str(trace.values, &trace.cause, err.long_ty_path()),
             }
             .add_to_diag(err),
-            SubregionOrigin::Reborrow(span) => {
-                RegionOriginNote::Plain { span, msg: fluent::trait_selection_reborrow }
-                    .add_to_diag(err)
+            SubregionOrigin::Reborrow(span) => RegionOriginNote::Plain {
+                span,
+                msg: inline_fluent!("...so that reference does not outlive borrowed content"),
             }
+            .add_to_diag(err),
             SubregionOrigin::RelateObjectBound(span) => {
-                RegionOriginNote::Plain { span, msg: fluent::trait_selection_relate_object_bound }
-                    .add_to_diag(err);
+                RegionOriginNote::Plain {
+                    span,
+                    msg: inline_fluent!("...so that it can be closed over into an object"),
+                }
+                .add_to_diag(err);
             }
             SubregionOrigin::ReferenceOutlivesReferent(ty, span) => {
                 RegionOriginNote::WithName {
                     span,
-                    msg: fluent::trait_selection_reference_outlives_referent,
+                    msg: inline_fluent!("...so that the reference type `{$name}` does not outlive the data it points at"),
                     name: &self.ty_to_string(ty),
                     continues: false,
                 }
@@ -248,30 +252,37 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             SubregionOrigin::RelateParamBound(span, ty, opt_span) => {
                 RegionOriginNote::WithName {
                     span,
-                    msg: fluent::trait_selection_relate_param_bound,
+                    msg: inline_fluent!("...so that the type `{$name}` will meet its required lifetime bounds{$continues ->
+[true] ...
+*[false] {\"\"}
+}"),
                     name: &self.ty_to_string(ty),
                     continues: opt_span.is_some(),
                 }
                 .add_to_diag(err);
                 if let Some(span) = opt_span {
                     RegionOriginNote::Plain {
                         span,
-                        msg: fluent::trait_selection_relate_param_bound_2,
+                        msg: inline_fluent!("...that is required by this bound"),
                     }
                     .add_to_diag(err);
                 }
             }
             SubregionOrigin::RelateRegionParamBound(span, _) => {
                 RegionOriginNote::Plain {
                     span,
-                    msg: fluent::trait_selection_relate_region_param_bound,
+                    msg: inline_fluent!(
+                        "...so that the declared lifetime parameter bounds are satisfied"
+                    ),
                 }
                 .add_to_diag(err);
             }
             SubregionOrigin::CompareImplItemObligation { span, .. } => {
                 RegionOriginNote::Plain {
                     span,
-                    msg: fluent::trait_selection_compare_impl_item_obligation,
+                    msg: inline_fluent!(
+                        "...so that the definition in impl matches the definition from the trait"
+                    ),
                 }
                 .add_to_diag(err);
             }
@@ -281,7 +292,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             SubregionOrigin::AscribeUserTypeProvePredicate(span) => {
                 RegionOriginNote::Plain {
                     span,
-                    msg: fluent::trait_selection_ascribe_user_type_prove_predicate,
+                    msg: inline_fluent!("...so that the where clause holds"),
                 }
                 .add_to_diag(err);
             }

compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs

@@ -12,7 +12,7 @@ use rustc_data_structures::unord::UnordSet;
 use rustc_errors::codes::*;
 use rustc_errors::{
     Applicability, Diag, ErrorGuaranteed, Level, MultiSpan, StashKey, StringPart, Suggestions,
-    pluralize, struct_span_code_err,
+    inline_fluent, pluralize, struct_span_code_err,
 };
 use rustc_hir::def_id::{DefId, LOCAL_CRATE, LocalDefId};
 use rustc_hir::intravisit::Visitor;
@@ -3003,7 +3003,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         {
             err.span_help(
                 self.tcx.def_span(trait_def_id),
-                crate::fluent_generated::trait_selection_trait_has_no_impls,
+                inline_fluent!("this trait has no implementations, consider adding one"),
             );
         } else if !suggested && trait_predicate.polarity() == ty::PredicatePolarity::Positive {
             // Can't show anything else useful, try to find similar impls.

compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs

@@ -360,10 +360,10 @@ pub enum AppendConstMessage {
 }
 
 #[derive(LintDiagnostic)]
-#[diag(trait_selection_malformed_on_unimplemented_attr)]
-#[help]
+#[diag("malformed `on_unimplemented` attribute")]
+#[help("only `message`, `note` and `label` are allowed as options")]
 pub struct MalformedOnUnimplementedAttrLint {
-    #[label]
+    #[label("invalid option found here")]
     pub span: Span,
 }
 
@@ -374,17 +374,17 @@ impl MalformedOnUnimplementedAttrLint {
 }
 
 #[derive(LintDiagnostic)]
-#[diag(trait_selection_missing_options_for_on_unimplemented_attr)]
-#[help]
+#[diag("missing options for `on_unimplemented` attribute")]
+#[help("at least one of the `message`, `note` and `label` options are expected")]
 pub struct MissingOptionsForOnUnimplementedAttr;
 
 #[derive(LintDiagnostic)]
-#[diag(trait_selection_ignored_diagnostic_option)]
+#[diag("`{$option_name}` is ignored due to previous definition of `{$option_name}`")]
 pub struct IgnoredDiagnosticOption {
     pub option_name: &'static str,
-    #[label]
+    #[label("`{$option_name}` is already declared here")]
     pub span: Span,
-    #[label(trait_selection_other_label)]
+    #[label("`{$option_name}` is first declared here")]
     pub prev_span: Span,
 }
 
@@ -410,7 +410,7 @@ impl IgnoredDiagnosticOption {
 }
 
 #[derive(LintDiagnostic)]
-#[diag(trait_selection_wrapped_parser_error)]
+#[diag("{$description}")]
 pub struct WrappedParserError {
     pub description: String,
     pub label: String,

compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented_format.rs

@@ -310,25 +310,27 @@ pub mod errors {
     use super::*;
 
     #[derive(LintDiagnostic)]
-    #[diag(trait_selection_unknown_format_parameter_for_on_unimplemented_attr)]
-    #[help]
+    #[diag("there is no parameter `{$argument_name}` on trait `{$trait_name}`")]
+    #[help("expect either a generic argument name or {\"`{Self}`\"} as format argument")]
     pub struct UnknownFormatParameterForOnUnimplementedAttr {
         pub argument_name: Symbol,
         pub trait_name: Ident,
     }
 
     #[derive(LintDiagnostic)]
-    #[diag(trait_selection_disallowed_positional_argument)]
-    #[help]
+    #[diag("positional format arguments are not allowed here")]
+    #[help(
+        "only named format arguments with the name of one of the generic types are allowed in this context"
+    )]
     pub struct DisallowedPositionalArgument;
 
     #[derive(LintDiagnostic)]
-    #[diag(trait_selection_invalid_format_specifier)]
-    #[help]
+    #[diag("invalid format specifier")]
+    #[help("no format specifier are supported in this position")]
     pub struct InvalidFormatSpecifier;
 
     #[derive(LintDiagnostic)]
-    #[diag(trait_selection_missing_options_for_on_unimplemented_attr)]
-    #[help]
+    #[diag("missing options for `on_unimplemented` attribute")]
+    #[help("at least one of the `message`, `note` and `label` options are expected")]
     pub struct MissingOptionsForOnUnimplementedAttr;
 }