Auto merge of #160222 - jhpratt:rollup-bWMwb4u, r=<try>

Rollup of 14 pull requests


try-job: dist-various-1
try-job: test-various
try-job: x86_64-gnu-aux
try-job: x86_64-gnu-llvm-21-3
try-job: x86_64-msvc-1
try-job: aarch64-apple
try-job: x86_64-mingw-1
try-job: i686-msvc-*

Author: bors

.github/renovate.json5

@@ -31,25 +31,40 @@
       "dependencyDashboardApproval": false
     },
     {
-      // Only maintain the Cargo lockfiles managed by update-lockfile.sh.
+      // Update all Cargo.lock files except library/Cargo.lock in one PR.
       "matchManagers": ["cargo"],
       "matchUpdateTypes": ["lockFileMaintenance"],
-      "enabled": false
+      "groupName": "Cargo lock file maintenance",
+      "commitMessageAction": "Cargo lock file maintenance"
+    },
+    {
+      // 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"
     },
     {
+      // These packages don't have a committed Cargo.lock file.
       "matchManagers": ["cargo"],
       "matchUpdateTypes": ["lockFileMaintenance"],
       "matchFileNames": [
-        "Cargo.toml",
-        "library/Cargo.toml",
-        "src/tools/rustbook/Cargo.toml"
+        "library/rustc-std-workspace-*/Cargo.toml",
       ],
-      "enabled": true
+      "enabled": false
+    },
+    {
+      // Update yarn.lock in a dedicated PR.
+      "matchManagers": ["npm"],
+      "matchUpdateTypes": ["lockFileMaintenance"],
+      "groupName": "Yarn lock file maintenance",
+      "commitMessageAction": "Yarn lock file maintenance"
     }
   ],
-  // Don't manage dependencies inside subtrees. They are updated upstream and
-  // synced in. See `src/doc/rustc-dev-guide/src/external-repos.md` for the list.
   "ignorePaths": [
+    // Don't manage dependencies inside subtrees. They are updated upstream and
+    // synced in. See `src/doc/rustc-dev-guide/src/external-repos.md` for the list.
     "compiler/rustc_codegen_cranelift/**",
     "compiler/rustc_codegen_gcc/**",
     "library/compiler-builtins/**",
@@ -59,6 +74,10 @@
     "src/tools/clippy/**",
     "src/tools/miri/**",
     "src/tools/rust-analyzer/**",
-    "src/tools/rustfmt/**"
+    "src/tools/rustfmt/**",
+
+    // Test manifests are fixtures; their versions and lockfiles may
+    // intentionally be part of the test input.
+    "tests/**",
   ]
 }

compiler/rustc_ast/src/ast.rs

@@ -3071,7 +3071,7 @@ impl FnDecl {
             } else {
                 arg.attrs
                     .iter()
-                    .any(|attr| attr.has_name(sym::splat))
+                    .any(|attr| attr.has_name(sym::rustc_splat))
                     .then_some(u8::try_from(index).unwrap())
             }
         })

compiler/rustc_ast_passes/src/ast_validation.rs

@@ -46,7 +46,7 @@ enum SelfSemantic {
     No,
 }
 
-/// Is `#[splat]` allowed semantically in a function or closure?
+/// Is `#[rustc_splat]` allowed semantically in a function or closure?
 /// Only applies to the function kind and header, the parameters are checked elsewhere.
 enum SplatSemantic {
     Yes,
@@ -439,7 +439,7 @@ impl<'a> AstValidator<'a> {
 
     /// Emits an error if a function declaration has more than one splatted argument, with a
     /// C-variadic parameter, or a splat at an unsupported index (for performance).
-    /// Example: `fn foo(#[splat] x: (), #[splat] y: ())` will emit an error.
+    /// Example: `fn foo(#[rustc_splat] x: (), #[rustc_splat] y: ())` will emit an error.
     fn check_decl_splatting(
         &self,
         fn_decl: &FnDecl,
@@ -454,7 +454,7 @@ impl<'a> AstValidator<'a> {
                 let splat_arg_spans: Vec<Span> = arg
                     .attrs
                     .iter()
-                    .filter_map(|attr| attr.has_name(sym::splat).then_some(attr.span))
+                    .filter_map(|attr| attr.has_name(sym::rustc_splat).then_some(attr.span))
                     .collect();
                 if splat_arg_spans.is_empty() {
                     None
@@ -521,8 +521,14 @@ impl<'a> AstValidator<'a> {
             .flat_map(|i| i.attrs.as_ref())
             .filter(|attr| match &attr.kind {
                 AttrKind::Normal(normal) => {
-                    let arr =
-                        [sym::allow, sym::deny, sym::expect, sym::forbid, sym::splat, sym::warn];
+                    let arr = [
+                        sym::allow,
+                        sym::deny,
+                        sym::expect,
+                        sym::forbid,
+                        sym::rustc_splat,
+                        sym::warn,
+                    ];
                     !attr.has_any_name(&arr) && rustc_attr_parsing::is_builtin_attr(&normal.item)
                 }
                 AttrKind::Synthetic(CfgTrace(_) | CfgAttrTrace(_)) => false,

compiler/rustc_ast_passes/src/diagnostics.rs

@@ -125,46 +125,48 @@ pub(crate) struct FnParamCVarArgsNotLast {
 
 #[derive(Diagnostic)]
 #[diag(
-    "`#[splat]` is only supported on argument index {$max_valid_splatted_arg_index} or less, this `#[splat]` is on index {$first_invalid_splatted_arg_index}"
+    "`#[rustc_splat]` is only supported on argument index {$max_valid_splatted_arg_index} or less, this `#[rustc_splat]` is on index {$first_invalid_splatted_arg_index}"
+)]
+#[help(
+    "remove `#[rustc_splat]`, or use it on an argument closer to the start of the argument list"
 )]
-#[help("remove `#[splat]`, or use it on an argument closer to the start of the argument list")]
 pub(crate) struct InvalidSplattedArgs {
     pub max_valid_splatted_arg_index: u16,
 
     pub first_invalid_splatted_arg_index: u16,
 
     #[primary_span]
-    #[label("`#[splat]` is not supported here")]
+    #[label("`#[rustc_splat]` is not supported here")]
     pub spans: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag("multiple `#[splat]`s are not allowed in the same function argument list")]
-#[help("remove `#[splat]` from all but one argument")]
+#[diag("multiple `#[rustc_splat]`s are not allowed in the same function argument list")]
+#[help("remove `#[rustc_splat]` from all but one argument")]
 pub(crate) struct DuplicateSplattedArgs {
     #[primary_span]
     pub spans: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag("`...` and `#[splat]` are not allowed in the same function argument list")]
-#[help("remove `#[splat]` or remove `...`")]
+#[diag("`...` and `#[rustc_splat]` are not allowed in the same function argument list")]
+#[help("remove `#[rustc_splat]` or remove `...`")]
 pub(crate) struct CVarArgsAndSplat {
     #[primary_span]
     pub spans: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag("`#[splat]` is not allowed on closure arguments")]
-#[help("remove `#[splat]` or turn the closure into a function")]
+#[diag("`#[rustc_splat]` is not allowed on closure arguments")]
+#[help("remove `#[rustc_splat]` or turn the closure into a function")]
 pub(crate) struct SplatNotAllowedOnClosures {
     #[primary_span]
     pub spans: Vec<Span>,
 }
 
 #[derive(Diagnostic)]
-#[diag("`#[splat]` is not allowed in the arguments of functions with the `{$abi}` ABI")]
-#[help("remove `#[splat]` or change the ABI")]
+#[diag("`#[rustc_splat]` is not allowed in the arguments of functions with the `{$abi}` ABI")]
+#[help("remove `#[rustc_splat]` or change the ABI")]
 pub(crate) struct SplatNotAllowedOnAbiCall {
     #[primary_span]
     pub spans: Vec<Span>,

compiler/rustc_ast_passes/src/feature_gate.rs

@@ -483,7 +483,11 @@ pub fn check_crate(krate: &ast::Crate, sess: &Session, features: &Features) {
     gate_all!(pin_ergonomics, "pinned reference syntax is experimental");
     gate_all!(postfix_match, "postfix match is experimental");
     gate_all!(return_type_notation, "return type notation is experimental");
-    gate_all!(splat, "`fn(#[splat] (a, ...))` is incomplete", "call as func((a, ...)) instead");
+    gate_all!(
+        splat,
+        "`fn(#[rustc_splat] (a, ...))` is incomplete",
+        "call as func((a, ...)) instead"
+    );
     gate_all!(super_let, "`super let` is experimental");
     gate_all!(try_blocks_heterogeneous, "`try bikeshed` expression is experimental");
     gate_all!(unnamed_enum_variants, "unnamed enum variants are experimental");

compiler/rustc_attr_parsing/src/attributes/splat.rs

@@ -1,4 +1,4 @@
-//! Attribute parsing for the `#[splat]` function argument overloading attribute.
+//! Attribute parsing for the `#[rustc_splat]` function argument overloading attribute.
 //! This attribute modifies typecheck to support overload resolution, then modifies codegen for performance.
 
 use rustc_feature::AttributeStability;
@@ -8,8 +8,9 @@ use super::prelude::*;
 pub(crate) struct SplatParser;
 
 impl NoArgsAttributeParser for SplatParser {
-    const PATH: &[Symbol] = &[sym::splat];
+    const PATH: &[Symbol] = &[sym::rustc_splat];
     const ALLOWED_TARGETS: AllowedTargets<'_> = AllowedTargets::AllowList(&[Allow(Target::Param)]);
-    const STABILITY: AttributeStability = unstable!(splat, "the `splat` attribute is experimental");
+    const STABILITY: AttributeStability =
+        unstable!(splat, "the `rustc_splat` attribute is experimental");
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::Splat;
 }

compiler/rustc_codegen_llvm/src/attributes.rs

@@ -530,9 +530,7 @@ pub(crate) fn llfn_attrs_from_instance<'ll, 'tcx>(
         to_add.extend(sanitize_attrs(cx, tcx, codegen_fn_attrs.sanitizers));
 
         // For non-naked functions, set branch protection attributes on aarch64.
-        if let Some(BranchProtection { bti, pac_ret, gcs }) =
-            sess.opts.unstable_opts.branch_protection
-        {
+        if let Some(BranchProtection { bti, pac_ret, gcs }) = sess.branch_protection() {
             assert!(sess.target.arch == Arch::AArch64);
             if bti {
                 to_add.push(llvm::CreateAttrString(cx.llcx, "branch-target-enforcement"));

compiler/rustc_codegen_llvm/src/context.rs

@@ -405,8 +405,7 @@ pub(crate) unsafe fn create_module<'ll>(
         );
     }
 
-    if let Some(BranchProtection { bti, pac_ret, gcs }) = sess.opts.unstable_opts.branch_protection
-    {
+    if let Some(BranchProtection { bti, pac_ret, gcs }) = sess.branch_protection() {
         if sess.target.arch == Arch::AArch64 {
             llvm::add_module_flag_u32(
                 llmod,
@@ -420,7 +419,11 @@ pub(crate) unsafe fn create_module<'ll>(
                 "sign-return-address",
                 pac_ret.is_some().into(),
             );
-            let pac_opts = pac_ret.unwrap_or(PacRet { leaf: false, pc: false, key: PAuthKey::A });
+            let pac_opts = pac_ret.unwrap_or_else(|| {
+                // Windows on Arm only supports PAC key B.
+                let key = if sess.target.os == Os::Windows { PAuthKey::B } else { PAuthKey::A };
+                PacRet { leaf: false, pc: false, key }
+            });
             llvm::add_module_flag_u32(
                 llmod,
                 llvm::ModuleFlagMergeBehavior::Min,

compiler/rustc_codegen_ssa/src/back/linker.rs

@@ -137,9 +137,6 @@ pub(crate) fn get_linker<'a>(
     // to the linker args construction.
     assert!(cmd.get_args().is_empty() || sess.target.cfg_abi == CfgAbi::Uwp);
     match flavor {
-        LinkerFlavor::Unix(Cc::No) if sess.target.os == Os::L4Re => {
-            Box::new(L4Bender::new(cmd, sess)) as Box<dyn Linker>
-        }
         LinkerFlavor::Unix(Cc::No) if sess.target.os == Os::Aix => {
             Box::new(AixLinker::new(cmd, sess)) as Box<dyn Linker>
         }
@@ -279,7 +276,6 @@ generate_arg_methods! {
     MsvcLinker<'_>
     EmLinker<'_>
     WasmLd<'_>
-    L4Bender<'_>
     AixLinker<'_>
     LlbcLinker<'_>
     BpfLinker<'_>
@@ -1468,128 +1464,6 @@ impl<'a> WasmLd<'a> {
     }
 }
 
-/// Linker shepherd script for L4Re (Fiasco)
-struct L4Bender<'a> {
-    cmd: Command,
-    sess: &'a Session,
-    hinted_static: bool,
-}
-
-impl<'a> Linker for L4Bender<'a> {
-    fn cmd(&mut self) -> &mut Command {
-        &mut self.cmd
-    }
-
-    fn set_output_kind(
-        &mut self,
-        _output_kind: LinkOutputKind,
-        _crate_type: CrateType,
-        _out_filename: &Path,
-    ) {
-    }
-
-    fn link_staticlib_by_name(&mut self, name: &str, _verbatim: bool, whole_archive: bool) {
-        self.hint_static();
-        if !whole_archive {
-            self.link_arg(format!("-PC{name}"));
-        } else {
-            self.link_arg("--whole-archive")
-                .link_or_cc_arg(format!("-l{name}"))
-                .link_arg("--no-whole-archive");
-        }
-    }
-
-    fn link_staticlib_by_path(&mut self, path: &Path, whole_archive: bool) {
-        self.hint_static();
-        if !whole_archive {
-            self.link_or_cc_arg(path);
-        } else {
-            self.link_arg("--whole-archive").link_or_cc_arg(path).link_arg("--no-whole-archive");
-        }
-    }
-
-    fn full_relro(&mut self) {
-        self.link_args(&["-z", "relro", "-z", "now"]);
-    }
-
-    fn partial_relro(&mut self) {
-        self.link_args(&["-z", "relro"]);
-    }
-
-    fn no_relro(&mut self) {
-        self.link_args(&["-z", "norelro"]);
-    }
-
-    fn gc_sections(&mut self, keep_metadata: bool) {
-        if !keep_metadata {
-            self.link_arg("--gc-sections");
-        }
-    }
-
-    fn optimize(&mut self) {
-        // GNU-style linkers support optimization with -O. GNU ld doesn't
-        // need a numeric argument, but other linkers do.
-        if self.sess.opts.optimize == config::OptLevel::More
-            || self.sess.opts.optimize == config::OptLevel::Aggressive
-        {
-            self.link_arg("-O1");
-        }
-    }
-
-    fn pgo_gen(&mut self) {}
-
-    fn debuginfo(&mut self, strip: Strip, _: &[PathBuf]) {
-        match strip {
-            Strip::None => {}
-            Strip::Debuginfo => {
-                self.link_arg("--strip-debug");
-            }
-            Strip::Symbols => {
-                self.link_arg("--strip-all");
-            }
-        }
-    }
-
-    fn no_default_libraries(&mut self) {
-        self.cc_arg("-nostdlib");
-    }
-
-    fn export_symbols(&mut self, _: &Path, _: CrateType, _: &[SymbolExport]) {
-        // ToDo, not implemented, copy from GCC
-        self.sess.dcx().emit_warn(diagnostics::L4BenderExportingSymbolsUnimplemented);
-    }
-
-    fn windows_subsystem(&mut self, subsystem: WindowsSubsystemKind) {
-        let subsystem = subsystem.as_str();
-        self.link_arg(&format!("--subsystem {subsystem}"));
-    }
-
-    fn reset_per_library_state(&mut self) {
-        self.hint_static(); // Reset to default before returning the composed command line.
-    }
-
-    fn linker_plugin_lto(&mut self) {}
-
-    fn control_flow_guard(&mut self) {}
-
-    fn ehcont_guard(&mut self) {}
-
-    fn no_crt_objects(&mut self) {}
-}
-
-impl<'a> L4Bender<'a> {
-    fn new(cmd: Command, sess: &'a Session) -> L4Bender<'a> {
-        L4Bender { cmd, sess, hinted_static: false }
-    }
-
-    fn hint_static(&mut self) {
-        if !self.hinted_static {
-            self.link_or_cc_arg("-static");
-            self.hinted_static = true;
-        }
-    }
-}
-
 /// Linker for AIX.
 struct AixLinker<'a> {
     cmd: Command,

compiler/rustc_codegen_ssa/src/diagnostics.rs

@@ -97,10 +97,6 @@ pub(crate) struct Ld64UnimplementedModifier;
 #[diag("`as-needed` modifier not supported for current linker")]
 pub(crate) struct LinkerUnsupportedModifier;
 
-#[derive(Diagnostic)]
-#[diag("exporting symbols not implemented yet for L4Bender")]
-pub(crate) struct L4BenderExportingSymbolsUnimplemented;
-
 #[derive(Diagnostic)]
 #[diag("error enumerating natvis directory: {$error}")]
 pub(crate) struct NoNatvisDirectory {