Auto merge of #131628 - matthiaskrgr:rollup-imbojxz, r=matthiaskrgr

Rollup of 8 pull requests Successful merges: - #128784 (Check ABI target compatibility for function pointers) - #130965 (make `Step` doc-comments more clear) - #131239 (Don't assume traits used as type are trait objs in 2021 edition) - #131277 (Handle `clippy` cases of `rustc::potential_query_instability` lint) - #131503 (More clearly document Stdin::read_line) - #131567 (Emit an error for unstable attributes that reference already stable features) - #131599 (Shallowly match opaque key in storage) - #131617 (remove const_cow_is_borrowed feature gate) Failed merges: - #131616 (merge const_ipv4 / const_ipv6 feature gate into 'ip' feature gate) r? `@ghost` `@rustbot` modify labels: rollup
2024-10-12 21:03:01 +00:00 · 2024-10-12 21:03:01 +00:00 · ef4e8259b5
commit ef4e8259b5
parent 6b9676b454 de72917050
102 changed files with 1915 additions and 864 deletions
--- a/compiler/rustc_data_structures/src/unhash.rs
+++ b/compiler/rustc_data_structures/src/unhash.rs
@ -3,6 +3,7 @@ use std::hash::{BuildHasherDefault, Hasher};

 pub type UnhashMap<K, V> = HashMap<K, V, BuildHasherDefault<Unhasher>>;
 pub type UnhashSet<V> = HashSet<V, BuildHasherDefault<Unhasher>>;
+pub type UnindexMap<K, V> = indexmap::IndexMap<K, V, BuildHasherDefault<Unhasher>>;

 /// This no-op hasher expects only a single `write_u64` call. It's intended for
 /// map keys that already have hash-like quality, like `Fingerprint`.
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@ -8,7 +8,9 @@ use rustc_hir::Node;
 use rustc_hir::def::{CtorKind, DefKind};
 use rustc_infer::infer::{RegionVariableOrigin, TyCtxtInferExt};
 use rustc_infer::traits::Obligation;
-use rustc_lint_defs::builtin::REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS;
+use rustc_lint_defs::builtin::{
+    REPR_TRANSPARENT_EXTERNAL_PRIVATE_FIELDS, UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS,
+};
 use rustc_middle::middle::resolve_bound_vars::ResolvedArg;
 use rustc_middle::middle::stability::EvalResult;
 use rustc_middle::span_bug;
@ -52,16 +54,18 @@ pub fn check_abi(tcx: TyCtxt<'_>, hir_id: hir::HirId, span: Span, abi: Abi) {
            });
        }
    }
+}

-    // This ABI is only allowed on function pointers
-    if abi == Abi::CCmseNonSecureCall {
-        struct_span_code_err!(
-            tcx.dcx(),
-            span,
-            E0781,
-            "the `\"C-cmse-nonsecure-call\"` ABI is only allowed on function pointers"
-        )
-        .emit();
+pub fn check_abi_fn_ptr(tcx: TyCtxt<'_>, hir_id: hir::HirId, span: Span, abi: Abi) {
+    match tcx.sess.target.is_abi_supported(abi) {
+        Some(true) => (),
+        Some(false) | None => {
+            tcx.node_span_lint(UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS, hir_id, span, |lint| {
+                lint.primary_message(
+                    "use of calling convention not supported on this target on function pointer",
+                );
+            });
+        }
    }
 }

--- a/compiler/rustc_hir_analysis/src/check/mod.rs
+++ b/compiler/rustc_hir_analysis/src/check/mod.rs
@ -73,7 +73,7 @@ pub mod wfcheck;

 use std::num::NonZero;

-pub use check::check_abi;
+pub use check::{check_abi, check_abi_fn_ptr};
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
 use rustc_errors::{Diag, ErrorGuaranteed, pluralize, struct_span_code_err};
 use rustc_hir::def_id::{DefId, LocalDefId};
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/cmse.rs
@ -1,6 +1,5 @@
-use rustc_errors::DiagCtxtHandle;
-use rustc_hir as hir;
-use rustc_hir::HirId;
+use rustc_errors::{DiagCtxtHandle, E0781, struct_span_code_err};
+use rustc_hir::{self as hir, HirId};
 use rustc_middle::ty::layout::LayoutError;
 use rustc_middle::ty::{self, ParamEnv, TyCtxt};
 use rustc_span::Span;
@ -26,7 +25,19 @@ pub(crate) fn validate_cmse_abi<'tcx>(
            ..
        }) = hir_node
        else {
-            // might happen when this ABI is used incorrectly. That will be handled elsewhere
+            let span = match tcx.parent_hir_node(hir_id) {
+                hir::Node::Item(hir::Item {
+                    kind: hir::ItemKind::ForeignMod { .. }, span, ..
+                }) => *span,
+                _ => tcx.hir().span(hir_id),
+            };
+            struct_span_code_err!(
+                tcx.dcx(),
+                span,
+                E0781,
+                "the `\"C-cmse-nonsecure-call\"` ABI is only allowed on function pointers"
+            )
+            .emit();
            return;
        };

--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/lint.rs
@ -1,6 +1,6 @@
 use rustc_ast::TraitObjectSyntax;
 use rustc_errors::codes::*;
-use rustc_errors::{Diag, EmissionGuarantee, StashKey};
+use rustc_errors::{Diag, EmissionGuarantee, ErrorGuaranteed, StashKey, Suggestions};
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_lint_defs::Applicability;
@ -15,13 +15,16 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
    ///
    /// *Bare* trait object types are ones that aren't preceded by the keyword `dyn`.
    /// In edition 2021 and onward we emit a hard error for them.
-    pub(super) fn prohibit_or_lint_bare_trait_object_ty(&self, self_ty: &hir::Ty<'_>) {
+    pub(super) fn prohibit_or_lint_bare_trait_object_ty(
+        &self,
+        self_ty: &hir::Ty<'_>,
+    ) -> Option<ErrorGuaranteed> {
        let tcx = self.tcx();

        let hir::TyKind::TraitObject([poly_trait_ref, ..], _, TraitObjectSyntax::None) =
            self_ty.kind
        else {
-            return;
+            return None;
        };

        let in_path = match tcx.parent_hir_node(self_ty.hir_id) {
@ -70,8 +73,8 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
        }

        if self_ty.span.edition().at_least_rust_2021() {
-            let msg = "trait objects must include the `dyn` keyword";
-            let label = "add `dyn` keyword before this trait";
+            let msg = "expected a type, found a trait";
+            let label = "you can add the `dyn` keyword if you want a trait object";
            let mut diag =
                rustc_errors::struct_span_code_err!(self.dcx(), self_ty.span, E0782, "{}", msg);
            if self_ty.span.can_be_used_for_suggestions()
@ -83,7 +86,17 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
            // Check if the impl trait that we are considering is an impl of a local trait.
            self.maybe_suggest_blanket_trait_impl(self_ty, &mut diag);
            self.maybe_suggest_assoc_ty_bound(self_ty, &mut diag);
-            diag.stash(self_ty.span, StashKey::TraitMissingMethod);
+            // In case there is an associate type with the same name
+            // Add the suggestion to this error
+            if let Some(mut sugg) =
+                tcx.dcx().steal_non_err(self_ty.span, StashKey::AssociatedTypeSuggestion)
+                && let Suggestions::Enabled(ref mut s1) = diag.suggestions
+                && let Suggestions::Enabled(ref mut s2) = sugg.suggestions
+            {
+                s1.append(s2);
+                sugg.cancel();
+            }
+            diag.stash(self_ty.span, StashKey::TraitMissingMethod)
        } else {
            tcx.node_span_lint(BARE_TRAIT_OBJECTS, self_ty.hir_id, self_ty.span, |lint| {
                lint.primary_message("trait objects without an explicit `dyn` are deprecated");
@ -96,6 +109,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                }
                self.maybe_suggest_blanket_trait_impl(self_ty, lint);
            });
+            None
        }
    }

@ -174,41 +188,31 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
        // 1. Independent functions
        // 2. Functions inside trait blocks
        // 3. Functions inside impl blocks
-        let (sig, generics, owner) = match tcx.hir_node_by_def_id(parent_id) {
+        let (sig, generics) = match tcx.hir_node_by_def_id(parent_id) {
            hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn(sig, generics, _), .. }) => {
-                (sig, generics, None)
+                (sig, generics)
            }
            hir::Node::TraitItem(hir::TraitItem {
                kind: hir::TraitItemKind::Fn(sig, _),
                generics,
-                owner_id,
                ..
-            }) => (sig, generics, Some(tcx.parent(owner_id.to_def_id()))),
+            }) => (sig, generics),
            hir::Node::ImplItem(hir::ImplItem {
                kind: hir::ImplItemKind::Fn(sig, _),
                generics,
-                owner_id,
                ..
-            }) => (sig, generics, Some(tcx.parent(owner_id.to_def_id()))),
+            }) => (sig, generics),
            _ => return false,
        };
        let Ok(trait_name) = tcx.sess.source_map().span_to_snippet(self_ty.span) else {
            return false;
        };
        let impl_sugg = vec![(self_ty.span.shrink_to_lo(), "impl ".to_string())];
-        let mut is_downgradable = true;
-
        // Check if trait object is safe for suggesting dynamic dispatch.
        let is_dyn_compatible = match self_ty.kind {
            hir::TyKind::TraitObject(objects, ..) => {
                objects.iter().all(|(o, _)| match o.trait_ref.path.res {
-                    Res::Def(DefKind::Trait, id) => {
-                        if Some(id) == owner {
-                            // For recursive traits, don't downgrade the error. (#119652)
-                            is_downgradable = false;
-                        }
-                        tcx.is_dyn_compatible(id)
-                    }
+                    Res::Def(DefKind::Trait, id) => tcx.is_dyn_compatible(id),
                    _ => false,
                })
            }
@ -255,9 +259,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                    suggestion,
                    Applicability::MachineApplicable,
                );
-            } else if is_downgradable {
-                // We'll emit the dyn-compatibility error already, with a structured suggestion.
-                diag.downgrade_to_delayed_bug();
            }
            return true;
        }
@ -281,10 +282,6 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
            );
            if !is_dyn_compatible {
                diag.note(format!("`{trait_name}` it is dyn-incompatible, so it can't be `dyn`"));
-                if is_downgradable {
-                    // We'll emit the dyn-compatibility error already, with a structured suggestion.
-                    diag.downgrade_to_delayed_bug();
-                }
            } else {
                // No ampersand in suggestion if it's borrowed already
                let (dyn_str, paren_dyn_str) =
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@ -53,6 +53,7 @@ use rustc_trait_selection::traits::{self, ObligationCtxt};
 use tracing::{debug, debug_span, instrument};

 use crate::bounds::Bounds;
+use crate::check::check_abi_fn_ptr;
 use crate::errors::{AmbiguousLifetimeBound, BadReturnTypeNotation, WildPatTy};
 use crate::hir_ty_lowering::errors::{GenericsArgsErrExtend, prohibit_assoc_item_constraint};
 use crate::hir_ty_lowering::generics::{check_generic_arg_count, lower_generic_args};
@ -2063,13 +2064,18 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                )
            }
            hir::TyKind::TraitObject(bounds, lifetime, repr) => {
-                self.prohibit_or_lint_bare_trait_object_ty(hir_ty);
-
-                let repr = match repr {
-                    TraitObjectSyntax::Dyn | TraitObjectSyntax::None => ty::Dyn,
-                    TraitObjectSyntax::DynStar => ty::DynStar,
-                };
-                self.lower_trait_object_ty(hir_ty.span, hir_ty.hir_id, bounds, lifetime, repr)
+                if let Some(guar) = self.prohibit_or_lint_bare_trait_object_ty(hir_ty) {
+                    // Don't continue with type analysis if the `dyn` keyword is missing
+                    // It generates confusing errors, especially if the user meant to use another
+                    // keyword like `impl`
+                    Ty::new_error(tcx, guar)
+                } else {
+                    let repr = match repr {
+                        TraitObjectSyntax::Dyn | TraitObjectSyntax::None => ty::Dyn,
+                        TraitObjectSyntax::DynStar => ty::DynStar,
+                    };
+                    self.lower_trait_object_ty(hir_ty.span, hir_ty.hir_id, bounds, lifetime, repr)
+                }
            }
            // If we encounter a fully qualified path with RTN generics, then it must have
            // *not* gone through `lower_ty_maybe_return_type_notation`, and therefore
@ -2337,6 +2343,12 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
        let fn_ty = tcx.mk_fn_sig(input_tys, output_ty, decl.c_variadic, safety, abi);
        let bare_fn_ty = ty::Binder::bind_with_vars(fn_ty, bound_vars);

+        if let hir::Node::Ty(hir::Ty { kind: hir::TyKind::BareFn(bare_fn_ty), span, .. }) =
+            tcx.hir_node(hir_id)
+        {
+            check_abi_fn_ptr(tcx, hir_id, *span, bare_fn_ty.abi);
+        }
+
        // reject function types that violate cmse ABI requirements
        cmse::validate_cmse_abi(self.tcx(), self.dcx(), hir_id, abi, bare_fn_ty);

--- a/compiler/rustc_lint_defs/src/builtin.rs
+++ b/compiler/rustc_lint_defs/src/builtin.rs
@ -124,6 +124,7 @@ declare_lint_pass! {
        UNSTABLE_NAME_COLLISIONS,
        UNSTABLE_SYNTAX_PRE_EXPANSION,
        UNSUPPORTED_CALLING_CONVENTIONS,
+        UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS,
        UNUSED_ASSIGNMENTS,
        UNUSED_ASSOCIATED_TYPE_BOUNDS,
        UNUSED_ATTRIBUTES,
@ -3839,6 +3840,50 @@ declare_lint! {
    };
 }

+declare_lint! {
+    /// The `unsupported_fn_ptr_calling_conventions` lint is output whenever there is a use of
+    /// a target dependent calling convention on a target that does not support this calling
+    /// convention on a function pointer.
+    ///
+    /// For example `stdcall` does not make much sense for a x86_64 or, more apparently, powerpc
+    /// code, because this calling convention was never specified for those targets.
+    ///
+    /// ### Example
+    ///
+    /// ```rust,ignore (needs specific targets)
+    /// fn stdcall_ptr(f: extern "stdcall" fn ()) {
+    ///     f()
+    /// }
+    /// ```
+    ///
+    /// This will produce:
+    ///
+    /// ```text
+    /// warning: use of calling convention not supported on this target on function pointer
+    ///   --> $DIR/unsupported.rs:34:15
+    ///    |
+    /// LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
+    ///    |               ^^^^^^^^^^^^^^^^^^^^^^^^
+    ///    |
+    ///    = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+    ///    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
+    /// ```
+    ///
+    /// ### Explanation
+    ///
+    /// On most of the targets the behaviour of `stdcall` and similar calling conventions is not
+    /// defined at all, but was previously accepted due to a bug in the implementation of the
+    /// compiler.
+    pub UNSUPPORTED_FN_PTR_CALLING_CONVENTIONS,
+    Warn,
+    "use of unsupported calling convention for function pointer",
+    @future_incompatible = FutureIncompatibleInfo {
+        reason: FutureIncompatibilityReason::FutureReleaseErrorDontReportInDeps,
+        reference: "issue #130260 <https://github.com/rust-lang/rust/issues/130260>",
+    };
+}
+
 declare_lint! {
    /// The `break_with_label_and_loop` lint detects labeled `break` expressions with
    /// an unlabeled loop as their value expression.
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@ -4,6 +4,7 @@ use derive_where::derive_where;
 #[cfg(feature = "nightly")]
 use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
 use rustc_type_ir::data_structures::{HashMap, HashSet, ensure_sufficient_stack};
+use rustc_type_ir::fast_reject::DeepRejectCtxt;
 use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::Relate;
@ -18,9 +19,9 @@ use crate::delegate::SolverDelegate;
 use crate::solve::inspect::{self, ProofTreeBuilder};
 use crate::solve::search_graph::SearchGraph;
 use crate::solve::{
-    CanonicalInput, CanonicalResponse, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluationKind,
-    GoalSource, HasChanged, NestedNormalizationGoals, NoSolution, PredefinedOpaquesData,
-    QueryResult, SolverMode,
+    CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluationKind, GoalSource,
+    HasChanged, NestedNormalizationGoals, NoSolution, PredefinedOpaquesData, QueryResult,
+    SolverMode,
 };

 pub(super) mod canonical;
@ -987,40 +988,22 @@ where

    // Do something for each opaque/hidden pair defined with `def_id` in the
    // current inference context.
-    pub(super) fn unify_existing_opaque_tys(
+    pub(super) fn probe_existing_opaque_ty(
        &mut self,
-        param_env: I::ParamEnv,
        key: ty::OpaqueTypeKey<I>,
-        ty: I::Ty,
-    ) -> Vec<CanonicalResponse<I>> {
-        // FIXME: Super inefficient to be cloning this...
-        let opaques = self.delegate.clone_opaque_types_for_query_response();
-
-        let mut values = vec![];
-        for (candidate_key, candidate_ty) in opaques {
-            if candidate_key.def_id != key.def_id {
-                continue;
-            }
-            values.extend(
-                self.probe(|result| inspect::ProbeKind::OpaqueTypeStorageLookup {
-                    result: *result,
-                })
-                .enter(|ecx| {
-                    for (a, b) in std::iter::zip(candidate_key.args.iter(), key.args.iter()) {
-                        ecx.eq(param_env, a, b)?;
-                    }
-                    ecx.eq(param_env, candidate_ty, ty)?;
-                    ecx.add_item_bounds_for_hidden_type(
-                        candidate_key.def_id.into(),
-                        candidate_key.args,
-                        param_env,
-                        candidate_ty,
-                    );
-                    ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
-                }),
+    ) -> Option<(ty::OpaqueTypeKey<I>, I::Ty)> {
+        let mut matching =
+            self.delegate.clone_opaque_types_for_query_response().into_iter().filter(
+                |(candidate_key, _)| {
+                    candidate_key.def_id == key.def_id
+                        && DeepRejectCtxt::relate_rigid_rigid(self.cx())
+                            .args_may_unify(candidate_key.args, key.args)
+                },
            );
-        }
-        values
+        let first = matching.next();
+        let second = matching.next();
+        assert_eq!(second, None);
+        first
    }

    // Try to evaluate a const, or return `None` if the const is too generic.
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/opaque_types.rs
@ -7,7 +7,9 @@ use rustc_type_ir::inherent::*;
 use rustc_type_ir::{self as ty, Interner};

 use crate::delegate::SolverDelegate;
-use crate::solve::{Certainty, EvalCtxt, Goal, NoSolution, QueryResult, Reveal, SolverMode};
+use crate::solve::{
+    Certainty, EvalCtxt, Goal, NoSolution, QueryResult, Reveal, SolverMode, inspect,
+};

 impl<D, I> EvalCtxt<'_, D>
 where
@ -52,14 +54,28 @@ where
                //
                // If that fails, we insert `expected` as a new hidden type instead of
                // eagerly emitting an error.
-                let matches =
-                    self.unify_existing_opaque_tys(goal.param_env, opaque_type_key, expected);
-                if !matches.is_empty() {
-                    if let Some(response) = self.try_merge_responses(&matches) {
-                        return Ok(response);
-                    } else {
-                        return self.flounder(&matches);
-                    }
+                let existing = self.probe_existing_opaque_ty(opaque_type_key);
+                if let Some((candidate_key, candidate_ty)) = existing {
+                    return self
+                        .probe(|result| inspect::ProbeKind::OpaqueTypeStorageLookup {
+                            result: *result,
+                        })
+                        .enter(|ecx| {
+                            for (a, b) in std::iter::zip(
+                                candidate_key.args.iter(),
+                                opaque_type_key.args.iter(),
+                            ) {
+                                ecx.eq(goal.param_env, a, b)?;
+                            }
+                            ecx.eq(goal.param_env, candidate_ty, expected)?;
+                            ecx.add_item_bounds_for_hidden_type(
+                                candidate_key.def_id.into(),
+                                candidate_key.args,
+                                goal.param_env,
+                                candidate_ty,
+                            );
+                            ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
+                        });
                }

                // Otherwise, define a new opaque type
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@ -739,6 +739,12 @@ passes_unrecognized_repr_hint =
    unrecognized representation hint
    .help = valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`

+passes_unstable_attr_for_already_stable_feature =
+    can't mark as unstable using an already stable feature
+    .label = this feature is already stable
+    .item = the stability attribute annotates this item
+    .help = consider removing the attribute
+
 passes_unused =
    unused attribute
    .suggestion = remove this attribute
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@ -1480,6 +1480,17 @@ pub(crate) struct CannotStabilizeDeprecated {
    pub item_sp: Span,
 }

+#[derive(Diagnostic)]
+#[diag(passes_unstable_attr_for_already_stable_feature)]
+pub(crate) struct UnstableAttrForAlreadyStableFeature {
+    #[primary_span]
+    #[label]
+    #[help]
+    pub span: Span,
+    #[label(passes_item)]
+    pub item_sp: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_missing_stability_attr)]
 pub(crate) struct MissingStabilityAttr<'a> {
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@ -10,6 +10,7 @@ use rustc_attr::{
 };
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::{ExtendUnord, UnordMap, UnordSet};
+use rustc_feature::ACCEPTED_FEATURES;
 use rustc_hir as hir;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::def_id::{CRATE_DEF_ID, LOCAL_CRATE, LocalDefId, LocalModDefId};
@ -246,12 +247,27 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                }
            }

+            if let Stability { level: Unstable { .. }, feature } = stab {
+                if ACCEPTED_FEATURES.iter().find(|f| f.name == feature).is_some() {
+                    self.tcx
+                        .dcx()
+                        .emit_err(errors::UnstableAttrForAlreadyStableFeature { span, item_sp });
+                }
+            }
            if let Stability { level: Unstable { implied_by: Some(implied_by), .. }, feature } =
                stab
            {
                self.index.implications.insert(implied_by, feature);
            }

+            if let Some(ConstStability { level: Unstable { .. }, feature, .. }) = const_stab {
+                if ACCEPTED_FEATURES.iter().find(|f| f.name == feature).is_some() {
+                    self.tcx.dcx().emit_err(errors::UnstableAttrForAlreadyStableFeature {
+                        span: const_span.unwrap(), // If const_stab contains Some(..), same is true for const_span
+                        item_sp,
+                    });
+                }
+            }
            if let Some(ConstStability {
                level: Unstable { implied_by: Some(implied_by), .. },
                feature,
--- a/compiler/rustc_session/src/parse.rs
+++ b/compiler/rustc_session/src/parse.rs
@ -66,7 +66,7 @@ impl GatedSpans {
 #[derive(Default)]
 pub struct SymbolGallery {
    /// All symbols occurred and their first occurrence span.
-    pub symbols: Lock<FxHashMap<Symbol, Span>>,
+    pub symbols: Lock<FxIndexMap<Symbol, Span>>,
 }

 impl SymbolGallery {
--- a/library/alloc/src/borrow.rs
+++ b/library/alloc/src/borrow.rs
@ -225,7 +225,6 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
    /// assert!(!bull.is_borrowed());
    /// ```
    #[unstable(feature = "cow_is_borrowed", issue = "65143")]
-    #[rustc_const_unstable(feature = "const_cow_is_borrowed", issue = "65143")]
    pub const fn is_borrowed(&self) -> bool {
        match *self {
            Borrowed(_) => true,
@ -248,7 +247,6 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
    /// assert!(!bull.is_owned());
    /// ```
    #[unstable(feature = "cow_is_borrowed", issue = "65143")]
-    #[rustc_const_unstable(feature = "const_cow_is_borrowed", issue = "65143")]
    pub const fn is_owned(&self) -> bool {
        !self.is_borrowed()
    }
--- a/library/alloc/src/lib.rs
+++ b/library/alloc/src/lib.rs
@ -108,7 +108,6 @@
 #![feature(coerce_unsized)]
 #![feature(const_align_of_val)]
 #![feature(const_box)]
-#![feature(const_cow_is_borrowed)]
 #![feature(const_eval_select)]
 #![feature(const_heap)]
 #![feature(const_maybe_uninit_write)]
--- a/library/alloc/tests/lib.rs
+++ b/library/alloc/tests/lib.rs
@ -4,7 +4,6 @@
 #![feature(assert_matches)]
 #![feature(btree_extract_if)]
 #![feature(cow_is_borrowed)]
-#![feature(const_cow_is_borrowed)]
 #![feature(const_heap)]
 #![cfg_attr(bootstrap, feature(const_mut_refs))]
 #![feature(const_try)]
--- a/library/std/src/io/stdio.rs
+++ b/library/std/src/io/stdio.rs
@ -370,7 +370,12 @@ impl Stdin {
    /// Locks this handle and reads a line of input, appending it to the specified buffer.
    ///
    /// For detailed semantics of this method, see the documentation on
-    /// [`BufRead::read_line`].
+    /// [`BufRead::read_line`]. In particular:
+    /// * Previous content of the buffer will be preserved. To avoid appending
+    ///   to the buffer, you need to [`clear`] it first.
+    /// * The trailing newline character, if any, is included in the buffer.
+    ///
+    /// [`clear`]: String::clear
    ///
    /// # Examples
    ///
--- a/src/bootstrap/src/core/builder.rs
+++ b/src/bootstrap/src/core/builder.rs
@ -72,36 +72,40 @@ impl<'a> Deref for Builder<'a> {
 }

 pub trait Step: 'static + Clone + Debug + PartialEq + Eq + Hash {
-    /// `PathBuf` when directories are created or to return a `Compiler` once
-    /// it's been assembled.
+    /// Result type of `Step::run`.
    type Output: Clone;

-    /// Whether this step is run by default as part of its respective phase.
-    /// `true` here can still be overwritten by `should_run` calling `default_condition`.
+    /// Whether this step is run by default as part of its respective phase, as defined by the `describe`
+    /// macro in [`Builder::get_step_descriptions`].
+    ///
+    /// Note: Even if set to `true`, it can still be overridden with [`ShouldRun::default_condition`]
+    /// by `Step::should_run`.
    const DEFAULT: bool = false;

    /// If true, then this rule should be skipped if --target was specified, but --host was not
    const ONLY_HOSTS: bool = false;

-    /// Primary function to execute this rule. Can call `builder.ensure()`
-    /// with other steps to run those.
+    /// Primary function to implement `Step` logic.
    ///
-    /// This gets called twice during a normal `./x.py` execution: first
-    /// with `dry_run() == true`, and then for real.
+    /// This function can be triggered in two ways:
+    ///     1. Directly from [`Builder::execute_cli`].
+    ///     2. Indirectly by being called from other `Step`s using [`Builder::ensure`].
+    ///
+    /// When called with [`Builder::execute_cli`] (as done by `Build::build`), this function executed twice:
+    ///     - First in "dry-run" mode to validate certain things (like cyclic Step invocations,
+    ///         directory creation, etc) super quickly.
+    ///     - Then it's called again to run the actual, very expensive process.
+    ///
+    /// When triggered indirectly from other `Step`s, it may still run twice (as dry-run and real mode)
+    /// depending on the `Step::run` implementation of the caller.
    fn run(self, builder: &Builder<'_>) -> Self::Output;

-    /// When bootstrap is passed a set of paths, this controls whether this rule
-    /// will execute. However, it does not get called in a "default" context
-    /// when we are not passed any paths; in that case, `make_run` is called
-    /// directly.
+    /// Determines if this `Step` should be run when given specific paths (e.g., `x build $path`).
    fn should_run(run: ShouldRun<'_>) -> ShouldRun<'_>;

-    /// Builds up a "root" rule, either as a default rule or from a path passed
-    /// to us.
-    ///
-    /// When path is `None`, we are executing in a context where no paths were
-    /// passed. When `./x.py build` is run, for example, this rule could get
-    /// called if it is in the correct list below with a path of `None`.
+    /// Called directly by the bootstrap `Step` handler when not triggered indirectly by other `Step`s using [`Builder::ensure`].
+    /// For example, `./x.py test bootstrap` runs this for `test::Bootstrap`. Similarly, `./x.py test` runs it for every step
+    /// that is listed by the `describe` macro in [`Builder::get_step_descriptions`].
    fn make_run(_run: RunConfig<'_>) {
        // It is reasonable to not have an implementation of make_run for rules
        // who do not want to get called from the root context. This means that
--- a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
+++ b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
@ -5,7 +5,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::IfLet;
 use clippy_utils::ty::is_copy;
 use clippy_utils::{is_expn_of, is_lint_allowed, path_to_local};
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::HirId;
@ -133,7 +133,7 @@ fn lint_slice(cx: &LateContext<'_>, slice: &SliceLintInformation) {
        .index_use
        .iter()
        .map(|(index, _)| *index)
-        .collect::<FxHashSet<_>>();
+        .collect::<FxIndexSet<_>>();

    let value_name = |index| format!("{}_{index}", slice.ident.name);

--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@ -26,8 +26,6 @@
    unused_qualifications,
    rustc::internal
 )]
-// Disable this rustc lint for now, as it was also done in rustc
-#![allow(rustc::potential_query_instability)]

 // FIXME: switch to something more ergonomic here, once available.
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
--- a/src/tools/clippy/clippy_lints/src/lifetimes.rs
+++ b/src/tools/clippy/clippy_lints/src/lifetimes.rs
@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
 use clippy_utils::trait_ref_of_method;
 use itertools::Itertools;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::Applicability;
 use rustc_hir::FnRetTy::Return;
 use rustc_hir::intravisit::nested_filter::{self as hir_nested_filter, NestedFilter};
@ -311,7 +311,7 @@ fn could_use_elision<'tcx>(
    Some((elidable_lts, usages))
 }

-fn allowed_lts_from(named_generics: &[GenericParam<'_>]) -> FxHashSet<LocalDefId> {
+fn allowed_lts_from(named_generics: &[GenericParam<'_>]) -> FxIndexSet<LocalDefId> {
    named_generics
        .iter()
        .filter_map(|par| {
@ -497,7 +497,7 @@ struct Usage {

 struct LifetimeChecker<'cx, 'tcx, F> {
    cx: &'cx LateContext<'tcx>,
-    map: FxHashMap<LocalDefId, Vec<Usage>>,
+    map: FxIndexMap<LocalDefId, Vec<Usage>>,
    where_predicate_depth: usize,
    generic_args_depth: usize,
    phantom: std::marker::PhantomData<F>,
@ -619,7 +619,7 @@ fn report_extra_impl_lifetimes<'tcx>(cx: &LateContext<'tcx>, impl_: &'tcx Impl<'
 fn report_elidable_impl_lifetimes<'tcx>(
    cx: &LateContext<'tcx>,
    impl_: &'tcx Impl<'_>,
-    map: &FxHashMap<LocalDefId, Vec<Usage>>,
+    map: &FxIndexMap<LocalDefId, Vec<Usage>>,
 ) {
    let single_usages = map
        .iter()
--- a/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/needless_range_loop.rs
@ -5,7 +5,7 @@ use clippy_utils::ty::has_iter_method;
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{SpanlessEq, contains_name, higher, is_integer_const, sugg};
 use rustc_ast::ast;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::{Visitor, walk_expr};
@ -39,7 +39,7 @@ pub(super) fn check<'tcx>(
                var: canonical_id,
                indexed_mut: FxHashSet::default(),
                indexed_indirectly: FxHashMap::default(),
-                indexed_directly: FxHashMap::default(),
+                indexed_directly: FxIndexMap::default(),
                referenced: FxHashSet::default(),
                nonindex: false,
                prefer_mutable: false,
@ -229,7 +229,7 @@ struct VarVisitor<'a, 'tcx> {
    indexed_indirectly: FxHashMap<Symbol, Option<region::Scope>>,
    /// subset of `indexed` of vars that are indexed directly: `v[i]`
    /// this will not contain cases like `v[calc_index(i)]` or `v[(i + 4) % N]`
-    indexed_directly: FxHashMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
+    indexed_directly: FxIndexMap<Symbol, (Option<region::Scope>, Ty<'tcx>)>,
    /// Any names that are used outside an index operation.
    /// Used to detect things like `&mut vec` used together with `vec[i]`
    referenced: FxHashSet<Symbol>,
--- a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@ -7,6 +7,7 @@ use clippy_utils::ty::{for_each_top_level_late_bound_region, is_copy};
 use clippy_utils::{get_attr, is_lint_allowed};
 use itertools::Itertools;
 use rustc_ast::Mutability;
+use rustc_data_structures::fx::FxIndexSet;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::intravisit::{Visitor, walk_expr};
 use rustc_hir::{Arm, Expr, ExprKind, MatchSource};
@ -475,19 +476,19 @@ impl<'tcx> Visitor<'tcx> for SigDropHelper<'_, 'tcx> {

 struct ArmSigDropHelper<'a, 'tcx> {
    sig_drop_checker: SigDropChecker<'a, 'tcx>,
-    found_sig_drop_spans: FxHashSet<Span>,
+    found_sig_drop_spans: FxIndexSet<Span>,
 }

 impl<'a, 'tcx> ArmSigDropHelper<'a, 'tcx> {
    fn new(cx: &'a LateContext<'tcx>) -> ArmSigDropHelper<'a, 'tcx> {
        ArmSigDropHelper {
            sig_drop_checker: SigDropChecker::new(cx),
-            found_sig_drop_spans: FxHashSet::<Span>::default(),
+            found_sig_drop_spans: FxIndexSet::<Span>::default(),
        }
    }
 }

-fn has_significant_drop_in_arms<'tcx>(cx: &LateContext<'tcx>, arms: &[&'tcx Expr<'_>]) -> FxHashSet<Span> {
+fn has_significant_drop_in_arms<'tcx>(cx: &LateContext<'tcx>, arms: &[&'tcx Expr<'_>]) -> FxIndexSet<Span> {
    let mut helper = ArmSigDropHelper::new(cx);
    for arm in arms {
        helper.visit_expr(arm);
--- a/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_asserts_for_indexing.rs
@ -8,7 +8,7 @@ use clippy_utils::visitors::for_each_expr_without_closures;
 use clippy_utils::{eq_expr_value, hash_expr, higher};
 use rustc_ast::{LitKind, RangeLimits};
 use rustc_data_structures::packed::Pu128;
-use rustc_data_structures::unhash::UnhashMap;
+use rustc_data_structures::unhash::UnindexMap;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::{BinOp, Block, Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
@ -226,7 +226,7 @@ fn upper_index_expr(expr: &Expr<'_>) -> Option<usize> {
 }

 /// Checks if the expression is an index into a slice and adds it to `indexes`
-fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnhashMap<u64, Vec<IndexEntry<'hir>>>) {
+fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnindexMap<u64, Vec<IndexEntry<'hir>>>) {
    if let ExprKind::Index(slice, index_lit, _) = expr.kind
        && cx.typeck_results().expr_ty_adjusted(slice).peel_refs().is_slice()
        && let Some(index) = upper_index_expr(index_lit)
@ -274,7 +274,7 @@ fn check_index<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut Unh
 }

 /// Checks if the expression is an `assert!` expression and adds it to `asserts`
-fn check_assert<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnhashMap<u64, Vec<IndexEntry<'hir>>>) {
+fn check_assert<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut UnindexMap<u64, Vec<IndexEntry<'hir>>>) {
    if let Some((comparison, asserted_len, slice)) = assert_len_expr(cx, expr) {
        let hash = hash_expr(cx, slice);
        let indexes = map.entry(hash).or_default();
@ -311,7 +311,7 @@ fn check_assert<'hir>(cx: &LateContext<'_>, expr: &'hir Expr<'hir>, map: &mut Un
 /// Inspects indexes and reports lints.
 ///
 /// Called at the end of this lint after all indexing and `assert!` expressions have been collected.
-fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>>) {
+fn report_indexes(cx: &LateContext<'_>, map: &UnindexMap<u64, Vec<IndexEntry<'_>>>) {
    for bucket in map.values() {
        for entry in bucket {
            let Some(full_span) = entry
@ -403,7 +403,7 @@ fn report_indexes(cx: &LateContext<'_>, map: &UnhashMap<u64, Vec<IndexEntry<'_>>

 impl LateLintPass<'_> for MissingAssertsForIndexing {
    fn check_body(&mut self, cx: &LateContext<'_>, body: &Body<'_>) {
-        let mut map = UnhashMap::default();
+        let mut map = UnindexMap::default();

        for_each_expr_without_closures(body.value, |expr| {
            check_index(cx, expr, &mut map);
--- a/src/tools/clippy/clippy_lints/src/module_style.rs
+++ b/src/tools/clippy/clippy_lints/src/module_style.rs
@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::ast;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexSet};
 use rustc_lint::{EarlyContext, EarlyLintPass, Level, LintContext};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LOCAL_CRATE;
@ -87,7 +87,7 @@ impl EarlyLintPass for ModStyle {

        // `folder_segments` is all unique folder path segments `path/to/foo.rs` gives
        // `[path, to]` but not foo
-        let mut folder_segments = FxHashSet::default();
+        let mut folder_segments = FxIndexSet::default();
        // `mod_folders` is all the unique folder names that contain a mod.rs file
        let mut mod_folders = FxHashSet::default();
        // `file_map` maps file names to the full path including the file name
@ -144,7 +144,7 @@ impl EarlyLintPass for ModStyle {
 /// is `mod.rs` we add it's parent folder to `mod_folders`.
 fn process_paths_for_mod_files<'a>(
    path: &'a Path,
-    folder_segments: &mut FxHashSet<&'a OsStr>,
+    folder_segments: &mut FxIndexSet<&'a OsStr>,
    mod_folders: &mut FxHashSet<&'a OsStr>,
 ) {
    let mut comp = path.components().rev().peekable();
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
@ -5,7 +5,7 @@ use clippy_utils::source::snippet;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{inherits_cfg, is_from_proc_macro, is_self};
 use core::ops::ControlFlow;
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap};
+use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
@ -101,7 +101,7 @@ fn check_closures<'tcx>(
    ctx: &mut MutablyUsedVariablesCtxt<'tcx>,
    cx: &LateContext<'tcx>,
    checked_closures: &mut FxHashSet<LocalDefId>,
-    closures: FxHashSet<LocalDefId>,
+    closures: FxIndexSet<LocalDefId>,
 ) {
    let hir = cx.tcx.hir();
    for closure in closures {
@ -196,7 +196,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {
                prev_bind: None,
                prev_move_to_closure: HirIdSet::default(),
                aliases: HirIdMap::default(),
-                async_closures: FxHashSet::default(),
+                async_closures: FxIndexSet::default(),
                tcx: cx.tcx,
            };
            euv::ExprUseVisitor::for_clippy(cx, fn_def_id, &mut ctx)
@ -207,7 +207,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessPassByRefMut<'tcx> {

            // We retrieve all the closures declared in the function because they will not be found
            // by `euv::Delegate`.
-            let mut closures: FxHashSet<LocalDefId> = FxHashSet::default();
+            let mut closures: FxIndexSet<LocalDefId> = FxIndexSet::default();
            for_each_expr(cx, body, |expr| {
                if let ExprKind::Closure(closure) = expr.kind {
                    closures.insert(closure.def_id);
@ -307,7 +307,7 @@ struct MutablyUsedVariablesCtxt<'tcx> {
    /// use of a variable.
    prev_move_to_closure: HirIdSet,
    aliases: HirIdMap<HirId>,
-    async_closures: FxHashSet<LocalDefId>,
+    async_closures: FxIndexSet<LocalDefId>,
    tcx: TyCtxt<'tcx>,
 }

--- a/src/tools/clippy/clippy_lints/src/swap.rs
+++ b/src/tools/clippy/clippy_lints/src/swap.rs
@ -6,9 +6,9 @@ use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{can_mut_borrow_both, eq_expr_value, is_in_const_context, std_or_core};
 use itertools::Itertools;

+use rustc_data_structures::fx::FxIndexSet;
 use rustc_hir::intravisit::{Visitor, walk_expr};

-use crate::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::{BinOpKind, Block, Expr, ExprKind, LetStmt, PatKind, QPath, Stmt, StmtKind};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
@ -334,7 +334,7 @@ struct IndexBinding<'a, 'tcx> {

 impl<'tcx> IndexBinding<'_, 'tcx> {
    fn snippet_index_bindings(&mut self, exprs: &[&'tcx Expr<'tcx>]) -> String {
-        let mut bindings = FxHashSet::default();
+        let mut bindings = FxIndexSet::default();
        for expr in exprs {
            bindings.insert(self.snippet_index_binding(expr));
        }
--- a/src/tools/clippy/clippy_lints/src/trait_bounds.rs
+++ b/src/tools/clippy/clippy_lints/src/trait_bounds.rs
@ -5,7 +5,7 @@ use clippy_utils::source::{SpanRangeExt, snippet, snippet_with_applicability};
 use clippy_utils::{SpanlessEq, SpanlessHash, is_from_proc_macro};
 use core::hash::{Hash, Hasher};
 use itertools::Itertools;
-use rustc_data_structures::fx::{FxHashMap, FxHashSet};
+use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, IndexEntry};
 use rustc_data_structures::unhash::UnhashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@ -16,7 +16,6 @@ use rustc_hir::{
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::{BytePos, Span};
-use std::collections::hash_map::Entry;

 declare_clippy_lint! {
    /// ### What it does
@ -427,7 +426,7 @@ fn rollup_traits(
    bounds: &[GenericBound<'_>],
    msg: &'static str,
 ) -> Vec<(ComparableTraitRef, Span)> {
-    let mut map = FxHashMap::default();
+    let mut map = FxIndexMap::default();
    let mut repeated_res = false;

    let only_comparable_trait_refs = |bound: &GenericBound<'_>| {
@ -442,8 +441,8 @@ fn rollup_traits(
    for bound in bounds.iter().filter_map(only_comparable_trait_refs) {
        let (comparable_bound, span_direct) = bound;
        match map.entry(comparable_bound) {
-            Entry::Occupied(_) => repeated_res = true,
-            Entry::Vacant(e) => {
+            IndexEntry::Occupied(_) => repeated_res = true,
+            IndexEntry::Vacant(e) => {
                e.insert((span_direct, i));
                i += 1;
            },
--- a/tests/crashes/120241-2.rs
+++ b/tests/crashes/120241-2.rs
@ -1,10 +0,0 @@
-//@ known-bug: #120241
-//@ edition:2021
-#![feature(dyn_compatible_for_dispatch)]
-#![feature(unsized_fn_params)]
-
-fn guard(_s: Copy) -> bool {
-    panic!()
-}
-
-fn main() {}
--- a/tests/crashes/120241.rs
+++ b/tests/crashes/120241.rs
@ -1,13 +0,0 @@
-//@ known-bug: #120241
-//@ edition:2021
-#![feature(dyn_compatible_for_dispatch)]
-
-trait B {
-    fn f(a: A) -> A;
-}
-
-trait A {
-    fn g(b: B) -> B;
-}
-
-fn main() {}
--- a/tests/crashes/120482.rs
+++ b/tests/crashes/120482.rs
@ -1,13 +0,0 @@
-//@ known-bug: #120482
-//@ edition:2021
-#![feature(dyn_compatible_for_dispatch)]
-
-trait B {
-    fn bar(&self, x: &Self);
-}
-
-trait A {
-    fn g(new: B) -> B;
-}
-
-fn main() {}
--- a/tests/crashes/125512.rs
+++ b/tests/crashes/125512.rs
@ -1,10 +0,0 @@
-//@ known-bug: rust-lang/rust#125512
-//@ edition:2021
-#![feature(dyn_compatible_for_dispatch)]
-trait B {
-    fn f(a: A) -> A;
-}
-trait A {
-    fn concrete(b: B) -> B;
-}
-fn main() {}
--- a/tests/debuginfo/type-names.rs
+++ b/tests/debuginfo/type-names.rs
@ -17,7 +17,7 @@
 // gdb-check:type = type_names::GenericStruct<type_names::mod1::Struct2, type_names::mod1::mod2::Struct3>

 // gdb-command:whatis generic_struct2
-// gdb-check:type = type_names::GenericStruct<type_names::Struct1, extern "fastcall" fn(isize) -> usize>
+// gdb-check:type = type_names::GenericStruct<type_names::Struct1, extern "system" fn(isize) -> usize>

 // gdb-command:whatis mod_struct
 // gdb-check:type = type_names::mod1::Struct2
@ -372,7 +372,7 @@ fn main() {
    let simple_struct = Struct1;
    let generic_struct1: GenericStruct<mod1::Struct2, mod1::mod2::Struct3> =
        GenericStruct(PhantomData);
-    let generic_struct2: GenericStruct<Struct1, extern "fastcall" fn(isize) -> usize> =
+    let generic_struct2: GenericStruct<Struct1, extern "system" fn(isize) -> usize> =
        GenericStruct(PhantomData);
    let mod_struct = mod1::Struct2;

--- a/tests/ui/abi/unsupported.aarch64.stderr
+++ b/tests/ui/abi/unsupported.aarch64.stderr
@ -1,55 +1,209 @@
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:35:15
+   |
+LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+   = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
+
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:28:1
+  --> $DIR/unsupported.rs:40:1
+   |
+LL | extern "ptx-kernel" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:49:17
+   |
+LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"aapcs"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:62:1
+   |
+LL | extern "aapcs" {}
+   | ^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:71:18
+   |
+LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:76:1
+   |
+LL | extern "msp430-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:81:15
+   |
+LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:86:1
+   |
+LL | extern "avr-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:94:17
+   |
+LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:105:1
+   |
+LL | extern "riscv-interrupt-m" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:116:15
+   |
+LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:127:1
+   |
+LL | extern "x86-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:139:20
+   |
+LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"thiscall"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:152:1
+   |
+LL | extern "thiscall" {}
+   | ^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:170:19
+   |
+LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
+   |                   ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target
+  --> $DIR/unsupported.rs:183:1
+   |
+LL | extern "stdcall" {}
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
+   = note: `#[warn(unsupported_calling_conventions)]` on by default
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:195:21
+   |
+LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:203:22
+   |
+LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:208:1
+   |
+LL | extern "C-cmse-nonsecure-entry" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:33:1
   |
 LL | extern "ptx-kernel" fn ptx() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:30:1
+  --> $DIR/unsupported.rs:43:1
   |
 LL | extern "aapcs" fn aapcs() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:36:1
+  --> $DIR/unsupported.rs:69:1
   |
 LL | extern "msp430-interrupt" fn msp430() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:38:1
+  --> $DIR/unsupported.rs:79:1
   |
 LL | extern "avr-interrupt" fn avr() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:40:1
+  --> $DIR/unsupported.rs:89:1
   |
 LL | extern "riscv-interrupt-m" fn riscv() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:45:1
+  --> $DIR/unsupported.rs:111:1
   |
 LL | extern "x86-interrupt" fn x86() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:50:1
+  --> $DIR/unsupported.rs:133:1
   |
 LL | extern "thiscall" fn thiscall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 warning: use of calling convention not supported on this target
-  --> $DIR/unsupported.rs:56:1
+  --> $DIR/unsupported.rs:159:1
   |
 LL | extern "stdcall" fn stdcall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
-   = note: `#[warn(unsupported_calling_conventions)]` on by default

-error: aborting due to 7 previous errors; 1 warning emitted
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:201:1
+   |
+LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 16 previous errors; 12 warnings emitted

 For more information about this error, try `rustc --explain E0570`.
--- a/tests/ui/abi/unsupported.arm.stderr
+++ b/tests/ui/abi/unsupported.arm.stderr
@ -1,49 +1,188 @@
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:35:15
+   |
+LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+   = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
+
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:28:1
+  --> $DIR/unsupported.rs:40:1
+   |
+LL | extern "ptx-kernel" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:71:18
+   |
+LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:76:1
+   |
+LL | extern "msp430-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:81:15
+   |
+LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:86:1
+   |
+LL | extern "avr-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:94:17
+   |
+LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:105:1
+   |
+LL | extern "riscv-interrupt-m" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:116:15
+   |
+LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:127:1
+   |
+LL | extern "x86-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:139:20
+   |
+LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"thiscall"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:152:1
+   |
+LL | extern "thiscall" {}
+   | ^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:170:19
+   |
+LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
+   |                   ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target
+  --> $DIR/unsupported.rs:183:1
+   |
+LL | extern "stdcall" {}
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
+   = note: `#[warn(unsupported_calling_conventions)]` on by default
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:195:21
+   |
+LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:203:22
+   |
+LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:208:1
+   |
+LL | extern "C-cmse-nonsecure-entry" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:33:1
   |
 LL | extern "ptx-kernel" fn ptx() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:36:1
+  --> $DIR/unsupported.rs:69:1
   |
 LL | extern "msp430-interrupt" fn msp430() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:38:1
+  --> $DIR/unsupported.rs:79:1
   |
 LL | extern "avr-interrupt" fn avr() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:40:1
+  --> $DIR/unsupported.rs:89:1
   |
 LL | extern "riscv-interrupt-m" fn riscv() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:45:1
+  --> $DIR/unsupported.rs:111:1
   |
 LL | extern "x86-interrupt" fn x86() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:50:1
+  --> $DIR/unsupported.rs:133:1
   |
 LL | extern "thiscall" fn thiscall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 warning: use of calling convention not supported on this target
-  --> $DIR/unsupported.rs:56:1
+  --> $DIR/unsupported.rs:159:1
   |
 LL | extern "stdcall" fn stdcall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
-   = note: `#[warn(unsupported_calling_conventions)]` on by default

-error: aborting due to 6 previous errors; 1 warning emitted
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:201:1
+   |
+LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors; 11 warnings emitted

 For more information about this error, try `rustc --explain E0570`.
--- a/tests/ui/abi/unsupported.i686.stderr
+++ b/tests/ui/abi/unsupported.i686.stderr
@ -1,33 +1,139 @@
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:35:15
+   |
+LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+   = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
+
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:28:1
+  --> $DIR/unsupported.rs:40:1
+   |
+LL | extern "ptx-kernel" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:49:17
+   |
+LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"aapcs"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:62:1
+   |
+LL | extern "aapcs" {}
+   | ^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:71:18
+   |
+LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:76:1
+   |
+LL | extern "msp430-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:81:15
+   |
+LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:86:1
+   |
+LL | extern "avr-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:94:17
+   |
+LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:105:1
+   |
+LL | extern "riscv-interrupt-m" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:195:21
+   |
+LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:203:22
+   |
+LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:208:1
+   |
+LL | extern "C-cmse-nonsecure-entry" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:33:1
   |
 LL | extern "ptx-kernel" fn ptx() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:30:1
+  --> $DIR/unsupported.rs:43:1
   |
 LL | extern "aapcs" fn aapcs() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:36:1
+  --> $DIR/unsupported.rs:69:1
   |
 LL | extern "msp430-interrupt" fn msp430() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:38:1
+  --> $DIR/unsupported.rs:79:1
   |
 LL | extern "avr-interrupt" fn avr() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:40:1
+  --> $DIR/unsupported.rs:89:1
   |
 LL | extern "riscv-interrupt-m" fn riscv() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

-error: aborting due to 5 previous errors
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:201:1
+   |
+LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 12 previous errors; 7 warnings emitted

 For more information about this error, try `rustc --explain E0570`.
--- a/tests/ui/abi/unsupported.riscv32.stderr
+++ b/tests/ui/abi/unsupported.riscv32.stderr
@ -1,49 +1,188 @@
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:35:15
+   |
+LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+   = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
+
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:28:1
+  --> $DIR/unsupported.rs:40:1
+   |
+LL | extern "ptx-kernel" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:49:17
+   |
+LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"aapcs"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:62:1
+   |
+LL | extern "aapcs" {}
+   | ^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:71:18
+   |
+LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:76:1
+   |
+LL | extern "msp430-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:81:15
+   |
+LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:86:1
+   |
+LL | extern "avr-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:116:15
+   |
+LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:127:1
+   |
+LL | extern "x86-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:139:20
+   |
+LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"thiscall"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:152:1
+   |
+LL | extern "thiscall" {}
+   | ^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:170:19
+   |
+LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
+   |                   ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target
+  --> $DIR/unsupported.rs:183:1
+   |
+LL | extern "stdcall" {}
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
+   = note: `#[warn(unsupported_calling_conventions)]` on by default
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:195:21
+   |
+LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:203:22
+   |
+LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:208:1
+   |
+LL | extern "C-cmse-nonsecure-entry" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:33:1
   |
 LL | extern "ptx-kernel" fn ptx() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:30:1
+  --> $DIR/unsupported.rs:43:1
   |
 LL | extern "aapcs" fn aapcs() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:36:1
+  --> $DIR/unsupported.rs:69:1
   |
 LL | extern "msp430-interrupt" fn msp430() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:38:1
+  --> $DIR/unsupported.rs:79:1
   |
 LL | extern "avr-interrupt" fn avr() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:45:1
+  --> $DIR/unsupported.rs:111:1
   |
 LL | extern "x86-interrupt" fn x86() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:50:1
+  --> $DIR/unsupported.rs:133:1
   |
 LL | extern "thiscall" fn thiscall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 warning: use of calling convention not supported on this target
-  --> $DIR/unsupported.rs:56:1
+  --> $DIR/unsupported.rs:159:1
   |
 LL | extern "stdcall" fn stdcall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
-   = note: `#[warn(unsupported_calling_conventions)]` on by default

-error: aborting due to 6 previous errors; 1 warning emitted
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:201:1
+   |
+LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors; 11 warnings emitted

 For more information about this error, try `rustc --explain E0570`.
--- a/tests/ui/abi/unsupported.riscv64.stderr
+++ b/tests/ui/abi/unsupported.riscv64.stderr
@ -1,49 +1,188 @@
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:35:15
+   |
+LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+   = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
+
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:28:1
+  --> $DIR/unsupported.rs:40:1
+   |
+LL | extern "ptx-kernel" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:49:17
+   |
+LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"aapcs"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:62:1
+   |
+LL | extern "aapcs" {}
+   | ^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:71:18
+   |
+LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:76:1
+   |
+LL | extern "msp430-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:81:15
+   |
+LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:86:1
+   |
+LL | extern "avr-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:116:15
+   |
+LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:127:1
+   |
+LL | extern "x86-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:139:20
+   |
+LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"thiscall"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:152:1
+   |
+LL | extern "thiscall" {}
+   | ^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:170:19
+   |
+LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
+   |                   ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target
+  --> $DIR/unsupported.rs:183:1
+   |
+LL | extern "stdcall" {}
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
+   = note: `#[warn(unsupported_calling_conventions)]` on by default
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:195:21
+   |
+LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:203:22
+   |
+LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:208:1
+   |
+LL | extern "C-cmse-nonsecure-entry" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:33:1
   |
 LL | extern "ptx-kernel" fn ptx() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:30:1
+  --> $DIR/unsupported.rs:43:1
   |
 LL | extern "aapcs" fn aapcs() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:36:1
+  --> $DIR/unsupported.rs:69:1
   |
 LL | extern "msp430-interrupt" fn msp430() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:38:1
+  --> $DIR/unsupported.rs:79:1
   |
 LL | extern "avr-interrupt" fn avr() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:45:1
+  --> $DIR/unsupported.rs:111:1
   |
 LL | extern "x86-interrupt" fn x86() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:50:1
+  --> $DIR/unsupported.rs:133:1
   |
 LL | extern "thiscall" fn thiscall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 warning: use of calling convention not supported on this target
-  --> $DIR/unsupported.rs:56:1
+  --> $DIR/unsupported.rs:159:1
   |
 LL | extern "stdcall" fn stdcall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
-   = note: `#[warn(unsupported_calling_conventions)]` on by default

-error: aborting due to 6 previous errors; 1 warning emitted
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:201:1
+   |
+LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors; 11 warnings emitted

 For more information about this error, try `rustc --explain E0570`.
--- a/tests/ui/abi/unsupported.rs
+++ b/tests/ui/abi/unsupported.rs
@ -20,39 +20,142 @@
    abi_msp430_interrupt,
    abi_avr_interrupt,
    abi_x86_interrupt,
-    abi_riscv_interrupt
+    abi_riscv_interrupt,
+    abi_c_cmse_nonsecure_call,
+    cmse_nonsecure_entry
 )]
 #[lang = "sized"]
 trait Sized {}

+#[lang = "copy"]
+trait Copy {}
+
 extern "ptx-kernel" fn ptx() {}
 //~^ ERROR is not a supported ABI
+fn ptx_ptr(f: extern "ptx-kernel" fn()) {
+    //~^ WARN unsupported_fn_ptr_calling_conventions
+    //~^^ WARN this was previously accepted
+    f()
+}
+extern "ptx-kernel" {}
+//~^ ERROR is not a supported ABI
+
 extern "aapcs" fn aapcs() {}
 //[x64]~^ ERROR is not a supported ABI
 //[i686]~^^ ERROR is not a supported ABI
 //[aarch64]~^^^ ERROR is not a supported ABI
 //[riscv32]~^^^^ ERROR is not a supported ABI
 //[riscv64]~^^^^^ ERROR is not a supported ABI
+fn aapcs_ptr(f: extern "aapcs" fn()) {
+    //[x64]~^ WARN unsupported_fn_ptr_calling_conventions
+    //[x64]~^^ WARN this was previously accepted
+    //[i686]~^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[i686]~^^^^ WARN this was previously accepted
+    //[aarch64]~^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[aarch64]~^^^^^^ WARN this was previously accepted
+    //[riscv32]~^^^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[riscv32]~^^^^^^^^ WARN this was previously accepted
+    //[riscv64]~^^^^^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[riscv64]~^^^^^^^^^^ WARN this was previously accepted
+    f()
+}
+extern "aapcs" {}
+//[x64]~^ ERROR is not a supported ABI
+//[i686]~^^ ERROR is not a supported ABI
+//[aarch64]~^^^ ERROR is not a supported ABI
+//[riscv32]~^^^^ ERROR is not a supported ABI
+//[riscv64]~^^^^^ ERROR is not a supported ABI
+
 extern "msp430-interrupt" fn msp430() {}
 //~^ ERROR is not a supported ABI
+fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+    //~^ WARN unsupported_fn_ptr_calling_conventions
+    //~^^ WARN this was previously accepted
+    f()
+}
+extern "msp430-interrupt" {}
+//~^ ERROR is not a supported ABI
+
 extern "avr-interrupt" fn avr() {}
 //~^ ERROR is not a supported ABI
+fn avr_ptr(f: extern "avr-interrupt" fn()) {
+    //~^ WARN unsupported_fn_ptr_calling_conventions
+    //~^^ WARN this was previously accepted
+    f()
+}
+extern "avr-interrupt" {}
+//~^ ERROR is not a supported ABI
+
 extern "riscv-interrupt-m" fn riscv() {}
 //[arm]~^ ERROR is not a supported ABI
 //[x64]~^^ ERROR is not a supported ABI
 //[i686]~^^^ ERROR is not a supported ABI
 //[aarch64]~^^^^ ERROR is not a supported ABI
+fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
+    //[arm]~^ WARN unsupported_fn_ptr_calling_conventions
+    //[arm]~^^ WARN this was previously accepted
+    //[x64]~^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[x64]~^^^^ WARN this was previously accepted
+    //[i686]~^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[i686]~^^^^^^ WARN this was previously accepted
+    //[aarch64]~^^^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[aarch64]~^^^^^^^^ WARN this was previously accepted
+    f()
+}
+extern "riscv-interrupt-m" {}
+//[arm]~^ ERROR is not a supported ABI
+//[x64]~^^ ERROR is not a supported ABI
+//[i686]~^^^ ERROR is not a supported ABI
+//[aarch64]~^^^^ ERROR is not a supported ABI
+
 extern "x86-interrupt" fn x86() {}
 //[aarch64]~^ ERROR is not a supported ABI
 //[arm]~^^ ERROR is not a supported ABI
 //[riscv32]~^^^ ERROR is not a supported ABI
 //[riscv64]~^^^^ ERROR is not a supported ABI
+fn x86_ptr(f: extern "x86-interrupt" fn()) {
+    //[aarch64]~^ WARN unsupported_fn_ptr_calling_conventions
+    //[aarch64]~^^ WARN this was previously accepted
+    //[arm]~^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[arm]~^^^^ WARN this was previously accepted
+    //[riscv32]~^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[riscv32]~^^^^^^ WARN this was previously accepted
+    //[riscv64]~^^^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[riscv64]~^^^^^^^^ WARN this was previously accepted
+    f()
+}
+extern "x86-interrupt" {}
+//[aarch64]~^ ERROR is not a supported ABI
+//[arm]~^^ ERROR is not a supported ABI
+//[riscv32]~^^^ ERROR is not a supported ABI
+//[riscv64]~^^^^ ERROR is not a supported ABI
+
 extern "thiscall" fn thiscall() {}
 //[x64]~^ ERROR is not a supported ABI
 //[arm]~^^ ERROR is not a supported ABI
 //[aarch64]~^^^ ERROR is not a supported ABI
 //[riscv32]~^^^^ ERROR is not a supported ABI
 //[riscv64]~^^^^^ ERROR is not a supported ABI
+fn thiscall_ptr(f: extern "thiscall" fn()) {
+    //[x64]~^ WARN unsupported_fn_ptr_calling_conventions
+    //[x64]~^^ WARN this was previously accepted
+    //[arm]~^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[arm]~^^^^ WARN this was previously accepted
+    //[aarch64]~^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[aarch64]~^^^^^^ WARN this was previously accepted
+    //[riscv32]~^^^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[riscv32]~^^^^^^^^ WARN this was previously accepted
+    //[riscv64]~^^^^^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[riscv64]~^^^^^^^^^^ WARN this was previously accepted
+    f()
+}
+extern "thiscall" {}
+//[x64]~^ ERROR is not a supported ABI
+//[arm]~^^ ERROR is not a supported ABI
+//[aarch64]~^^^ ERROR is not a supported ABI
+//[riscv32]~^^^^ ERROR is not a supported ABI
+//[riscv64]~^^^^^ ERROR is not a supported ABI
+
 extern "stdcall" fn stdcall() {}
 //[x64]~^ WARN use of calling convention not supported
 //[x64]~^^ WARN this was previously accepted
@ -64,3 +167,43 @@ extern "stdcall" fn stdcall() {}
 //[riscv32]~^^^^^^^^ WARN this was previously accepted
 //[riscv64]~^^^^^^^^^ WARN use of calling convention not supported
 //[riscv64]~^^^^^^^^^^ WARN this was previously accepted
+fn stdcall_ptr(f: extern "stdcall" fn()) {
+    //[x64]~^ WARN unsupported_fn_ptr_calling_conventions
+    //[x64]~^^ WARN this was previously accepted
+    //[arm]~^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[arm]~^^^^ WARN this was previously accepted
+    //[aarch64]~^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[aarch64]~^^^^^^ WARN this was previously accepted
+    //[riscv32]~^^^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[riscv32]~^^^^^^^^ WARN this was previously accepted
+    //[riscv64]~^^^^^^^^^ WARN unsupported_fn_ptr_calling_conventions
+    //[riscv64]~^^^^^^^^^^ WARN this was previously accepted
+    f()
+}
+extern "stdcall" {}
+//[x64]~^ WARN use of calling convention not supported
+//[x64]~^^ WARN this was previously accepted
+//[arm]~^^^ WARN use of calling convention not supported
+//[arm]~^^^^ WARN this was previously accepted
+//[aarch64]~^^^^^ WARN use of calling convention not supported
+//[aarch64]~^^^^^^ WARN this was previously accepted
+//[riscv32]~^^^^^^^ WARN use of calling convention not supported
+//[riscv32]~^^^^^^^^ WARN this was previously accepted
+//[riscv64]~^^^^^^^^^ WARN use of calling convention not supported
+//[riscv64]~^^^^^^^^^^ WARN this was previously accepted
+
+fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
+    //~^ WARN unsupported_fn_ptr_calling_conventions
+    //~^^ WARN this was previously accepted
+    f()
+}
+
+extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
+//~^ ERROR is not a supported ABI
+fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
+    //~^ WARN unsupported_fn_ptr_calling_conventions
+    //~^^ WARN this was previously accepted
+    f()
+}
+extern "C-cmse-nonsecure-entry" {}
+//~^ ERROR is not a supported ABI
--- a/tests/ui/abi/unsupported.x64.stderr
+++ b/tests/ui/abi/unsupported.x64.stderr
@ -1,49 +1,188 @@
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:35:15
+   |
+LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+   = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
+
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:28:1
+  --> $DIR/unsupported.rs:40:1
+   |
+LL | extern "ptx-kernel" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:49:17
+   |
+LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"aapcs"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:62:1
+   |
+LL | extern "aapcs" {}
+   | ^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:71:18
+   |
+LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:76:1
+   |
+LL | extern "msp430-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:81:15
+   |
+LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:86:1
+   |
+LL | extern "avr-interrupt" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:94:17
+   |
+LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:105:1
+   |
+LL | extern "riscv-interrupt-m" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:139:20
+   |
+LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
+   |                    ^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"thiscall"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:152:1
+   |
+LL | extern "thiscall" {}
+   | ^^^^^^^^^^^^^^^^^^^^
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:170:19
+   |
+LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
+   |                   ^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target
+  --> $DIR/unsupported.rs:183:1
+   |
+LL | extern "stdcall" {}
+   | ^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
+   = note: `#[warn(unsupported_calling_conventions)]` on by default
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:195:21
+   |
+LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+warning: use of calling convention not supported on this target on function pointer
+  --> $DIR/unsupported.rs:203:22
+   |
+LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
+   |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = 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 #130260 <https://github.com/rust-lang/rust/issues/130260>
+
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:208:1
+   |
+LL | extern "C-cmse-nonsecure-entry" {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:33:1
   |
 LL | extern "ptx-kernel" fn ptx() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:30:1
+  --> $DIR/unsupported.rs:43:1
   |
 LL | extern "aapcs" fn aapcs() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:36:1
+  --> $DIR/unsupported.rs:69:1
   |
 LL | extern "msp430-interrupt" fn msp430() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:38:1
+  --> $DIR/unsupported.rs:79:1
   |
 LL | extern "avr-interrupt" fn avr() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:40:1
+  --> $DIR/unsupported.rs:89:1
   |
 LL | extern "riscv-interrupt-m" fn riscv() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:50:1
+  --> $DIR/unsupported.rs:133:1
   |
 LL | extern "thiscall" fn thiscall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 warning: use of calling convention not supported on this target
-  --> $DIR/unsupported.rs:56:1
+  --> $DIR/unsupported.rs:159:1
   |
 LL | extern "stdcall" fn stdcall() {}
   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
   = 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 #87678 <https://github.com/rust-lang/rust/issues/87678>
-   = note: `#[warn(unsupported_calling_conventions)]` on by default

-error: aborting due to 6 previous errors; 1 warning emitted
+error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
+  --> $DIR/unsupported.rs:201:1
+   |
+LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors; 11 warnings emitted

 For more information about this error, try `rustc --explain E0570`.
--- a/tests/ui/associated-type-bounds/suggest-assoc-ty-bound-on-eq-bound.rs
+++ b/tests/ui/associated-type-bounds/suggest-assoc-ty-bound-on-eq-bound.rs
@ -2,28 +2,24 @@
 //@ edition: 2021

 fn f(_: impl Trait<T = Copy>) {}
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
 //~| HELP you might have meant to write a bound here
-//~| ERROR the trait `Copy` cannot be made into an object

 fn g(_: impl Trait<T = std::fmt::Debug + Eq>) {}
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
 //~| HELP you might have meant to write a bound here
-//~| ERROR only auto traits can be used as additional traits in a trait object
-//~| HELP consider creating a new trait
-//~| ERROR the trait `Eq` cannot be made into an object

 fn h(_: impl Trait<T<> = 'static + for<'a> Fn(&'a ())>) {}
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
 //~| HELP you might have meant to write a bound here

 // Don't suggest assoc ty bound in trait object types, that's not valid:
 type Obj = dyn Trait<T = Clone>;
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object

 trait Trait { type T; }

--- a/tests/ui/associated-type-bounds/suggest-assoc-ty-bound-on-eq-bound.stderr
+++ b/tests/ui/associated-type-bounds/suggest-assoc-ty-bound-on-eq-bound.stderr
@ -1,41 +1,10 @@
-error[E0038]: the trait `Copy` cannot be made into an object
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:4:20
-   |
-LL | fn f(_: impl Trait<T = Copy>) {}
-   |                    ^^^^^^^^ `Copy` cannot be made into an object
-   |
-   = note: the trait cannot be made into an object because it requires `Self: Sized`
-   = note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-
-error[E0225]: only auto traits can be used as additional traits in a trait object
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:10:42
-   |
-LL | fn g(_: impl Trait<T = std::fmt::Debug + Eq>) {}
-   |                        ---------------   ^^ additional non-auto trait
-   |                        |
-   |                        first non-auto trait
-   |
-   = help: consider creating a new trait with all of these as supertraits and using that trait here instead: `trait NewTrait: Debug + Eq {}`
-   = note: auto-traits like `Send` and `Sync` are traits that have special properties; for more information on them, visit <https://doc.rust-lang.org/reference/special-types-and-traits.html#auto-traits>
-
-error[E0038]: the trait `Eq` cannot be made into an object
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:10:24
-   |
-LL | fn g(_: impl Trait<T = std::fmt::Debug + Eq>) {}
-   |                        ^^^^^^^^^^^^^^^^^^^^ `Eq` cannot be made into an object
-   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $SRC_DIR/core/src/cmp.rs:LL:COL
-   |
-   = note: the trait cannot be made into an object because it uses `Self` as a type parameter
-
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:4:24
   |
 LL | fn f(_: impl Trait<T = Copy>) {}
   |                        ^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | fn f(_: impl Trait<T = dyn Copy>) {}
   |                        +++
@ -44,13 +13,13 @@ help: you might have meant to write a bound here
 LL | fn f(_: impl Trait<T: Copy>) {}
   |                     ~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:10:24
+error[E0782]: expected a type, found a trait
+  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:9:24
   |
 LL | fn g(_: impl Trait<T = std::fmt::Debug + Eq>) {}
   |                        ^^^^^^^^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | fn g(_: impl Trait<T = dyn std::fmt::Debug + Eq>) {}
   |                        +++
@ -59,13 +28,13 @@ help: you might have meant to write a bound here
 LL | fn g(_: impl Trait<T: std::fmt::Debug + Eq>) {}
   |                     ~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:18:26
+error[E0782]: expected a type, found a trait
+  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:14:26
   |
 LL | fn h(_: impl Trait<T<> = 'static + for<'a> Fn(&'a ())>) {}
   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | fn h(_: impl Trait<T<> = dyn 'static + for<'a> Fn(&'a ())>) {}
   |                          +++
@ -74,18 +43,17 @@ help: you might have meant to write a bound here
 LL | fn h(_: impl Trait<T<>: 'static + for<'a> Fn(&'a ())>) {}
   |                       ~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:24:26
+error[E0782]: expected a type, found a trait
+  --> $DIR/suggest-assoc-ty-bound-on-eq-bound.rs:20:26
   |
 LL | type Obj = dyn Trait<T = Clone>;
   |                          ^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | type Obj = dyn Trait<T = dyn Clone>;
   |                          +++

-error: aborting due to 7 previous errors
+error: aborting due to 4 previous errors

-Some errors have detailed explanations: E0038, E0225, E0782.
-For more information about an error, try `rustc --explain E0038`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.rs
+++ b/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.rs
@ -1,3 +1,5 @@
+//@ only-x86_64
+
 fn efiapi(f: extern "efiapi" fn(usize, ...)) {
    //~^ ERROR: C-variadic function must have a compatible calling convention, like `C` or `cdecl`
    //~^^ ERROR: using calling conventions other than `C` or `cdecl` for varargs functions is unstable
--- a/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.stderr
+++ b/tests/ui/c-variadic/feature-gate-extended_varargs_abi_support.stderr
@ -1,5 +1,5 @@
 error[E0658]: using calling conventions other than `C` or `cdecl` for varargs functions is unstable
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:1:14
+  --> $DIR/feature-gate-extended_varargs_abi_support.rs:3:14
   |
 LL | fn efiapi(f: extern "efiapi" fn(usize, ...)) {
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -9,13 +9,13 @@ LL | fn efiapi(f: extern "efiapi" fn(usize, ...)) {
   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date

 error[E0045]: C-variadic function must have a compatible calling convention, like `C` or `cdecl`
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:1:14
+  --> $DIR/feature-gate-extended_varargs_abi_support.rs:3:14
   |
 LL | fn efiapi(f: extern "efiapi" fn(usize, ...)) {
   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention

 error[E0658]: using calling conventions other than `C` or `cdecl` for varargs functions is unstable
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:6:12
+  --> $DIR/feature-gate-extended_varargs_abi_support.rs:8:12
   |
 LL | fn sysv(f: extern "sysv64" fn(usize, ...)) {
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -25,13 +25,13 @@ LL | fn sysv(f: extern "sysv64" fn(usize, ...)) {
   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date

 error[E0045]: C-variadic function must have a compatible calling convention, like `C` or `cdecl`
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:6:12
+  --> $DIR/feature-gate-extended_varargs_abi_support.rs:8:12
   |
 LL | fn sysv(f: extern "sysv64" fn(usize, ...)) {
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention

 error[E0658]: using calling conventions other than `C` or `cdecl` for varargs functions is unstable
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:11:11
+  --> $DIR/feature-gate-extended_varargs_abi_support.rs:13:11
   |
 LL | fn win(f: extern "win64" fn(usize, ...)) {
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -41,7 +41,7 @@ LL | fn win(f: extern "win64" fn(usize, ...)) {
   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date

 error[E0045]: C-variadic function must have a compatible calling convention, like `C` or `cdecl`
-  --> $DIR/feature-gate-extended_varargs_abi_support.rs:11:11
+  --> $DIR/feature-gate-extended_varargs_abi_support.rs:13:11
   |
 LL | fn win(f: extern "win64" fn(usize, ...)) {
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
--- a/tests/ui/c-variadic/variadic-ffi-2-arm.rs
+++ b/tests/ui/c-variadic/variadic-ffi-2-arm.rs
@ -0,0 +1,9 @@
+//@ only-arm
+//@ build-pass
+#![feature(extended_varargs_abi_support)]
+
+fn aapcs(f: extern "aapcs" fn(usize, ...)) {
+    f(22, 44);
+}
+
+fn main() {}
--- a/tests/ui/c-variadic/variadic-ffi-2.rs
+++ b/tests/ui/c-variadic/variadic-ffi-2.rs
@ -1,6 +1,7 @@
 //@ ignore-arm stdcall isn't supported
 #![feature(extended_varargs_abi_support)]

+#[allow(unsupported_fn_ptr_calling_conventions)]
 fn baz(f: extern "stdcall" fn(usize, ...)) {
    //~^ ERROR: C-variadic function must have a compatible calling convention,
    // like C, cdecl, system, aapcs, win64, sysv64 or efiapi
@ -10,15 +11,22 @@ fn baz(f: extern "stdcall" fn(usize, ...)) {
 fn system(f: extern "system" fn(usize, ...)) {
    f(22, 44);
 }
-fn aapcs(f: extern "aapcs" fn(usize, ...)) {
-    f(22, 44);
-}
+#[cfg(target_arch = "x86_64")]
 fn sysv(f: extern "sysv64" fn(usize, ...)) {
    f(22, 44);
 }
+#[cfg(target_arch = "x86_64")]
 fn win(f: extern "win64" fn(usize, ...)) {
    f(22, 44);
 }
+#[cfg(any(
+    target_arch = "arm",
+    target_arch = "aarch64",
+    target_arch = "riscv32",
+    target_arch = "riscv64",
+    target_arch = "x86",
+    target_arch = "x86_64"
+))]
 fn efiapi(f: extern "efiapi" fn(usize, ...)) {
    f(22, 44);
 }
--- a/tests/ui/c-variadic/variadic-ffi-2.stderr
+++ b/tests/ui/c-variadic/variadic-ffi-2.stderr
@ -1,5 +1,5 @@
 error[E0045]: C-variadic function must have a compatible calling convention, like `C`, `cdecl`, `system`, `aapcs`, `win64`, `sysv64` or `efiapi`
-  --> $DIR/variadic-ffi-2.rs:4:11
+  --> $DIR/variadic-ffi-2.rs:5:11
   |
 LL | fn baz(f: extern "stdcall" fn(usize, ...)) {
   |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.rs
@ -1,8 +1,9 @@
 // gate-test-abi_c_cmse_nonsecure_call
+#[allow(unsupported_fn_ptr_calling_conventions)]
 fn main() {
    let non_secure_function = unsafe {
        core::mem::transmute::<usize, extern "C-cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
-        //~^ ERROR [E0658]
+            //~^ ERROR [E0658]
            0x10000004,
        )
    };
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/gate_test.stderr
@ -1,5 +1,5 @@
 error[E0658]: C-cmse-nonsecure-call ABI is experimental and subject to change
-  --> $DIR/gate_test.rs:4:46
+  --> $DIR/gate_test.rs:5:46
   |
 LL |         core::mem::transmute::<usize, extern "C-cmse-nonsecure-call" fn(i32, i32, i32, i32) -> i32>(
   |                                              ^^^^^^^^^^^^^^^^^^^^^^^
--- a/tests/ui/const-generics/generic_const_exprs/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.rs
+++ b/tests/ui/const-generics/generic_const_exprs/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.rs
@ -14,10 +14,8 @@ fn f<T>(
         1
     }],
 ) -> impl Iterator<Item = SubAssign> {
-//~^ ERROR the type parameter `Rhs` must be explicitly specified
+//~^ ERROR expected a type, found a trait
 //~| ERROR `()` is not an iterator
-//~| ERROR trait objects must include the `dyn` keyword
-//~| ERROR the type parameter `Rhs` must be explicitly specified [E0393]
 }

 pub fn main() {}
--- a/tests/ui/const-generics/generic_const_exprs/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.stderr
+++ b/tests/ui/const-generics/generic_const_exprs/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.stderr
@ -16,37 +16,6 @@ help: you might be missing a type parameter
 LL | fn f<T, F>(
   |       +++

-error[E0393]: the type parameter `Rhs` must be explicitly specified
-  --> $DIR/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.rs:16:27
-   |
-LL | ) -> impl Iterator<Item = SubAssign> {
-   |                           ^^^^^^^^^
-  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-   |
-   = note: type parameter `Rhs` must be specified for this
-   |
-   = note: because of the default `Self` reference, type parameters must be specified on object types
-help: set the type parameter to the desired type
-   |
-LL | ) -> impl Iterator<Item = SubAssign<Rhs>> {
-   |                                    +++++
-
-error[E0393]: the type parameter `Rhs` must be explicitly specified
-  --> $DIR/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.rs:16:27
-   |
-LL | ) -> impl Iterator<Item = SubAssign> {
-   |                           ^^^^^^^^^
-  --> $SRC_DIR/core/src/ops/arith.rs:LL:COL
-   |
-   = note: type parameter `Rhs` must be specified for this
-   |
-   = note: because of the default `Self` reference, type parameters must be specified on object types
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-help: set the type parameter to the desired type
-   |
-LL | ) -> impl Iterator<Item = SubAssign<Rhs>> {
-   |                                    +++++
-
 error[E0277]: `()` is not an iterator
  --> $DIR/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.rs:16:6
   |
@ -55,13 +24,13 @@ LL | ) -> impl Iterator<Item = SubAssign> {
   |
   = help: the trait `Iterator` is not implemented for `()`

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/expected-type-of-closure-body-to-be-a-closure-or-coroutine-ice-113776.rs:16:27
   |
 LL | ) -> impl Iterator<Item = SubAssign> {
   |                           ^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | ) -> impl Iterator<Item = dyn SubAssign> {
   |                           +++
@ -70,7 +39,7 @@ help: you might have meant to write a bound here
 LL | ) -> impl Iterator<Item: SubAssign> {
   |                        ~

-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors

-Some errors have detailed explanations: E0277, E0393, E0412, E0782.
+Some errors have detailed explanations: E0277, E0412, E0782.
 For more information about an error, try `rustc --explain E0277`.
--- a/tests/ui/const-generics/not_wf_param_in_rpitit.rs
+++ b/tests/ui/const-generics/not_wf_param_in_rpitit.rs
@ -1,12 +1,11 @@
 //@ edition:2021

-trait Trait<const N: Trait = bar> {
+trait Trait<const N: dyn Trait = bar> {
    //~^ ERROR: cannot find value `bar` in this scope
    //~| ERROR: cycle detected when computing type of `Trait::N`
    //~| ERROR: the trait `Trait` cannot be made into an object
    //~| ERROR: the trait `Trait` cannot be made into an object
    //~| ERROR: the trait `Trait` cannot be made into an object
-    //~| ERROR: trait objects must include the `dyn` keyword
    async fn a() {}
 }

--- a/tests/ui/const-generics/not_wf_param_in_rpitit.stderr
+++ b/tests/ui/const-generics/not_wf_param_in_rpitit.stderr
@ -1,33 +1,33 @@
 error[E0425]: cannot find value `bar` in this scope
-  --> $DIR/not_wf_param_in_rpitit.rs:3:30
+  --> $DIR/not_wf_param_in_rpitit.rs:3:34
   |
-LL | trait Trait<const N: Trait = bar> {
-   |                              ^^^ not found in this scope
+LL | trait Trait<const N: dyn Trait = bar> {
+   |                                  ^^^ not found in this scope

 error[E0391]: cycle detected when computing type of `Trait::N`
-  --> $DIR/not_wf_param_in_rpitit.rs:3:22
+  --> $DIR/not_wf_param_in_rpitit.rs:3:26
   |
-LL | trait Trait<const N: Trait = bar> {
-   |                      ^^^^^
+LL | trait Trait<const N: dyn Trait = bar> {
+   |                          ^^^^^
   |
   = note: ...which immediately requires computing type of `Trait::N` again
 note: cycle used when computing explicit predicates of trait `Trait`
  --> $DIR/not_wf_param_in_rpitit.rs:3:1
   |
-LL | trait Trait<const N: Trait = bar> {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | trait Trait<const N: dyn Trait = bar> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information

 error[E0038]: the trait `Trait` cannot be made into an object
  --> $DIR/not_wf_param_in_rpitit.rs:3:22
   |
-LL | trait Trait<const N: Trait = bar> {
-   |                      ^^^^^ `Trait` cannot be made into an object
+LL | trait Trait<const N: dyn Trait = bar> {
+   |                      ^^^^^^^^^ `Trait` cannot be made into an object
   |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/not_wf_param_in_rpitit.rs:10:14
+  --> $DIR/not_wf_param_in_rpitit.rs:9:14
   |
-LL | trait Trait<const N: Trait = bar> {
+LL | trait Trait<const N: dyn Trait = bar> {
   |       ----- this trait cannot be made into an object...
 ...
 LL |     async fn a() {}
@ -44,13 +44,13 @@ LL |     async fn a() where Self: Sized {}
 error[E0038]: the trait `Trait` cannot be made into an object
  --> $DIR/not_wf_param_in_rpitit.rs:3:13
   |
-LL | trait Trait<const N: Trait = bar> {
-   |             ^^^^^^^^^^^^^^^^^^^^ `Trait` cannot be made into an object
+LL | trait Trait<const N: dyn Trait = bar> {
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ `Trait` cannot be made into an object
   |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/not_wf_param_in_rpitit.rs:10:14
+  --> $DIR/not_wf_param_in_rpitit.rs:9:14
   |
-LL | trait Trait<const N: Trait = bar> {
+LL | trait Trait<const N: dyn Trait = bar> {
   |       ----- this trait cannot be made into an object...
 ...
 LL |     async fn a() {}
@ -67,13 +67,13 @@ LL |     async fn a() where Self: Sized {}
 error[E0038]: the trait `Trait` cannot be made into an object
  --> $DIR/not_wf_param_in_rpitit.rs:3:13
   |
-LL | trait Trait<const N: Trait = bar> {
-   |             ^^^^^^^^^^^^^^^^^^^^ `Trait` cannot be made into an object
+LL | trait Trait<const N: dyn Trait = bar> {
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^ `Trait` cannot be made into an object
   |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/not_wf_param_in_rpitit.rs:10:14
+  --> $DIR/not_wf_param_in_rpitit.rs:9:14
   |
-LL | trait Trait<const N: Trait = bar> {
+LL | trait Trait<const N: dyn Trait = bar> {
   |       ----- this trait cannot be made into an object...
 ...
 LL |     async fn a() {}
@ -88,18 +88,7 @@ help: alternatively, consider constraining `a` so it does not apply to trait obj
 LL |     async fn a() where Self: Sized {}
   |                  +++++++++++++++++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/not_wf_param_in_rpitit.rs:3:22
-   |
-LL | trait Trait<const N: Trait = bar> {
-   |                      ^^^^^
-   |
-help: add `dyn` keyword before this trait
-   |
-LL | trait Trait<const N: dyn Trait = bar> {
-   |                      +++
+error: aborting due to 5 previous errors

-error: aborting due to 6 previous errors
-
-Some errors have detailed explanations: E0038, E0391, E0425, E0782.
+Some errors have detailed explanations: E0038, E0391, E0425.
 For more information about an error, try `rustc --explain E0038`.
--- a/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.new.stderr
+++ b/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.new.stderr
@ -1,41 +1,19 @@
-error[E0038]: the trait `Copy` cannot be made into an object
+error[E0782]: expected a type, found a trait
  --> $DIR/avoid-ice-on-warning-2.rs:4:13
   |
 LL | fn id<F>(f: Copy) -> usize {
-   |             ^^^^ `Copy` cannot be made into an object
+   |             ^^^^
   |
-   = note: the trait cannot be made into an object because it requires `Self: Sized`
-   = note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-
-error[E0618]: expected function, found `(dyn Copy + 'static)`
-  --> $DIR/avoid-ice-on-warning-2.rs:11:5
+   = note: `Copy` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `Copy`
   |
-LL | fn id<F>(f: Copy) -> usize {
-   |          - `f` has type `(dyn Copy + 'static)`
-...
-LL |     f()
-   |     ^--
-   |     |
-   |     call expression requires function
-
-error[E0277]: the size for values of type `(dyn Copy + 'static)` cannot be known at compilation time
-  --> $DIR/avoid-ice-on-warning-2.rs:4:13
-   |
-LL | fn id<F>(f: Copy) -> usize {
-   |             ^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `(dyn Copy + 'static)`
-   = help: unsized fn params are gated as an unstable feature
-help: you can use `impl Trait` as the argument type
+LL | fn id<F, T: Copy>(f: T) -> usize {
+   |        +++++++++     ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
 LL | fn id<F>(f: impl Copy) -> usize {
   |             ++++
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn id<F>(f: &dyn Copy) -> usize {
-   |             ++++

-error: aborting due to 3 previous errors
+error: aborting due to 1 previous error

-Some errors have detailed explanations: E0038, E0277, E0618.
-For more information about an error, try `rustc --explain E0038`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.old.stderr
+++ b/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.old.stderr
@ -36,7 +36,7 @@ LL | fn id<F>(f: Copy) -> usize {
   = note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>

 error[E0618]: expected function, found `(dyn Copy + 'static)`
-  --> $DIR/avoid-ice-on-warning-2.rs:11:5
+  --> $DIR/avoid-ice-on-warning-2.rs:12:5
   |
 LL | fn id<F>(f: Copy) -> usize {
   |          - `f` has type `(dyn Copy + 'static)`
--- a/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.rs
+++ b/tests/ui/dyn-compatibility/avoid-ice-on-warning-2.rs
@ -2,13 +2,14 @@
 //@[old] edition:2015
 //@[new] edition:2021
 fn id<F>(f: Copy) -> usize {
-//~^ ERROR the trait `Copy` cannot be made into an object
-//~| ERROR: the size for values of type `(dyn Copy + 'static)`
+//[new]~^ ERROR expected a type, found a trait
+//[old]~^^ ERROR the trait `Copy` cannot be made into an object
+//[old]~| ERROR the size for values of type `(dyn Copy + 'static)`
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
 //[old]~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
 //[old]~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
    f()
-    //~^ ERROR: expected function, found `(dyn Copy + 'static)`
+    //[old]~^ ERROR: expected function, found `(dyn Copy + 'static)`
 }
 fn main() {}
--- a/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.new.stderr
+++ b/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.new.stderr
@ -1,47 +1,57 @@
-error[E0038]: the trait `A` cannot be made into an object
+error[E0782]: expected a type, found a trait
+  --> $DIR/avoid-ice-on-warning-3.rs:14:19
+   |
+LL | trait A { fn g(b: B) -> B; }
+   |                   ^
+   |
+   = note: `B` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `B`
+   |
+LL | trait A { fn g<T: B>(b: T) -> B; }
+   |               ++++++    ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+   |
+LL | trait A { fn g(b: impl B) -> B; }
+   |                   ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/avoid-ice-on-warning-3.rs:14:25
+   |
+LL | trait A { fn g(b: B) -> B; }
+   |                         ^
+   |
+help: `B` is dyn-incompatible, use `impl B` to return an opaque type, as long as you return a single underlying type
+   |
+LL | trait A { fn g(b: B) -> impl B; }
+   |                         ++++
+
+error[E0782]: expected a type, found a trait
  --> $DIR/avoid-ice-on-warning-3.rs:4:19
   |
 LL | trait B { fn f(a: A) -> A; }
-   |                   ^ `A` cannot be made into an object
+   |                   ^
   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/avoid-ice-on-warning-3.rs:12:14
+   = note: `A` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `A`
   |
-LL | trait A { fn g(b: B) -> B; }
-   |       -      ^ ...because associated function `g` has no `self` parameter
-   |       |
-   |       this trait cannot be made into an object...
-help: consider turning `g` into a method by giving it a `&self` argument
+LL | trait B { fn f<T: A>(a: T) -> A; }
+   |               ++++++    ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
   |
-LL | trait A { fn g(&self, b: B) -> B; }
-   |                ++++++
-help: alternatively, consider constraining `g` so it does not apply to trait objects
-   |
-LL | trait A { fn g(b: B) -> B where Self: Sized; }
-   |                           +++++++++++++++++
+LL | trait B { fn f(a: impl A) -> A; }
+   |                   ++++

-error[E0038]: the trait `B` cannot be made into an object
-  --> $DIR/avoid-ice-on-warning-3.rs:12:19
-   |
-LL | trait A { fn g(b: B) -> B; }
-   |                   ^ `B` cannot be made into an object
-   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/avoid-ice-on-warning-3.rs:4:14
+error[E0782]: expected a type, found a trait
+  --> $DIR/avoid-ice-on-warning-3.rs:4:25
   |
 LL | trait B { fn f(a: A) -> A; }
-   |       -      ^ ...because associated function `f` has no `self` parameter
-   |       |
-   |       this trait cannot be made into an object...
-help: consider turning `f` into a method by giving it a `&self` argument
+   |                         ^
   |
-LL | trait B { fn f(&self, a: A) -> A; }
-   |                ++++++
-help: alternatively, consider constraining `f` so it does not apply to trait objects
+help: `A` is dyn-incompatible, use `impl A` to return an opaque type, as long as you return a single underlying type
   |
-LL | trait B { fn f(a: A) -> A where Self: Sized; }
-   |                           +++++++++++++++++
+LL | trait B { fn f(a: A) -> impl A; }
+   |                         ++++

-error: aborting due to 2 previous errors
+error: aborting due to 4 previous errors

-For more information about this error, try `rustc --explain E0038`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.old.stderr
+++ b/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.old.stderr
@ -26,7 +26,7 @@ LL | trait B { fn f(a: A) -> dyn A; }
   |                         +++

 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/avoid-ice-on-warning-3.rs:12:19
+  --> $DIR/avoid-ice-on-warning-3.rs:14:19
   |
 LL | trait A { fn g(b: B) -> B; }
   |                   ^
@ -39,7 +39,7 @@ LL | trait A { fn g(b: dyn B) -> B; }
   |                   +++

 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/avoid-ice-on-warning-3.rs:12:25
+  --> $DIR/avoid-ice-on-warning-3.rs:14:25
   |
 LL | trait A { fn g(b: B) -> B; }
   |                         ^
@ -72,7 +72,7 @@ LL | trait B { fn f(a: A) -> A; }
   |                   ^ `A` cannot be made into an object
   |
 note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/avoid-ice-on-warning-3.rs:12:14
+  --> $DIR/avoid-ice-on-warning-3.rs:14:14
   |
 LL | trait A { fn g(b: B) -> B; }
   |       -      ^ ...because associated function `g` has no `self` parameter
@ -88,7 +88,7 @@ LL | trait A { fn g(b: B) -> B where Self: Sized; }
   |                           +++++++++++++++++

 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/avoid-ice-on-warning-3.rs:12:19
+  --> $DIR/avoid-ice-on-warning-3.rs:14:19
   |
 LL | trait A { fn g(b: B) -> B; }
   |                   ^
@ -102,7 +102,7 @@ LL | trait A { fn g(b: dyn B) -> B; }
   |                   +++

 error[E0038]: the trait `B` cannot be made into an object
-  --> $DIR/avoid-ice-on-warning-3.rs:12:19
+  --> $DIR/avoid-ice-on-warning-3.rs:14:19
   |
 LL | trait A { fn g(b: B) -> B; }
   |                   ^ `B` cannot be made into an object
--- a/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.rs
+++ b/tests/ui/dyn-compatibility/avoid-ice-on-warning-3.rs
@ -2,7 +2,9 @@
 //@[old] edition:2015
 //@[new] edition:2021
 trait B { fn f(a: A) -> A; }
-//~^ ERROR the trait `A` cannot be made into an object
+//[new]~^ ERROR expected a type, found a trait
+//[new]~| ERROR expected a type, found a trait
+//[old]~^^^ ERROR the trait `A` cannot be made into an object
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
@ -10,7 +12,9 @@ trait B { fn f(a: A) -> A; }
 //[old]~| WARN this is accepted in the current edition
 //[old]~| WARN this is accepted in the current edition
 trait A { fn g(b: B) -> B; }
-//~^ ERROR the trait `B` cannot be made into an object
+//[new]~^ ERROR expected a type, found a trait
+//[new]~| ERROR expected a type, found a trait
+//[old]~^^^ ERROR the trait `B` cannot be made into an object
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
--- a/tests/ui/dyn-compatibility/avoid-ice-on-warning.new.stderr
+++ b/tests/ui/dyn-compatibility/avoid-ice-on-warning.new.stderr
@ -15,6 +15,18 @@ error[E0405]: cannot find trait `call_that` in this scope
 LL | fn call_this<F>(f: F) : Fn(&str) + call_that {}
   |                                    ^^^^^^^^^ not found in this scope

-error: aborting due to 2 previous errors
+error[E0782]: expected a type, found a trait
+  --> $DIR/avoid-ice-on-warning.rs:4:25
+   |
+LL | fn call_this<F>(f: F) : Fn(&str) + call_that {}
+   |                         ^^^^^^^^^^^^^^^^^^^^
+   |
+help: `Fn(&str) + call_that` is dyn-incompatible, use `impl Fn(&str) + call_that` to return an opaque type, as long as you return a single underlying type
+   |
+LL | fn call_this<F>(f: F) : impl Fn(&str) + call_that {}
+   |                         ++++

-For more information about this error, try `rustc --explain E0405`.
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0405, E0782.
+For more information about an error, try `rustc --explain E0405`.
--- a/tests/ui/dyn-compatibility/avoid-ice-on-warning.rs
+++ b/tests/ui/dyn-compatibility/avoid-ice-on-warning.rs
@ -4,6 +4,7 @@
 fn call_this<F>(f: F) : Fn(&str) + call_that {}
 //~^ ERROR return types are denoted using `->`
 //~| ERROR cannot find trait `call_that` in this scope
+//[new]~| ERROR expected a type, found a trait
 //[old]~| WARN trait objects without an explicit `dyn` are deprecated
 //[old]~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
 fn main() {}
--- a/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.new.fixed
+++ b/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.new.fixed
@ -4,7 +4,8 @@
 //@[new] run-rustfix
 #![deny(bare_trait_objects)]
 fn ord_prefer_dot(s: String) -> impl Ord {
-    //~^ ERROR the trait `Ord` cannot be made into an object
+    //[new]~^ ERROR expected a type, found a trait
+    //[old]~^^ ERROR the trait `Ord` cannot be made into an object
    //[old]~| ERROR trait objects without an explicit `dyn` are deprecated
    //[old]~| WARNING this is accepted in the current edition (Rust 2015)
    (s.starts_with("."), s)
--- a/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.new.stderr
+++ b/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.new.stderr
@ -1,21 +1,14 @@
-error[E0038]: the trait `Ord` cannot be made into an object
+error[E0782]: expected a type, found a trait
  --> $DIR/bare-trait-dont-suggest-dyn.rs:6:33
   |
 LL | fn ord_prefer_dot(s: String) -> Ord {
-   |                                 ^^^ `Ord` cannot be made into an object
+   |                                 ^^^
   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $SRC_DIR/core/src/cmp.rs:LL:COL
-   |
-   = note: the trait cannot be made into an object because it uses `Self` as a type parameter
-  ::: $SRC_DIR/core/src/cmp.rs:LL:COL
-   |
-   = note: the trait cannot be made into an object because it uses `Self` as a type parameter
-help: consider using an opaque type instead
+help: `Ord` is dyn-incompatible, use `impl Ord` to return an opaque type, as long as you return a single underlying type
   |
 LL | fn ord_prefer_dot(s: String) -> impl Ord {
   |                                 ++++

 error: aborting due to 1 previous error

-For more information about this error, try `rustc --explain E0038`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.rs
+++ b/tests/ui/dyn-compatibility/bare-trait-dont-suggest-dyn.rs
@ -4,7 +4,8 @@
 //@[new] run-rustfix
 #![deny(bare_trait_objects)]
 fn ord_prefer_dot(s: String) -> Ord {
-    //~^ ERROR the trait `Ord` cannot be made into an object
+    //[new]~^ ERROR expected a type, found a trait
+    //[old]~^^ ERROR the trait `Ord` cannot be made into an object
    //[old]~| ERROR trait objects without an explicit `dyn` are deprecated
    //[old]~| WARNING this is accepted in the current edition (Rust 2015)
    (s.starts_with("."), s)
--- a/tests/ui/dyn-compatibility/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs
+++ b/tests/ui/dyn-compatibility/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs
@ -6,104 +6,102 @@ struct IceCream;

 impl IceCream {
    fn foo(_: &Trait) {}
-    //~^ ERROR: trait objects must include the `dyn` keyword
+    //~^ ERROR: expected a type, found a trait

    fn bar(self, _: &'a Trait) {}
-    //~^ ERROR: trait objects must include the `dyn` keyword
+    //~^ ERROR: expected a type, found a trait
    //~| ERROR: use of undeclared lifetime name

    fn alice<'a>(&self, _: &Trait) {}
-    //~^ ERROR: trait objects must include the `dyn` keyword
+    //~^ ERROR: expected a type, found a trait

    fn bob<'a>(_: &'a Trait) {}
-    //~^ ERROR: trait objects must include the `dyn` keyword
+    //~^ ERROR: expected a type, found a trait

    fn cat() -> &Trait {
        //~^ ERROR: missing lifetime specifier
-        //~| ERROR: trait objects must include the `dyn` keyword
+        //~| ERROR: expected a type, found a trait
        &Type
    }

    fn dog<'a>() -> &Trait {
        //~^ ERROR: missing lifetime specifier
-        //~| ERROR: trait objects must include the `dyn` keyword
+        //~| ERROR: expected a type, found a trait
        &Type
    }

    fn kitten() -> &'a Trait {
        //~^ ERROR: use of undeclared lifetime name
-        //~| ERROR: trait objects must include the `dyn` keyword
+        //~| ERROR: expected a type, found a trait
        &Type
    }

    fn puppy<'a>() -> &'a Trait {
-        //~^ ERROR: trait objects must include the `dyn` keyword
+        //~^ ERROR: expected a type, found a trait
        &Type
    }

    fn parrot() -> &mut Trait {
        //~^ ERROR: missing lifetime specifier
-        //~| ERROR: trait objects must include the `dyn` keyword
+        //~| ERROR: expected a type, found a trait
        &mut Type
-        //~^ ERROR: cannot return reference to temporary value
    }
 }

 trait Sing {
    fn foo(_: &Trait);
-    //~^ ERROR: trait objects must include the `dyn` keyword
+    //~^ ERROR: expected a type, found a trait

    fn bar(_: &'a Trait);
-    //~^ ERROR: trait objects must include the `dyn` keyword
+    //~^ ERROR: expected a type, found a trait
    //~| ERROR: use of undeclared lifetime name

    fn alice<'a>(_: &Trait);
-    //~^ ERROR: trait objects must include the `dyn` keyword
+    //~^ ERROR: expected a type, found a trait

    fn bob<'a>(_: &'a Trait);
-    //~^ ERROR: trait objects must include the `dyn` keyword
+    //~^ ERROR: expected a type, found a trait

    fn cat() -> &Trait;
        //~^ ERROR: missing lifetime specifier
-        //~| ERROR: trait objects must include the `dyn` keyword
+        //~| ERROR: expected a type, found a trait

    fn dog<'a>() -> &Trait {
        //~^ ERROR: missing lifetime specifier
-        //~| ERROR: trait objects must include the `dyn` keyword
+        //~| ERROR: expected a type, found a trait
        &Type
    }

    fn kitten() -> &'a Trait {
        //~^ ERROR: use of undeclared lifetime name
-        //~| ERROR: trait objects must include the `dyn` keyword
+        //~| ERROR: expected a type, found a trait
        &Type
    }

    fn puppy<'a>() -> &'a Trait {
-        //~^ ERROR: trait objects must include the `dyn` keyword
+        //~^ ERROR: expected a type, found a trait
        &Type
    }

    fn parrot() -> &mut Trait {
        //~^ ERROR: missing lifetime specifier
-        //~| ERROR: trait objects must include the `dyn` keyword
+        //~| ERROR: expected a type, found a trait
        &mut Type
-        //~^ ERROR: cannot return reference to temporary value
    }
 }

 fn foo(_: &Trait) {}
-//~^ ERROR: trait objects must include the `dyn` keyword
+//~^ ERROR: expected a type, found a trait

 fn bar(_: &'a Trait) {}
-//~^ ERROR: trait objects must include the `dyn` keyword
+//~^ ERROR: expected a type, found a trait
 //~| ERROR: use of undeclared lifetime name

 fn alice<'a>(_: &Trait) {}
-//~^ ERROR: trait objects must include the `dyn` keyword
+//~^ ERROR: expected a type, found a trait

 fn bob<'a>(_: &'a Trait) {}
-//~^ ERROR: trait objects must include the `dyn` keyword
+//~^ ERROR: expected a type, found a trait

 struct Type;

@ -111,32 +109,31 @@ impl Trait for Type {}

 fn cat() -> &Trait {
 //~^ ERROR: missing lifetime specifier
-//~| ERROR: trait objects must include the `dyn` keyword
+//~| ERROR: expected a type, found a trait
    &Type
 }

 fn dog<'a>() -> &Trait {
 //~^ ERROR: missing lifetime specifier
-//~| ERROR: trait objects must include the `dyn` keyword
+//~| ERROR: expected a type, found a trait
    &Type
 }

 fn kitten() -> &'a Trait {
 //~^ ERROR: use of undeclared lifetime name
-//~| ERROR: trait objects must include the `dyn` keyword
+//~| ERROR: expected a type, found a trait
    &Type
 }

 fn puppy<'a>() -> &'a Trait {
-//~^ ERROR: trait objects must include the `dyn` keyword
+//~^ ERROR: expected a type, found a trait
    &Type
 }

 fn parrot() -> &mut Trait {
    //~^ ERROR: missing lifetime specifier
-    //~| ERROR: trait objects must include the `dyn` keyword
+    //~| ERROR: expected a type, found a trait
    &mut Type
-    //~^ ERROR: cannot return reference to temporary value
 }

 fn main() {}
--- a/tests/ui/dyn-compatibility/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.stderr
+++ b/tests/ui/dyn-compatibility/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.stderr
@ -65,7 +65,7 @@ LL |     fn parrot() -> &'static mut Trait {
   |                     +++++++

 error[E0261]: use of undeclared lifetime name `'a`
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:56:16
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:55:16
   |
 LL |     fn bar(_: &'a Trait);
   |                ^^ undeclared lifetime
@ -80,7 +80,7 @@ LL | trait Sing<'a> {
   |           ++++

 error[E0106]: missing lifetime specifier
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:66:17
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:65:17
   |
 LL |     fn cat() -> &Trait;
   |                 ^ expected named lifetime parameter
@ -97,7 +97,7 @@ LL +     fn cat() -> Trait;
   |

 error[E0106]: missing lifetime specifier
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:70:21
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:69:21
   |
 LL |     fn dog<'a>() -> &Trait {
   |                     ^ expected named lifetime parameter
@ -109,7 +109,7 @@ LL |     fn dog<'a>() -> &'a Trait {
   |                      ++

 error[E0261]: use of undeclared lifetime name `'a`
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:76:21
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:75:21
   |
 LL |     fn kitten() -> &'a Trait {
   |                     ^^ undeclared lifetime
@ -124,7 +124,7 @@ LL | trait Sing<'a> {
   |           ++++

 error[E0106]: missing lifetime specifier
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:87:20
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:86:20
   |
 LL |     fn parrot() -> &mut Trait {
   |                    ^ expected named lifetime parameter
@ -136,7 +136,7 @@ LL |     fn parrot() -> &'static mut Trait {
   |                     +++++++

 error[E0261]: use of undeclared lifetime name `'a`
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:98:12
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:96:12
   |
 LL | fn bar(_: &'a Trait) {}
   |       -    ^^ undeclared lifetime
@ -144,7 +144,7 @@ LL | fn bar(_: &'a Trait) {}
   |       help: consider introducing lifetime `'a` here: `<'a>`

 error[E0106]: missing lifetime specifier
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:112:13
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:110:13
   |
 LL | fn cat() -> &Trait {
   |             ^ expected named lifetime parameter
@ -156,7 +156,7 @@ LL | fn cat() -> &'static Trait {
   |              +++++++

 error[E0106]: missing lifetime specifier
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:118:17
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:116:17
   |
 LL | fn dog<'a>() -> &Trait {
   |                 ^ expected named lifetime parameter
@ -168,7 +168,7 @@ LL | fn dog<'a>() -> &'a Trait {
   |                  ++

 error[E0261]: use of undeclared lifetime name `'a`
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:124:17
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:122:17
   |
 LL | fn kitten() -> &'a Trait {
   |          -      ^^ undeclared lifetime
@ -176,7 +176,7 @@ LL | fn kitten() -> &'a Trait {
   |          help: consider introducing lifetime `'a` here: `<'a>`

 error[E0106]: missing lifetime specifier
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:135:16
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:133:16
   |
 LL | fn parrot() -> &mut Trait {
   |                ^ expected named lifetime parameter
@ -187,35 +187,8 @@ help: consider using the `'static` lifetime, but this is uncommon unless you're
 LL | fn parrot() -> &'static mut Trait {
   |                 +++++++

-error[E0515]: cannot return reference to temporary value
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:47:9
-   |
-LL |         &mut Type
-   |         ^^^^^----
-   |         |    |
-   |         |    temporary value created here
-   |         returns a reference to data owned by the current function
-
-error[E0515]: cannot return reference to temporary value
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:90:9
-   |
-LL |         &mut Type
-   |         ^^^^^----
-   |         |    |
-   |         |    temporary value created here
-   |         returns a reference to data owned by the current function
-
-error[E0515]: cannot return reference to temporary value
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:138:5
-   |
-LL |     &mut Type
-   |     ^^^^^----
-   |     |    |
-   |     |    temporary value created here
-   |     returns a reference to data owned by the current function
-
-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:53:16
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:52:16
   |
 LL |     fn foo(_: &Trait);
   |                ^^^^^
@ -233,8 +206,8 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL |     fn foo(_: &dyn Trait);
   |                +++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:56:19
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:55:19
   |
 LL |     fn bar(_: &'a Trait);
   |                   ^^^^^
@ -252,8 +225,8 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL |     fn bar(_: &'a dyn Trait);
   |                   +++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:60:22
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:59:22
   |
 LL |     fn alice<'a>(_: &Trait);
   |                      ^^^^^
@ -271,8 +244,8 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL |     fn alice<'a>(_: &dyn Trait);
   |                      +++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:63:23
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:62:23
   |
 LL |     fn bob<'a>(_: &'a Trait);
   |                       ^^^^^
@ -290,8 +263,8 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL |     fn bob<'a>(_: &'a dyn Trait);
   |                       +++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:66:18
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:65:18
   |
 LL |     fn cat() -> &Trait;
   |                  ^^^^^
@ -305,8 +278,8 @@ help: alternatively, you can return an owned trait object
 LL |     fn cat() -> Box<dyn Trait>;
   |                 ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:70:22
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:69:22
   |
 LL |     fn dog<'a>() -> &Trait {
   |                      ^^^^^
@ -320,8 +293,8 @@ help: alternatively, you can return an owned trait object
 LL |     fn dog<'a>() -> Box<dyn Trait> {
   |                     ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:76:24
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:75:24
   |
 LL |     fn kitten() -> &'a Trait {
   |                        ^^^^^
@ -335,8 +308,8 @@ help: alternatively, you can return an owned trait object
 LL |     fn kitten() -> Box<dyn Trait> {
   |                    ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:82:27
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:81:27
   |
 LL |     fn puppy<'a>() -> &'a Trait {
   |                           ^^^^^
@ -350,8 +323,8 @@ help: alternatively, you can return an owned trait object
 LL |     fn puppy<'a>() -> Box<dyn Trait> {
   |                       ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:87:25
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:86:25
   |
 LL |     fn parrot() -> &mut Trait {
   |                         ^^^^^
@ -365,8 +338,8 @@ help: alternatively, you can return an owned trait object
 LL |     fn parrot() -> Box<dyn Trait> {
   |                    ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:95:12
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:93:12
   |
 LL | fn foo(_: &Trait) {}
   |            ^^^^^
@ -384,8 +357,8 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL | fn foo(_: &dyn Trait) {}
   |            +++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:98:15
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:96:15
   |
 LL | fn bar(_: &'a Trait) {}
   |               ^^^^^
@ -403,8 +376,8 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL | fn bar(_: &'a dyn Trait) {}
   |               +++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:102:18
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:100:18
   |
 LL | fn alice<'a>(_: &Trait) {}
   |                  ^^^^^
@ -422,8 +395,8 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL | fn alice<'a>(_: &dyn Trait) {}
   |                  +++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:105:19
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:103:19
   |
 LL | fn bob<'a>(_: &'a Trait) {}
   |                   ^^^^^
@ -441,8 +414,8 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL | fn bob<'a>(_: &'a dyn Trait) {}
   |                   +++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:112:14
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:110:14
   |
 LL | fn cat() -> &Trait {
   |              ^^^^^
@ -456,8 +429,8 @@ help: alternatively, you can return an owned trait object
 LL | fn cat() -> Box<dyn Trait> {
   |             ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:118:18
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:116:18
   |
 LL | fn dog<'a>() -> &Trait {
   |                  ^^^^^
@ -471,8 +444,8 @@ help: alternatively, you can return an owned trait object
 LL | fn dog<'a>() -> Box<dyn Trait> {
   |                 ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:124:20
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:122:20
   |
 LL | fn kitten() -> &'a Trait {
   |                    ^^^^^
@ -486,8 +459,8 @@ help: alternatively, you can return an owned trait object
 LL | fn kitten() -> Box<dyn Trait> {
   |                ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:130:23
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:128:23
   |
 LL | fn puppy<'a>() -> &'a Trait {
   |                       ^^^^^
@ -501,8 +474,8 @@ help: alternatively, you can return an owned trait object
 LL | fn puppy<'a>() -> Box<dyn Trait> {
   |                   ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:135:21
+error[E0782]: expected a type, found a trait
+  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:133:21
   |
 LL | fn parrot() -> &mut Trait {
   |                     ^^^^^
@ -516,7 +489,7 @@ help: alternatively, you can return an owned trait object
 LL | fn parrot() -> Box<dyn Trait> {
   |                ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:8:16
   |
 LL |     fn foo(_: &Trait) {}
@ -535,7 +508,7 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL |     fn foo(_: &dyn Trait) {}
   |                +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:11:25
   |
 LL |     fn bar(self, _: &'a Trait) {}
@ -554,7 +527,7 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL |     fn bar(self, _: &'a dyn Trait) {}
   |                         +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:15:29
   |
 LL |     fn alice<'a>(&self, _: &Trait) {}
@ -573,7 +546,7 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL |     fn alice<'a>(&self, _: &dyn Trait) {}
   |                             +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:18:23
   |
 LL |     fn bob<'a>(_: &'a Trait) {}
@ -592,7 +565,7 @@ help: alternatively, use a trait object to accept any type that implements `Trai
 LL |     fn bob<'a>(_: &'a dyn Trait) {}
   |                       +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:21:18
   |
 LL |     fn cat() -> &Trait {
@ -607,7 +580,7 @@ help: alternatively, you can return an owned trait object
 LL |     fn cat() -> Box<dyn Trait> {
   |                 ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:27:22
   |
 LL |     fn dog<'a>() -> &Trait {
@ -622,7 +595,7 @@ help: alternatively, you can return an owned trait object
 LL |     fn dog<'a>() -> Box<dyn Trait> {
   |                     ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:33:24
   |
 LL |     fn kitten() -> &'a Trait {
@ -637,7 +610,7 @@ help: alternatively, you can return an owned trait object
 LL |     fn kitten() -> Box<dyn Trait> {
   |                    ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:39:27
   |
 LL |     fn puppy<'a>() -> &'a Trait {
@ -652,7 +625,7 @@ help: alternatively, you can return an owned trait object
 LL |     fn puppy<'a>() -> Box<dyn Trait> {
   |                       ~~~~~~~~~~~~~~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/reference-to-bare-trait-in-fn-inputs-and-outputs-issue-125139.rs:44:25
   |
 LL |     fn parrot() -> &mut Trait {
@ -667,7 +640,7 @@ help: alternatively, you can return an owned trait object
 LL |     fn parrot() -> Box<dyn Trait> {
   |                    ~~~~~~~~~~~~~~

-error: aborting due to 45 previous errors
+error: aborting due to 42 previous errors

-Some errors have detailed explanations: E0106, E0261, E0515, E0782.
+Some errors have detailed explanations: E0106, E0261, E0782.
 For more information about an error, try `rustc --explain E0106`.
--- a/tests/ui/dyn-keyword/dyn-2021-edition-error.rs
+++ b/tests/ui/dyn-keyword/dyn-2021-edition-error.rs
@ -1,10 +1,10 @@
 //@ edition:2021

 fn function(x: &SomeTrait, y: Box<SomeTrait>) {
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR trait objects must include the `dyn` keyword
+    //~^ ERROR expected a type, found a trait
+    //~| ERROR expected a type, found a trait
    let _x: &SomeTrait = todo!();
-    //~^ ERROR trait objects must include the `dyn` keyword
+    //~^ ERROR expected a type, found a trait
 }

 trait SomeTrait {}
--- a/tests/ui/dyn-keyword/dyn-2021-edition-error.stderr
+++ b/tests/ui/dyn-keyword/dyn-2021-edition-error.stderr
@ -1,4 +1,4 @@
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/dyn-2021-edition-error.rs:3:17
   |
 LL | fn function(x: &SomeTrait, y: Box<SomeTrait>) {
@ -17,24 +17,24 @@ help: alternatively, use a trait object to accept any type that implements `Some
 LL | fn function(x: &dyn SomeTrait, y: Box<SomeTrait>) {
   |                 +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/dyn-2021-edition-error.rs:3:35
   |
 LL | fn function(x: &SomeTrait, y: Box<SomeTrait>) {
   |                                   ^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | fn function(x: &SomeTrait, y: Box<dyn SomeTrait>) {
   |                                   +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/dyn-2021-edition-error.rs:6:14
   |
 LL |     let _x: &SomeTrait = todo!();
   |              ^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL |     let _x: &dyn SomeTrait = todo!();
   |              +++
--- a/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.rs
+++ b/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.rs
@ -9,6 +9,7 @@ impl dyn Trait {
 fn main() {
    match () {
        Trait::CONST => {}
-        //~^ ERROR trait objects must include the `dyn` keyword
+        //~^ ERROR expected a type, found a trait
+        //~| HELP you can add the `dyn` keyword if you want a trait object
    }
 }
--- a/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.stderr
+++ b/tests/ui/dyn-keyword/suggest-dyn-on-bare-trait-in-pat.stderr
@ -1,10 +1,10 @@
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-dyn-on-bare-trait-in-pat.rs:11:9
   |
 LL |         Trait::CONST => {}
   |         ^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL |         <dyn Trait>::CONST => {}
   |         ++++      +
--- a/tests/ui/editions/dyn-trait-sugg-2021.rs
+++ b/tests/ui/editions/dyn-trait-sugg-2021.rs
@ -8,5 +8,5 @@ impl<T> dyn Foo<T> {

 fn main() {
    Foo::hi(123);
-    //~^ ERROR trait objects must include the `dyn` keyword
+    //~^ ERROR expected a type, found a trait
 }
--- a/tests/ui/editions/dyn-trait-sugg-2021.stderr
+++ b/tests/ui/editions/dyn-trait-sugg-2021.stderr
@ -1,10 +1,10 @@
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/dyn-trait-sugg-2021.rs:10:5
   |
 LL |     Foo::hi(123);
   |     ^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL |     <dyn Foo>::hi(123);
   |     ++++    +
--- a/tests/ui/feature-gates/unstable-attribute-rejects-already-stable-features.rs
+++ b/tests/ui/feature-gates/unstable-attribute-rejects-already-stable-features.rs
@ -0,0 +1,10 @@
+//! Ensure #[unstable] doesn't accept already stable features
+
+#![feature(staged_api)]
+#![stable(feature = "rust_test", since = "1.0.0")]
+
+#[unstable(feature = "arbitrary_enum_discriminant", issue = "42")] //~ ERROR can't mark as unstable using an already stable feature
+#[rustc_const_unstable(feature = "arbitrary_enum_discriminant", issue = "42")] //~ ERROR can't mark as unstable using an already stable feature
+const fn my_fun() {}
+
+fn main() {}
--- a/tests/ui/feature-gates/unstable-attribute-rejects-already-stable-features.stderr
+++ b/tests/ui/feature-gates/unstable-attribute-rejects-already-stable-features.stderr
@ -0,0 +1,31 @@
+error: can't mark as unstable using an already stable feature
+  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:6:1
+   |
+LL | #[unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this feature is already stable
+LL | #[rustc_const_unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+LL | const fn my_fun() {}
+   | -------------------- the stability attribute annotates this item
+   |
+help: consider removing the attribute
+  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:6:1
+   |
+LL | #[unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: can't mark as unstable using an already stable feature
+  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:7:1
+   |
+LL | #[rustc_const_unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this feature is already stable
+LL | const fn my_fun() {}
+   | -------------------- the stability attribute annotates this item
+   |
+help: consider removing the attribute
+  --> $DIR/unstable-attribute-rejects-already-stable-features.rs:7:1
+   |
+LL | #[rustc_const_unstable(feature = "arbitrary_enum_discriminant", issue = "42")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
--- a/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2021.stderr
+++ b/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.edition2021.stderr
@ -1,21 +1,14 @@
-error[E0277]: the trait bound `(): AsRef<(dyn for<'a> Fn(&'a ()) + 'static)>` is not satisfied
-  --> $DIR/generic-with-implicit-hrtb-without-dyn.rs:6:13
-   |
-LL | fn ice() -> impl AsRef<Fn(&())> {
-   |             ^^^^^^^^^^^^^^^^^^^ the trait `AsRef<(dyn for<'a> Fn(&'a ()) + 'static)>` is not implemented for `()`
-
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/generic-with-implicit-hrtb-without-dyn.rs:6:24
   |
 LL | fn ice() -> impl AsRef<Fn(&())> {
   |                        ^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | fn ice() -> impl AsRef<dyn Fn(&())> {
   |                        +++

-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error

-Some errors have detailed explanations: E0277, E0782.
-For more information about an error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.rs
+++ b/tests/ui/impl-trait/generic-with-implicit-hrtb-without-dyn.rs
@ -5,8 +5,7 @@

 fn ice() -> impl AsRef<Fn(&())> {
    //[edition2015]~^ ERROR: the trait bound `(): AsRef<(dyn for<'a> Fn(&'a ()) + 'static)>` is not satisfied [E0277]
-    //[edition2021]~^^ ERROR: trait objects must include the `dyn` keyword [E0782]
-    //[edition2021]~| ERROR: the trait bound `(): AsRef<(dyn for<'a> Fn(&'a ()) + 'static)>` is not satisfied [E0277]
+    //[edition2021]~^^ ERROR: expected a type, found a trait [E0782]
    todo!()
 }

--- a/tests/ui/resolve/issue-111312.rs
+++ b/tests/ui/resolve/issue-111312.rs
@ -8,6 +8,5 @@ trait HasNot {}

 fn main() {
    HasNot::has();
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR no function or associated item named `has` found for trait `HasNot`
+    //~^ ERROR expected a type, found a trait
 }
--- a/tests/ui/resolve/issue-111312.stderr
+++ b/tests/ui/resolve/issue-111312.stderr
@ -1,27 +1,14 @@
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/issue-111312.rs:10:5
   |
 LL |     HasNot::has();
   |     ^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL |     <dyn HasNot>::has();
   |     ++++       +

-error[E0599]: no function or associated item named `has` found for trait `HasNot`
-  --> $DIR/issue-111312.rs:10:13
-   |
-LL |     HasNot::has();
-   |             ^^^ function or associated item not found in `HasNot`
-   |
-note: `Has` defines an item `has`
-  --> $DIR/issue-111312.rs:3:1
-   |
-LL | trait Has {
-   | ^^^^^^^^^
+error: aborting due to 1 previous error

-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0599, E0782.
-For more information about an error, try `rustc --explain E0599`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/resolve/issue-111727.rs
+++ b/tests/ui/resolve/issue-111727.rs
@ -2,6 +2,5 @@

 fn main() {
    std::any::Any::create();
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR no function or associated item named `create` found for trait `Any`
+    //~^ ERROR expected a type, found a trait
 }
--- a/tests/ui/resolve/issue-111727.stderr
+++ b/tests/ui/resolve/issue-111727.stderr
@ -1,21 +1,14 @@
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/issue-111727.rs:4:5
   |
 LL |     std::any::Any::create();
   |     ^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL |     <dyn std::any::Any>::create();
   |     ++++              +

-error[E0599]: no function or associated item named `create` found for trait `Any`
-  --> $DIR/issue-111727.rs:4:20
-   |
-LL |     std::any::Any::create();
-   |                    ^^^^^^ function or associated item not found in `Any`
+error: aborting due to 1 previous error

-error: aborting due to 2 previous errors
-
-Some errors have detailed explanations: E0599, E0782.
-For more information about an error, try `rustc --explain E0599`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/rust-2021/ice-return-unsized-can-impl-2.rs
+++ b/tests/ui/rust-2021/ice-return-unsized-can-impl-2.rs
@ -0,0 +1,15 @@
+// Doesn't trigger ICE when returning unsized trait that can be impl
+// issue https://github.com/rust-lang/rust/issues/125512
+//@ edition:2021
+#![feature(dyn_compatible_for_dispatch)]
+trait B {
+    fn f(a: A) -> A;
+    //~^ ERROR: expected a type, found a trait
+    //~| ERROR: expected a type, found a trait
+}
+trait A {
+    fn concrete(b: B) -> B;
+    //~^ ERROR: expected a type, found a trait
+    //~| ERROR: expected a type, found a trait
+}
+fn main() {}
--- a/tests/ui/rust-2021/ice-return-unsized-can-impl-2.stderr
+++ b/tests/ui/rust-2021/ice-return-unsized-can-impl-2.stderr
@ -0,0 +1,57 @@
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-return-unsized-can-impl-2.rs:11:20
+   |
+LL |     fn concrete(b: B) -> B;
+   |                    ^
+   |
+   = note: `B` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `B`
+   |
+LL |     fn concrete<T: B>(b: T) -> B;
+   |                ++++++    ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+   |
+LL |     fn concrete(b: impl B) -> B;
+   |                    ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-return-unsized-can-impl-2.rs:11:26
+   |
+LL |     fn concrete(b: B) -> B;
+   |                          ^
+   |
+help: `B` is dyn-incompatible, use `impl B` to return an opaque type, as long as you return a single underlying type
+   |
+LL |     fn concrete(b: B) -> impl B;
+   |                          ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-return-unsized-can-impl-2.rs:6:13
+   |
+LL |     fn f(a: A) -> A;
+   |             ^
+   |
+   = note: `A` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `A`
+   |
+LL |     fn f<T: A>(a: T) -> A;
+   |         ++++++    ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+   |
+LL |     fn f(a: impl A) -> A;
+   |             ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-return-unsized-can-impl-2.rs:6:19
+   |
+LL |     fn f(a: A) -> A;
+   |                   ^
+   |
+help: `A` is dyn-incompatible, use `impl A` to return an opaque type, as long as you return a single underlying type
+   |
+LL |     fn f(a: A) -> impl A;
+   |                   ++++
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/rust-2021/ice-return-unsized-can-impl.rs
+++ b/tests/ui/rust-2021/ice-return-unsized-can-impl.rs
@ -0,0 +1,16 @@
+// Doesn't trigger ICE when returning unsized trait that can be impl
+// issue https://github.com/rust-lang/rust/issues/120482
+//@ edition:2021
+#![feature(dyn_compatible_for_dispatch)]
+
+trait B {
+    fn bar(&self, x: &Self);
+}
+
+trait A {
+    fn g(new: B) -> B;
+    //~^ ERROR: expected a type, found a trait
+    //~| ERROR: expected a type, found a trait
+}
+
+fn main() {}
--- a/tests/ui/rust-2021/ice-return-unsized-can-impl.stderr
+++ b/tests/ui/rust-2021/ice-return-unsized-can-impl.stderr
@ -0,0 +1,30 @@
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-return-unsized-can-impl.rs:11:15
+   |
+LL |     fn g(new: B) -> B;
+   |               ^
+   |
+   = note: `B` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `B`
+   |
+LL |     fn g<T: B>(new: T) -> B;
+   |         ++++++      ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+   |
+LL |     fn g(new: impl B) -> B;
+   |               ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-return-unsized-can-impl.rs:11:21
+   |
+LL |     fn g(new: B) -> B;
+   |                     ^
+   |
+help: `B` is dyn-incompatible, use `impl B` to return an opaque type, as long as you return a single underlying type
+   |
+LL |     fn g(new: B) -> impl B;
+   |                     ++++
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/rust-2021/ice-unsized-fn-params-2.rs
+++ b/tests/ui/rust-2021/ice-unsized-fn-params-2.rs
@ -0,0 +1,12 @@
+//@ edition:2021
+// Test that it doesn't trigger an ICE when using an unsized fn params.
+// https://github.com/rust-lang/rust/issues/120241
+#![feature(dyn_compatible_for_dispatch)]
+#![feature(unsized_fn_params)]
+
+fn guard(_s: Copy) -> bool {
+    //~^ ERROR: expected a type, found a trait
+    panic!()
+}
+
+fn main() {}
--- a/tests/ui/rust-2021/ice-unsized-fn-params-2.stderr
+++ b/tests/ui/rust-2021/ice-unsized-fn-params-2.stderr
@ -0,0 +1,19 @@
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-unsized-fn-params-2.rs:7:14
+   |
+LL | fn guard(_s: Copy) -> bool {
+   |              ^^^^
+   |
+   = note: `Copy` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `Copy`
+   |
+LL | fn guard<T: Copy>(_s: T) -> bool {
+   |         +++++++++     ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+   |
+LL | fn guard(_s: impl Copy) -> bool {
+   |              ++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/rust-2021/ice-unsized-fn-params.rs
+++ b/tests/ui/rust-2021/ice-unsized-fn-params.rs
@ -0,0 +1,18 @@
+//@ edition:2021
+// Test that it doesn't trigger an ICE when using an unsized fn params.
+// https://github.com/rust-lang/rust/issues/120241
+#![feature(dyn_compatible_for_dispatch)]
+
+trait B {
+    fn f(a: A) -> A;
+    //~^ ERROR: expected a type, found a trait
+    //~| ERROR: expected a type, found a trait
+}
+
+trait A {
+    fn g(b: B) -> B;
+    //~^ ERROR: expected a type, found a trait
+    //~| ERROR: expected a type, found a trait
+}
+
+fn main() {}
--- a/tests/ui/rust-2021/ice-unsized-fn-params.stderr
+++ b/tests/ui/rust-2021/ice-unsized-fn-params.stderr
@ -0,0 +1,57 @@
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-unsized-fn-params.rs:13:13
+   |
+LL |     fn g(b: B) -> B;
+   |             ^
+   |
+   = note: `B` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `B`
+   |
+LL |     fn g<T: B>(b: T) -> B;
+   |         ++++++    ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+   |
+LL |     fn g(b: impl B) -> B;
+   |             ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-unsized-fn-params.rs:13:19
+   |
+LL |     fn g(b: B) -> B;
+   |                   ^
+   |
+help: `B` is dyn-incompatible, use `impl B` to return an opaque type, as long as you return a single underlying type
+   |
+LL |     fn g(b: B) -> impl B;
+   |                   ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-unsized-fn-params.rs:7:13
+   |
+LL |     fn f(a: A) -> A;
+   |             ^
+   |
+   = note: `A` it is dyn-incompatible, so it can't be `dyn`
+help: use a new generic type parameter, constrained by `A`
+   |
+LL |     fn f<T: A>(a: T) -> A;
+   |         ++++++    ~
+help: you can also use an opaque type, but users won't be able to specify the type parameter when calling the `fn`, having to rely exclusively on type inference
+   |
+LL |     fn f(a: impl A) -> A;
+   |             ++++
+
+error[E0782]: expected a type, found a trait
+  --> $DIR/ice-unsized-fn-params.rs:7:19
+   |
+LL |     fn f(a: A) -> A;
+   |                   ^
+   |
+help: `A` is dyn-incompatible, use `impl A` to return an opaque type, as long as you return a single underlying type
+   |
+LL |     fn f(a: A) -> impl A;
+   |                   ++++
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs
+++ b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs
@ -2,24 +2,21 @@
 #![allow(bare_trait_objects)]
 trait A: Sized {
    fn f(a: A) -> A;
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR trait objects must include the `dyn` keyword
+    //~^ ERROR expected a type, found a trait
+    //~| ERROR expected a type, found a trait
    //~| ERROR associated item referring to unboxed trait object for its own trait
-    //~| ERROR the trait `A` cannot be made into an object
 }
 trait B {
    fn f(b: B) -> B;
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR trait objects must include the `dyn` keyword
+    //~^ ERROR expected a type, found a trait
+    //~| ERROR expected a type, found a trait
    //~| ERROR associated item referring to unboxed trait object for its own trait
-    //~| ERROR the trait `B` cannot be made into an object
 }
 trait C {
    fn f(&self, c: C) -> C;
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR trait objects must include the `dyn` keyword
+    //~^ ERROR expected a type, found a trait
+    //~| ERROR expected a type, found a trait
    //~| ERROR associated item referring to unboxed trait object for its own trait
-    //~| ERROR the trait `C` cannot be made into an object
 }

 fn main() {}
--- a/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.stderr
+++ b/tests/ui/suggestions/dyn-incompatible-trait-should-use-self-2021-without-dyn.stderr
@ -11,22 +11,8 @@ help: you might have meant to use `Self` to refer to the implementing type
 LL |     fn f(a: Self) -> Self;
   |             ~~~~     ~~~~

-error[E0038]: the trait `A` cannot be made into an object
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:4:13
-   |
-LL |     fn f(a: A) -> A;
-   |             ^ `A` cannot be made into an object
-   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:3:10
-   |
-LL | trait A: Sized {
-   |       -  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait cannot be made into an object...
-
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:13
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:10:13
   |
 LL | trait B {
   |       - in this trait
@ -38,30 +24,8 @@ help: you might have meant to use `Self` to refer to the implementing type
 LL |     fn f(b: Self) -> Self;
   |             ~~~~     ~~~~

-error[E0038]: the trait `B` cannot be made into an object
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:13
-   |
-LL |     fn f(b: B) -> B;
-   |             ^ `B` cannot be made into an object
-   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:8
-   |
-LL | trait B {
-   |       - this trait cannot be made into an object...
-LL |     fn f(b: B) -> B;
-   |        ^ ...because associated function `f` has no `self` parameter
-help: consider turning `f` into a method by giving it a `&self` argument
-   |
-LL |     fn f(&self, b: B) -> B;
-   |          ++++++
-help: alternatively, consider constraining `f` so it does not apply to trait objects
-   |
-LL |     fn f(b: B) -> B where Self: Sized;
-   |                     +++++++++++++++++
-
 error: associated item referring to unboxed trait object for its own trait
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:20
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:16:20
   |
 LL | trait C {
   |       - in this trait
@ -73,23 +37,7 @@ help: you might have meant to use `Self` to refer to the implementing type
 LL |     fn f(&self, c: Self) -> Self;
   |                    ~~~~     ~~~~

-error[E0038]: the trait `C` cannot be made into an object
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:20
-   |
-LL |     fn f(&self, c: C) -> C;
-   |          -----     ^ `C` cannot be made into an object
-   |          |
-   |          help: consider changing method `f`'s `self` parameter to be `&self` (notice the capitalization): `&Self`
-   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:10
-   |
-LL | trait C {
-   |       - this trait cannot be made into an object...
-LL |     fn f(&self, c: C) -> C;
-   |          ^^^^^ ...because method `f`'s `self` parameter cannot be dispatched on
-
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:4:13
   |
 LL |     fn f(a: A) -> A;
@ -105,7 +53,7 @@ help: you can also use an opaque type, but users won't be able to specify the ty
 LL |     fn f(a: impl A) -> A;
   |             ++++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:4:19
   |
 LL |     fn f(a: A) -> A;
@ -116,8 +64,8 @@ help: `A` is dyn-incompatible, use `impl A` to return an opaque type, as long as
 LL |     fn f(a: A) -> impl A;
   |                   ++++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:13
+error[E0782]: expected a type, found a trait
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:10:13
   |
 LL |     fn f(b: B) -> B;
   |             ^
@ -132,8 +80,8 @@ help: you can also use an opaque type, but users won't be able to specify the ty
 LL |     fn f(b: impl B) -> B;
   |             ++++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:11:19
+error[E0782]: expected a type, found a trait
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:10:19
   |
 LL |     fn f(b: B) -> B;
   |                   ^
@ -143,8 +91,8 @@ help: `B` is dyn-incompatible, use `impl B` to return an opaque type, as long as
 LL |     fn f(b: B) -> impl B;
   |                   ++++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:20
+error[E0782]: expected a type, found a trait
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:16:20
   |
 LL |     fn f(&self, c: C) -> C;
   |                    ^
@ -159,8 +107,8 @@ help: you can also use an opaque type, but users won't be able to specify the ty
 LL |     fn f(&self, c: impl C) -> C;
   |                    ++++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:18:26
+error[E0782]: expected a type, found a trait
+  --> $DIR/dyn-incompatible-trait-should-use-self-2021-without-dyn.rs:16:26
   |
 LL |     fn f(&self, c: C) -> C;
   |                          ^
@ -170,7 +118,6 @@ help: `C` is dyn-incompatible, use `impl C` to return an opaque type, as long as
 LL |     fn f(&self, c: C) -> impl C;
   |                          ++++

-error: aborting due to 12 previous errors
+error: aborting due to 9 previous errors

-Some errors have detailed explanations: E0038, E0782.
-For more information about an error, try `rustc --explain E0038`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/suggestions/issue-116434-2021.rs
+++ b/tests/ui/suggestions/issue-116434-2021.rs
@ -3,7 +3,8 @@
 trait Foo {
    type Clone;
    fn foo() -> Clone;
-    //~^ ERROR the trait `Clone` cannot be made into an object [E0038]
+    //~^ ERROR expected a type, found a trait
+    //~| HELP `Clone` is dyn-incompatible, use `impl Clone` to return an opaque type, as long as you return a single underlying type
    //~| HELP there is an associated type with the same name
 }

@ -12,7 +13,8 @@ trait DbHandle: Sized {}
 trait DbInterface {
    type DbHandle;
    fn handle() -> DbHandle;
-    //~^ ERROR the trait `DbHandle` cannot be made into an object [E0038]
+    //~^ ERROR expected a type, found a trait
+    //~| HELP `DbHandle` is dyn-incompatible, use `impl DbHandle` to return an opaque type, as long as you return a single underlying type
    //~| HELP there is an associated type with the same name
 }

--- a/tests/ui/suggestions/issue-116434-2021.stderr
+++ b/tests/ui/suggestions/issue-116434-2021.stderr
@ -1,29 +1,28 @@
-error[E0038]: the trait `Clone` cannot be made into an object
+error[E0782]: expected a type, found a trait
  --> $DIR/issue-116434-2021.rs:5:17
   |
 LL |     fn foo() -> Clone;
-   |                 ^^^^^ `Clone` cannot be made into an object
+   |                 ^^^^^
   |
-   = note: the trait cannot be made into an object because it requires `Self: Sized`
-   = note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
+help: `Clone` is dyn-incompatible, use `impl Clone` to return an opaque type, as long as you return a single underlying type
+   |
+LL |     fn foo() -> impl Clone;
+   |                 ++++
 help: there is an associated type with the same name
   |
 LL |     fn foo() -> Self::Clone;
   |                 ++++++

-error[E0038]: the trait `DbHandle` cannot be made into an object
-  --> $DIR/issue-116434-2021.rs:14:20
+error[E0782]: expected a type, found a trait
+  --> $DIR/issue-116434-2021.rs:15:20
   |
 LL |     fn handle() -> DbHandle;
-   |                    ^^^^^^^^ `DbHandle` cannot be made into an object
+   |                    ^^^^^^^^
   |
-note: for a trait to be "dyn-compatible" it needs to allow building a vtable to allow the call to be resolvable dynamically; for more information visit <https://doc.rust-lang.org/reference/items/traits.html#object-safety>
-  --> $DIR/issue-116434-2021.rs:10:17
+help: `DbHandle` is dyn-incompatible, use `impl DbHandle` to return an opaque type, as long as you return a single underlying type
   |
-LL | trait DbHandle: Sized {}
-   |       --------  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait cannot be made into an object...
+LL |     fn handle() -> impl DbHandle;
+   |                    ++++
 help: there is an associated type with the same name
   |
 LL |     fn handle() -> Self::DbHandle;
@ -31,4 +30,4 @@ LL |     fn handle() -> Self::DbHandle;

 error: aborting due to 2 previous errors

-For more information about this error, try `rustc --explain E0038`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/suggestions/suggest-blanket-impl-local-trait.rs
+++ b/tests/ui/suggestions/suggest-blanket-impl-local-trait.rs
@ -11,48 +11,48 @@ trait LocalTraitTwo { }
 trait GenericTrait<T> {}

 impl LocalTraitTwo for LocalTraitOne {}
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
 //~| HELP alternatively use a blanket implementation to implement `LocalTraitTwo` for all types that also implement `LocalTraitOne`

 impl fmt::Display for LocalTraitOne {
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
        todo!();
    }
 }

 impl fmt::Display for LocalTraitTwo + Send {
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
    fn fmt(&self, _f: &mut fmt::Formatter<'_>) -> fmt::Result {
        todo!();
    }
 }

 impl LocalTraitOne for fmt::Display {}
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
 //~| HELP alternatively use a blanket implementation to implement `LocalTraitOne` for all types that also implement `fmt::Display`


 impl LocalTraitOne for fmt::Display + Send {}
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
 //~| HELP alternatively use a blanket implementation to implement `LocalTraitOne` for all types that also implement `fmt::Display + Send`


 impl<E> GenericTrait<E> for LocalTraitOne {}
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
 //~| HELP alternatively use a blanket implementation to implement `GenericTrait<E>` for all types that also implement `LocalTraitOne`

 trait GenericTraitTwo<T> {}

 impl<T, E> GenericTraitTwo<E> for GenericTrait<T> {}
-//~^ ERROR trait objects must include the `dyn` keyword
-//~| HELP add `dyn` keyword before this trait
+//~^ ERROR expected a type, found a trait
+//~| HELP you can add the `dyn` keyword if you want a trait object
 //~| HELP alternatively use a blanket implementation to implement `GenericTraitTwo<E>` for all types that also implement `GenericTrait<T>`

 fn main() {}
--- a/tests/ui/suggestions/suggest-blanket-impl-local-trait.stderr
+++ b/tests/ui/suggestions/suggest-blanket-impl-local-trait.stderr
@ -1,10 +1,10 @@
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-blanket-impl-local-trait.rs:34:24
   |
 LL | impl LocalTraitOne for fmt::Display {}
   |                        ^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl LocalTraitOne for dyn fmt::Display {}
   |                        +++
@ -13,13 +13,13 @@ help: alternatively use a blanket implementation to implement `LocalTraitOne` fo
 LL | impl<T: fmt::Display> LocalTraitOne for T {}
   |     +++++++++++++++++                   ~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-blanket-impl-local-trait.rs:40:24
   |
 LL | impl LocalTraitOne for fmt::Display + Send {}
   |                        ^^^^^^^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl LocalTraitOne for dyn fmt::Display + Send {}
   |                        +++
@ -28,13 +28,13 @@ help: alternatively use a blanket implementation to implement `LocalTraitOne` fo
 LL | impl<T: fmt::Display + Send> LocalTraitOne for T {}
   |     ++++++++++++++++++++++++                   ~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-blanket-impl-local-trait.rs:13:24
   |
 LL | impl LocalTraitTwo for LocalTraitOne {}
   |                        ^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl LocalTraitTwo for dyn LocalTraitOne {}
   |                        +++
@ -43,13 +43,13 @@ help: alternatively use a blanket implementation to implement `LocalTraitTwo` fo
 LL | impl<T: LocalTraitOne> LocalTraitTwo for T {}
   |     ++++++++++++++++++                   ~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-blanket-impl-local-trait.rs:46:29
   |
 LL | impl<E> GenericTrait<E> for LocalTraitOne {}
   |                             ^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl<E> GenericTrait<E> for dyn LocalTraitOne {}
   |                             +++
@ -58,35 +58,35 @@ help: alternatively use a blanket implementation to implement `GenericTrait<E>`
 LL | impl<E, T: LocalTraitOne> GenericTrait<E> for T {}
   |       ++++++++++++++++++                      ~

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-blanket-impl-local-trait.rs:18:23
   |
 LL | impl fmt::Display for LocalTraitOne {
   |                       ^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl fmt::Display for dyn LocalTraitOne {
   |                       +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-blanket-impl-local-trait.rs:26:23
   |
 LL | impl fmt::Display for LocalTraitTwo + Send {
   |                       ^^^^^^^^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl fmt::Display for dyn LocalTraitTwo + Send {
   |                       +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-blanket-impl-local-trait.rs:53:35
   |
 LL | impl<T, E> GenericTraitTwo<E> for GenericTrait<T> {}
   |                                   ^^^^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl<T, E> GenericTraitTwo<E> for dyn GenericTrait<T> {}
   |                                   +++
--- a/tests/ui/suggestions/suggest-swapping-self-ty-and-trait-edition-2021.rs
+++ b/tests/ui/suggestions/suggest-swapping-self-ty-and-trait-edition-2021.rs
@ -14,14 +14,14 @@ pub union Union<T> {

 impl<'a, T> Struct<T> for Trait<'a, T> {}
 //~^ ERROR expected trait, found struct `Struct`
-//~| ERROR trait objects must include the `dyn` keyword
+//~| ERROR expected a type, found a trait

 impl<'a, T> Enum<T> for Trait<'a, T> {}
 //~^ ERROR expected trait, found enum `Enum`
-//~| ERROR trait objects must include the `dyn` keyword
+//~| ERROR expected a type, found a trait

 impl<'a, T> Union<T> for Trait<'a, T> {}
 //~^ ERROR expected trait, found union `Union`
-//~| ERROR trait objects must include the `dyn` keyword
+//~| ERROR expected a type, found a trait

 fn main() {}
--- a/tests/ui/suggestions/suggest-swapping-self-ty-and-trait-edition-2021.stderr
+++ b/tests/ui/suggestions/suggest-swapping-self-ty-and-trait-edition-2021.stderr
@ -58,35 +58,35 @@ LL | pub union Union<T> {
   = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
   = help: if you intended `T` to be a const parameter, use `const T: /* Type */` instead

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-swapping-self-ty-and-trait-edition-2021.rs:15:27
   |
 LL | impl<'a, T> Struct<T> for Trait<'a, T> {}
   |                           ^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl<'a, T> Struct<T> for dyn Trait<'a, T> {}
   |                           +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-swapping-self-ty-and-trait-edition-2021.rs:19:25
   |
 LL | impl<'a, T> Enum<T> for Trait<'a, T> {}
   |                         ^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl<'a, T> Enum<T> for dyn Trait<'a, T> {}
   |                         +++

-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/suggest-swapping-self-ty-and-trait-edition-2021.rs:23:26
   |
 LL | impl<'a, T> Union<T> for Trait<'a, T> {}
   |                          ^^^^^^^^^^^^
   |
-help: add `dyn` keyword before this trait
+help: you can add the `dyn` keyword if you want a trait object
   |
 LL | impl<'a, T> Union<T> for dyn Trait<'a, T> {}
   |                          +++
--- a/tests/ui/traits/bound/not-on-bare-trait-2021.rs
+++ b/tests/ui/traits/bound/not-on-bare-trait-2021.rs
@ -6,13 +6,11 @@ trait Foo {
 // This should emit the less confusing error, not the more confusing one.

 fn foo(_x: Foo + Send) {
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR size for values of type
+    //~^ ERROR expected a type, found a trait
 }
 fn bar(x: Foo) -> Foo {
-    //~^ ERROR trait objects must include the `dyn` keyword
-    //~| ERROR trait objects must include the `dyn` keyword
-    //~| ERROR size for values of type
+    //~^ ERROR expected a type, found a trait
+    //~| ERROR expected a type, found a trait
    x
 }

--- a/tests/ui/traits/bound/not-on-bare-trait-2021.stderr
+++ b/tests/ui/traits/bound/not-on-bare-trait-2021.stderr
@ -1,38 +1,4 @@
-error[E0277]: the size for values of type `(dyn Foo + Send + 'static)` cannot be known at compilation time
-  --> $DIR/not-on-bare-trait-2021.rs:8:12
-   |
-LL | fn foo(_x: Foo + Send) {
-   |            ^^^^^^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `(dyn Foo + Send + 'static)`
-   = help: unsized fn params are gated as an unstable feature
-help: you can use `impl Trait` as the argument type
-   |
-LL | fn foo(_x: impl Foo + Send) {
-   |            ++++
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn foo(_x: &(dyn Foo + Send)) {
-   |            +++++           +
-
-error[E0277]: the size for values of type `(dyn Foo + 'static)` cannot be known at compilation time
-  --> $DIR/not-on-bare-trait-2021.rs:12:11
-   |
-LL | fn bar(x: Foo) -> Foo {
-   |           ^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `(dyn Foo + 'static)`
-   = help: unsized fn params are gated as an unstable feature
-help: you can use `impl Trait` as the argument type
-   |
-LL | fn bar(x: impl Foo) -> Foo {
-   |           ++++
-help: function arguments must have a statically known size, borrowed types always have a known size
-   |
-LL | fn bar(x: &dyn Foo) -> Foo {
-   |           ++++
-
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/not-on-bare-trait-2021.rs:8:12
   |
 LL | fn foo(_x: Foo + Send) {
@ -51,8 +17,8 @@ help: alternatively, use a trait object to accept any type that implements `Foo
 LL | fn foo(_x: &(dyn Foo + Send)) {
   |            +++++           +

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/not-on-bare-trait-2021.rs:12:11
+error[E0782]: expected a type, found a trait
+  --> $DIR/not-on-bare-trait-2021.rs:11:11
   |
 LL | fn bar(x: Foo) -> Foo {
   |           ^^^
@ -70,8 +36,8 @@ help: alternatively, use a trait object to accept any type that implements `Foo`
 LL | fn bar(x: &dyn Foo) -> Foo {
   |           ++++

-error[E0782]: trait objects must include the `dyn` keyword
-  --> $DIR/not-on-bare-trait-2021.rs:12:19
+error[E0782]: expected a type, found a trait
+  --> $DIR/not-on-bare-trait-2021.rs:11:19
   |
 LL | fn bar(x: Foo) -> Foo {
   |                   ^^^
@ -85,7 +51,6 @@ help: alternatively, you can return an owned trait object
 LL | fn bar(x: Foo) -> Box<dyn Foo> {
   |                   +++++++    +

-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors

-Some errors have detailed explanations: E0277, E0782.
-For more information about an error, try `rustc --explain E0277`.
+For more information about this error, try `rustc --explain E0782`.
--- a/tests/ui/traits/issue-106072.rs
+++ b/tests/ui/traits/issue-106072.rs
@ -1,6 +1,4 @@
-#[derive(Clone)] //~  trait objects must include the `dyn` keyword
-//~^ ERROR: the size for values of type `(dyn Foo + 'static)` cannot be known
-//~| ERROR: return type cannot have an unboxed trait object
+#[derive(Clone)] //~  expected a type, found a trait
 struct Foo;
 trait Foo {} //~ the name `Foo` is defined multiple times
 fn main() {}
--- a/tests/ui/traits/issue-106072.stderr
+++ b/tests/ui/traits/issue-106072.stderr
@ -1,5 +1,5 @@
 error[E0428]: the name `Foo` is defined multiple times
-  --> $DIR/issue-106072.rs:5:1
+  --> $DIR/issue-106072.rs:3:1
   |
 LL | struct Foo;
   | ----------- previous definition of the type `Foo` here
@ -8,26 +8,7 @@ LL | trait Foo {}
   |
   = note: `Foo` must be defined only once in the type namespace of this module

-error[E0277]: the size for values of type `(dyn Foo + 'static)` cannot be known at compilation time
-  --> $DIR/issue-106072.rs:1:10
-   |
-LL | #[derive(Clone)]
-   |          ^^^^^ doesn't have a size known at compile-time
-   |
-   = help: the trait `Sized` is not implemented for `(dyn Foo + 'static)`
-note: required by a bound in `Clone`
-  --> $SRC_DIR/core/src/clone.rs:LL:COL
-   = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0746]: return type cannot have an unboxed trait object
-  --> $DIR/issue-106072.rs:1:10
-   |
-LL | #[derive(Clone)]
-   |          ^^^^^ doesn't have a size known at compile-time
-   |
-   = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0782]: trait objects must include the `dyn` keyword
+error[E0782]: expected a type, found a trait
  --> $DIR/issue-106072.rs:1:10
   |
 LL | #[derive(Clone)]
@ -35,7 +16,7 @@ LL | #[derive(Clone)]
   |
   = note: this error originates in the derive macro `Clone` (in Nightly builds, run with -Z macro-backtrace for more info)

-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors

-Some errors have detailed explanations: E0277, E0428, E0746, E0782.
-For more information about an error, try `rustc --explain E0277`.
+Some errors have detailed explanations: E0428, E0782.
+For more information about an error, try `rustc --explain E0428`.
--- a/Show more
+++ b/Show more