Auto merge of #157890 - jhpratt:rollup-0s3lJLm, r=jhpratt

Rollup of 2 pull requests

Successful merges:

 - #157677 (Slightly improve diagnostic impl+output for uncovered type parameters)
 - #157884 (Rename `errors.rs` file to `diagnostics.rs` (9/N))

Author: bors

compiler/rustc_borrowck/src/diagnostics/opaque_types.rs

@@ -12,8 +12,8 @@ use rustc_middle::ty::{
     Unnormalized,
 };
 use rustc_span::Span;
+use rustc_trait_selection::diagnostics::impl_trait_overcapture_suggestion;
 use rustc_trait_selection::error_reporting::infer::region::unexpected_hidden_region_diagnostic;
-use rustc_trait_selection::errors::impl_trait_overcapture_suggestion;
 
 use crate::MirBorrowckCtxt;
 use crate::borrow_set::BorrowData;

compiler/rustc_hir_analysis/src/coherence/orphan.rs

@@ -31,7 +31,21 @@ pub(crate) fn orphan_check_impl(
         Err(err) => match orphan_check(tcx, impl_def_id, OrphanCheckMode::Compat) {
             Ok(()) => match err {
                 OrphanCheckErr::UncoveredTyParams(uncovered_ty_params) => {
-                    lint_uncovered_ty_params(tcx, uncovered_ty_params, impl_def_id)
+                    let hir_id = tcx.local_def_id_to_hir_id(impl_def_id);
+
+                    for param_def_id in uncovered_ty_params.uncovered {
+                        let ident = tcx.item_ident(param_def_id);
+
+                        tcx.emit_node_span_lint(
+                            UNCOVERED_PARAM_IN_PROJECTION,
+                            hir_id,
+                            ident.span,
+                            diagnostics::UncoveredTyParam {
+                                param: ident,
+                                local_ty: uncovered_ty_params.local_ty,
+                            },
+                        );
+                    }
                 }
                 OrphanCheckErr::NonLocalInputType(_) => {
                     bug!("orphanck: shouldn't've gotten non-local input tys in compat mode")
@@ -458,56 +472,18 @@ fn emit_orphan_check_error<'tcx>(
             diag.emit()
         }
         traits::OrphanCheckErr::UncoveredTyParams(UncoveredTyParams { uncovered, local_ty }) => {
-            let mut reported = None;
+            let mut guar = None;
             for param_def_id in uncovered {
-                let name = tcx.item_ident(param_def_id);
-                let span = name.span;
-
-                reported.get_or_insert(match local_ty {
-                    Some(local_type) => tcx.dcx().emit_err(diagnostics::TyParamFirstLocal {
-                        span,
-                        note: (),
-                        param: name,
-                        local_type,
-                    }),
-                    None => {
-                        tcx.dcx().emit_err(diagnostics::TyParamSome { span, note: (), param: name })
-                    }
-                });
+                guar.get_or_insert(tcx.dcx().emit_err(diagnostics::UncoveredTyParam {
+                    param: tcx.item_ident(param_def_id),
+                    local_ty,
+                }));
             }
-            reported.unwrap() // FIXME(fmease): This is very likely reachable.
+            guar.unwrap()
         }
     }
 }
 
-fn lint_uncovered_ty_params<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    UncoveredTyParams { uncovered, local_ty }: UncoveredTyParams<TyCtxt<'tcx>, FxIndexSet<DefId>>,
-    impl_def_id: LocalDefId,
-) {
-    let hir_id = tcx.local_def_id_to_hir_id(impl_def_id);
-
-    for param_def_id in uncovered {
-        let span = tcx.def_ident_span(param_def_id).unwrap();
-        let name = tcx.item_ident(param_def_id);
-
-        match local_ty {
-            Some(local_type) => tcx.emit_node_span_lint(
-                UNCOVERED_PARAM_IN_PROJECTION,
-                hir_id,
-                span,
-                diagnostics::TyParamFirstLocalLint { span, note: (), param: name, local_type },
-            ),
-            None => tcx.emit_node_span_lint(
-                UNCOVERED_PARAM_IN_PROJECTION,
-                hir_id,
-                span,
-                diagnostics::TyParamSomeLint { span, note: (), param: name },
-            ),
-        };
-    }
-}
-
 struct UncoveredTyParamCollector<'cx, 'tcx> {
     infcx: &'cx InferCtxt<'tcx>,
     uncovered_params: FxIndexSet<DefId>,

compiler/rustc_hir_analysis/src/diagnostics.rs

@@ -1474,72 +1474,6 @@ pub struct NoFieldOnType<'tcx> {
     pub field: Ident,
 }
 
-// FIXME(fmease): Deduplicate:
-
-#[derive(Diagnostic)]
-#[diag("type parameter `{$param}` must be covered by another type when it appears before the first local type (`{$local_type}`)", code = E0210)]
-#[note(
-    "implementing a foreign trait is only possible if at least one of the types for which it is implemented is local, and no uncovered type parameters appear before that first local type"
-)]
-pub(crate) struct TyParamFirstLocal<'tcx> {
-    #[primary_span]
-    #[label(
-        "type parameter `{$param}` must be covered by another type when it appears before the first local type (`{$local_type}`)"
-    )]
-    pub span: Span,
-    #[note(
-        "in this case, 'before' refers to the following order: `impl<..> ForeignTrait<T1, ..., Tn> for T0`, where `T0` is the first and `Tn` is the last"
-    )]
-    pub note: (),
-    pub param: Ident,
-    pub local_type: Ty<'tcx>,
-}
-
-#[derive(Diagnostic)]
-#[diag("type parameter `{$param}` must be covered by another type when it appears before the first local type (`{$local_type}`)", code = E0210)]
-#[note(
-    "implementing a foreign trait is only possible if at least one of the types for which it is implemented is local, and no uncovered type parameters appear before that first local type"
-)]
-pub(crate) struct TyParamFirstLocalLint<'tcx> {
-    #[label(
-        "type parameter `{$param}` must be covered by another type when it appears before the first local type (`{$local_type}`)"
-    )]
-    pub span: Span,
-    #[note(
-        "in this case, 'before' refers to the following order: `impl<..> ForeignTrait<T1, ..., Tn> for T0`, where `T0` is the first and `Tn` is the last"
-    )]
-    pub note: (),
-    pub param: Ident,
-    pub local_type: Ty<'tcx>,
-}
-
-#[derive(Diagnostic)]
-#[diag("type parameter `{$param}` must be used as the type parameter for some local type (e.g., `MyStruct<{$param}>`)", code = E0210)]
-#[note(
-    "implementing a foreign trait is only possible if at least one of the types for which it is implemented is local"
-)]
-pub(crate) struct TyParamSome {
-    #[primary_span]
-    #[label("type parameter `{$param}` must be used as the type parameter for some local type")]
-    pub span: Span,
-    #[note("only traits defined in the current crate can be implemented for a type parameter")]
-    pub note: (),
-    pub param: Ident,
-}
-
-#[derive(Diagnostic)]
-#[diag("type parameter `{$param}` must be used as the type parameter for some local type (e.g., `MyStruct<{$param}>`)", code = E0210)]
-#[note(
-    "implementing a foreign trait is only possible if at least one of the types for which it is implemented is local"
-)]
-pub(crate) struct TyParamSomeLint {
-    #[label("type parameter `{$param}` must be used as the type parameter for some local type")]
-    pub span: Span,
-    #[note("only traits defined in the current crate can be implemented for a type parameter")]
-    pub note: (),
-    pub param: Ident,
-}
-
 #[derive(Diagnostic)]
 pub(crate) enum OnlyCurrentTraits {
     #[diag("only traits defined in the current crate can be implemented for types defined outside of the crate", code = E0117)]
@@ -2024,3 +1958,53 @@ pub(crate) struct PinV2OnPacked {
     pub pin_v2_span: Option<Span>,
     pub adt_name: Symbol,
 }
+
+pub(crate) struct UncoveredTyParam<'tcx> {
+    pub(crate) param: Ident,
+    pub(crate) local_ty: Option<Ty<'tcx>>,
+}
+
+impl<G: EmissionGuarantee> Diagnostic<'_, G> for UncoveredTyParam<'_> {
+    fn into_diag(self, dcx: DiagCtxtHandle<'_>, level: Level) -> Diag<'_, G> {
+        let Self { param, local_ty } = self;
+
+        let mut diag = Diag::new(dcx, level, "")
+            .with_span(param.span)
+            .with_span_label(param.span, "uncovered type parameter");
+        if diag.is_error() {
+            diag.code(E0210);
+        }
+
+        let note = "\
+            implementing a foreign trait is only possible if \
+            at least one of the types for which it is implemented is local";
+
+        if let Some(local_ty) = local_ty {
+            diag.primary_message(format!(
+                "type parameter `{param}` must be covered by another type when \
+                 it appears before the first local type (`{local_ty}`)"
+            ));
+
+            diag.note(format!(
+                "{note},\nand no uncovered type parameters appear before that first local type"
+            ));
+            diag.note(
+                "in this case, 'before' refers to the following order: \
+                 `impl<..> ForeignTrait<T1, ..., Tn> for T0`,\n\
+                 where `T0` is the first and `Tn` is the last",
+            );
+        } else {
+            diag.primary_message(format!(
+                "type parameter `{param}` must be used as an argument to \
+                 some local type (e.g., `MyStruct<{param}>`)"
+            ));
+
+            diag.note(note);
+            diag.note(
+                "only traits defined in the current crate can be implemented for a type parameter",
+            );
+        }
+
+        diag
+    }
+}

compiler/rustc_lint/src/impl_trait_overcaptures.rs

@@ -23,7 +23,7 @@ use rustc_middle::{bug, span_bug};
 use rustc_session::lint::fcw;
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::{Span, Symbol};
-use rustc_trait_selection::errors::{
+use rustc_trait_selection::diagnostics::{
     AddPreciseCapturingForOvercapture, impl_trait_overcapture_suggestion,
 };
 use rustc_trait_selection::regions::OutlivesEnvironmentBuildExt;

compiler/rustc_mir_transform/src/check_call_recursion.rs

@@ -10,7 +10,7 @@ use rustc_middle::ty::{self, GenericArg, GenericArgs, Instance, Ty, TyCtxt, Unno
 use rustc_session::lint::builtin::UNCONDITIONAL_RECURSION;
 use rustc_span::Span;
 
-use crate::errors::UnconditionalRecursion;
+use crate::diagnostics::UnconditionalRecursion;
 use crate::pass_manager::MirLint;
 
 pub(super) struct CheckCallRecursion;

compiler/rustc_mir_transform/src/check_const_item_mutation.rs

@@ -6,7 +6,7 @@ use rustc_session::lint::builtin::CONST_ITEM_MUTATION;
 use rustc_span::Span;
 use rustc_span::def_id::DefId;
 
-use crate::errors;
+use crate::diagnostics;
 
 pub(super) struct CheckConstItemMutation;
 
@@ -108,7 +108,7 @@ impl<'tcx> Visitor<'tcx> for ConstMutationChecker<'_, 'tcx> {
                     CONST_ITEM_MUTATION,
                     lint_root,
                     span,
-                    errors::ConstMutate::Modify { konst: item },
+                    diagnostics::ConstMutate::Modify { konst: item },
                 );
             }
 
@@ -154,7 +154,7 @@ impl<'tcx> Visitor<'tcx> for ConstMutationChecker<'_, 'tcx> {
                         CONST_ITEM_MUTATION,
                         lint_root,
                         span,
-                        errors::ConstMutate::MutBorrow { method_call, konst: item },
+                        diagnostics::ConstMutate::MutBorrow { method_call, konst: item },
                     );
                 }
             }

compiler/rustc_mir_transform/src/check_inline.rs

@@ -26,7 +26,7 @@ impl<'tcx> MirLint<'tcx> for CheckForceInline {
         if let Err(reason) =
             is_inline_valid_on_fn(tcx, def_id).and_then(|_| is_inline_valid_on_body(tcx, body))
         {
-            tcx.dcx().emit_err(crate::errors::InvalidForceInline {
+            tcx.dcx().emit_err(crate::diagnostics::InvalidForceInline {
                 attr_span,
                 callee_span: tcx.def_span(def_id),
                 callee: tcx.def_path_str(def_id),

compiler/rustc_mir_transform/src/check_packed_ref.rs

@@ -3,7 +3,7 @@ use rustc_middle::mir::*;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{self, TyCtxt};
 
-use crate::{errors, util};
+use crate::{diagnostics, util};
 
 pub(super) struct CheckPackedRef;
 
@@ -50,7 +50,7 @@ impl<'tcx> Visitor<'tcx> for PackedRefChecker<'_, 'tcx> {
                 // shouldn't do.
                 span_bug!(self.source_info.span, "builtin derive created an unaligned reference");
             } else {
-                self.tcx.dcx().emit_err(errors::UnalignedPackedRef {
+                self.tcx.dcx().emit_err(diagnostics::UnalignedPackedRef {
                     span: self.source_info.span,
                     ty_descr: adt.descr(),
                     align: pack.bytes(),

compiler/rustc_mir_transform/src/coroutine/layout.rs

@@ -46,7 +46,7 @@ use rustc_trait_selection::infer::TyCtxtInferExt as _;
 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode, ObligationCtxt};
 use tracing::{debug, instrument, trace};
 
-use crate::errors::{MustNotSupend, MustNotSuspendReason};
+use crate::diagnostics::{MustNotSupend, MustNotSuspendReason};
 
 const SELF_ARG: Local = Local::arg(0);