Auto merge of #160238 - JonathanBrouwer:rollup-6GZndbU, r=JonathanBrouwer

Rollup of 25 pull requests

Successful merges:

 - #160204 (Sync from portable simd 2026 07 30)
 - #138230 (Add `raw_borrows_via_references` lint)
 - #158057 (Don't escape U+FF9E and U+FF9F in `escape_debug_ext`)
 - #160015 (refactor(mir-transform): Merge `can_be_overridden`, `is_required` and `is_enabled` into one)
 - #160031 (std: make positioned I/O unsupported on VxWorks)
 - #160125 (Fix typing mode handling in transmute checks and rustc_dump_layout)
 - #160152 (Create on-demand CI job for testing EC2 instances)
 - #160232 (rustdoc: fix ICE when a grapheme cluster joins a Prepend-class character to `_` or `:`)
 - #159214 (std: improve the documentation of the random feature)
 - #159818 (Resolve vars before calling `unnormalized_obligations`)
 - #159955 (Stop using higher-order macros to declare arenas)
 - #159958 (Fix avoid cycle for self referential return type notation)
 - #160040 (Split function parsing out of `item.rs` to a new module.)
 - #160044 (Add regression tests for fixed dead-code issues)
 - #160144 (renovate: group lockfiles PRs)
 - #160149 (Fix Windows on Arm PAC default)
 - #160164 (Derive `GenericTypeVisitable` for `RegionConstraint`)
 - #160175 (Try to recover less from incorrectly parsed const arg)
 - #160177 (A few more "predicate"-to-"clause" renamings)
 - #160181 (Mark `Tuple` and `FnPtr` traits `#[fundamental]`)
 - #160192 (Fix ICE for parsing issue with a closing brace)
 - #160209 (bootstrap: Remove method `Subcommand::kind`)
 - #160221 (Remove `Copy` supertrait from `VaList`)
 - #160223 (interpret: rename validate_operand → validate_place)
 - #160234 (Always use short ty path for call with missing arguments suggestion)

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_arena/src/lib.rs

@@ -598,21 +598,32 @@ impl DroplessArena {
     }
 }
 
-/// Declare an `Arena` containing one dropless arena and many typed arenas (the
-/// types of the typed arenas are specified by the arguments).
+/// Declares an `Arena` that can allocate values of a variety of `Copy`, `needs_drop` and
+/// `!needs_drop` types.
 ///
-/// There are three cases of interest.
-/// - Types that are `Copy`: these need not be specified in the arguments. They
-///   will use the `DroplessArena`.
-/// - Types that are `!Copy` and `!Drop`: these must be specified in the
-///   arguments. An empty `TypedArena` will be created for each one, but the
-///   `DroplessArena` will always be used and the `TypedArena` will stay empty.
-///   This is odd but harmless, because an empty arena allocates no memory.
-/// - Types that are `!Copy` and `Drop`: these must be specified in the
-///   arguments. The `TypedArena` will be used for them.
+/// The declared arena actually contains a single [`DroplessArena`], plus a separate
+/// [`TypedArena`] for each of the types listed in the body of the macro invocation.
 ///
+/// Any type that is `Copy` can be allocated in the arena without needing to be listed
+/// explicitly. Those values will be stored in the [`DroplessArena`].
+///
+/// Types that are `!Copy` can only be allocated if they are listed in the macro invocation.
+/// For types that are `!Copy + needs_drop`, values will be stored in the corresponding
+/// [`TypedArena`] and will be dropped when the arena is dropped.
+///
+/// As an optimization, types that are `!Copy + !needs_drop` will actually be stored in the
+/// [`DroplessArena`], and the corresponding [`TypedArena`] will remain empty. This makes
+/// better use of the dropless arena's storage blocks, while the overhead of having a few
+/// unused typed-arenas is negligible.
 #[rustc_macro_transparency = "semiopaque"]
-pub macro declare_arena([$($a:tt $name:ident: $ty:ty,)*]) {
+pub macro declare_arena(
+    // Each of these entries becomes a `$name: TypedArena<$ty>` field in the arena.
+    // This allows values of non-copy type $ty to be allocated in the arena.
+    // The field names must be distinct, but have no further significance.
+    $(
+        $name:ident: $ty:ty,
+    )*
+) {
     #[derive(Default)]
     pub struct Arena<'tcx> {
         pub dropless: $crate::DroplessArena,

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_const_eval/src/const_eval/eval_queries.rs

@@ -484,7 +484,7 @@ fn const_validate_mplace<'tcx>(
                 CtfeValidationMode::Const { allow_immutable_unsafe_cell: !inner }
             }
         };
-        ecx.const_validate_operand(&mplace.into(), path, &mut ref_tracking, mode)
+        ecx.const_validate_place(&mplace.into(), path, &mut ref_tracking, mode)
             .report_err()
             // Instead of just reporting the `InterpError` via the usual machinery, we give a more targeted
             // error about the validation failure.

compiler/rustc_const_eval/src/interpret/intrinsics.rs

@@ -1117,7 +1117,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         // ourselves. This value is now in `left.` The one that started out in `left` already got
         // validated by the copy above.
         if M::enforce_validity(self, left.layout) {
-            self.validate_operand(
+            self.validate_place(
                 &left.clone().into(),
                 M::enforce_validity_recursively(self, left.layout),
                 /*reset_provenance_and_padding*/ true,

compiler/rustc_const_eval/src/interpret/place.rs

@@ -626,7 +626,7 @@ where
         if M::enforce_validity(self, dest.layout()) {
             // Data got changed, better make sure it matches the type!
             // Also needed to reset padding.
-            self.validate_operand(
+            self.validate_place(
                 &dest.to_place(),
                 M::enforce_validity_recursively(self, dest.layout()),
                 /*reset_provenance_and_padding*/ true,
@@ -858,13 +858,13 @@ where
             // shared reference.
             // But if the types are identical, that is strictly redundant so we only do one pass.
             if src.layout().ty != dest.layout().ty {
-                self.validate_operand(
+                self.validate_place(
                     &dest.transmute(src.layout(), self)?,
                     M::enforce_validity_recursively(self, src.layout()),
                     /*reset_provenance_and_padding*/ true,
                 )?;
             }
-            self.validate_operand(
+            self.validate_place(
                 &dest,
                 M::enforce_validity_recursively(self, dest.layout()),
                 /*reset_provenance_and_padding*/ true,

compiler/rustc_const_eval/src/interpret/step.rs

@@ -342,7 +342,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         // Validate that the entire thing is valid, and reset padding that might be in between the
         // fields.
         if M::enforce_validity(self, dest.layout()) {
-            self.validate_operand(
+            self.validate_place(
                 dest,
                 M::enforce_validity_recursively(self, dest.layout()),
                 /*reset_provenance_and_padding*/ true,

compiler/rustc_const_eval/src/interpret/validity.rs

@@ -363,7 +363,7 @@ struct ValidityVisitor<'rt, 'tcx, M: Machine<'tcx>> {
     /// we only store a (range) set of offsets -- the base pointer is the same throughout the entire
     /// visit, after all.
     /// If this is `Some`, then `reset_provenance_and_padding` must be true (but not vice versa:
-    /// we might not track data vs padding bytes if the operand isn't stored in memory anyway).
+    /// we might not track data vs padding bytes if the place isn't stored in memory anyway).
     data_bytes: Option<RangeSet>,
     /// True if we are inside of `MaybeDangling`. This disables pointer access checks.
     may_dangle: bool,
@@ -1573,7 +1573,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValueVisitor<'tcx, M> for ValidityVisitor<'rt,
 
 impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// The internal core entry point for all validation operations.
-    fn validate_operand_internal(
+    fn validate_place_internal(
         &mut self,
         val: &PlaceTy<'tcx, M::Provenance>,
         path: Path<'tcx>,
@@ -1582,7 +1582,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         reset_provenance_and_padding: bool,
         start_in_may_dangle: bool,
     ) -> InterpResult<'tcx> {
-        trace!("validate_operand_internal: {:?}, {:?}", *val, val.layout.ty);
+        trace!("validate_place_internal: {:?}, {:?}", *val, val.layout.ty);
 
         // Run the visitor.
         self.run_for_validation_mut(|ecx| {
@@ -1621,7 +1621,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     }
 
     /// This function checks the data at `val` to be const-valid.
-    /// `val` is assumed to cover valid memory if it is an indirect operand.
+    /// `val` is assumed to cover valid memory.
     /// It will error if the bits at the destination do not match the ones described by the layout.
     ///
     /// `ref_tracking` is used to record references that we encounter so that they
@@ -1631,14 +1631,14 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     /// - no pointers to statics.
     /// - no `UnsafeCell` or non-ZST `&mut`.
     #[inline(always)]
-    pub(crate) fn const_validate_operand(
+    pub(crate) fn const_validate_place(
         &mut self,
         val: &PlaceTy<'tcx, M::Provenance>,
         path: Path<'tcx>,
         ref_tracking: &mut RefTracking<MPlaceTy<'tcx, M::Provenance>, Path<'tcx>>,
         ctfe_mode: CtfeValidationMode,
     ) -> InterpResult<'tcx> {
-        self.validate_operand_internal(
+        self.validate_place_internal(
             val,
             path,
             Some(ref_tracking),
@@ -1649,27 +1649,22 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
     }
 
     /// This function checks the data at `val` to be runtime-valid.
-    /// `val` is assumed to cover valid memory if it is an indirect operand.
+    /// `val` is assumed to cover valid memory.
     /// It will error if the bits at the destination do not match the ones described by the layout.
     #[inline(always)]
-    pub fn validate_operand(
+    pub fn validate_place(
         &mut self,
         val: &PlaceTy<'tcx, M::Provenance>,
         recursive: bool,
         reset_provenance_and_padding: bool,
     ) -> InterpResult<'tcx> {
-        let _trace = enter_trace_span!(
-            M,
-            "validate_operand",
-            recursive,
-            reset_provenance_and_padding,
-            ?val,
-        );
+        let _trace =
+            enter_trace_span!(M, "validate_place", recursive, reset_provenance_and_padding, ?val,);
         // Note that we *could* actually be in CTFE here with `-Zextra-const-ub-checks`, but it's
         // still correct to not use `ctfe_mode`: that mode is for validation of the final constant
         // value, it rules out things like `UnsafeCell` in awkward places.
         if !recursive {
-            return self.validate_operand_internal(
+            return self.validate_place_internal(
                 val,
                 Path::new(val.layout.ty),
                 None,
@@ -1680,7 +1675,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
         }
         // Do a recursive check.
         let mut ref_tracking = RefTracking::empty();
-        self.validate_operand_internal(
+        self.validate_place_internal(
             val,
             Path::new(val.layout.ty),
             Some(&mut ref_tracking),
@@ -1692,7 +1687,7 @@ impl<'tcx, M: Machine<'tcx>> InterpCx<'tcx, M> {
             // Things behind reference do *not* have the provenance reset. In fact
             // we treat the entire thing as being inside MaybeDangling, i.e., references
             // do not have to be dereferenceable.
-            self.validate_operand_internal(
+            self.validate_place_internal(
                 &mplace.into(),
                 path,
                 None, // no further recursion

compiler/rustc_const_eval/src/util/check_validity_requirement.rs

@@ -76,7 +76,7 @@ fn check_validity_requirement_strict<'tcx>(
     // option this is fine, but if this is ever meant to be stable we should probably add
     // a "fast mode" to validation.
     with_no_trimmed_paths!(
-        cx.validate_operand(
+        cx.validate_place(
             &allocated.into(),
             /*recursive*/ false,
             /*reset_provenance_and_padding*/ false,
@@ -200,7 +200,7 @@ pub(crate) fn validate_scalar_in_layout<'tcx>(
 
     cx.write_scalar(scalar, &allocated).unwrap();
 
-    cx.validate_operand(
+    cx.validate_place(
         &allocated.into(),
         /*recursive*/ false,
         /*reset_provenance_and_padding*/ false,