Auto merge of #152450 - cuviper:stable-next, r=cuviper

[stable] prepare Rust 1.93.1

This includes the following backported fixes:

- Don't try to recover keyword as non-keyword identifier rust-lang/rust#150590
- Fix `panicking_unwrap` FP on field access with implicit deref rust-lang/rust-clippy#16196
- Revert "Update wasm-related dependencies in CI" rust-lang/rust#152259

And these are just to avoid recent CI issues:

- Remove rustdoc GUI flaky test rust-lang/rust#152116
- Remove the 4 failing tests from rustdoc-gui rust-lang/rust#152194

r? @rust-lang/release
@rustbot ping relnotes-interest-group

.github/workflows/ci.yml

@@ -15,6 +15,7 @@ on:
       - try
       - try-perf
       - automation/bors/try
+      - automation/bors/auto
   pull_request:
     branches:
       - "**"
@@ -56,7 +57,7 @@ jobs:
       - name: Test citool
         # Only test citool on the auto branch, to reduce latency of the calculate matrix job
         # on PR/try builds.
-        if: ${{ github.ref == 'refs/heads/auto' }}
+        if: ${{ github.ref == 'refs/heads/auto' || github.ref == 'refs/heads/automation/bors/auto' }}
         run: |
           cd src/ci/citool
           CARGO_INCREMENTAL=0 cargo test
@@ -79,7 +80,7 @@ jobs:
     # access the environment.
     #
     # We only enable the environment for the rust-lang/rust repository, so that CI works on forks.
-    environment: ${{ ((github.repository == 'rust-lang/rust' && (github.ref == 'refs/heads/try' || github.ref == 'refs/heads/try-perf' || github.ref == 'refs/heads/automation/bors/try' || github.ref == 'refs/heads/auto')) && 'bors') || '' }}
+    environment: ${{ ((github.repository == 'rust-lang/rust' && (github.ref == 'refs/heads/try' || github.ref == 'refs/heads/try-perf' || github.ref == 'refs/heads/automation/bors/try' || github.ref == 'refs/heads/auto' || github.ref == 'refs/heads/automation/bors/auto')) && 'bors') || '' }}
     env:
       CI_JOB_NAME: ${{ matrix.name }}
       CI_JOB_DOC_URL: ${{ matrix.doc_url }}
@@ -288,7 +289,7 @@ jobs:
           fi
 
           # Get closest bors merge commit
-          PARENT_COMMIT=`git rev-list --author='bors <bors@rust-lang.org>' -n1 --first-parent HEAD^1`
+          PARENT_COMMIT=`git rev-list --author='bors@rust-lang.org' --author='122020455+rust-bors\[bot\]@users.noreply.github.com' -n1 --first-parent HEAD^1`
 
           ./build/citool/debug/citool postprocess-metrics \
               --job-name ${CI_JOB_NAME} \
@@ -313,7 +314,7 @@ jobs:
     needs: [ calculate_matrix, job ]
     # !cancelled() executes the job regardless of whether the previous jobs passed or failed
     if: ${{ !cancelled() && contains(fromJSON('["auto", "try"]'), needs.calculate_matrix.outputs.run_type) }}
-    environment: ${{ ((github.repository == 'rust-lang/rust' && (github.ref == 'refs/heads/try' || github.ref == 'refs/heads/try-perf' || github.ref == 'refs/heads/automation/bors/try' || github.ref == 'refs/heads/auto')) && 'bors') || '' }}
+    environment: ${{ ((github.repository == 'rust-lang/rust' && (github.ref == 'refs/heads/try' || github.ref == 'refs/heads/try-perf' || github.ref == 'refs/heads/automation/bors/try' || github.ref == 'refs/heads/auto' || github.ref == 'refs/heads/automation/bors/auto')) && 'bors') || '' }}
     steps:
       - name: checkout the source code
         uses: actions/checkout@v5

.github/workflows/post-merge.yml

@@ -29,7 +29,7 @@ jobs:
           sleep 60
 
           # Get closest bors merge commit
-          PARENT_COMMIT=`git rev-list --author='bors <bors@rust-lang.org>' -n1 --first-parent HEAD^1`
+          PARENT_COMMIT=`git rev-list --author='bors@rust-lang.org' --author='122020455+rust-bors\[bot\]@users.noreply.github.com' -n1 --first-parent HEAD^1`
           echo "Parent: ${PARENT_COMMIT}"
 
           # Find PR for the current commit

RELEASES.md

@@ -1,3 +1,208 @@
+Version 1.93.1 (2026-02-12)
+===========================
+
+<a id="1.93.1"></a>
+
+- [Don't try to recover keyword as non-keyword identifier](https://github.com/rust-lang/rust/pull/150590), fixing an ICE that especially [affected rustfmt](https://github.com/rust-lang/rustfmt/issues/6739).
+- [Fix `clippy::panicking_unwrap` false-positive on field access with implicit deref](https://github.com/rust-lang/rust-clippy/pull/16196).
+- [Revert "Update wasm-related dependencies in CI"](https://github.com/rust-lang/rust/pull/152259), fixing file descriptor leaks on the `wasm32-wasip2` target.
+
+Version 1.93.0 (2026-01-22)
+==========================
+
+<a id="1.93.0-Language"></a>
+
+Language
+--------
+- [Stabilize several s390x `vector`-related target features and the `is_s390x_feature_detected!` macro](https://github.com/rust-lang/rust/pull/145656)
+- [Stabilize declaration of C-style variadic functions for the `system` ABI](https://github.com/rust-lang/rust/pull/145954)
+- [Emit error when using some keyword as a `cfg` predicate](https://github.com/rust-lang/rust/pull/146978)
+- [Stabilize `asm_cfg`](https://github.com/rust-lang/rust/pull/147736)
+- [During const-evaluation, support copying pointers byte-by-byte](https://github.com/rust-lang/rust/pull/148259)
+- [LUB coercions now correctly handle function item types, and functions with differing safeties](https://github.com/rust-lang/rust/pull/148602)
+- [Allow `const` items that contain mutable references to `static` (which is *very* unsafe, but not *always* UB)](https://github.com/rust-lang/rust/pull/148746)
+- [Add warn-by-default `const_item_interior_mutations` lint to warn against calls which mutate interior mutable `const` items](https://github.com/rust-lang/rust/pull/148407)
+- [Add warn-by-default `function_casts_as_integer` lint](https://github.com/rust-lang/rust/pull/141470)
+
+
+<a id="1.93.0-Compiler"></a>
+
+Compiler
+--------
+- [Stabilize `-Cjump-tables=bool`](https://github.com/rust-lang/rust/pull/145974). The flag was previously called `-Zno-jump-tables`.
+
+<a id="1.93.0-Platform-Support"></a>
+
+Platform Support
+----------------
+
+- [Promote `riscv64a23-unknown-linux-gnu` to Tier 2 (without host tools)](https://github.com/rust-lang/rust/pull/148435)
+
+Refer to Rust's [platform support page][platform-support-doc]
+for more information on Rust's tiered platform support.
+
+[platform-support-doc]: https://doc.rust-lang.org/rustc/platform-support.html
+
+<a id="1.93.0-Libraries"></a>
+
+Libraries
+---------
+- [Stop internally using `specialization` on the `Copy` trait as it is unsound in the presence of lifetime dependent `Copy` implementations. This may result in some performance regressions as some standard library APIs may now call `Clone::clone` instead of performing bitwise copies](https://github.com/rust-lang/rust/pull/135634)
+- [Allow the global allocator to use thread-local storage and `std::thread::current()`](https://github.com/rust-lang/rust/pull/144465)
+- [Make `BTree::append` not update existing keys when appending an entry which already exists](https://github.com/rust-lang/rust/pull/145628)
+- [Don't require `T: RefUnwindSafe` for `vec::IntoIter<T>: UnwindSafe`](https://github.com/rust-lang/rust/pull/145665)
+
+
+<a id="1.93.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`<[MaybeUninit<T>]>::assume_init_drop`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.assume_init_drop)
+- [`<[MaybeUninit<T>]>::assume_init_ref`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.assume_init_ref)
+- [`<[MaybeUninit<T>]>::assume_init_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.assume_init_mut)
+- [`<[MaybeUninit<T>]>::write_copy_of_slice`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.write_copy_of_slice)
+- [`<[MaybeUninit<T>]>::write_clone_of_slice`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.write_clone_of_slice)
+- [`String::into_raw_parts`](https://doc.rust-lang.org/stable/std/string/struct.String.html#method.into_raw_parts)
+- [`Vec::into_raw_parts`](https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.into_raw_parts)
+- [`<iN>::unchecked_neg`](https://doc.rust-lang.org/stable/std/primitive.isize.html#method.unchecked_neg)
+- [`<iN>::unchecked_shl`](https://doc.rust-lang.org/stable/std/primitive.isize.html#method.unchecked_shl)
+- [`<iN>::unchecked_shr`](https://doc.rust-lang.org/stable/std/primitive.isize.html#method.unchecked_shr)
+- [`<uN>::unchecked_shl`](https://doc.rust-lang.org/stable/std/primitive.usize.html#method.unchecked_shl)
+- [`<uN>::unchecked_shr`](https://doc.rust-lang.org/stable/std/primitive.usize.html#method.unchecked_shr)
+- [`<[T]>::as_array`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.as_array)
+- [`<[T]>::as_mut_array`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.as_mut_array)
+- [`<*const [T]>::as_array`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.as_array)
+- [`<*mut [T]>::as_mut_array`](https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.as_mut_array)
+- [`VecDeque::pop_front_if`](https://doc.rust-lang.org/stable/std/collections/struct.VecDeque.html#method.pop_front_if)
+- [`VecDeque::pop_back_if`](https://doc.rust-lang.org/stable/std/collections/struct.VecDeque.html#method.pop_back_if)
+- [`Duration::from_nanos_u128`](https://doc.rust-lang.org/stable/std/time/struct.Duration.html#method.from_nanos_u128)
+- [`char::MAX_LEN_UTF8`](https://doc.rust-lang.org/stable/std/primitive.char.html#associatedconstant.MAX_LEN_UTF8)
+- [`char::MAX_LEN_UTF16`](https://doc.rust-lang.org/stable/std/primitive.char.html#associatedconstant.MAX_LEN_UTF16)
+- [`std::fmt::from_fn`](https://doc.rust-lang.org/stable/std/fmt/fn.from_fn.html)
+- [`std::fmt::FromFn`](https://doc.rust-lang.org/stable/std/fmt/struct.FromFn.html)
+
+
+<a id="1.93.0-Cargo"></a>
+
+Cargo
+-----
+- [Enable CARGO_CFG_DEBUG_ASSERTIONS in build scripts based on profile](https://github.com/rust-lang/cargo/pull/16160/)
+- [In `cargo tree`, support long forms for `--format` variables](https://github.com/rust-lang/cargo/pull/16204/)
+- [Add `--workspace` to `cargo clean`](https://github.com/rust-lang/cargo/pull/16263/)
+
+<a id="1.93.0-Rustdoc"></a>
+
+Rustdoc
+-----
+- [Remove `#![doc(document_private_items)]`](https://github.com/rust-lang/rust/pull/146495)
+- [Include attribute and derive macros in search filters for "macros"](https://github.com/rust-lang/rust/pull/148176)
+- [Include extern crates in search filters for `import`](https://github.com/rust-lang/rust/pull/148301)
+- [Validate usage of crate-level doc attributes](https://github.com/rust-lang/rust/pull/149197).  This means if any of `html_favicon_url`, `html_logo_url`, `html_playground_url`, `issue_tracker_base_url`, or `html_no_source` either has a missing value, an unexpected value, or a value of the wrong type, rustdoc will emit the deny-by-default lint `rustdoc::invalid_doc_attributes`.
+
+
+<a id="1.93.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+- [Introduce `pin_v2` into the builtin attributes namespace](https://github.com/rust-lang/rust/pull/139751)
+- [Update bundled musl to 1.2.5](https://github.com/rust-lang/rust/pull/142682)
+- [On Emscripten, the unwinding ABI used when compiling with `panic=unwind` was changed from the JS exception handling ABI to the wasm exception handling ABI.](https://github.com/rust-lang/rust/pull/147224) If linking C/C++ object files with Rust objects, `-fwasm-exceptions` must be passed to the linker now. On nightly Rust, it is possible to get the old behavior with `-Zwasm-emscripten-eh=false -Zbuild-std`, but it will be removed in a future release.
+- The `#[test]` attribute, used to define tests, was previously ignored in various places where it had no meaning (e.g on trait methods or types). Putting the `#[test]` attribute in these places is no longer ignored, and will now result in an error; this may also result in errors when generating rustdoc. [Error when `test` attribute is applied to structs](https://github.com/rust-lang/rust/pull/147841)
+- Cargo now sets the `CARGO_CFG_DEBUG_ASSERTIONS` environment variable in more situations. This will cause crates depending on `static-init` versions 1.0.1 to 1.0.3 to fail compilation with "failed to resolve: use of unresolved module or unlinked crate `parking_lot`". See [the linked issue](https://github.com/rust-lang/rust/issues/150646#issuecomment-3718964342) for details.
+- [User written types in the `offset_of!` macro are now checked to be well formed.](https://github.com/rust-lang/rust/issues/150465/)
+- `cargo publish` no longer emits `.crate` files as a final artifact for user access when the `build.build-dir` config is unset
+- [Upgrade the `deref_nullptr` lint from warn-by-default to deny-by-default](https://github.com/rust-lang/rust/pull/148122)
+- [Add future-incompatibility warning for `...` function parameters without a pattern outside of `extern` blocks](https://github.com/rust-lang/rust/pull/143619)
+- [Introduce future-compatibility warning for `repr(C)` enums whose discriminant values do not fit into a `c_int` or `c_uint`](https://github.com/rust-lang/rust/pull/147017)
+- [Introduce future-compatibility warning against ignoring `repr(C)` types as part of `repr(transparent)`](https://github.com/rust-lang/rust/pull/147185)
+
+
+Version 1.92.0 (2025-12-11)
+==========================
+
+<a id="1.92.0-Language"></a>
+
+Language
+--------
+- [Document `MaybeUninit` representation and validity](https://github.com/rust-lang/rust/pull/140463)
+- [Allow `&raw [mut | const]` for union field in safe code](https://github.com/rust-lang/rust/pull/141469)
+- [Prefer item bounds of associated types over where-bounds for auto-traits and `Sized`](https://github.com/rust-lang/rust/pull/144064)
+- [Do not materialize `X` in `[X; 0]` when `X` is unsizing a const](https://github.com/rust-lang/rust/pull/145277)
+- [Support combining `#[track_caller]` and `#[no_mangle]` (requires every declaration specifying `#[track_caller]` as well)](https://github.com/rust-lang/rust/pull/145724)
+- [Make never type lints `never_type_fallback_flowing_into_unsafe` and `dependency_on_unit_never_type_fallback` deny-by-default](https://github.com/rust-lang/rust/pull/146167)
+- [Allow specifying multiple bounds for same associated item, except in trait objects](https://github.com/rust-lang/rust/pull/146593)
+- [Slightly strengthen higher-ranked region handling in coherence](https://github.com/rust-lang/rust/pull/146725)
+- [The `unused_must_use` lint no longer warns on `Result<(), Uninhabited>` (for instance, `Result<(), !>`), or `ControlFlow<Uninhabited, ()>`](https://github.com/rust-lang/rust/pull/147382). This avoids having to check for an error that can never happen.
+
+<a id="1.92.0-Compiler"></a>
+
+Compiler
+--------
+- [Make `mips64el-unknown-linux-muslabi64` link dynamically](https://github.com/rust-lang/rust/pull/146858)
+- [Remove current code for embedding command-line args in PDB](https://github.com/rust-lang/rust/pull/147022)
+  Command-line information is typically not needed by debugging tools, and the removed code
+  was causing problems for incremental builds even on targets that don't use PDB debuginfo.
+
+<a id="1.92.0-Libraries"></a>
+
+Libraries
+---------
+- [Specialize `Iterator::eq{_by}` for `TrustedLen` iterators](https://github.com/rust-lang/rust/pull/137122)
+- [Simplify `Extend` for tuples](https://github.com/rust-lang/rust/pull/138799)
+- [Added details to `Debug` for `EncodeWide`](https://github.com/rust-lang/rust/pull/140153).
+- [`iter::Repeat::last`](https://github.com/rust-lang/rust/pull/147258) and [`count`](https://github.com/rust-lang/rust/pull/146410) will now panic, rather than looping infinitely.
+
+<a id="1.92.0-Stabilized-APIs"></a>
+
+Stabilized APIs
+---------------
+
+- [`NonZero<u{N}>::div_ceil`](https://doc.rust-lang.org/stable/std/num/struct.NonZero.html#method.div_ceil)
+- [`Location::file_as_c_str`](https://doc.rust-lang.org/stable/std/panic/struct.Location.html#method.file_as_c_str)
+- [`RwLockWriteGuard::downgrade`](https://doc.rust-lang.org/stable/std/sync/struct.RwLockWriteGuard.html#method.downgrade)
+- [`Box::new_zeroed`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.new_zeroed)
+- [`Box::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/boxed/struct.Box.html#method.new_zeroed_slice)
+- [`Rc::new_zeroed`](https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.new_zeroed)
+- [`Rc::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/rc/struct.Rc.html#method.new_zeroed_slice)
+- [`Arc::new_zeroed`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.new_zeroed)
+- [`Arc::new_zeroed_slice`](https://doc.rust-lang.org/stable/std/sync/struct.Arc.html#method.new_zeroed_slice)
+- [`btree_map::Entry::insert_entry`](https://doc.rust-lang.org/stable/std/collections/btree_map/enum.Entry.html#method.insert_entry)
+- [`btree_map::VacantEntry::insert_entry`](https://doc.rust-lang.org/stable/std/collections/btree_map/struct.VacantEntry.html#method.insert_entry)
+- [`impl Extend<proc_macro::Group> for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CGroup%3E-for-TokenStream)
+- [`impl Extend<proc_macro::Literal> for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CLiteral%3E-for-TokenStream)
+- [`impl Extend<proc_macro::Punct> for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CPunct%3E-for-TokenStream)
+- [`impl Extend<proc_macro::Ident> for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CIdent%3E-for-TokenStream)
+
+These previously stable APIs are now stable in const contexts:
+
+- [`<[_]>::rotate_left`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.rotate_left)
+- [`<[_]>::rotate_right`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.rotate_right)
+
+<a id="1.92.0-Cargo"></a>
+
+Cargo
+-----
+- [Added a new chapter](https://github.com/rust-lang/cargo/issues/16119) to the Cargo book, ["Optimizing Build Performance"](https://doc.rust-lang.org/stable/cargo/guide/build-performance.html).
+
+<a id="1.92.0-Rustdoc"></a>
+
+Rustdoc
+-----
+- [If a trait item appears in rustdoc search, hide the corresponding impl items](https://github.com/rust-lang/rust/pull/145898).  Previously a search for "last" would show both `Iterator::last` as well as impl methods like `std::vec::IntoIter::last`.  Now these impl methods will be hidden, freeing up space for inherent methods like `BTreeSet::last`.
+- [Relax rules for identifiers in search](https://github.com/rust-lang/rust/pull/147860).  Previously you could only search for identifiers that were valid in rust code, now searches only need to be valid as part of an identifier.  For example, you can now perform a search that starts with a digit.
+
+<a id="1.92.0-Compatibility-Notes"></a>
+
+Compatibility Notes
+-------------------
+* [Fix backtraces with `-C panic=abort` on Linux by generating unwind tables by default](https://github.com/rust-lang/rust/pull/143613). Build with `-C force-unwind-tables=no` to keep omitting unwind tables.
+- As part of the larger effort refactoring compiler built-in attributes and their diagnostics, [the future-compatibility lint `invalid_macro_export_arguments` is upgraded to deny-by-default and will be reported in dependencies too.](https://github.com/rust-lang/rust/pull/143857)
+- [Update the minimum external LLVM to 20](https://github.com/rust-lang/rust/pull/145071)
+- [Prevent downstream `impl DerefMut for Pin<LocalType>`](https://github.com/rust-lang/rust/pull/145608)
+- [Don't apply temporary lifetime extension rules to the arguments of non-extended `pin!` and formatting macros](https://github.com/rust-lang/rust/pull/145838)
+
+
 Version 1.91.1 (2025-11-10)
 ===========================
 

compiler/rustc_feature/src/accepted.rs

@@ -61,7 +61,7 @@ declare_features! (
     /// Allows explicit discriminants on non-unit enum variants.
     (accepted, arbitrary_enum_discriminant, "1.66.0", Some(60553)),
     /// Allows #[cfg(...)] on inline assembly templates and operands.
-    (accepted, asm_cfg, "CURRENT_RUSTC_VERSION", Some(140364)),
+    (accepted, asm_cfg, "1.93.0", Some(140364)),
     /// Allows using `const` operands in inline assembly.
     (accepted, asm_const, "1.82.0", Some(93332)),
     /// Allows using `label` operands in inline assembly.
@@ -218,7 +218,7 @@ declare_features! (
     /// Allows access to crate names passed via `--extern` through prelude.
     (accepted, extern_prelude, "1.30.0", Some(44660)),
     /// Allows using `system` as a calling convention with varargs.
-    (accepted, extern_system_varargs, "CURRENT_RUSTC_VERSION", Some(136946)),
+    (accepted, extern_system_varargs, "1.93.0", Some(136946)),
     /// Allows using F16C intrinsics from `core::arch::{x86, x86_64}`.
     (accepted, f16c_target_feature, "1.68.0", Some(44839)),
     /// Allows field shorthands (`x` meaning `x: x`) in struct literal expressions.
@@ -392,7 +392,7 @@ declare_features! (
     /// Allows code like `let x: &'static u32 = &42` to work (RFC 1414).
     (accepted, rvalue_static_promotion, "1.21.0", Some(38865)),
     /// Allows use of the `vector` and related s390x target features.
-    (accepted, s390x_target_feature_vector, "CURRENT_RUSTC_VERSION", Some(145649)),
+    (accepted, s390x_target_feature_vector, "1.93.0", Some(145649)),
     /// Allows `Self` in type definitions (RFC 2300).
     (accepted, self_in_typedefs, "1.32.0", Some(49303)),
     /// Allows `Self` struct constructor (RFC 2302).

compiler/rustc_feature/src/removed.rs

@@ -190,7 +190,7 @@ declare_features! (
     /// Allows use of unary negate on unsigned integers, e.g., -e for e: u8
     (removed, negate_unsigned, "1.0.0", Some(29645), None),
     /// Allows diverging expressions to fall back to `!` rather than `()`.
-    (removed, never_type_fallback, "CURRENT_RUSTC_VERSION", Some(65992), Some("removed in favor of unconditional fallback"), 148871),
+    (removed, never_type_fallback, "1.93.0", Some(65992), Some("removed in favor of unconditional fallback"), 148871),
     /// Allows `#[no_coverage]` on functions.
     /// The feature was renamed to `coverage_attribute` and the attribute to `#[coverage(on|off)]`
     (removed, no_coverage, "1.74.0", Some(84605), Some("renamed to `coverage_attribute`"), 114656),

compiler/rustc_feature/src/unstable.rs

@@ -410,7 +410,7 @@ declare_features! (
     (unstable, c_variadic, "1.34.0", Some(44930)),
     /// Allows defining c-variadic naked functions with any extern ABI that is allowed
     /// on c-variadic foreign functions.
-    (unstable, c_variadic_naked_functions, "CURRENT_RUSTC_VERSION", Some(148767)),
+    (unstable, c_variadic_naked_functions, "1.93.0", Some(148767)),
     /// Allows the use of `#[cfg(contract_checks)` to check if contract checks are enabled.
     (unstable, cfg_contract_checks, "1.86.0", Some(128044)),
     /// Allows the use of `#[cfg(overflow_checks)` to check if integer overflow behaviour.
@@ -484,7 +484,7 @@ declare_features! (
     /// Allows deriving the From trait on single-field structs.
     (unstable, derive_from, "1.91.0", Some(144889)),
     /// Allows giving non-const impls custom diagnostic messages if attempted to be used as const
-    (unstable, diagnostic_on_const, "CURRENT_RUSTC_VERSION", Some(143874)),
+    (unstable, diagnostic_on_const, "1.93.0", Some(143874)),
     /// Allows `#[doc(cfg(...))]`.
     (unstable, doc_cfg, "1.21.0", Some(43781)),
     /// Allows `#[doc(masked)]`.

compiler/rustc_lint/src/interior_mutable_consts.rs

@@ -1,6 +1,7 @@
 use rustc_hir::attrs::AttributeKind;
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, ItemKind, Node, find_attr};
+use rustc_middle::ty::adjustment::Adjust;
 use rustc_session::{declare_lint, declare_lint_pass};
 
 use crate::lints::{ConstItemInteriorMutationsDiag, ConstItemInteriorMutationsSuggestionStatic};
@@ -77,6 +78,13 @@ impl<'tcx> LateLintPass<'tcx> for InteriorMutableConsts {
         if let ExprKind::Path(qpath) = &receiver.kind
             && let Res::Def(DefKind::Const | DefKind::AssocConst, const_did) =
                 typeck.qpath_res(qpath, receiver.hir_id)
+            // Don't consider derefs as those can do arbitrary things
+            // like using thread local (see rust-lang/rust#150157)
+            && !cx
+                .typeck_results()
+                .expr_adjustments(receiver)
+                .into_iter()
+                .any(|adj| matches!(adj.kind, Adjust::Deref(_)))
             // Let's do the attribute check after the other checks for perf reasons
             && find_attr!(
                 cx.tcx.get_all_attrs(method_did),

compiler/rustc_mir_build/src/builder/mod.rs

@@ -839,6 +839,25 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 self.infcx.typing_env(self.param_env),
             );
 
+            // check if the function's return type is inhabited
+            // this was added here because of this regression
+            // https://github.com/rust-lang/rust/issues/149571
+            let output_is_inhabited =
+                if matches!(self.tcx.def_kind(self.def_id), DefKind::Fn | DefKind::AssocFn) {
+                    self.tcx
+                        .fn_sig(self.def_id)
+                        .instantiate_identity()
+                        .skip_binder()
+                        .output()
+                        .is_inhabited_from(
+                            self.tcx,
+                            self.parent_module,
+                            self.infcx.typing_env(self.param_env),
+                        )
+                } else {
+                    true
+                };
+
             if !ty_is_inhabited {
                 // Unreachable code warnings are already emitted during type checking.
                 // However, during type checking, full type information is being
@@ -849,7 +868,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 // uninhabited types (e.g. empty enums). The check above is used so
                 // that we do not emit the same warning twice if the uninhabited type
                 // is indeed `!`.
-                if !ty.is_never() {
+                if !ty.is_never() && output_is_inhabited {
                     lints.push((target_bb, ty, term.source_info.span));
                 }
 

compiler/rustc_mir_transform/src/liveness.rs

@@ -75,11 +75,6 @@ pub(crate) fn check_liveness<'tcx>(tcx: TyCtxt<'tcx>, def_id: LocalDefId) -> Den
         return DenseBitSet::new_empty(0);
     }
 
-    // Don't run unused pass for items generated by foreign macros
-    if tcx.def_span(parent).in_external_macro(tcx.sess.source_map()) {
-        return DenseBitSet::new_empty(0);
-    }
-
     let mut body = &*tcx.mir_promoted(def_id).0.borrow();
     let mut body_mem;
 

compiler/rustc_mir_transform/src/simplify_comparison_integral.rs

@@ -27,7 +27,7 @@ pub(super) struct SimplifyComparisonIntegral;
 
 impl<'tcx> crate::MirPass<'tcx> for SimplifyComparisonIntegral {
     fn is_enabled(&self, sess: &rustc_session::Session) -> bool {
-        sess.mir_opt_level() > 0
+        sess.mir_opt_level() > 0 && sess.opts.unstable_opts.unsound_mir_opts
     }
 
     fn run_pass(&self, tcx: TyCtxt<'tcx>, body: &mut Body<'tcx>) {

compiler/rustc_parse/src/parser/item.rs

@@ -393,6 +393,7 @@ impl<'a> Parser<'a> {
         let insert_span = ident_span.shrink_to_lo();
 
         let ident = if self.token.is_ident()
+            && self.token.is_non_reserved_ident()
             && (!is_const || self.look_ahead(1, |t| *t == token::OpenParen))
             && self.look_ahead(1, |t| {
                 matches!(t.kind, token::Lt | token::OpenBrace | token::OpenParen)

library/alloc/src/collections/vec_deque/mod.rs

@@ -2053,7 +2053,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(deque, [1, 2, 3, 4]);
     /// assert_eq!(deque.pop_front_if(pred), None);
     /// ```
-    #[stable(feature = "vec_deque_pop_if", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "vec_deque_pop_if", since = "1.93.0")]
     pub fn pop_front_if(&mut self, predicate: impl FnOnce(&mut T) -> bool) -> Option<T> {
         let first = self.front_mut()?;
         if predicate(first) { self.pop_front() } else { None }
@@ -2075,7 +2075,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert_eq!(deque, [0, 1, 2, 3]);
     /// assert_eq!(deque.pop_back_if(pred), None);
     /// ```
-    #[stable(feature = "vec_deque_pop_if", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "vec_deque_pop_if", since = "1.93.0")]
     pub fn pop_back_if(&mut self, predicate: impl FnOnce(&mut T) -> bool) -> Option<T> {
         let last = self.back_mut()?;
         if predicate(last) { self.pop_back() } else { None }

library/alloc/src/fmt.rs

@@ -602,7 +602,7 @@ pub use core::fmt::{DebugAsHex, FormattingOptions, Sign};
 pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::fmt::{Formatter, Result, Write};
-#[stable(feature = "fmt_from_fn", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "fmt_from_fn", since = "1.93.0")]
 pub use core::fmt::{FromFn, from_fn};
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::fmt::{LowerExp, UpperExp};

library/alloc/src/string.rs

@@ -937,7 +937,7 @@ impl String {
     /// assert_eq!(rebuilt, "hello");
     /// ```
     #[must_use = "losing the pointer will leak memory"]
-    #[stable(feature = "vec_into_raw_parts", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "vec_into_raw_parts", since = "1.93.0")]
     pub fn into_raw_parts(self) -> (*mut u8, usize, usize) {
         self.vec.into_raw_parts()
     }

library/alloc/src/vec/mod.rs

@@ -781,7 +781,7 @@ impl<T> Vec<T> {
     /// assert_eq!(rebuilt, [4294967295, 0, 1]);
     /// ```
     #[must_use = "losing the pointer will leak memory"]
-    #[stable(feature = "vec_into_raw_parts", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "vec_into_raw_parts", since = "1.93.0")]
     pub fn into_raw_parts(self) -> (*mut T, usize, usize) {
         let mut me = ManuallyDrop::new(self);
         (me.as_mut_ptr(), me.len(), me.capacity())

library/core/src/char/methods.rs

@@ -74,12 +74,12 @@ impl char {
 
     /// The maximum number of bytes required to [encode](char::encode_utf8) a `char` to
     /// UTF-8 encoding.
-    #[stable(feature = "char_max_len_assoc", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "char_max_len_assoc", since = "1.93.0")]
     pub const MAX_LEN_UTF8: usize = 4;
 
     /// The maximum number of two-byte units required to [encode](char::encode_utf16) a `char`
     /// to UTF-16 encoding.
-    #[stable(feature = "char_max_len_assoc", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "char_max_len_assoc", since = "1.93.0")]
     pub const MAX_LEN_UTF16: usize = 2;
 
     /// `U+FFFD REPLACEMENT CHARACTER` (<28>) is used in Unicode to represent a

library/core/src/fmt/builders.rs

@@ -1226,7 +1226,7 @@ impl<'a, 'b: 'a> DebugMap<'a, 'b> {
 /// assert_eq!(format!("{}", wrapped), "'a'");
 /// assert_eq!(format!("{:?}", wrapped), "'a'");
 /// ```
-#[stable(feature = "fmt_from_fn", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "fmt_from_fn", since = "1.93.0")]
 #[must_use = "returns a type implementing Debug and Display, which do not have any effects unless they are used"]
 pub fn from_fn<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result>(f: F) -> FromFn<F> {
     FromFn(f)
@@ -1235,10 +1235,10 @@ pub fn from_fn<F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result>(f: F) -> FromFn<F>
 /// Implements [`fmt::Debug`] and [`fmt::Display`] via the provided closure.
 ///
 /// Created with [`from_fn`].
-#[stable(feature = "fmt_from_fn", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "fmt_from_fn", since = "1.93.0")]
 pub struct FromFn<F>(F);
 
-#[stable(feature = "fmt_from_fn", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "fmt_from_fn", since = "1.93.0")]
 impl<F> fmt::Debug for FromFn<F>
 where
     F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,
@@ -1248,7 +1248,7 @@ where
     }
 }
 
-#[stable(feature = "fmt_from_fn", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "fmt_from_fn", since = "1.93.0")]
 impl<F> fmt::Display for FromFn<F>
 where
     F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result,

library/core/src/fmt/mod.rs

@@ -41,7 +41,7 @@ pub use num_buffer::{NumBuffer, NumBufferTrait};
 
 #[stable(feature = "debug_builders", since = "1.2.0")]
 pub use self::builders::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};
-#[stable(feature = "fmt_from_fn", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "fmt_from_fn", since = "1.93.0")]
 pub use self::builders::{FromFn, from_fn};
 
 /// The type returned by formatter methods.

library/core/src/io/borrowed_buf.rs

@@ -2,26 +2,27 @@
 
 use crate::fmt::{self, Debug, Formatter};
 use crate::mem::{self, MaybeUninit};
+use crate::{cmp, ptr};
 
-/// A borrowed buffer of initially uninitialized bytes, which is incrementally filled.
+/// A borrowed byte buffer which is incrementally filled and initialized.
 ///
-/// This type makes it safer to work with `MaybeUninit` buffers, such as to read into a buffer
+/// This type is a sort of "double cursor". It tracks three regions in the buffer: a region at the beginning of the
-/// without having to initialize it first. It tracks the region of bytes that have been filled and
+/// buffer that has been logically filled with data, a region that has been initialized at some point but not yet
-/// the region that remains uninitialized.
+/// logically filled, and a region at the end that is fully uninitialized. The filled region is guaranteed to be a
+/// subset of the initialized region.
 ///
-/// The contents of the buffer can be visualized as:
+/// In summary, the contents of the buffer can be visualized as:
 /// ```not_rust
-/// [                         capacity                            ]
+/// [             capacity              ]
-/// [ len: filled and initialized | capacity - len: uninitialized ]
+/// [ filled |         unfilled         ]
+/// [    initialized    | uninitialized ]
 /// ```
 ///
-/// Note that `BorrowedBuf` does not distinguish between uninitialized data and data that was
+/// A `BorrowedBuf` is created around some existing data (or capacity for data) via a unique reference
-/// previously initialized but no longer contains valid data.
+/// (`&mut`). The `BorrowedBuf` can be configured (e.g., using `clear` or `set_init`), but cannot be
-///
+/// directly written. To write into the buffer, use `unfilled` to create a `BorrowedCursor`. The cursor
-/// A `BorrowedBuf` is created around some existing data (or capacity for data) via a unique
+/// has write-only access to the unfilled portion of the buffer (you can think of it as a
-/// reference (`&mut`). The `BorrowedBuf` can be configured (e.g., using `clear` or `set_len`), but
+/// write-only iterator).
-/// cannot be directly written. To write into the buffer, use `unfilled` to create a
-/// `BorrowedCursor`. The cursor has write-only access to the unfilled portion of the buffer.
 ///
 /// The lifetime `'data` is a bound on the lifetime of the underlying data.
 pub struct BorrowedBuf<'data> {
@@ -29,11 +30,14 @@ pub struct BorrowedBuf<'data> {
     buf: &'data mut [MaybeUninit<u8>],
     /// The length of `self.buf` which is known to be filled.
     filled: usize,
+    /// The length of `self.buf` which is known to be initialized.
+    init: usize,
 }
 
 impl Debug for BorrowedBuf<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         f.debug_struct("BorrowedBuf")
+            .field("init", &self.init)
             .field("filled", &self.filled)
             .field("capacity", &self.capacity())
             .finish()
@@ -44,22 +48,24 @@ impl Debug for BorrowedBuf<'_> {
 impl<'data> From<&'data mut [u8]> for BorrowedBuf<'data> {
     #[inline]
     fn from(slice: &'data mut [u8]) -> BorrowedBuf<'data> {
+        let len = slice.len();
+
         BorrowedBuf {
-            // SAFETY: Always in bounds. We treat the buffer as uninitialized, even though it's
+            // SAFETY: initialized data never becoming uninitialized is an invariant of BorrowedBuf
-            // already initialized.
             buf: unsafe { (slice as *mut [u8]).as_uninit_slice_mut().unwrap() },
             filled: 0,
+            init: len,
         }
     }
 }
 
 /// Creates a new `BorrowedBuf` from an uninitialized buffer.
 ///
-/// Use `set_filled` if part of the buffer is known to be already filled.
+/// Use `set_init` if part of the buffer is known to be already initialized.
 impl<'data> From<&'data mut [MaybeUninit<u8>]> for BorrowedBuf<'data> {
     #[inline]
     fn from(buf: &'data mut [MaybeUninit<u8>]) -> BorrowedBuf<'data> {
-        BorrowedBuf { buf, filled: 0 }
+        BorrowedBuf { buf, filled: 0, init: 0 }
     }
 }
 
@@ -68,11 +74,14 @@ impl<'data> From<&'data mut [MaybeUninit<u8>]> for BorrowedBuf<'data> {
 /// Use `BorrowedCursor::with_unfilled_buf` instead for a safer alternative.
 impl<'data> From<BorrowedCursor<'data>> for BorrowedBuf<'data> {
     #[inline]
-    fn from(buf: BorrowedCursor<'data>) -> BorrowedBuf<'data> {
+    fn from(mut buf: BorrowedCursor<'data>) -> BorrowedBuf<'data> {
+        let init = buf.init_mut().len();
         BorrowedBuf {
-            // SAFETY: Always in bounds. We treat the buffer as uninitialized.
+            // SAFETY: no initialized byte is ever uninitialized as per
+            // `BorrowedBuf`'s invariant
             buf: unsafe { buf.buf.buf.get_unchecked_mut(buf.buf.filled..) },
             filled: 0,
+            init,
         }
     }
 }
@@ -90,6 +99,12 @@ impl<'data> BorrowedBuf<'data> {
         self.filled
     }
 
+    /// Returns the length of the initialized part of the buffer.
+    #[inline]
+    pub fn init_len(&self) -> usize {
+        self.init
+    }
+
     /// Returns a shared reference to the filled portion of the buffer.
     #[inline]
     pub fn filled(&self) -> &[u8] {
@@ -144,16 +159,33 @@ impl<'data> BorrowedBuf<'data> {
 
     /// Clears the buffer, resetting the filled region to empty.
     ///
-    /// The contents of the buffer are not modified.
+    /// The number of initialized bytes is not changed, and the contents of the buffer are not modified.
     #[inline]
     pub fn clear(&mut self) -> &mut Self {
         self.filled = 0;
         self
     }
+
+    /// Asserts that the first `n` bytes of the buffer are initialized.
+    ///
+    /// `BorrowedBuf` assumes that bytes are never de-initialized, so this method does nothing when called with fewer
+    /// bytes than are already known to be initialized.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the first `n` unfilled bytes of the buffer have already been initialized.
+    #[inline]
+    pub unsafe fn set_init(&mut self, n: usize) -> &mut Self {
+        self.init = cmp::max(self.init, n);
+        self
+    }
 }
 
 /// A writeable view of the unfilled portion of a [`BorrowedBuf`].
 ///
+/// The unfilled portion consists of an initialized and an uninitialized part; see [`BorrowedBuf`]
+/// for details.
+///
 /// Data can be written directly to the cursor by using [`append`](BorrowedCursor::append) or
 /// indirectly by getting a slice of part or all of the cursor and writing into the slice. In the
 /// indirect case, the caller must call [`advance`](BorrowedCursor::advance) after writing to inform
@@ -206,17 +238,48 @@ impl<'a> BorrowedCursor<'a> {
         self.buf.filled
     }
 
+    /// Returns a mutable reference to the initialized portion of the cursor.
+    #[inline]
+    pub fn init_mut(&mut self) -> &mut [u8] {
+        // SAFETY: We only slice the initialized part of the buffer, which is always valid
+        unsafe {
+            let buf = self.buf.buf.get_unchecked_mut(self.buf.filled..self.buf.init);
+            buf.assume_init_mut()
+        }
+    }
+
     /// Returns a mutable reference to the whole cursor.
     ///
     /// # Safety
     ///
-    /// The caller must not uninitialize any previously initialized bytes.
+    /// The caller must not uninitialize any bytes in the initialized portion of the cursor.
     #[inline]
     pub unsafe fn as_mut(&mut self) -> &mut [MaybeUninit<u8>] {
         // SAFETY: always in bounds
         unsafe { self.buf.buf.get_unchecked_mut(self.buf.filled..) }
     }
 
+    /// Advances the cursor by asserting that `n` bytes have been filled.
+    ///
+    /// After advancing, the `n` bytes are no longer accessible via the cursor and can only be
+    /// accessed via the underlying buffer. I.e., the buffer's filled portion grows by `n` elements
+    /// and its unfilled portion (and the capacity of this cursor) shrinks by `n` elements.
+    ///
+    /// If less than `n` bytes initialized (by the cursor's point of view), `set_init` should be
+    /// called first.
+    ///
+    /// # Panics
+    ///
+    /// Panics if there are less than `n` bytes initialized.
+    #[inline]
+    pub fn advance(&mut self, n: usize) -> &mut Self {
+        // The subtraction cannot underflow by invariant of this type.
+        assert!(n <= self.buf.init - self.buf.filled);
+
+        self.buf.filled += n;
+        self
+    }
+
     /// Advances the cursor by asserting that `n` bytes have been filled.
     ///
     /// After advancing, the `n` bytes are no longer accessible via the cursor and can only be
@@ -225,11 +288,42 @@ impl<'a> BorrowedCursor<'a> {
     ///
     /// # Safety
     ///
-    /// The caller must ensure that the first `n` bytes of the cursor have been initialized. `n`
+    /// The caller must ensure that the first `n` bytes of the cursor have been properly
-    /// must not exceed the remaining capacity of this cursor.
+    /// initialised.
     #[inline]
-    pub unsafe fn advance(&mut self, n: usize) -> &mut Self {
+    pub unsafe fn advance_unchecked(&mut self, n: usize) -> &mut Self {
         self.buf.filled += n;
+        self.buf.init = cmp::max(self.buf.init, self.buf.filled);
+        self
+    }
+
+    /// Initializes all bytes in the cursor.
+    #[inline]
+    pub fn ensure_init(&mut self) -> &mut Self {
+        // SAFETY: always in bounds and we never uninitialize these bytes.
+        let uninit = unsafe { self.buf.buf.get_unchecked_mut(self.buf.init..) };
+
+        // SAFETY: 0 is a valid value for MaybeUninit<u8> and the length matches the allocation
+        // since it is comes from a slice reference.
+        unsafe {
+            ptr::write_bytes(uninit.as_mut_ptr(), 0, uninit.len());
+        }
+        self.buf.init = self.buf.capacity();
+
+        self
+    }
+
+    /// Asserts that the first `n` unfilled bytes of the cursor are initialized.
+    ///
+    /// `BorrowedBuf` assumes that bytes are never de-initialized, so this method does nothing when
+    /// called with fewer bytes than are already known to be initialized.
+    ///
+    /// # Safety
+    ///
+    /// The caller must ensure that the first `n` bytes of the buffer have already been initialized.
+    #[inline]
+    pub unsafe fn set_init(&mut self, n: usize) -> &mut Self {
+        self.buf.init = cmp::max(self.buf.init, self.buf.filled + n);
         self
     }
 
@@ -247,6 +341,10 @@ impl<'a> BorrowedCursor<'a> {
             self.as_mut()[..buf.len()].write_copy_of_slice(buf);
         }
 
+        // SAFETY: We just added the entire contents of buf to the filled section.
+        unsafe {
+            self.set_init(buf.len());
+        }
         self.buf.filled += buf.len();
     }
 
@@ -269,9 +367,17 @@ impl<'a> BorrowedCursor<'a> {
         // there, one could mark some bytes as initialized even though there aren't.
         assert!(core::ptr::addr_eq(prev_ptr, buf.buf));
 
-        // SAFETY: These bytes were filled in the `BorrowedBuf`, so they're filled in the cursor
+        let filled = buf.filled;
-        // too, because the buffer wasn't replaced.
+        let init = buf.init;
-        self.buf.filled += buf.filled;
+
+        // Update `init` and `filled` fields with what was written to the buffer.
+        // `self.buf.filled` was the starting length of the `BorrowedBuf`.
+        //
+        // SAFETY: These amounts of bytes were initialized/filled in the `BorrowedBuf`,
+        // and therefore they are initialized/filled in the cursor too, because the
+        // buffer wasn't replaced.
+        self.buf.init = self.buf.filled + init;
+        self.buf.filled += filled;
 
         res
     }

library/core/src/mem/maybe_uninit.rs

@@ -1140,8 +1140,8 @@ impl<T> [MaybeUninit<T>] {
     /// ```
     ///
     /// [`write_clone_of_slice`]: slice::write_clone_of_slice
-    #[stable(feature = "maybe_uninit_write_slice", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "maybe_uninit_write_slice", since = "1.93.0")]
-    #[rustc_const_stable(feature = "maybe_uninit_write_slice", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "maybe_uninit_write_slice", since = "1.93.0")]
     pub const fn write_copy_of_slice(&mut self, src: &[T]) -> &mut [T]
     where
         T: Copy,
@@ -1201,7 +1201,7 @@ impl<T> [MaybeUninit<T>] {
     /// ```
     ///
     /// [`write_copy_of_slice`]: slice::write_copy_of_slice
-    #[stable(feature = "maybe_uninit_write_slice", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "maybe_uninit_write_slice", since = "1.93.0")]
     pub fn write_clone_of_slice(&mut self, src: &[T]) -> &mut [T]
     where
         T: Clone,
@@ -1463,7 +1463,7 @@ impl<T> [MaybeUninit<T>] {
     /// requirement the compiler knows about it is that the data pointer must be
     /// non-null. Dropping such a `Vec<T>` however will cause undefined
     /// behaviour.
-    #[stable(feature = "maybe_uninit_slice", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "maybe_uninit_slice", since = "1.93.0")]
     #[inline(always)]
     #[rustc_const_unstable(feature = "const_drop_in_place", issue = "109342")]
     pub const unsafe fn assume_init_drop(&mut self)
@@ -1485,8 +1485,8 @@ impl<T> [MaybeUninit<T>] {
     /// Calling this when the content is not yet fully initialized causes undefined
     /// behavior: it is up to the caller to guarantee that every `MaybeUninit<T>` in
     /// the slice really is in an initialized state.
-    #[stable(feature = "maybe_uninit_slice", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "maybe_uninit_slice", since = "1.93.0")]
-    #[rustc_const_stable(feature = "maybe_uninit_slice", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "maybe_uninit_slice", since = "1.93.0")]
     #[inline(always)]
     pub const unsafe fn assume_init_ref(&self) -> &[T] {
         // SAFETY: casting `slice` to a `*const [T]` is safe since the caller guarantees that
@@ -1504,8 +1504,8 @@ impl<T> [MaybeUninit<T>] {
     /// behavior: it is up to the caller to guarantee that every `MaybeUninit<T>` in the
     /// slice really is in an initialized state. For instance, `.assume_init_mut()` cannot
     /// be used to initialize a `MaybeUninit` slice.
-    #[stable(feature = "maybe_uninit_slice", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "maybe_uninit_slice", since = "1.93.0")]
-    #[rustc_const_stable(feature = "maybe_uninit_slice", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "maybe_uninit_slice", since = "1.93.0")]
     #[inline(always)]
     pub const unsafe fn assume_init_mut(&mut self) -> &mut [T] {
         // SAFETY: similar to safety notes for `slice_get_ref`, but we have a

library/core/src/num/int_macros.rs

@@ -1275,8 +1275,8 @@ macro_rules! int_impl {
         /// i.e. when [`checked_neg`] would return `None`.
         ///
         #[doc = concat!("[`checked_neg`]: ", stringify!($SelfT), "::checked_neg")]
-        #[stable(feature = "unchecked_neg", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unchecked_neg", since = "1.93.0")]
-        #[rustc_const_stable(feature = "unchecked_neg", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unchecked_neg", since = "1.93.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
@@ -1392,8 +1392,8 @@ macro_rules! int_impl {
         /// i.e. when [`checked_shl`] would return `None`.
         ///
         #[doc = concat!("[`checked_shl`]: ", stringify!($SelfT), "::checked_shl")]
-        #[stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unchecked_shifts", since = "1.93.0")]
-        #[rustc_const_stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unchecked_shifts", since = "1.93.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
@@ -1564,8 +1564,8 @@ macro_rules! int_impl {
         /// i.e. when [`checked_shr`] would return `None`.
         ///
         #[doc = concat!("[`checked_shr`]: ", stringify!($SelfT), "::checked_shr")]
-        #[stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unchecked_shifts", since = "1.93.0")]
-        #[rustc_const_stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unchecked_shifts", since = "1.93.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]

library/core/src/num/uint_macros.rs

@@ -1851,8 +1851,8 @@ macro_rules! uint_impl {
         /// i.e. when [`checked_shl`] would return `None`.
         ///
         #[doc = concat!("[`checked_shl`]: ", stringify!($SelfT), "::checked_shl")]
-        #[stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unchecked_shifts", since = "1.93.0")]
-        #[rustc_const_stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unchecked_shifts", since = "1.93.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]
@@ -2020,8 +2020,8 @@ macro_rules! uint_impl {
         /// i.e. when [`checked_shr`] would return `None`.
         ///
         #[doc = concat!("[`checked_shr`]: ", stringify!($SelfT), "::checked_shr")]
-        #[stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "unchecked_shifts", since = "1.93.0")]
-        #[rustc_const_stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unchecked_shifts", since = "1.93.0")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline(always)]

library/core/src/ptr/const_ptr.rs

@@ -1462,8 +1462,8 @@ impl<T> *const [T] {
     /// Gets a raw pointer to the underlying array.
     ///
     /// If `N` is not exactly equal to the length of `self`, then this method returns `None`.
-    #[stable(feature = "core_slice_as_array", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "core_slice_as_array", since = "1.93.0")]
-    #[rustc_const_stable(feature = "core_slice_as_array", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "core_slice_as_array", since = "1.93.0")]
     #[inline]
     #[must_use]
     pub const fn as_array<const N: usize>(self) -> Option<*const [T; N]> {

library/core/src/ptr/mut_ptr.rs

@@ -1712,8 +1712,8 @@ impl<T> *mut [T] {
     /// Gets a raw, mutable pointer to the underlying array.
     ///
     /// If `N` is not exactly equal to the length of `self`, then this method returns `None`.
-    #[stable(feature = "core_slice_as_array", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "core_slice_as_array", since = "1.93.0")]
-    #[rustc_const_stable(feature = "core_slice_as_array", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "core_slice_as_array", since = "1.93.0")]
     #[inline]
     #[must_use]
     pub const fn as_mut_array<const N: usize>(self) -> Option<*mut [T; N]> {

library/core/src/slice/mod.rs

@@ -842,8 +842,8 @@ impl<T> [T] {
     /// Gets a reference to the underlying array.
     ///
     /// If `N` is not exactly equal to the length of `self`, then this method returns `None`.
-    #[stable(feature = "core_slice_as_array", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "core_slice_as_array", since = "1.93.0")]
-    #[rustc_const_stable(feature = "core_slice_as_array", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "core_slice_as_array", since = "1.93.0")]
     #[inline]
     #[must_use]
     pub const fn as_array<const N: usize>(&self) -> Option<&[T; N]> {
@@ -861,8 +861,8 @@ impl<T> [T] {
     /// Gets a mutable reference to the slice's underlying array.
     ///
     /// If `N` is not exactly equal to the length of `self`, then this method returns `None`.
-    #[stable(feature = "core_slice_as_array", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "core_slice_as_array", since = "1.93.0")]
-    #[rustc_const_stable(feature = "core_slice_as_array", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "core_slice_as_array", since = "1.93.0")]
     #[inline]
     #[must_use]
     pub const fn as_mut_array<const N: usize>(&mut self) -> Option<&mut [T; N]> {

library/core/src/time.rs

@@ -325,8 +325,8 @@ impl Duration {
     /// assert_eq!(10_u64.pow(15), duration.as_secs());
     /// assert_eq!(321, duration.subsec_nanos());
     /// ```
-    #[stable(feature = "duration_from_nanos_u128", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "duration_from_nanos_u128", since = "1.93.0")]
-    #[rustc_const_stable(feature = "duration_from_nanos_u128", since = "CURRENT_RUSTC_VERSION")]
+    #[rustc_const_stable(feature = "duration_from_nanos_u128", since = "1.93.0")]
     #[must_use]
     #[inline]
     #[track_caller]

library/coretests/tests/io/borrowed_buf.rs

@@ -8,6 +8,7 @@ fn new() {
     let mut rbuf: BorrowedBuf<'_> = buf.into();
 
     assert_eq!(rbuf.filled().len(), 0);
+    assert_eq!(rbuf.init_len(), 16);
     assert_eq!(rbuf.capacity(), 16);
     assert_eq!(rbuf.unfilled().capacity(), 16);
 }
@@ -19,16 +20,27 @@ fn uninit() {
     let mut rbuf: BorrowedBuf<'_> = buf.into();
 
     assert_eq!(rbuf.filled().len(), 0);
+    assert_eq!(rbuf.init_len(), 0);
     assert_eq!(rbuf.capacity(), 16);
     assert_eq!(rbuf.unfilled().capacity(), 16);
 }
 
+#[test]
+fn initialize_unfilled() {
+    let buf: &mut [_] = &mut [MaybeUninit::uninit(); 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
+
+    rbuf.unfilled().ensure_init();
+
+    assert_eq!(rbuf.init_len(), 16);
+}
+
 #[test]
 fn advance_filled() {
     let buf: &mut [_] = &mut [0; 16];
     let mut rbuf: BorrowedBuf<'_> = buf.into();
 
-    unsafe { rbuf.unfilled().advance(1) };
+    rbuf.unfilled().advance(1);
 
     assert_eq!(rbuf.filled().len(), 1);
     assert_eq!(rbuf.unfilled().capacity(), 15);
@@ -39,7 +51,7 @@ fn clear() {
     let buf: &mut [_] = &mut [255; 16];
     let mut rbuf: BorrowedBuf<'_> = buf.into();
 
-    unsafe { rbuf.unfilled().advance(16) };
+    rbuf.unfilled().advance(16);
 
     assert_eq!(rbuf.filled().len(), 16);
     assert_eq!(rbuf.unfilled().capacity(), 0);
@@ -49,9 +61,33 @@ fn clear() {
     assert_eq!(rbuf.filled().len(), 0);
     assert_eq!(rbuf.unfilled().capacity(), 16);
 
-    unsafe { rbuf.unfilled().advance(16) };
+    assert_eq!(rbuf.unfilled().init_mut(), [255; 16]);
+}
 
-    assert_eq!(rbuf.filled(), [255; 16]);
+#[test]
+fn set_init() {
+    let buf: &mut [_] = &mut [MaybeUninit::zeroed(); 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
+
+    unsafe {
+        rbuf.set_init(8);
+    }
+
+    assert_eq!(rbuf.init_len(), 8);
+
+    rbuf.unfilled().advance(4);
+
+    unsafe {
+        rbuf.set_init(2);
+    }
+
+    assert_eq!(rbuf.init_len(), 8);
+
+    unsafe {
+        rbuf.set_init(8);
+    }
+
+    assert_eq!(rbuf.init_len(), 8);
 }
 
 #[test]
@@ -61,6 +97,7 @@ fn append() {
 
     rbuf.unfilled().append(&[0; 8]);
 
+    assert_eq!(rbuf.init_len(), 8);
     assert_eq!(rbuf.filled().len(), 8);
     assert_eq!(rbuf.filled(), [0; 8]);
 
@@ -68,6 +105,7 @@ fn append() {
 
     rbuf.unfilled().append(&[1; 16]);
 
+    assert_eq!(rbuf.init_len(), 16);
     assert_eq!(rbuf.filled().len(), 16);
     assert_eq!(rbuf.filled(), [1; 16]);
 }
@@ -87,12 +125,43 @@ fn reborrow_written() {
     assert_eq!(cursor.written(), 32);
 
     assert_eq!(buf.unfilled().written(), 32);
+    assert_eq!(buf.init_len(), 32);
     assert_eq!(buf.filled().len(), 32);
     let filled = buf.filled();
     assert_eq!(&filled[..16], [1; 16]);
     assert_eq!(&filled[16..], [2; 16]);
 }
 
+#[test]
+fn cursor_set_init() {
+    let buf: &mut [_] = &mut [MaybeUninit::zeroed(); 16];
+    let mut rbuf: BorrowedBuf<'_> = buf.into();
+
+    unsafe {
+        rbuf.unfilled().set_init(8);
+    }
+
+    assert_eq!(rbuf.init_len(), 8);
+    assert_eq!(rbuf.unfilled().init_mut().len(), 8);
+    assert_eq!(unsafe { rbuf.unfilled().as_mut().len() }, 16);
+
+    rbuf.unfilled().advance(4);
+
+    unsafe {
+        rbuf.unfilled().set_init(2);
+    }
+
+    assert_eq!(rbuf.init_len(), 8);
+
+    unsafe {
+        rbuf.unfilled().set_init(8);
+    }
+
+    assert_eq!(rbuf.init_len(), 12);
+    assert_eq!(rbuf.unfilled().init_mut().len(), 8);
+    assert_eq!(unsafe { rbuf.unfilled().as_mut().len() }, 12);
+}
+
 #[test]
 fn cursor_with_unfilled_buf() {
     let buf: &mut [_] = &mut [MaybeUninit::uninit(); 16];
@@ -100,30 +169,31 @@ fn cursor_with_unfilled_buf() {
     let mut cursor = rbuf.unfilled();
 
     cursor.with_unfilled_buf(|buf| {
-        assert_eq!(buf.capacity(), 16);
         buf.unfilled().append(&[1, 2, 3]);
         assert_eq!(buf.filled(), &[1, 2, 3]);
     });
 
+    assert_eq!(cursor.init_mut().len(), 0);
     assert_eq!(cursor.written(), 3);
 
     cursor.with_unfilled_buf(|buf| {
         assert_eq!(buf.capacity(), 13);
+        assert_eq!(buf.init_len(), 0);
 
-        unsafe {
+        buf.unfilled().ensure_init();
-            buf.unfilled().as_mut().write_filled(0);
+        buf.unfilled().advance(4);
-            buf.unfilled().advance(4)
-        };
     });
 
+    assert_eq!(cursor.init_mut().len(), 9);
     assert_eq!(cursor.written(), 7);
 
     cursor.with_unfilled_buf(|buf| {
         assert_eq!(buf.capacity(), 9);
+        assert_eq!(buf.init_len(), 9);
     });
 
+    assert_eq!(cursor.init_mut().len(), 9);
     assert_eq!(cursor.written(), 7);
-    assert_eq!(rbuf.len(), 7);
 
     assert_eq!(rbuf.filled(), &[1, 2, 3, 0, 0, 0, 0]);
 }

library/std/src/fs/tests.rs

@@ -709,6 +709,8 @@ fn file_test_read_buf() {
     let mut file = check!(File::open(filename));
     check!(file.read_buf(buf.unfilled()));
     assert_eq!(buf.filled(), &[1, 2, 3, 4]);
+    // File::read_buf should omit buffer initialization.
+    assert_eq!(buf.init_len(), 4);
 
     check!(fs::remove_file(filename));
 }

library/std/src/io/buffered/bufreader.rs

@@ -284,6 +284,15 @@ impl<R: ?Sized> BufReader<R> {
     }
 }
 
+// This is only used by a test which asserts that the initialization-tracking is correct.
+#[cfg(test)]
+impl<R: ?Sized> BufReader<R> {
+    #[allow(missing_docs)]
+    pub fn initialized(&self) -> usize {
+        self.buf.initialized()
+    }
+}
+
 impl<R: ?Sized + Seek> BufReader<R> {
     /// Seeks relative to the current position. If the new position lies within the buffer,
     /// the buffer will not be flushed, allowing for more efficient seeks.

library/std/src/io/buffered/bufreader/buffer.rs

@@ -21,19 +21,25 @@ pub struct Buffer {
     // Each call to `fill_buf` sets `filled` to indicate how many bytes at the start of `buf` are
     // initialized with bytes from a read.
     filled: usize,
+    // This is the max number of bytes returned across all `fill_buf` calls. We track this so that we
+    // can accurately tell `read_buf` how many bytes of buf are initialized, to bypass as much of its
+    // defensive initialization as possible. Note that while this often the same as `filled`, it
+    // doesn't need to be. Calls to `fill_buf` are not required to actually fill the buffer, and
+    // omitting this is a huge perf regression for `Read` impls that do not.
+    initialized: usize,
 }
 
 impl Buffer {
     #[inline]
     pub fn with_capacity(capacity: usize) -> Self {
         let buf = Box::new_uninit_slice(capacity);
-        Self { buf, pos: 0, filled: 0 }
+        Self { buf, pos: 0, filled: 0, initialized: 0 }
     }
 
     #[inline]
     pub fn try_with_capacity(capacity: usize) -> io::Result<Self> {
         match Box::try_new_uninit_slice(capacity) {
-            Ok(buf) => Ok(Self { buf, pos: 0, filled: 0 }),
+            Ok(buf) => Ok(Self { buf, pos: 0, filled: 0, initialized: 0 }),
             Err(_) => {
                 Err(io::const_error!(ErrorKind::OutOfMemory, "failed to allocate read buffer"))
             }
@@ -62,6 +68,12 @@ impl Buffer {
         self.pos
     }
 
+    // This is only used by a test which asserts that the initialization-tracking is correct.
+    #[cfg(test)]
+    pub fn initialized(&self) -> usize {
+        self.initialized
+    }
+
     #[inline]
     pub fn discard_buffer(&mut self) {
         self.pos = 0;
@@ -98,8 +110,13 @@ impl Buffer {
     /// Read more bytes into the buffer without discarding any of its contents
     pub fn read_more(&mut self, mut reader: impl Read) -> io::Result<usize> {
         let mut buf = BorrowedBuf::from(&mut self.buf[self.filled..]);
+        let old_init = self.initialized - self.filled;
+        unsafe {
+            buf.set_init(old_init);
+        }
         reader.read_buf(buf.unfilled())?;
         self.filled += buf.len();
+        self.initialized += buf.init_len() - old_init;
         Ok(buf.len())
     }
 
@@ -120,10 +137,16 @@ impl Buffer {
             debug_assert!(self.pos == self.filled);
 
             let mut buf = BorrowedBuf::from(&mut *self.buf);
+            // SAFETY: `self.filled` bytes will always have been initialized.
+            unsafe {
+                buf.set_init(self.initialized);
+            }
+
             let result = reader.read_buf(buf.unfilled());
 
             self.pos = 0;
             self.filled = buf.len();
+            self.initialized = buf.init_len();
 
             result?;
         }

library/std/src/io/buffered/tests.rs

@@ -1052,6 +1052,30 @@ fn single_formatted_write() {
     assert_eq!(writer.get_ref().events, [RecordedEvent::Write("hello, world!\n".to_string())]);
 }
 
+#[test]
+fn bufreader_full_initialize() {
+    struct OneByteReader;
+    impl Read for OneByteReader {
+        fn read(&mut self, buf: &mut [u8]) -> crate::io::Result<usize> {
+            if buf.len() > 0 {
+                buf[0] = 0;
+                Ok(1)
+            } else {
+                Ok(0)
+            }
+        }
+    }
+    let mut reader = BufReader::new(OneByteReader);
+    // Nothing is initialized yet.
+    assert_eq!(reader.initialized(), 0);
+
+    let buf = reader.fill_buf().unwrap();
+    // We read one byte...
+    assert_eq!(buf.len(), 1);
+    // But we initialized the whole buffer!
+    assert_eq!(reader.initialized(), reader.capacity());
+}
+
 /// This is a regression test for https://github.com/rust-lang/rust/issues/127584.
 #[test]
 fn bufwriter_aliasing() {

library/std/src/io/copy.rs

@@ -214,19 +214,28 @@ impl<I: Write + ?Sized> BufferedWriterSpec for BufWriter<I> {
         }
 
         let mut len = 0;
+        let mut init = 0;
 
         loop {
             let buf = self.buffer_mut();
             let mut read_buf: BorrowedBuf<'_> = buf.spare_capacity_mut().into();
 
+            unsafe {
+                // SAFETY: init is either 0 or the init_len from the previous iteration.
+                read_buf.set_init(init);
+            }
+
             if read_buf.capacity() >= DEFAULT_BUF_SIZE {
                 let mut cursor = read_buf.unfilled();
                 match reader.read_buf(cursor.reborrow()) {
                     Ok(()) => {
                         let bytes_read = cursor.written();
+
                         if bytes_read == 0 {
                             return Ok(len);
                         }
+
+                        init = read_buf.init_len() - bytes_read;
                         len += bytes_read as u64;
 
                         // SAFETY: BorrowedBuf guarantees all of its filled bytes are init
@@ -239,6 +248,10 @@ impl<I: Write + ?Sized> BufferedWriterSpec for BufWriter<I> {
                     Err(e) => return Err(e),
                 }
             } else {
+                // All the bytes that were already in the buffer are initialized,
+                // treat them as such when the buffer is flushed.
+                init += buf.len();
+
                 self.flush_buf()?;
             }
         }

library/std/src/io/mod.rs

@@ -419,6 +419,8 @@ pub(crate) fn default_read_to_end<R: Read + ?Sized>(
         .and_then(|s| s.checked_add(1024)?.checked_next_multiple_of(DEFAULT_BUF_SIZE))
         .unwrap_or(DEFAULT_BUF_SIZE);
 
+    let mut initialized = 0; // Extra initialized bytes from previous loop iteration
+
     const PROBE_SIZE: usize = 32;
 
     fn small_probe_read<R: Read + ?Sized>(r: &mut R, buf: &mut Vec<u8>) -> Result<usize> {
@@ -447,6 +449,8 @@ pub(crate) fn default_read_to_end<R: Read + ?Sized>(
         }
     }
 
+    let mut consecutive_short_reads = 0;
+
     loop {
         if buf.len() == buf.capacity() && buf.capacity() == start_cap {
             // The buffer might be an exact fit. Let's read into a probe buffer
@@ -470,6 +474,11 @@ pub(crate) fn default_read_to_end<R: Read + ?Sized>(
         spare = &mut spare[..buf_len];
         let mut read_buf: BorrowedBuf<'_> = spare.into();
 
+        // SAFETY: These bytes were initialized but not filled in the previous loop
+        unsafe {
+            read_buf.set_init(initialized);
+        }
+
         let mut cursor = read_buf.unfilled();
         let result = loop {
             match r.read_buf(cursor.reborrow()) {
@@ -480,7 +489,9 @@ pub(crate) fn default_read_to_end<R: Read + ?Sized>(
             }
         };
 
+        let unfilled_but_initialized = cursor.init_mut().len();
         let bytes_read = cursor.written();
+        let was_fully_initialized = read_buf.init_len() == buf_len;
 
         // SAFETY: BorrowedBuf's invariants mean this much memory is initialized.
         unsafe {
@@ -495,8 +506,27 @@ pub(crate) fn default_read_to_end<R: Read + ?Sized>(
             return Ok(buf.len() - start_len);
         }
 
+        if bytes_read < buf_len {
+            consecutive_short_reads += 1;
+        } else {
+            consecutive_short_reads = 0;
+        }
+
+        // store how much was initialized but not filled
+        initialized = unfilled_but_initialized;
+
         // Use heuristics to determine the max read size if no initial size hint was provided
         if size_hint.is_none() {
+            // The reader is returning short reads but it doesn't call ensure_init().
+            // In that case we no longer need to restrict read sizes to avoid
+            // initialization costs.
+            // When reading from disk we usually don't get any short reads except at EOF.
+            // So we wait for at least 2 short reads before uncapping the read buffer;
+            // this helps with the Windows issue.
+            if !was_fully_initialized && consecutive_short_reads > 1 {
+                max_read_size = usize::MAX;
+            }
+
             // we have passed a larger buffer than previously and the
             // reader still hasn't returned a short read
             if buf_len >= max_read_size && bytes_read == buf_len {
@@ -557,13 +587,8 @@ pub(crate) fn default_read_buf<F>(read: F, mut cursor: BorrowedCursor<'_>) -> Re
 where
     F: FnOnce(&mut [u8]) -> Result<usize>,
 {
-    // SAFETY: We do not uninitialize any part of the buffer.
+    let n = read(cursor.ensure_init().init_mut())?;
-    let n = read(unsafe { cursor.as_mut().write_filled(0) })?;
+    cursor.advance(n);
-    assert!(n <= cursor.capacity());
-    // SAFETY: We've initialized the entire buffer, and `read` can't make it uninitialized.
-    unsafe {
-        cursor.advance(n);
-    }
     Ok(())
 }
 
@@ -3073,21 +3098,31 @@ impl<T: Read> Read for Take<T> {
             // The condition above guarantees that `self.limit` fits in `usize`.
             let limit = self.limit as usize;
 
+            let extra_init = cmp::min(limit, buf.init_mut().len());
+
             // SAFETY: no uninit data is written to ibuf
             let ibuf = unsafe { &mut buf.as_mut()[..limit] };
 
             let mut sliced_buf: BorrowedBuf<'_> = ibuf.into();
 
+            // SAFETY: extra_init bytes of ibuf are known to be initialized
+            unsafe {
+                sliced_buf.set_init(extra_init);
+            }
+
             let mut cursor = sliced_buf.unfilled();
             let result = self.inner.read_buf(cursor.reborrow());
 
+            let new_init = cursor.init_mut().len();
             let filled = sliced_buf.len();
 
             // cursor / sliced_buf / ibuf must drop here
 
-            // SAFETY: filled bytes have been filled and therefore initialized
             unsafe {
-                buf.advance(filled);
+                // SAFETY: filled bytes have been filled and therefore initialized
+                buf.advance_unchecked(filled);
+                // SAFETY: new_init bytes of buf's unfilled buffer have been initialized
+                buf.set_init(new_init);
             }
 
             self.limit -= filled as u64;

library/std/src/io/tests.rs

@@ -209,6 +209,15 @@ fn read_buf_exact() {
     assert_eq!(c.read_buf_exact(buf.unfilled()).unwrap_err().kind(), io::ErrorKind::UnexpectedEof);
 }
 
+#[test]
+#[should_panic]
+fn borrowed_cursor_advance_overflow() {
+    let mut buf = [0; 512];
+    let mut buf = BorrowedBuf::from(&mut buf[..]);
+    buf.unfilled().advance(1);
+    buf.unfilled().advance(usize::MAX);
+}
+
 #[test]
 fn take_eof() {
     struct R;

library/std/src/io/util.rs

@@ -283,7 +283,7 @@ impl Read for Repeat {
         // SAFETY: No uninit bytes are being written.
         unsafe { buf.as_mut() }.write_filled(self.byte);
         // SAFETY: the entire unfilled portion of buf has been initialized.
-        unsafe { buf.advance(buf.capacity()) };
+        unsafe { buf.advance_unchecked(buf.capacity()) };
         Ok(())
     }
 

library/std/src/io/util/tests.rs

@@ -75,36 +75,43 @@ fn empty_reads() {
     let mut buf: BorrowedBuf<'_> = buf.into();
     e.read_buf(buf.unfilled()).unwrap();
     assert_eq!(buf.len(), 0);
+    assert_eq!(buf.init_len(), 0);
 
     let buf: &mut [_] = &mut [MaybeUninit::uninit()];
     let mut buf: BorrowedBuf<'_> = buf.into();
     e.read_buf(buf.unfilled()).unwrap();
     assert_eq!(buf.len(), 0);
+    assert_eq!(buf.init_len(), 0);
 
     let buf: &mut [_] = &mut [MaybeUninit::uninit(); 1024];
     let mut buf: BorrowedBuf<'_> = buf.into();
     e.read_buf(buf.unfilled()).unwrap();
     assert_eq!(buf.len(), 0);
+    assert_eq!(buf.init_len(), 0);
 
     let buf: &mut [_] = &mut [MaybeUninit::uninit(); 1024];
     let mut buf: BorrowedBuf<'_> = buf.into();
     Read::by_ref(&mut e).read_buf(buf.unfilled()).unwrap();
     assert_eq!(buf.len(), 0);
+    assert_eq!(buf.init_len(), 0);
 
     let buf: &mut [MaybeUninit<_>] = &mut [];
     let mut buf: BorrowedBuf<'_> = buf.into();
     e.read_buf_exact(buf.unfilled()).unwrap();
     assert_eq!(buf.len(), 0);
+    assert_eq!(buf.init_len(), 0);
 
     let buf: &mut [_] = &mut [MaybeUninit::uninit()];
     let mut buf: BorrowedBuf<'_> = buf.into();
     assert_eq!(e.read_buf_exact(buf.unfilled()).unwrap_err().kind(), ErrorKind::UnexpectedEof);
     assert_eq!(buf.len(), 0);
+    assert_eq!(buf.init_len(), 0);
 
     let buf: &mut [_] = &mut [MaybeUninit::uninit(); 1024];
     let mut buf: BorrowedBuf<'_> = buf.into();
     assert_eq!(e.read_buf_exact(buf.unfilled()).unwrap_err().kind(), ErrorKind::UnexpectedEof);
     assert_eq!(buf.len(), 0);
+    assert_eq!(buf.init_len(), 0);
 
     let buf: &mut [_] = &mut [MaybeUninit::uninit(); 1024];
     let mut buf: BorrowedBuf<'_> = buf.into();
@@ -113,6 +120,7 @@ fn empty_reads() {
         ErrorKind::UnexpectedEof,
     );
     assert_eq!(buf.len(), 0);
+    assert_eq!(buf.init_len(), 0);
 
     let mut buf = Vec::new();
     assert_eq!(e.read_to_end(&mut buf).unwrap(), 0);

library/std/src/lib.rs

@@ -668,7 +668,7 @@ pub mod arch {
     pub use std_detect::is_loongarch_feature_detected;
     #[unstable(feature = "is_riscv_feature_detected", issue = "111192")]
     pub use std_detect::is_riscv_feature_detected;
-    #[stable(feature = "stdarch_s390x_feature_detection", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "stdarch_s390x_feature_detection", since = "1.93.0")]
     pub use std_detect::is_s390x_feature_detected;
     #[stable(feature = "simd_x86", since = "1.27.0")]
     pub use std_detect::is_x86_feature_detected;

library/std/src/net/tcp/tests.rs

@@ -315,6 +315,8 @@ fn read_buf() {
         let mut buf = BorrowedBuf::from(buf.as_mut_slice());
         t!(s.read_buf(buf.unfilled()));
         assert_eq!(buf.filled(), &[1, 2, 3, 4]);
+        // TcpStream::read_buf should omit buffer initialization.
+        assert_eq!(buf.init_len(), 4);
 
         t.join().ok().expect("thread panicked");
     })

library/std/src/process/tests.rs

@@ -188,8 +188,10 @@ fn child_stdout_read_buf() {
     // ChildStdout::read_buf should omit buffer initialization.
     if cfg!(target_os = "windows") {
         assert_eq!(buf.filled(), b"abc\r\n");
+        assert_eq!(buf.init_len(), 5);
     } else {
         assert_eq!(buf.filled(), b"abc\n");
+        assert_eq!(buf.init_len(), 4);
     };
 }
 

library/std/src/sys/fd/hermit.rs

@@ -34,7 +34,7 @@ impl FileDesc {
             )
         })?;
         // SAFETY: Exactly `result` bytes have been filled.
-        unsafe { buf.advance(result as usize) };
+        unsafe { buf.advance_unchecked(result as usize) };
         Ok(())
     }
 

library/std/src/sys/fd/unix.rs

@@ -185,7 +185,7 @@ impl FileDesc {
 
         // SAFETY: `ret` bytes were written to the initialized portion of the buffer
         unsafe {
-            cursor.advance(ret as usize);
+            cursor.advance_unchecked(ret as usize);
         }
         Ok(())
     }
@@ -203,7 +203,7 @@ impl FileDesc {
 
         // SAFETY: `ret` bytes were written to the initialized portion of the buffer
         unsafe {
-            cursor.advance(ret as usize);
+            cursor.advance_unchecked(ret as usize);
         }
         Ok(())
     }

library/std/src/sys/fd/wasi.rs

@@ -59,7 +59,7 @@ impl WasiFd {
             }];
             match wasi::fd_read(self.as_raw_fd() as wasi::Fd, &bufs) {
                 Ok(n) => {
-                    buf.advance(n);
+                    buf.advance_unchecked(n);
                     Ok(())
                 }
                 Err(e) => Err(err2io(e)),

library/std/src/sys/fs/solid.rs

@@ -401,7 +401,7 @@ impl File {
 
             // Safety: `num_bytes_read` bytes were written to the unfilled
             // portion of the buffer
-            cursor.advance(num_bytes_read);
+            cursor.advance_unchecked(num_bytes_read);
 
             Ok(())
         }

library/std/src/sys/net/connection/socket/hermit.rs

@@ -143,7 +143,7 @@ impl Socket {
             )
         })?;
         unsafe {
-            buf.advance(ret as usize);
+            buf.advance_unchecked(ret as usize);
         }
         Ok(())
     }

library/std/src/sys/net/connection/socket/solid.rs

@@ -191,7 +191,7 @@ impl Socket {
             netc::recv(self.as_raw_fd(), buf.as_mut().as_mut_ptr().cast(), buf.capacity(), flags)
         })?;
         unsafe {
-            buf.advance(ret as usize);
+            buf.advance_unchecked(ret as usize);
         }
         Ok(())
     }

library/std/src/sys/net/connection/socket/unix.rs

@@ -293,7 +293,7 @@ impl Socket {
             )
         })?;
         unsafe {
-            buf.advance(ret as usize);
+            buf.advance_unchecked(ret as usize);
         }
         Ok(())
     }

library/std/src/sys/net/connection/socket/wasip2.rs

@@ -167,7 +167,7 @@ impl Socket {
             )
         })?;
         unsafe {
-            buf.advance(ret as usize);
+            buf.advance_unchecked(ret as usize);
         }
         Ok(())
     }

library/std/src/sys/net/connection/socket/windows.rs

@@ -244,7 +244,7 @@ impl Socket {
                 }
             }
             _ => {
-                unsafe { buf.advance(result as usize) };
+                unsafe { buf.advance_unchecked(result as usize) };
                 Ok(())
             }
         }

library/std/src/sys/pal/sgx/abi/usercalls/mod.rs

@@ -46,7 +46,7 @@ pub fn read_buf(fd: Fd, mut buf: BorrowedCursor<'_>) -> IoResult<()> {
         let mut userbuf = alloc::User::<[u8]>::uninitialized(buf.capacity());
         let len = raw::read(fd, userbuf.as_mut_ptr().cast(), userbuf.len()).from_sgx_result()?;
         userbuf[..len].copy_to_enclave(&mut buf.as_mut()[..len]);
-        buf.advance(len);
+        buf.advance_unchecked(len);
         Ok(())
     }
 }

library/std/src/sys/pal/windows/handle.rs

@@ -121,7 +121,7 @@ impl Handle {
             Ok(read) => {
                 // Safety: `read` bytes were written to the initialized portion of the buffer
                 unsafe {
-                    cursor.advance(read);
+                    cursor.advance_unchecked(read);
                 }
                 Ok(())
             }
@@ -144,7 +144,7 @@ impl Handle {
 
         // SAFETY: `read` bytes were written to the initialized portion of the buffer
         unsafe {
-            cursor.advance(read);
+            cursor.advance_unchecked(read);
         }
         Ok(())
     }

library/std/src/sys/pal/windows/pipe.rs

@@ -259,7 +259,7 @@ impl AnonPipe {
             Err(e) => Err(e),
             Ok(n) => {
                 unsafe {
-                    buf.advance(n);
+                    buf.advance_unchecked(n);
                 }
                 Ok(())
             }

library/std/src/sys/stdio/zkvm.rs

@@ -19,7 +19,7 @@ impl io::Read for Stdin {
     fn read_buf(&mut self, mut buf: BorrowedCursor<'_>) -> io::Result<()> {
         unsafe {
             let n = abi::sys_read(fileno::STDIN, buf.as_mut().as_mut_ptr().cast(), buf.capacity());
-            buf.advance(n);
+            buf.advance_unchecked(n);
         }
         Ok(())
     }

library/std_detect/src/detect/arch/mod.rs

@@ -60,7 +60,7 @@ cfg_select! {
         pub use loongarch::*;
     }
     target_arch = "s390x" => {
-        #[stable(feature = "stdarch_s390x_feature_detection", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "stdarch_s390x_feature_detection", since = "1.93.0")]
         pub use s390x::*;
     }
     _ => {

library/std_detect/src/detect/arch/s390x.rs

@@ -9,7 +9,7 @@ features! {
     ///
     /// When the feature is known to be enabled at compile time (e.g. via `-Ctarget-feature`)
     /// the macro expands to `true`.
-    #[stable(feature = "stdarch_s390x_feature_detection", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "stdarch_s390x_feature_detection", since = "1.93.0")]
     @FEATURE: #[unstable(feature = "s390x_target_feature", issue = "44839")] concurrent_functions: "concurrent-functions";
     /// s390x concurrent-functions facility
     @FEATURE: #[unstable(feature = "s390x_target_feature", issue = "44839")] deflate_conversion: "deflate-conversion";
@@ -32,30 +32,30 @@ features! {
     /// s390x message-security-assist-extension9 facility
     @FEATURE: #[unstable(feature = "s390x_target_feature", issue = "44839")] message_security_assist_extension12: "message-security-assist-extension12";
     /// s390x message-security-assist-extension12 facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] miscellaneous_extensions_2: "miscellaneous-extensions-2";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] miscellaneous_extensions_2: "miscellaneous-extensions-2";
     /// s390x miscellaneous-extensions-2 facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] miscellaneous_extensions_3: "miscellaneous-extensions-3";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] miscellaneous_extensions_3: "miscellaneous-extensions-3";
     /// s390x miscellaneous-extensions-3 facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] miscellaneous_extensions_4: "miscellaneous-extensions-4";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] miscellaneous_extensions_4: "miscellaneous-extensions-4";
     /// s390x miscellaneous-extensions-4 facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] nnp_assist: "nnp-assist";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] nnp_assist: "nnp-assist";
     /// s390x nnp-assist facility
     @FEATURE: #[unstable(feature = "s390x_target_feature", issue = "44839")] transactional_execution: "transactional-execution";
     /// s390x transactional-execution facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] vector: "vector";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] vector: "vector";
     /// s390x vector facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] vector_enhancements_1: "vector-enhancements-1";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] vector_enhancements_1: "vector-enhancements-1";
     /// s390x vector-enhancements-1 facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] vector_enhancements_2: "vector-enhancements-2";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] vector_enhancements_2: "vector-enhancements-2";
     /// s390x vector-enhancements-2 facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] vector_enhancements_3: "vector-enhancements-3";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] vector_enhancements_3: "vector-enhancements-3";
     /// s390x vector-enhancements-3 facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] vector_packed_decimal: "vector-packed-decimal";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] vector_packed_decimal: "vector-packed-decimal";
     /// s390x vector-packed-decimal facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] vector_packed_decimal_enhancement: "vector-packed-decimal-enhancement";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] vector_packed_decimal_enhancement: "vector-packed-decimal-enhancement";
     /// s390x vector-packed-decimal-enhancement facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] vector_packed_decimal_enhancement_2: "vector-packed-decimal-enhancement-2";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] vector_packed_decimal_enhancement_2: "vector-packed-decimal-enhancement-2";
     /// s390x vector-packed-decimal-enhancement-2 facility
-    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "CURRENT_RUSTC_VERSION")] vector_packed_decimal_enhancement_3: "vector-packed-decimal-enhancement-3";
+    @FEATURE: #[stable(feature = "s390x_target_feature_vector", since = "1.93.0")] vector_packed_decimal_enhancement_3: "vector-packed-decimal-enhancement-3";
     /// s390x vector-packed-decimal-enhancement-3 facility
 }

library/stdarch/crates/core_arch/src/x86/avx2.rs

@@ -1754,12 +1754,19 @@ pub fn _mm256_inserti128_si256<const IMM1: i32>(a: __m256i, b: __m128i) -> __m25
 #[cfg_attr(test, assert_instr(vpmaddwd))]
 #[stable(feature = "simd_x86", since = "1.27.0")]
 pub fn _mm256_madd_epi16(a: __m256i, b: __m256i) -> __m256i {
-    unsafe {
+    // It's a trick used in the Adler-32 algorithm to perform a widening addition.
-        let r: i32x16 = simd_mul(simd_cast(a.as_i16x16()), simd_cast(b.as_i16x16()));
+    //
-        let even: i32x8 = simd_shuffle!(r, r, [0, 2, 4, 6, 8, 10, 12, 14]);
+    // ```rust
-        let odd: i32x8 = simd_shuffle!(r, r, [1, 3, 5, 7, 9, 11, 13, 15]);
+    // #[target_feature(enable = "avx2")]
-        simd_add(even, odd).as_m256i()
+    // unsafe fn widening_add(mad: __m256i) -> __m256i {
-    }
+    //     _mm256_madd_epi16(mad, _mm256_set1_epi16(1))
+    // }
+    // ```
+    //
+    // If we implement this using generic vector intrinsics, the optimizer
+    // will eliminate this pattern, and `vpmaddwd` will no longer be emitted.
+    // For this reason, we use x86 intrinsics.
+    unsafe { transmute(pmaddwd(a.as_i16x16(), b.as_i16x16())) }
 }
 
 /// Vertically multiplies each unsigned 8-bit integer from `a` with the
@@ -3701,6 +3708,8 @@ unsafe extern "C" {
     fn phaddsw(a: i16x16, b: i16x16) -> i16x16;
     #[link_name = "llvm.x86.avx2.phsub.sw"]
     fn phsubsw(a: i16x16, b: i16x16) -> i16x16;
+    #[link_name = "llvm.x86.avx2.pmadd.wd"]
+    fn pmaddwd(a: i16x16, b: i16x16) -> i32x8;
     #[link_name = "llvm.x86.avx2.pmadd.ub.sw"]
     fn pmaddubsw(a: u8x32, b: i8x32) -> i16x16;
     #[link_name = "llvm.x86.avx2.mpsadbw"]

library/stdarch/crates/core_arch/src/x86/avx512bw.rs

@@ -5847,20 +5847,19 @@ pub unsafe fn _mm_mask_storeu_epi8(mem_addr: *mut i8, mask: __mmask16, a: __m128
 #[stable(feature = "stdarch_x86_avx512", since = "1.89")]
 #[cfg_attr(test, assert_instr(vpmaddwd))]
 pub fn _mm512_madd_epi16(a: __m512i, b: __m512i) -> __m512i {
-    unsafe {
+    // It's a trick used in the Adler-32 algorithm to perform a widening addition.
-        let r: i32x32 = simd_mul(simd_cast(a.as_i16x32()), simd_cast(b.as_i16x32()));
+    //
-        let even: i32x16 = simd_shuffle!(
+    // ```rust
-            r,
+    // #[target_feature(enable = "avx512bw")]
-            r,
+    // unsafe fn widening_add(mad: __m512i) -> __m512i {
-            [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30]
+    //     _mm512_madd_epi16(mad, _mm512_set1_epi16(1))
-        );
+    // }
-        let odd: i32x16 = simd_shuffle!(
+    // ```
-            r,
+    //
-            r,
+    // If we implement this using generic vector intrinsics, the optimizer
-            [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31]
+    // will eliminate this pattern, and `vpmaddwd` will no longer be emitted.
-        );
+    // For this reason, we use x86 intrinsics.
-        simd_add(even, odd).as_m512i()
+    unsafe { transmute(vpmaddwd(a.as_i16x32(), b.as_i16x32())) }
-    }
 }
 
 /// Multiply packed signed 16-bit integers in a and b, producing intermediate signed 32-bit integers. Horizontally add adjacent pairs of intermediate 32-bit integers, and pack the results in dst using writemask k (elements are copied from src when the corresponding mask bit is not set).
@@ -11687,6 +11686,8 @@ unsafe extern "C" {
     #[link_name = "llvm.x86.avx512.pmul.hr.sw.512"]
     fn vpmulhrsw(a: i16x32, b: i16x32) -> i16x32;
 
+    #[link_name = "llvm.x86.avx512.pmaddw.d.512"]
+    fn vpmaddwd(a: i16x32, b: i16x32) -> i32x16;
     #[link_name = "llvm.x86.avx512.pmaddubs.w.512"]
     fn vpmaddubsw(a: u8x64, b: i8x64) -> i16x32;
 

library/stdarch/crates/core_arch/src/x86/sse2.rs

@@ -201,12 +201,19 @@ pub fn _mm_avg_epu16(a: __m128i, b: __m128i) -> __m128i {
 #[cfg_attr(test, assert_instr(pmaddwd))]
 #[stable(feature = "simd_x86", since = "1.27.0")]
 pub fn _mm_madd_epi16(a: __m128i, b: __m128i) -> __m128i {
-    unsafe {
+    // It's a trick used in the Adler-32 algorithm to perform a widening addition.
-        let r: i32x8 = simd_mul(simd_cast(a.as_i16x8()), simd_cast(b.as_i16x8()));
+    //
-        let even: i32x4 = simd_shuffle!(r, r, [0, 2, 4, 6]);
+    // ```rust
-        let odd: i32x4 = simd_shuffle!(r, r, [1, 3, 5, 7]);
+    // #[target_feature(enable = "sse2")]
-        simd_add(even, odd).as_m128i()
+    // unsafe fn widening_add(mad: __m128i) -> __m128i {
-    }
+    //     _mm_madd_epi16(mad, _mm_set1_epi16(1))
+    // }
+    // ```
+    //
+    // If we implement this using generic vector intrinsics, the optimizer
+    // will eliminate this pattern, and `pmaddwd` will no longer be emitted.
+    // For this reason, we use x86 intrinsics.
+    unsafe { transmute(pmaddwd(a.as_i16x8(), b.as_i16x8())) }
 }
 
 /// Compares packed 16-bit integers in `a` and `b`, and returns the packed
@@ -3054,6 +3061,8 @@ unsafe extern "C" {
     fn lfence();
     #[link_name = "llvm.x86.sse2.mfence"]
     fn mfence();
+    #[link_name = "llvm.x86.sse2.pmadd.wd"]
+    fn pmaddwd(a: i16x8, b: i16x8) -> i32x4;
     #[link_name = "llvm.x86.sse2.psad.bw"]
     fn psadbw(a: u8x16, b: u8x16) -> u64x2;
     #[link_name = "llvm.x86.sse2.psll.w"]

rust-bors.toml

@@ -25,3 +25,42 @@ labels_blocking_approval = [
     "S-waiting-on-t-rustdoc-frontend",
     "S-waiting-on-t-clippy"
 ]
+
+# If CI runs quicker than this duration, consider it to be a failure
+min_ci_time = 600
+
+[labels]
+approved = [
+    "+S-waiting-on-bors",
+    "-S-blocked",
+    "-S-waiting-on-author",
+    "-S-waiting-on-crater",
+    "-S-waiting-on-review",
+    "-S-waiting-on-team"
+]
+unapproved = [
+    "+S-waiting-on-author",
+    "-S-blocked",
+    "-S-waiting-on-bors",
+    "-S-waiting-on-crater",
+    "-S-waiting-on-review",
+    "-S-waiting-on-team"
+]
+try_failed = [
+    "+S-waiting-on-author",
+    "-S-waiting-on-review",
+    "-S-waiting-on-crater"
+]
+auto_build_succeeded = ["+merged-by-bors"]
+auto_build_failed = [
+    "+S-waiting-on-review",
+    "-S-blocked",
+    "-S-waiting-on-bors",
+    "-S-waiting-on-author",
+    "-S-waiting-on-crater",
+    "-S-waiting-on-team"
+]
+
+# Flip this two once new bors is used for actual merges on this repository
+merge_queue_enabled = false
+report_merge_conflicts = true

src/build_helper/src/git.rs

@@ -152,6 +152,17 @@ pub fn has_changed_since(git_dir: &Path, base: &str, paths: &[&str]) -> bool {
     })
 }
 
+// Temporary e-mail used by new bors for merge commits for a few days, until it learned how to reuse
+// the original homu e-mail
+// FIXME: remove in Q2 2026
+const TEMPORARY_BORS_EMAIL: &str = "122020455+rust-bors[bot]@users.noreply.github.com";
+
+/// Escape characters from the git user e-mail, so that git commands do not interpret it as regex
+/// special characters.
+fn escape_email_git_regex(text: &str) -> String {
+    text.replace("[", "\\[").replace("]", "\\]").replace(".", "\\.")
+}
+
 /// Returns the latest upstream commit that modified `target_paths`, or `None` if no such commit
 /// was found.
 fn get_latest_upstream_commit_that_modified_files(
@@ -182,9 +193,14 @@ fn get_latest_upstream_commit_that_modified_files(
         "-n1",
         &upstream,
         "--author",
-        git_config.git_merge_commit_email,
+        &escape_email_git_regex(git_config.git_merge_commit_email),
     ]);
 
+    // Also search for temporary bors account
+    if git_config.git_merge_commit_email != TEMPORARY_BORS_EMAIL {
+        git.args(["--author", &escape_email_git_regex(TEMPORARY_BORS_EMAIL)]);
+    }
+
     if !target_paths.is_empty() {
         git.arg("--").args(target_paths);
     }
@@ -229,11 +245,16 @@ pub fn get_closest_upstream_commit(
     git.args([
         "rev-list",
         "--author-date-order",
-        &format!("--author={}", config.git_merge_commit_email),
+        &format!("--author={}", &escape_email_git_regex(config.git_merge_commit_email),),
         "-n1",
         base,
     ]);
 
+    // Also search for temporary bors account
+    if config.git_merge_commit_email != TEMPORARY_BORS_EMAIL {
+        git.args(["--author", &escape_email_git_regex(TEMPORARY_BORS_EMAIL)]);
+    }
+
     let output = output_result(&mut git)?.trim().to_owned();
     if output.is_empty() { Ok(None) } else { Ok(Some(output)) }
 }

src/ci/channel

@@ -1 +1 @@
-nightly
+stable

src/ci/citool/src/main.rs

@@ -46,7 +46,9 @@ impl GitHubContext {
                 let patterns = if !patterns.is_empty() { Some(patterns) } else { None };
                 Some(RunType::TryJob { job_patterns: patterns })
             }
-            ("push", "refs/heads/auto") => Some(RunType::AutoJob),
+            ("push", "refs/heads/auto" | "refs/heads/automation/bors/auto") => {
+                Some(RunType::AutoJob)
+            }
             ("push", "refs/heads/main") => Some(RunType::MainJob),
             _ => None,
         }

src/ci/docker/host-x86_64/dist-various-2/Dockerfile

@@ -85,9 +85,9 @@ RUN /tmp/build-fuchsia-toolchain.sh
 COPY host-x86_64/dist-various-2/build-x86_64-fortanix-unknown-sgx-toolchain.sh /tmp/
 RUN /tmp/build-x86_64-fortanix-unknown-sgx-toolchain.sh
 
-RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-29/wasi-sdk-29.0-x86_64-linux.tar.gz | \
+RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-27/wasi-sdk-27.0-x86_64-linux.tar.gz | \
   tar -xz
-ENV WASI_SDK_PATH=/tmp/wasi-sdk-29.0-x86_64-linux
+ENV WASI_SDK_PATH=/tmp/wasi-sdk-27.0-x86_64-linux
 
 COPY scripts/freebsd-toolchain.sh /tmp/
 RUN /tmp/freebsd-toolchain.sh i686

src/ci/docker/host-x86_64/pr-check-2/Dockerfile

@@ -21,9 +21,9 @@ RUN apt-get update && apt-get install -y --no-install-recommends \
   mingw-w64 \
   && rm -rf /var/lib/apt/lists/*
 
-RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-29/wasi-sdk-29.0-x86_64-linux.tar.gz | \
+RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-27/wasi-sdk-27.0-x86_64-linux.tar.gz | \
   tar -xz
-ENV WASI_SDK_PATH=/wasi-sdk-29.0-x86_64-linux
+ENV WASI_SDK_PATH=/wasi-sdk-27.0-x86_64-linux
 
 ENV RUST_CONFIGURE_ARGS="--set rust.validate-mir-opts=3"
 

src/ci/docker/host-x86_64/test-various/Dockerfile

@@ -41,9 +41,9 @@ WORKDIR /
 COPY scripts/sccache.sh /scripts/
 RUN sh /scripts/sccache.sh
 
-RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-29/wasi-sdk-29.0-x86_64-linux.tar.gz | \
+RUN curl -L https://github.com/WebAssembly/wasi-sdk/releases/download/wasi-sdk-27/wasi-sdk-27.0-x86_64-linux.tar.gz | \
   tar -xz
-ENV WASI_SDK_PATH=/wasi-sdk-29.0-x86_64-linux
+ENV WASI_SDK_PATH=/wasi-sdk-27.0-x86_64-linux
 
 ENV RUST_CONFIGURE_ARGS \
   --musl-root-x86_64=/usr/local/x86_64-linux-musl \
@@ -56,9 +56,9 @@ ENV RUST_CONFIGURE_ARGS \
 ENV NO_DEBUG_ASSERTIONS=1
 ENV NO_OVERFLOW_CHECKS=1
 
-RUN curl -L https://github.com/bytecodealliance/wasmtime/releases/download/v38.0.4/wasmtime-v38.0.4-x86_64-linux.tar.xz | \
+RUN curl -L https://github.com/bytecodealliance/wasmtime/releases/download/v19.0.0/wasmtime-v19.0.0-x86_64-linux.tar.xz | \
   tar -xJ
-ENV PATH "$PATH:/wasmtime-v38.0.4-x86_64-linux"
+ENV PATH "$PATH:/wasmtime-v19.0.0-x86_64-linux"
 
 ENV WASM_WASIP_TARGET=wasm32-wasip1
 ENV WASM_WASIP_SCRIPT python3 /checkout/x.py --stage 2 test --host='' --target $WASM_WASIP_TARGET \

src/ci/docker/run.sh

@@ -312,16 +312,6 @@ else
   command=(/checkout/src/ci/run.sh)
 fi
 
-if isCI; then
-  # Get some needed information for $BASE_COMMIT
-  #
-  # This command gets the last merge commit which we'll use as base to list
-  # deleted files since then.
-  BASE_COMMIT="$(git log --author=bors@rust-lang.org -n 2 --pretty=format:%H | tail -n 1)"
-else
-  BASE_COMMIT=""
-fi
-
 SUMMARY_FILE=github-summary.md
 touch $objdir/${SUMMARY_FILE}
 
@@ -359,7 +349,6 @@ docker \
   --env RUST_CI_OVERRIDE_RELEASE_CHANNEL \
   --env CI_JOB_NAME="${CI_JOB_NAME-$image}" \
   --env CI_JOB_DOC_URL="${CI_JOB_DOC_URL}" \
-  --env BASE_COMMIT="$BASE_COMMIT" \
   --env DIST_TRY_BUILD \
   --env PR_CI_JOB \
   --env OBJDIR_ON_HOST="$objdir" \

src/ci/github-actions/jobs.yml

@@ -152,8 +152,8 @@ try:
   - <<: *job-dist-x86_64-linux
 
 # Jobs that only run when explicitly invoked in one of the following ways:
-# - comment `@bors2 try jobs=<job-name>`
+# - comment `@bors try jobs=<job-name>`
-# - `try-job: <job-name>` in the PR description and comment `@bors try` or `@bors2 try`.
+# - `try-job: <job-name>` in the PR description and comment `@bors try`.
 optional:
   # This job is used just to test optional jobs.
   # It will be replaced by tier 2 and tier 3 jobs in the future.

src/ci/scripts/verify-channel.sh

@@ -8,7 +8,8 @@ IFS=$'\n\t'
 
 source "$(cd "$(dirname "$0")" && pwd)/../shared.sh"
 
-if isCiBranch auto || isCiBranch try || isCiBranch try-perf || isCiBranch automation/bors/try; then
+if isCiBranch auto || isCiBranch try || isCiBranch try-perf || \
+   isCiBranch automation/bors/try || isCiBranch automation/bors/auto; then
     echo "channel verification is only executed on PR builds"
     exit
 fi

src/librustdoc/html/render/mod.rs

@@ -1049,14 +1049,11 @@ fn assoc_const(
             ty = print_type(ty, cx),
         )?;
         if let AssocConstValue::TraitDefault(konst) | AssocConstValue::Impl(konst) = value {
-            // FIXME: `.value()` uses `clean::utils::format_integer_with_underscore_sep` under the
+            let repr = konst.expr(tcx);
-            //        hood which adds noisy underscores and a type suffix to number literals.
-            //        This hurts readability in this context especially when more complex expressions
-            //        are involved and it doesn't add much of value.
-            //        Find a way to print constants here without all that jazz.
-            let repr = konst.value(tcx).unwrap_or_else(|| konst.expr(tcx));
             if match value {
                 AssocConstValue::TraitDefault(_) => true, // always show
+                // FIXME: Comparing against the special string "_" denoting overly complex const exprs
+                //        is rather hacky; `ConstKind::expr` should have a richer return type.
                 AssocConstValue::Impl(_) => repr != "_", // show if there is a meaningful value to show
                 AssocConstValue::None => unreachable!(),
             } {

src/llvm-project

@@ -1 +1 @@
-Subproject commit 16b5ac8b0a5456eb23c72e1bff3fc9bd6e824f84
+Subproject commit 85a90d119deb25b518867cd37d62c7b93b575a6f

src/stage0

@@ -13,528 +13,395 @@ nightly_branch=main
 # All changes below this comment will be overridden the next time the
 # tool is executed.
 
-compiler_channel_manifest_hash=d8adf7e1722d2dc8ebdb327ee661e58a58145464bfcd9bb3cab66d652cc7bb90
+compiler_channel_manifest_hash=b2a49624353173ecdacf59c158c00929300606e1963f6e4609fb483a508402d0
-compiler_git_commit_hash=3b4dd9bf1410f8da6329baa36ce5e37673cbbd1f
+compiler_git_commit_hash=ded5c06cf21d2b93bffd5d884aa6e96934ee4234
-compiler_date=2025-10-28
+compiler_date=2025-12-11
-compiler_version=beta
+compiler_version=1.92.0
-rustfmt_channel_manifest_hash=108599f303463cabaef3b53ab5e0c0e560a6a5a97f606d75a802efb595141baf
-rustfmt_git_commit_hash=adaa838976ff99a4f0661136322f64cb466b58a0
-rustfmt_date=2025-10-28
-rustfmt_version=nightly
 
-dist/2025-10-28/rustc-beta-aarch64-apple-darwin.tar.gz=5d971d3a1c127d314f94f41440f0717b51692176630fef7f05a70d9bcd3bae44
+dist/2025-12-11/rustc-1.92.0-aarch64-apple-darwin.tar.gz=9bba82c249776b282e25f4bc9c9386ea5ec81d3a2346281516c9da8910a5fd22
-dist/2025-10-28/rustc-beta-aarch64-apple-darwin.tar.xz=2cedfc3a96acc9ebe82c5cf5bcf5355902a5726e1c28e7d50b15cfa2ee343174
+dist/2025-12-11/rustc-1.92.0-aarch64-apple-darwin.tar.xz=15dee753c9217dff4cf45d734b29dc13ce6017d8a55fe34eed75022b39a63ff0
-dist/2025-10-28/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=1875833b43088879444902023cc76682fa58f39520a1135e438afaacf3605f88
+dist/2025-12-11/rustc-1.92.0-aarch64-pc-windows-gnullvm.tar.gz=be37ee49589ab366548802d5f123ebd20eaeb7046c2f2149bbaef76582a154bb
-dist/2025-10-28/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=a925fb02b296b8ce753ff7b1fae583a27fb2ef6de582a80f1428678a2f61a466
+dist/2025-12-11/rustc-1.92.0-aarch64-pc-windows-gnullvm.tar.xz=a7556b86bce94dd8c078a62f71a9a0a3f4b3e841bc5d4fae546d797b78186eb1
-dist/2025-10-28/rustc-beta-aarch64-pc-windows-msvc.tar.gz=28f423bb7db80232b887bd0d47243341a50611eca913c17c305dd55fa6bd3f12
+dist/2025-12-11/rustc-1.92.0-aarch64-pc-windows-msvc.tar.gz=9296c18c3502c9c083bf39be6c5cab0d1afd39d3270810a1e630d6237f1cde0a
-dist/2025-10-28/rustc-beta-aarch64-pc-windows-msvc.tar.xz=3be7d39a956afd591ba4b22785b4851fd6c0c7afd23d045c54d6b603cc14bc2d
+dist/2025-12-11/rustc-1.92.0-aarch64-pc-windows-msvc.tar.xz=07ba5606143de3bc916455714f67732fca05805591396a8190d5e88b8863eea3
-dist/2025-10-28/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=8b98b7e04ef03c3b2bc95e0d6e3a92ad7849bad8d5a8969d6c9eefe169673066
+dist/2025-12-11/rustc-1.92.0-aarch64-unknown-linux-gnu.tar.gz=0d4e2145fe184fd6069c3a67deb44cc5bdadee7a631e742a025a47e3ea774577
-dist/2025-10-28/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=1b35688d58c10fdd1f1d02325022ae9eb36ee139f76ae753e16a0f4524d0f6d4
+dist/2025-12-11/rustc-1.92.0-aarch64-unknown-linux-gnu.tar.xz=7c8706fad4c038b5eacab0092e15db54d2b365d5f3323ca046fe987f814e7826
-dist/2025-10-28/rustc-beta-aarch64-unknown-linux-musl.tar.gz=c1de08dbaff419f08f82aef49972965d87e02054822e83e6e7f73714afbc4155
+dist/2025-12-11/rustc-1.92.0-aarch64-unknown-linux-musl.tar.gz=da8c6d290ed86fb58ac9a7af78d3b0c27e1171e2ec62893fce667c085d172593
-dist/2025-10-28/rustc-beta-aarch64-unknown-linux-musl.tar.xz=2755a71cee31227e4638499dc882347ed9ecf0698cc64a177ff8a94c6ff3be8c
+dist/2025-12-11/rustc-1.92.0-aarch64-unknown-linux-musl.tar.xz=e7099dddd30f92093916e47a34cd6a866ea0acbf2836c17b74bdd795f0137a2a
-dist/2025-10-28/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=dac50bed8e2bb5d65b5f6ea52963d2b268829c9f79800304a225e058152be0bd
+dist/2025-12-11/rustc-1.92.0-arm-unknown-linux-gnueabi.tar.gz=601d613c027cccc3ed295c057d5948fe57cbe75992419970d15dc04e9b083b6f
-dist/2025-10-28/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=f818783e566cebc2ac392f923efd0ae8f51ae77ce6ade284514a57c21d288b7e
+dist/2025-12-11/rustc-1.92.0-arm-unknown-linux-gnueabi.tar.xz=18961e1d83fb747b60c766f68f8297a54452def6e79cc3e02c2d23712e0b3a17
-dist/2025-10-28/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=922d9d3aba6c5ac4da95ab9310d0f33ec7da4830a7d424b83d6f0181af96bccb
+dist/2025-12-11/rustc-1.92.0-arm-unknown-linux-gnueabihf.tar.gz=5b79849c220f59a41f0949cd3b8fbf719200d3230b5922ae9b1c88e1f0860c42
-dist/2025-10-28/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=746a200dab88eec922dc08ea244ae818c27a0ca91360278e578ab9fc433bd3be
+dist/2025-12-11/rustc-1.92.0-arm-unknown-linux-gnueabihf.tar.xz=53406761d1774302d50007ab005ff95befc9396856389fadbc94949629bed71d
-dist/2025-10-28/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=ac45fe7547dc1064286de6704a9343e95fa760163247ac02ff88ebf2bf4d7d8c
+dist/2025-12-11/rustc-1.92.0-armv7-unknown-linux-gnueabihf.tar.gz=f34a35f33fd922ffb5f9b40753c86159707449788dbb7fe43090dc030bc47cf1
-dist/2025-10-28/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=35ab727f335242d588742f79f29fb94590ac0c3bef29d012538f2e925cb9f96f
+dist/2025-12-11/rustc-1.92.0-armv7-unknown-linux-gnueabihf.tar.xz=c49d5679f7f4f5ce3cf0d3b72c4299a0f95521087f3122d6c15be77658d4f9e9
-dist/2025-10-28/rustc-beta-i686-pc-windows-gnu.tar.gz=42eab38b498e0b8efd7fae51facd7caaf253e1bc341f915f978b484065e4c812
+dist/2025-12-11/rustc-1.92.0-i686-pc-windows-gnu.tar.gz=9e8839f507a74653cfc06fc6de8a028d7874b933ea55e953f5a1d1eab29c9d0f
-dist/2025-10-28/rustc-beta-i686-pc-windows-gnu.tar.xz=d663982b6293285fa1ffcc5987ded64569216c0133476243b5525768cd6123bb
+dist/2025-12-11/rustc-1.92.0-i686-pc-windows-gnu.tar.xz=a3dd59a53c7c919457b4c4eab814c3cd18cdc7a3f679fdaf8df6f9a21ef8c1ef
-dist/2025-10-28/rustc-beta-i686-pc-windows-msvc.tar.gz=571eeccc9c1f25c4b9c2c6f45d15dbd9730bf6c0ac0f75a5b49652b6d4e98f68
+dist/2025-12-11/rustc-1.92.0-i686-pc-windows-msvc.tar.gz=4883ea7d39f7030a4290d7e9e5cc71483c867b4188bff293ff8f770bf4ee8f66
-dist/2025-10-28/rustc-beta-i686-pc-windows-msvc.tar.xz=595a8b6b74910fa53a947ddde81f5519152f8c773a41a2f5b0d663540bc913fa
+dist/2025-12-11/rustc-1.92.0-i686-pc-windows-msvc.tar.xz=e892036f2ac1f24cdf853df74f631e9ad80fa6fcb2b9ca241527ed5b03eea96d
-dist/2025-10-28/rustc-beta-i686-unknown-linux-gnu.tar.gz=3f2261279e5c16b0a4b572e799e2d3079aa33192e7713803214011e14c5c6707
+dist/2025-12-11/rustc-1.92.0-i686-unknown-linux-gnu.tar.gz=81b884e76b8e3b45509c20874f93d993477c4db2131745c8bf61282c8e673d78
-dist/2025-10-28/rustc-beta-i686-unknown-linux-gnu.tar.xz=c49c0e84b4b43aa6b72dc355173b4b5dc41563f3f76e882c405a8625c00befbc
+dist/2025-12-11/rustc-1.92.0-i686-unknown-linux-gnu.tar.xz=c1c920cd59e255e5dcf844af22b80483fe4b04ff04f143be6da69314bd6733f8
-dist/2025-10-28/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=92cea4e2708fbd86b35bc798b25a69ab10b62f28e972ff0624709e6e8268db60
+dist/2025-12-11/rustc-1.92.0-loongarch64-unknown-linux-gnu.tar.gz=d85f10ad64fa7e8ddde205538503a97968f10d800e1432e8d22c94ff48a4345f
-dist/2025-10-28/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=224f6e9896d19e00e369da70bc0e0dbd545d04033ff6ecff12b3f2d2bfe73fc8
+dist/2025-12-11/rustc-1.92.0-loongarch64-unknown-linux-gnu.tar.xz=6207ea209b332c01437fe742c2ef2bc914c88b6d4f9a23a43bc01ad924f6e4a8
-dist/2025-10-28/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=74901d397d5f6695df197520d16851986df2a5c5d432b8f24da1a5c3a5c0474b
+dist/2025-12-11/rustc-1.92.0-loongarch64-unknown-linux-musl.tar.gz=4203f9a11ffb57374dc498a6eb6f2df6f7bff4d13586a10af12476a69fb801b6
-dist/2025-10-28/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=02d8962da7234bfd365147b4177497a99c8f1f12f6841160abede61332edd35f
+dist/2025-12-11/rustc-1.92.0-loongarch64-unknown-linux-musl.tar.xz=66ac74c23df9f42cbda26587a37a70a67d5fd9821673656712a9f5a3b4cc8151
-dist/2025-10-28/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=b8d810c76102a325cdecb98e7d7fab480a8d349328ce8a275366018a627fa4bf
+dist/2025-12-11/rustc-1.92.0-powerpc-unknown-linux-gnu.tar.gz=84dc48d1b6b553439267dbb22bda57232e604764181cba7c19ed6a601b17ef27
-dist/2025-10-28/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=f09c4e8d4a4ae4cf490e55bcd29ab00b6f7c1aed09c93b63f10fc3f812f415e7
+dist/2025-12-11/rustc-1.92.0-powerpc-unknown-linux-gnu.tar.xz=961cb6b8c2b5e969ad8eb0256fee43b88608b27310d946a7df3c9e9577139cae
-dist/2025-10-28/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=6c71850444d597cdc07a7169bd5d2564cbd99d1a34ec806ac8b818b39c9fd529
+dist/2025-12-11/rustc-1.92.0-powerpc64-unknown-linux-gnu.tar.gz=209a0e4371ae4f5670c58ca35cdd295d4b9f590b5270225b045a4655e3ca216e
-dist/2025-10-28/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=01f3537787f41c2fd2ed1f955520ff0852bb27d899141cf44de3ae126abf8808
+dist/2025-12-11/rustc-1.92.0-powerpc64-unknown-linux-gnu.tar.xz=357dd4745f978080d35dbb6192ecfea331abbb93d88be7d70407856b30722a40
-dist/2025-10-28/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=833dcfab6dc87d375154d593c8e53cd5c74b3029f8b94c753928de718185283c
+dist/2025-12-11/rustc-1.92.0-powerpc64le-unknown-linux-gnu.tar.gz=89cdf91094ff3f68cc3bc679274134e491087eea3b0cf2fe61ebc2ce5f211827
-dist/2025-10-28/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=cf99a56b49b3db107d33f5c6e668310317aaeb2b2ca3c80a0ea2b30a09b453dd
+dist/2025-12-11/rustc-1.92.0-powerpc64le-unknown-linux-gnu.tar.xz=f48a214ff6fa36a77de8a0a2ee009be8aa48ba1533792450aca5edac29497606
-dist/2025-10-28/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=55b1db794a4bb0f535e46a2c4a85eb7ea0016482b7086b6deae033746a42a69d
+dist/2025-12-11/rustc-1.92.0-powerpc64le-unknown-linux-musl.tar.gz=9215fe368a7d22143b96d42d9ada17009420ea080e5650d30fb8a4e2e720117e
-dist/2025-10-28/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=a741b18a92f5fa35cab2ed93d90782175b70e3ef5a127e21fde7acabb6228b59
+dist/2025-12-11/rustc-1.92.0-powerpc64le-unknown-linux-musl.tar.xz=f418ffded33abecec8d8aa72abf40448511ac78e8ae14ca43c066c7dd98310c3
-dist/2025-10-28/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=97335caa2ace3f33cd959dc35f01ec8a3d2de5699518b93fd191766eda3fe318
+dist/2025-12-11/rustc-1.92.0-riscv64gc-unknown-linux-gnu.tar.gz=e36b96182e9a0c2e2f3a83cddfc5318a8ca2d049a0bddca9b42d05428ebed89d
-dist/2025-10-28/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=2127853b7b4e2b3cf906ef292e9c7e370ec3f3760ce5576b447ed7902048794f
+dist/2025-12-11/rustc-1.92.0-riscv64gc-unknown-linux-gnu.tar.xz=729f4c074ccda30bff493fa94f255bcfcec1be594fecd8a4d0f57da845121c64
-dist/2025-10-28/rustc-beta-s390x-unknown-linux-gnu.tar.gz=eb3df84c1a840cc69799ef0649972e5312afe59144700ba3652bd6083f48074a
+dist/2025-12-11/rustc-1.92.0-s390x-unknown-linux-gnu.tar.gz=1fb255054864d857b32ca2c0dd06a2739cdd464d8872e18f2b103fb7a6d1f530
-dist/2025-10-28/rustc-beta-s390x-unknown-linux-gnu.tar.xz=16942680ea11ead1ab4d9d46d31389a14f237637a6877b278cd30a608446b787
+dist/2025-12-11/rustc-1.92.0-s390x-unknown-linux-gnu.tar.xz=6a8cf614a74f7469c70d32b378f0163633e6bbe19624b248b758501c5bcdfe84
-dist/2025-10-28/rustc-beta-sparcv9-sun-solaris.tar.gz=5c7848ab2b2cb181bd7f64cdbdc3b5b659b61850c14604a7977c35b9807daa48
+dist/2025-12-11/rustc-1.92.0-sparcv9-sun-solaris.tar.gz=a5d20ba9277bb8b3b756f9f6dd2f7a1e9931ac8673fcca31d745eb81f1d573b6
-dist/2025-10-28/rustc-beta-sparcv9-sun-solaris.tar.xz=0f12cb118e253206ea74e7b1dabdda6e95bb0b10d47657aa4c560fa9ca28cf83
+dist/2025-12-11/rustc-1.92.0-sparcv9-sun-solaris.tar.xz=74d6f885557f11b136d780c6fcc22d1db4b80644baaad22dbbbe29c890a0475a
-dist/2025-10-28/rustc-beta-x86_64-apple-darwin.tar.gz=3c34e03deee0445864c7f5ebc89883db051a3c69b874a2daff658fb5dd364aba
+dist/2025-12-11/rustc-1.92.0-x86_64-apple-darwin.tar.gz=d3dc5b7ddad48bb0afba0c6448aa00efec2d3fa9bc02ca55575c76d425c15ce4
-dist/2025-10-28/rustc-beta-x86_64-apple-darwin.tar.xz=292d40e5ea57295ecd921a07fa11796771953d38793edcea9841a95e79d94ac2
+dist/2025-12-11/rustc-1.92.0-x86_64-apple-darwin.tar.xz=0facbd5d2742c8e97c53d59c9b5b81db6088cfc285d9ecb99523a50d6765fc5c
-dist/2025-10-28/rustc-beta-x86_64-pc-solaris.tar.gz=6ac79775ff166ba76e663e8760ddf9625e06a28e5033d4d8cc570dcca73ca725
+dist/2025-12-11/rustc-1.92.0-x86_64-pc-solaris.tar.gz=aeec5a91df699ab7a6b276e694a2711a59988dcc664ba9de43d5502e53d7b504
-dist/2025-10-28/rustc-beta-x86_64-pc-solaris.tar.xz=46c214af2c11ccb17529a991201624bad044d59c171c6f872468acb8523b6f96
+dist/2025-12-11/rustc-1.92.0-x86_64-pc-solaris.tar.xz=03ed0965a4b4006f347513e7a2e7e0a9dac13053b432d65e97c59fd604973542
-dist/2025-10-28/rustc-beta-x86_64-pc-windows-gnu.tar.gz=29067fc4a5e0f123c34a045a1b0d55f88170bc9f658584d50e32219cd5945854
+dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-gnu.tar.gz=338ec86978c5d25799b79105c7bfb146002208d656f9e82b14692cd535c2ae65
-dist/2025-10-28/rustc-beta-x86_64-pc-windows-gnu.tar.xz=30c20794d0c244bd04dbd4de304ef3aea5ba11e26882f2a004680281f21e05b0
+dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-gnu.tar.xz=fa0cbdf49f267f316433f054ca99951177827d0d406ddbaba9a0bbdcb093b56d
-dist/2025-10-28/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=6c6c7614b538d9bad498b3642321adf0b2b6cdd3b24706903a8eb2125c0c122a
+dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-gnullvm.tar.gz=b3575d7f29cd0423dbcf89457a9682acf8c0c1ad923136a12c7d3162c7b9a2d9
-dist/2025-10-28/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=09822c7d5bbf218d5113e902968b37719949997fd788523bf80400274f428986
+dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-gnullvm.tar.xz=e67ec11b4c6e04e95effa7b4063ae8327c2861c6d08a7c692d69a0f1adcd8ecb
-dist/2025-10-28/rustc-beta-x86_64-pc-windows-msvc.tar.gz=fcf05b8150cf7199e100f560854f6acb6874985a5cfbb00ead36914dc3fb66e9
+dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-msvc.tar.gz=4f321ca1903b8b08ceb07c0305f9f0320bc711ff6e285d726b8ef1dda774935d
-dist/2025-10-28/rustc-beta-x86_64-pc-windows-msvc.tar.xz=f5259f5b521ea10f093c522abd5bcec4e9dfb94ce3e384e3b53865a223e700d0
+dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-msvc.tar.xz=6aec5aba5384ce1041538e71ebebf671d82e29f4fe697bc7844626d94b0dbfe6
-dist/2025-10-28/rustc-beta-x86_64-unknown-freebsd.tar.gz=c3719366a9687d243483431231b86140e268bf2ce99e1ea1759a611524ea8ade
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-freebsd.tar.gz=a0c0710281e86f7523d116c3826ed406491430d9f92769e4f4b4caf28e686edf
-dist/2025-10-28/rustc-beta-x86_64-unknown-freebsd.tar.xz=015e02fb99098c31d502738e9e525d48ac6ca386e16f3ecb55235c7268d4abe7
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-freebsd.tar.xz=f9b3a4fdb825c171e15f68db7c4faefecd60ea7475b9b11e98004fb7d711fd7c
-dist/2025-10-28/rustc-beta-x86_64-unknown-illumos.tar.gz=508acec5f2b092d09d55590e7fe921f7415aacc13c535532997776c4ebb86483
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-illumos.tar.gz=b48d9c46b58f00a164b35611a58d0ed13bf5dd4ff7b138252b61f8100fcd7434
-dist/2025-10-28/rustc-beta-x86_64-unknown-illumos.tar.xz=f7437c9b0e747b0eccd7755a3ef551fa81194f23304ddb40ae44bca5782dda4b
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-illumos.tar.xz=e74f639cdfb368edfede795394932c8665cb192a2618e88c947ebd57ce2cc159
-dist/2025-10-28/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=cd985cf21af999dbb76e25cb6c9b5ac5723e8cda8625cf511e7df2c98e7e735a
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-linux-gnu.tar.gz=e133546ebb40974356cc82434e07f6a0ce15966d8b01898f97eab235c46883e8
-dist/2025-10-28/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=d30acafe9f3ddfd25148abdd3078deaaafb6bb62f7979252e9e7880abc260b23
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-linux-gnu.tar.xz=78b2dd9c6b1fcd2621fa81c611cf5e2d6950690775038b585c64f364422886e0
-dist/2025-10-28/rustc-beta-x86_64-unknown-linux-musl.tar.gz=1778c649d790e52b8462d5ea377339443e607b2434fa9b579236b465f63748c7
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-linux-musl.tar.gz=eaff6d6b051e59875eb585a981c799be87a2a68f1d52556dc64e26531a499531
-dist/2025-10-28/rustc-beta-x86_64-unknown-linux-musl.tar.xz=909808e6e3a10cd3fc2c0927f47dbe4ac8de4653b4e771c9c44b8e58cbe5fe2d
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-linux-musl.tar.xz=f1a037c367d29d329d041f0bf1d271e60440adc961b6eaa9ea902018a672d4a3
-dist/2025-10-28/rustc-beta-x86_64-unknown-netbsd.tar.gz=8584d5ad71c7cedcf6e64b0f83ed2cfa82346e88a1000acac677f464dbb0e6f6
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-netbsd.tar.gz=49f33344d9b22dea5a4f97f1d1c4fdb52afd1c34bd5fd78bb8d7e5e5ee92333c
-dist/2025-10-28/rustc-beta-x86_64-unknown-netbsd.tar.xz=7b85928ce5f6908ad82895097ba07fad70990b7810aa23c63725d7ecbbf54d54
+dist/2025-12-11/rustc-1.92.0-x86_64-unknown-netbsd.tar.xz=a0cdbdd508e72de8f3e783b61827fac1f741acd6503464dc263a7292880a16e5
-dist/2025-10-28/rust-std-beta-aarch64-apple-darwin.tar.gz=312c1121edf001f03ea169e8fff9668efd1925a45962b282b32d5f126bd6b010
+dist/2025-12-11/rust-std-1.92.0-aarch64-apple-darwin.tar.gz=b1f55aac4bc982ea67b68b262b711263005e470d31cab5d09d534bc1866d455a
-dist/2025-10-28/rust-std-beta-aarch64-apple-darwin.tar.xz=11e0fd642939358a892e66ebeea7f1737a009ad23692da486c7427cdce60c37d
+dist/2025-12-11/rust-std-1.92.0-aarch64-apple-darwin.tar.xz=ea619984fcb8e24b05dbd568d599b8e10d904435ab458dfba6469e03e0fd69aa
-dist/2025-10-28/rust-std-beta-aarch64-apple-ios.tar.gz=d7086698f3414ebf1410f79f8167ef2e4cf8e9143dc7e3704200d67e64252080
+dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios.tar.gz=449a3f453215eaa86ee80bd4f70cb1a8dfca0447e27f7e820a73047913d7c724
-dist/2025-10-28/rust-std-beta-aarch64-apple-ios.tar.xz=a71fd039b0bfa2fa7a1abd13c622c89371f7af273fc44b3c210b1ead6a1f9156
+dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios.tar.xz=81fb496f94a3f52ec2818a76a7107905b13b37d490ca849d22c0a7a7d7b0125e
-dist/2025-10-28/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=52795cad4c58b32c3f36fb7b596c25a8e3277c85c165e161445d1fc81e0c4200
+dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios-macabi.tar.gz=cc4ca331919012b71cb634082ab761003c752067a7b7cbcdb5a513a56f629bef
-dist/2025-10-28/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=7db4e584f7890bd05d7cf8a991f539be249e0f04526e30743575129dada977c2
+dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios-macabi.tar.xz=d0453906db0abe9efb595e1ed59feb131a94c0312c0bc72da6482936667ff8da
-dist/2025-10-28/rust-std-beta-aarch64-apple-ios-sim.tar.gz=575b6d5185a71a4f4d29dc881f5dea5fe492d7b21a01c0bd9987cc212bb8ca25
+dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios-sim.tar.gz=1e08495db970e62931fd1f2349b10c04a765469aecd84b9ded10bcf09e98904d
-dist/2025-10-28/rust-std-beta-aarch64-apple-ios-sim.tar.xz=ea1c7896e21d0a89da399405611a25ec447ff71495a4b5d48501c9f8129b2a20
+dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios-sim.tar.xz=9362b66fbaf2503276ea34f34b41b171269db9ba4dce05dde3472ea9d1852601
-dist/2025-10-28/rust-std-beta-aarch64-linux-android.tar.gz=f7a85a478dd9d55491a2395dda9539ab7898385782ef5be479362ba35e8be837
+dist/2025-12-11/rust-std-1.92.0-aarch64-linux-android.tar.gz=f6689cf5b71056e887261ec84ae1f499eeb42c67e5ae73e7c0e06065b6648c44
-dist/2025-10-28/rust-std-beta-aarch64-linux-android.tar.xz=4fc53a2be557540332410446f6f43f5e6339d10d8010c153d99d707df64a5ef1
+dist/2025-12-11/rust-std-1.92.0-aarch64-linux-android.tar.xz=ce6350bd43856c630773c93e40310989c6cb98a1178233c44e512a31761943d0
-dist/2025-10-28/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=99b3f95696883f18e3734d02c75a5dc91edac003b6d9627c5a32baac41f3c69c
+dist/2025-12-11/rust-std-1.92.0-aarch64-pc-windows-gnullvm.tar.gz=4b4774c66e6952fb46d0049dffb2c664d95712052c4816e354bca3e97799dda4
-dist/2025-10-28/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=375db4717baaac6a784d8f53f84035f99d5f76f9a3f7df7dd385ee2d93027368
+dist/2025-12-11/rust-std-1.92.0-aarch64-pc-windows-gnullvm.tar.xz=4e79f57b80040757a3425568b5978986f026daf771649a64021c74bcc138214b
-dist/2025-10-28/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=b650ca7708ae5b05fc82c7aa483f9aaa42be83d6bcc6c524690da745f32f6f60
+dist/2025-12-11/rust-std-1.92.0-aarch64-pc-windows-msvc.tar.gz=7b27adfa0f10ee44a78430ad7ec000eb95cf4586b7338bc001dae5d5b865578c
-dist/2025-10-28/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=1683d5a33387dd546ff641222b501e90049241df0f52c2f1a5dc568b35594135
+dist/2025-12-11/rust-std-1.92.0-aarch64-pc-windows-msvc.tar.xz=b20c5c696af4ecfb683370ca0ee3c76ab8726fe6470ce9f1368d41a5b06ea065
-dist/2025-10-28/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=3e2d64dd8d2fdedb30b25f899f8ed8deff653c4d3f3f7e16e534ab7e1eec8a66
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-fuchsia.tar.gz=ead00e822bf91191e4982e35d89744e977a9c51aa1b3ea1717e744c899067ee5
-dist/2025-10-28/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=e83d63666e0372f27d404a4ddf48de7abc5b646d9f087ebf8856bcbfe6f86362
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-fuchsia.tar.xz=6021246b6c0d9d6104c0b350f7cd48a31d5707edaa8063f77f5636fe07bdb79d
-dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=8a99f5fbaf869f68bced6435acf18127ac8880193fb23e44cb5791546bc795d7
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-gnu.tar.gz=04a5c9883bce2c4e89d22dd68af1bdc29b741bb456c01f8839b759a163e8e9d4
-dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=53be5ecbcb4d47e6a1fb811a6e8b4ecec7fd6ae2b6efac7d9934dee4cfb19dce
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-gnu.tar.xz=ce2ab42c09d633b0a8b4b65a297c700ae0fad47aae890f75894782f95be7e36d
-dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=f61af59bc40a53dddf0a85b5205bec90d287a41ee3ac32345a97d21861ae6546
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-musl.tar.gz=715fbcfd8712c723947a020d0371c8a1a21f7531f2b696aeaed50ac23ba675c9
-dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=9ed2894300f6ac917ac33d0724133ba2fada2ab2e42a0b21a9bd994d70c942f4
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-musl.tar.xz=94b9f84f21d29825c55a27fbb6b4b9fb9296a4a841aa54d85b95c42445623363
-dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=70ad473c7d4934bab123afb8cff98773993fdbb73b4941f6022a25ef2942a223
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-ohos.tar.gz=0971b3c864ab1baa06a7fb5ba2fb176d8ca762bdecfd9e374810dc827d69d134
-dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=d0a06230a38c725ceed103c89e8031b541b7bc15a3646a1a3662d8147901b2fd
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-ohos.tar.xz=6fb30061fae54c4a27bb209d314456d04826c345a8015b10d1fe9b82eeb46f9c
-dist/2025-10-28/rust-std-beta-aarch64-unknown-none.tar.gz=90d4484a1e390e0d3edf25331d41f9b419730bd2e318e8927c4a891b2c035652
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-none.tar.gz=93e18afe654009b56783f1295d25a8bafa31badc8f6fcb46c2e217856daf68a6
-dist/2025-10-28/rust-std-beta-aarch64-unknown-none.tar.xz=5b795b7378b6753fb2a8ea0ecef760009ffa05c9a4778815d2d2b4085baffe14
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-none.tar.xz=ab6a2edab924739fc2c86e9f8fd8068b379e881a6261a177d66608d3ea4cacb1
-dist/2025-10-28/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=52d0e13f1dc2083787d3294d5c3569b11227724ab4ced4ba9905ac0a5f25bde0
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-none-softfloat.tar.gz=911108d6f01ff1040ea3de993bcf3ea52fe19aee099516a607e9967ce4813bcb
-dist/2025-10-28/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=981dca064b73d6617039bb35a32a17111445bc1ed9ba957525d227d3be9e8f6d
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-none-softfloat.tar.xz=0dc46fafaaa36f53eec49e14a69e1d6d9ac6f0b9624a01081ad311d8139a2be0
-dist/2025-10-28/rust-std-beta-aarch64-unknown-uefi.tar.gz=fbb7066da0824513e4441bb59d4c6a6d4c8bc34f67ed79f67da3b8ec69ff3a4c
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-uefi.tar.gz=a14f2491f87149b779460b898ff1208adc31fc463094d8eff86e778fce9f6ce6
-dist/2025-10-28/rust-std-beta-aarch64-unknown-uefi.tar.xz=c0bb51d8c513c0b5d597cbc00260bf2764595b12244906606c20ae6f98e0fc66
+dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-uefi.tar.xz=f98001222bf23743598382c232b08d3137035b53645a420a1425288d501808af
-dist/2025-10-28/rust-std-beta-arm-linux-androideabi.tar.gz=7cd5763f202c5679dc1bdc0e6551dc8093ee95a9b2d405ad8cbd31fcf232332c
+dist/2025-12-11/rust-std-1.92.0-arm-linux-androideabi.tar.gz=7d9d430c187580c1075649dfdef03dde9f5616ed74ed050ae01cc9d5eda79268
-dist/2025-10-28/rust-std-beta-arm-linux-androideabi.tar.xz=126b3a04432a3f6f5f1aef6f5e22deec98629da4a0809b0c7739911ae5e4b6cc
+dist/2025-12-11/rust-std-1.92.0-arm-linux-androideabi.tar.xz=d41ec7255556b605dda04201a23e4445b5b86bc6786c703f91eb985bddc9f4ca
-dist/2025-10-28/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=01bc31ad9812edeb11dc4b6c15d4bf80a325e286390829babd85176b91c38cfa
+dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-gnueabi.tar.gz=56d8b0df4b716a69aeefc06fbd859461938d54bcac37d7eea25b07764f6e3c5c
-dist/2025-10-28/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=0b1c799856c8314afddfaa5109535535c36df31bb9188a319c1e45f4968a7079
+dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-gnueabi.tar.xz=35478e20f8cc13912b31f2905b313a2820ddae564b363a66ab7a5da39d12787f
-dist/2025-10-28/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=8792d0115ba1d9b0e3bfefbd7a9ddf7859f7bbf8431ef32530b05ec7cf9c68b8
+dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-gnueabihf.tar.gz=d0a355524cf219351f15d8984c102f6425bc2c6c1e14af9282e2db60a997a5e0
-dist/2025-10-28/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=fc470db282fb0fab537e4b93a9498d4b4fc65cf014536905654cc2c14f82d245
+dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-gnueabihf.tar.xz=836ada282b65c57d71f9b7e6fb490832410c954aac905c5437fb0bf851b53c83
-dist/2025-10-28/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=fe82493d2a7f4a9566916beefcd7fb26301bd13b8b838b5251398ecac0c867ef
+dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-musleabi.tar.gz=a505ed45f3c55334e8294f304366e2210609305dd25a86b0396c89016219a9d7
-dist/2025-10-28/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=b7cd0514db083e115d8aacceb3f7998da11f26e9f2be44137e8af2e2f9ac786e
+dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-musleabi.tar.xz=91d3c5fdbda9ba2e778bb638e3a5d060f3021bbc7a60edf22b0035be4e611b30
-dist/2025-10-28/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=0adc4e2e0f5bee4c28c81ba2cfd9796268e830d23b23b80c71121c30f08e3326
+dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-musleabihf.tar.gz=1a2bba0ac573420064fec467a713ab169b54d9281d5652817d5d628a98ff167a
-dist/2025-10-28/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=8c98799e7b4c454cad130d0eb87e8ed59e0e7e64bb0513af8beb6d1d5f8e3ac7
+dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-musleabihf.tar.xz=20411e3858308add0dadde9ce2059d82cdd6c5339881fa93ac995e733df0f832
-dist/2025-10-28/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=bb1da273578b508b9f397074438ecb2527a729e404d2820bd34d67dc8824106a
+dist/2025-12-11/rust-std-1.92.0-arm64ec-pc-windows-msvc.tar.gz=8cca22404b172c1ac590e6a507ec73bece0e3698bfd74f549246d23392ee3a45
-dist/2025-10-28/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=e004d91a9732284851d613a3c488909bc7d457b2053a1af45710aa4bbe3169e9
+dist/2025-12-11/rust-std-1.92.0-arm64ec-pc-windows-msvc.tar.xz=1618d3d429a3c9b06d43bcc12ec7c50c5eb6cb01cb2f077c525bc0f077c7a6f0
-dist/2025-10-28/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=7e6b5d4266306001366003cdc4fd4b60d700e86ec5dce01b58b0e73bd6a50c42
+dist/2025-12-11/rust-std-1.92.0-armv5te-unknown-linux-gnueabi.tar.gz=547a6282ed5896dbac1df388a116301cfedf41fc579fa25caa57b3ee7e333e19
-dist/2025-10-28/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=170b32ea83d21436e744d11a56ea8e298278f8b9aa58fd82d6d788ff1e3258f3
+dist/2025-12-11/rust-std-1.92.0-armv5te-unknown-linux-gnueabi.tar.xz=702be50f225ad4681af1bf9c40fd020b4623ee46aab5363ea96e4874dffb694d
-dist/2025-10-28/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=8ee71b71a8e90b21d580f9e64cc115f182db8582cd6238f946e24fc32de27e65
+dist/2025-12-11/rust-std-1.92.0-armv5te-unknown-linux-musleabi.tar.gz=578a0eee2513520e4195e09c0657b074cc9f7bff215507ddd905cfe7b15bab77
-dist/2025-10-28/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=9319475d974dce729182c3d99696bd5cf6a36257b1b80186f261d2885610ddb9
+dist/2025-12-11/rust-std-1.92.0-armv5te-unknown-linux-musleabi.tar.xz=c1c645c1b33625b9735a7c6f062a122fb172957093fac33f8ee3b80663deeb41
-dist/2025-10-28/rust-std-beta-armv7-linux-androideabi.tar.gz=71db2b02df33e229899f0dafc675572f2b4041400954f9145796edee7cd923d4
+dist/2025-12-11/rust-std-1.92.0-armv7-linux-androideabi.tar.gz=18f6e6903c5f4361efe8c8a1ea546303e4473e8b9cd1b11fcf4e5b170468d464
-dist/2025-10-28/rust-std-beta-armv7-linux-androideabi.tar.xz=0f331806b4523d61204f38f2d7ddd07e6f3dcda8a15806a9f01cb1747a587e8f
+dist/2025-12-11/rust-std-1.92.0-armv7-linux-androideabi.tar.xz=06ac2f08dcf5c480e7767c0541c9bd7460754ec3a369a4b7097b328eca28fab9
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=52f331579373b749fb1c7a6302a770a4be33008cdd9db4a5640208ba1ba7b540
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-gnueabi.tar.gz=1e2238cb33c6adc29c13fdc980a4019587f69af5ae88f7bd473da2dbd9b70a2c
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=1e8c5dcc4cb672c4e8ba2862549cd281ea6802fb73701c885eaf5423673ab233
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-gnueabi.tar.xz=3d5e3fb14441ea8e6fc6307cbd89efd69be42143ff7f2b8dfb19818ddca993c0
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=2d0dded898f567cbfa5605dcc09b1e44970e345a030ef91c806eafcac4470258
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-gnueabihf.tar.gz=2c44994e0982bdb60c132c40b481b3c6ca83a131f09d568831553e3e29384130
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=3a63913c874f30c8a68d5cbb62dc654ec9c3bf2f4488e1098034f60c51824bb7
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-gnueabihf.tar.xz=e3ac810db43067d8af9e17679d47534e871f1daad8cd0762e67da935681e9e19
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=24c341427a9b5a4d883e7f322a9c7760446896e8c2eeb1f8654b80cef00db6ea
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-musleabi.tar.gz=3bf1b0015dc3b0f5f6f5622588431855c658d5c47093f24e4077f6893229ab30
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=53c5607351479ad76c3450bcc81353633f2587aafda473487bb11e42f80d8523
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-musleabi.tar.xz=89cbf7db934d543754b446a52398081ec40ee6b98ed5bca93ac1dbd5faf48c16
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=beda2ede28453b81588d639c18b36fa6e935e586723159e39ab9b714291c680a
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-musleabihf.tar.gz=fc5c4ca757599caab8e93000becb9d57587088d32dab5c4f3b253f00ec3a2fd6
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=f175a55fc81159e9a40407b1d97ea658239014cf0f5191a3533318e53ee1ff7f
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-musleabihf.tar.xz=c7c08a389bd351226fd52266bfe2d2c444597e1bbb5d0307da44bdfa4df62c99
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=db1f0cfd65d795d23a60d29e44f24e6174a0a516b998e65bd1964230c9c6c03c
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-ohos.tar.gz=4cc8337f39f1b2820880dd8cac203399b5fd0eee7716d0a9c785a71f6d9fbf50
-dist/2025-10-28/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=264efedfd340c095dfe08fc95a35c36392eda0d1c2c179e56c75b27685b90d7e
+dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-ohos.tar.xz=e75603f745d5becd2e79d0cd6c7976e53bcc56d7af8ba1ac4e3494effc502f15
-dist/2025-10-28/rust-std-beta-armv7a-none-eabi.tar.gz=578fe97f24afa73c155290bf7386594e8b18a4652f54477d7a4e3f6f3ada0b5a
+dist/2025-12-11/rust-std-1.92.0-armv7a-none-eabi.tar.gz=b7b68dc24eb7e80592938a928372391e57fc04066238b178855f06863a597341
-dist/2025-10-28/rust-std-beta-armv7a-none-eabi.tar.xz=a373109143f701d266ba53b3fff32206d88f5dfabdd888ac988606fade0b4928
+dist/2025-12-11/rust-std-1.92.0-armv7a-none-eabi.tar.xz=e97368a7876332ce5181d8efca43996ee9d16ecc0be195e7d9b4f295a36c39ac
-dist/2025-10-28/rust-std-beta-armv7a-none-eabihf.tar.gz=b3d6ec33c14a034c621aaf7de6ec81f0a916e18f5acc933713cc479fc21af755
+dist/2025-12-11/rust-std-1.92.0-armv7a-none-eabihf.tar.gz=f79f1983b5c3867657ba1849472b0aa1a54ab1ab94bab66f046583f8858bebad
-dist/2025-10-28/rust-std-beta-armv7a-none-eabihf.tar.xz=6550b2a97ce84884aa0da9133b81703e08b6e57b65c2e93f310fad2559ea4a08
+dist/2025-12-11/rust-std-1.92.0-armv7a-none-eabihf.tar.xz=407899b91b4a44d5096bebbae00b3044ecc71e4cce958f79a149f4149a662bf6
-dist/2025-10-28/rust-std-beta-armv7r-none-eabi.tar.gz=b50984f65ee8a9e8c1b62158d8e91cb976f7c36f6ebc3c70ccfcab2a3da26533
+dist/2025-12-11/rust-std-1.92.0-armv7r-none-eabi.tar.gz=310c5149e672a794364c389ee383f437e367eac912c8c9c63e9e024c8eb5a98e
-dist/2025-10-28/rust-std-beta-armv7r-none-eabi.tar.xz=0227fe58cacca86a04d85860a1de852a29ab9ac1bfea7bc50c2f560b73951d8b
+dist/2025-12-11/rust-std-1.92.0-armv7r-none-eabi.tar.xz=d135b9aa652dbdbf8115c31a71eb5b5e022968dd3c98a6d0421ad13ed8b8385e
-dist/2025-10-28/rust-std-beta-armv7r-none-eabihf.tar.gz=da5e26a7cb5b91d3b8ec4f1a02c81b0f538dbb416e10e9453f3fd9d5cfc08129
+dist/2025-12-11/rust-std-1.92.0-armv7r-none-eabihf.tar.gz=49b7583f91e42ee05c057e8ca5b736d883725d40e71bc8f8ce369b46bb074343
-dist/2025-10-28/rust-std-beta-armv7r-none-eabihf.tar.xz=9132e8a69bf5dbd144def8bc647c659304fa785612a0f68f2e1a2df5dc195e33
+dist/2025-12-11/rust-std-1.92.0-armv7r-none-eabihf.tar.xz=d6b44323ffcb32ead9be54ef4786048f48cec1f18cd269e2fcab36d2c3d5e7e9
-dist/2025-10-28/rust-std-beta-armv8r-none-eabihf.tar.gz=a312253ad16ccffacd0d840cba85d290fb5d2580865de99887990eff96f58b45
+dist/2025-12-11/rust-std-1.92.0-armv8r-none-eabihf.tar.gz=f0b184acd74d500d6a7f559a62d7946d00fed6ac427bdbd7c52640be6d98e767
-dist/2025-10-28/rust-std-beta-armv8r-none-eabihf.tar.xz=474813a75bd586e562cf76705bdabf37a915cda6edb45afe029cbcbe54be3cb5
+dist/2025-12-11/rust-std-1.92.0-armv8r-none-eabihf.tar.xz=355ffd45d0d450e1e5d2ce8aa1ff0977ebb4b3ca9c6689e8d72dcd2c56b6046d
-dist/2025-10-28/rust-std-beta-i586-unknown-linux-gnu.tar.gz=4be0898bb9da3e8d75cb9b4851d5119efdd3136eb10cf31a42109f188781b6ea
+dist/2025-12-11/rust-std-1.92.0-i586-unknown-linux-gnu.tar.gz=3fb6630b6341a07a9bbc37a8c541ad3e389a26dc0ef48c09aa3b14a6afbf672a
-dist/2025-10-28/rust-std-beta-i586-unknown-linux-gnu.tar.xz=5a51fb1f2da0dd645c1eb6ce19f37f16f356042ba176ab109f8bcd4ad3514ad3
+dist/2025-12-11/rust-std-1.92.0-i586-unknown-linux-gnu.tar.xz=8b984b31ffca1f27d32ee77ec2cc4c2ab59e72beab67bfce13bbd926dbea8715
-dist/2025-10-28/rust-std-beta-i586-unknown-linux-musl.tar.gz=96f621043d426d00f6baec72f66db5d91940215ba3e6985bb823c7b02acbd7ff
+dist/2025-12-11/rust-std-1.92.0-i586-unknown-linux-musl.tar.gz=6c39e5506fd6a0532d15f3cd9510e6e9fb0da0712f426b8a55f04114125b6e13
-dist/2025-10-28/rust-std-beta-i586-unknown-linux-musl.tar.xz=2e62b9a670e3ca1d892ab18da1cd4b2bd946395e35c3b7829dd4b03726a73e4c
+dist/2025-12-11/rust-std-1.92.0-i586-unknown-linux-musl.tar.xz=059d919f147e6bd40e132ad00ee23de59d5464f5e3409f3139b3ac14faf45893
-dist/2025-10-28/rust-std-beta-i686-linux-android.tar.gz=6c3b0e8796cb87e1a0369b55a91e49d5129af929deb4b63a623cf68219679543
+dist/2025-12-11/rust-std-1.92.0-i686-linux-android.tar.gz=d994d70493ad68ced22a5269e41b9fa6f83af9f3adabade154860058bc2e18c0
-dist/2025-10-28/rust-std-beta-i686-linux-android.tar.xz=682747e9ab2706e90b5071ce13e8bff21160987d42ed0565f8e0012acded5f40
+dist/2025-12-11/rust-std-1.92.0-i686-linux-android.tar.xz=e45832b005556f65c6d26f05f34bd4ab5ceea8d9b9fefc4175d52b0780ca89db
-dist/2025-10-28/rust-std-beta-i686-pc-windows-gnu.tar.gz=e7afe1e6ccb84fcf03114a6a3fd7232b40d7b2005f31a00a02d9c8e092af8b5d
+dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-gnu.tar.gz=5f30330e61a7d87426e3192e3ba99ec5db2b3d239825f15ce7482b88e695757e
-dist/2025-10-28/rust-std-beta-i686-pc-windows-gnu.tar.xz=99d64d295d7bc0befe84a1da5d888de3ee0daa67a027c8628f78c36ab53eb7b4
+dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-gnu.tar.xz=b3eefe10d4aed3ccbeaff3ae9cd2e0e0a36894c0635d0e69af1c9a698679d75f
-dist/2025-10-28/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=1b36e3979b73348b46a01961a2515bc6ae19a54924e63272cb1bca709a07bcf0
+dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-gnullvm.tar.gz=916badef8e6415e599b41b706aa522f514ee2932b5e65baea5b04db34e03c185
-dist/2025-10-28/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=f579f144f9f653df8be318e4f5ba363116a538b840030d3cd5305f87e03b9e23
+dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-gnullvm.tar.xz=e6d709f85dea51d81f2f1a030845b732b9f7761d95d93c57c7276b0a451c2993
-dist/2025-10-28/rust-std-beta-i686-pc-windows-msvc.tar.gz=79de79f2ed569a93dcd57aba35c7995582dde8b633bafbf0fc43ab6a8fb9d152
+dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-msvc.tar.gz=2d248d48ff8650e61097c57d653ae3c785413b8fa916c51623374b22c5f3be0c
-dist/2025-10-28/rust-std-beta-i686-pc-windows-msvc.tar.xz=8c3fdbeb815085aaa9d484f1b22d0adbcc829a88511df5930bb518b139d20801
+dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-msvc.tar.xz=e5671b276047647e994a7cab99c90ee70c46787572fbe4e266a13c6edb84d5ce
-dist/2025-10-28/rust-std-beta-i686-unknown-freebsd.tar.gz=d25fbb684148778444743e9d651a6d36dc4527d42367bfa67eebc43200e6cc0f
+dist/2025-12-11/rust-std-1.92.0-i686-unknown-freebsd.tar.gz=235c77dac41505cfc170a448ff70695fbb78b986e6febbb72eb931f23c66d8cc
-dist/2025-10-28/rust-std-beta-i686-unknown-freebsd.tar.xz=32c6d84e419a72cb862294a110fc79a88b123c4180a3a64bd53c38b200c60f9a
+dist/2025-12-11/rust-std-1.92.0-i686-unknown-freebsd.tar.xz=e008a0506ec4d5eff30abdf376c7933e235670bd6c5e1131c52bcda097a21116
-dist/2025-10-28/rust-std-beta-i686-unknown-linux-gnu.tar.gz=577cec0f5fb83cd22a9256dcf7c74529d95572976f102a8a63eb1cb9550f0a6c
+dist/2025-12-11/rust-std-1.92.0-i686-unknown-linux-gnu.tar.gz=f568a3c307fad16528bf5accecfdce9e77b6ebda3302ae7a79588adc10d2bd29
-dist/2025-10-28/rust-std-beta-i686-unknown-linux-gnu.tar.xz=dc537d7c09efaeb054d2954689842c813b5e9d646fcad912005f4b10e137181d
+dist/2025-12-11/rust-std-1.92.0-i686-unknown-linux-gnu.tar.xz=abc840631a4462a4c8ec61341110ff653ab2ef86ef3b10f84489d00cc8a9310d
-dist/2025-10-28/rust-std-beta-i686-unknown-linux-musl.tar.gz=5713f1784a424f509f47f70e0bce2bf8ae82e1a16efab8cd771677988b37516b
+dist/2025-12-11/rust-std-1.92.0-i686-unknown-linux-musl.tar.gz=3d6ccb700a17533eea10c7541896c92817783045c5537af37228142da7668fb3
-dist/2025-10-28/rust-std-beta-i686-unknown-linux-musl.tar.xz=1a3dc46f4cb4e4c8e4f96e9835b1188242addcb7a5a8ebbe3ef614c3aef862c4
+dist/2025-12-11/rust-std-1.92.0-i686-unknown-linux-musl.tar.xz=c796874b1343721f575203fa179dc258e09ac45cd95dd6c35c4d5979a3870494
-dist/2025-10-28/rust-std-beta-i686-unknown-uefi.tar.gz=4c32dcb28c1fbaeb910c9c7c60ea7dfe50e6556663eb3f002b66ec3ed42bd7ed
+dist/2025-12-11/rust-std-1.92.0-i686-unknown-uefi.tar.gz=78814c81a60fc1e3326f6d00eee4bc907053bb3a8971a825bf6728ba645f264c
-dist/2025-10-28/rust-std-beta-i686-unknown-uefi.tar.xz=1683c1c2838a2693b2f08a9daf0626675623d6bccbc4c996fcda8489eac853a1
+dist/2025-12-11/rust-std-1.92.0-i686-unknown-uefi.tar.xz=90da7759e28e62fb82454d4eb4e02ac14320b8da3372e02f9ca4f47f7afbfe40
-dist/2025-10-28/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=401945e68f2246d1f502d4ac63666d5443ca7fa2f81ce38e76fbb0647fed4643
+dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-linux-gnu.tar.gz=cabff40eb871616ce5d40592262b25aba1e6ff8f309bb6e0dab08609470dcfce
-dist/2025-10-28/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=9b8d7d2f8a4ebf1369718d8bd3ae6973c977cdcb7030ccea0542f9e28970c281
+dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-linux-gnu.tar.xz=62e2568ebf6f1addc750a8c32dd1fa4fef8d27679cbac33b837afeb54f204819
-dist/2025-10-28/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=ae351e8f921f0c3b8bcccafa0c84402e15ced7591debf82287e63bac0965801b
+dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-linux-musl.tar.gz=e46b3f6a18ba0faa5190deb3ee296fc971214c9d38f9d616fce2457e335a98a8
-dist/2025-10-28/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=7d64ee15508ebb610abe61e1aa03607140302fdbe41200e82070be85312d4a07
+dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-linux-musl.tar.xz=274838eebb615e6d2719157aa53230cd0c3233a1e6f1c975c0f5978198c55da3
-dist/2025-10-28/rust-std-beta-loongarch64-unknown-none.tar.gz=9f951f51a32a4f037f3548935a07208e14f3e67d29100954ae6fbf61a8e56c06
+dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-none.tar.gz=dfe120d2bc8cb81ee70c2a2e1ad685d382a0ebd72b37231183d8cb7b6890effe
-dist/2025-10-28/rust-std-beta-loongarch64-unknown-none.tar.xz=80494d9d9e02d7a6f56a638d93253d087a4edb83d4662b4771bd1d5c2cba97b3
+dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-none.tar.xz=7e03cbb3aeb5a2c882433f2de0d096455bcab2465729cb0399d1b31e2d400075
-dist/2025-10-28/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=f23fd6331ba600a3a4350565ad11f51129ad13a248f35c37b9d485fab725b4ac
+dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-none-softfloat.tar.gz=7e07f54e69ee2b7e4ef2861d7b1fcadfe3fda3ccb5442e0d85afe1dfdfc52b8a
-dist/2025-10-28/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=03d765256191ab9fac9f37102fa4252f7efb05261c8d2464745826232351dcd7
+dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-none-softfloat.tar.xz=dd01f0348ca2c90d6115b79894360f9ae8468aa8755e0f345e53fe5186f2d891
-dist/2025-10-28/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=509bcbeb245d69fcb828bf9f3fa4413d1d4d59a0e85ed28c4f412929c734aacf
+dist/2025-12-11/rust-std-1.92.0-nvptx64-nvidia-cuda.tar.gz=3f4ac1e0c35b4a709d926727a49c86d169fa61660d08e940f10f948da9777375
-dist/2025-10-28/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=543aa41bd2ae544c0114cca0e5a50c15eb7ed78d3d132bf5b48f93f2f92b502d
+dist/2025-12-11/rust-std-1.92.0-nvptx64-nvidia-cuda.tar.xz=e8d3d0d81d5bb92baae3f0cc0c43d456e312d6f2770c460ff62521dccba7a855
-dist/2025-10-28/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=d67670d0b9385f4433635a473548031d083fe14e1a407766fb1ae5c4762da93e
+dist/2025-12-11/rust-std-1.92.0-powerpc-unknown-linux-gnu.tar.gz=28320c60a2fb42756d7a825f44d35c12100492c44770b0658056e4c468974f86
-dist/2025-10-28/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=e2f403936d191b38347bbad4e9b9bd66270b23e9df238ba9b5d52f81aaebfdb8
+dist/2025-12-11/rust-std-1.92.0-powerpc-unknown-linux-gnu.tar.xz=c3e809a324b00eb53096c58df38645bb496c6560de334dfe04ed0b77c0605aaa
-dist/2025-10-28/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=15ef51a8fc10b2298db444d68130ef350414722133097d670b8106e8de68609b
+dist/2025-12-11/rust-std-1.92.0-powerpc64-unknown-linux-gnu.tar.gz=c47938c152f1b237c901090d69522ce1ccfa69a859ed10d634fe3083108c3017
-dist/2025-10-28/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=515151364a93fc458ab5f11831797d2d708b22d9a71c78f717cf89e4e593417a
+dist/2025-12-11/rust-std-1.92.0-powerpc64-unknown-linux-gnu.tar.xz=2ce706afa4a46b6773340854de877fc63618a40e351298a4e3da8eb482619863
-dist/2025-10-28/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=8ea0204c3ac93828c5a72f671c12167d0b5120cde99bb797c8d839caeb3ba3d8
+dist/2025-12-11/rust-std-1.92.0-powerpc64le-unknown-linux-gnu.tar.gz=f63de16a3c3f8e11aaf21de60ec38de59b1234aea4fe38d0577414a43adc4a8e
-dist/2025-10-28/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=138969d2a43b6c4d736a950f8ba5bc0ed5fc7868c7044623d389d8278727e759
+dist/2025-12-11/rust-std-1.92.0-powerpc64le-unknown-linux-gnu.tar.xz=eba59766c2d9805c0a1fc82fd723acbb36569e1bec1088c037bba84d965f70ba
-dist/2025-10-28/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=a3423e7917b59232faaf855ad9b9cd3b23e5d2188aeb8636e2cef324d405beb4
+dist/2025-12-11/rust-std-1.92.0-powerpc64le-unknown-linux-musl.tar.gz=696958d87842d877640140ddbbaa74d044374874dee9516e227a395b70bfb8d4
-dist/2025-10-28/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=36914d3ce6a2e5a56a2a394d2c5a461a7c8a40fc235b3552a658ab1ed7d786f6
+dist/2025-12-11/rust-std-1.92.0-powerpc64le-unknown-linux-musl.tar.xz=8b515e18b6ac8f8d37ea3cabe644b7f571984333c3b4192b7f5877e79eae7893
-dist/2025-10-28/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=dbc0b69f7eba79726bc08a0a6b357f9d818623d3cbe153dff5f2fcb31aeea61b
+dist/2025-12-11/rust-std-1.92.0-riscv32i-unknown-none-elf.tar.gz=a56084ad27ec50df0a0da2473deb84d51cb831cbf913bf983a029850e9e9f0ac
-dist/2025-10-28/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=39def1e42a80080159347b5e85bc666830a3a346c9b0e83eea8207e94659ed94
+dist/2025-12-11/rust-std-1.92.0-riscv32i-unknown-none-elf.tar.xz=e115633fa0dccec2f94477e26c5c93cbb17c54af2769e19b4636f50708a00f6b
-dist/2025-10-28/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=7aebf847c08b0eee42c77da8defc6b30439f4b6d29e4122802f02d029518a31e
+dist/2025-12-11/rust-std-1.92.0-riscv32im-unknown-none-elf.tar.gz=b1ac7c191995b67f819446f2dc1bc4a3e66036aa5ae54ad05b7891bb4bbf0e50
-dist/2025-10-28/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=35c49b2df4b3e18e0ec8ac20ec8b9a4a81b69f026921d85a666e0a97a671045b
+dist/2025-12-11/rust-std-1.92.0-riscv32im-unknown-none-elf.tar.xz=2d7547fbf012b06a2b570c94e3611b86fb10edcf23589c47ea4da99c87d50537
-dist/2025-10-28/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=b10e9e0a0457db1441a9bfeb3c4b9a8b2af4d33518bc58a8ee1d3fa7546c0bb5
+dist/2025-12-11/rust-std-1.92.0-riscv32imac-unknown-none-elf.tar.gz=52d8c75e48a2575381e2a041a5bb359adf161a6c29f4ba990e54384fa6699861
-dist/2025-10-28/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=8e210b59b95b3c8db109d978ea73a540478315fb49d4515ccf248aafa7517617
+dist/2025-12-11/rust-std-1.92.0-riscv32imac-unknown-none-elf.tar.xz=5915223db6b8afa173f67eb4fe6f5aff2402351ed9abab1b370d0860be4af6c9
-dist/2025-10-28/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=e2bfdac9e858f144db5e9ae79b494f1e09b2a012b18f0eaac96ce684a6a43e25
+dist/2025-12-11/rust-std-1.92.0-riscv32imafc-unknown-none-elf.tar.gz=2bd1d15d7d1e1a133afc7244375f3af405453153c4c3f924a0ee019fff807ca6
-dist/2025-10-28/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=6d2f5e60af9f6824fe2078a58a6cb804e61116e4848e1502289e08b0b9a5196c
+dist/2025-12-11/rust-std-1.92.0-riscv32imafc-unknown-none-elf.tar.xz=a3de78da39a79a9facf729ac005f69b4d3c68044f0b8ec4daa9e271a719d9a46
-dist/2025-10-28/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=382f448ea95627ee9fbb3d42c32ab9ecffe21ea12c00810e4eb8e94553d463a9
+dist/2025-12-11/rust-std-1.92.0-riscv32imc-unknown-none-elf.tar.gz=939b46b6320a082d562ba79efd53a028b3c01276f70106ecbcc95148b013f990
-dist/2025-10-28/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=ad7f534565c1b97495bf29054c202d8fada0a0ddfa0cca110c14a8221c654cb9
+dist/2025-12-11/rust-std-1.92.0-riscv32imc-unknown-none-elf.tar.xz=e1c6968ce25ab78f2c5b5460691763a2d39cb71b01d6d54c208d4a8b735b0584
-dist/2025-10-28/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=7c8cf6afaa4edb589259dcc61ec5e1e667a5deeace8e277f752a433f20bcbf8d
+dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-linux-gnu.tar.gz=b15965fec2297deff49412cc0e22a005db5ff710ca77187058c4907f1e7dd467
-dist/2025-10-28/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=8a396e9db63f1352bfde7a0d51446dabe6873c9a0a46e3c74f59ee775092e2af
+dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-linux-gnu.tar.xz=8ee20dcf3b1063fa6069b3ce85e1fcf42794dfa783263314865cb53fff42d9e4
-dist/2025-10-28/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=551d398055ee522ec4a67a9173daca7a1f0f537ab006383ed2ada6b00cc81cbc
+dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-linux-musl.tar.gz=34f5722ff2a0940bcd7ff6603a7748d2b963de72f6f713579c39c74ead06a7a0
-dist/2025-10-28/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=cf08dcb74f961bff041ad52efcae0c8e239e6439ecdcb32f869eb57b1a3aea1d
+dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-linux-musl.tar.xz=f20d822309900fd6c7230688694baf91e900154e44e6247feca49b7b7a203a57
-dist/2025-10-28/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=fd4e49a23ea0d512ed32bbaaefc1e5ea32c837e9a371513b94643966afabc521
+dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-none-elf.tar.gz=aa6d992ef5ea58a732e9f7a5843b37b6d03059f0de90bd6f0e45a9067e4c52cf
-dist/2025-10-28/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=10700fa42e00a3b58ddcd664c0179016b837b43a31476fe4c56e8124619e4a22
+dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-none-elf.tar.xz=7eacf6a98786d58ef912643fd5aedc35111712e96a47b7e5d3ccddcdf9fb166d
-dist/2025-10-28/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=ea2f2873255dcc73185490b2c396abb4bcd5f1623f7749f77885426f753ce29f
+dist/2025-12-11/rust-std-1.92.0-riscv64imac-unknown-none-elf.tar.gz=d81c6b2c7c71e38e6b0e1634af5b782e23f35adef36e1f35237d66c191d9f170
-dist/2025-10-28/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=7c02315d003cf65ac1246e3ac21b6da39cb1d99e61078ba9941647ae48bf9aa5
+dist/2025-12-11/rust-std-1.92.0-riscv64imac-unknown-none-elf.tar.xz=e3eda32b99bbff3fe77aa72c29de9373009e8650f7ab93c2b4c344ad13bc459e
-dist/2025-10-28/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=008321f0ccd9b96e77829b709c2683c0053acbb19ae86f2fccef49c2cb964531
+dist/2025-12-11/rust-std-1.92.0-s390x-unknown-linux-gnu.tar.gz=c33203be69a7415c6d3465bc30189617684105bdcd68a3c78d6b7257c83b005b
-dist/2025-10-28/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=047db35903bec7fee6c1d9deee5b4dc21db546a06e11c30d8372ffaf09814c59
+dist/2025-12-11/rust-std-1.92.0-s390x-unknown-linux-gnu.tar.xz=ebf944dc95015498d322504a54e4f9cdb28590f7790aa3a9eb86d6cf4b6c93ff
-dist/2025-10-28/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=19677dc6495a139eac6c5827cb765e54e3b099d64f83e92273190f09ead7dab7
+dist/2025-12-11/rust-std-1.92.0-sparc64-unknown-linux-gnu.tar.gz=6915a7d1880facef71d4712623b254a78fdc7c9edc8f98e3200b6095d81b99ab
-dist/2025-10-28/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=d5815d1eb4906a442da0a0b56fe61cf94767dda29479da447d94a23803f9cf0e
+dist/2025-12-11/rust-std-1.92.0-sparc64-unknown-linux-gnu.tar.xz=d85afb14120c3c7367338a565a920db653dccd4bc5062398791d7b62b89fd1fd
-dist/2025-10-28/rust-std-beta-sparcv9-sun-solaris.tar.gz=184424d0d18c2c49ce1c819e49804d7667edf2bce34fafedd4eeb6d4f427ae5e
+dist/2025-12-11/rust-std-1.92.0-sparcv9-sun-solaris.tar.gz=637a8fcc402792ab97411031258fdbbfbe66328fbc4aad8aa536f598501ba10d
-dist/2025-10-28/rust-std-beta-sparcv9-sun-solaris.tar.xz=30ad3f9e3eaf48af0eb700d528b330118ad39f221a7beaab1a42e52b1ffa8531
+dist/2025-12-11/rust-std-1.92.0-sparcv9-sun-solaris.tar.xz=e9ae7dc479e6c97335b3ebee8c3d69069cf6a617942196871229794ca94f3458
-dist/2025-10-28/rust-std-beta-thumbv6m-none-eabi.tar.gz=c9a72ea7a13651f1b9bc6e509d9d6d32e56a4659d541e20f571ef9f6dd858480
+dist/2025-12-11/rust-std-1.92.0-thumbv6m-none-eabi.tar.gz=a8a57993bb98d61486fac274b285168e253988d7a7fca0b3f72dc23057d9a88e
-dist/2025-10-28/rust-std-beta-thumbv6m-none-eabi.tar.xz=6dd3a25ee5060cdf4631d8b0b7f16aa569bf611ef392d93826e88846053779e5
+dist/2025-12-11/rust-std-1.92.0-thumbv6m-none-eabi.tar.xz=f55de77126b60e1da38f8a5cdd127db872155ce9fbb53d4459502dd47b1dd476
-dist/2025-10-28/rust-std-beta-thumbv7em-none-eabi.tar.gz=ccf8d09ba0bed60fecc775689649f2de31bab68cff273d796378d213c9d1e44a
+dist/2025-12-11/rust-std-1.92.0-thumbv7em-none-eabi.tar.gz=fdbc35de85989f4c2155b813d1ba4abb34f57c195d97ed863c06de8b8fb426d7
-dist/2025-10-28/rust-std-beta-thumbv7em-none-eabi.tar.xz=b7a972a9b972a2e0665387cd825491bf0ee9581ff26a586806c986014f0ae742
+dist/2025-12-11/rust-std-1.92.0-thumbv7em-none-eabi.tar.xz=fdee017dcebfa8675220c20ca65b945b6eaee744d5d19b92cb0ca5480dd19ba6
-dist/2025-10-28/rust-std-beta-thumbv7em-none-eabihf.tar.gz=26baa00580268fb5b7aba63a069c187dcca43dcf29161a0c1b849ef3765bbbda
+dist/2025-12-11/rust-std-1.92.0-thumbv7em-none-eabihf.tar.gz=d94cd679358a4eb33970df571fdfcacb385980c4f4a3f92114ffa5d356f86456
-dist/2025-10-28/rust-std-beta-thumbv7em-none-eabihf.tar.xz=dcd67a3ad1f2c553fb90009c630a8edcd8f571e28e5fcef0ade63c624fa11037
+dist/2025-12-11/rust-std-1.92.0-thumbv7em-none-eabihf.tar.xz=6bfd083ce4917440fb4b04ca39ab4dadc9f40d9dc2775056899857bfa8911fd0
-dist/2025-10-28/rust-std-beta-thumbv7m-none-eabi.tar.gz=cef72caa89fcd3d48c070b1aae2fe85f29547c9b615446af2d51767ef42b5045
+dist/2025-12-11/rust-std-1.92.0-thumbv7m-none-eabi.tar.gz=7861c515c0fdb2fcf74e434813d43de8d0b084babdd87b9cd8bf67fc173cfc54
-dist/2025-10-28/rust-std-beta-thumbv7m-none-eabi.tar.xz=70ad20d0016c6c81b4526ccf89bbd96f4bc0a97b904b2c06487fd0a0368d7a17
+dist/2025-12-11/rust-std-1.92.0-thumbv7m-none-eabi.tar.xz=7dc4c92e97db5ce1ddd9fbb7fbb1ad2d367f1c2e20d296a6d6427480c900c315
-dist/2025-10-28/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=f22aeb9cdd40a4a465525fca7e6520aaa74b5fbfb41f45777e1376742f711c59
+dist/2025-12-11/rust-std-1.92.0-thumbv7neon-linux-androideabi.tar.gz=28f77e164fbdb373d5bf729a7672d775d57a08ccbbf2d8d6aefffa0f1b9d6112
-dist/2025-10-28/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=48410a5a2f05c80f3d76b9f0b3e0eb89521495b273a854b40386048f27b553c2
+dist/2025-12-11/rust-std-1.92.0-thumbv7neon-linux-androideabi.tar.xz=ce99df993198da32a2f655d8f6666f2ef7995242cdc31686db49bfeac07e6f7c
-dist/2025-10-28/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=a791f5442467819c154f943c3126de1dd8f5fdd6b62527aadd88260ecb8c380b
+dist/2025-12-11/rust-std-1.92.0-thumbv7neon-unknown-linux-gnueabihf.tar.gz=c9de934e22d796a4f542783d60b43b62a213a15014bbea02ca9f9520abfec872
-dist/2025-10-28/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=cf43ec766a353cad48150d47d108d8df4b1561101b2c95241b909d4a5ec47bce
+dist/2025-12-11/rust-std-1.92.0-thumbv7neon-unknown-linux-gnueabihf.tar.xz=08a51cb570fc25bf226c25c1031b98d3963a52e263bbacd873f111faa918484e
-dist/2025-10-28/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=3699e5b727abc016ab9fa78f40655ef7d88ff157e46759297cd80e5c169136f8
+dist/2025-12-11/rust-std-1.92.0-thumbv8m.base-none-eabi.tar.gz=06453a93570c63a0d6a56000493d4e6ff20f1e20c4c3b9ec7124359ebc79a3eb
-dist/2025-10-28/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=a6942c04a569f68cf1c5126e520400c51dfccd9e18a1d3941e28d7a8e63ae648
+dist/2025-12-11/rust-std-1.92.0-thumbv8m.base-none-eabi.tar.xz=3c5d71fa1d6f242be184339d8bbb360acf9ca552f0093c10309c83e06a95bcaf
-dist/2025-10-28/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=eb27f46d3ee51e4f71316a75087d4ca2493f55ed5e0b720f0dfa3564c8f19a67
+dist/2025-12-11/rust-std-1.92.0-thumbv8m.main-none-eabi.tar.gz=c3c0cde9afce994bfbd0f2fbde02efb6ad1238a3d33056ccac6e99aba579af3a
-dist/2025-10-28/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=f50b7fa2830844fd27041ced4c96eaa68ae6595b370eef1c958e3542c718d5aa
+dist/2025-12-11/rust-std-1.92.0-thumbv8m.main-none-eabi.tar.xz=61a6a80d03ebdb80ab06a044d4ec60e3c2bd8dc4d6011e920cf41592df4f0646
-dist/2025-10-28/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=398556eca8a50c1d905ef7e2bf3f25d75f8dcf1d9b679af87b565f5f58af5c2b
+dist/2025-12-11/rust-std-1.92.0-thumbv8m.main-none-eabihf.tar.gz=21336cc1a032eb35b8c4a546805ce1e8e3afa24735ee23aae5599fd8787ce581
-dist/2025-10-28/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=8dc4a5036cfda5725120a8d7e7d0cd05151230ed967ff77fa028c4b73dde6885
+dist/2025-12-11/rust-std-1.92.0-thumbv8m.main-none-eabihf.tar.xz=24c2f65371a2a5c6a40b51ae0e276ea9afff0479255f180f5e1549a0a4d58fb3
-dist/2025-10-28/rust-std-beta-wasm32-unknown-emscripten.tar.gz=212f761263b9a4c72a53aba0b76986f70b3d624557f34d36af2e7d935702359d
+dist/2025-12-11/rust-std-1.92.0-wasm32-unknown-emscripten.tar.gz=fec9cb6cced27592fa601c18afb357bb861d5ebeaad1dda9304f6acfd85b4000
-dist/2025-10-28/rust-std-beta-wasm32-unknown-emscripten.tar.xz=89c0dae14955afab89b8fa2892944325ff154987c863fd36f93089f29ef993b6
+dist/2025-12-11/rust-std-1.92.0-wasm32-unknown-emscripten.tar.xz=59b7adf18c0cc416a005fad7f704203b965905eb1c0ed9c556daa3c14048b9f4
-dist/2025-10-28/rust-std-beta-wasm32-unknown-unknown.tar.gz=92159d52588bb1ca6346025f894dce5520b42d89cb54a78a3ff42ee119c1e90b
+dist/2025-12-11/rust-std-1.92.0-wasm32-unknown-unknown.tar.gz=4763b575ecceab7637557527a91af6c5c36816a68e3f2de1e18518dd15a63bcd
-dist/2025-10-28/rust-std-beta-wasm32-unknown-unknown.tar.xz=a187e36833f587ad5f117b012a5d9ddacb3122b39b902bc2a9d9d03b5aba27a2
+dist/2025-12-11/rust-std-1.92.0-wasm32-unknown-unknown.tar.xz=6c73f053ccd6adc886f802270ba960fd854e5e1111e4b5cfb875f1fdcfc0eb60
-dist/2025-10-28/rust-std-beta-wasm32-wasip1.tar.gz=fa8971fcd7c22f5d382f4239fa8742238ec967f70fa40180ac9d8a39bffc28b3
+dist/2025-12-11/rust-std-1.92.0-wasm32-wasip1.tar.gz=a8736000e35213951e53315e3d5841cbe8e6c70fad167a302bd8ae1a43331cec
-dist/2025-10-28/rust-std-beta-wasm32-wasip1.tar.xz=0603acb7e6fa5540fb458cf363fe473889b0abba91ec0c124ce380ffb1869cbf
+dist/2025-12-11/rust-std-1.92.0-wasm32-wasip1.tar.xz=8107dc35f0b6b744d998e766351419b4e0d27cddd6456c461337753a25f29fcd
-dist/2025-10-28/rust-std-beta-wasm32-wasip1-threads.tar.gz=7651d409d4a89dab576cabf51cdd2947f877b77f09f668c6f9b8826dccd5c322
+dist/2025-12-11/rust-std-1.92.0-wasm32-wasip1-threads.tar.gz=87476037322f6bb9467467ce0b11bc2fe81d9fab181a14f6adbb949136f044d6
-dist/2025-10-28/rust-std-beta-wasm32-wasip1-threads.tar.xz=a6c3bc7f7f2e6a4cee6db2aa16f74af80cdd17ca92dcfcb1ab1e0c06bbaddd79
+dist/2025-12-11/rust-std-1.92.0-wasm32-wasip1-threads.tar.xz=feea056dd657a26560dfddfe4b53daeef3ded83c140b453b6dbdebaabd2a664c
-dist/2025-10-28/rust-std-beta-wasm32-wasip2.tar.gz=77537c7a4518e62cb592e5e9d41df02d1ec8a3038b87cdfe082c98ae578973d5
+dist/2025-12-11/rust-std-1.92.0-wasm32-wasip2.tar.gz=20b2ee79e2a66f80764f2829b9cd313bd66532fff85c71a75cd7d4f6f75decbf
-dist/2025-10-28/rust-std-beta-wasm32-wasip2.tar.xz=794a3c2e08edd74b7a004489017172c30a3242f7f0c5538c3b033937787da332
+dist/2025-12-11/rust-std-1.92.0-wasm32-wasip2.tar.xz=e69ce601b6b24eea08b0d9e1fb0d9bf2a4188b3109353b272be4d995f687c943
-dist/2025-10-28/rust-std-beta-wasm32v1-none.tar.gz=746ac6eb726ea2d2996b68be881d5c5fbeeba2bec1fbe57e6c315d4953cccba1
+dist/2025-12-11/rust-std-1.92.0-wasm32v1-none.tar.gz=b5d12a32aef0ce2be6999e7a15f21496e50fc9366e2dceb273e3816381821f73
-dist/2025-10-28/rust-std-beta-wasm32v1-none.tar.xz=8bdbcf0cc2b598cbb2098f113128e6f94085dfdaea3ed3d5e15cfd0a82262b56
+dist/2025-12-11/rust-std-1.92.0-wasm32v1-none.tar.xz=0b89f2b5a720589168a81e294fc80ab6bc2c7bbe5509030dd17ad38e221ce903
-dist/2025-10-28/rust-std-beta-x86_64-apple-darwin.tar.gz=2082bcdfd0e837163aec012cba1ae674825f52f5891c8cf3d4d00c619d5bd27b
+dist/2025-12-11/rust-std-1.92.0-x86_64-apple-darwin.tar.gz=1e5a8fee4e038ea2d35d82a680e2b9bf44ffccb3746aaf9dbdc56cb14152dcb8
-dist/2025-10-28/rust-std-beta-x86_64-apple-darwin.tar.xz=b2267e0df76f21bcfbb55ab323c58015501d3a3060c4127a005e29fa0e628a7b
+dist/2025-12-11/rust-std-1.92.0-x86_64-apple-darwin.tar.xz=6ce143bf9e83c71e200f4180e8774ab22c8c8c2351c88484b13ff13be82c8d57
-dist/2025-10-28/rust-std-beta-x86_64-apple-ios.tar.gz=6a48b60d0aa883ffad612a657d9de232ad1df92f937a5166532a7ee4e655fcc7
+dist/2025-12-11/rust-std-1.92.0-x86_64-apple-ios.tar.gz=4ca50621893f34bde5ad81cd82006c8b271fef8cc0ba4a4e1418fe3dbf599e56
-dist/2025-10-28/rust-std-beta-x86_64-apple-ios.tar.xz=81ee2cdad7fd25b56be24d919268d0dc61c1d44d50bccb4c1811e30e85b97869
+dist/2025-12-11/rust-std-1.92.0-x86_64-apple-ios.tar.xz=b6e38e5f8c9e6fb294681a7951301856b8f9424af4589e14493c0c939338814c
-dist/2025-10-28/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=01d5952f0970508064fa24196e126cb09aca5085ad6258c53397c3b23b006217
+dist/2025-12-11/rust-std-1.92.0-x86_64-apple-ios-macabi.tar.gz=14e6389c01ab709dbf62885639b8c3e6fc97e6d8fa91f9805db26e9309107ec2
-dist/2025-10-28/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=3c10717be0087060ffb0e5b83c86ce69bff8b0dee9dee95b1be6a44f4238b5c5
+dist/2025-12-11/rust-std-1.92.0-x86_64-apple-ios-macabi.tar.xz=6a292d774653f2deaac743060ec68bfd5d7ff01d9b364e1a7d1e57a679650b47
-dist/2025-10-28/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=ce87a282ea73eb83015a321b208abfa9d4afdf4a797c799d9efeb1a246e4a64d
+dist/2025-12-11/rust-std-1.92.0-x86_64-fortanix-unknown-sgx.tar.gz=88fc95491ec06d98bde84ccf4b6a4cc63aa0a6d3e66e0d796de158afb7d69c67
-dist/2025-10-28/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=5c8866ec1cb4ec7826a94510c00f5cbc7f31822dd7e01ec2fe6b781b25e2afa8
+dist/2025-12-11/rust-std-1.92.0-x86_64-fortanix-unknown-sgx.tar.xz=b0339c3bf7966e7b1c9892f855c85d123382632f49a1d1f589db68bf0908feb7
-dist/2025-10-28/rust-std-beta-x86_64-linux-android.tar.gz=19538e0dd74d638b3ac1ac9ed679b8ebc6c058f661d7f167f957eb0866f7cb65
+dist/2025-12-11/rust-std-1.92.0-x86_64-linux-android.tar.gz=b9074f6961baff09334afaff745fb16dbf9f05cdf856b17309d8e6232a281c40
-dist/2025-10-28/rust-std-beta-x86_64-linux-android.tar.xz=15554ba8cc8d1d1c4c46e0438503170aff5a5519eb8bedef07a32d187ca32915
+dist/2025-12-11/rust-std-1.92.0-x86_64-linux-android.tar.xz=ffd39429435ff2f0763b940dd6afb4b9ccb1ed443eeef4fff9f1e9b3c5730026
-dist/2025-10-28/rust-std-beta-x86_64-pc-solaris.tar.gz=41a6db659dff188414e33595448dc9c2b99103dbbdedab53d74c6aeccbb76458
+dist/2025-12-11/rust-std-1.92.0-x86_64-pc-solaris.tar.gz=28f7f5568399c56e64f614194dc70f7073c0e394c5ad60bcb85dc1b1018c6089
-dist/2025-10-28/rust-std-beta-x86_64-pc-solaris.tar.xz=2bbcb13b8271c39a48ac2774e7444fdce883a283622400085623c161f8be405d
+dist/2025-12-11/rust-std-1.92.0-x86_64-pc-solaris.tar.xz=776ceb389296b22a74bd7631f4440b965504d1687448030d2d51c853fe4598a5
-dist/2025-10-28/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=e2390bf5da8a91f056df7133020d053d5d90c84c81763738efe8a862864318ae
+dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-gnu.tar.gz=6256f3497e3b14b6650511e84fdfb51fc632db1908ae5a173dffcdc96c80b7ce
-dist/2025-10-28/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=5d6fb692f2a1d2bad7b550b79e1288223ec598a46975848d07f2a5105b36cb4d
+dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-gnu.tar.xz=d4043304ef0e4792fb79a1153cbeca41308aac37cb1af3aa6bc3f0bb6d2276e1
-dist/2025-10-28/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=30c66f64c7343388f3205e172e64e51dc2930214fae46eb3b21648285092c944
+dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-gnullvm.tar.gz=67bd7e328b9579c01365c01f58e29fa616806444eafb9b8bfead0de2b57fcf32
-dist/2025-10-28/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=25788901f6fc13a4963bba4e985d619e0739b1239a5679406229a2bd5eaafbaa
+dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-gnullvm.tar.xz=6169605b3073a7c2d6960bc1c74cb9cd6b65f45ee34e7ede02368e07ce4564cf
-dist/2025-10-28/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=9fab4a6cc38c2f06113ae9f0620e40ff5e9134f83562c32576c1e82048ad3bc8
+dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-msvc.tar.gz=3af377fb29083c2117e85e6a107aedb008bd76929c22d56ce45c5be1be3a2540
-dist/2025-10-28/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=1b7007f9bc3619cfba09bfa92c3b1e5460316501fee4ae7c8492703a79517f4a
+dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-msvc.tar.xz=b4e53a9c9b96a1a0618364791b7728a1c8978101ec6d1ee78fe930e1ef061994
-dist/2025-10-28/rust-std-beta-x86_64-unknown-freebsd.tar.gz=461036ed77e332851e88fb6f0f5c64068aef0b177b27662f326d157c06c7115a
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-freebsd.tar.gz=3616afb808cd030e65e66c51f6f0fb6a6fc52d877d0d70bb681b0c35238adbe8
-dist/2025-10-28/rust-std-beta-x86_64-unknown-freebsd.tar.xz=fd7c7b75a50833650f131a6a676df90dcd57c4784654aee12ce594846da1c219
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-freebsd.tar.xz=151929a4255175d14b2cbcb69ef46d9217add23be268b9cd1446f8eab16616f2
-dist/2025-10-28/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=882fe895b376384d9b1b1d9c01d9b641ab56b1405d63d7a83266f228b4b759d7
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-fuchsia.tar.gz=8b895dc4bbd95481cd171a6de01a0b74248fbd3f55bafec8dc0360e110946836
-dist/2025-10-28/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=e9d1fdbd0ba327b6d4e618622c0336eb6895e0e188005423710d514e145baac7
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-fuchsia.tar.xz=51ec26391d166e2f190a329919e3c7bd793861f02284aba461a086268725d9f1
-dist/2025-10-28/rust-std-beta-x86_64-unknown-illumos.tar.gz=aade9f95b362cf13ee48e1d7608eb8487229cf86cc72082afe21fef533e45f5d
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-illumos.tar.gz=a197e02ac48cdacfdb7487f612818b23c461c52e7e6015737a6b0a1cc2a744c5
-dist/2025-10-28/rust-std-beta-x86_64-unknown-illumos.tar.xz=de92c9cf00a2413d5481e96e1db5157c5cb3814851951076e4881b9269651cb9
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-illumos.tar.xz=31c6f2296543e684554b9eb4ac34551270a0a9c7d0cbc96986cf15a301e27035
-dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=04f6feb37de8305d17e7aacc6174395bd55447340963303767c5a66a63200149
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-gnu.tar.gz=ba4e0b4a60c082e0b1cc6284a38bb144844c92f1aab09732cd1183658e08a6e7
-dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=2838910a0ef0084245a69fefdc67845ea579f49629cd24fa051b4db0bdc76d98
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-gnu.tar.xz=5f106805ed86ebf8df287039e53a45cf974391ef4d088c2760776b05b8e48b5d
-dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=d2f88d608fdccd0aecbcd83cc184d157d93159e29ad525583188013f327572d1
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-gnux32.tar.gz=8b9c9330278a97b79f3783dbacaaf4c0d110bb608cd1c615bb931b340ca6b27f
-dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=b5e7ae18377727f93fece51d9ee5704ffd5a9ccd00c540b38ebbf3b9155cf20a
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-gnux32.tar.xz=f29c2380d21edbd0cd9f674a2915ccc95822c9ecdae3b2e823f066de32760bb9
-dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=40a52cf3527090a12095b0ed4ad8d35fa5e3cef39146a9a8bff9009cf5772dc1
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-musl.tar.gz=8bfd9a42c8295949d556587201acdb35d2bfb8b7ce55223845f337aa5614f9a3
-dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=28be865d06f9bd744aaad2e82ab8bdb87045e6e2d7ee6fceef2024fa620ba920
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-musl.tar.xz=11f0b7efccdb5e7972e3c0fc23693a487abc28b624675c08161d055a016d527e
-dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=e0afdd5422adac97fe8c6943470a8561847a614d3e367cb983f28250c0e2e34c
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-ohos.tar.gz=61dfeaf174eabc9152fff91b9de705539e76f623f37606ac878564fef79fb4fc
-dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=3007d13a0640d915eca622260c6b8b6a8936788a1228011b90df817b6888155c
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-ohos.tar.xz=a5d6c40e3e712d9d7ffcc3d3895e53dad19bcba792ad6b6945a60304bdb82be1
-dist/2025-10-28/rust-std-beta-x86_64-unknown-netbsd.tar.gz=1744c2485854792601518dcf7855d4223db63e9f3693e2d06c1ac285b92ba33b
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-netbsd.tar.gz=1048621ad4bcd2c629882e74f9439d8b0508e6eb4ce5fee5dab0ffd6a5988261
-dist/2025-10-28/rust-std-beta-x86_64-unknown-netbsd.tar.xz=757803d3cfb8db12dd7c9528852c1e28fb3a9ba97e4230d1e29dbf1834cf3f84
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-netbsd.tar.xz=db6a8d3a091551701b12e40cc58d4a541adfb63f250074aae90d250329beb8de
-dist/2025-10-28/rust-std-beta-x86_64-unknown-none.tar.gz=21d5de489cc22d849f246225909278f123483a446e1a3c68b14b8b992c104082
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-none.tar.gz=a912deaa2ceff2042cb67a12e82b9212c849c1bc0321aea639f2ec432d13f9d2
-dist/2025-10-28/rust-std-beta-x86_64-unknown-none.tar.xz=62755ecf24c0a2423b4d05c09ec8e8d38737e6762312d1ba993e1a9417083ba9
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-none.tar.xz=1d8420ab8eb241a35e38b76470277c722bd5a7aa4ac0c7a565ad6f30b37cb852
-dist/2025-10-28/rust-std-beta-x86_64-unknown-redox.tar.gz=0339d37d857f7f5ecb1607e8c53c499623f0c3563e3b68f2b939ee960d31b270
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-redox.tar.gz=c5a5c0dc2ca2eec79b78d9efa4af92815a3b0aefdb4009fb523b9d2a989d55de
-dist/2025-10-28/rust-std-beta-x86_64-unknown-redox.tar.xz=613b5ca94e5c33c46d9f29cb557d1e512abd1104c5d81f1897915f6153175cc5
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-redox.tar.xz=c5c1466da81956d483fe673c604e7c66f5d16e44752d39c79fab45906738b178
-dist/2025-10-28/rust-std-beta-x86_64-unknown-uefi.tar.gz=1da6167f0a2652b1622cae5ac815d55e307dbd639e4901005a3b225150dcafa7
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-uefi.tar.gz=89a5e952221daa4cdbd4d033bb33a18855e1f3428a022af31843391af6cda8dc
-dist/2025-10-28/rust-std-beta-x86_64-unknown-uefi.tar.xz=6fca79a15c1ef9f8a3974f84af805106ab453099bdb6f652f584abcd7c8174be
+dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-uefi.tar.xz=1b849250cf095269f3a2c7bc2087a919386da7da28e80dc289e6268bc705142d
-dist/2025-10-28/cargo-beta-aarch64-apple-darwin.tar.gz=e66d076303fe8010c27fdbf8a9e31f47223508a280cd2ffcfea698aede848986
+dist/2025-12-11/cargo-1.92.0-aarch64-apple-darwin.tar.gz=5295d590590a606d98e3f97b730fe3b4e8d96a0c78e5268232b15b3c45180d28
-dist/2025-10-28/cargo-beta-aarch64-apple-darwin.tar.xz=f4e87741a4070fe5bc4ad59ecfd324785cd9a477c539543d6a4fc1675afa8111
+dist/2025-12-11/cargo-1.92.0-aarch64-apple-darwin.tar.xz=bce6e7def37240c5a63115828017a9fc0ebcb31e64115382f5943b62b71aa34a
-dist/2025-10-28/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=5e9213968960bab07ad28408563b46d01c1d881c26ccd07651bdb527440461cb
+dist/2025-12-11/cargo-1.92.0-aarch64-pc-windows-gnullvm.tar.gz=77567d78fd5d8ae368a21682172aa929cb6b293dd03d234b01fb0e014b14c29c
-dist/2025-10-28/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=ec01099da59fab595f8ed8a2f6fb308fbaaabf563cf50c103d47fad4595d72ec
+dist/2025-12-11/cargo-1.92.0-aarch64-pc-windows-gnullvm.tar.xz=56d38a6a89e2a38ec777938d74feb93a3498bc8788df96a94fcb4eac2e07338b
-dist/2025-10-28/cargo-beta-aarch64-pc-windows-msvc.tar.gz=ed3cd99db73648bb87c5a25556da30993346f1acc665f9dc906094639370282a
+dist/2025-12-11/cargo-1.92.0-aarch64-pc-windows-msvc.tar.gz=c283f18461a840191b2e03d19a8ac0e6441646b668a94a03a3e76e11b75296fb
-dist/2025-10-28/cargo-beta-aarch64-pc-windows-msvc.tar.xz=c5f89cae65188a7d1b5b5a93f8645774f878db6a14032abb8fd960fa9f4cdb06
+dist/2025-12-11/cargo-1.92.0-aarch64-pc-windows-msvc.tar.xz=3fc47cc29781190c5075f807836c4b98d411aaf27c59598fbfb2aa781ccf6190
-dist/2025-10-28/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=2c85f1c5b1a8bb9532194a16ceb8b04f1586d0ade14442f45e740f3e85022924
+dist/2025-12-11/cargo-1.92.0-aarch64-unknown-linux-gnu.tar.gz=f0bc99a9990f722c3c795bd778cae6aa7927a9907100698a1eed272beb4bef20
-dist/2025-10-28/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=a675601cf6552783625b79c33c1d42715c3918a08078e6eed01236910bafc4b4
+dist/2025-12-11/cargo-1.92.0-aarch64-unknown-linux-gnu.tar.xz=cb2ce6be6411b986e25c71ad8a813f9dfbe3461738136fd684e3644f8dd75df4
-dist/2025-10-28/cargo-beta-aarch64-unknown-linux-musl.tar.gz=e5f2cc9f31b927e2e02117c38a5822c39993242459a057c48e7e11695dabe5a5
+dist/2025-12-11/cargo-1.92.0-aarch64-unknown-linux-musl.tar.gz=92287147c07b5b31b69b355eb8040f4d3cb22cede8418ee77f806a93e90cc005
-dist/2025-10-28/cargo-beta-aarch64-unknown-linux-musl.tar.xz=1830b8b7e43fc03f0348503ae036b30d0e906cb024bc2257e717a58df95ac222
+dist/2025-12-11/cargo-1.92.0-aarch64-unknown-linux-musl.tar.xz=492614aa4fab1d58cdf495ab040426174e740038f715145bbbce7a87716a4c8b
-dist/2025-10-28/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=eef6f553184a8177525a1ee932d6e293f42eaed6986c1c83f7d76d579f02b867
+dist/2025-12-11/cargo-1.92.0-arm-unknown-linux-gnueabi.tar.gz=09dc930cf59637c3bd48ff5bc0b53200949e5194e39fbba374f139a7a03f69a8
-dist/2025-10-28/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=13c81e5874532e490c987dbc46b19cf3a7eac14fefdffc30d0c5493a84f8a257
+dist/2025-12-11/cargo-1.92.0-arm-unknown-linux-gnueabi.tar.xz=d09d3e8402f868b784aa17f2e8268de91d8f4634c34bfb5be65596abc6043d35
-dist/2025-10-28/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=56d7f1b41af4d72091c8a99b9a583f24d5aa3912f6dfcbfeeae4eb47bfbf158e
+dist/2025-12-11/cargo-1.92.0-arm-unknown-linux-gnueabihf.tar.gz=401b054bc35f33835e6234352b519858ca9fe009bd01b85766dbcacce986dc48
-dist/2025-10-28/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=010292117dca5b10b71b7aabe38d1e8c2f0180ab54e9bf072a9ca8bab3f40ced
+dist/2025-12-11/cargo-1.92.0-arm-unknown-linux-gnueabihf.tar.xz=dbeb44e4924218afc7c57db5f7a48058fe0bd0653c292fab5cc4a8b9016b2096
-dist/2025-10-28/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=91671bdd6438df48e4c529e5897afe57b91e8575c12d40c3cb3280493599c0d9
+dist/2025-12-11/cargo-1.92.0-armv7-unknown-linux-gnueabihf.tar.gz=861561f65347eb9020cb93daa51eb43592f994dca7c392a3e8d9771ab797435a
-dist/2025-10-28/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=0da8474db35ef547b28f123e8c98ec84dcc4a4a5c4a487a222ac006e809ceb80
+dist/2025-12-11/cargo-1.92.0-armv7-unknown-linux-gnueabihf.tar.xz=713f7d2ca8776ce537c0a5e716f7bdf644d54949c78c0a98ca4113f80bd670e7
-dist/2025-10-28/cargo-beta-i686-pc-windows-gnu.tar.gz=5d9ce7ba82e8d694e53ac877214c0873b0dd78a60c8eabcfe9128433d199d12e
+dist/2025-12-11/cargo-1.92.0-i686-pc-windows-gnu.tar.gz=c7f394ac5eb52bb9790feedbc2a22bbf5770c614f94ac899004e895580fe8955
-dist/2025-10-28/cargo-beta-i686-pc-windows-gnu.tar.xz=209100fad49e274457d8299360a4c2e83803411a69fec69898a03d9a2bdee955
+dist/2025-12-11/cargo-1.92.0-i686-pc-windows-gnu.tar.xz=8b6368d75f20c3cdfbb0c03f2cd7c386b9224bbf3717fbd635fff6ace0260660
-dist/2025-10-28/cargo-beta-i686-pc-windows-msvc.tar.gz=edca4ca03b055b40d0c4778e325b93e3759123f207a6d32d7ff42cfa0f323604
+dist/2025-12-11/cargo-1.92.0-i686-pc-windows-msvc.tar.gz=25035fc699d3d907e0ac3c77ee4b524455b29d762b98951dd4f8084c64d0c416
-dist/2025-10-28/cargo-beta-i686-pc-windows-msvc.tar.xz=5146440d030e04450de61bd6022cd7ad6364fd06f9cec28bbb7889bad171e579
+dist/2025-12-11/cargo-1.92.0-i686-pc-windows-msvc.tar.xz=a734070e84d1d9124bd0f4157eadf66c5b2030e49162f209ad0a0ebf895333ff
-dist/2025-10-28/cargo-beta-i686-unknown-linux-gnu.tar.gz=d1045ab266d914060e24224b0e74ea865f4bf4cd527d9a09c5631441c40f48a3
+dist/2025-12-11/cargo-1.92.0-i686-unknown-linux-gnu.tar.gz=f95a54f1aabc6b4611d80f2bd5dda8f27719266f7cd829c5b9c2edcbf190a42c
-dist/2025-10-28/cargo-beta-i686-unknown-linux-gnu.tar.xz=caed7a0786cc9f476d1b9fb5367c67a02397ccb12ed18a357b5ed04fe77fb12f
+dist/2025-12-11/cargo-1.92.0-i686-unknown-linux-gnu.tar.xz=63001bbde1c036fae9ad624807bfb18117c7e7cb4a04de81adc4acc7e8580c07
-dist/2025-10-28/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=017335d6ca97cbe4bf93e2ffb4def850b05a8efa0367b008de4cc8b55f1af3cf
+dist/2025-12-11/cargo-1.92.0-loongarch64-unknown-linux-gnu.tar.gz=572a85632fcf90dd9fa359dd6eaed16266b75eaccc7d47e2c6974a01b0139b27
-dist/2025-10-28/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=f5671ec0dee9841d4a482183f56ccb986f358a80d043d1ec4b05bc8a356f8ad7
+dist/2025-12-11/cargo-1.92.0-loongarch64-unknown-linux-gnu.tar.xz=32f4b393f1471d7d50c9a50512f02116187b3ea6a885c26ff2d74f87fa72baa8
-dist/2025-10-28/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=0a280ebc1b5aab8452f1445fe858ad4808fd7035dd498510951d8b7caa13edc8
+dist/2025-12-11/cargo-1.92.0-loongarch64-unknown-linux-musl.tar.gz=0a02be499899e8a59fdf97e08bd1c2eaeb2bcb1328e230d8966eb1c0c0fc736e
-dist/2025-10-28/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=8ab41df2264470d6ed0a6d82b665992f76f9065046a153bc8ee1eda9ca81eaae
+dist/2025-12-11/cargo-1.92.0-loongarch64-unknown-linux-musl.tar.xz=edf8ae60bbe7821dfd02434951cca3b8c3ea63dc075b8a425ca45ac84da5796e
-dist/2025-10-28/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=7368d0d297fa06108271b03138a9dda0cfbdbe5463a614ebf6fb5b573dde08d7
+dist/2025-12-11/cargo-1.92.0-powerpc-unknown-linux-gnu.tar.gz=f33e2312126f52f0da9e5073b4311e9cad114228607e0fb5c3ae51b3add2a624
-dist/2025-10-28/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=1ad0b7d4e3173150768db7105b1a691e8c85db3e9c6a391390e2f5df7844d420
+dist/2025-12-11/cargo-1.92.0-powerpc-unknown-linux-gnu.tar.xz=1249c64f95d8187b3a89cf8429329bdbc98f53a9fc538e898c95c487e3234d90
-dist/2025-10-28/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=75740d0b1847f73777894f484e085f70f24d981b0ef69d00cb5b0c29d276c5b5
+dist/2025-12-11/cargo-1.92.0-powerpc64-unknown-linux-gnu.tar.gz=414cfee5d5c39b757fb4bead92af90018601f8e40a447c2d2ee172a235605ecb
-dist/2025-10-28/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=1ca71e60a6fa9752dd27bfe4f354a1b732b67e55c9e645021e6041a2450b7994
+dist/2025-12-11/cargo-1.92.0-powerpc64-unknown-linux-gnu.tar.xz=e94a8f97c3143158e285b4f8ade1fae844961caca30c0eeed44f6c14da484f05
-dist/2025-10-28/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=ab37e6d39ccb7fe33c55bf62836c2174f1a4197f02cbe9d88d118b81ec6d49e2
+dist/2025-12-11/cargo-1.92.0-powerpc64le-unknown-linux-gnu.tar.gz=69f56f4df9722d1a50273a69d32ed4593e84ec81f61ec949e58684e2ab1fac5c
-dist/2025-10-28/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=77cc38c5b89fc65fb7453dcc3c3212e0a512923497420b7782ffbfd88f00b39f
+dist/2025-12-11/cargo-1.92.0-powerpc64le-unknown-linux-gnu.tar.xz=49dd01f5d10e3f368181223db0fbf7dc191161f7d80a295de4909bf87e53da58
-dist/2025-10-28/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=29a2dd23fe30b2d1741e1d4032d4250b4f7f0e2af5ae718b309f2d271e13ef41
+dist/2025-12-11/cargo-1.92.0-powerpc64le-unknown-linux-musl.tar.gz=37a3d27d185abf8e3af51912f5f28b6acbd768445d1ca78e97acab5de4741b8a
-dist/2025-10-28/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=bac42c5d4af02abbb4db1a9dd4664340d686e4c23f923f372d3b08e090bd105c
+dist/2025-12-11/cargo-1.92.0-powerpc64le-unknown-linux-musl.tar.xz=0f64d4df6bfad74ac9a60dfccf0c574ef56cd092d3207931b100e9b9130f7640
-dist/2025-10-28/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=3b396bf0ddede9f4964bc9fb27b52e628db1d9ccc38dbc5d5e06c316ba8bef87
+dist/2025-12-11/cargo-1.92.0-riscv64gc-unknown-linux-gnu.tar.gz=6e6e42f0fbe0d0f8aca38946b3884b8d0cde6513ffe59fe9c2bcccd89d40f0e4
-dist/2025-10-28/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=e706521e4496c79bb677d7d06d79fc1ae2770cdba4a81d8c28ede81ab4ee7909
+dist/2025-12-11/cargo-1.92.0-riscv64gc-unknown-linux-gnu.tar.xz=e8708d0a929ad15941ecde368e8a156911927a805b492afafc737124b6aa55d4
-dist/2025-10-28/cargo-beta-s390x-unknown-linux-gnu.tar.gz=2fa6ecf04d1cb20dde5f700a0e425ea186d628c5704885e84e197e4494af101f
+dist/2025-12-11/cargo-1.92.0-s390x-unknown-linux-gnu.tar.gz=8efdf1355d3eb6107854dcd3ab5b4396bed7b09910099dc791633740859cf5f2
-dist/2025-10-28/cargo-beta-s390x-unknown-linux-gnu.tar.xz=e8810699e679fd0306d4e6c95608970ec5a1d1ccffcdd707fe4a4508518a0e6d
+dist/2025-12-11/cargo-1.92.0-s390x-unknown-linux-gnu.tar.xz=a290edf359a5632dfda3b2325a309d9edeb58c97de97e3cc67274335b58adf05
-dist/2025-10-28/cargo-beta-sparcv9-sun-solaris.tar.gz=2fcae7eb2f538d84545944c744bbac39e28b3bd58e8d2bdc862d5f66df7068e7
+dist/2025-12-11/cargo-1.92.0-sparcv9-sun-solaris.tar.gz=535bf08187504fc5b157be2443973310e94ce75ab029ccf54f39f59b0f2d4c88
-dist/2025-10-28/cargo-beta-sparcv9-sun-solaris.tar.xz=2fe42f27469fdc23a9e45ec025c60a09f00be07a239cd8c8df74ce52e94b4cab
+dist/2025-12-11/cargo-1.92.0-sparcv9-sun-solaris.tar.xz=a0749eb1c52b8b6488fa0515ce0ae945f5a8dee331762334e1462776dfa0ec96
-dist/2025-10-28/cargo-beta-x86_64-apple-darwin.tar.gz=c92c1a580eb85d96f973df4dd9cf4440eb661f8fab9c632b5f0621cf0839badc
+dist/2025-12-11/cargo-1.92.0-x86_64-apple-darwin.tar.gz=3423880db7c38ba0259dbe8106039ad9cfb650c65b7bf311a33addd05aec3cb5
-dist/2025-10-28/cargo-beta-x86_64-apple-darwin.tar.xz=6c2b13253e1066e49fc52f3cb1654776d5d38853a15e8022652b4a2cb6845daa
+dist/2025-12-11/cargo-1.92.0-x86_64-apple-darwin.tar.xz=b033a7c33aba8af947c9d0ab2785f9696347cded228ffe731897f1c627466262
-dist/2025-10-28/cargo-beta-x86_64-pc-solaris.tar.gz=ca98af5dcaae734ccc02fde2807dca8d95947918eb753d407c12dd05ae937568
+dist/2025-12-11/cargo-1.92.0-x86_64-pc-solaris.tar.gz=6f6f2a5b13fdde3ebcdb4e3f9a0a62104616940400bad050d27dec9c9cb00b25
-dist/2025-10-28/cargo-beta-x86_64-pc-solaris.tar.xz=864ed5842890359e9f767b4050b8a27ec9c27c88a8cef20993b8f775c213d394
+dist/2025-12-11/cargo-1.92.0-x86_64-pc-solaris.tar.xz=cbfc3e9543990f65dff8c76f0cc87b22b15f5ed6777cfb71b7eb7ea634a4d27f
-dist/2025-10-28/cargo-beta-x86_64-pc-windows-gnu.tar.gz=ec8a9e8436f83388736f16f7ad9962a1d9b72673c3da56b8233a6b39dde54534
+dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-gnu.tar.gz=e2c59ffc93e18049f0ee829e6a9b768aa97a7aee480a28576cf786fd4aeb95dd
-dist/2025-10-28/cargo-beta-x86_64-pc-windows-gnu.tar.xz=1f059aae8e6faedcc56663d833a07417e07eededdc2776b2762822987a010131
+dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-gnu.tar.xz=962e0350346b417719cc36db333424a03e368d602fb411676c901f15487ea29c
-dist/2025-10-28/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=f364bf2f20f35c7ff0381cbd34c88a256849a1b9a27267436e14bc01b7bacfbd
+dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-gnullvm.tar.gz=8c5de85558085a3e0f3b3280865236d3ea6d06c6e39fc458318c6b4becb7ad7f
-dist/2025-10-28/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=451f18d049f1c47bfa0c010481e499afa1baaffb889de11534cf451578c62f76
+dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-gnullvm.tar.xz=c27d5936e1c11feb33f3221b85741c33f783c8723fca84552e7c2a5a73959352
-dist/2025-10-28/cargo-beta-x86_64-pc-windows-msvc.tar.gz=96ca48b12b27b8e933cbb426e7123873a1120bd884a62d150aceb6a26bfc7694
+dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-msvc.tar.gz=9f6178ddcaed7c9190c454db5da801e2fe6c8fde8600258a9bdd0e107e81ac3b
-dist/2025-10-28/cargo-beta-x86_64-pc-windows-msvc.tar.xz=dfe14d019f5c1744a312da8d926059147974de0b5bcdcd869526b5257a1112b3
+dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-msvc.tar.xz=f4057534ec58708ed3554957582a6c8e8c6abfee011b5c8ad45c3ab27c0b3076
-dist/2025-10-28/cargo-beta-x86_64-unknown-freebsd.tar.gz=7ef3d3edb6b536382f5063a5de5aaf036d6ba09bf7bd1ff770b87d8942110c2a
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-freebsd.tar.gz=a43043c5bbc907260594d542ea0dd17630d432024dd0af0b90c99b7397227f9e
-dist/2025-10-28/cargo-beta-x86_64-unknown-freebsd.tar.xz=beb5587235e8ff471a8eb9fd84ae5cf4380e7ec9b00ab03dc0c549be0e661dd0
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-freebsd.tar.xz=7bf1853c6ac4b426d7b4b67ee4ecf60f4a3e83151147a13b4cf04f81ccff3c4b
-dist/2025-10-28/cargo-beta-x86_64-unknown-illumos.tar.gz=b97f511486ad044dae0c8b50df8430e489887ac36b770155f163d8e4216cd9c9
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-illumos.tar.gz=4c679e0c8c18649ca280096b1d6b7856a26540a6ac37e4fca371576c1dc0811e
-dist/2025-10-28/cargo-beta-x86_64-unknown-illumos.tar.xz=21fc84a42fa988632fb9b0d9dccdf6ab2fbbd06a6780076282fc9bea56567559
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-illumos.tar.xz=a620fd5c893261ac0f9b59dfe6062f4a8e1eaf517b8116b64d3c0925dc1a5d1d
-dist/2025-10-28/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=d5b05dc398716909df77415b4a68233b68a5d578855e0e91dcf423f2985fc1cd
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-linux-gnu.tar.gz=2aa2b1c1df189d346f3937b4887c901b737df2663a667de17beb8f1098442bb9
-dist/2025-10-28/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=21e79bba772e93a6fd910e9d6ee833b55a53b80088f8280525717a4cd800c21b
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-linux-gnu.tar.xz=e5e12be2c7126a7036c8adf573078a28b92611f5767cc9bd0a6f7c83081df103
-dist/2025-10-28/cargo-beta-x86_64-unknown-linux-musl.tar.gz=4d126f2591652ddea26884973c1ae1f1e25246cc5f60baeb3a52d6ff45a1aa15
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-linux-musl.tar.gz=df116b5f1400daffd0074125e6c7cb98e5763ae9aefe341e3605b623042b7b11
-dist/2025-10-28/cargo-beta-x86_64-unknown-linux-musl.tar.xz=62113a7383f7ff8a9bee099155ca55c3c69d16bf135fc06046f672b2102deafa
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-linux-musl.tar.xz=b37ef0ce8c49103a904559f17c83c6e5a182f0f165f158e7be00e9036ca8c6d5
-dist/2025-10-28/cargo-beta-x86_64-unknown-netbsd.tar.gz=e9a07f035f308d4b9cf5f1b0ab4ef969cad1c41528adea2fca81d8dfe45ebff0
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-netbsd.tar.gz=e6ddc2363ad9073d101368110eeedb2bd91fa7a318f3823295edab3bc191747a
-dist/2025-10-28/cargo-beta-x86_64-unknown-netbsd.tar.xz=3f3d87269072d8e219e7213ca878a7fd441aaf74e4d052ca44ccc7ad75e83eee
+dist/2025-12-11/cargo-1.92.0-x86_64-unknown-netbsd.tar.xz=19065f32ac1edae4f000695d3814b5b1ae2649e218304d223e8af1634f465b37
-dist/2025-10-28/clippy-beta-aarch64-apple-darwin.tar.gz=a44daddb30309be19856b9572679569ffc2ab2c30318706ad59aa2dc14887587
+dist/2025-12-11/clippy-1.92.0-aarch64-apple-darwin.tar.gz=02cb1fb33fead2b4378c37db711fda2945b7487ccc462ee1abeeb3a4ffcff312
-dist/2025-10-28/clippy-beta-aarch64-apple-darwin.tar.xz=00576ad0f30db5be96e6434e22a2fcdd167067d65ab85199df06a6d11d1ef6c0
+dist/2025-12-11/clippy-1.92.0-aarch64-apple-darwin.tar.xz=08c65b6cf8faae3861706f8c97acf2aa6b784ed9455354c3b13495a7cfe5cb84
-dist/2025-10-28/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=24fb3dc6680e845c84e535f9c14be5e3d4052ef3ccc800e0fd81815edccb4836
+dist/2025-12-11/clippy-1.92.0-aarch64-pc-windows-gnullvm.tar.gz=8a7fcc3e006b5fe1160011f692adec30a8c772585572541c52fc5647b9ec74d4
-dist/2025-10-28/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=20d2ebdb6e2a902eb74ad502a14a2a66e6a9316d5f94513ec9781d146c323d9d
+dist/2025-12-11/clippy-1.92.0-aarch64-pc-windows-gnullvm.tar.xz=ea3e63c684273f629f918e8f50d510225c48a35ec28eaf026fa68c27f273bbd6
-dist/2025-10-28/clippy-beta-aarch64-pc-windows-msvc.tar.gz=652e5bdffbb89ba281cbd5efe3a2cf103adea6af7ba56a21cb6bb538a2ea6536
+dist/2025-12-11/clippy-1.92.0-aarch64-pc-windows-msvc.tar.gz=4fa5ed26256ad52a5f5f2039c3b2fa008ee890a6c366153806368c912d74b0db
-dist/2025-10-28/clippy-beta-aarch64-pc-windows-msvc.tar.xz=59d0fb72db77c484571ebab8c992303659225735d3f820ed7048122d8f96d764
+dist/2025-12-11/clippy-1.92.0-aarch64-pc-windows-msvc.tar.xz=2aa2f1288072ea1f870d6d860d09f5911c1305d506f344b65cf5e27b5070e262
-dist/2025-10-28/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=6bf6fb7279ecf5df6edca6014db5f8ba0427fd8cd32f073630b6b02e2e69feaf
+dist/2025-12-11/clippy-1.92.0-aarch64-unknown-linux-gnu.tar.gz=37c0bc5ea8a2421d2353bbb871620617ac5de0c3aaa7548a0952d0d64d551222
-dist/2025-10-28/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=0a8d19bca62dc38e64cf527b239106901fa2e0642ca5c2ef1cde070faaa901b0
+dist/2025-12-11/clippy-1.92.0-aarch64-unknown-linux-gnu.tar.xz=333ab38c673b589468b8293b525e5704fb52515d9d516ee28d3d34dd5a63d3c3
-dist/2025-10-28/clippy-beta-aarch64-unknown-linux-musl.tar.gz=663581dbd93b22b3b20d281486c8dc0580e43ceca42d9455d78f2d2c341cc758
+dist/2025-12-11/clippy-1.92.0-aarch64-unknown-linux-musl.tar.gz=8e7a88b0bee51760b9c416dce4a0b355a74cf8681de115ef55bee14a6bf9ba46
-dist/2025-10-28/clippy-beta-aarch64-unknown-linux-musl.tar.xz=49548d8ee0561ab96629e354ad055ed5f0c6f3f60c1559ca2a27352b441ff848
+dist/2025-12-11/clippy-1.92.0-aarch64-unknown-linux-musl.tar.xz=8aecf9e71c9a8b349587e5c0c69dc91e373264ffc55d946a00ab8f9aff072e64
-dist/2025-10-28/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=b3d44866b1f909576e0e586aa34b480f1170aa3eba28209ac5bcb929f544d07c
+dist/2025-12-11/clippy-1.92.0-arm-unknown-linux-gnueabi.tar.gz=39ce64be0c9878f2fd20f9bdda70f6cdf7bfc5928986c65719d93580cd784a11
-dist/2025-10-28/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=717397166acd760e391c251b1c308657f45deadd928035d2860c772c8b377b91
+dist/2025-12-11/clippy-1.92.0-arm-unknown-linux-gnueabi.tar.xz=957d0c8bb77f6589d579d6133e98aaf351dfbbcec3ef1603659a90d9d7c2ce41
-dist/2025-10-28/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=8911fa3347ca26a2afed6140bc4cafa629830740b8e4ff5e648c517f6ea43c6b
+dist/2025-12-11/clippy-1.92.0-arm-unknown-linux-gnueabihf.tar.gz=27ac4e9184be7e3a245ce6dddf438a2728a6b4fd8959e665e9f02b63ef99f671
-dist/2025-10-28/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=e7360c728068520ec7bd712d57357ce30bbfbb629ec69cfdcf6596002751d93b
+dist/2025-12-11/clippy-1.92.0-arm-unknown-linux-gnueabihf.tar.xz=0c360081ff01d1319cf9667b1c46f9ee684276bfbabce268589342e304c32299
-dist/2025-10-28/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=6d94df05e43804f1054d17542db72cfd3f2df27eedc275c810b35362f9d581c1
+dist/2025-12-11/clippy-1.92.0-armv7-unknown-linux-gnueabihf.tar.gz=b85d187bb8f896383e349ec91699501205644152fce229c2ffbc87723e44d4ff
-dist/2025-10-28/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=25c33744d9722aad4f9fc80674233d16eb653adb17d0deadcd3be8f16a79ecb7
+dist/2025-12-11/clippy-1.92.0-armv7-unknown-linux-gnueabihf.tar.xz=c47e0bb86ac299c36492a125f0231bc715787fc65ab28de5a2dd576ac613cbd3
-dist/2025-10-28/clippy-beta-i686-pc-windows-gnu.tar.gz=dfb9ba0cc842b7c92f1dda8bb88bd1db9beeac746c3ca3d144dd4d66d91ff6ff
+dist/2025-12-11/clippy-1.92.0-i686-pc-windows-gnu.tar.gz=4f8cecf22d6ba620ed2739ef84463f546da12b1b4320ac97144f4a1adda12e23
-dist/2025-10-28/clippy-beta-i686-pc-windows-gnu.tar.xz=20f3cf3fe6b52b8f54391be7edd11331a376313c37b674f4987589f50eac68d0
+dist/2025-12-11/clippy-1.92.0-i686-pc-windows-gnu.tar.xz=37bf65d4d059534ff633996963e497cc470fbd8f3d52a87af45298c1d3785473
-dist/2025-10-28/clippy-beta-i686-pc-windows-msvc.tar.gz=bcabe1f7679e1ae416c7ed56afd74ad224ff47cd9b5413dececb0e6f503ce393
+dist/2025-12-11/clippy-1.92.0-i686-pc-windows-msvc.tar.gz=5291a3c1f8c1ba513575b1240613eabf1fc423570d1fec8ed2927b8d7110b70f
-dist/2025-10-28/clippy-beta-i686-pc-windows-msvc.tar.xz=f8ebfef39e7119b45a4f714e91b47964aeb6653fbdaf9b01786ef629cbaf3d31
+dist/2025-12-11/clippy-1.92.0-i686-pc-windows-msvc.tar.xz=974ed40fe323ea3a6c2de1226aed5634d168b29113ac25d87370d4934c956ea5
-dist/2025-10-28/clippy-beta-i686-unknown-linux-gnu.tar.gz=f0fc318e90de4f45f6ca7d0d6ca3ed5d044db75f97254d792cdea9a7b196042e
+dist/2025-12-11/clippy-1.92.0-i686-unknown-linux-gnu.tar.gz=987e71ce7fd0b633db9fc0ab37eb149cb6d67add4e767d0fe30870cd6a6d2e62
-dist/2025-10-28/clippy-beta-i686-unknown-linux-gnu.tar.xz=27c9adb19a7f84edb19ff4c8ce34dd836fb8d10e8786999591e41ec9c60e4602
+dist/2025-12-11/clippy-1.92.0-i686-unknown-linux-gnu.tar.xz=f21090ddb01503ab7e326ff8b1ab44121611121e83572aa2dba2c5ceffe12d22
-dist/2025-10-28/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=04673347c7e13eee9e301ffc1640ce7a5ed733915c29d90750706829d6b02884
+dist/2025-12-11/clippy-1.92.0-loongarch64-unknown-linux-gnu.tar.gz=bfd0bd79f87e61f99645cdc439be58b7fd64a4a9ef0ef32aeab2ec59ec250d1a
-dist/2025-10-28/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=2484f24346fbbd2d48f69d86ab7710ef65a5952bb5ea0141f3388f616c7d6d0c
+dist/2025-12-11/clippy-1.92.0-loongarch64-unknown-linux-gnu.tar.xz=70783e0b31682938db53b78f87c948acfe589e3ece5dee6ae6aa5b667a384f3c
-dist/2025-10-28/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=656eb1b94dd2324958e6ba0b1c7a37281abe24dac7d87b0e406fc10931ea0d29
+dist/2025-12-11/clippy-1.92.0-loongarch64-unknown-linux-musl.tar.gz=cf38e7b7abb35fff475847285c8e6d71651bc230fc69df91d8b5d9fa7c09c277
-dist/2025-10-28/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=3349952da5d2693554d2e1ae60bb7ff9cd64451719cadf4227095b73377228c1
+dist/2025-12-11/clippy-1.92.0-loongarch64-unknown-linux-musl.tar.xz=790b5b921c6423a007951f3839a083c4c73a9b64fb6c5019e1e117f98975d9f9
-dist/2025-10-28/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=40eeba3b2807a1d807ed25c3bc0482d5b91135a769d2281a894ec8cb8bb52a35
+dist/2025-12-11/clippy-1.92.0-powerpc-unknown-linux-gnu.tar.gz=162f860ee371105f141aa2ac9024d6c597615f4511b7bc628f33d6346625f4f3
-dist/2025-10-28/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=0a6e79cea6655d6b3e1ff1218651c627886d8f06a5d36e9c3bd3c9c45b375f57
+dist/2025-12-11/clippy-1.92.0-powerpc-unknown-linux-gnu.tar.xz=93ed9fdd6fc2655c7789ed096d57a47178532b6bda1ec4480adca7920563e934
-dist/2025-10-28/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=b11f919fce34d70816a6dfa0884e37939c38336bad6261fccf5d67d25935852c
+dist/2025-12-11/clippy-1.92.0-powerpc64-unknown-linux-gnu.tar.gz=d430546bbad6c5710d68bb88e6c6f405bd79b191af2da1ca2760b7d1adfd1b93
-dist/2025-10-28/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=ead91ce4260d07d4e4f950092e94ae224f067ae3c711efe2ccedc9250b2f3dd7
+dist/2025-12-11/clippy-1.92.0-powerpc64-unknown-linux-gnu.tar.xz=7912584254f455b90ed6ce6089c4efded33bb753d1bf948286ef2f4f782d2f30
-dist/2025-10-28/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=481a2e3b45751e2d86c30d4fb3897f0a7a18e9eadde2c9a3ad1a8b0259fa2066
+dist/2025-12-11/clippy-1.92.0-powerpc64le-unknown-linux-gnu.tar.gz=46c0b94dbf705439bebd9cb47de7fb6925e462b62db8885375205e4b48db518f
-dist/2025-10-28/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=d5d6529cfc89c29443d9e87041a5f93b746e5bc5791016242e2f271be5bcb557
+dist/2025-12-11/clippy-1.92.0-powerpc64le-unknown-linux-gnu.tar.xz=873047278043e6506f5c98b8f633a9b96dc49ff83869a86a151fe5b1b9455044
-dist/2025-10-28/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=a70d30948f5e95cdd454fa2b3284b97f29134f59e98e130fc2877781f3b62e89
+dist/2025-12-11/clippy-1.92.0-powerpc64le-unknown-linux-musl.tar.gz=d630a37d6b9ff16c17a0b363adf6ace44bfbf71cd61db1c11f9e4d5ac135774f
-dist/2025-10-28/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=8dddfc0b1b2ca8e8866a11a1c95b8601c50150f1e52adbd3803cca2fabb386e9
+dist/2025-12-11/clippy-1.92.0-powerpc64le-unknown-linux-musl.tar.xz=b0b1ebe31d7b2ec101cb0464c64bdcd28e1ca4172f765fcc8478ebd8b2f90b39
-dist/2025-10-28/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=bd1b28dd79a52de657515ba5c25063b0b6015eb30ee3b0ee05511567b429c992
+dist/2025-12-11/clippy-1.92.0-riscv64gc-unknown-linux-gnu.tar.gz=7a5d3773d578649f3b683463c3d7559b8788370d8c79b4fb6036e3d72ced8e6d
-dist/2025-10-28/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=5262011db6be068ef70905a28939b1838a2fd2b719d38d59e80754695049269b
+dist/2025-12-11/clippy-1.92.0-riscv64gc-unknown-linux-gnu.tar.xz=bdedabeedd48080e6ef70376c52338fbb45ff80d1fbb12a81aa2d8cabbb706c8
-dist/2025-10-28/clippy-beta-s390x-unknown-linux-gnu.tar.gz=6d3d83d03c46e1de2cc6b6f204e701acc9dddb6d4baef80fada9d868b7eb86cc
+dist/2025-12-11/clippy-1.92.0-s390x-unknown-linux-gnu.tar.gz=80bd8a76913069a8f467f5121a0d2fa969a9dc525813d033f2234c3304531a06
-dist/2025-10-28/clippy-beta-s390x-unknown-linux-gnu.tar.xz=e57ac819f962d9b431b699b40a047d3e2530f76f2670c5a04747b7de11c3d5e2
+dist/2025-12-11/clippy-1.92.0-s390x-unknown-linux-gnu.tar.xz=41aa44f1cf37cac87b83e450eb19148c539ff266bb40dc146207ad5b9e1e1acc
-dist/2025-10-28/clippy-beta-sparcv9-sun-solaris.tar.gz=7a492d27b49facb9554248935728cba483eb7ecf3de317751a7445c3932932e6
+dist/2025-12-11/clippy-1.92.0-sparcv9-sun-solaris.tar.gz=b73f28698ae974ebdb03f89cac3933fd34bd048ec2b4392d13fd082302b44720
-dist/2025-10-28/clippy-beta-sparcv9-sun-solaris.tar.xz=cc02f4f971b9e5eb63ca65ff6947cf3490101bfb40ea9fb2b310283bb6d10b27
+dist/2025-12-11/clippy-1.92.0-sparcv9-sun-solaris.tar.xz=c8e6cfbfe8442f9e34c0e6d2d2a6ae8f7fec5278b800c8adc4446c7ca89fc6d7
-dist/2025-10-28/clippy-beta-x86_64-apple-darwin.tar.gz=56f11b8ca012467ef6aa8dc3458a5bf45950f1de062a616a01f6c0aae412d0fd
+dist/2025-12-11/clippy-1.92.0-x86_64-apple-darwin.tar.gz=4bdbc9b3a0dcbf04f1bf807dc74311fe4a4fbadc1887e57e01f3bae1d16bd801
-dist/2025-10-28/clippy-beta-x86_64-apple-darwin.tar.xz=01fe53ec63d71a8427fa3220d037313fc31f8d0fa33a64305b01109344aac21a
+dist/2025-12-11/clippy-1.92.0-x86_64-apple-darwin.tar.xz=39cce87aab3d8b71350edcb3f943fba7bc59581ce1e65e158ee01e64cf0f1cf5
-dist/2025-10-28/clippy-beta-x86_64-pc-solaris.tar.gz=d222cfda8613bba09b0ac1d02fad99c0d081d10733f0f9253d809221ffdda506
+dist/2025-12-11/clippy-1.92.0-x86_64-pc-solaris.tar.gz=8d9b266efa76ef5e4514705c61b7f92a0829a15bcc9e492895b551e7d9811ae1
-dist/2025-10-28/clippy-beta-x86_64-pc-solaris.tar.xz=918706ee8ed38bf398cbf0dad85333e3082dc461fff2fb2399b96e840dc24766
+dist/2025-12-11/clippy-1.92.0-x86_64-pc-solaris.tar.xz=4cd9a59b61ba75146a20d24c016a14b971ffefbc9256fdd2145f31987520b8d7
-dist/2025-10-28/clippy-beta-x86_64-pc-windows-gnu.tar.gz=7764df051100b08b4b4e5c434d5ced1aaa84d9665f6a4401c9ed6350db983b70
+dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-gnu.tar.gz=c4a858e83cea2aab2eb101285b61df663eb08042226c4c13f4cdc18b3e94698e
-dist/2025-10-28/clippy-beta-x86_64-pc-windows-gnu.tar.xz=4a43dee6ce0279de929566f844fa4987d10fa5ca856bb2a2cbea4327eef3308e
+dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-gnu.tar.xz=e9084ced75940856b57e61e3dda7ccce08d57890dff9c2caa8c814c356fa34d2
-dist/2025-10-28/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=add2532fe4e8afb8b53aee8a729fde0c0b36f83a8f6a859c39ae25f3d01e8dd6
+dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-gnullvm.tar.gz=4495c4d97736105fe93fbe9bce954ba21508ebb8d31b473ebc0f6cf57ac981c3
-dist/2025-10-28/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=7117f0afc57ac09c277ba99be4a7de80d62ffaebe4174706910d5ab6501ec9f7
+dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-gnullvm.tar.xz=b22f615210f328aabafa8d0eab3fed62784fa771956c51a92ae24a4dfd2073ed
-dist/2025-10-28/clippy-beta-x86_64-pc-windows-msvc.tar.gz=e71d45b8bdb5346d89f769b4698b404b293884878a7f697680318c72829c1d6f
+dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-msvc.tar.gz=c4f5bf37194bf71a872ab0c7248338d7d6ddf28d0cf35cfde9bad94745bd9f9e
-dist/2025-10-28/clippy-beta-x86_64-pc-windows-msvc.tar.xz=67be8cf6580a4a6e36eff94bfe19fdad290eae5db598d2a016dfcc7516178e14
+dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-msvc.tar.xz=51a9a67931a3e50eb0c26b4c6a7ec2ef6ddd633319343a2d4767710c1e33b21f
-dist/2025-10-28/clippy-beta-x86_64-unknown-freebsd.tar.gz=03b78bad90efe98cab6416ecc641b7da0c9a2be5950edbb4c520c0758cdb90a8
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-freebsd.tar.gz=617ef6d0be4bc2accc80909037e80d450fb1c0cbf797f0d6152fb50a26356437
-dist/2025-10-28/clippy-beta-x86_64-unknown-freebsd.tar.xz=056aecae34c8ae10a41516834809d983bd6126bd0374a7bf0857710492f0d0a5
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-freebsd.tar.xz=73d799e51800ebe4af40395c63c46ec60fc51b7b5f56467b550d5a29f213075a
-dist/2025-10-28/clippy-beta-x86_64-unknown-illumos.tar.gz=a67147c647da8a9b68a507087b66610ed19e65b94538b08326b000e66c170260
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-illumos.tar.gz=031f313032ef7c704f6212a5a84a798a828e9775a61e40ed7b246dcce43c12a7
-dist/2025-10-28/clippy-beta-x86_64-unknown-illumos.tar.xz=09bd43034d7bc1e9ad1873610237f98543751809ebe63d8255813eadf4a00e70
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-illumos.tar.xz=8b7383dfc99c026917b037c0fbad8f42da494a898d71fb7ff6c98ebfea4e9448
-dist/2025-10-28/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=9397e5c3b1f45ce949b8e3420233e8b86f95a887667c917b8e7615218989820f
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-linux-gnu.tar.gz=cd63fc19e6047742b735e959ed615f2013df5a0653913ec37a7e17fe9b0f99d7
-dist/2025-10-28/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=5b67e9eb803c180d101e799f6d7c2a6ea7ec07a93a6395b4f688bf2592bc30d5
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-linux-gnu.tar.xz=2c1bf6e7da8ec50feba03fe188fc9a744ba59e2c6ece7970c13e201d08defa9a
-dist/2025-10-28/clippy-beta-x86_64-unknown-linux-musl.tar.gz=b255c33a89b0b1bd666ffb584c20554daa3a7c48123de75eae5e1b4cbc53e1aa
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-linux-musl.tar.gz=81596511aa023876b881869224188d98d803bf393b6d5a5abe32b486f7fc1dc7
-dist/2025-10-28/clippy-beta-x86_64-unknown-linux-musl.tar.xz=bc7f3f7d59f9c52370849092541a9368632f390ed9bc88f2566f1e3700f4da80
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-linux-musl.tar.xz=8051ed46eb7c3650361dc26dc348dcdcbffb765ef099f9f44bbf8141e223050a
-dist/2025-10-28/clippy-beta-x86_64-unknown-netbsd.tar.gz=a8f366918520cc5a82c9bcfbb419570e6792712455ec5c04655e6557a657e949
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-netbsd.tar.gz=55678429c5dd5370cb455bb6600dbb2c9383662789bf75577282a7c8b1a2ff10
-dist/2025-10-28/clippy-beta-x86_64-unknown-netbsd.tar.xz=dad3555be56e7c8d042f65dfced7915856f9f23cec13a7a633a4aad38c634247
+dist/2025-12-11/clippy-1.92.0-x86_64-unknown-netbsd.tar.xz=66ab46b59f74700d99b5554a191877011aa465e805b52118b65f4964c4ce3563
-dist/2025-10-28/rust-beta-aarch64-pc-windows-msvc.msi=943683af0d464ecd36678e1c87b1207a67105820cb3d1516eeebaae450a2928b
+dist/2025-12-11/rust-1.92.0-aarch64-pc-windows-msvc.msi=dbb09f213d5a9ebb3b2f4c7d65ba7c3c6cad7d9a76927d079604020c3ea0ad5a
-dist/2025-10-28/rust-beta-i686-pc-windows-gnu.msi=8532743b3406fbf2926e5c6643300194eaace9de492e7f2ad0caa6f7d040f8db
+dist/2025-12-11/rust-1.92.0-i686-pc-windows-gnu.msi=95a4922605093c67f6527c44c0e982026727b38a1e25979fcd8b2b0ff9cc7968
-dist/2025-10-28/rust-beta-i686-pc-windows-msvc.msi=1b3b15aa90c3dca73e9d72d53d214eb3c02b97386c83d8755a03f571cc09de4e
+dist/2025-12-11/rust-1.92.0-i686-pc-windows-msvc.msi=b73f851252fe3ae340b9be8e1f9cc05e34210498c0c3321a46243be633454909
-dist/2025-10-28/rust-beta-x86_64-pc-windows-gnu.msi=6249ad7cfcfe78b541e4935ed18dc4cfb10130252885668383a4c8f5046ecc2d
+dist/2025-12-11/rust-1.92.0-x86_64-pc-windows-gnu.msi=899c79a6a68c59470d5f721ae90718f83cabd613e0a7fb595fe87ab6429a0fc6
-dist/2025-10-28/rust-beta-x86_64-pc-windows-msvc.msi=700f63a1baf0de2f0d1972454486f890af15b3700481698ffb0daf403778390a
+dist/2025-12-11/rust-1.92.0-x86_64-pc-windows-msvc.msi=bd3fd270e92d12094151aae3a67435b7fef2164b10d96e99a94230929cda09fd
-dist/2025-10-28/rust-beta-aarch64-apple-darwin.pkg=1f2862fd5dbf8a9c7a765e75391cfffc5a3cd6837066b29f95778b5a346f0f59
+dist/2025-12-11/rust-1.92.0-aarch64-apple-darwin.pkg=ce8eca0010032eb9ccb1baa8d3527d3ed7099c06db5a048205d0940c3866b0c9
-dist/2025-10-28/rust-beta-x86_64-apple-darwin.pkg=ffa2c6275b401c73575a5158911bc53edfece2edc03f6b3f6a140823cf870ee4
+dist/2025-12-11/rust-1.92.0-x86_64-apple-darwin.pkg=d8b439cbabd4db21a3958d6cf9126bd216257f29c1457bba524363d06f4b1eec
-dist/2025-10-28/rustc-beta-src.tar.gz=dbbae9e1c0b5e914b588ba5b659b7fb6af3d5b422831aba028d64b00c7161417
+dist/2025-12-11/rustc-1.92.0-src.tar.gz=9e0d2ca75c7e275fdc758255bf4b03afb3d65d1543602746907c933b6901c3b8
-dist/2025-10-28/rustc-beta-src.tar.xz=aa771d2b1ea8c933444c962c03c384bf2511bdeddf90edcaac8f45bd49f5232c
+dist/2025-12-11/rustc-1.92.0-src.tar.xz=ebee170bfe4c4dfc59521a101de651e5534f4dae889756a5c97ca9ea40d0c307
-dist/2025-10-28/rustfmt-nightly-aarch64-apple-darwin.tar.gz=5a5e525f45010fd3e30503f408f21eef78cafa54e42adf9709cff50f6cb29720
-dist/2025-10-28/rustfmt-nightly-aarch64-apple-darwin.tar.xz=b6f92173abde0be1f4f3378c682e42016390e6e5e20df7e84cbd7804a6161114
-dist/2025-10-28/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=430775c6856f4aea6a2b83e245904d5527f6ace134a9375dc7172f77ecd328f6
-dist/2025-10-28/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=3d14ccf194d04ad5767a5fc3df6f9c1427cd0e282671887d2264b8314586e168
-dist/2025-10-28/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=251f7fa0b78fdad3be1977ffd6a2f563d1524b6423d2bab73d1741aec97b4717
-dist/2025-10-28/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=534cacc40024fec78c02916e7e2d46cde8b8153d303efc1b805af8789f25fb1e
-dist/2025-10-28/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=5663e413cd9ae9f403a4b5c5e9a9862c00d57bcd68bde9161c91e852115e45cd
-dist/2025-10-28/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=3625b287a83796cb71741b9a4b002eb4517950d386f97a91470c0acd5aed835c
-dist/2025-10-28/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=657b0774a95a925eb38d039ef11bc23d15c4733d0b322f172f0b8236bc7410f6
-dist/2025-10-28/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=4e058f11346ec86801bc9cdb830c6dec2620b81fe2cd4b439b275a5145859dfa
-dist/2025-10-28/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=820ece81e455d11f65ddf09093b6bf97359cc803959d951bd199c70a79ae117e
-dist/2025-10-28/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=8a72a3e715ab2427fc120f8af20d67f722881ee9e13bf482e45ef07f5fb2bf86
-dist/2025-10-28/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=fb583c846e1a11663a1fc525f02c0146dc70e7b4da12c264c8b00cf7927ad9c9
-dist/2025-10-28/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=8a15430000d48b702142cc4569a5eef3aba59c07f33f69cfb6966250fae18178
-dist/2025-10-28/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=c470dd9f35b1b701e8475716e61cfadee5475fa29a2994f407d532a794c0ef82
-dist/2025-10-28/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=774898dd43893b99e4e11d004c52244d78d2fb08aaa6fa242cf1d7070d9ff8ac
-dist/2025-10-28/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=31ef71bea5f5ce3668b903fabb1582dc256fe6e2f97e5c23ca468e05f3deb7c9
-dist/2025-10-28/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=232351f0a578f9973b536eb587b2e90cb01ca5f76ad376c09d7dd225c09810b0
-dist/2025-10-28/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=eb469e8475af339d36e1381474f931e326ef1f095a6f56f44730019c5f6422fb
-dist/2025-10-28/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=42c5f2e88f81cdcc375d26c4ab6d9ec03b387b8de632af8a3fa75bcbfcbf56da
-dist/2025-10-28/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=79e06c14b8f18927b1c24cc4ea97e55a805355137a9bdbe3ba616e334878d85a
-dist/2025-10-28/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=3883c297de03da522a20b893f24970305fadaf726dd9388f89196e1f284115e9
-dist/2025-10-28/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=b3ddf283d7964a4c261668df7685bc47b469c7294325f975436d465cb7d44163
-dist/2025-10-28/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=9e63e1bd8b4c52943092e91942737be9b3ee9c128dfbeafdc01d3dc732058165
-dist/2025-10-28/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=83845c5809a9b525655565b3e3b4889e2a07562587c6f046280a44dcbb809094
-dist/2025-10-28/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=533113ead2985a36cf685cfbd6645d43f1a7e2e66b6eaadbde2ff5a72d10c5dd
-dist/2025-10-28/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=82c6aa57adb0f03b96982f51edc65aebfac3811cd2845d280b7bf5fb81cbe92a
-dist/2025-10-28/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=8f4b3c91072d56ba80ba4702e611dbc6fe66163666e6ee35d74602ef36fe9839
-dist/2025-10-28/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=4fe0b85296e2249b36a0b021d6b82e7c31c40a5f717a5f447b6bf9b9524069a2
-dist/2025-10-28/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=9257bb295a58a7df3fbbda809bafc74a8601618afd0fd41467439a8972278cae
-dist/2025-10-28/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=d3a5851060a66a0e027ba142dbdb6e827f4f5f5116b5fdb0b8e86ee56616d682
-dist/2025-10-28/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=fe1e9e4e3a234ba8cb656b08b7bbf5349f5068906cb60a4c5c53f7fe3e214487
-dist/2025-10-28/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=2187f1ccbd4e638efaf9f05566998b579b32729fd9ee4332964a3c54556c3a20
-dist/2025-10-28/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=88526ca6af21bdbc6c46130012cb5fdde25fd44e6372187e66d273067efbc052
-dist/2025-10-28/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=9299c8d4dfc320cf331dc4005c36a0108961a6d5ad750a5b0a6be8c7cda77953
-dist/2025-10-28/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=7da58822a9ba4d65258ca0cd514b9abcc85070baa195ce65d40ed9d9de049049
-dist/2025-10-28/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=e07cc8f1166bb39aada202559c1e2ee9190cf85fc11b4d4abb921cab352748f8
-dist/2025-10-28/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=ebcb49b4ee1e8dded5e6569c7edea1578a369e92aac9030a51d11e95bd8bb8b1
-dist/2025-10-28/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=247ce6a1fb10911b8f38bc8f88617d9a7dd2147e1f1896710b0b610f8bb4b86e
-dist/2025-10-28/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=020d64391c730a61f4c61d802b432a463d4909d0e4d5fe4756db4683df6e000c
-dist/2025-10-28/rustfmt-nightly-x86_64-apple-darwin.tar.gz=547d7711acee55435e271fca1cebead82045375b0fb136404be7df379b0d404b
-dist/2025-10-28/rustfmt-nightly-x86_64-apple-darwin.tar.xz=e8ef4fa56be91b642fd3a8c29afb9dfb3fb7601c8fbd24393be4f3dea1802163
-dist/2025-10-28/rustfmt-nightly-x86_64-pc-solaris.tar.gz=0e41caa314927c9a8656d16b6623c95463a64f07a23941d03597a17582c224d6
-dist/2025-10-28/rustfmt-nightly-x86_64-pc-solaris.tar.xz=d73dcd42d9110befbdf64c46b9e4e8bad07839302cec49e2d8cd99ab436d4bbf
-dist/2025-10-28/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=8e821c45dc91d5df1b9f8487554cadc4deb86a9ef3db25f4e21b38eab3cc8ed2
-dist/2025-10-28/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=f98ccfcc37b7412788a546cbafe5f09b90c26f823e3cad17e71432df4ba910ef
-dist/2025-10-28/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=762e15406bac23f0f41dae2b1b3370458b92e8be771868b4f8f536f53cb26fc3
-dist/2025-10-28/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=cd87b4a4c2af3edea8ba09ce9bb8704449d8f51c5dee8ba10161e0ce2ec2aa19
-dist/2025-10-28/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=7de2ee69be5384656024a6d7c3481315fe90abc9ba9a26726f1eab09aae2c818
-dist/2025-10-28/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=16377ae5474e30b6c11ba886579ef13db4039d0b9f43240db00aacf7366b37d7
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=d98fd17080ed5a4fda444719011540a80320001a0b0dc36148f2e3f78e5f5c33
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=c825c2b46f43fe71f4452494fb422cd9565ec6454857835a6c77081553081523
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=8844743cc05351b1f6ba8fb50ac1d86161a285775eb4c0e474308aec71b631c7
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=172dc660ceb00e7003e855a09f46d9f83096773495ed6d7b8b1ed6b9e770912f
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=2710450c26834b07a5eb80bf990dc67a6db89f87e26d6b613ed96116c28958d4
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=bbb8eac454e0ba3b23c9803d8201fa341d0f0af509aa9e8b530c9b98a1d9886c
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=e6bb6a67878c9cbbbbc96f1a1858500403ecc3b8c951366e18ace0f2601f41cb
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=f6509af9551e73ac16c425c53e667382bf7b6b48be65f4779485ee7843e68030
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=3915f1907939fbfcd82012efa4293e7ddf22bd5bf1484efffacb31c805e6cf68
-dist/2025-10-28/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=cca6182ce9f2906a8b16971741a8435dbcf60d9ef6020cc7d6f7909525a73dc2
-dist/2025-10-28/rustc-nightly-aarch64-apple-darwin.tar.gz=876004fa16a6154ea8ea46cd1bb60a06fc14b24e72e26e20e42fde4e32882b46
-dist/2025-10-28/rustc-nightly-aarch64-apple-darwin.tar.xz=0a98f29bb6a2a1555f6ceaa161ecdd2e599ffe879b98bc98c6066e257fc12362
-dist/2025-10-28/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=b07b2f7975b463970cbb4a8c92e51788ac63c3a46d3ae6c8cb54c7024161d899
-dist/2025-10-28/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=5445b2e30804733fe2a7d07f66a77c2e3ec5e7c71bb55403541b8d365cf91870
-dist/2025-10-28/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=d2cff6b8cb52172f4bb394f8ca891897c774ece1b87f9d30729aa236dfa24900
-dist/2025-10-28/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=a6d0c00367b49654c91d4b71b33819854f628d51b7193c2475b9f737258a575a
-dist/2025-10-28/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=c30649c2360aef41d97bdbf76d55bbfe674a1225161bc125a8215d3954656cda
-dist/2025-10-28/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=3b204fb1461f47b4e2a79a67923abcf8610ab7ab006ee3f9a70cdc87458f81c5
-dist/2025-10-28/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=949f55697b50db7d70a6465b100ae4458d2f676b818ca7227014ddc9c5f707e5
-dist/2025-10-28/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=ff500cd8f318f0316936af462264254df2aa1bd5a2b368ad3c5758e9079eaf71
-dist/2025-10-28/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=231c4cfa37df03a0e0517843bd115a0f0b13ec259397d6e4dfb4014d3a0d4d9f
-dist/2025-10-28/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=50f4d7060d02833949ffc970b88c5ad2183fabd3c498334bf63d87d0c9602720
-dist/2025-10-28/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=f89586ea5bac722a06c225a50d7d603b4895aea89297509f248a1cb51a5cf0ed
-dist/2025-10-28/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=0de0552ae68cb9b61f2c5031cdbefae5ccde39c4003441e93c2e4e704d3751aa
-dist/2025-10-28/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=019bbb267d1c0520a715287e0a1a680b58dd5e9ece2071f3ebd6f2b1d8eb2228
-dist/2025-10-28/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=069bcd46adfb5e14786fd8aced5ceb74af24cc05dfa2bd41ebd81ac146122598
-dist/2025-10-28/rustc-nightly-i686-pc-windows-gnu.tar.gz=911eb977b10aa4bb1f25124f08f3397fb3ac65f36666865be40bf44259b5d77a
-dist/2025-10-28/rustc-nightly-i686-pc-windows-gnu.tar.xz=14ed0abc8708a90e8bbaf0c0de2aec1a4ed60c63b4db00fd4a732f3c808c125b
-dist/2025-10-28/rustc-nightly-i686-pc-windows-msvc.tar.gz=8917e6dd4786f0f413908e9db4c92e060bce525f91b9cc0d43b453d26057435d
-dist/2025-10-28/rustc-nightly-i686-pc-windows-msvc.tar.xz=86a8580a180de9224c176beb1ada2c69acc37fc73ae0e7c7780bbbded842365c
-dist/2025-10-28/rustc-nightly-i686-unknown-linux-gnu.tar.gz=0d29e999ccbc46ff6b0c50a5648e0c5c8f767daa9a0d1fc86dff30c6e0078dd5
-dist/2025-10-28/rustc-nightly-i686-unknown-linux-gnu.tar.xz=bcafb54ca3f587d3cc9302c057da2fbdb4531e2279ef462fc8682e82e1046561
-dist/2025-10-28/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=0a5bfd49a7a2fb98fe06815a2a50d9dc859722da3cc107928e36596c7b8c7f8e
-dist/2025-10-28/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=b8ec7898e087577b78ef1b716f8935c7023d740b389234f38075a09b2c7b494a
-dist/2025-10-28/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=5cab6709c372feed484b5148ec642cf9767e7fe051146023459467012f2e0b64
-dist/2025-10-28/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=e42a3c007bdf7e8179c597daffc61d7a6bd8eac782b8d81d0b883267bc226f86
-dist/2025-10-28/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=a7cb220770ebd482ff9737d787d04e2e1274c46b7da0809041d06712e27f69ae
-dist/2025-10-28/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=088b1d0898bc5b5d83d0fe20edfdadc2d1c0865c39108d11a5d078074aa37a1f
-dist/2025-10-28/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=90a3b28ca667187fb18eee8b87f5aebdb2c2e457acbe5b7b088d9b9a39314a1a
-dist/2025-10-28/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=4eb8f1d20b2eeb85a2b78d3e28a1d665e1171e1271540bdd8453833818d53c30
-dist/2025-10-28/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=e4fc106d7d4e098912b4dc0ac0211769ecc1f01731e118bf6c0bca33c7ceb9f5
-dist/2025-10-28/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=74bf23136731240e8dac7497d8b1a244fc35cd529d12f77fff308099354f3aef
-dist/2025-10-28/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=85ada50366246530a0dcbd462aef31a6edac600d22074d97bfc07321569eafdf
-dist/2025-10-28/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=f0cb51df2f6639fc65091608d569b9ac0730f5a8d88e27079d87bc8a8834b1e4
-dist/2025-10-28/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=c37432d8d8db7aaad9132e1301025dd5bf3671bad0ac1fea0f04e9aae238cae3
-dist/2025-10-28/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=57f72896f0309149a4b376a21d56ea28e65316db08065bfe32cdbd750bbc9657
-dist/2025-10-28/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=170776eefa09f01859af0b3694c013ebfab04e9fcf8fb44233593ef4a763bd38
-dist/2025-10-28/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=29335ffe7d88b758ec1a7a067056e35fe8f24430e8d899df3256b4e2d19ac16e
-dist/2025-10-28/rustc-nightly-sparcv9-sun-solaris.tar.gz=14b5cfe710c92e8691aaad99de891695ef025638eca065587107c075a31215bf
-dist/2025-10-28/rustc-nightly-sparcv9-sun-solaris.tar.xz=d21bb41b4abdaededefd199192bc257424295ec74d482693d032ca67f02dee15
-dist/2025-10-28/rustc-nightly-x86_64-apple-darwin.tar.gz=09c7d0777ea308ad552ea1e958f5c65fa3380c9cb93efa1e6edec3a29fc30b5c
-dist/2025-10-28/rustc-nightly-x86_64-apple-darwin.tar.xz=923ef47f5bd9608d277b6636b8c798c5b2760460264fa6f0c0836f317746a89c
-dist/2025-10-28/rustc-nightly-x86_64-pc-solaris.tar.gz=805643ab958df449ffd8dd5557e43c5e7060a10a3deab2238096b721ab451f08
-dist/2025-10-28/rustc-nightly-x86_64-pc-solaris.tar.xz=f2fb0c0643808bd9f483bf9bf66ead4444285f2e50bc1264b4861deddfaa9c62
-dist/2025-10-28/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=05b7ee4041b2cdcee1739da7a22e4083acc24c043d11cb3f61d0c22237a9f42a
-dist/2025-10-28/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=2f3b04d56dd929ab5997711bc52395fa700247ff38b9362cda375b685c740337
-dist/2025-10-28/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=52575038868d91349b40434ec8faf9836a0aa0a4f77c2decc634a9ba02796c07
-dist/2025-10-28/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=d2d1f2a0d26cc3dc86d88ae46a9dcaa5f0ce694ebac3f46b7466fb058a1a76e5
-dist/2025-10-28/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=5469701cbe03939a82ce5ec50dc166342ab968d2f96cb372dee8f29dfd6e4362
-dist/2025-10-28/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=e6d18f7b7fa3a3613f1aa129f4a14820d4fa1977550689cd99b7dad12054edab
-dist/2025-10-28/rustc-nightly-x86_64-unknown-freebsd.tar.gz=e2a5ff9df2b07f8c939fdb885da717faf19a5b3e63ab780962dc288f832cba6f
-dist/2025-10-28/rustc-nightly-x86_64-unknown-freebsd.tar.xz=b577558a8f1b42d6bbbc80804e3b72835a85979c98659696db32832595283d04
-dist/2025-10-28/rustc-nightly-x86_64-unknown-illumos.tar.gz=5535a693d5b8edf3fae7e1da97c20596a1f60135fefe22835109ed3648765a16
-dist/2025-10-28/rustc-nightly-x86_64-unknown-illumos.tar.xz=bfc15f0678099ea110135d4e7bcb1b9a545f041e5810f6528d49e0b5451a29bb
-dist/2025-10-28/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=877bf56730551f851e2ce5279c105f231906959bcf904aa2fc29acaba5160cc5
-dist/2025-10-28/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=911bf7891d7687675f9200d3bd51946e21df3762b5320b7d31bd49d58526a8a7
-dist/2025-10-28/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=c0c26704d16d6612d0d99ad078bbcb2ac0ed86419a0404a9e08739990acc5ad9
-dist/2025-10-28/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=677f5c6126262b64126b5fc7c3c527cbc9e8ba62aaf4376c924149b6d05e16db
-dist/2025-10-28/rustc-nightly-x86_64-unknown-netbsd.tar.gz=84c82523969ff1b987a09d5f7401e9a773b3110f51f00d708a4791ef6615272b
-dist/2025-10-28/rustc-nightly-x86_64-unknown-netbsd.tar.xz=680eb70467d5695e986b013b3d16dbd0c0b0b7bc85cf8df4a3392c100f97eff9
-dist/2025-10-28/rust-nightly-aarch64-pc-windows-msvc.msi=a8f7ef71113d5ca8094d9433f23d5bab8ae910803e0cc23110d4fd0e04816bf3
-dist/2025-10-28/rust-nightly-i686-pc-windows-gnu.msi=6c4c49c2c2303f94a39d5c598c4f75b9d2c894b1c30aa6b49c8ab7ca674c8ca9
-dist/2025-10-28/rust-nightly-i686-pc-windows-msvc.msi=f7c80d8c614f5b53a596bfd8a263fc0e680b554ec47630e36e23354afb7fd426
-dist/2025-10-28/rust-nightly-x86_64-pc-windows-gnu.msi=2f830bf3391a7da78de14ba4ffd82de8a49652262fcc7a3ae377a3703fe7ab93
-dist/2025-10-28/rust-nightly-x86_64-pc-windows-msvc.msi=c9b61b50bace832fc504853a5ea5dacd869909946c04d1d9c95b15385e98fd47
-dist/2025-10-28/rust-nightly-aarch64-apple-darwin.pkg=8d7cb75018220eac497ffa180c94b210e2e53e8e8c36ab8a39d6c4c6234fe72b
-dist/2025-10-28/rust-nightly-x86_64-apple-darwin.pkg=82e9979fe0cdbac0e008f46cd2d7da70e9fa2caa0d4f1df56654cf57114c993a
-dist/2025-10-28/rustc-nightly-src.tar.gz=f6da3a086dd47e5ace7eec9f03879d4c3082503912fe631e54e38168dac60f22
-dist/2025-10-28/rustc-nightly-src.tar.xz=523289ae9e6a87f076decc1beb412897184e728302826882bf53dfde4df4ce15

src/tools/cargo

@@ -1 +1 @@
-Subproject commit 2c283a9a5c5968eeb9a8f12313f04feb1ff8dfac
+Subproject commit 083ac5135f967fd9dc906ab057a2315861c7a80d

src/tools/clippy/clippy_lints/src/unwrap.rs

@@ -180,14 +180,19 @@ impl Local {
                 field_indices,
                 ..
             } => {
+                let field_projections = place
+                    .projections
+                    .iter()
+                    .filter(|proj| matches!(proj.kind, ProjectionKind::Field(_, _)))
+                    .collect::<Vec<_>>();
                 is_potentially_local_place(*local_id, place)
                     // If there were projections other than field projections, err on the side of caution and say that they
                     // _might_ be mutating something.
                     //
                     // The reason we use `<=` and not `==` is that a mutation of `struct` or `struct.field1` should count as
                     // mutation of the child fields such as `struct.field1.field2`
-                    && place.projections.len() <= field_indices.len()
+                    && field_projections.len() <= field_indices.len()
-                    && iter::zip(&place.projections, field_indices.iter().copied().rev()).all(|(proj, field_idx)| {
+                    && iter::zip(&field_projections, field_indices.iter().copied().rev()).all(|(proj, field_idx)| {
                          match proj.kind {
                             ProjectionKind::Field(f_idx, _) => f_idx == field_idx,
                                 // If this is a projection we don't expect, it _might_ be mutating something

src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs

@@ -472,3 +472,22 @@ fn issue15321() {
         //~^ unnecessary_unwrap
     }
 }
+
+mod issue16188 {
+    struct Foo {
+        value: Option<i32>,
+    }
+
+    impl Foo {
+        pub fn bar(&mut self) {
+            let print_value = |v: i32| {
+                println!("{}", v);
+            };
+
+            if self.value.is_none() {
+                self.value = Some(10);
+                print_value(self.value.unwrap());
+            }
+        }
+    }
+}

src/tools/miri/src/shims/x86/avx2.rs

@@ -245,6 +245,42 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
                 shift_simd_by_scalar(this, left, right, which, dest)?;
             }
+            // Used to implement the _mm256_madd_epi16 function.
+            // Multiplies packed signed 16-bit integers in `left` and `right`, producing
+            // intermediate signed 32-bit integers. Horizontally add adjacent pairs of
+            // intermediate 32-bit integers, and pack the results in `dest`.
+            "pmadd.wd" => {
+                let [left, right] =
+                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+
+                let (left, left_len) = this.project_to_simd(left)?;
+                let (right, right_len) = this.project_to_simd(right)?;
+                let (dest, dest_len) = this.project_to_simd(dest)?;
+
+                assert_eq!(left_len, right_len);
+                assert_eq!(dest_len.strict_mul(2), left_len);
+
+                for i in 0..dest_len {
+                    let j1 = i.strict_mul(2);
+                    let left1 = this.read_scalar(&this.project_index(&left, j1)?)?.to_i16()?;
+                    let right1 = this.read_scalar(&this.project_index(&right, j1)?)?.to_i16()?;
+
+                    let j2 = j1.strict_add(1);
+                    let left2 = this.read_scalar(&this.project_index(&left, j2)?)?.to_i16()?;
+                    let right2 = this.read_scalar(&this.project_index(&right, j2)?)?.to_i16()?;
+
+                    let dest = this.project_index(&dest, i)?;
+
+                    // Multiplications are i16*i16->i32, which will not overflow.
+                    let mul1 = i32::from(left1).strict_mul(right1.into());
+                    let mul2 = i32::from(left2).strict_mul(right2.into());
+                    // However, this addition can overflow in the most extreme case
+                    // (-0x8000)*(-0x8000)+(-0x8000)*(-0x8000) = 0x80000000
+                    let res = mul1.wrapping_add(mul2);
+
+                    this.write_scalar(Scalar::from_i32(res), &dest)?;
+                }
+            }
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)

src/tools/miri/src/shims/x86/sse2.rs

@@ -278,6 +278,42 @@ pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.copy_op(&this.project_index(&left, i)?, &this.project_index(&dest, i)?)?;
                 }
             }
+            // Used to implement the _mm_madd_epi16 function.
+            // Multiplies packed signed 16-bit integers in `left` and `right`, producing
+            // intermediate signed 32-bit integers. Horizontally add adjacent pairs of
+            // intermediate 32-bit integers, and pack the results in `dest`.
+            "pmadd.wd" => {
+                let [left, right] =
+                    this.check_shim_sig_lenient(abi, CanonAbi::C, link_name, args)?;
+
+                let (left, left_len) = this.project_to_simd(left)?;
+                let (right, right_len) = this.project_to_simd(right)?;
+                let (dest, dest_len) = this.project_to_simd(dest)?;
+
+                assert_eq!(left_len, right_len);
+                assert_eq!(dest_len.strict_mul(2), left_len);
+
+                for i in 0..dest_len {
+                    let j1 = i.strict_mul(2);
+                    let left1 = this.read_scalar(&this.project_index(&left, j1)?)?.to_i16()?;
+                    let right1 = this.read_scalar(&this.project_index(&right, j1)?)?.to_i16()?;
+
+                    let j2 = j1.strict_add(1);
+                    let left2 = this.read_scalar(&this.project_index(&left, j2)?)?.to_i16()?;
+                    let right2 = this.read_scalar(&this.project_index(&right, j2)?)?.to_i16()?;
+
+                    let dest = this.project_index(&dest, i)?;
+
+                    // Multiplications are i16*i16->i32, which will not overflow.
+                    let mul1 = i32::from(left1).strict_mul(right1.into());
+                    let mul2 = i32::from(left2).strict_mul(right2.into());
+                    // However, this addition can overflow in the most extreme case
+                    // (-0x8000)*(-0x8000)+(-0x8000)*(-0x8000) = 0x80000000
+                    let res = mul1.wrapping_add(mul2);
+
+                    this.write_scalar(Scalar::from_i32(res), &dest)?;
+                }
+            }
             _ => return interp_ok(EmulateItemResult::NotSupported),
         }
         interp_ok(EmulateItemResult::NeedsReturn)

src/tools/rust-analyzer/crates/proc-macro-api/src/process.rs

@@ -58,7 +58,9 @@ impl ProcMacroServerProcess {
             if v.pre.as_str() == "nightly" { *v > VERSION } else { *v >= VERSION }
         });
 
-        let formats: &[_] = if has_working_format_flag {
+        let formats: &[_] = if std::env::var_os("RUST_ANALYZER_USE_POSTCARD").is_some()
+            && has_working_format_flag
+        {
             &[
                 (Some("postcard-legacy"), Protocol::LegacyPostcard { mode: SpanMode::Id }),
                 (Some("json-legacy"), Protocol::LegacyJson { mode: SpanMode::Id }),

src/version

@@ -1 +1 @@
-1.93.0
+1.93.1

tests/codegen-llvm/hint/likely.rs

@@ -70,7 +70,7 @@ pub fn test4(x: u64) {
     }
 
     // CHECK-LABEL: @test4(
-    // CHECK: br i1 %0, label %bb3, label %bb2, !prof ![[NUM2:[0-9]+]]
+    // CHECK: br i1 %_2.not, label %bb3, label %bb2, !prof ![[NUM2:[0-9]+]]
     // CHECK: bb3:
     // CHECK: path_a
     // CHECK: bb2:

tests/codegen-llvm/hint/unlikely.rs

@@ -70,7 +70,7 @@ pub fn test4(x: u64) {
     }
 
     // CHECK-LABEL: @test4(
-    // CHECK: br i1 %0, label %bb4, label %bb2, !prof ![[NUM2:[0-9]+]]
+    // CHECK: br i1 %_2.not, label %bb4, label %bb2, !prof ![[NUM2:[0-9]+]]
     // CHECK: bb4:
     // CHECK: path_a
     // CHECK: bb2:

tests/debuginfo/dummy_span.rs

@@ -1,6 +1,6 @@
 //@ min-lldb-version: 310
 
-//@ compile-flags:-g
+//@ compile-flags:-g -Zunsound-mir-opts
 //@ ignore-backends: gcc
 
 // === GDB TESTS ===================================================================================

tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff

@@ -29,10 +29,11 @@
                   debug precision => _8;
                   let _8: usize;
                   scope 5 (inlined Formatter::<'_>::precision) {
-                      let mut _22: u32;
+                      let mut _22: bool;
                       let mut _23: u32;
-                      let mut _24: usize;
+                      let mut _24: u32;
-                      let mut _25: u16;
+                      let mut _25: usize;
+                      let mut _26: u16;
                   }
               }
           }
@@ -71,10 +72,12 @@
           StorageLive(_6);
           StorageLive(_22);
           StorageLive(_23);
-          _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
+          StorageLive(_24);
-          _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG);
+          _24 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          StorageDead(_23);
+          _23 = BitAnd(move _24, const core::fmt::flags::PRECISION_FLAG);
-          switchInt(move _22) -> [0: bb10, otherwise: bb11];
+          StorageDead(_24);
+          _22 = Eq(move _23, const 0_u32);
+          switchInt(move _22) -> [0: bb10, otherwise: bb9];
       }
   
       bb4: {
@@ -142,26 +145,27 @@
       }
   
       bb9: {
-          _7 = discriminant(_6);
+          StorageDead(_23);
-          switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
+          _6 = const Option::<usize>::None;
+          goto -> bb11;
       }
   
       bb10: {
-          StorageDead(_22);
+          StorageDead(_23);
-          _6 = const Option::<usize>::None;
+          StorageLive(_25);
-          goto -> bb9;
+          StorageLive(_26);
+          _26 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16);
+          _25 = move _26 as usize (IntToInt);
+          StorageDead(_26);
+          _6 = Option::<usize>::Some(move _25);
+          StorageDead(_25);
+          goto -> bb11;
       }
   
       bb11: {
           StorageDead(_22);
-          StorageLive(_24);
+          _7 = discriminant(_6);
-          StorageLive(_25);
+          switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
-          _25 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16);
-          _24 = move _25 as usize (IntToInt);
-          StorageDead(_25);
-          _6 = Option::<usize>::Some(move _24);
-          StorageDead(_24);
-          goto -> bb9;
       }
   
       bb12: {

tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff

@@ -29,10 +29,11 @@
                   debug precision => _8;
                   let _8: usize;
                   scope 5 (inlined Formatter::<'_>::precision) {
-                      let mut _22: u32;
+                      let mut _22: bool;
                       let mut _23: u32;
-                      let mut _24: usize;
+                      let mut _24: u32;
-                      let mut _25: u16;
+                      let mut _25: usize;
+                      let mut _26: u16;
                   }
               }
           }
@@ -71,10 +72,12 @@
           StorageLive(_6);
           StorageLive(_22);
           StorageLive(_23);
-          _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
+          StorageLive(_24);
-          _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG);
+          _24 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          StorageDead(_23);
+          _23 = BitAnd(move _24, const core::fmt::flags::PRECISION_FLAG);
-          switchInt(move _22) -> [0: bb10, otherwise: bb11];
+          StorageDead(_24);
+          _22 = Eq(move _23, const 0_u32);
+          switchInt(move _22) -> [0: bb10, otherwise: bb9];
       }
   
       bb4: {
@@ -142,26 +145,27 @@
       }
   
       bb9: {
-          _7 = discriminant(_6);
+          StorageDead(_23);
-          switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
+          _6 = const Option::<usize>::None;
+          goto -> bb11;
       }
   
       bb10: {
-          StorageDead(_22);
+          StorageDead(_23);
-          _6 = const Option::<usize>::None;
+          StorageLive(_25);
-          goto -> bb9;
+          StorageLive(_26);
+          _26 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16);
+          _25 = move _26 as usize (IntToInt);
+          StorageDead(_26);
+          _6 = Option::<usize>::Some(move _25);
+          StorageDead(_25);
+          goto -> bb11;
       }
   
       bb11: {
           StorageDead(_22);
-          StorageLive(_24);
+          _7 = discriminant(_6);
-          StorageLive(_25);
+          switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
-          _25 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16);
-          _24 = move _25 as usize (IntToInt);
-          StorageDead(_25);
-          _6 = Option::<usize>::Some(move _24);
-          StorageDead(_24);
-          goto -> bb9;
       }
   
       bb12: {

tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff

@@ -29,10 +29,11 @@
                   debug precision => _8;
                   let _8: usize;
                   scope 5 (inlined Formatter::<'_>::precision) {
-                      let mut _22: u32;
+                      let mut _22: bool;
                       let mut _23: u32;
-                      let mut _24: usize;
+                      let mut _24: u32;
-                      let mut _25: u16;
+                      let mut _25: usize;
+                      let mut _26: u16;
                   }
               }
           }
@@ -71,10 +72,12 @@
           StorageLive(_6);
           StorageLive(_22);
           StorageLive(_23);
-          _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
+          StorageLive(_24);
-          _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG);
+          _24 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          StorageDead(_23);
+          _23 = BitAnd(move _24, const core::fmt::flags::PRECISION_FLAG);
-          switchInt(move _22) -> [0: bb10, otherwise: bb11];
+          StorageDead(_24);
+          _22 = Eq(move _23, const 0_u32);
+          switchInt(move _22) -> [0: bb10, otherwise: bb9];
       }
   
       bb4: {
@@ -142,26 +145,27 @@
       }
   
       bb9: {
-          _7 = discriminant(_6);
+          StorageDead(_23);
-          switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
+          _6 = const Option::<usize>::None;
+          goto -> bb11;
       }
   
       bb10: {
-          StorageDead(_22);
+          StorageDead(_23);
-          _6 = const Option::<usize>::None;
+          StorageLive(_25);
-          goto -> bb9;
+          StorageLive(_26);
+          _26 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16);
+          _25 = move _26 as usize (IntToInt);
+          StorageDead(_26);
+          _6 = Option::<usize>::Some(move _25);
+          StorageDead(_25);
+          goto -> bb11;
       }
   
       bb11: {
           StorageDead(_22);
-          StorageLive(_24);
+          _7 = discriminant(_6);
-          StorageLive(_25);
+          switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
-          _25 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16);
-          _24 = move _25 as usize (IntToInt);
-          StorageDead(_25);
-          _6 = Option::<usize>::Some(move _24);
-          StorageDead(_24);
-          goto -> bb9;
       }
   
       bb12: {

tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff

@@ -29,10 +29,11 @@
                   debug precision => _8;
                   let _8: usize;
                   scope 5 (inlined Formatter::<'_>::precision) {
-                      let mut _22: u32;
+                      let mut _22: bool;
                       let mut _23: u32;
-                      let mut _24: usize;
+                      let mut _24: u32;
-                      let mut _25: u16;
+                      let mut _25: usize;
+                      let mut _26: u16;
                   }
               }
           }
@@ -71,10 +72,12 @@
           StorageLive(_6);
           StorageLive(_22);
           StorageLive(_23);
-          _23 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
+          StorageLive(_24);
-          _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG);
+          _24 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32);
-          StorageDead(_23);
+          _23 = BitAnd(move _24, const core::fmt::flags::PRECISION_FLAG);
-          switchInt(move _22) -> [0: bb10, otherwise: bb11];
+          StorageDead(_24);
+          _22 = Eq(move _23, const 0_u32);
+          switchInt(move _22) -> [0: bb10, otherwise: bb9];
       }
   
       bb4: {
@@ -142,26 +145,27 @@
       }
   
       bb9: {
-          _7 = discriminant(_6);
+          StorageDead(_23);
-          switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
+          _6 = const Option::<usize>::None;
+          goto -> bb11;
       }
   
       bb10: {
-          StorageDead(_22);
+          StorageDead(_23);
-          _6 = const Option::<usize>::None;
+          StorageLive(_25);
-          goto -> bb9;
+          StorageLive(_26);
+          _26 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16);
+          _25 = move _26 as usize (IntToInt);
+          StorageDead(_26);
+          _6 = Option::<usize>::Some(move _25);
+          StorageDead(_25);
+          goto -> bb11;
       }
   
       bb11: {
           StorageDead(_22);
-          StorageLive(_24);
+          _7 = discriminant(_6);
-          StorageLive(_25);
+          switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12];
-          _25 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16);
-          _24 = move _25 as usize (IntToInt);
-          StorageDead(_25);
-          _6 = Option::<usize>::Some(move _24);
-          StorageDead(_24);
-          goto -> bb9;
       }
   
       bb12: {

tests/mir-opt/issue_76432.rs

@@ -1,6 +1,7 @@
 // skip-filecheck
 // EMIT_MIR_FOR_EACH_PANIC_STRATEGY
 // Check that we do not insert StorageDead at each target if StorageDead was never seen
+//@ compile-flags: -Zunsound-mir-opts
 
 use std::fmt::Debug;
 

tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir

@@ -3,7 +3,8 @@
 fn num_to_digit(_1: char) -> u32 {
     debug num => _1;
     let mut _0: u32;
-    let mut _4: std::option::Option<u32>;
+    let mut _4: bool;
+    let mut _5: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
@@ -13,13 +14,14 @@ fn num_to_digit(_1: char) -> u32 {
         }
     }
     scope 4 (inlined #[track_caller] Option::<u32>::unwrap) {
-        let mut _5: isize;
+        let mut _6: isize;
-        let mut _6: !;
+        let mut _7: !;
         scope 5 {
         }
     }
 
     bb0: {
+        StorageLive(_4);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind unreachable];
     }
@@ -27,44 +29,45 @@ fn num_to_digit(_1: char) -> u32 {
     bb1: {
         StorageLive(_3);
         _3 = discriminant(_2);
+        _4 = Eq(copy _3, const 1_isize);
+        StorageDead(_3);
         StorageDead(_2);
-        switchInt(move _3) -> [1: bb2, otherwise: bb7];
+        switchInt(move _4) -> [0: bb2, otherwise: bb3];
     }
 
     bb2: {
-        StorageDead(_3);
+        _0 = const 0_u32;
-        StorageLive(_4);
+        goto -> bb7;
-        _4 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
         StorageLive(_5);
-        _5 = discriminant(_4);
+        _5 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb4, unwind unreachable];
-        switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6];
     }
 
     bb4: {
-        _6 = option::unwrap_failed() -> unwind unreachable;
+        StorageLive(_6);
+        _6 = discriminant(_5);
+        switchInt(move _6) -> [0: bb5, 1: bb6, otherwise: bb8];
     }
 
     bb5: {
-        _0 = move ((_4 as Some).0: u32);
+        _7 = option::unwrap_failed() -> unwind unreachable;
-        StorageDead(_5);
-        StorageDead(_4);
-        goto -> bb8;
     }
 
     bb6: {
-        unreachable;
+        _0 = move ((_5 as Some).0: u32);
+        StorageDead(_6);
+        StorageDead(_5);
+        goto -> bb7;
     }
 
     bb7: {
-        StorageDead(_3);
+        StorageDead(_4);
-        _0 = const 0_u32;
+        return;
-        goto -> bb8;
     }
 
     bb8: {
-        return;
+        unreachable;
     }
 }

tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir

@@ -3,7 +3,8 @@
 fn num_to_digit(_1: char) -> u32 {
     debug num => _1;
     let mut _0: u32;
-    let mut _4: std::option::Option<u32>;
+    let mut _4: bool;
+    let mut _5: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
@@ -13,13 +14,14 @@ fn num_to_digit(_1: char) -> u32 {
         }
     }
     scope 4 (inlined #[track_caller] Option::<u32>::unwrap) {
-        let mut _5: isize;
+        let mut _6: isize;
-        let mut _6: !;
+        let mut _7: !;
         scope 5 {
         }
     }
 
     bb0: {
+        StorageLive(_4);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind continue];
     }
@@ -27,44 +29,45 @@ fn num_to_digit(_1: char) -> u32 {
     bb1: {
         StorageLive(_3);
         _3 = discriminant(_2);
+        _4 = Eq(copy _3, const 1_isize);
+        StorageDead(_3);
         StorageDead(_2);
-        switchInt(move _3) -> [1: bb2, otherwise: bb7];
+        switchInt(move _4) -> [0: bb2, otherwise: bb3];
     }
 
     bb2: {
-        StorageDead(_3);
+        _0 = const 0_u32;
-        StorageLive(_4);
+        goto -> bb7;
-        _4 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb3, unwind continue];
     }
 
     bb3: {
         StorageLive(_5);
-        _5 = discriminant(_4);
+        _5 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb4, unwind continue];
-        switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6];
     }
 
     bb4: {
-        _6 = option::unwrap_failed() -> unwind continue;
+        StorageLive(_6);
+        _6 = discriminant(_5);
+        switchInt(move _6) -> [0: bb5, 1: bb6, otherwise: bb8];
     }
 
     bb5: {
-        _0 = move ((_4 as Some).0: u32);
+        _7 = option::unwrap_failed() -> unwind continue;
-        StorageDead(_5);
-        StorageDead(_4);
-        goto -> bb8;
     }
 
     bb6: {
-        unreachable;
+        _0 = move ((_5 as Some).0: u32);
+        StorageDead(_6);
+        StorageDead(_5);
+        goto -> bb7;
     }
 
     bb7: {
-        StorageDead(_3);
+        StorageDead(_4);
-        _0 = const 0_u32;
+        return;
-        goto -> bb8;
     }
 
     bb8: {
-        return;
+        unreachable;
     }
 }

tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir

@@ -3,7 +3,8 @@
 fn num_to_digit(_1: char) -> u32 {
     debug num => _1;
     let mut _0: u32;
-    let mut _4: std::option::Option<u32>;
+    let mut _4: bool;
+    let mut _5: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
@@ -13,13 +14,14 @@ fn num_to_digit(_1: char) -> u32 {
         }
     }
     scope 4 (inlined #[track_caller] Option::<u32>::unwrap) {
-        let mut _5: isize;
+        let mut _6: isize;
-        let mut _6: !;
+        let mut _7: !;
         scope 5 {
         }
     }
 
     bb0: {
+        StorageLive(_4);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind unreachable];
     }
@@ -27,44 +29,45 @@ fn num_to_digit(_1: char) -> u32 {
     bb1: {
         StorageLive(_3);
         _3 = discriminant(_2);
+        _4 = Eq(copy _3, const 1_isize);
+        StorageDead(_3);
         StorageDead(_2);
-        switchInt(move _3) -> [1: bb2, otherwise: bb7];
+        switchInt(move _4) -> [0: bb2, otherwise: bb3];
     }
 
     bb2: {
-        StorageDead(_3);
+        _0 = const 0_u32;
-        StorageLive(_4);
+        goto -> bb7;
-        _4 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
         StorageLive(_5);
-        _5 = discriminant(_4);
+        _5 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb4, unwind unreachable];
-        switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6];
     }
 
     bb4: {
-        _6 = option::unwrap_failed() -> unwind unreachable;
+        StorageLive(_6);
+        _6 = discriminant(_5);
+        switchInt(move _6) -> [0: bb5, 1: bb6, otherwise: bb8];
     }
 
     bb5: {
-        _0 = move ((_4 as Some).0: u32);
+        _7 = option::unwrap_failed() -> unwind unreachable;
-        StorageDead(_5);
-        StorageDead(_4);
-        goto -> bb8;
     }
 
     bb6: {
-        unreachable;
+        _0 = move ((_5 as Some).0: u32);
+        StorageDead(_6);
+        StorageDead(_5);
+        goto -> bb7;
     }
 
     bb7: {
-        StorageDead(_3);
+        StorageDead(_4);
-        _0 = const 0_u32;
+        return;
-        goto -> bb8;
     }
 
     bb8: {
-        return;
+        unreachable;
     }
 }

tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir

@@ -3,7 +3,8 @@
 fn num_to_digit(_1: char) -> u32 {
     debug num => _1;
     let mut _0: u32;
-    let mut _4: std::option::Option<u32>;
+    let mut _4: bool;
+    let mut _5: std::option::Option<u32>;
     scope 1 (inlined char::methods::<impl char>::is_digit) {
         let _2: std::option::Option<u32>;
         scope 2 (inlined Option::<u32>::is_some) {
@@ -13,13 +14,14 @@ fn num_to_digit(_1: char) -> u32 {
         }
     }
     scope 4 (inlined #[track_caller] Option::<u32>::unwrap) {
-        let mut _5: isize;
+        let mut _6: isize;
-        let mut _6: !;
+        let mut _7: !;
         scope 5 {
         }
     }
 
     bb0: {
+        StorageLive(_4);
         StorageLive(_2);
         _2 = char::methods::<impl char>::to_digit(copy _1, const 8_u32) -> [return: bb1, unwind continue];
     }
@@ -27,44 +29,45 @@ fn num_to_digit(_1: char) -> u32 {
     bb1: {
         StorageLive(_3);
         _3 = discriminant(_2);
+        _4 = Eq(copy _3, const 1_isize);
+        StorageDead(_3);
         StorageDead(_2);
-        switchInt(move _3) -> [1: bb2, otherwise: bb7];
+        switchInt(move _4) -> [0: bb2, otherwise: bb3];
     }
 
     bb2: {
-        StorageDead(_3);
+        _0 = const 0_u32;
-        StorageLive(_4);
+        goto -> bb7;
-        _4 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb3, unwind continue];
     }
 
     bb3: {
         StorageLive(_5);
-        _5 = discriminant(_4);
+        _5 = char::methods::<impl char>::to_digit(move _1, const 8_u32) -> [return: bb4, unwind continue];
-        switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6];
     }
 
     bb4: {
-        _6 = option::unwrap_failed() -> unwind continue;
+        StorageLive(_6);
+        _6 = discriminant(_5);
+        switchInt(move _6) -> [0: bb5, 1: bb6, otherwise: bb8];
     }
 
     bb5: {
-        _0 = move ((_4 as Some).0: u32);
+        _7 = option::unwrap_failed() -> unwind continue;
-        StorageDead(_5);
-        StorageDead(_4);
-        goto -> bb8;
     }
 
     bb6: {
-        unreachable;
+        _0 = move ((_5 as Some).0: u32);
+        StorageDead(_6);
+        StorageDead(_5);
+        goto -> bb7;
     }
 
     bb7: {
-        StorageDead(_3);
+        StorageDead(_4);
-        _0 = const 0_u32;
+        return;
-        goto -> bb8;
     }
 
     bb8: {
-        return;
+        unreachable;
     }
 }

tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir

@@ -8,7 +8,8 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _11: ();
+            let mut _9: bool;
+            let _12: ();
             scope 3 {
                 let _8: std::ptr::alignment::AlignmentEnum;
                 scope 4 {
@@ -25,13 +26,13 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                         }
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        let mut _9: *mut u8;
+                        let mut _10: *mut u8;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
+                            let mut _11: usize;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
@@ -80,20 +81,21 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
         StorageDead(_7);
         StorageDead(_6);
         StorageDead(_4);
-        switchInt(copy _5) -> [0: bb4, otherwise: bb2];
+        _9 = Ne(copy _5, const 0_usize);
+        switchInt(copy _9) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
-        StorageLive(_9);
-        _9 = copy _3 as *mut u8 (PtrToPtr);
         StorageLive(_10);
-        _10 = discriminant(_8);
+        _10 = copy _3 as *mut u8 (PtrToPtr);
-        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
+        StorageLive(_11);
+        _11 = discriminant(_8);
+        _12 = alloc::alloc::__rust_dealloc(move _10, move _5, move _11) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
+        StorageDead(_11);
         StorageDead(_10);
-        StorageDead(_9);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir

@@ -8,7 +8,8 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _11: ();
+            let mut _9: bool;
+            let _12: ();
             scope 3 {
                 let _8: std::ptr::alignment::AlignmentEnum;
                 scope 4 {
@@ -25,13 +26,13 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                         }
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        let mut _9: *mut u8;
+                        let mut _10: *mut u8;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
+                            let mut _11: usize;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
@@ -80,20 +81,21 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
         StorageDead(_7);
         StorageDead(_6);
         StorageDead(_4);
-        switchInt(copy _5) -> [0: bb4, otherwise: bb2];
+        _9 = Ne(copy _5, const 0_usize);
+        switchInt(copy _9) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
-        StorageLive(_9);
-        _9 = copy _3 as *mut u8 (PtrToPtr);
         StorageLive(_10);
-        _10 = discriminant(_8);
+        _10 = copy _3 as *mut u8 (PtrToPtr);
-        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
+        StorageLive(_11);
+        _11 = discriminant(_8);
+        _12 = alloc::alloc::__rust_dealloc(move _10, move _5, move _11) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
+        StorageDead(_11);
         StorageDead(_10);
-        StorageDead(_9);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir

@@ -8,7 +8,8 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _11: ();
+            let mut _9: bool;
+            let _12: ();
             scope 3 {
                 let _8: std::ptr::alignment::AlignmentEnum;
                 scope 4 {
@@ -25,13 +26,13 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                         }
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        let mut _9: *mut u8;
+                        let mut _10: *mut u8;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
+                            let mut _11: usize;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
@@ -80,20 +81,21 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
         StorageDead(_7);
         StorageDead(_6);
         StorageDead(_4);
-        switchInt(copy _5) -> [0: bb4, otherwise: bb2];
+        _9 = Ne(copy _5, const 0_usize);
+        switchInt(copy _9) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
-        StorageLive(_9);
-        _9 = copy _3 as *mut u8 (PtrToPtr);
         StorageLive(_10);
-        _10 = discriminant(_8);
+        _10 = copy _3 as *mut u8 (PtrToPtr);
-        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
+        StorageLive(_11);
+        _11 = discriminant(_8);
+        _12 = alloc::alloc::__rust_dealloc(move _10, move _5, move _11) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
+        StorageDead(_11);
         StorageDead(_10);
-        StorageDead(_9);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir

@@ -8,7 +8,8 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
             let _2: std::ptr::NonNull<[T]>;
             let mut _3: *mut [T];
             let mut _4: *const [T];
-            let _11: ();
+            let mut _9: bool;
+            let _12: ();
             scope 3 {
                 let _8: std::ptr::alignment::AlignmentEnum;
                 scope 4 {
@@ -25,13 +26,13 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
                         }
                     }
                     scope 18 (inlined <std::alloc::Global as Allocator>::deallocate) {
-                        let mut _9: *mut u8;
+                        let mut _10: *mut u8;
                         scope 19 (inlined Layout::size) {
                         }
                         scope 20 (inlined NonNull::<u8>::as_ptr) {
                         }
                         scope 21 (inlined std::alloc::dealloc) {
-                            let mut _10: usize;
+                            let mut _11: usize;
                             scope 22 (inlined Layout::size) {
                             }
                             scope 23 (inlined Layout::align) {
@@ -80,20 +81,21 @@ fn generic_in_place(_1: *mut Box<[T]>) -> () {
         StorageDead(_7);
         StorageDead(_6);
         StorageDead(_4);
-        switchInt(copy _5) -> [0: bb4, otherwise: bb2];
+        _9 = Ne(copy _5, const 0_usize);
+        switchInt(copy _9) -> [0: bb4, otherwise: bb2];
     }
 
     bb2: {
-        StorageLive(_9);
-        _9 = copy _3 as *mut u8 (PtrToPtr);
         StorageLive(_10);
-        _10 = discriminant(_8);
+        _10 = copy _3 as *mut u8 (PtrToPtr);
-        _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable];
+        StorageLive(_11);
+        _11 = discriminant(_8);
+        _12 = alloc::alloc::__rust_dealloc(move _10, move _5, move _11) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
+        StorageDead(_11);
         StorageDead(_10);
-        StorageDead(_9);
         goto -> bb4;
     }
 

tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir

@@ -3,316 +3,72 @@
 fn vec_move(_1: Vec<impl Sized>) -> () {
     debug v => _1;
     let mut _0: ();
-    let mut _21: std::vec::IntoIter<impl Sized>;
+    let mut _2: std::vec::IntoIter<impl Sized>;
-    let mut _22: std::vec::IntoIter<impl Sized>;
+    let mut _3: std::vec::IntoIter<impl Sized>;
-    let mut _23: &mut std::vec::IntoIter<impl Sized>;
+    let mut _4: &mut std::vec::IntoIter<impl Sized>;
-    let mut _24: std::option::Option<impl Sized>;
+    let mut _5: std::option::Option<impl Sized>;
-    let mut _25: isize;
+    let mut _6: isize;
-    let _27: ();
+    let _8: ();
     scope 1 {
-        debug iter => _22;
+        debug iter => _3;
-        let _26: impl Sized;
+        let _7: impl Sized;
         scope 2 {
-            debug x => _26;
+            debug x => _7;
-        }
-    }
-    scope 3 (inlined <Vec<impl Sized> as IntoIterator>::into_iter) {
-        debug self => _1;
-        let _2: std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
-        let mut _3: *const std::alloc::Global;
-        let mut _8: usize;
-        let mut _10: *mut impl Sized;
-        let mut _11: *const impl Sized;
-        let mut _12: usize;
-        let _28: &std::vec::Vec<impl Sized>;
-        let mut _29: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
-        let mut _30: &alloc::raw_vec::RawVec<impl Sized>;
-        let mut _31: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
-        let _32: &std::vec::Vec<impl Sized>;
-        let mut _33: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
-        let _34: &std::vec::Vec<impl Sized>;
-        let mut _35: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
-        let mut _36: &alloc::raw_vec::RawVec<impl Sized>;
-        let mut _37: &std::mem::ManuallyDrop<std::vec::Vec<impl Sized>>;
-        scope 4 {
-            debug me => _2;
-            scope 5 {
-                debug alloc => const ManuallyDrop::<std::alloc::Global> {{ value: std::alloc::Global }};
-                let _6: std::ptr::NonNull<impl Sized>;
-                scope 6 {
-                    debug buf => _6;
-                    let _7: *mut impl Sized;
-                    scope 7 {
-                        debug begin => _7;
-                        scope 8 {
-                            debug end => _11;
-                            let _19: usize;
-                            scope 9 {
-                                debug cap => _19;
-                            }
-                            scope 39 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
-                                debug self => _37;
-                            }
-                            scope 40 (inlined alloc::raw_vec::RawVec::<impl Sized>::capacity) {
-                                debug self => _36;
-                                let mut _38: &alloc::raw_vec::RawVecInner;
-                                scope 41 (inlined std::mem::size_of::<impl Sized>) {
-                                }
-                                scope 42 (inlined alloc::raw_vec::RawVecInner::capacity) {
-                                    debug self => _38;
-                                    debug elem_size => const <impl Sized as std::mem::SizedTypeProperties>::SIZE;
-                                    let mut _20: core::num::niche_types::UsizeNoHighBit;
-                                    scope 43 (inlined core::num::niche_types::UsizeNoHighBit::as_inner) {
-                                        debug self => _20;
-                                    }
-                                }
-                            }
-                        }
-                        scope 25 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
-                            debug self => _33;
-                        }
-                        scope 26 (inlined Vec::<impl Sized>::len) {
-                            debug self => _32;
-                            let mut _13: bool;
-                            scope 27 {
-                            }
-                        }
-                        scope 28 (inlined std::ptr::mut_ptr::<impl *mut impl Sized>::wrapping_byte_add) {
-                            debug self => _7;
-                            debug count => _12;
-                            let mut _14: *mut u8;
-                            let mut _18: *mut u8;
-                            scope 29 (inlined std::ptr::mut_ptr::<impl *mut impl Sized>::cast::<u8>) {
-                                debug self => _7;
-                            }
-                            scope 30 (inlined std::ptr::mut_ptr::<impl *mut u8>::wrapping_add) {
-                                debug self => _14;
-                                debug count => _12;
-                                let mut _15: isize;
-                                scope 31 (inlined std::ptr::mut_ptr::<impl *mut u8>::wrapping_offset) {
-                                    debug self => _14;
-                                    debug count => _15;
-                                    let mut _16: *const u8;
-                                    let mut _17: *const u8;
-                                }
-                            }
-                            scope 32 (inlined std::ptr::mut_ptr::<impl *mut u8>::with_metadata_of::<impl Sized>) {
-                                debug self => _18;
-                                debug meta => _5;
-                                scope 33 (inlined std::ptr::metadata::<impl Sized>) {
-                                    debug ptr => _5;
-                                }
-                                scope 34 (inlined std::ptr::from_raw_parts_mut::<impl Sized, ()>) {
-                                }
-                            }
-                        }
-                        scope 35 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
-                            debug self => _35;
-                        }
-                        scope 36 (inlined Vec::<impl Sized>::len) {
-                            debug self => _34;
-                            let mut _9: bool;
-                            scope 37 {
-                            }
-                        }
-                        scope 38 (inlined #[track_caller] std::ptr::mut_ptr::<impl *mut impl Sized>::add) {
-                            debug self => _7;
-                            debug count => _8;
-                        }
-                    }
-                    scope 24 (inlined NonNull::<impl Sized>::as_ptr) {
-                        debug self => _6;
-                    }
-                }
-                scope 17 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
-                    debug self => _31;
-                }
-                scope 18 (inlined alloc::raw_vec::RawVec::<impl Sized>::non_null) {
-                    debug self => _30;
-                    scope 19 (inlined alloc::raw_vec::RawVecInner::non_null::<impl Sized>) {
-                        let mut _4: std::ptr::NonNull<u8>;
-                        scope 20 (inlined Unique::<u8>::cast::<impl Sized>) {
-                            scope 21 (inlined NonNull::<u8>::cast::<impl Sized>) {
-                                let mut _5: *const impl Sized;
-                                scope 22 (inlined NonNull::<u8>::as_ptr) {
-                                }
-                            }
-                        }
-                        scope 23 (inlined Unique::<impl Sized>::as_non_null_ptr) {
-                        }
-                    }
-                }
-            }
-            scope 11 (inlined <ManuallyDrop<Vec<impl Sized>> as Deref>::deref) {
-                debug self => _29;
-            }
-            scope 12 (inlined Vec::<impl Sized>::allocator) {
-                debug self => _28;
-                scope 13 (inlined alloc::raw_vec::RawVec::<impl Sized>::allocator) {
-                    scope 14 (inlined alloc::raw_vec::RawVecInner::allocator) {
-                    }
-                }
-            }
-            scope 15 (inlined #[track_caller] std::ptr::read::<std::alloc::Global>) {
-                debug src => _3;
-            }
-            scope 16 (inlined ManuallyDrop::<std::alloc::Global>::new) {
-                debug value => const std::alloc::Global;
-            }
-        }
-        scope 10 (inlined ManuallyDrop::<Vec<impl Sized>>::new) {
-            debug value => _1;
         }
     }
 
     bb0: {
-        StorageLive(_21);
-        StorageLive(_6);
-        StorageLive(_7);
-        StorageLive(_11);
-        StorageLive(_19);
-        StorageLive(_5);
-        StorageLive(_4);
-        StorageLive(_17);
         StorageLive(_2);
-        _2 = ManuallyDrop::<Vec<impl Sized>> { value: copy _1 };
+        _2 = <Vec<impl Sized> as IntoIterator>::into_iter(move _1) -> [return: bb1, unwind continue];
-        StorageLive(_3);
-        // DBG: _29 = &_2;
-        // DBG: _28 = &(_2.0: std::vec::Vec<impl Sized>);
-        _3 = &raw const ((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).2: std::alloc::Global);
-        StorageDead(_3);
-        // DBG: _31 = &_2;
-        // DBG: _30 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
-        _4 = copy (((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique<u8>).0: std::ptr::NonNull<u8>);
-        _5 = copy _4 as *const impl Sized (Transmute);
-        _6 = NonNull::<impl Sized> { pointer: copy _5 };
-        _7 = copy _4 as *mut impl Sized (Transmute);
-        switchInt(const <impl Sized as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb2];
     }
 
     bb1: {
-        StorageLive(_10);
+        StorageLive(_3);
-        StorageLive(_8);
+        _3 = move _2;
-        // DBG: _35 = &_2;
+        goto -> bb2;
-        // DBG: _34 = &(_2.0: std::vec::Vec<impl Sized>);
-        _8 = copy ((_2.0: std::vec::Vec<impl Sized>).1: usize);
-        StorageLive(_9);
-        _9 = Le(copy _8, const <impl Sized as std::mem::SizedTypeProperties>::MAX_SLICE_LEN);
-        assume(move _9);
-        StorageDead(_9);
-        _10 = Offset(copy _7, copy _8);
-        _11 = copy _10 as *const impl Sized (PtrToPtr);
-        StorageDead(_8);
-        StorageDead(_10);
-        goto -> bb4;
     }
 
     bb2: {
-        StorageLive(_12);
+        StorageLive(_5);
-        // DBG: _33 = &_2;
+        _4 = &mut _3;
-        // DBG: _32 = &(_2.0: std::vec::Vec<impl Sized>);
+        _5 = <std::vec::IntoIter<impl Sized> as Iterator>::next(move _4) -> [return: bb3, unwind: bb9];
-        _12 = copy ((_2.0: std::vec::Vec<impl Sized>).1: usize);
-        StorageLive(_13);
-        _13 = Le(copy _12, const <impl Sized as std::mem::SizedTypeProperties>::MAX_SLICE_LEN);
-        assume(move _13);
-        StorageDead(_13);
-        StorageLive(_18);
-        StorageLive(_14);
-        _14 = copy _4 as *mut u8 (Transmute);
-        StorageLive(_15);
-        _15 = copy _12 as isize (IntToInt);
-        StorageLive(_16);
-        _16 = copy _4 as *const u8 (Transmute);
-        _17 = arith_offset::<u8>(move _16, move _15) -> [return: bb3, unwind unreachable];
     }
 
     bb3: {
-        StorageDead(_16);
+        _6 = discriminant(_5);
-        _18 = copy _17 as *mut u8 (PtrToPtr);
+        switchInt(move _6) -> [0: bb4, 1: bb6, otherwise: bb8];
-        StorageDead(_15);
-        StorageDead(_14);
-        StorageDead(_18);
-        StorageDead(_12);
-        _11 = copy _17 as *const impl Sized (PtrToPtr);
-        goto -> bb4;
     }
 
     bb4: {
-        // DBG: _37 = &_2;
+        StorageDead(_5);
-        // DBG: _36 = &((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>);
+        drop(_3) -> [return: bb5, unwind continue];
-        // DBG: _38 = &(((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner);
-        switchInt(const <impl Sized as std::mem::SizedTypeProperties>::SIZE) -> [0: bb5, otherwise: bb6];
     }
 
     bb5: {
-        _19 = const usize::MAX;
+        StorageDead(_3);
-        goto -> bb7;
-    }
-
-    bb6: {
-        StorageLive(_20);
-        _20 = copy ((((_2.0: std::vec::Vec<impl Sized>).0: alloc::raw_vec::RawVec<impl Sized>).0: alloc::raw_vec::RawVecInner).1: core::num::niche_types::UsizeNoHighBit);
-        _19 = copy _20 as usize (Transmute);
-        StorageDead(_20);
-        goto -> bb7;
-    }
-
-    bb7: {
-        _21 = std::vec::IntoIter::<impl Sized> { buf: copy _6, phantom: const ZeroSized: PhantomData<impl Sized>, cap: move _19, alloc: const ManuallyDrop::<std::alloc::Global> {{ value: std::alloc::Global }}, ptr: copy _6, end: copy _11 };
         StorageDead(_2);
-        StorageDead(_17);
-        StorageDead(_4);
-        StorageDead(_5);
-        StorageDead(_19);
-        StorageDead(_11);
-        StorageDead(_7);
-        StorageDead(_6);
-        StorageLive(_22);
-        _22 = move _21;
-        goto -> bb8;
-    }
-
-    bb8: {
-        StorageLive(_24);
-        _23 = &mut _22;
-        _24 = <std::vec::IntoIter<impl Sized> as Iterator>::next(move _23) -> [return: bb9, unwind: bb15];
-    }
-
-    bb9: {
-        _25 = discriminant(_24);
-        switchInt(move _25) -> [0: bb10, 1: bb12, otherwise: bb14];
-    }
-
-    bb10: {
-        StorageDead(_24);
-        drop(_22) -> [return: bb11, unwind continue];
-    }
-
-    bb11: {
-        StorageDead(_22);
-        StorageDead(_21);
         return;
     }
 
-    bb12: {
+    bb6: {
-        _26 = move ((_24 as Some).0: impl Sized);
+        _7 = move ((_5 as Some).0: impl Sized);
-        _27 = opaque::<impl Sized>(move _26) -> [return: bb13, unwind: bb15];
+        _8 = opaque::<impl Sized>(move _7) -> [return: bb7, unwind: bb9];
     }
 
-    bb13: {
+    bb7: {
-        StorageDead(_24);
+        StorageDead(_5);
-        goto -> bb8;
+        goto -> bb2;
     }
 
-    bb14: {
+    bb8: {
         unreachable;
     }
 
-    bb15 (cleanup): {
+    bb9 (cleanup): {
-        drop(_22) -> [return: bb16, unwind terminate(cleanup)];
+        drop(_3) -> [return: bb10, unwind terminate(cleanup)];
     }
 
-    bb16 (cleanup): {
+    bb10 (cleanup): {
         resume;
     }
 }

tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir

@@ -5,27 +5,27 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     debug f => _2;
     let mut _0: ();
     let mut _10: usize;
-    let mut _28: std::option::Option<(usize, &T)>;
+    let mut _29: std::option::Option<(usize, &T)>;
-    let mut _31: &impl Fn(usize, &T);
+    let mut _32: &impl Fn(usize, &T);
-    let mut _32: (usize, &T);
+    let mut _33: (usize, &T);
-    let _33: ();
+    let _34: ();
     scope 1 {
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _6;
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).1: *const T) => _9;
         debug (((iter: Enumerate<std::slice::Iter<'_, T>>).0: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
         debug ((iter: Enumerate<std::slice::Iter<'_, T>>).1: usize) => _10;
-        let _29: usize;
+        let _30: usize;
-        let _30: &T;
+        let _31: &T;
         scope 2 {
-            debug i => _29;
+            debug i => _30;
-            debug x => _30;
+            debug x => _31;
         }
         scope 18 (inlined <Enumerate<std::slice::Iter<'_, T>> as Iterator>::next) {
-            let mut _23: std::option::Option<&T>;
+            let mut _24: std::option::Option<&T>;
-            let mut _26: (usize, bool);
+            let mut _27: (usize, bool);
-            let mut _27: (usize, &T);
+            let mut _28: (usize, &T);
             scope 19 {
-                let _25: usize;
+                let _26: usize;
                 scope 24 {
                 }
             }
@@ -40,7 +40,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 }
             }
             scope 25 (inlined <Option<&T> as Try>::branch) {
-                let _24: &T;
+                let _25: &T;
                 scope 26 {
                 }
             }
@@ -49,8 +49,9 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                 let _11: std::ptr::NonNull<T>;
                 let _13: std::ptr::NonNull<T>;
                 let mut _16: bool;
-                let mut _20: usize;
+                let mut _20: bool;
-                let _22: &T;
+                let mut _21: usize;
+                let _23: &T;
                 scope 29 {
                     let _12: *const T;
                     scope 30 {
@@ -84,7 +85,7 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
                             }
                         }
                         scope 43 (inlined NonNull::<T>::as_ref::<'_>) {
-                            let _21: *const T;
+                            let _22: *const T;
                             scope 44 (inlined NonNull::<T>::as_ptr) {
                             }
                             scope 45 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -169,16 +170,16 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
     }
 
     bb4: {
-        StorageLive(_28);
+        StorageLive(_29);
-        StorageLive(_25);
         StorageLive(_26);
-        StorageLive(_23);
+        StorageLive(_27);
+        StorageLive(_24);
         StorageLive(_11);
         StorageLive(_12);
         StorageLive(_19);
-        StorageLive(_20);
+        StorageLive(_21);
         StorageLive(_13);
-        StorageLive(_22);
+        StorageLive(_23);
         _11 = copy _6;
         _12 = copy _9;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
@@ -206,88 +207,92 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () {
         StorageDead(_17);
         _6 = NonNull::<T> { pointer: copy _18 };
         StorageDead(_18);
-        goto -> bb13;
+        goto -> bb10;
     }
 
     bb7: {
         StorageDead(_16);
-        goto -> bb10;
+        goto -> bb14;
     }
 
     bb8: {
         _19 = copy _12 as usize (Transmute);
-        switchInt(copy _19) -> [0: bb9, otherwise: bb12];
+        StorageLive(_20);
+        _20 = Eq(copy _19, const 0_usize);
+        switchInt(move _20) -> [0: bb9, otherwise: bb13];
     }
 
     bb9: {
+        StorageDead(_20);
+        _21 = SubUnchecked(copy _19, const 1_usize);
+        _9 = copy _21 as *const T (Transmute);
         goto -> bb10;
     }
 
     bb10: {
+        StorageLive(_22);
+        _22 = copy _11 as *const T (Transmute);
+        _23 = &(*_22);
         StorageDead(_22);
+        _24 = Option::<&T>::Some(copy _23);
+        StorageDead(_23);
         StorageDead(_13);
-        StorageDead(_20);
+        StorageDead(_21);
         StorageDead(_19);
         StorageDead(_12);
         StorageDead(_11);
-        StorageDead(_23);
+        _25 = copy ((_24 as Some).0: &T);
-        StorageDead(_26);
+        StorageDead(_24);
-        StorageDead(_25);
+        _26 = copy _10;
-        StorageDead(_28);
+        _27 = AddWithOverflow(copy _10, const 1_usize);
-        StorageDead(_10);
+        assert(!move (_27.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _10, const 1_usize) -> [success: bb11, unwind unreachable];
-        drop(_2) -> [return: bb11, unwind unreachable];
     }
 
     bb11: {
-        return;
+        _10 = move (_27.0: usize);
+        StorageLive(_28);
+        _28 = (copy _26, copy _25);
+        _29 = Option::<(usize, &T)>::Some(move _28);
+        StorageDead(_28);
+        StorageDead(_27);
+        StorageDead(_26);
+        _30 = copy (((_29 as Some).0: (usize, &T)).0: usize);
+        _31 = copy (((_29 as Some).0: (usize, &T)).1: &T);
+        StorageLive(_32);
+        _32 = &_2;
+        StorageLive(_33);
+        _33 = (copy _30, copy _31);
+        _34 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _32, move _33) -> [return: bb12, unwind unreachable];
     }
 
     bb12: {
-        _20 = SubUnchecked(copy _19, const 1_usize);
+        StorageDead(_33);
-        _9 = copy _20 as *const T (Transmute);
+        StorageDead(_32);
-        goto -> bb13;
+        StorageDead(_29);
+        goto -> bb4;
     }
 
     bb13: {
-        StorageLive(_21);
-        _21 = copy _11 as *const T (Transmute);
-        _22 = &(*_21);
-        StorageDead(_21);
-        _23 = Option::<&T>::Some(copy _22);
-        StorageDead(_22);
-        StorageDead(_13);
         StorageDead(_20);
-        StorageDead(_19);
+        goto -> bb14;
-        StorageDead(_12);
-        StorageDead(_11);
-        _24 = copy ((_23 as Some).0: &T);
-        StorageDead(_23);
-        _25 = copy _10;
-        _26 = AddWithOverflow(copy _10, const 1_usize);
-        assert(!move (_26.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _10, const 1_usize) -> [success: bb14, unwind unreachable];
     }
 
     bb14: {
-        _10 = move (_26.0: usize);
+        StorageDead(_23);
-        StorageLive(_27);
+        StorageDead(_13);
-        _27 = (copy _25, copy _24);
+        StorageDead(_21);
-        _28 = Option::<(usize, &T)>::Some(move _27);
+        StorageDead(_19);
+        StorageDead(_12);
+        StorageDead(_11);
+        StorageDead(_24);
         StorageDead(_27);
         StorageDead(_26);
-        StorageDead(_25);
+        StorageDead(_29);
-        _29 = copy (((_28 as Some).0: (usize, &T)).0: usize);
+        StorageDead(_10);
-        _30 = copy (((_28 as Some).0: (usize, &T)).1: &T);
+        drop(_2) -> [return: bb15, unwind unreachable];
-        StorageLive(_31);
-        _31 = &_2;
-        StorageLive(_32);
-        _32 = (copy _29, copy _30);
-        _33 = <impl Fn(usize, &T) as Fn<(usize, &T)>>::call(move _31, move _32) -> [return: bb15, unwind unreachable];
     }
 
     bb15: {
-        StorageDead(_32);
+        return;
-        StorageDead(_31);
-        StorageDead(_28);
-        goto -> bb4;
     }
 }

tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir

@@ -4,25 +4,26 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _22: std::option::Option<&T>;
+    let mut _23: std::option::Option<&T>;
-    let mut _24: &impl Fn(&T);
+    let mut _25: &impl Fn(&T);
-    let mut _25: (&T,);
+    let mut _26: (&T,);
-    let _26: ();
+    let _27: ();
     scope 1 {
         debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _6;
         debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _9;
         debug ((iter: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
-        let _23: &T;
+        let _24: &T;
         scope 2 {
-            debug x => _23;
+            debug x => _24;
         }
         scope 16 (inlined <std::slice::Iter<'_, T> as Iterator>::next) {
             let mut _6: std::ptr::NonNull<T>;
             let _10: std::ptr::NonNull<T>;
             let _12: std::ptr::NonNull<T>;
             let mut _15: bool;
-            let mut _19: usize;
+            let mut _19: bool;
-            let _21: &T;
+            let mut _20: usize;
+            let _22: &T;
             scope 17 {
                 let _11: *const T;
                 scope 18 {
@@ -56,7 +57,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                         }
                     }
                     scope 31 (inlined NonNull::<T>::as_ref::<'_>) {
-                        let _20: *const T;
+                        let _21: *const T;
                         scope 32 (inlined NonNull::<T>::as_ptr) {
                         }
                         scope 33 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -134,13 +135,13 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb4: {
-        StorageLive(_22);
+        StorageLive(_23);
         StorageLive(_10);
         StorageLive(_11);
         StorageLive(_18);
-        StorageLive(_19);
+        StorageLive(_20);
         StorageLive(_12);
-        StorageLive(_21);
+        StorageLive(_22);
         _10 = copy _6;
         _11 = copy _9;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
@@ -168,68 +169,72 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageDead(_16);
         _6 = NonNull::<T> { pointer: copy _17 };
         StorageDead(_17);
-        goto -> bb13;
+        goto -> bb10;
     }
 
     bb7: {
         StorageDead(_15);
-        goto -> bb10;
+        goto -> bb13;
     }
 
     bb8: {
         _18 = copy _11 as usize (Transmute);
-        switchInt(copy _18) -> [0: bb9, otherwise: bb12];
+        StorageLive(_19);
+        _19 = Eq(copy _18, const 0_usize);
+        switchInt(move _19) -> [0: bb9, otherwise: bb12];
     }
 
     bb9: {
+        StorageDead(_19);
+        _20 = SubUnchecked(copy _18, const 1_usize);
+        _9 = copy _20 as *const T (Transmute);
         goto -> bb10;
     }
 
     bb10: {
+        StorageLive(_21);
+        _21 = copy _10 as *const T (Transmute);
+        _22 = &(*_21);
         StorageDead(_21);
+        _23 = Option::<&T>::Some(copy _22);
+        StorageDead(_22);
         StorageDead(_12);
-        StorageDead(_19);
+        StorageDead(_20);
         StorageDead(_18);
         StorageDead(_11);
         StorageDead(_10);
-        StorageDead(_22);
+        _24 = copy ((_23 as Some).0: &T);
-        drop(_2) -> [return: bb11, unwind unreachable];
+        StorageLive(_25);
+        _25 = &_2;
+        StorageLive(_26);
+        _26 = (copy _24,);
+        _27 = <impl Fn(&T) as Fn<(&T,)>>::call(move _25, move _26) -> [return: bb11, unwind unreachable];
     }
 
     bb11: {
-        return;
+        StorageDead(_26);
+        StorageDead(_25);
+        StorageDead(_23);
+        goto -> bb4;
     }
 
     bb12: {
-        _19 = SubUnchecked(copy _18, const 1_usize);
+        StorageDead(_19);
-        _9 = copy _19 as *const T (Transmute);
         goto -> bb13;
     }
 
     bb13: {
-        StorageLive(_20);
+        StorageDead(_22);
-        _20 = copy _10 as *const T (Transmute);
-        _21 = &(*_20);
-        StorageDead(_20);
-        _22 = Option::<&T>::Some(copy _21);
-        StorageDead(_21);
         StorageDead(_12);
-        StorageDead(_19);
+        StorageDead(_20);
         StorageDead(_18);
         StorageDead(_11);
         StorageDead(_10);
-        _23 = copy ((_22 as Some).0: &T);
+        StorageDead(_23);
-        StorageLive(_24);
+        drop(_2) -> [return: bb14, unwind unreachable];
-        _24 = &_2;
-        StorageLive(_25);
-        _25 = (copy _23,);
-        _26 = <impl Fn(&T) as Fn<(&T,)>>::call(move _24, move _25) -> [return: bb14, unwind unreachable];
     }
 
     bb14: {
-        StorageDead(_25);
+        return;
-        StorageDead(_24);
-        StorageDead(_22);
-        goto -> bb4;
     }
 }

tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir

@@ -4,25 +4,26 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     debug slice => _1;
     debug f => _2;
     let mut _0: ();
-    let mut _22: std::option::Option<&T>;
+    let mut _23: std::option::Option<&T>;
-    let mut _24: &impl Fn(&T);
+    let mut _25: &impl Fn(&T);
-    let mut _25: (&T,);
+    let mut _26: (&T,);
-    let _26: ();
+    let _27: ();
     scope 1 {
         debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull<T>) => _6;
         debug ((iter: std::slice::Iter<'_, T>).1: *const T) => _9;
         debug ((iter: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>;
-        let _23: &T;
+        let _24: &T;
         scope 2 {
-            debug x => _23;
+            debug x => _24;
         }
         scope 16 (inlined <std::slice::Iter<'_, T> as Iterator>::next) {
             let mut _6: std::ptr::NonNull<T>;
             let _10: std::ptr::NonNull<T>;
             let _12: std::ptr::NonNull<T>;
             let mut _15: bool;
-            let mut _19: usize;
+            let mut _19: bool;
-            let _21: &T;
+            let mut _20: usize;
+            let _22: &T;
             scope 17 {
                 let _11: *const T;
                 scope 18 {
@@ -56,7 +57,7 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
                         }
                     }
                     scope 31 (inlined NonNull::<T>::as_ref::<'_>) {
-                        let _20: *const T;
+                        let _21: *const T;
                         scope 32 (inlined NonNull::<T>::as_ptr) {
                         }
                         scope 33 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -134,13 +135,13 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
     }
 
     bb4: {
-        StorageLive(_22);
+        StorageLive(_23);
         StorageLive(_10);
         StorageLive(_11);
         StorageLive(_18);
-        StorageLive(_19);
+        StorageLive(_20);
         StorageLive(_12);
-        StorageLive(_21);
+        StorageLive(_22);
         _10 = copy _6;
         _11 = copy _9;
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb5, otherwise: bb8];
@@ -168,76 +169,80 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () {
         StorageDead(_16);
         _6 = NonNull::<T> { pointer: copy _17 };
         StorageDead(_17);
-        goto -> bb13;
+        goto -> bb10;
     }
 
     bb7: {
         StorageDead(_15);
-        goto -> bb10;
+        goto -> bb15;
     }
 
     bb8: {
         _18 = copy _11 as usize (Transmute);
-        switchInt(copy _18) -> [0: bb9, otherwise: bb12];
+        StorageLive(_19);
+        _19 = Eq(copy _18, const 0_usize);
+        switchInt(move _19) -> [0: bb9, otherwise: bb14];
     }
 
     bb9: {
+        StorageDead(_19);
+        _20 = SubUnchecked(copy _18, const 1_usize);
+        _9 = copy _20 as *const T (Transmute);
         goto -> bb10;
     }
 
     bb10: {
+        StorageLive(_21);
+        _21 = copy _10 as *const T (Transmute);
+        _22 = &(*_21);
         StorageDead(_21);
+        _23 = Option::<&T>::Some(copy _22);
+        StorageDead(_22);
         StorageDead(_12);
-        StorageDead(_19);
+        StorageDead(_20);
         StorageDead(_18);
         StorageDead(_11);
         StorageDead(_10);
-        StorageDead(_22);
+        _24 = copy ((_23 as Some).0: &T);
-        drop(_2) -> [return: bb11, unwind continue];
+        StorageLive(_25);
+        _25 = &_2;
+        StorageLive(_26);
+        _26 = (copy _24,);
+        _27 = <impl Fn(&T) as Fn<(&T,)>>::call(move _25, move _26) -> [return: bb11, unwind: bb12];
     }
 
     bb11: {
-        return;
+        StorageDead(_26);
-    }
-
-    bb12: {
-        _19 = SubUnchecked(copy _18, const 1_usize);
-        _9 = copy _19 as *const T (Transmute);
-        goto -> bb13;
-    }
-
-    bb13: {
-        StorageLive(_20);
-        _20 = copy _10 as *const T (Transmute);
-        _21 = &(*_20);
-        StorageDead(_20);
-        _22 = Option::<&T>::Some(copy _21);
-        StorageDead(_21);
-        StorageDead(_12);
-        StorageDead(_19);
-        StorageDead(_18);
-        StorageDead(_11);
-        StorageDead(_10);
-        _23 = copy ((_22 as Some).0: &T);
-        StorageLive(_24);
-        _24 = &_2;
-        StorageLive(_25);
-        _25 = (copy _23,);
-        _26 = <impl Fn(&T) as Fn<(&T,)>>::call(move _24, move _25) -> [return: bb14, unwind: bb15];
-    }
-
-    bb14: {
         StorageDead(_25);
-        StorageDead(_24);
+        StorageDead(_23);
-        StorageDead(_22);
         goto -> bb4;
     }
 
-    bb15 (cleanup): {
+    bb12 (cleanup): {
-        drop(_2) -> [return: bb16, unwind terminate(cleanup)];
+        drop(_2) -> [return: bb13, unwind terminate(cleanup)];
     }
 
-    bb16 (cleanup): {
+    bb13 (cleanup): {
         resume;
     }
+
+    bb14: {
+        StorageDead(_19);
+        goto -> bb15;
+    }
+
+    bb15: {
+        StorageDead(_22);
+        StorageDead(_12);
+        StorageDead(_20);
+        StorageDead(_18);
+        StorageDead(_11);
+        StorageDead(_10);
+        StorageDead(_23);
+        drop(_2) -> [return: bb16, unwind continue];
+    }
+
+    bb16: {
+        return;
+    }
 }

tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir

@@ -8,8 +8,9 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         let _4: std::ptr::NonNull<T>;
         let mut _7: bool;
         let mut _10: std::ptr::NonNull<T>;
-        let mut _12: usize;
+        let mut _12: bool;
-        let _14: &T;
+        let mut _13: usize;
+        let _15: &T;
         scope 2 {
             let _3: *const T;
             scope 3 {
@@ -43,7 +44,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
                     }
                 }
                 scope 16 (inlined NonNull::<T>::as_ref::<'_>) {
-                    let _13: *const T;
+                    let _14: *const T;
                     scope 17 (inlined NonNull::<T>::as_ptr) {
                     }
                     scope 18 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -57,9 +58,9 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         StorageLive(_2);
         StorageLive(_3);
         StorageLive(_11);
-        StorageLive(_12);
+        StorageLive(_13);
         StorageLive(_4);
-        StorageLive(_14);
+        StorageLive(_15);
         _2 = copy ((*_1).0: std::ptr::NonNull<T>);
         _3 = copy ((*_1).1: *const T);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb4];
@@ -90,7 +91,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         StorageDead(_9);
         ((*_1).0: std::ptr::NonNull<T>) = move _10;
         StorageDead(_10);
-        goto -> bb7;
+        goto -> bb6;
     }
 
     bb3: {
@@ -101,33 +102,37 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
 
     bb4: {
         _11 = copy _3 as usize (Transmute);
-        switchInt(copy _11) -> [0: bb5, otherwise: bb6];
+        StorageLive(_12);
+        _12 = Eq(copy _11, const 0_usize);
+        switchInt(move _12) -> [0: bb5, otherwise: bb7];
     }
 
     bb5: {
-        _0 = const {transmute(0x0000000000000000): Option<&T>};
+        StorageDead(_12);
-        goto -> bb8;
+        _13 = SubUnchecked(copy _11, const 1_usize);
+        ((*_1).1: *const T) = copy _13 as *const T (Transmute);
+        goto -> bb6;
     }
 
     bb6: {
-        _12 = SubUnchecked(copy _11, const 1_usize);
+        StorageLive(_14);
-        ((*_1).1: *const T) = copy _12 as *const T (Transmute);
+        _14 = copy _2 as *const T (Transmute);
-        goto -> bb7;
+        _15 = &(*_14);
+        StorageDead(_14);
+        _0 = Option::<&T>::Some(copy _15);
+        goto -> bb8;
     }
 
     bb7: {
-        StorageLive(_13);
+        _0 = const {transmute(0x0000000000000000): Option<&T>};
-        _13 = copy _2 as *const T (Transmute);
+        StorageDead(_12);
-        _14 = &(*_13);
-        StorageDead(_13);
-        _0 = Option::<&T>::Some(copy _14);
         goto -> bb8;
     }
 
     bb8: {
-        StorageDead(_14);
+        StorageDead(_15);
         StorageDead(_4);
-        StorageDead(_12);
+        StorageDead(_13);
         StorageDead(_11);
         StorageDead(_3);
         StorageDead(_2);

tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir

@@ -8,8 +8,9 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         let _4: std::ptr::NonNull<T>;
         let mut _7: bool;
         let mut _10: std::ptr::NonNull<T>;
-        let mut _12: usize;
+        let mut _12: bool;
-        let _14: &T;
+        let mut _13: usize;
+        let _15: &T;
         scope 2 {
             let _3: *const T;
             scope 3 {
@@ -43,7 +44,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
                     }
                 }
                 scope 16 (inlined NonNull::<T>::as_ref::<'_>) {
-                    let _13: *const T;
+                    let _14: *const T;
                     scope 17 (inlined NonNull::<T>::as_ptr) {
                     }
                     scope 18 (inlined std::ptr::mut_ptr::<impl *mut T>::cast_const) {
@@ -57,9 +58,9 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         StorageLive(_2);
         StorageLive(_3);
         StorageLive(_11);
-        StorageLive(_12);
+        StorageLive(_13);
         StorageLive(_4);
-        StorageLive(_14);
+        StorageLive(_15);
         _2 = copy ((*_1).0: std::ptr::NonNull<T>);
         _3 = copy ((*_1).1: *const T);
         switchInt(const <T as std::mem::SizedTypeProperties>::IS_ZST) -> [0: bb1, otherwise: bb4];
@@ -90,7 +91,7 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
         StorageDead(_9);
         ((*_1).0: std::ptr::NonNull<T>) = move _10;
         StorageDead(_10);
-        goto -> bb7;
+        goto -> bb6;
     }
 
     bb3: {
@@ -101,33 +102,37 @@ fn slice_iter_next(_1: &mut std::slice::Iter<'_, T>) -> Option<&T> {
 
     bb4: {
         _11 = copy _3 as usize (Transmute);
-        switchInt(copy _11) -> [0: bb5, otherwise: bb6];
+        StorageLive(_12);
+        _12 = Eq(copy _11, const 0_usize);
+        switchInt(move _12) -> [0: bb5, otherwise: bb7];
     }
 
     bb5: {
-        _0 = const {transmute(0x0000000000000000): Option<&T>};
+        StorageDead(_12);
-        goto -> bb8;
+        _13 = SubUnchecked(copy _11, const 1_usize);
+        ((*_1).1: *const T) = copy _13 as *const T (Transmute);
+        goto -> bb6;
     }
 
     bb6: {
-        _12 = SubUnchecked(copy _11, const 1_usize);
+        StorageLive(_14);
-        ((*_1).1: *const T) = copy _12 as *const T (Transmute);
+        _14 = copy _2 as *const T (Transmute);
-        goto -> bb7;
+        _15 = &(*_14);
+        StorageDead(_14);
+        _0 = Option::<&T>::Some(copy _15);
+        goto -> bb8;
     }
 
     bb7: {
-        StorageLive(_13);
+        _0 = const {transmute(0x0000000000000000): Option<&T>};
-        _13 = copy _2 as *const T (Transmute);
+        StorageDead(_12);
-        _14 = &(*_13);
-        StorageDead(_13);
-        _0 = Option::<&T>::Some(copy _14);
         goto -> bb8;
     }
 
     bb8: {
-        StorageDead(_14);
+        StorageDead(_15);
         StorageDead(_4);
-        StorageDead(_12);
+        StorageDead(_13);
         StorageDead(_11);
         StorageDead(_3);
         StorageDead(_2);

tests/rustdoc-gui/globals.goml

@@ -1,20 +0,0 @@
-// Make sure search stores its data in `window`
-// It needs to use a global to avoid racing on search-index.js and search.js
-// https://github.com/rust-lang/rust/pull/118961
-include: "utils.goml"
-
-// URL query
-go-to: "file://" + |DOC_PATH| + "/test_docs/index.html?search=sa'%3Bda'%3Bds"
-wait-for: "#search-tabs"
-assert-window-property-false: {"searchIndex": null}
-
-// Form input
-go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
-call-function: ("perform-search", {"query": "Foo"})
-assert-window-property-false: {"searchIndex": null}
-
-// source sidebar
-go-to: "file://" + |DOC_PATH| + "/src/test_docs/lib.rs.html"
-click: "#sidebar-button"
-wait-for: "#src-sidebar details"
-assert-window-property: {"searchIndex": null}