each left 1

Author: AndyJado

compiler/rustc_borrowck/src/region_infer/mod.rs

@@ -1,3 +1,6 @@
+// #![deny(rustc::untranslatable_diagnostic)]
+// #![deny(rustc::diagnostic_outside_of_impl)]
+
 use std::collections::VecDeque;
 use std::rc::Rc;
 

compiler/rustc_borrowck/src/region_infer/opaque_types.rs

@@ -1,3 +1,6 @@
+// #![deny(rustc::untranslatable_diagnostic)]
+// #![deny(rustc::diagnostic_outside_of_impl)]
+
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::vec_map::VecMap;
 use rustc_hir::def_id::LocalDefId;
@@ -16,7 +19,9 @@ use rustc_span::Span;
 use rustc_trait_selection::traits::error_reporting::InferCtxtExt as _;
 use rustc_trait_selection::traits::TraitEngineExt as _;
 
-use crate::session_diagnostics::ConstNotUsedTraitAlias;
+use crate::session_diagnostics::{
+    ConstNotUsedTraitAlias, OpaqueTyDefineErrCause, OpaqueTypeNotDefine, UnusedTypeParameter,
+};
 
 use super::RegionInferenceContext;
 
@@ -374,15 +379,12 @@ fn check_opaque_type_parameter_valid(
         let arg_is_param = match arg.unpack() {
             GenericArgKind::Type(ty) => matches!(ty.kind(), ty::Param(_)),
             GenericArgKind::Lifetime(lt) if lt.is_static() => {
-                tcx.sess
-                    .struct_span_err(span, "non-defining opaque type use in defining scope")
-                    .span_label(
-                        tcx.def_span(opaque_generics.param_at(i, tcx).def_id),
-                        "cannot use static lifetime; use a bound lifetime \
-                                    instead or remove the lifetime parameter from the \
-                                    opaque type",
-                    )
-                    .emit();
+                tcx.sess.emit_err(OpaqueTypeNotDefine {
+                    cause: OpaqueTyDefineErrCause::UsedStaticLifetime {
+                        span: tcx.def_span(opaque_generics.param_at(i, tcx).def_id),
+                    },
+                    span,
+                });
                 return false;
             }
             GenericArgKind::Lifetime(lt) => {
@@ -396,17 +398,14 @@ fn check_opaque_type_parameter_valid(
         } else {
             // Prevent `fn foo() -> Foo<u32>` from being defining.
             let opaque_param = opaque_generics.param_at(i, tcx);
-            tcx.sess
-                .struct_span_err(span, "non-defining opaque type use in defining scope")
-                .span_note(
-                    tcx.def_span(opaque_param.def_id),
-                    &format!(
-                        "used non-generic {} `{}` for generic parameter",
-                        opaque_param.kind.descr(),
-                        arg,
-                    ),
-                )
-                .emit();
+            tcx.sess.emit_err(OpaqueTypeNotDefine {
+                cause: OpaqueTyDefineErrCause::NonGenericUsed {
+                    span: tcx.def_span(opaque_param.def_id),
+                    descr: opaque_param.kind.descr().to_string(),
+                    arg: arg.to_string(),
+                },
+                span,
+            });
             return false;
         }
     }
@@ -418,6 +417,7 @@ fn check_opaque_type_parameter_valid(
                 .into_iter()
                 .map(|i| tcx.def_span(opaque_generics.param_at(i, tcx).def_id))
                 .collect();
+            //FIXME: wait for lists?
             tcx.sess
                 .struct_span_err(span, "non-defining opaque type use in defining scope")
                 .span_note(spans, &format!("{} used multiple times", descr))
@@ -525,18 +525,13 @@ impl<'tcx> TypeFolder<'tcx> for ReverseMapper<'tcx> {
                 self.tcx.lifetimes.re_root_empty
             }
             None => {
-                self.tcx
-                    .sess
-                    .struct_span_err(self.span, "non-defining opaque type use in defining scope")
-                    .span_label(
-                        self.span,
-                        format!(
-                            "lifetime `{}` is part of concrete type but not used in \
-                                 parameter list of the `impl Trait` type alias",
-                            r
-                        ),
-                    )
-                    .emit();
+                self.tcx.sess.emit_err(OpaqueTypeNotDefine {
+                    cause: OpaqueTyDefineErrCause::UnusedLifetime {
+                        span: self.span,
+                        r: r.to_string(),
+                    },
+                    span: self.span,
+                });
 
                 self.tcx().lifetimes.re_static
             }
@@ -608,17 +603,7 @@ impl<'tcx> TypeFolder<'tcx> for ReverseMapper<'tcx> {
                     Some(u) => panic!("type mapped to unexpected kind: {:?}", u),
                     None => {
                         debug!(?param, ?self.map);
-                        self.tcx
-                            .sess
-                            .struct_span_err(
-                                self.span,
-                                &format!(
-                                    "type parameter `{}` is part of concrete type but not \
-                                          used in parameter list for the `impl Trait` type alias",
-                                    ty
-                                ),
-                            )
-                            .emit();
+                        self.tcx.sess.emit_err(UnusedTypeParameter { ty, span: self.span });
 
                         self.tcx().ty_error()
                     }

compiler/rustc_borrowck/src/session_diagnostics.rs

@@ -536,3 +536,56 @@ pub(crate) enum RegionNameLabels<'a> {
         location: &'a str,
     },
 }
+
+#[derive(SessionDiagnostic)]
+#[diag(borrowck::type_parameter_not_used_in_trait_type_alias)]
+pub(crate) struct UnusedTypeParameter<'tcx> {
+    pub ty: Ty<'tcx>,
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionDiagnostic)]
+#[diag(borrowck::non_defining_opaque_type)]
+pub(crate) struct OpaqueTypeNotDefine {
+    #[subdiagnostic]
+    pub cause: OpaqueTyDefineErrCause,
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(SessionSubdiagnostic)]
+pub(crate) enum OpaqueTyDefineErrCause {
+    #[label(borrowck::lifetime_not_used_in_trait_type_alias)]
+    UnusedLifetime {
+        #[primary_span]
+        span: Span,
+        r: String,
+    },
+    #[note(borrowck::used_non_generic_for_generic)]
+    NonGenericUsed {
+        #[primary_span]
+        span: Span,
+        descr: String,
+        arg: String,
+    },
+    #[label(borrowck::cannot_use_static_lifetime_here)]
+    UsedStaticLifetime {
+        #[primary_span]
+        span: Span,
+    },
+}
+
+#[derive(SessionSubdiagnostic)]
+pub(crate) enum DefiningTypeNote<'a> {
+    #[note(borrowck::define_type_with_closure_substs)]
+    Closure { type_name: &'a str, subsets: &'a str },
+    #[note(borrowck::define_type_with_generator_substs)]
+    Generator { type_name: &'a str, subsets: &'a str },
+    #[note(borrowck::define_type)]
+    FnDef { type_name: &'a str },
+    #[note(borrowck::define_const_type)]
+    Const { type_name: &'a str },
+    #[note(borrowck::define_inline_constant_type)]
+    InlineConst { type_name: &'a str },
+}

compiler/rustc_borrowck/src/universal_regions.rs

@@ -1,3 +1,6 @@
+// #![deny(rustc::untranslatable_diagnostic)]
+// #![deny(rustc::diagnostic_outside_of_impl)]
+
 //! Code to extract the universally quantified regions declared on a
 //! function and the relationships between them. For example:
 //!
@@ -27,6 +30,7 @@ use rustc_middle::ty::{self, InlineConstSubsts, InlineConstSubstsParts, RegionVi
 use std::iter;
 
 use crate::nll::ToRegionVid;
+use crate::session_diagnostics::DefiningTypeNote;
 
 #[derive(Debug)]
 pub struct UniversalRegions<'tcx> {
@@ -339,11 +343,9 @@ impl<'tcx> UniversalRegions<'tcx> {
     pub(crate) fn annotate(&self, tcx: TyCtxt<'tcx>, err: &mut Diagnostic) {
         match self.defining_ty {
             DefiningTy::Closure(def_id, substs) => {
-                err.note(&format!(
-                    "defining type: {} with closure substs {:#?}",
-                    tcx.def_path_str_with_substs(def_id, substs),
-                    &substs[tcx.generics_of(def_id).parent_count..],
-                ));
+                let type_name = &tcx.def_path_str_with_substs(def_id, substs);
+                let subsets = &format!("{:#?}", &substs[tcx.generics_of(def_id).parent_count..]);
+                err.subdiagnostic(DefiningTypeNote::Closure { type_name, subsets });
 
                 // FIXME: It'd be nice to print the late-bound regions
                 // here, but unfortunately these wind up stored into
@@ -356,11 +358,9 @@ impl<'tcx> UniversalRegions<'tcx> {
                 });
             }
             DefiningTy::Generator(def_id, substs, _) => {
-                err.note(&format!(
-                    "defining type: {} with generator substs {:#?}",
-                    tcx.def_path_str_with_substs(def_id, substs),
-                    &substs[tcx.generics_of(def_id).parent_count..],
-                ));
+                let type_name = &tcx.def_path_str_with_substs(def_id, substs);
+                let subsets = &format!("{:#?}", &substs[tcx.generics_of(def_id).parent_count..]);
+                err.subdiagnostic(DefiningTypeNote::Generator { type_name, subsets });
 
                 // FIXME: As above, we'd like to print out the region
                 // `r` but doing so is not stable across architectures
@@ -371,22 +371,16 @@ impl<'tcx> UniversalRegions<'tcx> {
                 });
             }
             DefiningTy::FnDef(def_id, substs) => {
-                err.note(&format!(
-                    "defining type: {}",
-                    tcx.def_path_str_with_substs(def_id, substs),
-                ));
+                let type_name = &tcx.def_path_str_with_substs(def_id, substs);
+                err.subdiagnostic(DefiningTypeNote::FnDef { type_name });
             }
             DefiningTy::Const(def_id, substs) => {
-                err.note(&format!(
-                    "defining constant type: {}",
-                    tcx.def_path_str_with_substs(def_id, substs),
-                ));
+                let type_name = &tcx.def_path_str_with_substs(def_id, substs);
+                err.subdiagnostic(DefiningTypeNote::Const { type_name });
             }
             DefiningTy::InlineConst(def_id, substs) => {
-                err.note(&format!(
-                    "defining inline constant type: {}",
-                    tcx.def_path_str_with_substs(def_id, substs),
-                ));
+                let type_name = &tcx.def_path_str_with_substs(def_id, substs);
+                err.subdiagnostic(DefiningTypeNote::InlineConst { type_name });
             }
         }
     }

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

@@ -218,3 +218,33 @@ borrowck_yield_type_is_type =
 
 borrowck_lifetime_appears_here_in_impl =
     lifetime `{$rg_name}` appears in the `impl`'s {$location}
+
+borrowck_type_parameter_not_used_in_trait_type_alias =
+    type parameter `{$ty}` is part of concrete type but not used in parameter list for the `impl Trait` type alias
+
+borrowck_non_defining_opaque_type =
+    non-defining opaque type use in defining scope
+
+borrowck_lifetime_not_used_in_trait_type_alias =
+    lifetime `{$r}` is part of concrete type but not used in parameter list of the `impl Trait` type alias
+
+borrowck_used_non_generic_for_generic =
+    used non-generic {$descr} `{$arg}` for generic parameter
+
+borrowck_cannot_use_static_lifetime_here =
+    cannot use static lifetime; use a bound lifetime instead or remove the lifetime parameter from the opaque type
+
+borrowck_define_inline_constant_type =
+    defining inline constant type: {$type_name}
+
+borrowck_define_const_type =
+    defining constant type: {$type_name}
+
+borrowck_define_type =
+    defining type: {$type_name}
+
+borrowck_define_type_with_generator_substs =
+    defining type: {$type_name} with generator substs {$subsets}
+
+borrowck_define_type_with_closure_substs =
+    defining type: {$type_name} with closure substs {$subsets}