diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 194f2cd04e468..df3dcd9945694 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -540,16 +540,6 @@ hir_analysis_transparent_non_zero_sized_enum = the variant of a transparent {$de
 
 hir_analysis_ty_of_assoc_const_binding_note = `{$assoc_const}` has type `{$ty}`
 
-hir_analysis_ty_param_first_local = type parameter `{$param}` must be covered by another type when it appears before the first local type (`{$local_type}`)
-    .label = type parameter `{$param}` must be covered by another type when it appears before the first local type (`{$local_type}`)
-    .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
-    .case_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
-
-hir_analysis_ty_param_some = type parameter `{$param}` must be used as the type parameter for some local type (e.g., `MyStruct<{$param}>`)
-    .label = type parameter `{$param}` must be used as the type parameter for some local type
-    .note = implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-    .only_note = only traits defined in the current crate can be implemented for a type parameter
-
 hir_analysis_type_of = {$ty}
 
 hir_analysis_typeof_reserved_keyword_used =
diff --git a/compiler/rustc_hir_analysis/src/coherence/orphan.rs b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
index 74ba4ffe25ea1..1f2b46445ae88 100644
--- a/compiler/rustc_hir_analysis/src/coherence/orphan.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/orphan.rs
@@ -2,17 +2,17 @@
 //! crate or pertains to a type defined in this crate.
 
 use rustc_data_structures::fx::FxIndexSet;
-use rustc_errors::ErrorGuaranteed;
+use rustc_errors::{Diag, EmissionGuarantee, ErrorGuaranteed};
 use rustc_infer::infer::{DefineOpaqueTypes, InferCtxt, TyCtxtInferExt};
 use rustc_lint_defs::builtin::UNCOVERED_PARAM_IN_PROJECTION;
 use rustc_middle::ty::{
-    self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor, TypingMode,
+    self, Ty, TyCtxt, TypeFlags, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
+    TypingMode,
 };
 use rustc_middle::{bug, span_bug};
-use rustc_span::def_id::{DefId, LocalDefId};
-use rustc_trait_selection::traits::{
-    self, IsFirstInputType, OrphanCheckErr, OrphanCheckMode, UncoveredTyParams,
-};
+use rustc_span::def_id::LocalDefId;
+use rustc_span::{Ident, Span};
+use rustc_trait_selection::traits::{self, InSelfTy, OrphanCheckErr, OrphanCheckMode, UncoveredTy};
 use tracing::{debug, instrument};
 
 use crate::errors;
@@ -29,8 +29,35 @@ pub(crate) fn orphan_check_impl(
         Ok(()) => {}
         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)
+                OrphanCheckErr::UncoveredTy(UncoveredTy { uncovered, local_ty, in_self_ty }) => {
+                    let item = tcx.hir_expect_item(impl_def_id);
+                    let impl_ = item.expect_impl();
+                    let hir_trait_ref = impl_.of_trait.as_ref().unwrap();
+
+                    // FIXME: Dedupe!
+                    // Given `impl<A, B> C<B> for D<A>`,
+                    let span = match in_self_ty {
+                        InSelfTy::Yes => impl_.self_ty.span,     // point at `D<A>`.
+                        InSelfTy::No => hir_trait_ref.path.span, // point at `C<B>`.
+                    };
+
+                    for ty in uncovered {
+                        match ty {
+                            UncoveredTyKind::TyParam(ident) => tcx.node_span_lint(
+                                UNCOVERED_PARAM_IN_PROJECTION,
+                                item.hir_id(),
+                                ident.span,
+                                |diag| decorate_uncovered_ty_diag(diag, ident.span, ty, local_ty),
+                            ),
+                            // FIXME(fmease): This one is hard to explain ^^'
+                            UncoveredTyKind::Unknown => {
+                                let mut diag = tcx.dcx().struct_span_err(span, "");
+                                decorate_uncovered_ty_diag(&mut diag, span, ty, local_ty);
+                                diag.emit();
+                            },
+                            _ => bug!(),
+                        }
+                    }
                 }
                 OrphanCheckErr::NonLocalInputType(_) => {
                     bug!("orphanck: shouldn't've gotten non-local input tys in compat mode")
@@ -276,20 +303,13 @@ pub(crate) fn orphan_check_impl(
     Ok(())
 }
 
-/// Checks the coherence orphan rules.
-///
-/// `impl_def_id` should be the `DefId` of a trait impl.
-///
-/// To pass, either the trait must be local, or else two conditions must be satisfied:
-///
-/// 1. All type parameters in `Self` must be "covered" by some local type constructor.
-/// 2. Some local type must appear in `Self`.
+/// Checks the coherence orphan rules for trait impl given by `impl_def_id`.
 #[instrument(level = "debug", skip(tcx), ret)]
 fn orphan_check<'tcx>(
     tcx: TyCtxt<'tcx>,
     impl_def_id: LocalDefId,
     mode: OrphanCheckMode,
-) -> Result<(), OrphanCheckErr<TyCtxt<'tcx>, FxIndexSet<DefId>>> {
+) -> Result<(), OrphanCheckErr<TyCtxt<'tcx>, UncoveredTys<'tcx>>> {
     // We only accept this routine to be invoked on implementations
     // of a trait, not inherent implementations.
     let trait_ref = tcx.impl_trait_ref(impl_def_id).unwrap();
@@ -342,15 +362,17 @@ fn orphan_check<'tcx>(
 
     // (2)  Try to map the remaining inference vars back to generic params.
     result.map_err(|err| match err {
-        OrphanCheckErr::UncoveredTyParams(UncoveredTyParams { uncovered, local_ty }) => {
+        OrphanCheckErr::UncoveredTy(UncoveredTy { uncovered, in_self_ty, local_ty }) => {
             let mut collector =
-                UncoveredTyParamCollector { infcx: &infcx, uncovered_params: Default::default() };
+                UncoveredTyCollector { infcx: &infcx, uncovered: Default::default() };
             uncovered.visit_with(&mut collector);
-            // FIXME(fmease): This is very likely reachable.
-            debug_assert!(!collector.uncovered_params.is_empty());
+            if collector.uncovered.is_empty() {
+                collector.uncovered.insert(UncoveredTyKind::Unknown);
+            }
 
-            OrphanCheckErr::UncoveredTyParams(UncoveredTyParams {
-                uncovered: collector.uncovered_params,
+            OrphanCheckErr::UncoveredTy(UncoveredTy {
+                uncovered: collector.uncovered,
+                in_self_ty,
                 local_ty,
             })
         }
@@ -378,14 +400,20 @@ fn emit_orphan_check_error<'tcx>(
     tcx: TyCtxt<'tcx>,
     trait_ref: ty::TraitRef<'tcx>,
     impl_def_id: LocalDefId,
-    err: traits::OrphanCheckErr<TyCtxt<'tcx>, FxIndexSet<DefId>>,
+    err: OrphanCheckErr<TyCtxt<'tcx>, UncoveredTys<'tcx>>,
 ) -> ErrorGuaranteed {
-    match err {
-        traits::OrphanCheckErr::NonLocalInputType(tys) => {
-            let item = tcx.hir_expect_item(impl_def_id);
-            let impl_ = item.expect_impl();
-            let hir_trait_ref = impl_.of_trait.as_ref().unwrap();
+    let item = tcx.hir_expect_item(impl_def_id);
+    let impl_ = item.expect_impl();
+    let hir_trait_ref = impl_.of_trait.as_ref().unwrap();
+
+    // Given `impl<A, B> C<B> for D<A>`,
+    let impl_trait_ref_span = |in_self_ty| match in_self_ty {
+        InSelfTy::Yes => impl_.self_ty.span,     // point at `D<A>`.
+        InSelfTy::No => hir_trait_ref.path.span, // point at `C<B>`.
+    };
 
+    match err {
+        OrphanCheckErr::NonLocalInputType(tys) => {
             let span = tcx.def_span(impl_def_id);
             let mut diag = tcx.dcx().create_err(match trait_ref.self_ty().kind() {
                 ty::Adt(..) => errors::OnlyCurrentTraits::Outside { span, note: () },
@@ -395,20 +423,12 @@ fn emit_orphan_check_error<'tcx>(
                 _ => errors::OnlyCurrentTraits::Arbitrary { span, note: () },
             });
 
-            for &(mut ty, is_target_ty) in &tys {
-                let span = if matches!(is_target_ty, IsFirstInputType::Yes) {
-                    // Point at `D<A>` in `impl<A, B> for C<B> in D<A>`
-                    impl_.self_ty.span
-                } else {
-                    // Point at `C<B>` in `impl<A, B> for C<B> in D<A>`
-                    hir_trait_ref.path.span
-                };
+            for &(mut ty, in_self_ty) in &tys {
+                let span = impl_trait_ref_span(in_self_ty);
+                let is_foreign = !trait_ref.def_id.is_local() && matches!(in_self_ty, InSelfTy::No);
 
                 ty = tcx.erase_regions(ty);
 
-                let is_foreign =
-                    !trait_ref.def_id.is_local() && matches!(is_target_ty, IsFirstInputType::No);
-
                 match *ty.kind() {
                     ty::Slice(_) => {
                         if is_foreign {
@@ -468,77 +488,121 @@ fn emit_orphan_check_error<'tcx>(
 
             diag.emit()
         }
-        traits::OrphanCheckErr::UncoveredTyParams(UncoveredTyParams { uncovered, local_ty }) => {
-            let mut reported = 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(errors::TyParamFirstLocal {
-                        span,
-                        note: (),
-                        param: name,
-                        local_type,
-                    }),
-                    None => tcx.dcx().emit_err(errors::TyParamSome { span, note: (), param: name }),
-                });
+        OrphanCheckErr::UncoveredTy(UncoveredTy { uncovered, in_self_ty, local_ty }) => {
+            let span = impl_trait_ref_span(in_self_ty);
+
+            let mut guar = None;
+            for ty in uncovered {
+                let span = match ty {
+                    UncoveredTyKind::TyParam(ident) => ident.span,
+                    _ => span,
+                };
+                let mut diag = tcx.dcx().struct_span_err(span, "");
+                decorate_uncovered_ty_diag(&mut diag, span, ty, local_ty);
+                guar.get_or_insert(diag.emit());
             }
-            reported.unwrap() // FIXME(fmease): This is very likely reachable.
+            // This should not fail because we know that `uncovered` was non-empty at the point of
+            // iteration since it always contains a single `Unknown` if all else fails.
+            guar.unwrap()
         }
     }
 }
 
-fn lint_uncovered_ty_params<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    UncoveredTyParams { uncovered, local_ty }: UncoveredTyParams<TyCtxt<'tcx>, FxIndexSet<DefId>>,
-    impl_def_id: LocalDefId,
+fn decorate_uncovered_ty_diag(
+    diag: &mut Diag<'_, impl EmissionGuarantee>,
+    span: Span,
+    kind: UncoveredTyKind<'_>,
+    local_ty: Option<Ty<'_>>,
 ) {
-    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,
-                errors::TyParamFirstLocalLint { span, note: (), param: name, local_type },
-            ),
-            None => tcx.emit_node_span_lint(
-                UNCOVERED_PARAM_IN_PROJECTION,
-                hir_id,
-                span,
-                errors::TyParamSomeLint { span, note: (), param: name },
-            ),
-        };
+    let descr = match kind {
+        UncoveredTyKind::TyParam(ident) => Some(("type parameter", ident.to_string())),
+        UncoveredTyKind::OpaqueTy(ty) => Some(("opaque type", ty.to_string())),
+        UncoveredTyKind::Unknown => None,
+    };
+
+    diag.code(rustc_errors::E0210);
+    diag.span_label(
+        span,
+        match descr {
+            Some((kind, _)) => format!("uncovered {kind}"),
+            None => "contains an uncovered type".into(),
+        },
+    );
+
+    let subject = match &descr {
+        Some((kind, ty)) => format!("{kind} `{ty}`"),
+        None => "type parameters and opaque types".into(),
+    };
+
+    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!("{subject} 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 or opaque types appear before that first local type"));
+        diag.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",
+        );
+    } else {
+        let example = descr.map(|(_, ty)| format!(" (e.g., `MyStruct<{ty}>`)")).unwrap_or_default();
+        diag.primary_message(format!(
+            "{subject} must be used as the argument to some local type{example}"
+        ));
+        diag.note(note);
+        diag.note(
+            "only traits defined in the current crate can be implemented for type parameters and opaque types"
+        );
     }
 }
 
-struct UncoveredTyParamCollector<'cx, 'tcx> {
+struct UncoveredTyCollector<'cx, 'tcx> {
     infcx: &'cx InferCtxt<'tcx>,
-    uncovered_params: FxIndexSet<DefId>,
+    uncovered: UncoveredTys<'tcx>,
 }
 
-impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for UncoveredTyParamCollector<'_, 'tcx> {
+impl<'tcx> TypeVisitor<TyCtxt<'tcx>> for UncoveredTyCollector<'_, 'tcx> {
     fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
-        if !ty.has_type_flags(ty::TypeFlags::HAS_TY_INFER) {
+        if !ty.has_type_flags(TypeFlags::HAS_TY_INFER | TypeFlags::HAS_TY_OPAQUE) {
             return;
         }
-        let ty::Infer(ty::TyVar(vid)) = *ty.kind() else {
-            return ty.super_visit_with(self);
-        };
-        let origin = self.infcx.type_var_origin(vid);
-        if let Some(def_id) = origin.param_def_id {
-            self.uncovered_params.insert(def_id);
+        match *ty.kind() {
+            ty::Infer(ty::TyVar(vid)) => {
+                if let Some(def_id) = self.infcx.type_var_origin(vid).param_def_id {
+                    let ident = self.infcx.tcx.item_ident(def_id);
+                    self.uncovered.insert(UncoveredTyKind::TyParam(ident));
+                }
+            }
+            // This only works with the old solver. With the next solver, alias types like opaque
+            // types structurally normalize to an infer var that is "unresolvable" under coherence.
+            // Furthermore, the orphan checker returns the unnormalized type in such cases (with
+            // exception like for `Fundamental<?opaque>`) which would be Weak for TAITs and
+            // Projection for ATPITs.
+            // FIXME(fmease): One solution I could see working would be to reintroduce
+            //                "TypeVarOriginKind::OpaqueTy(_)" and to stop OrphanChecker from
+            //                remapping to the unnormalized type at all.
+            // FIXME(fmease): Should we just let uncovered Opaques take precedence over
+            //                uncovered TyParams *inside* Opaques?
+            ty::Alias(ty::Opaque, alias) if !alias.has_type_flags(TypeFlags::HAS_TY_INFER) => {
+                self.uncovered.insert(UncoveredTyKind::OpaqueTy(ty));
+            }
+            _ => ty.super_visit_with(self),
         }
     }
 
     fn visit_const(&mut self, ct: ty::Const<'tcx>) -> Self::Result {
-        if ct.has_type_flags(ty::TypeFlags::HAS_TY_INFER) {
+        if ct.has_type_flags(TypeFlags::HAS_TY_INFER | TypeFlags::HAS_TY_OPAQUE) {
             ct.super_visit_with(self)
         }
     }
 }
+
+type UncoveredTys<'tcx> = FxIndexSet<UncoveredTyKind<'tcx>>;
+
+#[derive(PartialEq, Eq, Hash, Debug)]
+enum UncoveredTyKind<'tcx> {
+    TyParam(Ident),
+    OpaqueTy(Ty<'tcx>),
+    Unknown,
+}
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index f2560f22874bc..d271c9ef1092b 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -1365,56 +1365,6 @@ pub struct NoVariantNamed<'tcx> {
     pub ty: Ty<'tcx>,
 }
 
-// FIXME(fmease): Deduplicate:
-
-#[derive(Diagnostic)]
-#[diag(hir_analysis_ty_param_first_local, code = E0210)]
-#[note]
-pub(crate) struct TyParamFirstLocal<'tcx> {
-    #[primary_span]
-    #[label]
-    pub span: Span,
-    #[note(hir_analysis_case_note)]
-    pub note: (),
-    pub param: Ident,
-    pub local_type: Ty<'tcx>,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(hir_analysis_ty_param_first_local, code = E0210)]
-#[note]
-pub(crate) struct TyParamFirstLocalLint<'tcx> {
-    #[label]
-    pub span: Span,
-    #[note(hir_analysis_case_note)]
-    pub note: (),
-    pub param: Ident,
-    pub local_type: Ty<'tcx>,
-}
-
-#[derive(Diagnostic)]
-#[diag(hir_analysis_ty_param_some, code = E0210)]
-#[note]
-pub(crate) struct TyParamSome {
-    #[primary_span]
-    #[label]
-    pub span: Span,
-    #[note(hir_analysis_only_note)]
-    pub note: (),
-    pub param: Ident,
-}
-
-#[derive(LintDiagnostic)]
-#[diag(hir_analysis_ty_param_some, code = E0210)]
-#[note]
-pub(crate) struct TyParamSomeLint {
-    #[label]
-    pub span: Span,
-    #[note(hir_analysis_only_note)]
-    pub note: (),
-    pub param: Ident,
-}
-
 #[derive(Diagnostic)]
 pub(crate) enum OnlyCurrentTraits {
     #[diag(hir_analysis_only_current_traits_outside, code = E0117)]
diff --git a/compiler/rustc_next_trait_solver/src/coherence.rs b/compiler/rustc_next_trait_solver/src/coherence.rs
index f8215a228f5b6..bc0ccbe96d8c6 100644
--- a/compiler/rustc_next_trait_solver/src/coherence.rs
+++ b/compiler/rustc_next_trait_solver/src/coherence.rs
@@ -96,32 +96,24 @@ pub fn trait_ref_is_local_or_fundamental<I: Interner>(tcx: I, trait_ref: ty::Tra
     trait_ref.def_id.is_local() || tcx.trait_is_fundamental(trait_ref.def_id)
 }
 
-TrivialTypeTraversalImpls! { IsFirstInputType, }
+TrivialTypeTraversalImpls! { InSelfTy }
 
 #[derive(Debug, Copy, Clone)]
-pub enum IsFirstInputType {
+pub enum InSelfTy {
     No,
     Yes,
 }
 
-impl From<bool> for IsFirstInputType {
-    fn from(b: bool) -> IsFirstInputType {
-        match b {
-            false => IsFirstInputType::No,
-            true => IsFirstInputType::Yes,
-        }
-    }
-}
-
 #[derive_where(Debug; I: Interner, T: Debug)]
 pub enum OrphanCheckErr<I: Interner, T> {
-    NonLocalInputType(Vec<(I::Ty, IsFirstInputType)>),
-    UncoveredTyParams(UncoveredTyParams<I, T>),
+    NonLocalInputType(Vec<(I::Ty, InSelfTy)>),
+    UncoveredTy(UncoveredTy<I, T>),
 }
 
 #[derive_where(Debug; I: Interner, T: Debug)]
-pub struct UncoveredTyParams<I: Interner, T> {
+pub struct UncoveredTy<I: Interner, T> {
     pub uncovered: T,
+    pub in_self_ty: InSelfTy,
     pub local_ty: Option<I::Ty>,
 }
 
@@ -238,15 +230,16 @@ where
         ControlFlow::Continue(()) => Err(OrphanCheckErr::NonLocalInputType(checker.non_local_tys)),
         ControlFlow::Break(residual) => match residual {
             OrphanCheckEarlyExit::NormalizationFailure(err) => return Err(err),
-            OrphanCheckEarlyExit::UncoveredTyParam(ty) => {
+            OrphanCheckEarlyExit::UncoveredTy(ty, in_self_ty) => {
                 // Does there exist some local type after the `ParamTy`.
                 checker.search_first_local_ty = true;
                 let local_ty = match trait_ref.visit_with(&mut checker) {
                     ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(local_ty)) => Some(local_ty),
                     _ => None,
                 };
-                Err(OrphanCheckErr::UncoveredTyParams(UncoveredTyParams {
+                Err(OrphanCheckErr::UncoveredTy(UncoveredTy {
                     uncovered: ty,
+                    in_self_ty,
                     local_ty,
                 }))
             }
@@ -258,11 +251,11 @@ where
 struct OrphanChecker<'a, Infcx, I: Interner, F> {
     infcx: &'a Infcx,
     in_crate: InCrate,
-    in_self_ty: bool,
+    in_self_ty: InSelfTy,
     lazily_normalize_ty: F,
     /// Ignore orphan check failures and exclusively search for the first local type.
     search_first_local_ty: bool,
-    non_local_tys: Vec<(I::Ty, IsFirstInputType)>,
+    non_local_tys: Vec<(I::Ty, InSelfTy)>,
 }
 
 impl<'a, Infcx, I, F, E> OrphanChecker<'a, Infcx, I, F>
@@ -275,7 +268,7 @@ where
         OrphanChecker {
             infcx,
             in_crate,
-            in_self_ty: true,
+            in_self_ty: InSelfTy::Yes,
             lazily_normalize_ty,
             search_first_local_ty: false,
             non_local_tys: Vec::new(),
@@ -283,16 +276,16 @@ where
     }
 
     fn found_non_local_ty(&mut self, t: I::Ty) -> ControlFlow<OrphanCheckEarlyExit<I, E>> {
-        self.non_local_tys.push((t, self.in_self_ty.into()));
+        self.non_local_tys.push((t, self.in_self_ty));
         ControlFlow::Continue(())
     }
 
-    fn found_uncovered_ty_param(&mut self, ty: I::Ty) -> ControlFlow<OrphanCheckEarlyExit<I, E>> {
+    fn found_uncovered_ty(&mut self, ty: I::Ty) -> ControlFlow<OrphanCheckEarlyExit<I, E>> {
         if self.search_first_local_ty {
             return ControlFlow::Continue(());
         }
 
-        ControlFlow::Break(OrphanCheckEarlyExit::UncoveredTyParam(ty))
+        ControlFlow::Break(OrphanCheckEarlyExit::UncoveredTy(ty, self.in_self_ty))
     }
 
     fn def_id_is_local(&mut self, def_id: I::DefId) -> bool {
@@ -305,7 +298,7 @@ where
 
 enum OrphanCheckEarlyExit<I: Interner, E> {
     NormalizationFailure(E),
-    UncoveredTyParam(I::Ty),
+    UncoveredTy(I::Ty, InSelfTy),
     LocalTy(I::Ty),
 }
 
@@ -324,6 +317,7 @@ where
     fn visit_ty(&mut self, ty: I::Ty) -> Self::Result {
         let ty = self.infcx.shallow_resolve(ty);
         let ty = match (self.lazily_normalize_ty)(ty) {
+            // FIXME(fmease): Explain why.
             Ok(norm_ty) if norm_ty.is_ty_var() => ty,
             Ok(norm_ty) => norm_ty,
             Err(err) => return ControlFlow::Break(OrphanCheckEarlyExit::NormalizationFailure(err)),
@@ -349,62 +343,36 @@ where
 
             ty::Param(..) => panic!("unexpected ty param"),
 
+            // FIXME(fmease): Mention here or at the top of the function that infer vars may
+            //               correspond to ty params and opaque tys
             ty::Placeholder(..) | ty::Bound(..) | ty::Infer(..) => {
                 match self.in_crate {
-                    InCrate::Local { .. } => self.found_uncovered_ty_param(ty),
+                    InCrate::Local { .. } => self.found_uncovered_ty(ty),
                     // The inference variable might be unified with a local
                     // type in that remote crate.
                     InCrate::Remote => ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty)),
                 }
             }
 
+            // FIXME(fmease): Update comments.
             // A rigid alias may normalize to anything.
             // * If it references an infer var, placeholder or bound ty, it may
             //   normalize to that, so we have to treat it as an uncovered ty param.
             // * Otherwise it may normalize to any non-type-generic type
             //   be it local or non-local.
+            // FIXME(fmease): Go more in-depth for opaque types (→composability, ...).
             ty::Alias(kind, _) => {
-                if ty.has_type_flags(
-                    ty::TypeFlags::HAS_TY_PLACEHOLDER
-                        | ty::TypeFlags::HAS_TY_BOUND
-                        | ty::TypeFlags::HAS_TY_INFER,
-                ) {
-                    match self.in_crate {
-                        InCrate::Local { mode } => match kind {
-                            ty::Projection => {
-                                if let OrphanCheckMode::Compat = mode {
-                                    ControlFlow::Continue(())
-                                } else {
-                                    self.found_uncovered_ty_param(ty)
-                                }
-                            }
-                            _ => self.found_uncovered_ty_param(ty),
-                        },
-                        InCrate::Remote => {
-                            // The inference variable might be unified with a local
-                            // type in that remote crate.
-                            ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
-                        }
+                match self.in_crate {
+                    InCrate::Local { mode } => match (kind, mode) {
+                        (ty::Projection, OrphanCheckMode::Compat) => ControlFlow::Continue(()),
+                        _ => self.found_uncovered_ty(ty),
+                    },
+                    InCrate::Remote => {
+                        // FIXME(fmease): Update comment.
+                        // The inference variable might be unified with a local
+                        // type in that remote crate.
+                        ControlFlow::Break(OrphanCheckEarlyExit::LocalTy(ty))
                     }
-                } else {
-                    // Regarding *opaque types* specifically, we choose to treat them as non-local,
-                    // even those that appear within the same crate. This seems somewhat surprising
-                    // at first, but makes sense when you consider that opaque types are supposed
-                    // to hide the underlying type *within the same crate*. When an opaque type is
-                    // used from outside the module where it is declared, it should be impossible to
-                    // observe anything about it other than the traits that it implements.
-                    //
-                    // The alternative would be to look at the underlying type to determine whether
-                    // or not the opaque type itself should be considered local.
-                    //
-                    // However, this could make it a breaking change to switch the underlying hidden
-                    // type from a local type to a remote type. This would violate the rule that
-                    // opaque types should be completely opaque apart from the traits that they
-                    // implement, so we don't use this behavior.
-                    // Addendum: Moreover, revealing the underlying type is likely to cause cycle
-                    // errors as we rely on coherence / the specialization graph during typeck.
-
-                    self.found_non_local_ty(ty)
                 }
             }
 
@@ -449,7 +417,7 @@ where
         };
         // A bit of a hack, the `OrphanChecker` is only used to visit a `TraitRef`, so
         // the first type we visit is always the self type.
-        self.in_self_ty = false;
+        self.in_self_ty = InSelfTy::No;
         result
     }
 
diff --git a/compiler/rustc_trait_selection/src/traits/mod.rs b/compiler/rustc_trait_selection/src/traits/mod.rs
index de337710b5ef7..ad668290b7fbf 100644
--- a/compiler/rustc_trait_selection/src/traits/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/mod.rs
@@ -41,7 +41,7 @@ use rustc_span::{DUMMY_SP, Span};
 use tracing::{debug, instrument};
 
 pub use self::coherence::{
-    InCrate, IsFirstInputType, OrphanCheckErr, OrphanCheckMode, OverlapResult, UncoveredTyParams,
+    InCrate, InSelfTy, OrphanCheckErr, OrphanCheckMode, OverlapResult, UncoveredTy,
     add_placeholder_note, orphan_check_trait_ref, overlapping_impls,
 };
 pub use self::dyn_compatibility::{
diff --git a/compiler/rustc_type_ir/src/macros.rs b/compiler/rustc_type_ir/src/macros.rs
index c8c293121ca0a..0e609b43d9784 100644
--- a/compiler/rustc_type_ir/src/macros.rs
+++ b/compiler/rustc_type_ir/src/macros.rs
@@ -2,7 +2,7 @@
 /// allocated data** (i.e., don't need to be folded).
 #[macro_export]
 macro_rules! TrivialTypeTraversalImpls {
-    ($($ty:ty,)+) => {
+    ($($ty:ty),+ $(,)?) => {
         $(
             impl<I: $crate::Interner> $crate::TypeFoldable<I> for $ty {
                 fn try_fold_with<F: $crate::FallibleTypeFolder<I>>(
diff --git a/tests/crashes/136188.rs b/tests/crashes/136188.rs
deleted file mode 100644
index a701fc4c0b74f..0000000000000
--- a/tests/crashes/136188.rs
+++ /dev/null
@@ -1,9 +0,0 @@
-//@ known-bug: #136188
-//@ compile-flags: --crate-type=lib -Znext-solver
-#![feature(type_alias_impl_trait)]
-
-type Opaque = Box<impl Sized>;
-
-fn define() -> Opaque { Box::new(()) }
-
-impl Copy for Opaque {}
diff --git a/tests/ui/coherence/coherence-all-remote.stderr b/tests/ui/coherence/coherence-all-remote.stderr
index 0cf9f87b40ac7..9fc78129ac824 100644
--- a/tests/ui/coherence/coherence-all-remote.stderr
+++ b/tests/ui/coherence/coherence-all-remote.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/coherence-all-remote.rs:6:6
    |
 LL | impl<T> Remote1<T> for isize { }
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/coherence-bigint-param.stderr b/tests/ui/coherence/coherence-bigint-param.stderr
index e6c77624a8e8d..15cb29e3e08f1 100644
--- a/tests/ui/coherence/coherence-bigint-param.stderr
+++ b/tests/ui/coherence/coherence-bigint-param.stderr
@@ -2,10 +2,11 @@ error[E0210]: type parameter `T` must be covered by another type when it appears
   --> $DIR/coherence-bigint-param.rs:8:6
    |
 LL | impl<T> Remote1<BigInt> for T { }
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`BigInt`)
+   |      ^ uncovered type parameter
    |
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/coherence-cross-crate-conflict.stderr b/tests/ui/coherence/coherence-cross-crate-conflict.stderr
index 812ce97721ccf..d4fe67a79a003 100644
--- a/tests/ui/coherence/coherence-cross-crate-conflict.stderr
+++ b/tests/ui/coherence/coherence-cross-crate-conflict.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `A` must be used as the type parameter for some local type (e.g., `MyStruct<A>`)
+error[E0210]: type parameter `A` must be used as the argument to some local type (e.g., `MyStruct<A>`)
   --> $DIR/coherence-cross-crate-conflict.rs:9:6
    |
 LL | impl<A> Foo for A {
-   |      ^ type parameter `A` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/coherence-lone-type-parameter.stderr b/tests/ui/coherence/coherence-lone-type-parameter.stderr
index 48d25bba8d714..2a59b72017d75 100644
--- a/tests/ui/coherence/coherence-lone-type-parameter.stderr
+++ b/tests/ui/coherence/coherence-lone-type-parameter.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/coherence-lone-type-parameter.rs:6:6
    |
 LL | impl<T> Remote for T { }
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].rs b/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].rs
index d9616b9adda79..6038da43867db 100644
--- a/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].rs
+++ b/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].rs
@@ -8,7 +8,7 @@ use std::rc::Rc;
 struct Local;
 
 impl<T> Remote for Box<T> {
-    //~^ ERROR type parameter `T` must be used as the type parameter for
+    //~^ ERROR type parameter `T` must be used as the argument to
     // | some local type (e.g., `MyStruct<T>`)
 }
 
diff --git a/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr b/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr
index 12d9a807f492d..6a87d2b56e1ff 100644
--- a/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr
+++ b/tests/ui/coherence/impl[t]-foreign-for-fundamental[t].stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign-for-fundamental[t].rs:10:6
    |
 LL | impl<T> Remote for Box<T> {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/impl[t]-foreign[foreign]-for-fundamental[t].rs b/tests/ui/coherence/impl[t]-foreign[foreign]-for-fundamental[t].rs
index 9d4440ba4866a..de8277a2d0eb8 100644
--- a/tests/ui/coherence/impl[t]-foreign[foreign]-for-fundamental[t].rs
+++ b/tests/ui/coherence/impl[t]-foreign[foreign]-for-fundamental[t].rs
@@ -8,11 +8,11 @@ use std::rc::Rc;
 struct Local;
 
 impl<T> Remote1<u32> for Box<T> {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 impl<'a, T> Remote1<u32> for &'a T {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/impl[t]-foreign[foreign]-for-fundamental[t].stderr b/tests/ui/coherence/impl[t]-foreign[foreign]-for-fundamental[t].stderr
index 95a20cc5b0f5c..848a3affee71d 100644
--- a/tests/ui/coherence/impl[t]-foreign[foreign]-for-fundamental[t].stderr
+++ b/tests/ui/coherence/impl[t]-foreign[foreign]-for-fundamental[t].stderr
@@ -1,20 +1,20 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[foreign]-for-fundamental[t].rs:10:6
    |
 LL | impl<T> Remote1<u32> for Box<T> {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[foreign]-for-fundamental[t].rs:14:10
    |
 LL | impl<'a, T> Remote1<u32> for &'a T {
-   |          ^ type parameter `T` must be used as the type parameter for some local type
+   |          ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.rs b/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.rs
index 533f0892b98fe..dca73fdcd64d6 100644
--- a/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.rs
+++ b/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.rs
@@ -8,7 +8,7 @@ use std::rc::Rc;
 struct Local;
 
 impl<T> Remote1<u32> for T {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr b/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr
index 6ca3ccd05febc..025b2fc4a935c 100644
--- a/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[foreign]-for-t.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[foreign]-for-t.rs:10:6
    |
 LL | impl<T> Remote1<u32> for T {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-foreign.rs b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-foreign.rs
index 02731052a6a96..3cc83190c7ce8 100644
--- a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-foreign.rs
+++ b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-foreign.rs
@@ -8,11 +8,11 @@ use std::rc::Rc;
 struct Local;
 
 impl<T> Remote1<Box<T>> for u32 {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 impl<'a, T> Remote1<&'a T> for u32 {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-foreign.stderr b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-foreign.stderr
index 73b1e2c6ed248..0a35611fea44d 100644
--- a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-foreign.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-foreign.stderr
@@ -1,20 +1,20 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[fundamental[t]]-for-foreign.rs:10:6
    |
 LL | impl<T> Remote1<Box<T>> for u32 {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[fundamental[t]]-for-foreign.rs:14:10
    |
 LL | impl<'a, T> Remote1<&'a T> for u32 {
-   |          ^ type parameter `T` must be used as the type parameter for some local type
+   |          ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-fundamental[t].rs b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-fundamental[t].rs
index 7c94fd80af2f2..817476f8ca3f5 100644
--- a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-fundamental[t].rs
+++ b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-fundamental[t].rs
@@ -8,10 +8,10 @@ use std::rc::Rc;
 struct Local;
 
 impl<'a, T> Remote1<Box<T>> for &'a T {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 impl<'a, T> Remote1<&'a T> for Box<T> {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-fundamental[t].stderr b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-fundamental[t].stderr
index 5f89a7aa469c1..a7eec56ddbed2 100644
--- a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-fundamental[t].stderr
+++ b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-fundamental[t].stderr
@@ -1,20 +1,20 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[fundamental[t]]-for-fundamental[t].rs:10:10
    |
 LL | impl<'a, T> Remote1<Box<T>> for &'a T {
-   |          ^ type parameter `T` must be used as the type parameter for some local type
+   |          ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[fundamental[t]]-for-fundamental[t].rs:13:10
    |
 LL | impl<'a, T> Remote1<&'a T> for Box<T> {
-   |          ^ type parameter `T` must be used as the type parameter for some local type
+   |          ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-t.rs b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-t.rs
index d998731687c4f..c7f7cc8dcfe7e 100644
--- a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-t.rs
+++ b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-t.rs
@@ -8,10 +8,10 @@ use std::rc::Rc;
 struct Local;
 
 impl<T> Remote1<Box<T>> for T {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 impl<'a, T> Remote1<&'a T> for T {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-t.stderr b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-t.stderr
index 45559d8b62d37..bf35cc56ae71c 100644
--- a/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-t.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[fundamental[t]]-for-t.stderr
@@ -1,20 +1,20 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[fundamental[t]]-for-t.rs:10:6
    |
 LL | impl<T> Remote1<Box<T>> for T {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[fundamental[t]]-for-t.rs:13:10
    |
 LL | impl<'a, T> Remote1<&'a T> for T {
-   |          ^ type parameter `T` must be used as the type parameter for some local type
+   |          ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/coherence/impl[t]-foreign[fundamental[t]_local]-for-foreign.stderr b/tests/ui/coherence/impl[t]-foreign[fundamental[t]_local]-for-foreign.stderr
index f94f04c8df5c1..7e6a1b0744622 100644
--- a/tests/ui/coherence/impl[t]-foreign[fundamental[t]_local]-for-foreign.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[fundamental[t]_local]-for-foreign.stderr
@@ -2,19 +2,21 @@ error[E0210]: type parameter `T` must be covered by another type when it appears
   --> $DIR/impl[t]-foreign[fundamental[t]_local]-for-foreign.rs:10:6
    |
 LL | impl<T> Remote2<Box<T>, Local> for u32 {
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 error[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
   --> $DIR/impl[t]-foreign[fundamental[t]_local]-for-foreign.rs:14:10
    |
 LL | impl<'a, T> Remote2<&'a T, Local> for u32 {
-   |          ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |          ^ uncovered type parameter
    |
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/coherence/impl[t]-foreign[local]-for-fundamental[t].stderr b/tests/ui/coherence/impl[t]-foreign[local]-for-fundamental[t].stderr
index e68f2fe585637..af07cacf1eca0 100644
--- a/tests/ui/coherence/impl[t]-foreign[local]-for-fundamental[t].stderr
+++ b/tests/ui/coherence/impl[t]-foreign[local]-for-fundamental[t].stderr
@@ -2,19 +2,21 @@ error[E0210]: type parameter `T` must be covered by another type when it appears
   --> $DIR/impl[t]-foreign[local]-for-fundamental[t].rs:10:6
    |
 LL | impl<T> Remote1<Local> for Box<T> {
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 error[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
   --> $DIR/impl[t]-foreign[local]-for-fundamental[t].rs:14:6
    |
 LL | impl<T> Remote1<Local> for &T {
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr b/tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr
index 1f3463e88371b..988b6aafa3c7c 100644
--- a/tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[local]-for-t.stderr
@@ -2,10 +2,11 @@ error[E0210]: type parameter `T` must be covered by another type when it appears
   --> $DIR/impl[t]-foreign[local]-for-t.rs:10:6
    |
 LL | impl<T> Remote1<Local> for T {
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.rs b/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.rs
index c23a2d87a695c..1e579d543f551 100644
--- a/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.rs
+++ b/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.rs
@@ -8,7 +8,7 @@ use std::rc::Rc;
 struct Local;
 
 impl<T> Remote1<T> for u32 {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr b/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr
index a1f3936497e65..7114c041c2cc8 100644
--- a/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[t]-for-foreign.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[t]-for-foreign.rs:10:6
    |
 LL | impl<T> Remote1<T> for u32 {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/impl[t]-foreign[t]-for-fundamental.rs b/tests/ui/coherence/impl[t]-foreign[t]-for-fundamental.rs
index e9426e5127a04..3d4b363345155 100644
--- a/tests/ui/coherence/impl[t]-foreign[t]-for-fundamental.rs
+++ b/tests/ui/coherence/impl[t]-foreign[t]-for-fundamental.rs
@@ -8,11 +8,11 @@ use std::rc::Rc;
 struct Local;
 
 impl<T> Remote1<T> for Box<T> {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 impl<'a, A, B> Remote1<A> for &'a B {
-    //~^ ERROR type parameter `B` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `B` must be used as the argument to some local type
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/impl[t]-foreign[t]-for-fundamental.stderr b/tests/ui/coherence/impl[t]-foreign[t]-for-fundamental.stderr
index 80fb5dbec8662..c588631e95601 100644
--- a/tests/ui/coherence/impl[t]-foreign[t]-for-fundamental.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[t]-for-fundamental.stderr
@@ -1,20 +1,20 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[t]-for-fundamental.rs:10:6
    |
 LL | impl<T> Remote1<T> for Box<T> {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
-error[E0210]: type parameter `B` must be used as the type parameter for some local type (e.g., `MyStruct<B>`)
+error[E0210]: type parameter `B` must be used as the argument to some local type (e.g., `MyStruct<B>`)
   --> $DIR/impl[t]-foreign[t]-for-fundamental.rs:14:13
    |
 LL | impl<'a, A, B> Remote1<A> for &'a B {
-   |             ^ type parameter `B` must be used as the type parameter for some local type
+   |             ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/coherence/impl[t]-foreign[t]-for-t.rs b/tests/ui/coherence/impl[t]-foreign[t]-for-t.rs
index 9c3e82ad762f0..3bd59972d3049 100644
--- a/tests/ui/coherence/impl[t]-foreign[t]-for-t.rs
+++ b/tests/ui/coherence/impl[t]-foreign[t]-for-t.rs
@@ -8,7 +8,7 @@ use std::rc::Rc;
 struct Local;
 
 impl<T> Remote1<T> for T {
-    //~^ ERROR type parameter `T` must be used as the type parameter for some local type
+    //~^ ERROR type parameter `T` must be used as the argument to some local type
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr b/tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr
index acd84f7115f57..0ab46386bd5fc 100644
--- a/tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr
+++ b/tests/ui/coherence/impl[t]-foreign[t]-for-t.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/impl[t]-foreign[t]-for-t.rs:10:6
    |
 LL | impl<T> Remote1<T> for T {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/orphan-check-alias.classic.stderr b/tests/ui/coherence/orphan-check-alias.classic.stderr
index 3fd62b05b4df0..efa8868fa9dbb 100644
--- a/tests/ui/coherence/orphan-check-alias.classic.stderr
+++ b/tests/ui/coherence/orphan-check-alias.classic.stderr
@@ -2,12 +2,13 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-alias.rs:21:6
    |
 LL | impl<T> foreign::Trait2<B, T> for <T as Id>::Assoc {
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`B`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/orphan-check-alias.next.stderr b/tests/ui/coherence/orphan-check-alias.next.stderr
index 3fd62b05b4df0..efa8868fa9dbb 100644
--- a/tests/ui/coherence/orphan-check-alias.next.stderr
+++ b/tests/ui/coherence/orphan-check-alias.next.stderr
@@ -2,12 +2,13 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-alias.rs:21:6
    |
 LL | impl<T> foreign::Trait2<B, T> for <T as Id>::Assoc {
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`B`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/orphan-check-diagnostics.rs b/tests/ui/coherence/orphan-check-diagnostics.rs
index 4b6557fc9c8e9..9e5525800707f 100644
--- a/tests/ui/coherence/orphan-check-diagnostics.rs
+++ b/tests/ui/coherence/orphan-check-diagnostics.rs
@@ -9,6 +9,6 @@ use orphan_check_diagnostics::RemoteTrait;
 trait LocalTrait { fn dummy(&self) { } }
 
 impl<T> RemoteTrait for T where T: LocalTrait {}
-//~^ ERROR type parameter `T` must be used as the type parameter for some local type
+//~^ ERROR type parameter `T` must be used as the argument to some local type
 
 fn main() {}
diff --git a/tests/ui/coherence/orphan-check-diagnostics.stderr b/tests/ui/coherence/orphan-check-diagnostics.stderr
index b9fa7baf4c276..6f7068c65d2b7 100644
--- a/tests/ui/coherence/orphan-check-diagnostics.stderr
+++ b/tests/ui/coherence/orphan-check-diagnostics.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/orphan-check-diagnostics.rs:11:6
    |
 LL | impl<T> RemoteTrait for T where T: LocalTrait {}
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/orphan-check-opaque-types-not-covering.current.stderr b/tests/ui/coherence/orphan-check-opaque-types-not-covering.current.stderr
new file mode 100644
index 0000000000000..43a678422bd66
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-not-covering.current.stderr
@@ -0,0 +1,23 @@
+error[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-not-covering.rs:18:6
+   |
+LL | impl<T> foreign::Trait0<Local, T, ()> for Identity<T> {}
+   |      ^ uncovered type parameter
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-not-covering.rs:28:6
+   |
+LL | impl<T> foreign::Trait1<Local, T> for Opaque<T> {}
+   |      ^ uncovered type parameter
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/orphan-check-opaque-types-not-covering.next.stderr b/tests/ui/coherence/orphan-check-opaque-types-not-covering.next.stderr
new file mode 100644
index 0000000000000..43a678422bd66
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-not-covering.next.stderr
@@ -0,0 +1,23 @@
+error[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-not-covering.rs:18:6
+   |
+LL | impl<T> foreign::Trait0<Local, T, ()> for Identity<T> {}
+   |      ^ uncovered type parameter
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-not-covering.rs:28:6
+   |
+LL | impl<T> foreign::Trait1<Local, T> for Opaque<T> {}
+   |      ^ uncovered type parameter
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/orphan-check-opaque-types-not-covering.rs b/tests/ui/coherence/orphan-check-opaque-types-not-covering.rs
index ea91933e6949e..b484b6350bb8b 100644
--- a/tests/ui/coherence/orphan-check-opaque-types-not-covering.rs
+++ b/tests/ui/coherence/orphan-check-opaque-types-not-covering.rs
@@ -2,6 +2,9 @@
 
 //@ aux-crate:foreign=parametrized-trait.rs
 //@ edition:2021
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
 
 #![feature(type_alias_impl_trait)]
 
diff --git a/tests/ui/coherence/orphan-check-opaque-types-not-covering.stderr b/tests/ui/coherence/orphan-check-opaque-types-not-covering.stderr
deleted file mode 100644
index 6203742b47c0a..0000000000000
--- a/tests/ui/coherence/orphan-check-opaque-types-not-covering.stderr
+++ /dev/null
@@ -1,21 +0,0 @@
-error[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
-  --> $DIR/orphan-check-opaque-types-not-covering.rs:15:6
-   |
-LL | impl<T> foreign::Trait0<Local, T, ()> for Identity<T> {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
-   |
-   = 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
-   = 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
-
-error[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
-  --> $DIR/orphan-check-opaque-types-not-covering.rs:25:6
-   |
-LL | impl<T> foreign::Trait1<Local, T> for Opaque<T> {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
-   |
-   = 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
-   = 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
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.current.stderr b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.current.stderr
new file mode 100644
index 0000000000000..1d57e30751929
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.current.stderr
@@ -0,0 +1,42 @@
+error[E0210]: opaque type `Opaque0` must be used as the argument to some local type (e.g., `MyStruct<Opaque0>`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-000.rs:12:34
+   |
+LL | impl foreign::Trait1<(), ()> for Opaque0 {}
+   |                                  ^^^^^^^ uncovered opaque type
+   |
+   = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
+
+error[E0210]: opaque type `Opaque0` must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-000.rs:18:37
+   |
+LL | impl foreign::Trait1<Local, ()> for Opaque0 {}
+   |                                     ^^^^^^^ uncovered opaque type
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error[E0210]: opaque type `Opaque0` must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-000.rs:24:37
+   |
+LL | impl foreign::Trait1<(), Local> for Fundamental<Opaque0> {}
+   |                                     ^^^^^^^^^^^^^^^^^^^^ uncovered opaque type
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error[E0210]: opaque type `Opaque1::{opaque#0}` must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-000.rs:32:40
+   |
+LL | impl foreign::Trait1<Local, Local> for Opaque1 {}
+   |                                        ^^^^^^^ uncovered opaque type
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.next.stderr b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.next.stderr
new file mode 100644
index 0000000000000..e6cc9c6a41ca8
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.next.stderr
@@ -0,0 +1,42 @@
+error[E0210]: type parameters and opaque types must be used as the argument to some local type
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-000.rs:12:34
+   |
+LL | impl foreign::Trait1<(), ()> for Opaque0 {}
+   |                                  ^^^^^^^ contains an uncovered type
+   |
+   = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
+
+error[E0210]: type parameters and opaque types must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-000.rs:18:37
+   |
+LL | impl foreign::Trait1<Local, ()> for Opaque0 {}
+   |                                     ^^^^^^^ contains an uncovered type
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error[E0210]: type parameters and opaque types must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-000.rs:24:37
+   |
+LL | impl foreign::Trait1<(), Local> for Fundamental<Opaque0> {}
+   |                                     ^^^^^^^^^^^^^^^^^^^^ contains an uncovered type
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error[E0210]: type parameters and opaque types must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-000.rs:32:40
+   |
+LL | impl foreign::Trait1<Local, Local> for Opaque1 {}
+   |                                        ^^^^^^^ contains an uncovered type
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.rs b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.rs
new file mode 100644
index 0000000000000..ee0e93ade5199
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-000.rs
@@ -0,0 +1,36 @@
+//@ aux-crate:foreign=parametrized-trait.rs
+//@ edition:2021
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+
+#![feature(type_alias_impl_trait)]
+
+type Opaque0 = impl Sized;
+#[define_opaque(Opaque0)] fn define0() -> Opaque0 { 0i32 }
+
+impl foreign::Trait1<(), ()> for Opaque0 {}
+//[current]~^ ERROR opaque type `Opaque0` must be used as the argument to some local type
+//[next]~^^ ERROR type parameters and opaque types must be used as the argument to some local type
+
+struct Local;
+
+impl foreign::Trait1<Local, ()> for Opaque0 {}
+//[current]~^ ERROR opaque type `Opaque0` must be covered by another type when it appears before the first local type
+//[next]~^^ ERROR type parameters and opaque types must be covered by another type when it appears before the first local type
+
+type Fundamental<T> = Box<T>; // or any other fundamental type constructor
+
+impl foreign::Trait1<(), Local> for Fundamental<Opaque0> {}
+//[current]~^ ERROR opaque type `Opaque0` must be covered by another type when it appears before the first local type
+//[next]~^^ ERROR type parameters and opaque types must be covered by another type when it appears before the first local type
+
+type Opaque1 = Fundamental<impl Sized>;
+#[define_opaque(Opaque1)] fn define1() -> Opaque1 { Fundamental::new(()) }
+
+// Regression test for <https://github.com/rust-lang/rust/issues/136188>.
+impl foreign::Trait1<Local, Local> for Opaque1 {}
+//[current]~^ ERROR opaque type `Opaque1::{opaque#0}` must be covered by another type when it appears before the first local type
+//[next]~^^ ERROR type parameters and opaque types must be covered by another type when it appears before the first local type
+
+fn main() {}
diff --git a/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.current.stderr b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.current.stderr
new file mode 100644
index 0000000000000..8d8924831db82
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.current.stderr
@@ -0,0 +1,13 @@
+error[E0210]: opaque type `<() as Owner>::Opaque` must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-001.rs:14:37
+   |
+LL | impl foreign::Trait1<Local, ()> for <() as Owner>::Opaque {}
+   |                                     ^^^^^^^^^^^^^^^^^^^^^ uncovered opaque type
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.next.stderr b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.next.stderr
new file mode 100644
index 0000000000000..6edb644eed26a
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.next.stderr
@@ -0,0 +1,13 @@
+error[E0210]: type parameters and opaque types must be covered by another type when it appears before the first local type (`Local`)
+  --> $DIR/orphan-check-opaque-types-xxx-xxx-001.rs:14:37
+   |
+LL | impl foreign::Trait1<Local, ()> for <() as Owner>::Opaque {}
+   |                                     ^^^^^^^^^^^^^^^^^^^^^ contains an uncovered type
+   |
+   = 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 or opaque types appear before that first local type
+   = 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
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.rs b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.rs
new file mode 100644
index 0000000000000..5929be8aecfd9
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-001.rs
@@ -0,0 +1,18 @@
+//@ aux-crate:foreign=parametrized-trait.rs
+//@ edition:2021
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+
+#![feature(impl_trait_in_assoc_type)]
+
+trait Owner { type Opaque; fn define() -> Self::Opaque; }
+impl Owner for () { type Opaque = impl Sized; fn define() -> Self::Opaque { 0i32 } }
+
+struct Local;
+
+impl foreign::Trait1<Local, ()> for <() as Owner>::Opaque {}
+//[current]~^ ERROR opaque type `<() as Owner>::Opaque` must be covered by another type when it appears before the first local type
+//[next]~^^ ERROR type parameters and opaque types must be covered by another type when it appears before the first local type
+
+fn main() {}
diff --git a/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-002.rs b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-002.rs
new file mode 100644
index 0000000000000..81ae303bb58c0
--- /dev/null
+++ b/tests/ui/coherence/orphan-check-opaque-types-xxx-xxx-002.rs
@@ -0,0 +1,21 @@
+//@ aux-crate:foreign=parametrized-trait.rs
+//@ edition:2021
+//@ revisions: current next
+//@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@ check-pass
+
+#![feature(type_alias_impl_trait, impl_trait_in_assoc_type)]
+
+struct Cover<T>(T);
+
+type Opaque = impl Sized;
+#[define_opaque(Opaque)] fn define() -> Opaque { 0i32 }
+
+trait Owner { type Opaque; fn define() -> Self::Opaque; }
+impl Owner for () { type Opaque = impl Sized; fn define() -> Self::Opaque { 0i32 } }
+
+impl foreign::Trait0<(), (), ()> for Cover<Opaque> {}
+impl foreign::Trait1<(), ()> for Cover<<() as Owner>::Opaque> {}
+
+fn main() {}
diff --git a/tests/ui/coherence/orphan-check-projections-not-covering-ambiguity.classic.stderr b/tests/ui/coherence/orphan-check-projections-not-covering-ambiguity.classic.stderr
index d83a56c0bd0ea..ca9e7639a0f83 100644
--- a/tests/ui/coherence/orphan-check-projections-not-covering-ambiguity.classic.stderr
+++ b/tests/ui/coherence/orphan-check-projections-not-covering-ambiguity.classic.stderr
@@ -2,12 +2,13 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-projections-not-covering-ambiguity.rs:25:6
    |
 LL | impl<T> foreign::Trait1<Local, T> for <T as Project>::Output {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/orphan-check-projections-not-covering-ambiguity.next.stderr b/tests/ui/coherence/orphan-check-projections-not-covering-ambiguity.next.stderr
index d83a56c0bd0ea..ca9e7639a0f83 100644
--- a/tests/ui/coherence/orphan-check-projections-not-covering-ambiguity.next.stderr
+++ b/tests/ui/coherence/orphan-check-projections-not-covering-ambiguity.next.stderr
@@ -2,12 +2,13 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-projections-not-covering-ambiguity.rs:25:6
    |
 LL | impl<T> foreign::Trait1<Local, T> for <T as Project>::Output {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/orphan-check-projections-not-covering-multiple-params.classic.stderr b/tests/ui/coherence/orphan-check-projections-not-covering-multiple-params.classic.stderr
index 8964fefedd490..fd368c51a62fc 100644
--- a/tests/ui/coherence/orphan-check-projections-not-covering-multiple-params.classic.stderr
+++ b/tests/ui/coherence/orphan-check-projections-not-covering-multiple-params.classic.stderr
@@ -2,24 +2,26 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-projections-not-covering-multiple-params.rs:17:6
    |
 LL | impl<T, U> foreign::Trait0<LocalTy, T, U> for <() as Trait<T, U>>::Assoc {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`LocalTy`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning[E0210]: type parameter `U` must be covered by another type when it appears before the first local type (`LocalTy`)
   --> $DIR/orphan-check-projections-not-covering-multiple-params.rs:17:9
    |
 LL | impl<T, U> foreign::Trait0<LocalTy, T, U> for <() as Trait<T, U>>::Assoc {}
-   |         ^ type parameter `U` must be covered by another type when it appears before the first local type (`LocalTy`)
+   |         ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 warning: 2 warnings emitted
 
diff --git a/tests/ui/coherence/orphan-check-projections-not-covering-multiple-params.next.stderr b/tests/ui/coherence/orphan-check-projections-not-covering-multiple-params.next.stderr
index 8964fefedd490..fd368c51a62fc 100644
--- a/tests/ui/coherence/orphan-check-projections-not-covering-multiple-params.next.stderr
+++ b/tests/ui/coherence/orphan-check-projections-not-covering-multiple-params.next.stderr
@@ -2,24 +2,26 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-projections-not-covering-multiple-params.rs:17:6
    |
 LL | impl<T, U> foreign::Trait0<LocalTy, T, U> for <() as Trait<T, U>>::Assoc {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`LocalTy`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning[E0210]: type parameter `U` must be covered by another type when it appears before the first local type (`LocalTy`)
   --> $DIR/orphan-check-projections-not-covering-multiple-params.rs:17:9
    |
 LL | impl<T, U> foreign::Trait0<LocalTy, T, U> for <() as Trait<T, U>>::Assoc {}
-   |         ^ type parameter `U` must be covered by another type when it appears before the first local type (`LocalTy`)
+   |         ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 warning: 2 warnings emitted
 
diff --git a/tests/ui/coherence/orphan-check-projections-not-covering.classic.stderr b/tests/ui/coherence/orphan-check-projections-not-covering.classic.stderr
index 28b8c3f4a94bc..791ac9f5944b4 100644
--- a/tests/ui/coherence/orphan-check-projections-not-covering.classic.stderr
+++ b/tests/ui/coherence/orphan-check-projections-not-covering.classic.stderr
@@ -2,35 +2,38 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-projections-not-covering.rs:22:6
    |
 LL | impl<T> foreign::Trait0<Local, T, ()> for <T as Identity>::Output {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
   --> $DIR/orphan-check-projections-not-covering.rs:27:6
    |
 LL | impl<T> foreign::Trait0<<T as Identity>::Output, Local, T> for Option<T> {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 warning[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
   --> $DIR/orphan-check-projections-not-covering.rs:40:6
    |
 LL | impl<T: Deferred> foreign::Trait1<Local, T> for <T as Deferred>::Output {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 warning: 3 warnings emitted
 
diff --git a/tests/ui/coherence/orphan-check-projections-not-covering.next.stderr b/tests/ui/coherence/orphan-check-projections-not-covering.next.stderr
index 28b8c3f4a94bc..791ac9f5944b4 100644
--- a/tests/ui/coherence/orphan-check-projections-not-covering.next.stderr
+++ b/tests/ui/coherence/orphan-check-projections-not-covering.next.stderr
@@ -2,35 +2,38 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-projections-not-covering.rs:22:6
    |
 LL | impl<T> foreign::Trait0<Local, T, ()> for <T as Identity>::Output {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
   --> $DIR/orphan-check-projections-not-covering.rs:27:6
    |
 LL | impl<T> foreign::Trait0<<T as Identity>::Output, Local, T> for Option<T> {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 warning[E0210]: type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
   --> $DIR/orphan-check-projections-not-covering.rs:40:6
    |
 LL | impl<T: Deferred> foreign::Trait1<Local, T> for <T as Deferred>::Output {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 warning: 3 warnings emitted
 
diff --git a/tests/ui/coherence/orphan-check-projections-unsat-bounds.classic.stderr b/tests/ui/coherence/orphan-check-projections-unsat-bounds.classic.stderr
index 0346a9d665cf5..13b23889caaa7 100644
--- a/tests/ui/coherence/orphan-check-projections-unsat-bounds.classic.stderr
+++ b/tests/ui/coherence/orphan-check-projections-unsat-bounds.classic.stderr
@@ -2,12 +2,13 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-projections-unsat-bounds.rs:28:6
    |
 LL | impl<T> foreign::Trait1<LocalTy, T> for <Wrapper<T> as Discard>::Output
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`LocalTy`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/orphan-check-projections-unsat-bounds.next.stderr b/tests/ui/coherence/orphan-check-projections-unsat-bounds.next.stderr
index 0346a9d665cf5..13b23889caaa7 100644
--- a/tests/ui/coherence/orphan-check-projections-unsat-bounds.next.stderr
+++ b/tests/ui/coherence/orphan-check-projections-unsat-bounds.next.stderr
@@ -2,12 +2,13 @@ warning[E0210]: type parameter `T` must be covered by another type when it appea
   --> $DIR/orphan-check-projections-unsat-bounds.rs:28:6
    |
 LL | impl<T> foreign::Trait1<LocalTy, T> for <Wrapper<T> as Discard>::Output
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`LocalTy`)
+   |      ^ uncovered type parameter
    |
    = warning: this was previously accepted by the compiler but is being phased out; it will become a hard error in a future release!
    = note: for more information, see issue #124559 <https://github.com/rust-lang/rust/issues/124559>
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
    = note: `#[warn(uncovered_param_in_projection)]` on by default
 
 warning: 1 warning emitted
diff --git a/tests/ui/coherence/orphan-check-weak-aliases-not-covering.stderr b/tests/ui/coherence/orphan-check-weak-aliases-not-covering.stderr
index df915141a769f..006dd1dc2967c 100644
--- a/tests/ui/coherence/orphan-check-weak-aliases-not-covering.stderr
+++ b/tests/ui/coherence/orphan-check-weak-aliases-not-covering.stderr
@@ -2,10 +2,11 @@ error[E0210]: type parameter `T` must be covered by another type when it appears
   --> $DIR/orphan-check-weak-aliases-not-covering.rs:13:6
    |
 LL | impl<T> foreign::Trait1<Local, T> for Identity<T> {}
-   |      ^ type parameter `T` must be covered by another type when it appears before the first local type (`Local`)
+   |      ^ uncovered type parameter
    |
-   = 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
-   = 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
+   = 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 or opaque types appear before that first local type
+   = 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
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/e0119/issue-28981.stderr b/tests/ui/error-codes/e0119/issue-28981.stderr
index be3e4aea51a1a..d4051ee396185 100644
--- a/tests/ui/error-codes/e0119/issue-28981.stderr
+++ b/tests/ui/error-codes/e0119/issue-28981.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `Foo` must be used as the type parameter for some local type (e.g., `MyStruct<Foo>`)
+error[E0210]: type parameter `Foo` must be used as the argument to some local type (e.g., `MyStruct<Foo>`)
   --> $DIR/issue-28981.rs:5:6
    |
 LL | impl<Foo> Deref for Foo { }
-   |      ^^^ type parameter `Foo` must be used as the type parameter for some local type
+   |      ^^^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-41974.stderr b/tests/ui/issues/issue-41974.stderr
index e249db9df5324..4ebc3a711a0e7 100644
--- a/tests/ui/issues/issue-41974.stderr
+++ b/tests/ui/issues/issue-41974.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/issue-41974.rs:7:6
    |
 LL | impl<T> Drop for T where T: A {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error[E0120]: the `Drop` trait may only be implemented for local structs, enums, and unions
   --> $DIR/issue-41974.rs:7:18
diff --git a/tests/ui/specialization/fuzzed/fuzzing-ice-134905.rs b/tests/ui/specialization/fuzzed/fuzzing-ice-134905.rs
index 559c23455275b..4c32f8aac112d 100644
--- a/tests/ui/specialization/fuzzed/fuzzing-ice-134905.rs
+++ b/tests/ui/specialization/fuzzed/fuzzing-ice-134905.rs
@@ -15,7 +15,7 @@ where
 
 trait Check {}
 impl<'a, T> Eq for T where <T as Iterate<'a>>::Ty: Valid {}
-//~^ ERROR type parameter `T` must be used as the type parameter for some local type
+//~^ ERROR type parameter `T` must be used as the argument to some local type
 
 trait Valid {}
 
diff --git a/tests/ui/specialization/fuzzed/fuzzing-ice-134905.stderr b/tests/ui/specialization/fuzzed/fuzzing-ice-134905.stderr
index 611fef1df66bf..954f9077be687 100644
--- a/tests/ui/specialization/fuzzed/fuzzing-ice-134905.stderr
+++ b/tests/ui/specialization/fuzzed/fuzzing-ice-134905.stderr
@@ -25,14 +25,14 @@ note: required by a bound in `Iterate::Ty`
 LL |     type Ty: Valid;
    |              ^^^^^ required by this bound in `Iterate::Ty`
 
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/fuzzing-ice-134905.rs:17:10
    |
 LL | impl<'a, T> Eq for T where <T as Iterate<'a>>::Ty: Valid {}
-   |          ^ type parameter `T` must be used as the type parameter for some local type
+   |          ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 2 previous errors; 1 warning emitted
 
diff --git a/tests/ui/specialization/issue-43037.current.stderr b/tests/ui/specialization/issue-43037.current.stderr
index 2711350925716..e4369defd6602 100644
--- a/tests/ui/specialization/issue-43037.current.stderr
+++ b/tests/ui/specialization/issue-43037.current.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/issue-43037.rs:19:6
    |
 LL | impl<T> From<<A<T> as Z>::Assoc> for T {}
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/issue-43037.negative.stderr b/tests/ui/specialization/issue-43037.negative.stderr
index 2711350925716..e4369defd6602 100644
--- a/tests/ui/specialization/issue-43037.negative.stderr
+++ b/tests/ui/specialization/issue-43037.negative.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/issue-43037.rs:19:6
    |
 LL | impl<T> From<<A<T> as Z>::Assoc> for T {}
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/specialization/issue-43037.rs b/tests/ui/specialization/issue-43037.rs
index fb9a581369e6c..f07483fd66a22 100644
--- a/tests/ui/specialization/issue-43037.rs
+++ b/tests/ui/specialization/issue-43037.rs
@@ -17,6 +17,6 @@ impl<T: X> Z for A<T> {
 
 // this impl is invalid, but causes an ICE anyway
 impl<T> From<<A<T> as Z>::Assoc> for T {}
-//~^ ERROR type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+//~^ ERROR type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
 
 fn main() {}
diff --git a/tests/ui/stability-attribute/generics-default-stability-where.rs b/tests/ui/stability-attribute/generics-default-stability-where.rs
index a7bc1756d78a4..e793f2fa3691c 100644
--- a/tests/ui/stability-attribute/generics-default-stability-where.rs
+++ b/tests/ui/stability-attribute/generics-default-stability-where.rs
@@ -5,7 +5,7 @@ extern crate unstable_generic_param;
 use unstable_generic_param::*;
 
 impl<T> Trait3<usize> for T where T: Trait2<usize> { //~ ERROR use of unstable library feature `unstable_default`
-//~^ ERROR `T` must be used as the type parameter for some local type
+//~^ ERROR `T` must be used as the argument to some local type
     fn foo() -> usize { T::foo() }
 }
 
diff --git a/tests/ui/stability-attribute/generics-default-stability-where.stderr b/tests/ui/stability-attribute/generics-default-stability-where.stderr
index 9437f5d65fac2..4ceb63a878a86 100644
--- a/tests/ui/stability-attribute/generics-default-stability-where.stderr
+++ b/tests/ui/stability-attribute/generics-default-stability-where.stderr
@@ -7,14 +7,14 @@ LL | impl<T> Trait3<usize> for T where T: Trait2<usize> {
    = help: add `#![feature(unstable_default)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/generics-default-stability-where.rs:7:6
    |
 LL | impl<T> Trait3<usize> for T where T: Trait2<usize> {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
index dc1e719bded1a..ff1c15516e7a9 100644
--- a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
+++ b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.rs
@@ -5,7 +5,7 @@ use std::ops::FromResidual;
 
 impl<T> const FromResidual for T {
     //~^ ERROR const `impl` for trait `FromResidual` which is not marked with `#[const_trait]`
-    //~| type parameter `T` must be used as the type parameter for some local type
+    //~| type parameter `T` must be used as the argument to some local type
     fn from_residual(t: T) -> _ {
         //~^ the placeholder `_` is not allowed
         t
diff --git a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
index c6e0c699520b5..5f8959b71641b 100644
--- a/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
+++ b/tests/ui/traits/const-traits/ice-119717-constant-lifetime.stderr
@@ -7,14 +7,14 @@ LL | impl<T> const FromResidual for T {
    = note: marking a trait with `#[const_trait]` ensures all default method bodies are `const`
    = note: adding a non-const method body in the future would be a breaking change
 
-error[E0210]: type parameter `T` must be used as the type parameter for some local type (e.g., `MyStruct<T>`)
+error[E0210]: type parameter `T` must be used as the argument to some local type (e.g., `MyStruct<T>`)
   --> $DIR/ice-119717-constant-lifetime.rs:6:6
    |
 LL | impl<T> const FromResidual for T {
-   |      ^ type parameter `T` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error[E0121]: the placeholder `_` is not allowed within types on item signatures for functions
   --> $DIR/ice-119717-constant-lifetime.rs:9:31
diff --git a/tests/ui/type-alias-impl-trait/coherence.classic.stderr b/tests/ui/type-alias-impl-trait/coherence.classic.stderr
index e99d4636b1343..5986a49ec4fac 100644
--- a/tests/ui/type-alias-impl-trait/coherence.classic.stderr
+++ b/tests/ui/type-alias-impl-trait/coherence.classic.stderr
@@ -1,15 +1,12 @@
-error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
-  --> $DIR/coherence.rs:17:1
+error[E0210]: opaque type `AliasOfForeignType<()>` must be used as the argument to some local type  (e.g., `MyStruct<AliasOfForeignType<()>>`)
+  --> $DIR/coherence.rs:19:38
    |
 LL | impl foreign_crate::ForeignTrait for AliasOfForeignType<()> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------------
-   |                                      |
-   |                                      type alias impl trait is treated as if it were foreign, because its hidden type could be from a foreign crate
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^ uncovered opaque type
    |
-   = note: impl doesn't have any local type before any uncovered type parameters
-   = note: for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules
-   = note: define and implement a trait or new type instead
+   = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0117`.
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/type-alias-impl-trait/coherence.current.stderr b/tests/ui/type-alias-impl-trait/coherence.current.stderr
new file mode 100644
index 0000000000000..3e159f6cf3152
--- /dev/null
+++ b/tests/ui/type-alias-impl-trait/coherence.current.stderr
@@ -0,0 +1,12 @@
+error[E0210]: opaque type `AliasOfForeignType<()>` must be used as the argument to some local type (e.g., `MyStruct<AliasOfForeignType<()>>`)
+  --> $DIR/coherence.rs:21:38
+   |
+LL | impl foreign_crate::ForeignTrait for AliasOfForeignType<()> {}
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^ uncovered opaque type
+   |
+   = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/type-alias-impl-trait/coherence.next.stderr b/tests/ui/type-alias-impl-trait/coherence.next.stderr
index 6d14594e33a0f..df10ea465604d 100644
--- a/tests/ui/type-alias-impl-trait/coherence.next.stderr
+++ b/tests/ui/type-alias-impl-trait/coherence.next.stderr
@@ -1,15 +1,12 @@
-error[E0117]: only traits defined in the current crate can be implemented for arbitrary types
-  --> $DIR/coherence.rs:17:1
+error[E0210]: type parameters and opaque types must be used as the argument to some local type
+  --> $DIR/coherence.rs:21:38
    |
 LL | impl foreign_crate::ForeignTrait for AliasOfForeignType<()> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------------
-   |                                      |
-   |                                      `AliasOfForeignType<()>` is not defined in the current crate
+   |                                      ^^^^^^^^^^^^^^^^^^^^^^ contains an uncovered type
    |
-   = note: impl doesn't have any local type before any uncovered type parameters
-   = note: for more information see https://doc.rust-lang.org/reference/items/implementations.html#orphan-rules
-   = note: define and implement a trait or new type instead
+   = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0117`.
+For more information about this error, try `rustc --explain E0210`.
diff --git a/tests/ui/type-alias-impl-trait/coherence.rs b/tests/ui/type-alias-impl-trait/coherence.rs
index eb27c2708042a..02d89a54fe5bc 100644
--- a/tests/ui/type-alias-impl-trait/coherence.rs
+++ b/tests/ui/type-alias-impl-trait/coherence.rs
@@ -1,8 +1,12 @@
 //@ aux-build:foreign-crate.rs
-//@ revisions: classic next
+//@ revisions: current next
 //@[next] compile-flags: -Znext-solver
+//@ ignore-compare-mode-next-solver (explicit revisions)
 #![feature(type_alias_impl_trait)]
 
+// See also <https://github.com/rust-lang/rust/issues/130978>.
+// FIXME(fmease): Add a more descriptive comment.
+
 extern crate foreign_crate;
 
 trait LocalTrait {}
@@ -15,6 +19,7 @@ fn use_alias<T>(val: T) -> AliasOfForeignType<T> {
 }
 
 impl foreign_crate::ForeignTrait for AliasOfForeignType<()> {}
-//~^ ERROR only traits defined in the current crate can be implemented for arbitrary types
+//[current]~^ ERROR opaque type `AliasOfForeignType<()>` must be used as the argument to some local type
+//[next]~^^ ERROR type parameters and opaque types must be used as the argument to some local type
 
 fn main() {}
diff --git a/tests/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.stderr b/tests/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.stderr
index f0cf681d8bb72..1d528451ec2b1 100644
--- a/tests/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.stderr
+++ b/tests/ui/type-alias-impl-trait/incoherent-assoc-imp-trait.stderr
@@ -1,11 +1,11 @@
-error[E0210]: type parameter `F` must be used as the type parameter for some local type (e.g., `MyStruct<F>`)
+error[E0210]: type parameter `F` must be used as the argument to some local type (e.g., `MyStruct<F>`)
   --> $DIR/incoherent-assoc-imp-trait.rs:10:6
    |
 LL | impl<F> FnOnce<()> for &F {
-   |      ^ type parameter `F` must be used as the type parameter for some local type
+   |      ^ uncovered type parameter
    |
    = note: implementing a foreign trait is only possible if at least one of the types for which it is implemented is local
-   = note: only traits defined in the current crate can be implemented for a type parameter
+   = note: only traits defined in the current crate can be implemented for type parameters and opaque types
 
 error: aborting due to 1 previous error