Rollup of 29 pull requests

.github/renovate.json5

@@ -35,19 +35,24 @@
       "dependencyDashboardApproval": false
     },
     {
-      // Update all Cargo.lock files except library/Cargo.lock in one PR.
+      // Set defaults for all Cargo.lock files.
+      // library/Cargo.lock is grouped into a dedicated PR by the more
+      // specific rule below.
       "matchManagers": ["cargo"],
       "matchUpdateTypes": ["lockFileMaintenance"],
       "groupName": "Cargo lock file maintenance",
-      "commitMessageAction": "Cargo lock file maintenance"
+      "commitMessageAction": "Compiler and tools lock file update",
+      // Renovate merges all matching rules, so the lockfiles rules below
+      // also inherits this note and asks Triagebot for a dep-bumps reviewer.
+      "prBodyNotes": ["r? dep-bumps"]
     },
     {
       // Update library/Cargo.lock in a dedicated PR.
       "matchManagers": ["cargo"],
       "matchUpdateTypes": ["lockFileMaintenance"],
       "matchFileNames": ["library/Cargo.lock"],
       "groupName": "library lock file maintenance",
-      "commitMessageAction": "Library lock file maintenance"
+      "commitMessageAction": "Library lock file update"
     },
     {
       // These packages don't have a committed Cargo.lock file.
@@ -63,7 +68,7 @@
       "matchManagers": ["npm"],
       "matchUpdateTypes": ["lockFileMaintenance"],
       "groupName": "Yarn lock file maintenance",
-      "commitMessageAction": "Yarn lock file maintenance"
+      "commitMessageAction": "Yarn lock file update"
     }
   ],
   "ignorePaths": [

Cargo.lock

@@ -5927,9 +5927,9 @@ dependencies = [
 
 [[package]]
 name = "tracing-tree"
-version = "0.3.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b56c62d2c80033cb36fae448730a2f2ef99410fe3ecbffc916681a32f6807dbe"
+checksum = "ac87aa03b6a4d5a7e4810d1a80c19601dbe0f8a837e9177f23af721c7ba7beec"
 dependencies = [
  "nu-ansi-term",
  "tracing-core",

compiler/rustc_ast/src/ast.rs

@@ -3981,7 +3981,7 @@ pub struct Fn {
     /// This function is an implementation of an externally implementable item (EII).
     /// This means, there was an EII declared somewhere and this function is the
     /// implementation that should be run when the declaration is called.
-    pub eii_impls: ThinVec<EiiImpl>,
+    pub eii_impl: Option<Box<EiiImpl>>,
 }
 
 impl Fn {
@@ -4073,9 +4073,7 @@ pub struct StaticItem {
     /// This static is an implementation of an externally implementable item (EII).
     /// This means, there was an EII declared somewhere and this static is the
     /// implementation that should be used for the declaration.
-    ///
-    /// For statics, there may be at most one `EiiImpl`, but this is a `ThinVec` to make usages of this field nicer.
-    pub eii_impls: ThinVec<EiiImpl>,
+    pub eii_impl: Option<Box<EiiImpl>>,
 }
 
 #[derive(Clone, Encodable, Decodable, Debug, Walkable)]

compiler/rustc_ast/src/visit.rs

@@ -933,12 +933,12 @@ macro_rules! common_visitor_and_walkers {
                     _ctxt,
                     // Visibility is visited as a part of the item.
                     _vis,
-                    Fn { defaultness, ident, sig, generics, contract, body, define_opaque, eii_impls },
+                    Fn { defaultness, ident, sig, generics, contract, body, define_opaque, eii_impl },
                 ) => {
                     let FnSig { header, decl, span } = sig;
                     visit_visitable!($($mut)? vis,
                         defaultness, ident, header, generics, decl,
-                        contract, body, span, define_opaque, eii_impls
+                        contract, body, span, define_opaque, eii_impl
                     );
                 }
                 FnKind::Closure(binder, coroutine_kind, decl, body) =>

compiler/rustc_ast_lowering/src/item.rs

@@ -170,15 +170,13 @@ impl<'hir> LoweringContext<'_, 'hir> {
         i: &ItemKind,
     ) -> Vec<hir::Attribute> {
         match i {
-            ItemKind::Fn(Fn { eii_impls, .. }) | ItemKind::Static(StaticItem { eii_impls, .. })
-                if eii_impls.is_empty() =>
-            {
-                Vec::new()
-            }
-            ItemKind::Fn(Fn { eii_impls, .. }) | ItemKind::Static(StaticItem { eii_impls, .. }) => {
-                vec![hir::Attribute::Parsed(AttributeKind::EiiImpls(
-                    eii_impls.iter().map(|i| self.lower_eii_impl(i)).collect(),
-                ))]
+            ItemKind::Fn(Fn { eii_impl: None, .. })
+            | ItemKind::Static(StaticItem { eii_impl: None, .. }) => Vec::new(),
+            ItemKind::Fn(Fn { eii_impl: Some(eii_impl), .. })
+            | ItemKind::Static(StaticItem { eii_impl: Some(eii_impl), .. }) => {
+                vec![hir::Attribute::Parsed(AttributeKind::EiiImpl(Box::new(
+                    self.lower_eii_impl(eii_impl),
+                )))]
             }
             ItemKind::MacroDef(name, MacroDef { eii_declaration: Some(target), .. }) => self
                 .lower_eii_decl(id, *name, target)
@@ -226,7 +224,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             kind,
             vis_span,
             span: self.lower_span(i.span),
-            eii: find_attr!(attrs, EiiImpls(..) | EiiDeclaration(..)),
+            eii: find_attr!(attrs, EiiImpl(..) | EiiDeclaration(..)),
         };
         self.arena.alloc(item)
     }
@@ -259,7 +257,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 mutability: m,
                 expr: e,
                 define_opaque,
-                eii_impls: _,
+                eii_impl: _,
             }) => {
                 let ident = self.lower_ident(*ident);
                 let ty = self
@@ -696,7 +694,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                             kind,
                             vis_span,
                             span: this.lower_span(use_tree.span()),
-                            eii: find_attr!(attrs, EiiImpls(..) | EiiDeclaration(..)),
+                            eii: find_attr!(attrs, EiiImpl(..) | EiiDeclaration(..)),
                         };
                         hir::OwnerNode::Item(this.arena.alloc(item))
                     });
@@ -763,7 +761,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 expr: _,
                 safety,
                 define_opaque,
-                eii_impls: _,
+                eii_impl: _,
             }) => {
                 let ty = self
                     .lower_ty_alloc(ty, ImplTraitContext::Disallowed(ImplTraitPosition::StaticTy));

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -935,6 +935,13 @@ impl<'a> AstValidator<'a> {
         match fn_ctxt {
             FnCtxt::Foreign => return,
             FnCtxt::Free | FnCtxt::Assoc(_) => {
+                // Reject `...` without a pattern post-expansion. The varargs_without_pattern
+                // FCW is already triggered pre-expansion.
+                if let PatKind::Missing = variadic_param.pat.kind {
+                    self.dcx()
+                        .emit_err(diagnostics::VarargsWithoutPattern { span: variadic_param.span });
+                }
+
                 match self.sess.target.supports_c_variadic_definitions() {
                     CVariadicStatus::NotSupported => {
                         self.dcx().emit_err(diagnostics::CVariadicNotSupported {
@@ -1259,10 +1266,10 @@ impl<'a> AstValidator<'a> {
     }
 
     // Check EII implementation attributes against an allowlist.
-    fn check_eii_impl_attrs(&self, attrs: &[Attribute], eii_impls: &[EiiImpl]) {
-        if eii_impls.is_empty() {
+    fn check_eii_impl_attrs(&self, attrs: &[Attribute], eii_impl: &Option<Box<EiiImpl>>) {
+        let Some(eii_impl) = eii_impl else {
             return;
-        }
+        };
 
         let allowed_attrs: &[Symbol] = &[
             sym::allow,
@@ -1289,14 +1296,12 @@ impl<'a> AstValidator<'a> {
             }
 
             let attr_name = pprust::path_to_string(&normal.item.path);
-            for eii_impl in eii_impls {
-                self.dcx().emit_err(diagnostics::EiiImplAttributeNotSupported {
-                    attr_span: attr.span,
-                    attr_name: &attr_name,
-                    eii_span: eii_impl.span,
-                    eii_name: pprust::path_to_string(&eii_impl.eii_macro_path),
-                });
-            }
+            self.dcx().emit_err(diagnostics::EiiImplAttributeNotSupported {
+                attr_span: attr.span,
+                attr_name: &attr_name,
+                eii_span: eii_impl.span,
+                eii_name: pprust::path_to_string(&eii_impl.eii_macro_path),
+            });
         }
     }
 }
@@ -1479,16 +1484,16 @@ impl Visitor<'_> for AstValidator<'_> {
                     contract: _,
                     body,
                     define_opaque: _,
-                    eii_impls,
+                    eii_impl,
                 },
             ) => {
                 self.visit_attrs_vis_ident(&item.attrs, &item.vis, ident);
                 self.check_defaultness(item.span, *defaultness, AllowDefault::No, AllowFinal::No);
 
-                for EiiImpl { eii_macro_path, .. } in eii_impls {
+                if let Some(EiiImpl { eii_macro_path, .. }) = eii_impl {
                     self.visit_path(eii_macro_path);
                 }
-                self.check_eii_impl_attrs(&item.attrs, eii_impls);
+                self.check_eii_impl_attrs(&item.attrs, eii_impl);
 
                 let is_intrinsic = item.attrs.iter().any(|a| a.has_name(sym::rustc_intrinsic));
                 if body.is_none() && !is_intrinsic && !self.is_sdylib_interface {
@@ -1664,9 +1669,9 @@ impl Visitor<'_> for AstValidator<'_> {
 
                 visit::walk_item(self, item);
             }
-            ItemKind::Static(StaticItem { expr, safety, eii_impls, .. }) => {
+            ItemKind::Static(StaticItem { expr, safety, eii_impl, .. }) => {
                 self.check_item_safety(item.span, *safety);
-                self.check_eii_impl_attrs(&item.attrs, eii_impls);
+                self.check_eii_impl_attrs(&item.attrs, eii_impl);
                 if matches!(safety, Safety::Unsafe(_)) {
                     self.dcx().emit_err(diagnostics::UnsafeStatic { span: item.span });
                 }

compiler/rustc_ast_passes/src/diagnostics.rs

@@ -1245,3 +1245,15 @@ pub(crate) enum DeprecatedWhereClauseLocationSugg {
         span: Span,
     },
 }
+
+#[derive(Diagnostic)]
+#[diag("missing pattern for `...` argument")]
+pub(crate) struct VarargsWithoutPattern {
+    #[suggestion(
+        "add a pattern for this argument",
+        applicability = "machine-applicable",
+        code = "_: ..."
+    )]
+    #[primary_span]
+    pub span: Span,
+}

compiler/rustc_ast_pretty/src/pprust/state/item.rs

@@ -42,7 +42,7 @@ impl<'a> State<'a> {
                 expr,
                 safety,
                 define_opaque,
-                eii_impls,
+                eii_impl,
             }) => self.print_item_const(
                 *ident,
                 Some(*mutability),
@@ -53,7 +53,7 @@ impl<'a> State<'a> {
                 *safety,
                 ast::Defaultness::Implicit,
                 define_opaque.as_deref(),
-                eii_impls,
+                eii_impl.as_deref(),
             ),
             ast::ForeignItemKind::TyAlias(ast::TyAlias {
                 defaultness,
@@ -94,10 +94,10 @@ impl<'a> State<'a> {
         safety: ast::Safety,
         defaultness: ast::Defaultness,
         define_opaque: Option<&[(ast::NodeId, ast::Path)]>,
-        eii_impls: &[EiiImpl],
+        eii_impl: Option<&EiiImpl>,
     ) {
         self.print_define_opaques(define_opaque);
-        for eii_impl in eii_impls {
+        if let Some(eii_impl) = eii_impl {
             self.print_eii_impl(eii_impl);
         }
         let (cb, ib) = self.head("");
@@ -196,7 +196,7 @@ impl<'a> State<'a> {
                 mutability: mutbl,
                 expr: body,
                 define_opaque,
-                eii_impls,
+                eii_impl,
             }) => {
                 self.print_safety(*safety);
                 self.print_item_const(
@@ -209,7 +209,7 @@ impl<'a> State<'a> {
                     ast::Safety::Default,
                     ast::Defaultness::Implicit,
                     define_opaque.as_deref(),
-                    eii_impls,
+                    eii_impl.as_deref(),
                 );
             }
             ast::ItemKind::ConstBlock(ast::ConstBlockItem { id: _, span: _, block }) => {
@@ -242,7 +242,7 @@ impl<'a> State<'a> {
                     ast::Safety::Default,
                     *defaultness,
                     define_opaque.as_deref(),
-                    &[],
+                    None,
                 );
             }
             ast::ItemKind::Fn(func) => {
@@ -631,7 +631,7 @@ impl<'a> State<'a> {
                     ast::Safety::Default,
                     *defaultness,
                     define_opaque.as_deref(),
-                    &[],
+                    None,
                 );
             }
             ast::AssocItemKind::Type(ast::TyAlias {
@@ -731,12 +731,12 @@ impl<'a> State<'a> {
     }
 
     fn print_fn_full(&mut self, vis: &ast::Visibility, attrs: &[ast::Attribute], func: &ast::Fn) {
-        let ast::Fn { defaultness, ident, generics, sig, contract, body, define_opaque, eii_impls } =
+        let ast::Fn { defaultness, ident, generics, sig, contract, body, define_opaque, eii_impl } =
             func;
 
         self.print_define_opaques(define_opaque.as_deref());
 
-        for eii_impl in eii_impls {
+        if let Some(eii_impl) = eii_impl {
             self.print_eii_impl(eii_impl);
         }
 

compiler/rustc_attr_parsing/src/attributes/rustc_internal.rs

@@ -1,6 +1,7 @@
 use std::path::PathBuf;
 
 use rustc_ast::{LitIntType, LitKind, MetaItemLit};
+use rustc_data_structures::fx::FxHashMap;
 use rustc_feature::AttributeStability;
 use rustc_hir::LangItem;
 use rustc_hir::attrs::{
@@ -72,6 +73,18 @@ impl SingleAttributeParser for RustcMustImplementOneOfParser {
             return None;
         }
 
+        if cx.target == Target::Trait {
+            // Check for duplicates
+            let mut seen: FxHashMap<Symbol, Span> = FxHashMap::default();
+            for ident in &fn_names {
+                if let Some(dup) = seen.insert(ident.name, ident.span) {
+                    cx.emit_err(diagnostics::FunctionNamesDuplicated {
+                        spans: vec![dup, ident.span],
+                    });
+                }
+            }
+        }
+
         Some(AttributeKind::RustcMustImplementOneOf { attr_span: cx.attr_span, fn_names })
     }
 }

compiler/rustc_attr_parsing/src/diagnostics.rs

@@ -59,6 +59,14 @@ pub(crate) struct MustBeNameOfAssociatedFunction {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag("functions names are duplicated")]
+#[note("all `#[rustc_must_implement_one_of]` arguments must be unique")]
+pub(crate) struct FunctionNamesDuplicated {
+    #[primary_span]
+    pub spans: Vec<Span>,
+}
+
 #[derive(Diagnostic)]
 #[diag("unsafe attribute used without unsafe")]
 pub(crate) struct UnsafeAttrOutsideUnsafeLint {

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -4277,7 +4277,8 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
     ) -> Option<AnnotatedBorrowFnSignature<'tcx>> {
         // Define a fallback for when we can't match a closure.
         let fallback = || {
-            let is_closure = self.infcx.tcx.is_closure_like(self.mir_def_id().to_def_id());
+            let tcx = self.infcx.tcx;
+            let is_closure = tcx.is_closure_like(self.mir_def_id().to_def_id());
             if is_closure {
                 None
             } else {
@@ -4288,14 +4289,16 @@ impl<'diag, 'tcx> MirBorrowckCtxt<'_, 'diag, 'tcx> {
                     .instantiate_identity()
                     .skip_norm_wip();
                 match ty.kind() {
-                    ty::FnDef(_, _) | ty::FnPtr(..) => self.annotate_fn_sig(
+                    ty::FnDef(_, _) => self.annotate_fn_sig(
                         self.mir_def_id(),
                         self.infcx
                             .tcx
                             .fn_sig(self.mir_def_id())
                             .instantiate_identity()
                             .skip_norm_wip(),
                     ),
+                    // a const/static can have a fn ptr type, take the sig from the type instead.
+                    ty::FnPtr(_, _) => self.annotate_fn_sig(self.mir_def_id(), ty.fn_sig(tcx)),
                     _ => None,
                 }
             }