Rollup of 8 pull requests

compiler/rustc_ast_lowering/src/item.rs

@@ -569,16 +569,16 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         (safety, items, bounds)
                     },
                 );
-                hir::ItemKind::Trait(
+                hir::ItemKind::Trait {
                     impl_restriction,
                     constness,
-                    *is_auto,
+                    is_auto: *is_auto,
                     safety,
                     ident,
                     generics,
                     bounds,
                     items,
-                )
+                }
             }
             ItemKind::TraitAlias(box TraitAlias { constness, ident, generics, bounds }) => {
                 let constness = self.lower_constness(*constness);

compiler/rustc_error_codes/src/error_codes/E0429.md

@@ -1,9 +1,11 @@
+#### Note: this error code is no longer emitted by the compiler.
+
 The `self` keyword cannot appear alone as the last segment in a `use`
 declaration.
 
 Erroneous code example:
 
-```compile_fail,E0429
+```ignore (error is no longer emitted)
 use std::fmt::self; // error: `self` imports are only allowed within a { } list
 ```
 

compiler/rustc_hir/src/hir.rs

@@ -4467,7 +4467,7 @@ impl<'hir> Item<'hir> {
                 GenericBounds<'hir>,
                 &'hir [TraitItemId]
             ),
-            ItemKind::Trait(impl_restriction, constness, is_auto, safety, ident, generics, bounds, items),
+            ItemKind::Trait { impl_restriction, constness, is_auto, safety, ident, generics, bounds, items },
             (impl_restriction, *constness, *is_auto, *safety, *ident, generics, bounds, items);
 
         expect_trait_alias, (Constness, Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
@@ -4659,16 +4659,16 @@ pub enum ItemKind<'hir> {
     /// A union definition, e.g., `union Foo<A, B> {x: A, y: B}`.
     Union(Ident, &'hir Generics<'hir>, VariantData<'hir>),
     /// A trait definition.
-    Trait(
-        &'hir ImplRestriction<'hir>,
-        Constness,
-        IsAuto,
-        Safety,
-        Ident,
-        &'hir Generics<'hir>,
-        GenericBounds<'hir>,
-        &'hir [TraitItemId],
-    ),
+    Trait {
+        impl_restriction: &'hir ImplRestriction<'hir>,
+        constness: Constness,
+        is_auto: IsAuto,
+        safety: Safety,
+        ident: Ident,
+        generics: &'hir Generics<'hir>,
+        bounds: GenericBounds<'hir>,
+        items: &'hir [TraitItemId],
+    },
     /// A trait alias.
     TraitAlias(Constness, Ident, &'hir Generics<'hir>, GenericBounds<'hir>),
 
@@ -4714,7 +4714,7 @@ impl ItemKind<'_> {
             | ItemKind::Enum(ident, ..)
             | ItemKind::Struct(ident, ..)
             | ItemKind::Union(ident, ..)
-            | ItemKind::Trait(_, _, _, _, ident, ..)
+            | ItemKind::Trait { ident, .. }
             | ItemKind::TraitAlias(_, ident, ..) => Some(ident),
 
             ItemKind::Use(_, UseKind::Glob | UseKind::ListStem)
@@ -4732,7 +4732,7 @@ impl ItemKind<'_> {
             | ItemKind::Enum(_, generics, _)
             | ItemKind::Struct(_, generics, _)
             | ItemKind::Union(_, generics, _)
-            | ItemKind::Trait(_, _, _, _, _, generics, _, _)
+            | ItemKind::Trait { generics, .. }
             | ItemKind::TraitAlias(_, _, generics, _)
             | ItemKind::Impl(Impl { generics, .. }) => generics,
             _ => return None,

compiler/rustc_hir/src/intravisit.rs

@@ -618,16 +618,16 @@ pub fn walk_item<'v, V: Visitor<'v>>(visitor: &mut V, item: &'v Item<'v>) -> V::
             try_visit!(visitor.visit_generics(generics));
             try_visit!(visitor.visit_variant_data(struct_definition));
         }
-        ItemKind::Trait(
-            ref impl_restriction,
-            _constness,
-            _is_auto,
-            _safety,
+        ItemKind::Trait {
+            impl_restriction,
+            constness: _,
+            is_auto: _,
+            safety: _,
             ident,
-            ref generics,
+            generics,
             bounds,
-            trait_item_refs,
-        ) => {
+            items: trait_item_refs,
+        } => {
             if let RestrictionKind::Restricted(path) = &impl_restriction.kind {
                 walk_list!(visitor, visit_path_segment, path.segments);
             }

compiler/rustc_hir/src/target.rs

@@ -132,7 +132,7 @@ impl Target {
             ItemKind::Enum(..) => Target::Enum,
             ItemKind::Struct(..) => Target::Struct,
             ItemKind::Union(..) => Target::Union,
-            ItemKind::Trait(..) => Target::Trait,
+            ItemKind::Trait { .. } => Target::Trait,
             ItemKind::TraitAlias(..) => Target::TraitAlias,
             ItemKind::Impl(imp_) => Target::Impl { of_trait: imp_.of_trait.is_some() },
         }

compiler/rustc_hir_analysis/src/check/wfcheck.rs

@@ -326,7 +326,7 @@ pub(super) fn check_item<'tcx>(
         hir::ItemKind::Struct(..) => check_type_defn(tcx, item, false),
         hir::ItemKind::Union(..) => check_type_defn(tcx, item, true),
         hir::ItemKind::Enum(..) => check_type_defn(tcx, item, true),
-        hir::ItemKind::Trait(..) => check_trait(tcx, item),
+        hir::ItemKind::Trait { .. } => check_trait(tcx, item),
         hir::ItemKind::TraitAlias(..) => check_trait(tcx, item),
         _ => Ok(()),
     }
@@ -911,6 +911,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &ty::GenericParamDef) -> Result<(), Er
                     // Can never implement `ConstParamTy`, don't suggest anything.
                     Err(
                         ConstParamTyImplementationError::NotAnAdtOrBuiltinAllowed
+                        | ConstParamTyImplementationError::NonExhaustive(..)
                         | ConstParamTyImplementationError::InvalidInnerTyOfBuiltinTy(..),
                     ) => None,
                     Err(ConstParamTyImplementationError::UnsizedConstParamsFeatureRequired) => {
@@ -1188,7 +1189,7 @@ fn check_trait(tcx: TyCtxt<'_>, item: &hir::Item<'_>) -> Result<(), ErrorGuarant
     });
 
     // Only check traits, don't check trait aliases
-    if let hir::ItemKind::Trait(..) = item.kind {
+    if let hir::ItemKind::Trait { .. } = item.kind {
         check_gat_where_clauses(tcx, item.owner_id.def_id);
     }
     res

compiler/rustc_hir_analysis/src/coherence/builtin.rs

@@ -221,6 +221,12 @@ fn visit_implementation_of_const_param_ty(checker: &Checker<'_>) -> Result<(), E
             let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
             Err(tcx.dcx().emit_err(errors::ConstParamTyImplOnNonAdt { span }))
         }
+        Err(ConstParamTyImplementationError::NonExhaustive(attr_span)) => {
+            let defn_span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
+            Err(tcx
+                .dcx()
+                .emit_err(errors::ConstParamTyImplOnNonExhaustive { defn_span, attr_span }))
+        }
         Err(ConstParamTyImplementationError::InvalidInnerTyOfBuiltinTy(infringing_tys)) => {
             let span = tcx.hir_expect_item(impl_did).expect_impl().self_ty.span;
             Err(infringing_fields_error(

compiler/rustc_hir_analysis/src/collect.rs

@@ -895,7 +895,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
     let item = tcx.hir_expect_item(def_id);
 
     let (constness, is_alias, is_auto, safety, impl_restriction) = match item.kind {
-        hir::ItemKind::Trait(impl_restriction, constness, is_auto, safety, ..) => (
+        hir::ItemKind::Trait { impl_restriction, constness, is_auto, safety, .. } => (
             constness,
             false,
             is_auto == hir::IsAuto::Yes,

compiler/rustc_hir_analysis/src/collect/generics_of.rs

@@ -221,7 +221,7 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
 
     // Add in the self type parameter.
     let opt_self = if let Node::Item(item) = node
-        && let ItemKind::Trait(..) | ItemKind::TraitAlias(..) = item.kind
+        && let ItemKind::Trait { .. } | ItemKind::TraitAlias(..) = item.kind
     {
         // Something of a hack: We reuse the node ID of the trait for the self type parameter.
         Some(ty::GenericParamDef {
@@ -402,7 +402,7 @@ fn param_default_policy(node: Node<'_>) -> Option<ParamDefaultPolicy> {
 
     Some(match node {
         Node::Item(item) => match item.kind {
-            ItemKind::Trait(..)
+            ItemKind::Trait { .. }
             | ItemKind::TraitAlias(..)
             | ItemKind::TyAlias(..)
             | ItemKind::Enum(..)

compiler/rustc_hir_analysis/src/collect/predicates_of.rs

@@ -172,7 +172,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
                     ));
                 }
             }
-            ItemKind::Trait(_, _, _, _, _, _, self_bounds, ..)
+            ItemKind::Trait { bounds: self_bounds, .. }
             | ItemKind::TraitAlias(_, _, _, self_bounds) => {
                 is_trait = Some((self_bounds, item.span));
             }
@@ -669,7 +669,7 @@ pub(super) fn implied_predicates_with_filter<'tcx>(
     };
 
     let (generics, superbounds) = match item.kind {
-        hir::ItemKind::Trait(.., generics, supertraits, _) => (generics, supertraits),
+        hir::ItemKind::Trait { generics, bounds: supertraits, .. } => (generics, supertraits),
         hir::ItemKind::TraitAlias(_, _, generics, supertraits) => (generics, supertraits),
         _ => span_bug!(item.span, "super_predicates invoked on non-trait"),
     };
@@ -934,7 +934,7 @@ pub(super) fn type_param_predicates<'tcx>(
     };
 
     if let Node::Item(item) = hir_node
-        && let hir::ItemKind::Trait(..) = item.kind
+        && let hir::ItemKind::Trait { .. } = item.kind
         // Implied `Self: Trait` and supertrait bounds.
         && param_id == item_hir_id
     {
@@ -1073,7 +1073,7 @@ pub(super) fn const_conditions<'tcx>(
         Node::Item(item) => match item.kind {
             hir::ItemKind::Impl(impl_) => (impl_.generics, None, false),
             hir::ItemKind::Fn { generics, .. } => (generics, None, false),
-            hir::ItemKind::Trait(_, _, _, _, _, generics, supertraits, _) => {
+            hir::ItemKind::Trait { generics, bounds: supertraits, .. } => {
                 (generics, Some((Some(item.owner_id.def_id), supertraits)), false)
             }
             hir::ItemKind::TraitAlias(_, _, generics, supertraits) => {
@@ -1194,7 +1194,7 @@ pub(super) fn explicit_implied_const_bounds<'tcx>(
         }
         None => match tcx.hir_node_by_def_id(def_id) {
             Node::Item(hir::Item {
-                kind: hir::ItemKind::Trait(..) | hir::ItemKind::TraitAlias(..),
+                kind: hir::ItemKind::Trait { .. } | hir::ItemKind::TraitAlias(..),
                 ..
             }) => implied_predicates_with_filter(
                 tcx,

compiler/rustc_hir_analysis/src/collect/resolve_bound_vars.rs

@@ -647,7 +647,7 @@ impl<'a, 'tcx> Visitor<'tcx> for BoundVarContext<'a, 'tcx> {
             | hir::ItemKind::Enum(_, generics, _)
             | hir::ItemKind::Struct(_, generics, _)
             | hir::ItemKind::Union(_, generics, _)
-            | hir::ItemKind::Trait(_, _, _, _, _, generics, ..)
+            | hir::ItemKind::Trait { generics, .. }
             | hir::ItemKind::TraitAlias(_, _, generics, ..)
             | hir::ItemKind::Impl(hir::Impl { generics, .. }) => {
                 // These kinds of items have only early-bound lifetime parameters.
@@ -2258,7 +2258,7 @@ impl<'a, 'tcx> BoundVarContext<'a, 'tcx> {
                     // we already do that in `BoundVarContext::supertrait_hrtb_vars`.
                     if let Res::SelfTyParam { trait_: _ } = expected_res
                         && let hir::Node::Item(item) = node
-                        && let hir::ItemKind::Trait(..) = item.kind
+                        && let hir::ItemKind::Trait { .. } = item.kind
                     {
                         // Yield the trait's def id. Supertraits will be
                         // elaborated from that.

compiler/rustc_hir_analysis/src/collect/type_of.rs

@@ -171,7 +171,7 @@ pub(super) fn type_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::EarlyBinder<'_
                 Ty::new_adt(tcx, def, args)
             }
             ItemKind::GlobalAsm { .. } => tcx.typeck(def_id).node_type(hir_id),
-            ItemKind::Trait(..)
+            ItemKind::Trait { .. }
             | ItemKind::TraitAlias(..)
             | ItemKind::Macro(..)
             | ItemKind::Mod(..)

compiler/rustc_hir_analysis/src/errors.rs

@@ -317,6 +317,16 @@ pub(crate) struct ConstParamTyImplOnNonAdt {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("the trait `ConstParamTy` may not be implemented for this type")]
+pub(crate) struct ConstParamTyImplOnNonExhaustive {
+    #[primary_span]
+    #[label("non exhaustive const params are forbidden")]
+    pub defn_span: Span,
+    #[label("caused by this attribute")]
+    pub attr_span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag("the trait `ConstParamTy` may not be implemented for this struct")]
 pub(crate) struct ConstParamTyFieldVisMismatch {

compiler/rustc_hir_pretty/src/lib.rs

@@ -757,16 +757,16 @@ impl<'a> State<'a> {
                 }
                 self.bclose(item.span, cb);
             }
-            hir::ItemKind::Trait(
+            hir::ItemKind::Trait {
                 impl_restriction,
                 constness,
                 is_auto,
                 safety,
                 ident,
                 generics,
                 bounds,
-                trait_items,
-            ) => {
+                items: trait_items,
+            } => {
                 let (cb, ib) = self.head("");
                 self.print_impl_restriction(impl_restriction);
                 self.print_constness(constness);

compiler/rustc_hir_typeck/src/coercion.rs

@@ -1998,9 +1998,13 @@ impl<'tcx> CoerceMany<'tcx> {
             );
         }
 
-        let ret_coercion_span = fcx.ret_coercion_span.get();
+        let is_return_position = fcx
+            .tcx
+            .hir_get_fn_id_for_return_block(block_or_return_id)
+            .is_some_and(|fn_id| fn_id == fcx.tcx.local_def_id_to_hir_id(fcx.body_id));
 
-        if let Some(sp) = ret_coercion_span
+        if is_return_position
+            && let Some(sp) = fcx.ret_coercion_span.get()
             // If the closure has an explicit return type annotation, or if
             // the closure's return type has been inferred from outside
             // requirements (such as an Fn* trait bound), then a type error
@@ -2009,9 +2013,6 @@ impl<'tcx> CoerceMany<'tcx> {
             // note in this case, since it would be incorrect.
             && let Some(fn_sig) = fcx.body_fn_sig()
             && fn_sig.output().is_ty_var()
-            && fcx.ret_coercion.as_ref().is_some_and(|ret_coercion| {
-                fcx.resolve_vars_if_possible(ret_coercion.borrow().expected_ty()) == expected
-            })
         {
             err.span_note(sp, format!("return type inferred to be `{expected}` here"));
         }

compiler/rustc_hir_typeck/src/method/suggest.rs

@@ -1967,7 +1967,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     entry.1.insert((self_ty.span, String::new()));
                 }
                 Some(Node::Item(hir::Item {
-                    kind: hir::ItemKind::Trait(_, _, rustc_ast::ast::IsAuto::Yes, ..),
+                    kind: hir::ItemKind::Trait { is_auto:  rustc_ast::ast::IsAuto::Yes, .. },
                     span: item_span,
                     ..
                 })) => {
@@ -1979,7 +1979,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 Some(
                     Node::Item(hir::Item {
                         kind:
-                            hir::ItemKind::Trait(_, _, _, _, ident, ..)
+                            hir::ItemKind::Trait { ident, .. }
                             | hir::ItemKind::TraitAlias(_, ident, ..),
                         ..
                     })
@@ -4638,7 +4638,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                             return;
                         }
                         Node::Item(hir::Item {
-                            kind: hir::ItemKind::Trait(_, _, _, _, ident, _, bounds, _),
+                            kind: hir::ItemKind::Trait { ident, bounds, .. },
                             ..
                         }) => {
                             let (sp, sep, article) = if bounds.is_empty() {

compiler/rustc_incremental/src/persist/clean.rs

@@ -267,7 +267,7 @@ impl<'tcx> CleanVisitor<'tcx> {
                     HirItem::Union(..) => ("ItemUnion", LABELS_ADT),
 
                     // Represents a Trait Declaration
-                    HirItem::Trait(..) => ("ItemTrait", LABELS_TRAIT),
+                    HirItem::Trait { .. } => ("ItemTrait", LABELS_TRAIT),
 
                     // An implementation, eg `impl<A> Trait for Foo { .. }`
                     HirItem::Impl { .. } => ("ItemKind::Impl", LABELS_IMPL),

compiler/rustc_lint/src/multiple_supertrait_upcastable.rs

@@ -40,7 +40,7 @@ impl<'tcx> LateLintPass<'tcx> for MultipleSupertraitUpcastable {
         let def_id = item.owner_id.to_def_id();
         // NOTE(nbdd0121): use `dyn_compatibility_violations` instead of `is_dyn_compatible` because
         // the latter will report `where_clause_object_safety` lint.
-        if let hir::ItemKind::Trait(_, _, _, _, ident, ..) = item.kind
+        if let hir::ItemKind::Trait { ident, .. } = item.kind
             && cx.tcx.is_dyn_compatible(def_id)
         {
             let direct_super_traits_iter = cx

compiler/rustc_lint/src/types/improper_ctypes.rs

@@ -1145,7 +1145,7 @@ impl<'tcx> LateLintPass<'tcx> for ImproperCTypesLint {
             // Doesn't define something that can contain a external type to be checked.
             hir::ItemKind::Impl(..)
             | hir::ItemKind::TraitAlias(..)
-            | hir::ItemKind::Trait(..)
+            | hir::ItemKind::Trait { .. }
             | hir::ItemKind::GlobalAsm { .. }
             | hir::ItemKind::ForeignMod { .. }
             | hir::ItemKind::Mod(..)