Rollup of 8 pull requests

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -1071,11 +1071,19 @@ impl<'a> AstValidator<'a> {
         }
     }
 
-    fn check_item_named(&self, ident: Ident, kind: &str) {
+    fn check_item_named(&self, ident: Ident, kind: &str, ctxt: AssocCtxt) {
         if ident.name != kw::Underscore {
             return;
         }
-        self.dcx().emit_err(diagnostics::ItemUnderscore { span: ident.span, kind });
+
+        if !self.features.associated_const_underscore()
+            && matches!(ctxt, AssocCtxt::Impl { of_trait: false })
+        {
+            let msg = format!("naming associated constants with `_` is unstable");
+            feature_err(&self.sess, sym::associated_const_underscore, ident.span, msg).emit();
+        } else if !matches!(ctxt, AssocCtxt::Impl { of_trait: false }) {
+            self.dcx().emit_err(diagnostics::ItemUnderscore { span: ident.span, kind });
+        }
     }
 
     fn check_nomangle_item_asciionly(&self, ident: Ident, item_span: Span) {
@@ -2162,7 +2170,7 @@ impl Visitor<'_> for AstValidator<'_> {
         }
 
         if let AssocItemKind::Const(ci) = &item.kind {
-            self.check_item_named(ci.ident, "const");
+            self.check_item_named(ci.ident, "const", ctxt);
         }
 
         let parent_is_const =

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -1335,10 +1335,9 @@ pub(crate) struct UnknownVersionLiteral {
     pub span: Span,
 }
 
-// FIXME(jdonszelmann) duplicated from `rustc_passes`, remove once `check_attr` is integrated.
 #[derive(Diagnostic)]
 #[diag("multiple `{$name}` attributes")]
-pub(crate) struct UnusedMultiple {
+pub struct UnusedMultiple {
     #[primary_span]
     #[suggestion("remove this attribute", code = "", applicability = "unspecified")]
     pub this: Span,

compiler/rustc_attr_parsing/src/lib.rs

@@ -118,7 +118,7 @@ pub use attributes::cfg::{
 pub use attributes::cfg_select::*;
 pub use attributes::util::{is_builtin_attr, parse_version};
 pub use context::ShouldEmit;
-pub use diagnostics::ParsedDescription;
+pub use diagnostics::{ParsedDescription, UnusedMultiple};
 pub use interface::{AttributeParser, EmitAttribute};
 pub use rustc_parse::parser::Recovery;
 pub use template::AttributeTemplate;

compiler/rustc_builtin_macros/src/cfg_eval.rs

@@ -19,12 +19,12 @@ use crate::util::{check_builtin_macro_attribute, warn_on_duplicate_attribute};
 
 pub(crate) fn expand(
     ecx: &mut ExtCtxt<'_>,
-    _span: Span,
+    span: Span,
     meta_item: &ast::MetaItem,
     annotatable: Annotatable,
 ) -> Vec<Annotatable> {
     check_builtin_macro_attribute(ecx, meta_item, sym::cfg_eval);
-    warn_on_duplicate_attribute(ecx, &annotatable, sym::cfg_eval);
+    warn_on_duplicate_attribute(ecx, &annotatable, span, sym::cfg_eval);
     vec![cfg_eval(ecx.sess, ecx.ecfg.features, annotatable, ecx.current_expansion.lint_node_id)]
 }
 

compiler/rustc_builtin_macros/src/diagnostics.rs

@@ -22,10 +22,6 @@ pub(crate) struct IncompleteInclude;
 #[diag("cannot test inner items")]
 pub(crate) struct UnnameableTestItems;
 
-#[derive(Diagnostic)]
-#[diag("duplicated attribute")]
-pub(crate) struct DuplicateMacroAttribute;
-
 #[derive(Diagnostic)]
 #[diag("macro requires a cfg-pattern as an argument")]
 pub(crate) struct RequiresCfgPattern {

compiler/rustc_builtin_macros/src/test.rs

@@ -30,7 +30,7 @@ pub(crate) fn expand_test_case(
     anno_item: Annotatable,
 ) -> Vec<Annotatable> {
     check_builtin_macro_attribute(ecx, meta_item, sym::test_case);
-    warn_on_duplicate_attribute(ecx, &anno_item, sym::test_case);
+    warn_on_duplicate_attribute(ecx, &anno_item, attr_sp, sym::test_case);
 
     let sp = ecx.with_def_site_ctxt(attr_sp);
     let (mut item, is_stmt) = match anno_item {
@@ -88,7 +88,7 @@ pub(crate) fn expand_test(
     item: Annotatable,
 ) -> Vec<Annotatable> {
     check_builtin_macro_attribute(cx, meta_item, sym::test);
-    warn_on_duplicate_attribute(cx, &item, sym::test);
+    warn_on_duplicate_attribute(cx, &item, attr_sp, sym::test);
     expand_test_or_bench(cx, attr_sp, item, false)
 }
 
@@ -99,7 +99,7 @@ pub(crate) fn expand_bench(
     item: Annotatable,
 ) -> Vec<Annotatable> {
     check_builtin_macro_attribute(cx, meta_item, sym::bench);
-    warn_on_duplicate_attribute(cx, &item, sym::bench);
+    warn_on_duplicate_attribute(cx, &item, attr_path_sp, sym::bench);
     expand_test_or_bench(cx, attr_path_sp, item, true)
 }
 

compiler/rustc_builtin_macros/src/util.rs

@@ -1,6 +1,6 @@
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::{self as ast, AttrStyle, Attribute, MetaItem, attr, token};
-use rustc_attr_parsing::{AttributeTemplate, validate_attr};
+use rustc_attr_parsing::{AttributeTemplate, UnusedMultiple, validate_attr};
 use rustc_errors::{Applicability, Diag, ErrorGuaranteed};
 use rustc_expand::base::{Annotatable, ExpandResult, ExtCtxt};
 use rustc_expand::expand::AstFragment;
@@ -26,30 +26,33 @@ pub(crate) fn check_builtin_macro_attribute(ecx: &ExtCtxt<'_>, meta_item: &MetaI
 
 /// Emit a warning if the item is annotated with the given attribute. This is used to diagnose when
 /// an attribute may have been mistakenly duplicated.
-pub(crate) fn warn_on_duplicate_attribute(ecx: &ExtCtxt<'_>, item: &Annotatable, name: Symbol) {
-    let attrs: Option<&[Attribute]> = match item {
-        Annotatable::Item(item) => Some(&item.attrs),
-        Annotatable::AssocItem(item, _) => Some(&item.attrs),
-        Annotatable::ForeignItem(item) => Some(&item.attrs),
-        Annotatable::Expr(expr) => Some(&expr.attrs),
-        Annotatable::Arm(arm) => Some(&arm.attrs),
-        Annotatable::ExprField(field) => Some(&field.attrs),
-        Annotatable::PatField(field) => Some(&field.attrs),
-        Annotatable::GenericParam(param) => Some(&param.attrs),
-        Annotatable::Param(param) => Some(&param.attrs),
-        Annotatable::FieldDef(def) => Some(&def.attrs),
-        Annotatable::Variant(variant) => Some(&variant.attrs),
-        _ => None,
+pub(crate) fn warn_on_duplicate_attribute(
+    ecx: &ExtCtxt<'_>,
+    item: &Annotatable,
+    span: Span,
+    name: Symbol,
+) {
+    let attrs: &[Attribute] = match item {
+        Annotatable::Item(item) => &item.attrs,
+        Annotatable::AssocItem(item, _) => &item.attrs,
+        Annotatable::ForeignItem(item) => &item.attrs,
+        Annotatable::Expr(expr) => &expr.attrs,
+        Annotatable::Arm(arm) => &arm.attrs,
+        Annotatable::ExprField(field) => &field.attrs,
+        Annotatable::PatField(field) => &field.attrs,
+        Annotatable::GenericParam(param) => &param.attrs,
+        Annotatable::Param(param) => &param.attrs,
+        Annotatable::FieldDef(def) => &def.attrs,
+        Annotatable::Variant(variant) => &variant.attrs,
+        _ => return,
     };
-    if let Some(attrs) = attrs {
-        if let Some(attr) = attr::find_by_name(attrs, name) {
-            ecx.psess().buffer_lint(
-                DUPLICATE_MACRO_ATTRIBUTES,
-                attr.span,
-                ecx.current_expansion.lint_node_id,
-                diagnostics::DuplicateMacroAttribute,
-            );
-        }
+    if let Some(attr) = attr::find_by_name(attrs, name) {
+        ecx.psess().buffer_lint(
+            DUPLICATE_MACRO_ATTRIBUTES,
+            attr.span,
+            ecx.current_expansion.lint_node_id,
+            UnusedMultiple { this: attr.span, other: span, name },
+        );
     }
 }
 

compiler/rustc_feature/src/unstable.rs

@@ -390,6 +390,8 @@ declare_features! (
     (unstable, asm_goto_with_outputs, "1.85.0", Some(119364)),
     /// Allows the `may_unwind` option in inline assembly.
     (unstable, asm_unwind, "1.58.0", Some(93334)),
+    /// Allows `_` for the name of associated constants.
+    (unstable, associated_const_underscore, "CURRENT_RUSTC_VERSION", Some(158944)),
     /// Allows associated type defaults.
     (unstable, associated_type_defaults, "1.2.0", Some(29661)),
     /// Allows implementing `AsyncDrop`.

compiler/rustc_hir/src/hir.rs

@@ -3144,6 +3144,13 @@ impl<'hir> ImplItem<'hir> {
         ImplItemId { owner_id: self.owner_id }
     }
 
+    /// Returns whether this is an anonymous associated constant in an inherent impl.
+    pub fn is_anon_const(&self) -> bool {
+        matches!(self.impl_kind, ImplItemImplKind::Inherent { .. })
+            && matches!(self.kind, ImplItemKind::Const(..))
+            && self.ident.name == kw::Underscore
+    }
+
     pub fn vis_span(&self) -> Option<Span> {
         match self.impl_kind {
             ImplItemImplKind::Trait { .. } => None,

compiler/rustc_hir_analysis/src/check/mod.rs

@@ -614,7 +614,10 @@ fn suggestion_signature<'tcx>(
             );
             format!("type {}{generics} = /* Type */{where_clauses};", assoc.name())
         }
-        ty::AssocKind::Const { name, .. } => {
+        ty::AssocKind::Const { data: ty::AssocConstData::Anonymous } => {
+            panic!("anonymous associated consts shouldn't end up here")
+        }
+        ty::AssocKind::Const { data: ty::AssocConstData::Named(name) } => {
             let ty = tcx.type_of(assoc.def_id).instantiate_identity().skip_norm_wip();
             let val = tcx
                 .infer_ctxt()

compiler/rustc_hir_analysis/src/coherence/inherent_impls_overlap.rs

@@ -49,7 +49,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
             std::mem::swap(&mut impl_items1, &mut impl_items2);
         }
 
-        for &item1 in impl_items1.in_definition_order() {
+        for &item1 in impl_items1.named_items_in_definition_order() {
             let collision = impl_items2
                 .filter_by_name_unhygienic(item1.name())
                 .any(|&item2| self.compare_hygienically(item1, item2));
@@ -74,7 +74,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
 
         let mut seen_items = FxIndexMap::default();
         let mut res = Ok(());
-        for impl_item in impl_items.in_definition_order() {
+        for &impl_item in impl_items.named_items_in_definition_order() {
             let span = self.tcx.def_span(impl_item.def_id);
             let ident = impl_item.ident(self.tcx);
 
@@ -111,7 +111,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
         let impl_items2 = self.tcx.associated_items(impl2);
 
         let mut res = Ok(());
-        for &item1 in impl_items1.in_definition_order() {
+        for &item1 in impl_items1.named_items_in_definition_order() {
             let collision = impl_items2
                 .filter_by_name_unhygienic(item1.name())
                 .find(|&&item2| self.compare_hygienically(item1, item2));
@@ -228,7 +228,7 @@ impl<'tcx> InherentOverlapChecker<'tcx> {
                 // First obtain a list of existing connected region ids
                 let mut idents_to_add = SmallVec::<[Symbol; 8]>::new();
                 let mut ids = impl_items
-                    .in_definition_order()
+                    .named_items_in_definition_order()
                     .filter_map(|item| {
                         let entry = connected_region_ids.entry(item.name());
                         if let IndexEntry::Occupied(e) = &entry {

compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs

@@ -205,10 +205,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
         let wider_candidate_names: Vec<_> = visible_traits
             .iter()
-            .flat_map(|trait_def_id| tcx.associated_items(*trait_def_id).in_definition_order())
-            .filter_map(|item| {
-                (!item.is_impl_trait_in_trait() && item.tag() == assoc_tag).then(|| item.name())
+            .flat_map(|trait_def_id| {
+                tcx.associated_items(*trait_def_id).named_items_in_definition_order()
             })
+            .filter_map(|item| (item.tag() == assoc_tag).then(|| item.name()))
             .collect();
 
         if let Some(suggested_name) =

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -283,7 +283,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let Some(iterator_item_id) = tcx
             .associated_items(iterator_trait_id)
-            .in_definition_order()
+            .named_items_in_definition_order()
             .find(|item| item.name() == sym::Item)
             .map(|item| item.def_id)
         else {

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -1894,7 +1894,10 @@ impl<'tcx> Pick<'tcx> {
                             tcx.def_path_str(this.item.def_id),
                         ));
                     }
-                    (ty::AssocKind::Const { name, .. }, ty::AssocContainer::Trait) => {
+                    (
+                        ty::AssocKind::Const { data: ty::AssocConstData::Named(name) },
+                        ty::AssocContainer::Trait,
+                    ) => {
                         let def_id = this.item.container_id(tcx);
                         lint.span_suggestion(
                             span,
@@ -2662,7 +2665,6 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         {
             return true;
         }
-
         false
     }
 
@@ -2676,7 +2678,7 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
                 let max_dist = max(name.as_str().len(), 3) / 3;
                 self.tcx
                     .associated_items(def_id)
-                    .in_definition_order()
+                    .named_items_in_definition_order()
                     .filter(|x| {
                         if !self.is_relevant_kind_for_mode(x.kind) {
                             return false;

compiler/rustc_metadata/src/rmeta/decoder.rs

@@ -1444,7 +1444,14 @@ impl CrateMetadata {
 
     fn get_associated_item(&self, tcx: TyCtxt<'_>, id: DefIndex) -> ty::AssocItem {
         let kind = match self.def_kind(id) {
-            DefKind::AssocConst => ty::AssocKind::Const { name: self.item_name(id) },
+            DefKind::AssocConst => {
+                let data = if let Some(item_name) = self.root.tables.opt_item_name.get(self, id) {
+                    ty::AssocConstData::Named(item_name.decode((self, tcx)))
+                } else {
+                    ty::AssocConstData::Anonymous
+                };
+                ty::AssocKind::Const { data }
+            }
             DefKind::AssocFn => ty::AssocKind::Fn {
                 name: self.item_name(id),
                 has_self: self.get_fn_has_self_parameter(tcx, id),

compiler/rustc_metadata/src/rmeta/encoder.rs

@@ -1898,6 +1898,10 @@ impl<'a, 'tcx> EncodeContext<'a, 'tcx> {
 
         self.table_writer().assoc_container(def_id, item.container);
 
+        if let Some(item_name) = item.opt_name() {
+            self.table_writer().opt_item_name(def_id, Some(item_name));
+        }
+
         if let AssocContainer::Trait = item.container
             && item.is_type()
         {

compiler/rustc_metadata/src/rmeta/mod.rs

@@ -641,6 +641,7 @@ define_tables! {
     explicit_implied_clauses_of: Table<LazyArray<(ty::Clause<'static>, Span)>>,
     explicit_implied_const_bounds: Table<LazyArray<(ty::PolyTraitRef<'static>, Span)>>,
     inherent_impls: Table<LazyArray<LocalDefId>>,
+    opt_item_name: Table<Option<LazyValue<Symbol>>>,
     // Reexported names are not associated with individual `DefId`s,
     // e.g. a glob import can introduce a lot of names, all with the same `DefId`.
     // That's why the encoded list needs to contain `ModChild` structures describing all the names