diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml index 05aa600e649e..2458eb5fafb1 100644 --- a/.github/workflows/ci.yml +++ b/.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 ' -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 diff --git a/.github/workflows/post-merge.yml b/.github/workflows/post-merge.yml index d38cc0e8a17f..c3d9217a645b 100644 --- a/.github/workflows/post-merge.yml +++ b/.github/workflows/post-merge.yml @@ -29,7 +29,7 @@ jobs: sleep 60 # Get closest bors merge commit - PARENT_COMMIT=`git rev-list --author='bors ' -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 diff --git a/RELEASES.md b/RELEASES.md index b14cc499b46d..615146eddc92 100644 --- a/RELEASES.md +++ b/RELEASES.md @@ -1,3 +1,208 @@ +Version 1.93.1 (2026-02-12) +=========================== + + + +- [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) +========================== + + + +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) + + + + +Compiler +-------- +- [Stabilize `-Cjump-tables=bool`](https://github.com/rust-lang/rust/pull/145974). The flag was previously called `-Zno-jump-tables`. + + + +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 + + + +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: UnwindSafe`](https://github.com/rust-lang/rust/pull/145665) + + + + +Stabilized APIs +--------------- + +- [`<[MaybeUninit]>::assume_init_drop`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.assume_init_drop) +- [`<[MaybeUninit]>::assume_init_ref`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.assume_init_ref) +- [`<[MaybeUninit]>::assume_init_mut`](https://doc.rust-lang.org/stable/core/primitive.slice.html#method.assume_init_mut) +- [`<[MaybeUninit]>::write_copy_of_slice`](https://doc.rust-lang.org/stable/std/primitive.slice.html#method.write_copy_of_slice) +- [`<[MaybeUninit]>::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) +- [`::unchecked_neg`](https://doc.rust-lang.org/stable/std/primitive.isize.html#method.unchecked_neg) +- [`::unchecked_shl`](https://doc.rust-lang.org/stable/std/primitive.isize.html#method.unchecked_shl) +- [`::unchecked_shr`](https://doc.rust-lang.org/stable/std/primitive.isize.html#method.unchecked_shr) +- [`::unchecked_shl`](https://doc.rust-lang.org/stable/std/primitive.usize.html#method.unchecked_shl) +- [`::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) + + + + +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/) + + + +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`. + + + + +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) +========================== + + + +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`](https://github.com/rust-lang/rust/pull/147382). This avoids having to check for an error that can never happen. + + + +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. + + + +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. + + + +Stabilized APIs +--------------- + +- [`NonZero::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 for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CGroup%3E-for-TokenStream) +- [`impl Extend for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CLiteral%3E-for-TokenStream) +- [`impl Extend for proc_macro::TokenStream`](https://doc.rust-lang.org/stable/proc_macro/struct.TokenStream.html#impl-Extend%3CPunct%3E-for-TokenStream) +- [`impl Extend 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) + + + +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). + + + +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. + + + +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`](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) =========================== diff --git a/compiler/rustc_feature/src/accepted.rs b/compiler/rustc_feature/src/accepted.rs index 7e765918d7b6..13c1f2219bed 100644 --- a/compiler/rustc_feature/src/accepted.rs +++ b/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). diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs index cd61facb39bb..e5d66364c2a6 100644 --- a/compiler/rustc_feature/src/removed.rs +++ b/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), diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs index 3ef4eb00c354..5880af0909bf 100644 --- a/compiler/rustc_feature/src/unstable.rs +++ b/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)]`. diff --git a/compiler/rustc_lint/src/interior_mutable_consts.rs b/compiler/rustc_lint/src/interior_mutable_consts.rs index 8576698dec33..4c7d2c6af93b 100644 --- a/compiler/rustc_lint/src/interior_mutable_consts.rs +++ b/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), diff --git a/compiler/rustc_mir_build/src/builder/mod.rs b/compiler/rustc_mir_build/src/builder/mod.rs index 206eb9126f54..14a24265a8f4 100644 --- a/compiler/rustc_mir_build/src/builder/mod.rs +++ b/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)); } diff --git a/compiler/rustc_mir_transform/src/liveness.rs b/compiler/rustc_mir_transform/src/liveness.rs index 7ee7c3a81c7e..1d1ba455a81e 100644 --- a/compiler/rustc_mir_transform/src/liveness.rs +++ b/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; diff --git a/compiler/rustc_mir_transform/src/simplify_comparison_integral.rs b/compiler/rustc_mir_transform/src/simplify_comparison_integral.rs index 2643d78990e5..54f9f8809a75 100644 --- a/compiler/rustc_mir_transform/src/simplify_comparison_integral.rs +++ b/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>) { diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs index abc0ffa87d3d..5e725fd90562 100644 --- a/compiler/rustc_parse/src/parser/item.rs +++ b/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) diff --git a/library/alloc/src/collections/vec_deque/mod.rs b/library/alloc/src/collections/vec_deque/mod.rs index ea9d5b128ebe..0e01d0d19e7a 100644 --- a/library/alloc/src/collections/vec_deque/mod.rs +++ b/library/alloc/src/collections/vec_deque/mod.rs @@ -2053,7 +2053,7 @@ impl VecDeque { /// 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 { let first = self.front_mut()?; if predicate(first) { self.pop_front() } else { None } @@ -2075,7 +2075,7 @@ impl VecDeque { /// 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 { let last = self.back_mut()?; if predicate(last) { self.pop_back() } else { None } diff --git a/library/alloc/src/fmt.rs b/library/alloc/src/fmt.rs index 4d6fe220a09a..3d7c580be8c9 100644 --- a/library/alloc/src/fmt.rs +++ b/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}; diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs index f5ba71c28833..78ab4b4bbadd 100644 --- a/library/alloc/src/string.rs +++ b/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() } diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs index 2adce8d27039..d397e1ed313e 100644 --- a/library/alloc/src/vec/mod.rs +++ b/library/alloc/src/vec/mod.rs @@ -781,7 +781,7 @@ impl Vec { /// 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()) diff --git a/library/core/src/char/methods.rs b/library/core/src/char/methods.rs index d1de2c560615..89cb06972392 100644 --- a/library/core/src/char/methods.rs +++ b/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` (�) is used in Unicode to represent a diff --git a/library/core/src/fmt/builders.rs b/library/core/src/fmt/builders.rs index 4ea6c6ba8fb9..197cddd3fa9d 100644 --- a/library/core/src/fmt/builders.rs +++ b/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) -> fmt::Result>(f: F) -> FromFn { FromFn(f) @@ -1235,10 +1235,10 @@ pub fn from_fn) -> fmt::Result>(f: F) -> FromFn /// 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); -#[stable(feature = "fmt_from_fn", since = "CURRENT_RUSTC_VERSION")] +#[stable(feature = "fmt_from_fn", since = "1.93.0")] impl fmt::Debug for FromFn 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 fmt::Display for FromFn where F: Fn(&mut fmt::Formatter<'_>) -> fmt::Result, diff --git a/library/core/src/fmt/mod.rs b/library/core/src/fmt/mod.rs index 7a80023ce64e..e20109c3cc9a 100644 --- a/library/core/src/fmt/mod.rs +++ b/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. diff --git a/library/core/src/io/borrowed_buf.rs b/library/core/src/io/borrowed_buf.rs index b765b96fd00a..088dea781294 100644 --- a/library/core/src/io/borrowed_buf.rs +++ b/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 -/// without having to initialize it first. It tracks the region of bytes that have been filled and -/// the region that remains uninitialized. +/// This type is a sort of "double cursor". It tracks three regions in the buffer: a region at the beginning of the +/// buffer that has been logically filled with data, a region that has been initialized at some point but not yet +/// 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 ] -/// [ len: filled and initialized | capacity - len: uninitialized ] +/// [ capacity ] +/// [ filled | unfilled ] +/// [ initialized | uninitialized ] /// ``` /// -/// Note that `BorrowedBuf` does not distinguish between uninitialized data and data that was -/// previously initialized but no longer contains valid data. -/// -/// A `BorrowedBuf` is created around some existing data (or capacity for data) via a unique -/// reference (`&mut`). The `BorrowedBuf` can be configured (e.g., using `clear` or `set_len`), but -/// 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. +/// A `BorrowedBuf` is created around some existing data (or capacity for data) via a unique reference +/// (`&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 +/// has write-only access to the unfilled portion of the buffer (you can think of it as a +/// write-only iterator). /// /// 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], /// 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 - // already initialized. + // SAFETY: initialized data never becoming uninitialized is an invariant of BorrowedBuf 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]> for BorrowedBuf<'data> { #[inline] fn from(buf: &'data mut [MaybeUninit]) -> BorrowedBuf<'data> { - BorrowedBuf { buf, filled: 0 } + BorrowedBuf { buf, filled: 0, init: 0 } } } @@ -68,11 +74,14 @@ impl<'data> From<&'data mut [MaybeUninit]> for BorrowedBuf<'data> { /// Use `BorrowedCursor::with_unfilled_buf` instead for a safer alternative. impl<'data> From> 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] { // 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` - /// must not exceed the remaining capacity of this cursor. + /// The caller must ensure that the first `n` bytes of the cursor have been properly + /// 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 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 - // too, because the buffer wasn't replaced. - self.buf.filled += buf.filled; + let filled = buf.filled; + let init = buf.init; + + // 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 } diff --git a/library/core/src/mem/maybe_uninit.rs b/library/core/src/mem/maybe_uninit.rs index e00cf45fcab2..cff6c0457d02 100644 --- a/library/core/src/mem/maybe_uninit.rs +++ b/library/core/src/mem/maybe_uninit.rs @@ -1140,8 +1140,8 @@ impl [MaybeUninit] { /// ``` /// /// [`write_clone_of_slice`]: slice::write_clone_of_slice - #[stable(feature = "maybe_uninit_write_slice", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_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 = "1.93.0")] pub const fn write_copy_of_slice(&mut self, src: &[T]) -> &mut [T] where T: Copy, @@ -1201,7 +1201,7 @@ impl [MaybeUninit] { /// ``` /// /// [`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 [MaybeUninit] { /// requirement the compiler knows about it is that the data pointer must be /// non-null. Dropping such a `Vec` 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 [MaybeUninit] { /// Calling this when the content is not yet fully initialized causes undefined /// behavior: it is up to the caller to guarantee that every `MaybeUninit` in /// the slice really is in an initialized state. - #[stable(feature = "maybe_uninit_slice", since = "CURRENT_RUSTC_VERSION")] - #[rustc_const_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 = "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 [MaybeUninit] { /// behavior: it is up to the caller to guarantee that every `MaybeUninit` 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")] - #[rustc_const_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 = "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 diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs index 99662768a29f..bc451197289e 100644 --- a/library/core/src/num/int_macros.rs +++ b/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")] - #[rustc_const_stable(feature = "unchecked_neg", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "unchecked_neg", since = "1.93.0")] + #[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")] - #[rustc_const_stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "unchecked_shifts", since = "1.93.0")] + #[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")] - #[rustc_const_stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "unchecked_shifts", since = "1.93.0")] + #[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)] diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs index c8224e92b17e..64adeda35288 100644 --- a/library/core/src/num/uint_macros.rs +++ b/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")] - #[rustc_const_stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "unchecked_shifts", since = "1.93.0")] + #[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")] - #[rustc_const_stable(feature = "unchecked_shifts", since = "CURRENT_RUSTC_VERSION")] + #[stable(feature = "unchecked_shifts", since = "1.93.0")] + #[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)] diff --git a/library/core/src/ptr/const_ptr.rs b/library/core/src/ptr/const_ptr.rs index 2860bf0a6e69..00b71f9a997c 100644 --- a/library/core/src/ptr/const_ptr.rs +++ b/library/core/src/ptr/const_ptr.rs @@ -1462,8 +1462,8 @@ impl *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")] - #[rustc_const_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 = "1.93.0")] #[inline] #[must_use] pub const fn as_array(self) -> Option<*const [T; N]> { diff --git a/library/core/src/ptr/mut_ptr.rs b/library/core/src/ptr/mut_ptr.rs index f8dc6ef7ed71..8976154c61db 100644 --- a/library/core/src/ptr/mut_ptr.rs +++ b/library/core/src/ptr/mut_ptr.rs @@ -1712,8 +1712,8 @@ impl *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")] - #[rustc_const_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 = "1.93.0")] #[inline] #[must_use] pub const fn as_mut_array(self) -> Option<*mut [T; N]> { diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs index f03f2045444d..edc31c04ef9b 100644 --- a/library/core/src/slice/mod.rs +++ b/library/core/src/slice/mod.rs @@ -842,8 +842,8 @@ impl [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")] - #[rustc_const_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 = "1.93.0")] #[inline] #[must_use] pub const fn as_array(&self) -> Option<&[T; N]> { @@ -861,8 +861,8 @@ impl [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")] - #[rustc_const_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 = "1.93.0")] #[inline] #[must_use] pub const fn as_mut_array(&mut self) -> Option<&mut [T; N]> { diff --git a/library/core/src/time.rs b/library/core/src/time.rs index 51a01545f5cf..20895c988c45 100644 --- a/library/core/src/time.rs +++ b/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")] - #[rustc_const_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 = "1.93.0")] #[must_use] #[inline] #[track_caller] diff --git a/library/coretests/tests/io/borrowed_buf.rs b/library/coretests/tests/io/borrowed_buf.rs index 730ba04465a1..aaa98d26ff8b 100644 --- a/library/coretests/tests/io/borrowed_buf.rs +++ b/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().as_mut().write_filled(0); - buf.unfilled().advance(4) - }; + buf.unfilled().ensure_init(); + 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]); } diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs index bcaafcfee787..0a5d1153d860 100644 --- a/library/std/src/fs/tests.rs +++ b/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)); } diff --git a/library/std/src/io/buffered/bufreader.rs b/library/std/src/io/buffered/bufreader.rs index 69c260b5410a..40441dc057d0 100644 --- a/library/std/src/io/buffered/bufreader.rs +++ b/library/std/src/io/buffered/bufreader.rs @@ -284,6 +284,15 @@ impl BufReader { } } +// This is only used by a test which asserts that the initialization-tracking is correct. +#[cfg(test)] +impl BufReader { + #[allow(missing_docs)] + pub fn initialized(&self) -> usize { + self.buf.initialized() + } +} + impl BufReader { /// 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. diff --git a/library/std/src/io/buffered/bufreader/buffer.rs b/library/std/src/io/buffered/bufreader/buffer.rs index 2694726b3f44..9b600cd55758 100644 --- a/library/std/src/io/buffered/bufreader/buffer.rs +++ b/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 { 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 { 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?; } diff --git a/library/std/src/io/buffered/tests.rs b/library/std/src/io/buffered/tests.rs index 068dca819775..17f6107aa030 100644 --- a/library/std/src/io/buffered/tests.rs +++ b/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 { + 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() { diff --git a/library/std/src/io/copy.rs b/library/std/src/io/copy.rs index 8b5e7c4df4e0..2b558efb8885 100644 --- a/library/std/src/io/copy.rs +++ b/library/std/src/io/copy.rs @@ -214,19 +214,28 @@ impl BufferedWriterSpec for BufWriter { } 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 BufferedWriterSpec for BufWriter { 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()?; } } diff --git a/library/std/src/io/mod.rs b/library/std/src/io/mod.rs index 4c064c435e5b..b7756befa11e 100644 --- a/library/std/src/io/mod.rs +++ b/library/std/src/io/mod.rs @@ -419,6 +419,8 @@ pub(crate) fn default_read_to_end( .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: &mut R, buf: &mut Vec) -> Result { @@ -447,6 +449,8 @@ pub(crate) fn default_read_to_end( } } + 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( 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( } }; + 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( 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(read: F, mut cursor: BorrowedCursor<'_>) -> Re where F: FnOnce(&mut [u8]) -> Result, { - // SAFETY: We do not uninitialize any part of the buffer. - let n = read(unsafe { cursor.as_mut().write_filled(0) })?; - assert!(n <= cursor.capacity()); - // SAFETY: We've initialized the entire buffer, and `read` can't make it uninitialized. - unsafe { - cursor.advance(n); - } + let n = read(cursor.ensure_init().init_mut())?; + cursor.advance(n); Ok(()) } @@ -3073,21 +3098,31 @@ impl Read for Take { // 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; diff --git a/library/std/src/io/tests.rs b/library/std/src/io/tests.rs index e14e6432eafa..b22988d4a8a9 100644 --- a/library/std/src/io/tests.rs +++ b/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; diff --git a/library/std/src/io/util.rs b/library/std/src/io/util.rs index a09c8bc06930..0410df3ef1a3 100644 --- a/library/std/src/io/util.rs +++ b/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(()) } diff --git a/library/std/src/io/util/tests.rs b/library/std/src/io/util/tests.rs index 92dbc3919bea..d0f106d7af41 100644 --- a/library/std/src/io/util/tests.rs +++ b/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); diff --git a/library/std/src/lib.rs b/library/std/src/lib.rs index 0401e9b39ff4..4f8094dc1f2f 100644 --- a/library/std/src/lib.rs +++ b/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; diff --git a/library/std/src/net/tcp/tests.rs b/library/std/src/net/tcp/tests.rs index 4787f8a1040b..7c7ef7b2f701 100644 --- a/library/std/src/net/tcp/tests.rs +++ b/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"); }) diff --git a/library/std/src/process/tests.rs b/library/std/src/process/tests.rs index c8a83edffe42..12c5130defe5 100644 --- a/library/std/src/process/tests.rs +++ b/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); }; } diff --git a/library/std/src/sys/fd/hermit.rs b/library/std/src/sys/fd/hermit.rs index afcd8c635541..7e8ba065f1b9 100644 --- a/library/std/src/sys/fd/hermit.rs +++ b/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(()) } diff --git a/library/std/src/sys/fd/unix.rs b/library/std/src/sys/fd/unix.rs index a631e1d91393..2b2dfe48e89e 100644 --- a/library/std/src/sys/fd/unix.rs +++ b/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(()) } diff --git a/library/std/src/sys/fd/wasi.rs b/library/std/src/sys/fd/wasi.rs index a468b31168af..80a5143ff0b0 100644 --- a/library/std/src/sys/fd/wasi.rs +++ b/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)), diff --git a/library/std/src/sys/fs/solid.rs b/library/std/src/sys/fs/solid.rs index ec1db262855a..f6d5d3b784d3 100644 --- a/library/std/src/sys/fs/solid.rs +++ b/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(()) } diff --git a/library/std/src/sys/net/connection/socket/hermit.rs b/library/std/src/sys/net/connection/socket/hermit.rs index f044bf8dfae0..2f5c6fa31d40 100644 --- a/library/std/src/sys/net/connection/socket/hermit.rs +++ b/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(()) } diff --git a/library/std/src/sys/net/connection/socket/solid.rs b/library/std/src/sys/net/connection/socket/solid.rs index 731157ec319c..14cf75adcc06 100644 --- a/library/std/src/sys/net/connection/socket/solid.rs +++ b/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(()) } diff --git a/library/std/src/sys/net/connection/socket/unix.rs b/library/std/src/sys/net/connection/socket/unix.rs index c892daf0d39c..559e27604a9d 100644 --- a/library/std/src/sys/net/connection/socket/unix.rs +++ b/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(()) } diff --git a/library/std/src/sys/net/connection/socket/wasip2.rs b/library/std/src/sys/net/connection/socket/wasip2.rs index f86034266c26..a1b08609eb02 100644 --- a/library/std/src/sys/net/connection/socket/wasip2.rs +++ b/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(()) } diff --git a/library/std/src/sys/net/connection/socket/windows.rs b/library/std/src/sys/net/connection/socket/windows.rs index 08196d61aa30..6dbebc5e276e 100644 --- a/library/std/src/sys/net/connection/socket/windows.rs +++ b/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(()) } } diff --git a/library/std/src/sys/pal/sgx/abi/usercalls/mod.rs b/library/std/src/sys/pal/sgx/abi/usercalls/mod.rs index f1e4a5a42577..5041770faf66 100644 --- a/library/std/src/sys/pal/sgx/abi/usercalls/mod.rs +++ b/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(()) } } diff --git a/library/std/src/sys/pal/windows/handle.rs b/library/std/src/sys/pal/windows/handle.rs index 712f41ba8030..76c8aa939d3b 100644 --- a/library/std/src/sys/pal/windows/handle.rs +++ b/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(()) } diff --git a/library/std/src/sys/pal/windows/pipe.rs b/library/std/src/sys/pal/windows/pipe.rs index d8e306068d73..b5ccf037a4f2 100644 --- a/library/std/src/sys/pal/windows/pipe.rs +++ b/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(()) } diff --git a/library/std/src/sys/stdio/zkvm.rs b/library/std/src/sys/stdio/zkvm.rs index 84496ac93736..f31c6c26e87c 100644 --- a/library/std/src/sys/stdio/zkvm.rs +++ b/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(()) } diff --git a/library/std_detect/src/detect/arch/mod.rs b/library/std_detect/src/detect/arch/mod.rs index 23e7a30b985b..2be7f091c285 100644 --- a/library/std_detect/src/detect/arch/mod.rs +++ b/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::*; } _ => { diff --git a/library/std_detect/src/detect/arch/s390x.rs b/library/std_detect/src/detect/arch/s390x.rs index 6122e8f5b837..a04283f90a02 100644 --- a/library/std_detect/src/detect/arch/s390x.rs +++ b/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 } diff --git a/library/stdarch/crates/core_arch/src/x86/avx2.rs b/library/stdarch/crates/core_arch/src/x86/avx2.rs index 8be302cabc77..e22e39fca882 100644 --- a/library/stdarch/crates/core_arch/src/x86/avx2.rs +++ b/library/stdarch/crates/core_arch/src/x86/avx2.rs @@ -1754,12 +1754,19 @@ pub fn _mm256_inserti128_si256(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 { - 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]); - let odd: i32x8 = simd_shuffle!(r, r, [1, 3, 5, 7, 9, 11, 13, 15]); - simd_add(even, odd).as_m256i() - } + // It's a trick used in the Adler-32 algorithm to perform a widening addition. + // + // ```rust + // #[target_feature(enable = "avx2")] + // 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"] diff --git a/library/stdarch/crates/core_arch/src/x86/avx512bw.rs b/library/stdarch/crates/core_arch/src/x86/avx512bw.rs index 0e2dd3ad4068..d6cc0921750b 100644 --- a/library/stdarch/crates/core_arch/src/x86/avx512bw.rs +++ b/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 { - let r: i32x32 = simd_mul(simd_cast(a.as_i16x32()), simd_cast(b.as_i16x32())); - let even: i32x16 = simd_shuffle!( - r, - r, - [0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20, 22, 24, 26, 28, 30] - ); - let odd: i32x16 = simd_shuffle!( - r, - r, - [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29, 31] - ); - simd_add(even, odd).as_m512i() - } + // It's a trick used in the Adler-32 algorithm to perform a widening addition. + // + // ```rust + // #[target_feature(enable = "avx512bw")] + // unsafe fn widening_add(mad: __m512i) -> __m512i { + // _mm512_madd_epi16(mad, _mm512_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(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; diff --git a/library/stdarch/crates/core_arch/src/x86/sse2.rs b/library/stdarch/crates/core_arch/src/x86/sse2.rs index 11335856fb22..c5b051bfb69d 100644 --- a/library/stdarch/crates/core_arch/src/x86/sse2.rs +++ b/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 { - 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]); - let odd: i32x4 = simd_shuffle!(r, r, [1, 3, 5, 7]); - simd_add(even, odd).as_m128i() - } + // It's a trick used in the Adler-32 algorithm to perform a widening addition. + // + // ```rust + // #[target_feature(enable = "sse2")] + // 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"] diff --git a/rust-bors.toml b/rust-bors.toml index e813c6c4b116..996b50b2ea27 100644 --- a/rust-bors.toml +++ b/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 diff --git a/src/build_helper/src/git.rs b/src/build_helper/src/git.rs index 42d9b00f004a..330fb465de42 100644 --- a/src/build_helper/src/git.rs +++ b/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)) } } diff --git a/src/ci/channel b/src/ci/channel index bf867e0ae5b6..2bf5ad0447d3 100644 --- a/src/ci/channel +++ b/src/ci/channel @@ -1 +1 @@ -nightly +stable diff --git a/src/ci/citool/src/main.rs b/src/ci/citool/src/main.rs index 4fe9cee900ca..d7b491d38f41 100644 --- a/src/ci/citool/src/main.rs +++ b/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, } diff --git a/src/ci/docker/host-x86_64/dist-various-2/Dockerfile b/src/ci/docker/host-x86_64/dist-various-2/Dockerfile index 90f46b5376e0..33d551239362 100644 --- a/src/ci/docker/host-x86_64/dist-various-2/Dockerfile +++ b/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 diff --git a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile b/src/ci/docker/host-x86_64/pr-check-2/Dockerfile index 68162d136c3f..c9c3e3d2a330 100644 --- a/src/ci/docker/host-x86_64/pr-check-2/Dockerfile +++ b/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" diff --git a/src/ci/docker/host-x86_64/test-various/Dockerfile b/src/ci/docker/host-x86_64/test-various/Dockerfile index 9b1bf6c0df99..e1c882d5b085 100644 --- a/src/ci/docker/host-x86_64/test-various/Dockerfile +++ b/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 \ diff --git a/src/ci/docker/run.sh b/src/ci/docker/run.sh index 044f5a8fff32..691b8b8deb81 100755 --- a/src/ci/docker/run.sh +++ b/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" \ diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml index 9acad5c06b21..7411b394b94a 100644 --- a/src/ci/github-actions/jobs.yml +++ b/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=` -# - `try-job: ` in the PR description and comment `@bors try` or `@bors2 try`. +# - comment `@bors try jobs=` +# - `try-job: ` 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. diff --git a/src/ci/scripts/verify-channel.sh b/src/ci/scripts/verify-channel.sh index 9a9e713243d7..cac8ba332ed1 100755 --- a/src/ci/scripts/verify-channel.sh +++ b/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 diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs index 8740b5935973..2e7a0f46d8cc 100644 --- a/src/librustdoc/html/render/mod.rs +++ b/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 - // 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)); + let repr = 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!(), } { diff --git a/src/llvm-project b/src/llvm-project index 16b5ac8b0a54..85a90d119deb 160000 --- a/src/llvm-project +++ b/src/llvm-project @@ -1 +1 @@ -Subproject commit 16b5ac8b0a5456eb23c72e1bff3fc9bd6e824f84 +Subproject commit 85a90d119deb25b518867cd37d62c7b93b575a6f diff --git a/src/stage0 b/src/stage0 index 0e4e9eb1c4b9..ea0fe3bf84c4 100644 --- a/src/stage0 +++ b/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_git_commit_hash=3b4dd9bf1410f8da6329baa36ce5e37673cbbd1f -compiler_date=2025-10-28 -compiler_version=beta -rustfmt_channel_manifest_hash=108599f303463cabaef3b53ab5e0c0e560a6a5a97f606d75a802efb595141baf -rustfmt_git_commit_hash=adaa838976ff99a4f0661136322f64cb466b58a0 -rustfmt_date=2025-10-28 -rustfmt_version=nightly +compiler_channel_manifest_hash=b2a49624353173ecdacf59c158c00929300606e1963f6e4609fb483a508402d0 +compiler_git_commit_hash=ded5c06cf21d2b93bffd5d884aa6e96934ee4234 +compiler_date=2025-12-11 +compiler_version=1.92.0 -dist/2025-10-28/rustc-beta-aarch64-apple-darwin.tar.gz=5d971d3a1c127d314f94f41440f0717b51692176630fef7f05a70d9bcd3bae44 -dist/2025-10-28/rustc-beta-aarch64-apple-darwin.tar.xz=2cedfc3a96acc9ebe82c5cf5bcf5355902a5726e1c28e7d50b15cfa2ee343174 -dist/2025-10-28/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=1875833b43088879444902023cc76682fa58f39520a1135e438afaacf3605f88 -dist/2025-10-28/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=a925fb02b296b8ce753ff7b1fae583a27fb2ef6de582a80f1428678a2f61a466 -dist/2025-10-28/rustc-beta-aarch64-pc-windows-msvc.tar.gz=28f423bb7db80232b887bd0d47243341a50611eca913c17c305dd55fa6bd3f12 -dist/2025-10-28/rustc-beta-aarch64-pc-windows-msvc.tar.xz=3be7d39a956afd591ba4b22785b4851fd6c0c7afd23d045c54d6b603cc14bc2d -dist/2025-10-28/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=8b98b7e04ef03c3b2bc95e0d6e3a92ad7849bad8d5a8969d6c9eefe169673066 -dist/2025-10-28/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=1b35688d58c10fdd1f1d02325022ae9eb36ee139f76ae753e16a0f4524d0f6d4 -dist/2025-10-28/rustc-beta-aarch64-unknown-linux-musl.tar.gz=c1de08dbaff419f08f82aef49972965d87e02054822e83e6e7f73714afbc4155 -dist/2025-10-28/rustc-beta-aarch64-unknown-linux-musl.tar.xz=2755a71cee31227e4638499dc882347ed9ecf0698cc64a177ff8a94c6ff3be8c -dist/2025-10-28/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=dac50bed8e2bb5d65b5f6ea52963d2b268829c9f79800304a225e058152be0bd -dist/2025-10-28/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=f818783e566cebc2ac392f923efd0ae8f51ae77ce6ade284514a57c21d288b7e -dist/2025-10-28/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=922d9d3aba6c5ac4da95ab9310d0f33ec7da4830a7d424b83d6f0181af96bccb -dist/2025-10-28/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=746a200dab88eec922dc08ea244ae818c27a0ca91360278e578ab9fc433bd3be -dist/2025-10-28/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=ac45fe7547dc1064286de6704a9343e95fa760163247ac02ff88ebf2bf4d7d8c -dist/2025-10-28/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=35ab727f335242d588742f79f29fb94590ac0c3bef29d012538f2e925cb9f96f -dist/2025-10-28/rustc-beta-i686-pc-windows-gnu.tar.gz=42eab38b498e0b8efd7fae51facd7caaf253e1bc341f915f978b484065e4c812 -dist/2025-10-28/rustc-beta-i686-pc-windows-gnu.tar.xz=d663982b6293285fa1ffcc5987ded64569216c0133476243b5525768cd6123bb -dist/2025-10-28/rustc-beta-i686-pc-windows-msvc.tar.gz=571eeccc9c1f25c4b9c2c6f45d15dbd9730bf6c0ac0f75a5b49652b6d4e98f68 -dist/2025-10-28/rustc-beta-i686-pc-windows-msvc.tar.xz=595a8b6b74910fa53a947ddde81f5519152f8c773a41a2f5b0d663540bc913fa -dist/2025-10-28/rustc-beta-i686-unknown-linux-gnu.tar.gz=3f2261279e5c16b0a4b572e799e2d3079aa33192e7713803214011e14c5c6707 -dist/2025-10-28/rustc-beta-i686-unknown-linux-gnu.tar.xz=c49c0e84b4b43aa6b72dc355173b4b5dc41563f3f76e882c405a8625c00befbc -dist/2025-10-28/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=92cea4e2708fbd86b35bc798b25a69ab10b62f28e972ff0624709e6e8268db60 -dist/2025-10-28/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=224f6e9896d19e00e369da70bc0e0dbd545d04033ff6ecff12b3f2d2bfe73fc8 -dist/2025-10-28/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=74901d397d5f6695df197520d16851986df2a5c5d432b8f24da1a5c3a5c0474b -dist/2025-10-28/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=02d8962da7234bfd365147b4177497a99c8f1f12f6841160abede61332edd35f -dist/2025-10-28/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=b8d810c76102a325cdecb98e7d7fab480a8d349328ce8a275366018a627fa4bf -dist/2025-10-28/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=f09c4e8d4a4ae4cf490e55bcd29ab00b6f7c1aed09c93b63f10fc3f812f415e7 -dist/2025-10-28/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=6c71850444d597cdc07a7169bd5d2564cbd99d1a34ec806ac8b818b39c9fd529 -dist/2025-10-28/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=01f3537787f41c2fd2ed1f955520ff0852bb27d899141cf44de3ae126abf8808 -dist/2025-10-28/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=833dcfab6dc87d375154d593c8e53cd5c74b3029f8b94c753928de718185283c -dist/2025-10-28/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=cf99a56b49b3db107d33f5c6e668310317aaeb2b2ca3c80a0ea2b30a09b453dd -dist/2025-10-28/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=55b1db794a4bb0f535e46a2c4a85eb7ea0016482b7086b6deae033746a42a69d -dist/2025-10-28/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=a741b18a92f5fa35cab2ed93d90782175b70e3ef5a127e21fde7acabb6228b59 -dist/2025-10-28/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=97335caa2ace3f33cd959dc35f01ec8a3d2de5699518b93fd191766eda3fe318 -dist/2025-10-28/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=2127853b7b4e2b3cf906ef292e9c7e370ec3f3760ce5576b447ed7902048794f -dist/2025-10-28/rustc-beta-s390x-unknown-linux-gnu.tar.gz=eb3df84c1a840cc69799ef0649972e5312afe59144700ba3652bd6083f48074a -dist/2025-10-28/rustc-beta-s390x-unknown-linux-gnu.tar.xz=16942680ea11ead1ab4d9d46d31389a14f237637a6877b278cd30a608446b787 -dist/2025-10-28/rustc-beta-sparcv9-sun-solaris.tar.gz=5c7848ab2b2cb181bd7f64cdbdc3b5b659b61850c14604a7977c35b9807daa48 -dist/2025-10-28/rustc-beta-sparcv9-sun-solaris.tar.xz=0f12cb118e253206ea74e7b1dabdda6e95bb0b10d47657aa4c560fa9ca28cf83 -dist/2025-10-28/rustc-beta-x86_64-apple-darwin.tar.gz=3c34e03deee0445864c7f5ebc89883db051a3c69b874a2daff658fb5dd364aba -dist/2025-10-28/rustc-beta-x86_64-apple-darwin.tar.xz=292d40e5ea57295ecd921a07fa11796771953d38793edcea9841a95e79d94ac2 -dist/2025-10-28/rustc-beta-x86_64-pc-solaris.tar.gz=6ac79775ff166ba76e663e8760ddf9625e06a28e5033d4d8cc570dcca73ca725 -dist/2025-10-28/rustc-beta-x86_64-pc-solaris.tar.xz=46c214af2c11ccb17529a991201624bad044d59c171c6f872468acb8523b6f96 -dist/2025-10-28/rustc-beta-x86_64-pc-windows-gnu.tar.gz=29067fc4a5e0f123c34a045a1b0d55f88170bc9f658584d50e32219cd5945854 -dist/2025-10-28/rustc-beta-x86_64-pc-windows-gnu.tar.xz=30c20794d0c244bd04dbd4de304ef3aea5ba11e26882f2a004680281f21e05b0 -dist/2025-10-28/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=6c6c7614b538d9bad498b3642321adf0b2b6cdd3b24706903a8eb2125c0c122a -dist/2025-10-28/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=09822c7d5bbf218d5113e902968b37719949997fd788523bf80400274f428986 -dist/2025-10-28/rustc-beta-x86_64-pc-windows-msvc.tar.gz=fcf05b8150cf7199e100f560854f6acb6874985a5cfbb00ead36914dc3fb66e9 -dist/2025-10-28/rustc-beta-x86_64-pc-windows-msvc.tar.xz=f5259f5b521ea10f093c522abd5bcec4e9dfb94ce3e384e3b53865a223e700d0 -dist/2025-10-28/rustc-beta-x86_64-unknown-freebsd.tar.gz=c3719366a9687d243483431231b86140e268bf2ce99e1ea1759a611524ea8ade -dist/2025-10-28/rustc-beta-x86_64-unknown-freebsd.tar.xz=015e02fb99098c31d502738e9e525d48ac6ca386e16f3ecb55235c7268d4abe7 -dist/2025-10-28/rustc-beta-x86_64-unknown-illumos.tar.gz=508acec5f2b092d09d55590e7fe921f7415aacc13c535532997776c4ebb86483 -dist/2025-10-28/rustc-beta-x86_64-unknown-illumos.tar.xz=f7437c9b0e747b0eccd7755a3ef551fa81194f23304ddb40ae44bca5782dda4b -dist/2025-10-28/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=cd985cf21af999dbb76e25cb6c9b5ac5723e8cda8625cf511e7df2c98e7e735a -dist/2025-10-28/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=d30acafe9f3ddfd25148abdd3078deaaafb6bb62f7979252e9e7880abc260b23 -dist/2025-10-28/rustc-beta-x86_64-unknown-linux-musl.tar.gz=1778c649d790e52b8462d5ea377339443e607b2434fa9b579236b465f63748c7 -dist/2025-10-28/rustc-beta-x86_64-unknown-linux-musl.tar.xz=909808e6e3a10cd3fc2c0927f47dbe4ac8de4653b4e771c9c44b8e58cbe5fe2d -dist/2025-10-28/rustc-beta-x86_64-unknown-netbsd.tar.gz=8584d5ad71c7cedcf6e64b0f83ed2cfa82346e88a1000acac677f464dbb0e6f6 -dist/2025-10-28/rustc-beta-x86_64-unknown-netbsd.tar.xz=7b85928ce5f6908ad82895097ba07fad70990b7810aa23c63725d7ecbbf54d54 -dist/2025-10-28/rust-std-beta-aarch64-apple-darwin.tar.gz=312c1121edf001f03ea169e8fff9668efd1925a45962b282b32d5f126bd6b010 -dist/2025-10-28/rust-std-beta-aarch64-apple-darwin.tar.xz=11e0fd642939358a892e66ebeea7f1737a009ad23692da486c7427cdce60c37d -dist/2025-10-28/rust-std-beta-aarch64-apple-ios.tar.gz=d7086698f3414ebf1410f79f8167ef2e4cf8e9143dc7e3704200d67e64252080 -dist/2025-10-28/rust-std-beta-aarch64-apple-ios.tar.xz=a71fd039b0bfa2fa7a1abd13c622c89371f7af273fc44b3c210b1ead6a1f9156 -dist/2025-10-28/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=52795cad4c58b32c3f36fb7b596c25a8e3277c85c165e161445d1fc81e0c4200 -dist/2025-10-28/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=7db4e584f7890bd05d7cf8a991f539be249e0f04526e30743575129dada977c2 -dist/2025-10-28/rust-std-beta-aarch64-apple-ios-sim.tar.gz=575b6d5185a71a4f4d29dc881f5dea5fe492d7b21a01c0bd9987cc212bb8ca25 -dist/2025-10-28/rust-std-beta-aarch64-apple-ios-sim.tar.xz=ea1c7896e21d0a89da399405611a25ec447ff71495a4b5d48501c9f8129b2a20 -dist/2025-10-28/rust-std-beta-aarch64-linux-android.tar.gz=f7a85a478dd9d55491a2395dda9539ab7898385782ef5be479362ba35e8be837 -dist/2025-10-28/rust-std-beta-aarch64-linux-android.tar.xz=4fc53a2be557540332410446f6f43f5e6339d10d8010c153d99d707df64a5ef1 -dist/2025-10-28/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=99b3f95696883f18e3734d02c75a5dc91edac003b6d9627c5a32baac41f3c69c -dist/2025-10-28/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=375db4717baaac6a784d8f53f84035f99d5f76f9a3f7df7dd385ee2d93027368 -dist/2025-10-28/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=b650ca7708ae5b05fc82c7aa483f9aaa42be83d6bcc6c524690da745f32f6f60 -dist/2025-10-28/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=1683d5a33387dd546ff641222b501e90049241df0f52c2f1a5dc568b35594135 -dist/2025-10-28/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=3e2d64dd8d2fdedb30b25f899f8ed8deff653c4d3f3f7e16e534ab7e1eec8a66 -dist/2025-10-28/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=e83d63666e0372f27d404a4ddf48de7abc5b646d9f087ebf8856bcbfe6f86362 -dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=8a99f5fbaf869f68bced6435acf18127ac8880193fb23e44cb5791546bc795d7 -dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=53be5ecbcb4d47e6a1fb811a6e8b4ecec7fd6ae2b6efac7d9934dee4cfb19dce -dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=f61af59bc40a53dddf0a85b5205bec90d287a41ee3ac32345a97d21861ae6546 -dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=9ed2894300f6ac917ac33d0724133ba2fada2ab2e42a0b21a9bd994d70c942f4 -dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=70ad473c7d4934bab123afb8cff98773993fdbb73b4941f6022a25ef2942a223 -dist/2025-10-28/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=d0a06230a38c725ceed103c89e8031b541b7bc15a3646a1a3662d8147901b2fd -dist/2025-10-28/rust-std-beta-aarch64-unknown-none.tar.gz=90d4484a1e390e0d3edf25331d41f9b419730bd2e318e8927c4a891b2c035652 -dist/2025-10-28/rust-std-beta-aarch64-unknown-none.tar.xz=5b795b7378b6753fb2a8ea0ecef760009ffa05c9a4778815d2d2b4085baffe14 -dist/2025-10-28/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=52d0e13f1dc2083787d3294d5c3569b11227724ab4ced4ba9905ac0a5f25bde0 -dist/2025-10-28/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=981dca064b73d6617039bb35a32a17111445bc1ed9ba957525d227d3be9e8f6d -dist/2025-10-28/rust-std-beta-aarch64-unknown-uefi.tar.gz=fbb7066da0824513e4441bb59d4c6a6d4c8bc34f67ed79f67da3b8ec69ff3a4c -dist/2025-10-28/rust-std-beta-aarch64-unknown-uefi.tar.xz=c0bb51d8c513c0b5d597cbc00260bf2764595b12244906606c20ae6f98e0fc66 -dist/2025-10-28/rust-std-beta-arm-linux-androideabi.tar.gz=7cd5763f202c5679dc1bdc0e6551dc8093ee95a9b2d405ad8cbd31fcf232332c -dist/2025-10-28/rust-std-beta-arm-linux-androideabi.tar.xz=126b3a04432a3f6f5f1aef6f5e22deec98629da4a0809b0c7739911ae5e4b6cc -dist/2025-10-28/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=01bc31ad9812edeb11dc4b6c15d4bf80a325e286390829babd85176b91c38cfa -dist/2025-10-28/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=0b1c799856c8314afddfaa5109535535c36df31bb9188a319c1e45f4968a7079 -dist/2025-10-28/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=8792d0115ba1d9b0e3bfefbd7a9ddf7859f7bbf8431ef32530b05ec7cf9c68b8 -dist/2025-10-28/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=fc470db282fb0fab537e4b93a9498d4b4fc65cf014536905654cc2c14f82d245 -dist/2025-10-28/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=fe82493d2a7f4a9566916beefcd7fb26301bd13b8b838b5251398ecac0c867ef -dist/2025-10-28/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=b7cd0514db083e115d8aacceb3f7998da11f26e9f2be44137e8af2e2f9ac786e -dist/2025-10-28/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=0adc4e2e0f5bee4c28c81ba2cfd9796268e830d23b23b80c71121c30f08e3326 -dist/2025-10-28/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=8c98799e7b4c454cad130d0eb87e8ed59e0e7e64bb0513af8beb6d1d5f8e3ac7 -dist/2025-10-28/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=bb1da273578b508b9f397074438ecb2527a729e404d2820bd34d67dc8824106a -dist/2025-10-28/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=e004d91a9732284851d613a3c488909bc7d457b2053a1af45710aa4bbe3169e9 -dist/2025-10-28/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=7e6b5d4266306001366003cdc4fd4b60d700e86ec5dce01b58b0e73bd6a50c42 -dist/2025-10-28/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=170b32ea83d21436e744d11a56ea8e298278f8b9aa58fd82d6d788ff1e3258f3 -dist/2025-10-28/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=8ee71b71a8e90b21d580f9e64cc115f182db8582cd6238f946e24fc32de27e65 -dist/2025-10-28/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=9319475d974dce729182c3d99696bd5cf6a36257b1b80186f261d2885610ddb9 -dist/2025-10-28/rust-std-beta-armv7-linux-androideabi.tar.gz=71db2b02df33e229899f0dafc675572f2b4041400954f9145796edee7cd923d4 -dist/2025-10-28/rust-std-beta-armv7-linux-androideabi.tar.xz=0f331806b4523d61204f38f2d7ddd07e6f3dcda8a15806a9f01cb1747a587e8f -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=52f331579373b749fb1c7a6302a770a4be33008cdd9db4a5640208ba1ba7b540 -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=1e8c5dcc4cb672c4e8ba2862549cd281ea6802fb73701c885eaf5423673ab233 -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=2d0dded898f567cbfa5605dcc09b1e44970e345a030ef91c806eafcac4470258 -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=3a63913c874f30c8a68d5cbb62dc654ec9c3bf2f4488e1098034f60c51824bb7 -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=24c341427a9b5a4d883e7f322a9c7760446896e8c2eeb1f8654b80cef00db6ea -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=53c5607351479ad76c3450bcc81353633f2587aafda473487bb11e42f80d8523 -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=beda2ede28453b81588d639c18b36fa6e935e586723159e39ab9b714291c680a -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=f175a55fc81159e9a40407b1d97ea658239014cf0f5191a3533318e53ee1ff7f -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=db1f0cfd65d795d23a60d29e44f24e6174a0a516b998e65bd1964230c9c6c03c -dist/2025-10-28/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=264efedfd340c095dfe08fc95a35c36392eda0d1c2c179e56c75b27685b90d7e -dist/2025-10-28/rust-std-beta-armv7a-none-eabi.tar.gz=578fe97f24afa73c155290bf7386594e8b18a4652f54477d7a4e3f6f3ada0b5a -dist/2025-10-28/rust-std-beta-armv7a-none-eabi.tar.xz=a373109143f701d266ba53b3fff32206d88f5dfabdd888ac988606fade0b4928 -dist/2025-10-28/rust-std-beta-armv7a-none-eabihf.tar.gz=b3d6ec33c14a034c621aaf7de6ec81f0a916e18f5acc933713cc479fc21af755 -dist/2025-10-28/rust-std-beta-armv7a-none-eabihf.tar.xz=6550b2a97ce84884aa0da9133b81703e08b6e57b65c2e93f310fad2559ea4a08 -dist/2025-10-28/rust-std-beta-armv7r-none-eabi.tar.gz=b50984f65ee8a9e8c1b62158d8e91cb976f7c36f6ebc3c70ccfcab2a3da26533 -dist/2025-10-28/rust-std-beta-armv7r-none-eabi.tar.xz=0227fe58cacca86a04d85860a1de852a29ab9ac1bfea7bc50c2f560b73951d8b -dist/2025-10-28/rust-std-beta-armv7r-none-eabihf.tar.gz=da5e26a7cb5b91d3b8ec4f1a02c81b0f538dbb416e10e9453f3fd9d5cfc08129 -dist/2025-10-28/rust-std-beta-armv7r-none-eabihf.tar.xz=9132e8a69bf5dbd144def8bc647c659304fa785612a0f68f2e1a2df5dc195e33 -dist/2025-10-28/rust-std-beta-armv8r-none-eabihf.tar.gz=a312253ad16ccffacd0d840cba85d290fb5d2580865de99887990eff96f58b45 -dist/2025-10-28/rust-std-beta-armv8r-none-eabihf.tar.xz=474813a75bd586e562cf76705bdabf37a915cda6edb45afe029cbcbe54be3cb5 -dist/2025-10-28/rust-std-beta-i586-unknown-linux-gnu.tar.gz=4be0898bb9da3e8d75cb9b4851d5119efdd3136eb10cf31a42109f188781b6ea -dist/2025-10-28/rust-std-beta-i586-unknown-linux-gnu.tar.xz=5a51fb1f2da0dd645c1eb6ce19f37f16f356042ba176ab109f8bcd4ad3514ad3 -dist/2025-10-28/rust-std-beta-i586-unknown-linux-musl.tar.gz=96f621043d426d00f6baec72f66db5d91940215ba3e6985bb823c7b02acbd7ff -dist/2025-10-28/rust-std-beta-i586-unknown-linux-musl.tar.xz=2e62b9a670e3ca1d892ab18da1cd4b2bd946395e35c3b7829dd4b03726a73e4c -dist/2025-10-28/rust-std-beta-i686-linux-android.tar.gz=6c3b0e8796cb87e1a0369b55a91e49d5129af929deb4b63a623cf68219679543 -dist/2025-10-28/rust-std-beta-i686-linux-android.tar.xz=682747e9ab2706e90b5071ce13e8bff21160987d42ed0565f8e0012acded5f40 -dist/2025-10-28/rust-std-beta-i686-pc-windows-gnu.tar.gz=e7afe1e6ccb84fcf03114a6a3fd7232b40d7b2005f31a00a02d9c8e092af8b5d -dist/2025-10-28/rust-std-beta-i686-pc-windows-gnu.tar.xz=99d64d295d7bc0befe84a1da5d888de3ee0daa67a027c8628f78c36ab53eb7b4 -dist/2025-10-28/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=1b36e3979b73348b46a01961a2515bc6ae19a54924e63272cb1bca709a07bcf0 -dist/2025-10-28/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=f579f144f9f653df8be318e4f5ba363116a538b840030d3cd5305f87e03b9e23 -dist/2025-10-28/rust-std-beta-i686-pc-windows-msvc.tar.gz=79de79f2ed569a93dcd57aba35c7995582dde8b633bafbf0fc43ab6a8fb9d152 -dist/2025-10-28/rust-std-beta-i686-pc-windows-msvc.tar.xz=8c3fdbeb815085aaa9d484f1b22d0adbcc829a88511df5930bb518b139d20801 -dist/2025-10-28/rust-std-beta-i686-unknown-freebsd.tar.gz=d25fbb684148778444743e9d651a6d36dc4527d42367bfa67eebc43200e6cc0f -dist/2025-10-28/rust-std-beta-i686-unknown-freebsd.tar.xz=32c6d84e419a72cb862294a110fc79a88b123c4180a3a64bd53c38b200c60f9a -dist/2025-10-28/rust-std-beta-i686-unknown-linux-gnu.tar.gz=577cec0f5fb83cd22a9256dcf7c74529d95572976f102a8a63eb1cb9550f0a6c -dist/2025-10-28/rust-std-beta-i686-unknown-linux-gnu.tar.xz=dc537d7c09efaeb054d2954689842c813b5e9d646fcad912005f4b10e137181d -dist/2025-10-28/rust-std-beta-i686-unknown-linux-musl.tar.gz=5713f1784a424f509f47f70e0bce2bf8ae82e1a16efab8cd771677988b37516b -dist/2025-10-28/rust-std-beta-i686-unknown-linux-musl.tar.xz=1a3dc46f4cb4e4c8e4f96e9835b1188242addcb7a5a8ebbe3ef614c3aef862c4 -dist/2025-10-28/rust-std-beta-i686-unknown-uefi.tar.gz=4c32dcb28c1fbaeb910c9c7c60ea7dfe50e6556663eb3f002b66ec3ed42bd7ed -dist/2025-10-28/rust-std-beta-i686-unknown-uefi.tar.xz=1683c1c2838a2693b2f08a9daf0626675623d6bccbc4c996fcda8489eac853a1 -dist/2025-10-28/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=401945e68f2246d1f502d4ac63666d5443ca7fa2f81ce38e76fbb0647fed4643 -dist/2025-10-28/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=9b8d7d2f8a4ebf1369718d8bd3ae6973c977cdcb7030ccea0542f9e28970c281 -dist/2025-10-28/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=ae351e8f921f0c3b8bcccafa0c84402e15ced7591debf82287e63bac0965801b -dist/2025-10-28/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=7d64ee15508ebb610abe61e1aa03607140302fdbe41200e82070be85312d4a07 -dist/2025-10-28/rust-std-beta-loongarch64-unknown-none.tar.gz=9f951f51a32a4f037f3548935a07208e14f3e67d29100954ae6fbf61a8e56c06 -dist/2025-10-28/rust-std-beta-loongarch64-unknown-none.tar.xz=80494d9d9e02d7a6f56a638d93253d087a4edb83d4662b4771bd1d5c2cba97b3 -dist/2025-10-28/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=f23fd6331ba600a3a4350565ad11f51129ad13a248f35c37b9d485fab725b4ac -dist/2025-10-28/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=03d765256191ab9fac9f37102fa4252f7efb05261c8d2464745826232351dcd7 -dist/2025-10-28/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=509bcbeb245d69fcb828bf9f3fa4413d1d4d59a0e85ed28c4f412929c734aacf -dist/2025-10-28/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=543aa41bd2ae544c0114cca0e5a50c15eb7ed78d3d132bf5b48f93f2f92b502d -dist/2025-10-28/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=d67670d0b9385f4433635a473548031d083fe14e1a407766fb1ae5c4762da93e -dist/2025-10-28/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=e2f403936d191b38347bbad4e9b9bd66270b23e9df238ba9b5d52f81aaebfdb8 -dist/2025-10-28/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=15ef51a8fc10b2298db444d68130ef350414722133097d670b8106e8de68609b -dist/2025-10-28/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=515151364a93fc458ab5f11831797d2d708b22d9a71c78f717cf89e4e593417a -dist/2025-10-28/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=8ea0204c3ac93828c5a72f671c12167d0b5120cde99bb797c8d839caeb3ba3d8 -dist/2025-10-28/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=138969d2a43b6c4d736a950f8ba5bc0ed5fc7868c7044623d389d8278727e759 -dist/2025-10-28/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=a3423e7917b59232faaf855ad9b9cd3b23e5d2188aeb8636e2cef324d405beb4 -dist/2025-10-28/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=36914d3ce6a2e5a56a2a394d2c5a461a7c8a40fc235b3552a658ab1ed7d786f6 -dist/2025-10-28/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=dbc0b69f7eba79726bc08a0a6b357f9d818623d3cbe153dff5f2fcb31aeea61b -dist/2025-10-28/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=39def1e42a80080159347b5e85bc666830a3a346c9b0e83eea8207e94659ed94 -dist/2025-10-28/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=7aebf847c08b0eee42c77da8defc6b30439f4b6d29e4122802f02d029518a31e -dist/2025-10-28/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=35c49b2df4b3e18e0ec8ac20ec8b9a4a81b69f026921d85a666e0a97a671045b -dist/2025-10-28/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=b10e9e0a0457db1441a9bfeb3c4b9a8b2af4d33518bc58a8ee1d3fa7546c0bb5 -dist/2025-10-28/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=8e210b59b95b3c8db109d978ea73a540478315fb49d4515ccf248aafa7517617 -dist/2025-10-28/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=e2bfdac9e858f144db5e9ae79b494f1e09b2a012b18f0eaac96ce684a6a43e25 -dist/2025-10-28/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=6d2f5e60af9f6824fe2078a58a6cb804e61116e4848e1502289e08b0b9a5196c -dist/2025-10-28/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=382f448ea95627ee9fbb3d42c32ab9ecffe21ea12c00810e4eb8e94553d463a9 -dist/2025-10-28/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=ad7f534565c1b97495bf29054c202d8fada0a0ddfa0cca110c14a8221c654cb9 -dist/2025-10-28/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=7c8cf6afaa4edb589259dcc61ec5e1e667a5deeace8e277f752a433f20bcbf8d -dist/2025-10-28/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=8a396e9db63f1352bfde7a0d51446dabe6873c9a0a46e3c74f59ee775092e2af -dist/2025-10-28/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=551d398055ee522ec4a67a9173daca7a1f0f537ab006383ed2ada6b00cc81cbc -dist/2025-10-28/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=cf08dcb74f961bff041ad52efcae0c8e239e6439ecdcb32f869eb57b1a3aea1d -dist/2025-10-28/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=fd4e49a23ea0d512ed32bbaaefc1e5ea32c837e9a371513b94643966afabc521 -dist/2025-10-28/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=10700fa42e00a3b58ddcd664c0179016b837b43a31476fe4c56e8124619e4a22 -dist/2025-10-28/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=ea2f2873255dcc73185490b2c396abb4bcd5f1623f7749f77885426f753ce29f -dist/2025-10-28/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=7c02315d003cf65ac1246e3ac21b6da39cb1d99e61078ba9941647ae48bf9aa5 -dist/2025-10-28/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=008321f0ccd9b96e77829b709c2683c0053acbb19ae86f2fccef49c2cb964531 -dist/2025-10-28/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=047db35903bec7fee6c1d9deee5b4dc21db546a06e11c30d8372ffaf09814c59 -dist/2025-10-28/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=19677dc6495a139eac6c5827cb765e54e3b099d64f83e92273190f09ead7dab7 -dist/2025-10-28/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=d5815d1eb4906a442da0a0b56fe61cf94767dda29479da447d94a23803f9cf0e -dist/2025-10-28/rust-std-beta-sparcv9-sun-solaris.tar.gz=184424d0d18c2c49ce1c819e49804d7667edf2bce34fafedd4eeb6d4f427ae5e -dist/2025-10-28/rust-std-beta-sparcv9-sun-solaris.tar.xz=30ad3f9e3eaf48af0eb700d528b330118ad39f221a7beaab1a42e52b1ffa8531 -dist/2025-10-28/rust-std-beta-thumbv6m-none-eabi.tar.gz=c9a72ea7a13651f1b9bc6e509d9d6d32e56a4659d541e20f571ef9f6dd858480 -dist/2025-10-28/rust-std-beta-thumbv6m-none-eabi.tar.xz=6dd3a25ee5060cdf4631d8b0b7f16aa569bf611ef392d93826e88846053779e5 -dist/2025-10-28/rust-std-beta-thumbv7em-none-eabi.tar.gz=ccf8d09ba0bed60fecc775689649f2de31bab68cff273d796378d213c9d1e44a -dist/2025-10-28/rust-std-beta-thumbv7em-none-eabi.tar.xz=b7a972a9b972a2e0665387cd825491bf0ee9581ff26a586806c986014f0ae742 -dist/2025-10-28/rust-std-beta-thumbv7em-none-eabihf.tar.gz=26baa00580268fb5b7aba63a069c187dcca43dcf29161a0c1b849ef3765bbbda -dist/2025-10-28/rust-std-beta-thumbv7em-none-eabihf.tar.xz=dcd67a3ad1f2c553fb90009c630a8edcd8f571e28e5fcef0ade63c624fa11037 -dist/2025-10-28/rust-std-beta-thumbv7m-none-eabi.tar.gz=cef72caa89fcd3d48c070b1aae2fe85f29547c9b615446af2d51767ef42b5045 -dist/2025-10-28/rust-std-beta-thumbv7m-none-eabi.tar.xz=70ad20d0016c6c81b4526ccf89bbd96f4bc0a97b904b2c06487fd0a0368d7a17 -dist/2025-10-28/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=f22aeb9cdd40a4a465525fca7e6520aaa74b5fbfb41f45777e1376742f711c59 -dist/2025-10-28/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=48410a5a2f05c80f3d76b9f0b3e0eb89521495b273a854b40386048f27b553c2 -dist/2025-10-28/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=a791f5442467819c154f943c3126de1dd8f5fdd6b62527aadd88260ecb8c380b -dist/2025-10-28/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=cf43ec766a353cad48150d47d108d8df4b1561101b2c95241b909d4a5ec47bce -dist/2025-10-28/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=3699e5b727abc016ab9fa78f40655ef7d88ff157e46759297cd80e5c169136f8 -dist/2025-10-28/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=a6942c04a569f68cf1c5126e520400c51dfccd9e18a1d3941e28d7a8e63ae648 -dist/2025-10-28/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=eb27f46d3ee51e4f71316a75087d4ca2493f55ed5e0b720f0dfa3564c8f19a67 -dist/2025-10-28/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=f50b7fa2830844fd27041ced4c96eaa68ae6595b370eef1c958e3542c718d5aa -dist/2025-10-28/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=398556eca8a50c1d905ef7e2bf3f25d75f8dcf1d9b679af87b565f5f58af5c2b -dist/2025-10-28/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=8dc4a5036cfda5725120a8d7e7d0cd05151230ed967ff77fa028c4b73dde6885 -dist/2025-10-28/rust-std-beta-wasm32-unknown-emscripten.tar.gz=212f761263b9a4c72a53aba0b76986f70b3d624557f34d36af2e7d935702359d -dist/2025-10-28/rust-std-beta-wasm32-unknown-emscripten.tar.xz=89c0dae14955afab89b8fa2892944325ff154987c863fd36f93089f29ef993b6 -dist/2025-10-28/rust-std-beta-wasm32-unknown-unknown.tar.gz=92159d52588bb1ca6346025f894dce5520b42d89cb54a78a3ff42ee119c1e90b -dist/2025-10-28/rust-std-beta-wasm32-unknown-unknown.tar.xz=a187e36833f587ad5f117b012a5d9ddacb3122b39b902bc2a9d9d03b5aba27a2 -dist/2025-10-28/rust-std-beta-wasm32-wasip1.tar.gz=fa8971fcd7c22f5d382f4239fa8742238ec967f70fa40180ac9d8a39bffc28b3 -dist/2025-10-28/rust-std-beta-wasm32-wasip1.tar.xz=0603acb7e6fa5540fb458cf363fe473889b0abba91ec0c124ce380ffb1869cbf -dist/2025-10-28/rust-std-beta-wasm32-wasip1-threads.tar.gz=7651d409d4a89dab576cabf51cdd2947f877b77f09f668c6f9b8826dccd5c322 -dist/2025-10-28/rust-std-beta-wasm32-wasip1-threads.tar.xz=a6c3bc7f7f2e6a4cee6db2aa16f74af80cdd17ca92dcfcb1ab1e0c06bbaddd79 -dist/2025-10-28/rust-std-beta-wasm32-wasip2.tar.gz=77537c7a4518e62cb592e5e9d41df02d1ec8a3038b87cdfe082c98ae578973d5 -dist/2025-10-28/rust-std-beta-wasm32-wasip2.tar.xz=794a3c2e08edd74b7a004489017172c30a3242f7f0c5538c3b033937787da332 -dist/2025-10-28/rust-std-beta-wasm32v1-none.tar.gz=746ac6eb726ea2d2996b68be881d5c5fbeeba2bec1fbe57e6c315d4953cccba1 -dist/2025-10-28/rust-std-beta-wasm32v1-none.tar.xz=8bdbcf0cc2b598cbb2098f113128e6f94085dfdaea3ed3d5e15cfd0a82262b56 -dist/2025-10-28/rust-std-beta-x86_64-apple-darwin.tar.gz=2082bcdfd0e837163aec012cba1ae674825f52f5891c8cf3d4d00c619d5bd27b -dist/2025-10-28/rust-std-beta-x86_64-apple-darwin.tar.xz=b2267e0df76f21bcfbb55ab323c58015501d3a3060c4127a005e29fa0e628a7b -dist/2025-10-28/rust-std-beta-x86_64-apple-ios.tar.gz=6a48b60d0aa883ffad612a657d9de232ad1df92f937a5166532a7ee4e655fcc7 -dist/2025-10-28/rust-std-beta-x86_64-apple-ios.tar.xz=81ee2cdad7fd25b56be24d919268d0dc61c1d44d50bccb4c1811e30e85b97869 -dist/2025-10-28/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=01d5952f0970508064fa24196e126cb09aca5085ad6258c53397c3b23b006217 -dist/2025-10-28/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=3c10717be0087060ffb0e5b83c86ce69bff8b0dee9dee95b1be6a44f4238b5c5 -dist/2025-10-28/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=ce87a282ea73eb83015a321b208abfa9d4afdf4a797c799d9efeb1a246e4a64d -dist/2025-10-28/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=5c8866ec1cb4ec7826a94510c00f5cbc7f31822dd7e01ec2fe6b781b25e2afa8 -dist/2025-10-28/rust-std-beta-x86_64-linux-android.tar.gz=19538e0dd74d638b3ac1ac9ed679b8ebc6c058f661d7f167f957eb0866f7cb65 -dist/2025-10-28/rust-std-beta-x86_64-linux-android.tar.xz=15554ba8cc8d1d1c4c46e0438503170aff5a5519eb8bedef07a32d187ca32915 -dist/2025-10-28/rust-std-beta-x86_64-pc-solaris.tar.gz=41a6db659dff188414e33595448dc9c2b99103dbbdedab53d74c6aeccbb76458 -dist/2025-10-28/rust-std-beta-x86_64-pc-solaris.tar.xz=2bbcb13b8271c39a48ac2774e7444fdce883a283622400085623c161f8be405d -dist/2025-10-28/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=e2390bf5da8a91f056df7133020d053d5d90c84c81763738efe8a862864318ae -dist/2025-10-28/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=5d6fb692f2a1d2bad7b550b79e1288223ec598a46975848d07f2a5105b36cb4d -dist/2025-10-28/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=30c66f64c7343388f3205e172e64e51dc2930214fae46eb3b21648285092c944 -dist/2025-10-28/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=25788901f6fc13a4963bba4e985d619e0739b1239a5679406229a2bd5eaafbaa -dist/2025-10-28/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=9fab4a6cc38c2f06113ae9f0620e40ff5e9134f83562c32576c1e82048ad3bc8 -dist/2025-10-28/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=1b7007f9bc3619cfba09bfa92c3b1e5460316501fee4ae7c8492703a79517f4a -dist/2025-10-28/rust-std-beta-x86_64-unknown-freebsd.tar.gz=461036ed77e332851e88fb6f0f5c64068aef0b177b27662f326d157c06c7115a -dist/2025-10-28/rust-std-beta-x86_64-unknown-freebsd.tar.xz=fd7c7b75a50833650f131a6a676df90dcd57c4784654aee12ce594846da1c219 -dist/2025-10-28/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=882fe895b376384d9b1b1d9c01d9b641ab56b1405d63d7a83266f228b4b759d7 -dist/2025-10-28/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=e9d1fdbd0ba327b6d4e618622c0336eb6895e0e188005423710d514e145baac7 -dist/2025-10-28/rust-std-beta-x86_64-unknown-illumos.tar.gz=aade9f95b362cf13ee48e1d7608eb8487229cf86cc72082afe21fef533e45f5d -dist/2025-10-28/rust-std-beta-x86_64-unknown-illumos.tar.xz=de92c9cf00a2413d5481e96e1db5157c5cb3814851951076e4881b9269651cb9 -dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=04f6feb37de8305d17e7aacc6174395bd55447340963303767c5a66a63200149 -dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=2838910a0ef0084245a69fefdc67845ea579f49629cd24fa051b4db0bdc76d98 -dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=d2f88d608fdccd0aecbcd83cc184d157d93159e29ad525583188013f327572d1 -dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=b5e7ae18377727f93fece51d9ee5704ffd5a9ccd00c540b38ebbf3b9155cf20a -dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=40a52cf3527090a12095b0ed4ad8d35fa5e3cef39146a9a8bff9009cf5772dc1 -dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=28be865d06f9bd744aaad2e82ab8bdb87045e6e2d7ee6fceef2024fa620ba920 -dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=e0afdd5422adac97fe8c6943470a8561847a614d3e367cb983f28250c0e2e34c -dist/2025-10-28/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=3007d13a0640d915eca622260c6b8b6a8936788a1228011b90df817b6888155c -dist/2025-10-28/rust-std-beta-x86_64-unknown-netbsd.tar.gz=1744c2485854792601518dcf7855d4223db63e9f3693e2d06c1ac285b92ba33b -dist/2025-10-28/rust-std-beta-x86_64-unknown-netbsd.tar.xz=757803d3cfb8db12dd7c9528852c1e28fb3a9ba97e4230d1e29dbf1834cf3f84 -dist/2025-10-28/rust-std-beta-x86_64-unknown-none.tar.gz=21d5de489cc22d849f246225909278f123483a446e1a3c68b14b8b992c104082 -dist/2025-10-28/rust-std-beta-x86_64-unknown-none.tar.xz=62755ecf24c0a2423b4d05c09ec8e8d38737e6762312d1ba993e1a9417083ba9 -dist/2025-10-28/rust-std-beta-x86_64-unknown-redox.tar.gz=0339d37d857f7f5ecb1607e8c53c499623f0c3563e3b68f2b939ee960d31b270 -dist/2025-10-28/rust-std-beta-x86_64-unknown-redox.tar.xz=613b5ca94e5c33c46d9f29cb557d1e512abd1104c5d81f1897915f6153175cc5 -dist/2025-10-28/rust-std-beta-x86_64-unknown-uefi.tar.gz=1da6167f0a2652b1622cae5ac815d55e307dbd639e4901005a3b225150dcafa7 -dist/2025-10-28/rust-std-beta-x86_64-unknown-uefi.tar.xz=6fca79a15c1ef9f8a3974f84af805106ab453099bdb6f652f584abcd7c8174be -dist/2025-10-28/cargo-beta-aarch64-apple-darwin.tar.gz=e66d076303fe8010c27fdbf8a9e31f47223508a280cd2ffcfea698aede848986 -dist/2025-10-28/cargo-beta-aarch64-apple-darwin.tar.xz=f4e87741a4070fe5bc4ad59ecfd324785cd9a477c539543d6a4fc1675afa8111 -dist/2025-10-28/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=5e9213968960bab07ad28408563b46d01c1d881c26ccd07651bdb527440461cb -dist/2025-10-28/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=ec01099da59fab595f8ed8a2f6fb308fbaaabf563cf50c103d47fad4595d72ec -dist/2025-10-28/cargo-beta-aarch64-pc-windows-msvc.tar.gz=ed3cd99db73648bb87c5a25556da30993346f1acc665f9dc906094639370282a -dist/2025-10-28/cargo-beta-aarch64-pc-windows-msvc.tar.xz=c5f89cae65188a7d1b5b5a93f8645774f878db6a14032abb8fd960fa9f4cdb06 -dist/2025-10-28/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=2c85f1c5b1a8bb9532194a16ceb8b04f1586d0ade14442f45e740f3e85022924 -dist/2025-10-28/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=a675601cf6552783625b79c33c1d42715c3918a08078e6eed01236910bafc4b4 -dist/2025-10-28/cargo-beta-aarch64-unknown-linux-musl.tar.gz=e5f2cc9f31b927e2e02117c38a5822c39993242459a057c48e7e11695dabe5a5 -dist/2025-10-28/cargo-beta-aarch64-unknown-linux-musl.tar.xz=1830b8b7e43fc03f0348503ae036b30d0e906cb024bc2257e717a58df95ac222 -dist/2025-10-28/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=eef6f553184a8177525a1ee932d6e293f42eaed6986c1c83f7d76d579f02b867 -dist/2025-10-28/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=13c81e5874532e490c987dbc46b19cf3a7eac14fefdffc30d0c5493a84f8a257 -dist/2025-10-28/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=56d7f1b41af4d72091c8a99b9a583f24d5aa3912f6dfcbfeeae4eb47bfbf158e -dist/2025-10-28/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=010292117dca5b10b71b7aabe38d1e8c2f0180ab54e9bf072a9ca8bab3f40ced -dist/2025-10-28/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=91671bdd6438df48e4c529e5897afe57b91e8575c12d40c3cb3280493599c0d9 -dist/2025-10-28/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=0da8474db35ef547b28f123e8c98ec84dcc4a4a5c4a487a222ac006e809ceb80 -dist/2025-10-28/cargo-beta-i686-pc-windows-gnu.tar.gz=5d9ce7ba82e8d694e53ac877214c0873b0dd78a60c8eabcfe9128433d199d12e -dist/2025-10-28/cargo-beta-i686-pc-windows-gnu.tar.xz=209100fad49e274457d8299360a4c2e83803411a69fec69898a03d9a2bdee955 -dist/2025-10-28/cargo-beta-i686-pc-windows-msvc.tar.gz=edca4ca03b055b40d0c4778e325b93e3759123f207a6d32d7ff42cfa0f323604 -dist/2025-10-28/cargo-beta-i686-pc-windows-msvc.tar.xz=5146440d030e04450de61bd6022cd7ad6364fd06f9cec28bbb7889bad171e579 -dist/2025-10-28/cargo-beta-i686-unknown-linux-gnu.tar.gz=d1045ab266d914060e24224b0e74ea865f4bf4cd527d9a09c5631441c40f48a3 -dist/2025-10-28/cargo-beta-i686-unknown-linux-gnu.tar.xz=caed7a0786cc9f476d1b9fb5367c67a02397ccb12ed18a357b5ed04fe77fb12f -dist/2025-10-28/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=017335d6ca97cbe4bf93e2ffb4def850b05a8efa0367b008de4cc8b55f1af3cf -dist/2025-10-28/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=f5671ec0dee9841d4a482183f56ccb986f358a80d043d1ec4b05bc8a356f8ad7 -dist/2025-10-28/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=0a280ebc1b5aab8452f1445fe858ad4808fd7035dd498510951d8b7caa13edc8 -dist/2025-10-28/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=8ab41df2264470d6ed0a6d82b665992f76f9065046a153bc8ee1eda9ca81eaae -dist/2025-10-28/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=7368d0d297fa06108271b03138a9dda0cfbdbe5463a614ebf6fb5b573dde08d7 -dist/2025-10-28/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=1ad0b7d4e3173150768db7105b1a691e8c85db3e9c6a391390e2f5df7844d420 -dist/2025-10-28/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=75740d0b1847f73777894f484e085f70f24d981b0ef69d00cb5b0c29d276c5b5 -dist/2025-10-28/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=1ca71e60a6fa9752dd27bfe4f354a1b732b67e55c9e645021e6041a2450b7994 -dist/2025-10-28/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=ab37e6d39ccb7fe33c55bf62836c2174f1a4197f02cbe9d88d118b81ec6d49e2 -dist/2025-10-28/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=77cc38c5b89fc65fb7453dcc3c3212e0a512923497420b7782ffbfd88f00b39f -dist/2025-10-28/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=29a2dd23fe30b2d1741e1d4032d4250b4f7f0e2af5ae718b309f2d271e13ef41 -dist/2025-10-28/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=bac42c5d4af02abbb4db1a9dd4664340d686e4c23f923f372d3b08e090bd105c -dist/2025-10-28/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=3b396bf0ddede9f4964bc9fb27b52e628db1d9ccc38dbc5d5e06c316ba8bef87 -dist/2025-10-28/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=e706521e4496c79bb677d7d06d79fc1ae2770cdba4a81d8c28ede81ab4ee7909 -dist/2025-10-28/cargo-beta-s390x-unknown-linux-gnu.tar.gz=2fa6ecf04d1cb20dde5f700a0e425ea186d628c5704885e84e197e4494af101f -dist/2025-10-28/cargo-beta-s390x-unknown-linux-gnu.tar.xz=e8810699e679fd0306d4e6c95608970ec5a1d1ccffcdd707fe4a4508518a0e6d -dist/2025-10-28/cargo-beta-sparcv9-sun-solaris.tar.gz=2fcae7eb2f538d84545944c744bbac39e28b3bd58e8d2bdc862d5f66df7068e7 -dist/2025-10-28/cargo-beta-sparcv9-sun-solaris.tar.xz=2fe42f27469fdc23a9e45ec025c60a09f00be07a239cd8c8df74ce52e94b4cab -dist/2025-10-28/cargo-beta-x86_64-apple-darwin.tar.gz=c92c1a580eb85d96f973df4dd9cf4440eb661f8fab9c632b5f0621cf0839badc -dist/2025-10-28/cargo-beta-x86_64-apple-darwin.tar.xz=6c2b13253e1066e49fc52f3cb1654776d5d38853a15e8022652b4a2cb6845daa -dist/2025-10-28/cargo-beta-x86_64-pc-solaris.tar.gz=ca98af5dcaae734ccc02fde2807dca8d95947918eb753d407c12dd05ae937568 -dist/2025-10-28/cargo-beta-x86_64-pc-solaris.tar.xz=864ed5842890359e9f767b4050b8a27ec9c27c88a8cef20993b8f775c213d394 -dist/2025-10-28/cargo-beta-x86_64-pc-windows-gnu.tar.gz=ec8a9e8436f83388736f16f7ad9962a1d9b72673c3da56b8233a6b39dde54534 -dist/2025-10-28/cargo-beta-x86_64-pc-windows-gnu.tar.xz=1f059aae8e6faedcc56663d833a07417e07eededdc2776b2762822987a010131 -dist/2025-10-28/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=f364bf2f20f35c7ff0381cbd34c88a256849a1b9a27267436e14bc01b7bacfbd -dist/2025-10-28/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=451f18d049f1c47bfa0c010481e499afa1baaffb889de11534cf451578c62f76 -dist/2025-10-28/cargo-beta-x86_64-pc-windows-msvc.tar.gz=96ca48b12b27b8e933cbb426e7123873a1120bd884a62d150aceb6a26bfc7694 -dist/2025-10-28/cargo-beta-x86_64-pc-windows-msvc.tar.xz=dfe14d019f5c1744a312da8d926059147974de0b5bcdcd869526b5257a1112b3 -dist/2025-10-28/cargo-beta-x86_64-unknown-freebsd.tar.gz=7ef3d3edb6b536382f5063a5de5aaf036d6ba09bf7bd1ff770b87d8942110c2a -dist/2025-10-28/cargo-beta-x86_64-unknown-freebsd.tar.xz=beb5587235e8ff471a8eb9fd84ae5cf4380e7ec9b00ab03dc0c549be0e661dd0 -dist/2025-10-28/cargo-beta-x86_64-unknown-illumos.tar.gz=b97f511486ad044dae0c8b50df8430e489887ac36b770155f163d8e4216cd9c9 -dist/2025-10-28/cargo-beta-x86_64-unknown-illumos.tar.xz=21fc84a42fa988632fb9b0d9dccdf6ab2fbbd06a6780076282fc9bea56567559 -dist/2025-10-28/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=d5b05dc398716909df77415b4a68233b68a5d578855e0e91dcf423f2985fc1cd -dist/2025-10-28/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=21e79bba772e93a6fd910e9d6ee833b55a53b80088f8280525717a4cd800c21b -dist/2025-10-28/cargo-beta-x86_64-unknown-linux-musl.tar.gz=4d126f2591652ddea26884973c1ae1f1e25246cc5f60baeb3a52d6ff45a1aa15 -dist/2025-10-28/cargo-beta-x86_64-unknown-linux-musl.tar.xz=62113a7383f7ff8a9bee099155ca55c3c69d16bf135fc06046f672b2102deafa -dist/2025-10-28/cargo-beta-x86_64-unknown-netbsd.tar.gz=e9a07f035f308d4b9cf5f1b0ab4ef969cad1c41528adea2fca81d8dfe45ebff0 -dist/2025-10-28/cargo-beta-x86_64-unknown-netbsd.tar.xz=3f3d87269072d8e219e7213ca878a7fd441aaf74e4d052ca44ccc7ad75e83eee -dist/2025-10-28/clippy-beta-aarch64-apple-darwin.tar.gz=a44daddb30309be19856b9572679569ffc2ab2c30318706ad59aa2dc14887587 -dist/2025-10-28/clippy-beta-aarch64-apple-darwin.tar.xz=00576ad0f30db5be96e6434e22a2fcdd167067d65ab85199df06a6d11d1ef6c0 -dist/2025-10-28/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=24fb3dc6680e845c84e535f9c14be5e3d4052ef3ccc800e0fd81815edccb4836 -dist/2025-10-28/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=20d2ebdb6e2a902eb74ad502a14a2a66e6a9316d5f94513ec9781d146c323d9d -dist/2025-10-28/clippy-beta-aarch64-pc-windows-msvc.tar.gz=652e5bdffbb89ba281cbd5efe3a2cf103adea6af7ba56a21cb6bb538a2ea6536 -dist/2025-10-28/clippy-beta-aarch64-pc-windows-msvc.tar.xz=59d0fb72db77c484571ebab8c992303659225735d3f820ed7048122d8f96d764 -dist/2025-10-28/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=6bf6fb7279ecf5df6edca6014db5f8ba0427fd8cd32f073630b6b02e2e69feaf -dist/2025-10-28/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=0a8d19bca62dc38e64cf527b239106901fa2e0642ca5c2ef1cde070faaa901b0 -dist/2025-10-28/clippy-beta-aarch64-unknown-linux-musl.tar.gz=663581dbd93b22b3b20d281486c8dc0580e43ceca42d9455d78f2d2c341cc758 -dist/2025-10-28/clippy-beta-aarch64-unknown-linux-musl.tar.xz=49548d8ee0561ab96629e354ad055ed5f0c6f3f60c1559ca2a27352b441ff848 -dist/2025-10-28/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=b3d44866b1f909576e0e586aa34b480f1170aa3eba28209ac5bcb929f544d07c -dist/2025-10-28/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=717397166acd760e391c251b1c308657f45deadd928035d2860c772c8b377b91 -dist/2025-10-28/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=8911fa3347ca26a2afed6140bc4cafa629830740b8e4ff5e648c517f6ea43c6b -dist/2025-10-28/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=e7360c728068520ec7bd712d57357ce30bbfbb629ec69cfdcf6596002751d93b -dist/2025-10-28/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=6d94df05e43804f1054d17542db72cfd3f2df27eedc275c810b35362f9d581c1 -dist/2025-10-28/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=25c33744d9722aad4f9fc80674233d16eb653adb17d0deadcd3be8f16a79ecb7 -dist/2025-10-28/clippy-beta-i686-pc-windows-gnu.tar.gz=dfb9ba0cc842b7c92f1dda8bb88bd1db9beeac746c3ca3d144dd4d66d91ff6ff -dist/2025-10-28/clippy-beta-i686-pc-windows-gnu.tar.xz=20f3cf3fe6b52b8f54391be7edd11331a376313c37b674f4987589f50eac68d0 -dist/2025-10-28/clippy-beta-i686-pc-windows-msvc.tar.gz=bcabe1f7679e1ae416c7ed56afd74ad224ff47cd9b5413dececb0e6f503ce393 -dist/2025-10-28/clippy-beta-i686-pc-windows-msvc.tar.xz=f8ebfef39e7119b45a4f714e91b47964aeb6653fbdaf9b01786ef629cbaf3d31 -dist/2025-10-28/clippy-beta-i686-unknown-linux-gnu.tar.gz=f0fc318e90de4f45f6ca7d0d6ca3ed5d044db75f97254d792cdea9a7b196042e -dist/2025-10-28/clippy-beta-i686-unknown-linux-gnu.tar.xz=27c9adb19a7f84edb19ff4c8ce34dd836fb8d10e8786999591e41ec9c60e4602 -dist/2025-10-28/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=04673347c7e13eee9e301ffc1640ce7a5ed733915c29d90750706829d6b02884 -dist/2025-10-28/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=2484f24346fbbd2d48f69d86ab7710ef65a5952bb5ea0141f3388f616c7d6d0c -dist/2025-10-28/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=656eb1b94dd2324958e6ba0b1c7a37281abe24dac7d87b0e406fc10931ea0d29 -dist/2025-10-28/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=3349952da5d2693554d2e1ae60bb7ff9cd64451719cadf4227095b73377228c1 -dist/2025-10-28/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=40eeba3b2807a1d807ed25c3bc0482d5b91135a769d2281a894ec8cb8bb52a35 -dist/2025-10-28/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=0a6e79cea6655d6b3e1ff1218651c627886d8f06a5d36e9c3bd3c9c45b375f57 -dist/2025-10-28/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=b11f919fce34d70816a6dfa0884e37939c38336bad6261fccf5d67d25935852c -dist/2025-10-28/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=ead91ce4260d07d4e4f950092e94ae224f067ae3c711efe2ccedc9250b2f3dd7 -dist/2025-10-28/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=481a2e3b45751e2d86c30d4fb3897f0a7a18e9eadde2c9a3ad1a8b0259fa2066 -dist/2025-10-28/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=d5d6529cfc89c29443d9e87041a5f93b746e5bc5791016242e2f271be5bcb557 -dist/2025-10-28/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=a70d30948f5e95cdd454fa2b3284b97f29134f59e98e130fc2877781f3b62e89 -dist/2025-10-28/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=8dddfc0b1b2ca8e8866a11a1c95b8601c50150f1e52adbd3803cca2fabb386e9 -dist/2025-10-28/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=bd1b28dd79a52de657515ba5c25063b0b6015eb30ee3b0ee05511567b429c992 -dist/2025-10-28/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=5262011db6be068ef70905a28939b1838a2fd2b719d38d59e80754695049269b -dist/2025-10-28/clippy-beta-s390x-unknown-linux-gnu.tar.gz=6d3d83d03c46e1de2cc6b6f204e701acc9dddb6d4baef80fada9d868b7eb86cc -dist/2025-10-28/clippy-beta-s390x-unknown-linux-gnu.tar.xz=e57ac819f962d9b431b699b40a047d3e2530f76f2670c5a04747b7de11c3d5e2 -dist/2025-10-28/clippy-beta-sparcv9-sun-solaris.tar.gz=7a492d27b49facb9554248935728cba483eb7ecf3de317751a7445c3932932e6 -dist/2025-10-28/clippy-beta-sparcv9-sun-solaris.tar.xz=cc02f4f971b9e5eb63ca65ff6947cf3490101bfb40ea9fb2b310283bb6d10b27 -dist/2025-10-28/clippy-beta-x86_64-apple-darwin.tar.gz=56f11b8ca012467ef6aa8dc3458a5bf45950f1de062a616a01f6c0aae412d0fd -dist/2025-10-28/clippy-beta-x86_64-apple-darwin.tar.xz=01fe53ec63d71a8427fa3220d037313fc31f8d0fa33a64305b01109344aac21a -dist/2025-10-28/clippy-beta-x86_64-pc-solaris.tar.gz=d222cfda8613bba09b0ac1d02fad99c0d081d10733f0f9253d809221ffdda506 -dist/2025-10-28/clippy-beta-x86_64-pc-solaris.tar.xz=918706ee8ed38bf398cbf0dad85333e3082dc461fff2fb2399b96e840dc24766 -dist/2025-10-28/clippy-beta-x86_64-pc-windows-gnu.tar.gz=7764df051100b08b4b4e5c434d5ced1aaa84d9665f6a4401c9ed6350db983b70 -dist/2025-10-28/clippy-beta-x86_64-pc-windows-gnu.tar.xz=4a43dee6ce0279de929566f844fa4987d10fa5ca856bb2a2cbea4327eef3308e -dist/2025-10-28/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=add2532fe4e8afb8b53aee8a729fde0c0b36f83a8f6a859c39ae25f3d01e8dd6 -dist/2025-10-28/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=7117f0afc57ac09c277ba99be4a7de80d62ffaebe4174706910d5ab6501ec9f7 -dist/2025-10-28/clippy-beta-x86_64-pc-windows-msvc.tar.gz=e71d45b8bdb5346d89f769b4698b404b293884878a7f697680318c72829c1d6f -dist/2025-10-28/clippy-beta-x86_64-pc-windows-msvc.tar.xz=67be8cf6580a4a6e36eff94bfe19fdad290eae5db598d2a016dfcc7516178e14 -dist/2025-10-28/clippy-beta-x86_64-unknown-freebsd.tar.gz=03b78bad90efe98cab6416ecc641b7da0c9a2be5950edbb4c520c0758cdb90a8 -dist/2025-10-28/clippy-beta-x86_64-unknown-freebsd.tar.xz=056aecae34c8ae10a41516834809d983bd6126bd0374a7bf0857710492f0d0a5 -dist/2025-10-28/clippy-beta-x86_64-unknown-illumos.tar.gz=a67147c647da8a9b68a507087b66610ed19e65b94538b08326b000e66c170260 -dist/2025-10-28/clippy-beta-x86_64-unknown-illumos.tar.xz=09bd43034d7bc1e9ad1873610237f98543751809ebe63d8255813eadf4a00e70 -dist/2025-10-28/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=9397e5c3b1f45ce949b8e3420233e8b86f95a887667c917b8e7615218989820f -dist/2025-10-28/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=5b67e9eb803c180d101e799f6d7c2a6ea7ec07a93a6395b4f688bf2592bc30d5 -dist/2025-10-28/clippy-beta-x86_64-unknown-linux-musl.tar.gz=b255c33a89b0b1bd666ffb584c20554daa3a7c48123de75eae5e1b4cbc53e1aa -dist/2025-10-28/clippy-beta-x86_64-unknown-linux-musl.tar.xz=bc7f3f7d59f9c52370849092541a9368632f390ed9bc88f2566f1e3700f4da80 -dist/2025-10-28/clippy-beta-x86_64-unknown-netbsd.tar.gz=a8f366918520cc5a82c9bcfbb419570e6792712455ec5c04655e6557a657e949 -dist/2025-10-28/clippy-beta-x86_64-unknown-netbsd.tar.xz=dad3555be56e7c8d042f65dfced7915856f9f23cec13a7a633a4aad38c634247 -dist/2025-10-28/rust-beta-aarch64-pc-windows-msvc.msi=943683af0d464ecd36678e1c87b1207a67105820cb3d1516eeebaae450a2928b -dist/2025-10-28/rust-beta-i686-pc-windows-gnu.msi=8532743b3406fbf2926e5c6643300194eaace9de492e7f2ad0caa6f7d040f8db -dist/2025-10-28/rust-beta-i686-pc-windows-msvc.msi=1b3b15aa90c3dca73e9d72d53d214eb3c02b97386c83d8755a03f571cc09de4e -dist/2025-10-28/rust-beta-x86_64-pc-windows-gnu.msi=6249ad7cfcfe78b541e4935ed18dc4cfb10130252885668383a4c8f5046ecc2d -dist/2025-10-28/rust-beta-x86_64-pc-windows-msvc.msi=700f63a1baf0de2f0d1972454486f890af15b3700481698ffb0daf403778390a -dist/2025-10-28/rust-beta-aarch64-apple-darwin.pkg=1f2862fd5dbf8a9c7a765e75391cfffc5a3cd6837066b29f95778b5a346f0f59 -dist/2025-10-28/rust-beta-x86_64-apple-darwin.pkg=ffa2c6275b401c73575a5158911bc53edfece2edc03f6b3f6a140823cf870ee4 -dist/2025-10-28/rustc-beta-src.tar.gz=dbbae9e1c0b5e914b588ba5b659b7fb6af3d5b422831aba028d64b00c7161417 -dist/2025-10-28/rustc-beta-src.tar.xz=aa771d2b1ea8c933444c962c03c384bf2511bdeddf90edcaac8f45bd49f5232c -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 +dist/2025-12-11/rustc-1.92.0-aarch64-apple-darwin.tar.gz=9bba82c249776b282e25f4bc9c9386ea5ec81d3a2346281516c9da8910a5fd22 +dist/2025-12-11/rustc-1.92.0-aarch64-apple-darwin.tar.xz=15dee753c9217dff4cf45d734b29dc13ce6017d8a55fe34eed75022b39a63ff0 +dist/2025-12-11/rustc-1.92.0-aarch64-pc-windows-gnullvm.tar.gz=be37ee49589ab366548802d5f123ebd20eaeb7046c2f2149bbaef76582a154bb +dist/2025-12-11/rustc-1.92.0-aarch64-pc-windows-gnullvm.tar.xz=a7556b86bce94dd8c078a62f71a9a0a3f4b3e841bc5d4fae546d797b78186eb1 +dist/2025-12-11/rustc-1.92.0-aarch64-pc-windows-msvc.tar.gz=9296c18c3502c9c083bf39be6c5cab0d1afd39d3270810a1e630d6237f1cde0a +dist/2025-12-11/rustc-1.92.0-aarch64-pc-windows-msvc.tar.xz=07ba5606143de3bc916455714f67732fca05805591396a8190d5e88b8863eea3 +dist/2025-12-11/rustc-1.92.0-aarch64-unknown-linux-gnu.tar.gz=0d4e2145fe184fd6069c3a67deb44cc5bdadee7a631e742a025a47e3ea774577 +dist/2025-12-11/rustc-1.92.0-aarch64-unknown-linux-gnu.tar.xz=7c8706fad4c038b5eacab0092e15db54d2b365d5f3323ca046fe987f814e7826 +dist/2025-12-11/rustc-1.92.0-aarch64-unknown-linux-musl.tar.gz=da8c6d290ed86fb58ac9a7af78d3b0c27e1171e2ec62893fce667c085d172593 +dist/2025-12-11/rustc-1.92.0-aarch64-unknown-linux-musl.tar.xz=e7099dddd30f92093916e47a34cd6a866ea0acbf2836c17b74bdd795f0137a2a +dist/2025-12-11/rustc-1.92.0-arm-unknown-linux-gnueabi.tar.gz=601d613c027cccc3ed295c057d5948fe57cbe75992419970d15dc04e9b083b6f +dist/2025-12-11/rustc-1.92.0-arm-unknown-linux-gnueabi.tar.xz=18961e1d83fb747b60c766f68f8297a54452def6e79cc3e02c2d23712e0b3a17 +dist/2025-12-11/rustc-1.92.0-arm-unknown-linux-gnueabihf.tar.gz=5b79849c220f59a41f0949cd3b8fbf719200d3230b5922ae9b1c88e1f0860c42 +dist/2025-12-11/rustc-1.92.0-arm-unknown-linux-gnueabihf.tar.xz=53406761d1774302d50007ab005ff95befc9396856389fadbc94949629bed71d +dist/2025-12-11/rustc-1.92.0-armv7-unknown-linux-gnueabihf.tar.gz=f34a35f33fd922ffb5f9b40753c86159707449788dbb7fe43090dc030bc47cf1 +dist/2025-12-11/rustc-1.92.0-armv7-unknown-linux-gnueabihf.tar.xz=c49d5679f7f4f5ce3cf0d3b72c4299a0f95521087f3122d6c15be77658d4f9e9 +dist/2025-12-11/rustc-1.92.0-i686-pc-windows-gnu.tar.gz=9e8839f507a74653cfc06fc6de8a028d7874b933ea55e953f5a1d1eab29c9d0f +dist/2025-12-11/rustc-1.92.0-i686-pc-windows-gnu.tar.xz=a3dd59a53c7c919457b4c4eab814c3cd18cdc7a3f679fdaf8df6f9a21ef8c1ef +dist/2025-12-11/rustc-1.92.0-i686-pc-windows-msvc.tar.gz=4883ea7d39f7030a4290d7e9e5cc71483c867b4188bff293ff8f770bf4ee8f66 +dist/2025-12-11/rustc-1.92.0-i686-pc-windows-msvc.tar.xz=e892036f2ac1f24cdf853df74f631e9ad80fa6fcb2b9ca241527ed5b03eea96d +dist/2025-12-11/rustc-1.92.0-i686-unknown-linux-gnu.tar.gz=81b884e76b8e3b45509c20874f93d993477c4db2131745c8bf61282c8e673d78 +dist/2025-12-11/rustc-1.92.0-i686-unknown-linux-gnu.tar.xz=c1c920cd59e255e5dcf844af22b80483fe4b04ff04f143be6da69314bd6733f8 +dist/2025-12-11/rustc-1.92.0-loongarch64-unknown-linux-gnu.tar.gz=d85f10ad64fa7e8ddde205538503a97968f10d800e1432e8d22c94ff48a4345f +dist/2025-12-11/rustc-1.92.0-loongarch64-unknown-linux-gnu.tar.xz=6207ea209b332c01437fe742c2ef2bc914c88b6d4f9a23a43bc01ad924f6e4a8 +dist/2025-12-11/rustc-1.92.0-loongarch64-unknown-linux-musl.tar.gz=4203f9a11ffb57374dc498a6eb6f2df6f7bff4d13586a10af12476a69fb801b6 +dist/2025-12-11/rustc-1.92.0-loongarch64-unknown-linux-musl.tar.xz=66ac74c23df9f42cbda26587a37a70a67d5fd9821673656712a9f5a3b4cc8151 +dist/2025-12-11/rustc-1.92.0-powerpc-unknown-linux-gnu.tar.gz=84dc48d1b6b553439267dbb22bda57232e604764181cba7c19ed6a601b17ef27 +dist/2025-12-11/rustc-1.92.0-powerpc-unknown-linux-gnu.tar.xz=961cb6b8c2b5e969ad8eb0256fee43b88608b27310d946a7df3c9e9577139cae +dist/2025-12-11/rustc-1.92.0-powerpc64-unknown-linux-gnu.tar.gz=209a0e4371ae4f5670c58ca35cdd295d4b9f590b5270225b045a4655e3ca216e +dist/2025-12-11/rustc-1.92.0-powerpc64-unknown-linux-gnu.tar.xz=357dd4745f978080d35dbb6192ecfea331abbb93d88be7d70407856b30722a40 +dist/2025-12-11/rustc-1.92.0-powerpc64le-unknown-linux-gnu.tar.gz=89cdf91094ff3f68cc3bc679274134e491087eea3b0cf2fe61ebc2ce5f211827 +dist/2025-12-11/rustc-1.92.0-powerpc64le-unknown-linux-gnu.tar.xz=f48a214ff6fa36a77de8a0a2ee009be8aa48ba1533792450aca5edac29497606 +dist/2025-12-11/rustc-1.92.0-powerpc64le-unknown-linux-musl.tar.gz=9215fe368a7d22143b96d42d9ada17009420ea080e5650d30fb8a4e2e720117e +dist/2025-12-11/rustc-1.92.0-powerpc64le-unknown-linux-musl.tar.xz=f418ffded33abecec8d8aa72abf40448511ac78e8ae14ca43c066c7dd98310c3 +dist/2025-12-11/rustc-1.92.0-riscv64gc-unknown-linux-gnu.tar.gz=e36b96182e9a0c2e2f3a83cddfc5318a8ca2d049a0bddca9b42d05428ebed89d +dist/2025-12-11/rustc-1.92.0-riscv64gc-unknown-linux-gnu.tar.xz=729f4c074ccda30bff493fa94f255bcfcec1be594fecd8a4d0f57da845121c64 +dist/2025-12-11/rustc-1.92.0-s390x-unknown-linux-gnu.tar.gz=1fb255054864d857b32ca2c0dd06a2739cdd464d8872e18f2b103fb7a6d1f530 +dist/2025-12-11/rustc-1.92.0-s390x-unknown-linux-gnu.tar.xz=6a8cf614a74f7469c70d32b378f0163633e6bbe19624b248b758501c5bcdfe84 +dist/2025-12-11/rustc-1.92.0-sparcv9-sun-solaris.tar.gz=a5d20ba9277bb8b3b756f9f6dd2f7a1e9931ac8673fcca31d745eb81f1d573b6 +dist/2025-12-11/rustc-1.92.0-sparcv9-sun-solaris.tar.xz=74d6f885557f11b136d780c6fcc22d1db4b80644baaad22dbbbe29c890a0475a +dist/2025-12-11/rustc-1.92.0-x86_64-apple-darwin.tar.gz=d3dc5b7ddad48bb0afba0c6448aa00efec2d3fa9bc02ca55575c76d425c15ce4 +dist/2025-12-11/rustc-1.92.0-x86_64-apple-darwin.tar.xz=0facbd5d2742c8e97c53d59c9b5b81db6088cfc285d9ecb99523a50d6765fc5c +dist/2025-12-11/rustc-1.92.0-x86_64-pc-solaris.tar.gz=aeec5a91df699ab7a6b276e694a2711a59988dcc664ba9de43d5502e53d7b504 +dist/2025-12-11/rustc-1.92.0-x86_64-pc-solaris.tar.xz=03ed0965a4b4006f347513e7a2e7e0a9dac13053b432d65e97c59fd604973542 +dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-gnu.tar.gz=338ec86978c5d25799b79105c7bfb146002208d656f9e82b14692cd535c2ae65 +dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-gnu.tar.xz=fa0cbdf49f267f316433f054ca99951177827d0d406ddbaba9a0bbdcb093b56d +dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-gnullvm.tar.gz=b3575d7f29cd0423dbcf89457a9682acf8c0c1ad923136a12c7d3162c7b9a2d9 +dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-gnullvm.tar.xz=e67ec11b4c6e04e95effa7b4063ae8327c2861c6d08a7c692d69a0f1adcd8ecb +dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-msvc.tar.gz=4f321ca1903b8b08ceb07c0305f9f0320bc711ff6e285d726b8ef1dda774935d +dist/2025-12-11/rustc-1.92.0-x86_64-pc-windows-msvc.tar.xz=6aec5aba5384ce1041538e71ebebf671d82e29f4fe697bc7844626d94b0dbfe6 +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-freebsd.tar.gz=a0c0710281e86f7523d116c3826ed406491430d9f92769e4f4b4caf28e686edf +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-freebsd.tar.xz=f9b3a4fdb825c171e15f68db7c4faefecd60ea7475b9b11e98004fb7d711fd7c +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-illumos.tar.gz=b48d9c46b58f00a164b35611a58d0ed13bf5dd4ff7b138252b61f8100fcd7434 +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-illumos.tar.xz=e74f639cdfb368edfede795394932c8665cb192a2618e88c947ebd57ce2cc159 +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-linux-gnu.tar.gz=e133546ebb40974356cc82434e07f6a0ce15966d8b01898f97eab235c46883e8 +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-linux-gnu.tar.xz=78b2dd9c6b1fcd2621fa81c611cf5e2d6950690775038b585c64f364422886e0 +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-linux-musl.tar.gz=eaff6d6b051e59875eb585a981c799be87a2a68f1d52556dc64e26531a499531 +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-linux-musl.tar.xz=f1a037c367d29d329d041f0bf1d271e60440adc961b6eaa9ea902018a672d4a3 +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-netbsd.tar.gz=49f33344d9b22dea5a4f97f1d1c4fdb52afd1c34bd5fd78bb8d7e5e5ee92333c +dist/2025-12-11/rustc-1.92.0-x86_64-unknown-netbsd.tar.xz=a0cdbdd508e72de8f3e783b61827fac1f741acd6503464dc263a7292880a16e5 +dist/2025-12-11/rust-std-1.92.0-aarch64-apple-darwin.tar.gz=b1f55aac4bc982ea67b68b262b711263005e470d31cab5d09d534bc1866d455a +dist/2025-12-11/rust-std-1.92.0-aarch64-apple-darwin.tar.xz=ea619984fcb8e24b05dbd568d599b8e10d904435ab458dfba6469e03e0fd69aa +dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios.tar.gz=449a3f453215eaa86ee80bd4f70cb1a8dfca0447e27f7e820a73047913d7c724 +dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios.tar.xz=81fb496f94a3f52ec2818a76a7107905b13b37d490ca849d22c0a7a7d7b0125e +dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios-macabi.tar.gz=cc4ca331919012b71cb634082ab761003c752067a7b7cbcdb5a513a56f629bef +dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios-macabi.tar.xz=d0453906db0abe9efb595e1ed59feb131a94c0312c0bc72da6482936667ff8da +dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios-sim.tar.gz=1e08495db970e62931fd1f2349b10c04a765469aecd84b9ded10bcf09e98904d +dist/2025-12-11/rust-std-1.92.0-aarch64-apple-ios-sim.tar.xz=9362b66fbaf2503276ea34f34b41b171269db9ba4dce05dde3472ea9d1852601 +dist/2025-12-11/rust-std-1.92.0-aarch64-linux-android.tar.gz=f6689cf5b71056e887261ec84ae1f499eeb42c67e5ae73e7c0e06065b6648c44 +dist/2025-12-11/rust-std-1.92.0-aarch64-linux-android.tar.xz=ce6350bd43856c630773c93e40310989c6cb98a1178233c44e512a31761943d0 +dist/2025-12-11/rust-std-1.92.0-aarch64-pc-windows-gnullvm.tar.gz=4b4774c66e6952fb46d0049dffb2c664d95712052c4816e354bca3e97799dda4 +dist/2025-12-11/rust-std-1.92.0-aarch64-pc-windows-gnullvm.tar.xz=4e79f57b80040757a3425568b5978986f026daf771649a64021c74bcc138214b +dist/2025-12-11/rust-std-1.92.0-aarch64-pc-windows-msvc.tar.gz=7b27adfa0f10ee44a78430ad7ec000eb95cf4586b7338bc001dae5d5b865578c +dist/2025-12-11/rust-std-1.92.0-aarch64-pc-windows-msvc.tar.xz=b20c5c696af4ecfb683370ca0ee3c76ab8726fe6470ce9f1368d41a5b06ea065 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-fuchsia.tar.gz=ead00e822bf91191e4982e35d89744e977a9c51aa1b3ea1717e744c899067ee5 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-fuchsia.tar.xz=6021246b6c0d9d6104c0b350f7cd48a31d5707edaa8063f77f5636fe07bdb79d +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-gnu.tar.gz=04a5c9883bce2c4e89d22dd68af1bdc29b741bb456c01f8839b759a163e8e9d4 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-gnu.tar.xz=ce2ab42c09d633b0a8b4b65a297c700ae0fad47aae890f75894782f95be7e36d +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-musl.tar.gz=715fbcfd8712c723947a020d0371c8a1a21f7531f2b696aeaed50ac23ba675c9 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-musl.tar.xz=94b9f84f21d29825c55a27fbb6b4b9fb9296a4a841aa54d85b95c42445623363 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-ohos.tar.gz=0971b3c864ab1baa06a7fb5ba2fb176d8ca762bdecfd9e374810dc827d69d134 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-linux-ohos.tar.xz=6fb30061fae54c4a27bb209d314456d04826c345a8015b10d1fe9b82eeb46f9c +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-none.tar.gz=93e18afe654009b56783f1295d25a8bafa31badc8f6fcb46c2e217856daf68a6 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-none.tar.xz=ab6a2edab924739fc2c86e9f8fd8068b379e881a6261a177d66608d3ea4cacb1 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-none-softfloat.tar.gz=911108d6f01ff1040ea3de993bcf3ea52fe19aee099516a607e9967ce4813bcb +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-none-softfloat.tar.xz=0dc46fafaaa36f53eec49e14a69e1d6d9ac6f0b9624a01081ad311d8139a2be0 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-uefi.tar.gz=a14f2491f87149b779460b898ff1208adc31fc463094d8eff86e778fce9f6ce6 +dist/2025-12-11/rust-std-1.92.0-aarch64-unknown-uefi.tar.xz=f98001222bf23743598382c232b08d3137035b53645a420a1425288d501808af +dist/2025-12-11/rust-std-1.92.0-arm-linux-androideabi.tar.gz=7d9d430c187580c1075649dfdef03dde9f5616ed74ed050ae01cc9d5eda79268 +dist/2025-12-11/rust-std-1.92.0-arm-linux-androideabi.tar.xz=d41ec7255556b605dda04201a23e4445b5b86bc6786c703f91eb985bddc9f4ca +dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-gnueabi.tar.gz=56d8b0df4b716a69aeefc06fbd859461938d54bcac37d7eea25b07764f6e3c5c +dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-gnueabi.tar.xz=35478e20f8cc13912b31f2905b313a2820ddae564b363a66ab7a5da39d12787f +dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-gnueabihf.tar.gz=d0a355524cf219351f15d8984c102f6425bc2c6c1e14af9282e2db60a997a5e0 +dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-gnueabihf.tar.xz=836ada282b65c57d71f9b7e6fb490832410c954aac905c5437fb0bf851b53c83 +dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-musleabi.tar.gz=a505ed45f3c55334e8294f304366e2210609305dd25a86b0396c89016219a9d7 +dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-musleabi.tar.xz=91d3c5fdbda9ba2e778bb638e3a5d060f3021bbc7a60edf22b0035be4e611b30 +dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-musleabihf.tar.gz=1a2bba0ac573420064fec467a713ab169b54d9281d5652817d5d628a98ff167a +dist/2025-12-11/rust-std-1.92.0-arm-unknown-linux-musleabihf.tar.xz=20411e3858308add0dadde9ce2059d82cdd6c5339881fa93ac995e733df0f832 +dist/2025-12-11/rust-std-1.92.0-arm64ec-pc-windows-msvc.tar.gz=8cca22404b172c1ac590e6a507ec73bece0e3698bfd74f549246d23392ee3a45 +dist/2025-12-11/rust-std-1.92.0-arm64ec-pc-windows-msvc.tar.xz=1618d3d429a3c9b06d43bcc12ec7c50c5eb6cb01cb2f077c525bc0f077c7a6f0 +dist/2025-12-11/rust-std-1.92.0-armv5te-unknown-linux-gnueabi.tar.gz=547a6282ed5896dbac1df388a116301cfedf41fc579fa25caa57b3ee7e333e19 +dist/2025-12-11/rust-std-1.92.0-armv5te-unknown-linux-gnueabi.tar.xz=702be50f225ad4681af1bf9c40fd020b4623ee46aab5363ea96e4874dffb694d +dist/2025-12-11/rust-std-1.92.0-armv5te-unknown-linux-musleabi.tar.gz=578a0eee2513520e4195e09c0657b074cc9f7bff215507ddd905cfe7b15bab77 +dist/2025-12-11/rust-std-1.92.0-armv5te-unknown-linux-musleabi.tar.xz=c1c645c1b33625b9735a7c6f062a122fb172957093fac33f8ee3b80663deeb41 +dist/2025-12-11/rust-std-1.92.0-armv7-linux-androideabi.tar.gz=18f6e6903c5f4361efe8c8a1ea546303e4473e8b9cd1b11fcf4e5b170468d464 +dist/2025-12-11/rust-std-1.92.0-armv7-linux-androideabi.tar.xz=06ac2f08dcf5c480e7767c0541c9bd7460754ec3a369a4b7097b328eca28fab9 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-gnueabi.tar.gz=1e2238cb33c6adc29c13fdc980a4019587f69af5ae88f7bd473da2dbd9b70a2c +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-gnueabi.tar.xz=3d5e3fb14441ea8e6fc6307cbd89efd69be42143ff7f2b8dfb19818ddca993c0 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-gnueabihf.tar.gz=2c44994e0982bdb60c132c40b481b3c6ca83a131f09d568831553e3e29384130 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-gnueabihf.tar.xz=e3ac810db43067d8af9e17679d47534e871f1daad8cd0762e67da935681e9e19 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-musleabi.tar.gz=3bf1b0015dc3b0f5f6f5622588431855c658d5c47093f24e4077f6893229ab30 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-musleabi.tar.xz=89cbf7db934d543754b446a52398081ec40ee6b98ed5bca93ac1dbd5faf48c16 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-musleabihf.tar.gz=fc5c4ca757599caab8e93000becb9d57587088d32dab5c4f3b253f00ec3a2fd6 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-musleabihf.tar.xz=c7c08a389bd351226fd52266bfe2d2c444597e1bbb5d0307da44bdfa4df62c99 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-ohos.tar.gz=4cc8337f39f1b2820880dd8cac203399b5fd0eee7716d0a9c785a71f6d9fbf50 +dist/2025-12-11/rust-std-1.92.0-armv7-unknown-linux-ohos.tar.xz=e75603f745d5becd2e79d0cd6c7976e53bcc56d7af8ba1ac4e3494effc502f15 +dist/2025-12-11/rust-std-1.92.0-armv7a-none-eabi.tar.gz=b7b68dc24eb7e80592938a928372391e57fc04066238b178855f06863a597341 +dist/2025-12-11/rust-std-1.92.0-armv7a-none-eabi.tar.xz=e97368a7876332ce5181d8efca43996ee9d16ecc0be195e7d9b4f295a36c39ac +dist/2025-12-11/rust-std-1.92.0-armv7a-none-eabihf.tar.gz=f79f1983b5c3867657ba1849472b0aa1a54ab1ab94bab66f046583f8858bebad +dist/2025-12-11/rust-std-1.92.0-armv7a-none-eabihf.tar.xz=407899b91b4a44d5096bebbae00b3044ecc71e4cce958f79a149f4149a662bf6 +dist/2025-12-11/rust-std-1.92.0-armv7r-none-eabi.tar.gz=310c5149e672a794364c389ee383f437e367eac912c8c9c63e9e024c8eb5a98e +dist/2025-12-11/rust-std-1.92.0-armv7r-none-eabi.tar.xz=d135b9aa652dbdbf8115c31a71eb5b5e022968dd3c98a6d0421ad13ed8b8385e +dist/2025-12-11/rust-std-1.92.0-armv7r-none-eabihf.tar.gz=49b7583f91e42ee05c057e8ca5b736d883725d40e71bc8f8ce369b46bb074343 +dist/2025-12-11/rust-std-1.92.0-armv7r-none-eabihf.tar.xz=d6b44323ffcb32ead9be54ef4786048f48cec1f18cd269e2fcab36d2c3d5e7e9 +dist/2025-12-11/rust-std-1.92.0-armv8r-none-eabihf.tar.gz=f0b184acd74d500d6a7f559a62d7946d00fed6ac427bdbd7c52640be6d98e767 +dist/2025-12-11/rust-std-1.92.0-armv8r-none-eabihf.tar.xz=355ffd45d0d450e1e5d2ce8aa1ff0977ebb4b3ca9c6689e8d72dcd2c56b6046d +dist/2025-12-11/rust-std-1.92.0-i586-unknown-linux-gnu.tar.gz=3fb6630b6341a07a9bbc37a8c541ad3e389a26dc0ef48c09aa3b14a6afbf672a +dist/2025-12-11/rust-std-1.92.0-i586-unknown-linux-gnu.tar.xz=8b984b31ffca1f27d32ee77ec2cc4c2ab59e72beab67bfce13bbd926dbea8715 +dist/2025-12-11/rust-std-1.92.0-i586-unknown-linux-musl.tar.gz=6c39e5506fd6a0532d15f3cd9510e6e9fb0da0712f426b8a55f04114125b6e13 +dist/2025-12-11/rust-std-1.92.0-i586-unknown-linux-musl.tar.xz=059d919f147e6bd40e132ad00ee23de59d5464f5e3409f3139b3ac14faf45893 +dist/2025-12-11/rust-std-1.92.0-i686-linux-android.tar.gz=d994d70493ad68ced22a5269e41b9fa6f83af9f3adabade154860058bc2e18c0 +dist/2025-12-11/rust-std-1.92.0-i686-linux-android.tar.xz=e45832b005556f65c6d26f05f34bd4ab5ceea8d9b9fefc4175d52b0780ca89db +dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-gnu.tar.gz=5f30330e61a7d87426e3192e3ba99ec5db2b3d239825f15ce7482b88e695757e +dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-gnu.tar.xz=b3eefe10d4aed3ccbeaff3ae9cd2e0e0a36894c0635d0e69af1c9a698679d75f +dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-gnullvm.tar.gz=916badef8e6415e599b41b706aa522f514ee2932b5e65baea5b04db34e03c185 +dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-gnullvm.tar.xz=e6d709f85dea51d81f2f1a030845b732b9f7761d95d93c57c7276b0a451c2993 +dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-msvc.tar.gz=2d248d48ff8650e61097c57d653ae3c785413b8fa916c51623374b22c5f3be0c +dist/2025-12-11/rust-std-1.92.0-i686-pc-windows-msvc.tar.xz=e5671b276047647e994a7cab99c90ee70c46787572fbe4e266a13c6edb84d5ce +dist/2025-12-11/rust-std-1.92.0-i686-unknown-freebsd.tar.gz=235c77dac41505cfc170a448ff70695fbb78b986e6febbb72eb931f23c66d8cc +dist/2025-12-11/rust-std-1.92.0-i686-unknown-freebsd.tar.xz=e008a0506ec4d5eff30abdf376c7933e235670bd6c5e1131c52bcda097a21116 +dist/2025-12-11/rust-std-1.92.0-i686-unknown-linux-gnu.tar.gz=f568a3c307fad16528bf5accecfdce9e77b6ebda3302ae7a79588adc10d2bd29 +dist/2025-12-11/rust-std-1.92.0-i686-unknown-linux-gnu.tar.xz=abc840631a4462a4c8ec61341110ff653ab2ef86ef3b10f84489d00cc8a9310d +dist/2025-12-11/rust-std-1.92.0-i686-unknown-linux-musl.tar.gz=3d6ccb700a17533eea10c7541896c92817783045c5537af37228142da7668fb3 +dist/2025-12-11/rust-std-1.92.0-i686-unknown-linux-musl.tar.xz=c796874b1343721f575203fa179dc258e09ac45cd95dd6c35c4d5979a3870494 +dist/2025-12-11/rust-std-1.92.0-i686-unknown-uefi.tar.gz=78814c81a60fc1e3326f6d00eee4bc907053bb3a8971a825bf6728ba645f264c +dist/2025-12-11/rust-std-1.92.0-i686-unknown-uefi.tar.xz=90da7759e28e62fb82454d4eb4e02ac14320b8da3372e02f9ca4f47f7afbfe40 +dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-linux-gnu.tar.gz=cabff40eb871616ce5d40592262b25aba1e6ff8f309bb6e0dab08609470dcfce +dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-linux-gnu.tar.xz=62e2568ebf6f1addc750a8c32dd1fa4fef8d27679cbac33b837afeb54f204819 +dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-linux-musl.tar.gz=e46b3f6a18ba0faa5190deb3ee296fc971214c9d38f9d616fce2457e335a98a8 +dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-linux-musl.tar.xz=274838eebb615e6d2719157aa53230cd0c3233a1e6f1c975c0f5978198c55da3 +dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-none.tar.gz=dfe120d2bc8cb81ee70c2a2e1ad685d382a0ebd72b37231183d8cb7b6890effe +dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-none.tar.xz=7e03cbb3aeb5a2c882433f2de0d096455bcab2465729cb0399d1b31e2d400075 +dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-none-softfloat.tar.gz=7e07f54e69ee2b7e4ef2861d7b1fcadfe3fda3ccb5442e0d85afe1dfdfc52b8a +dist/2025-12-11/rust-std-1.92.0-loongarch64-unknown-none-softfloat.tar.xz=dd01f0348ca2c90d6115b79894360f9ae8468aa8755e0f345e53fe5186f2d891 +dist/2025-12-11/rust-std-1.92.0-nvptx64-nvidia-cuda.tar.gz=3f4ac1e0c35b4a709d926727a49c86d169fa61660d08e940f10f948da9777375 +dist/2025-12-11/rust-std-1.92.0-nvptx64-nvidia-cuda.tar.xz=e8d3d0d81d5bb92baae3f0cc0c43d456e312d6f2770c460ff62521dccba7a855 +dist/2025-12-11/rust-std-1.92.0-powerpc-unknown-linux-gnu.tar.gz=28320c60a2fb42756d7a825f44d35c12100492c44770b0658056e4c468974f86 +dist/2025-12-11/rust-std-1.92.0-powerpc-unknown-linux-gnu.tar.xz=c3e809a324b00eb53096c58df38645bb496c6560de334dfe04ed0b77c0605aaa +dist/2025-12-11/rust-std-1.92.0-powerpc64-unknown-linux-gnu.tar.gz=c47938c152f1b237c901090d69522ce1ccfa69a859ed10d634fe3083108c3017 +dist/2025-12-11/rust-std-1.92.0-powerpc64-unknown-linux-gnu.tar.xz=2ce706afa4a46b6773340854de877fc63618a40e351298a4e3da8eb482619863 +dist/2025-12-11/rust-std-1.92.0-powerpc64le-unknown-linux-gnu.tar.gz=f63de16a3c3f8e11aaf21de60ec38de59b1234aea4fe38d0577414a43adc4a8e +dist/2025-12-11/rust-std-1.92.0-powerpc64le-unknown-linux-gnu.tar.xz=eba59766c2d9805c0a1fc82fd723acbb36569e1bec1088c037bba84d965f70ba +dist/2025-12-11/rust-std-1.92.0-powerpc64le-unknown-linux-musl.tar.gz=696958d87842d877640140ddbbaa74d044374874dee9516e227a395b70bfb8d4 +dist/2025-12-11/rust-std-1.92.0-powerpc64le-unknown-linux-musl.tar.xz=8b515e18b6ac8f8d37ea3cabe644b7f571984333c3b4192b7f5877e79eae7893 +dist/2025-12-11/rust-std-1.92.0-riscv32i-unknown-none-elf.tar.gz=a56084ad27ec50df0a0da2473deb84d51cb831cbf913bf983a029850e9e9f0ac +dist/2025-12-11/rust-std-1.92.0-riscv32i-unknown-none-elf.tar.xz=e115633fa0dccec2f94477e26c5c93cbb17c54af2769e19b4636f50708a00f6b +dist/2025-12-11/rust-std-1.92.0-riscv32im-unknown-none-elf.tar.gz=b1ac7c191995b67f819446f2dc1bc4a3e66036aa5ae54ad05b7891bb4bbf0e50 +dist/2025-12-11/rust-std-1.92.0-riscv32im-unknown-none-elf.tar.xz=2d7547fbf012b06a2b570c94e3611b86fb10edcf23589c47ea4da99c87d50537 +dist/2025-12-11/rust-std-1.92.0-riscv32imac-unknown-none-elf.tar.gz=52d8c75e48a2575381e2a041a5bb359adf161a6c29f4ba990e54384fa6699861 +dist/2025-12-11/rust-std-1.92.0-riscv32imac-unknown-none-elf.tar.xz=5915223db6b8afa173f67eb4fe6f5aff2402351ed9abab1b370d0860be4af6c9 +dist/2025-12-11/rust-std-1.92.0-riscv32imafc-unknown-none-elf.tar.gz=2bd1d15d7d1e1a133afc7244375f3af405453153c4c3f924a0ee019fff807ca6 +dist/2025-12-11/rust-std-1.92.0-riscv32imafc-unknown-none-elf.tar.xz=a3de78da39a79a9facf729ac005f69b4d3c68044f0b8ec4daa9e271a719d9a46 +dist/2025-12-11/rust-std-1.92.0-riscv32imc-unknown-none-elf.tar.gz=939b46b6320a082d562ba79efd53a028b3c01276f70106ecbcc95148b013f990 +dist/2025-12-11/rust-std-1.92.0-riscv32imc-unknown-none-elf.tar.xz=e1c6968ce25ab78f2c5b5460691763a2d39cb71b01d6d54c208d4a8b735b0584 +dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-linux-gnu.tar.gz=b15965fec2297deff49412cc0e22a005db5ff710ca77187058c4907f1e7dd467 +dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-linux-gnu.tar.xz=8ee20dcf3b1063fa6069b3ce85e1fcf42794dfa783263314865cb53fff42d9e4 +dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-linux-musl.tar.gz=34f5722ff2a0940bcd7ff6603a7748d2b963de72f6f713579c39c74ead06a7a0 +dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-linux-musl.tar.xz=f20d822309900fd6c7230688694baf91e900154e44e6247feca49b7b7a203a57 +dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-none-elf.tar.gz=aa6d992ef5ea58a732e9f7a5843b37b6d03059f0de90bd6f0e45a9067e4c52cf +dist/2025-12-11/rust-std-1.92.0-riscv64gc-unknown-none-elf.tar.xz=7eacf6a98786d58ef912643fd5aedc35111712e96a47b7e5d3ccddcdf9fb166d +dist/2025-12-11/rust-std-1.92.0-riscv64imac-unknown-none-elf.tar.gz=d81c6b2c7c71e38e6b0e1634af5b782e23f35adef36e1f35237d66c191d9f170 +dist/2025-12-11/rust-std-1.92.0-riscv64imac-unknown-none-elf.tar.xz=e3eda32b99bbff3fe77aa72c29de9373009e8650f7ab93c2b4c344ad13bc459e +dist/2025-12-11/rust-std-1.92.0-s390x-unknown-linux-gnu.tar.gz=c33203be69a7415c6d3465bc30189617684105bdcd68a3c78d6b7257c83b005b +dist/2025-12-11/rust-std-1.92.0-s390x-unknown-linux-gnu.tar.xz=ebf944dc95015498d322504a54e4f9cdb28590f7790aa3a9eb86d6cf4b6c93ff +dist/2025-12-11/rust-std-1.92.0-sparc64-unknown-linux-gnu.tar.gz=6915a7d1880facef71d4712623b254a78fdc7c9edc8f98e3200b6095d81b99ab +dist/2025-12-11/rust-std-1.92.0-sparc64-unknown-linux-gnu.tar.xz=d85afb14120c3c7367338a565a920db653dccd4bc5062398791d7b62b89fd1fd +dist/2025-12-11/rust-std-1.92.0-sparcv9-sun-solaris.tar.gz=637a8fcc402792ab97411031258fdbbfbe66328fbc4aad8aa536f598501ba10d +dist/2025-12-11/rust-std-1.92.0-sparcv9-sun-solaris.tar.xz=e9ae7dc479e6c97335b3ebee8c3d69069cf6a617942196871229794ca94f3458 +dist/2025-12-11/rust-std-1.92.0-thumbv6m-none-eabi.tar.gz=a8a57993bb98d61486fac274b285168e253988d7a7fca0b3f72dc23057d9a88e +dist/2025-12-11/rust-std-1.92.0-thumbv6m-none-eabi.tar.xz=f55de77126b60e1da38f8a5cdd127db872155ce9fbb53d4459502dd47b1dd476 +dist/2025-12-11/rust-std-1.92.0-thumbv7em-none-eabi.tar.gz=fdbc35de85989f4c2155b813d1ba4abb34f57c195d97ed863c06de8b8fb426d7 +dist/2025-12-11/rust-std-1.92.0-thumbv7em-none-eabi.tar.xz=fdee017dcebfa8675220c20ca65b945b6eaee744d5d19b92cb0ca5480dd19ba6 +dist/2025-12-11/rust-std-1.92.0-thumbv7em-none-eabihf.tar.gz=d94cd679358a4eb33970df571fdfcacb385980c4f4a3f92114ffa5d356f86456 +dist/2025-12-11/rust-std-1.92.0-thumbv7em-none-eabihf.tar.xz=6bfd083ce4917440fb4b04ca39ab4dadc9f40d9dc2775056899857bfa8911fd0 +dist/2025-12-11/rust-std-1.92.0-thumbv7m-none-eabi.tar.gz=7861c515c0fdb2fcf74e434813d43de8d0b084babdd87b9cd8bf67fc173cfc54 +dist/2025-12-11/rust-std-1.92.0-thumbv7m-none-eabi.tar.xz=7dc4c92e97db5ce1ddd9fbb7fbb1ad2d367f1c2e20d296a6d6427480c900c315 +dist/2025-12-11/rust-std-1.92.0-thumbv7neon-linux-androideabi.tar.gz=28f77e164fbdb373d5bf729a7672d775d57a08ccbbf2d8d6aefffa0f1b9d6112 +dist/2025-12-11/rust-std-1.92.0-thumbv7neon-linux-androideabi.tar.xz=ce99df993198da32a2f655d8f6666f2ef7995242cdc31686db49bfeac07e6f7c +dist/2025-12-11/rust-std-1.92.0-thumbv7neon-unknown-linux-gnueabihf.tar.gz=c9de934e22d796a4f542783d60b43b62a213a15014bbea02ca9f9520abfec872 +dist/2025-12-11/rust-std-1.92.0-thumbv7neon-unknown-linux-gnueabihf.tar.xz=08a51cb570fc25bf226c25c1031b98d3963a52e263bbacd873f111faa918484e +dist/2025-12-11/rust-std-1.92.0-thumbv8m.base-none-eabi.tar.gz=06453a93570c63a0d6a56000493d4e6ff20f1e20c4c3b9ec7124359ebc79a3eb +dist/2025-12-11/rust-std-1.92.0-thumbv8m.base-none-eabi.tar.xz=3c5d71fa1d6f242be184339d8bbb360acf9ca552f0093c10309c83e06a95bcaf +dist/2025-12-11/rust-std-1.92.0-thumbv8m.main-none-eabi.tar.gz=c3c0cde9afce994bfbd0f2fbde02efb6ad1238a3d33056ccac6e99aba579af3a +dist/2025-12-11/rust-std-1.92.0-thumbv8m.main-none-eabi.tar.xz=61a6a80d03ebdb80ab06a044d4ec60e3c2bd8dc4d6011e920cf41592df4f0646 +dist/2025-12-11/rust-std-1.92.0-thumbv8m.main-none-eabihf.tar.gz=21336cc1a032eb35b8c4a546805ce1e8e3afa24735ee23aae5599fd8787ce581 +dist/2025-12-11/rust-std-1.92.0-thumbv8m.main-none-eabihf.tar.xz=24c2f65371a2a5c6a40b51ae0e276ea9afff0479255f180f5e1549a0a4d58fb3 +dist/2025-12-11/rust-std-1.92.0-wasm32-unknown-emscripten.tar.gz=fec9cb6cced27592fa601c18afb357bb861d5ebeaad1dda9304f6acfd85b4000 +dist/2025-12-11/rust-std-1.92.0-wasm32-unknown-emscripten.tar.xz=59b7adf18c0cc416a005fad7f704203b965905eb1c0ed9c556daa3c14048b9f4 +dist/2025-12-11/rust-std-1.92.0-wasm32-unknown-unknown.tar.gz=4763b575ecceab7637557527a91af6c5c36816a68e3f2de1e18518dd15a63bcd +dist/2025-12-11/rust-std-1.92.0-wasm32-unknown-unknown.tar.xz=6c73f053ccd6adc886f802270ba960fd854e5e1111e4b5cfb875f1fdcfc0eb60 +dist/2025-12-11/rust-std-1.92.0-wasm32-wasip1.tar.gz=a8736000e35213951e53315e3d5841cbe8e6c70fad167a302bd8ae1a43331cec +dist/2025-12-11/rust-std-1.92.0-wasm32-wasip1.tar.xz=8107dc35f0b6b744d998e766351419b4e0d27cddd6456c461337753a25f29fcd +dist/2025-12-11/rust-std-1.92.0-wasm32-wasip1-threads.tar.gz=87476037322f6bb9467467ce0b11bc2fe81d9fab181a14f6adbb949136f044d6 +dist/2025-12-11/rust-std-1.92.0-wasm32-wasip1-threads.tar.xz=feea056dd657a26560dfddfe4b53daeef3ded83c140b453b6dbdebaabd2a664c +dist/2025-12-11/rust-std-1.92.0-wasm32-wasip2.tar.gz=20b2ee79e2a66f80764f2829b9cd313bd66532fff85c71a75cd7d4f6f75decbf +dist/2025-12-11/rust-std-1.92.0-wasm32-wasip2.tar.xz=e69ce601b6b24eea08b0d9e1fb0d9bf2a4188b3109353b272be4d995f687c943 +dist/2025-12-11/rust-std-1.92.0-wasm32v1-none.tar.gz=b5d12a32aef0ce2be6999e7a15f21496e50fc9366e2dceb273e3816381821f73 +dist/2025-12-11/rust-std-1.92.0-wasm32v1-none.tar.xz=0b89f2b5a720589168a81e294fc80ab6bc2c7bbe5509030dd17ad38e221ce903 +dist/2025-12-11/rust-std-1.92.0-x86_64-apple-darwin.tar.gz=1e5a8fee4e038ea2d35d82a680e2b9bf44ffccb3746aaf9dbdc56cb14152dcb8 +dist/2025-12-11/rust-std-1.92.0-x86_64-apple-darwin.tar.xz=6ce143bf9e83c71e200f4180e8774ab22c8c8c2351c88484b13ff13be82c8d57 +dist/2025-12-11/rust-std-1.92.0-x86_64-apple-ios.tar.gz=4ca50621893f34bde5ad81cd82006c8b271fef8cc0ba4a4e1418fe3dbf599e56 +dist/2025-12-11/rust-std-1.92.0-x86_64-apple-ios.tar.xz=b6e38e5f8c9e6fb294681a7951301856b8f9424af4589e14493c0c939338814c +dist/2025-12-11/rust-std-1.92.0-x86_64-apple-ios-macabi.tar.gz=14e6389c01ab709dbf62885639b8c3e6fc97e6d8fa91f9805db26e9309107ec2 +dist/2025-12-11/rust-std-1.92.0-x86_64-apple-ios-macabi.tar.xz=6a292d774653f2deaac743060ec68bfd5d7ff01d9b364e1a7d1e57a679650b47 +dist/2025-12-11/rust-std-1.92.0-x86_64-fortanix-unknown-sgx.tar.gz=88fc95491ec06d98bde84ccf4b6a4cc63aa0a6d3e66e0d796de158afb7d69c67 +dist/2025-12-11/rust-std-1.92.0-x86_64-fortanix-unknown-sgx.tar.xz=b0339c3bf7966e7b1c9892f855c85d123382632f49a1d1f589db68bf0908feb7 +dist/2025-12-11/rust-std-1.92.0-x86_64-linux-android.tar.gz=b9074f6961baff09334afaff745fb16dbf9f05cdf856b17309d8e6232a281c40 +dist/2025-12-11/rust-std-1.92.0-x86_64-linux-android.tar.xz=ffd39429435ff2f0763b940dd6afb4b9ccb1ed443eeef4fff9f1e9b3c5730026 +dist/2025-12-11/rust-std-1.92.0-x86_64-pc-solaris.tar.gz=28f7f5568399c56e64f614194dc70f7073c0e394c5ad60bcb85dc1b1018c6089 +dist/2025-12-11/rust-std-1.92.0-x86_64-pc-solaris.tar.xz=776ceb389296b22a74bd7631f4440b965504d1687448030d2d51c853fe4598a5 +dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-gnu.tar.gz=6256f3497e3b14b6650511e84fdfb51fc632db1908ae5a173dffcdc96c80b7ce +dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-gnu.tar.xz=d4043304ef0e4792fb79a1153cbeca41308aac37cb1af3aa6bc3f0bb6d2276e1 +dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-gnullvm.tar.gz=67bd7e328b9579c01365c01f58e29fa616806444eafb9b8bfead0de2b57fcf32 +dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-gnullvm.tar.xz=6169605b3073a7c2d6960bc1c74cb9cd6b65f45ee34e7ede02368e07ce4564cf +dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-msvc.tar.gz=3af377fb29083c2117e85e6a107aedb008bd76929c22d56ce45c5be1be3a2540 +dist/2025-12-11/rust-std-1.92.0-x86_64-pc-windows-msvc.tar.xz=b4e53a9c9b96a1a0618364791b7728a1c8978101ec6d1ee78fe930e1ef061994 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-freebsd.tar.gz=3616afb808cd030e65e66c51f6f0fb6a6fc52d877d0d70bb681b0c35238adbe8 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-freebsd.tar.xz=151929a4255175d14b2cbcb69ef46d9217add23be268b9cd1446f8eab16616f2 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-fuchsia.tar.gz=8b895dc4bbd95481cd171a6de01a0b74248fbd3f55bafec8dc0360e110946836 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-fuchsia.tar.xz=51ec26391d166e2f190a329919e3c7bd793861f02284aba461a086268725d9f1 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-illumos.tar.gz=a197e02ac48cdacfdb7487f612818b23c461c52e7e6015737a6b0a1cc2a744c5 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-illumos.tar.xz=31c6f2296543e684554b9eb4ac34551270a0a9c7d0cbc96986cf15a301e27035 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-gnu.tar.gz=ba4e0b4a60c082e0b1cc6284a38bb144844c92f1aab09732cd1183658e08a6e7 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-gnu.tar.xz=5f106805ed86ebf8df287039e53a45cf974391ef4d088c2760776b05b8e48b5d +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-gnux32.tar.gz=8b9c9330278a97b79f3783dbacaaf4c0d110bb608cd1c615bb931b340ca6b27f +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-gnux32.tar.xz=f29c2380d21edbd0cd9f674a2915ccc95822c9ecdae3b2e823f066de32760bb9 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-musl.tar.gz=8bfd9a42c8295949d556587201acdb35d2bfb8b7ce55223845f337aa5614f9a3 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-musl.tar.xz=11f0b7efccdb5e7972e3c0fc23693a487abc28b624675c08161d055a016d527e +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-ohos.tar.gz=61dfeaf174eabc9152fff91b9de705539e76f623f37606ac878564fef79fb4fc +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-linux-ohos.tar.xz=a5d6c40e3e712d9d7ffcc3d3895e53dad19bcba792ad6b6945a60304bdb82be1 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-netbsd.tar.gz=1048621ad4bcd2c629882e74f9439d8b0508e6eb4ce5fee5dab0ffd6a5988261 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-netbsd.tar.xz=db6a8d3a091551701b12e40cc58d4a541adfb63f250074aae90d250329beb8de +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-none.tar.gz=a912deaa2ceff2042cb67a12e82b9212c849c1bc0321aea639f2ec432d13f9d2 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-none.tar.xz=1d8420ab8eb241a35e38b76470277c722bd5a7aa4ac0c7a565ad6f30b37cb852 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-redox.tar.gz=c5a5c0dc2ca2eec79b78d9efa4af92815a3b0aefdb4009fb523b9d2a989d55de +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-redox.tar.xz=c5c1466da81956d483fe673c604e7c66f5d16e44752d39c79fab45906738b178 +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-uefi.tar.gz=89a5e952221daa4cdbd4d033bb33a18855e1f3428a022af31843391af6cda8dc +dist/2025-12-11/rust-std-1.92.0-x86_64-unknown-uefi.tar.xz=1b849250cf095269f3a2c7bc2087a919386da7da28e80dc289e6268bc705142d +dist/2025-12-11/cargo-1.92.0-aarch64-apple-darwin.tar.gz=5295d590590a606d98e3f97b730fe3b4e8d96a0c78e5268232b15b3c45180d28 +dist/2025-12-11/cargo-1.92.0-aarch64-apple-darwin.tar.xz=bce6e7def37240c5a63115828017a9fc0ebcb31e64115382f5943b62b71aa34a +dist/2025-12-11/cargo-1.92.0-aarch64-pc-windows-gnullvm.tar.gz=77567d78fd5d8ae368a21682172aa929cb6b293dd03d234b01fb0e014b14c29c +dist/2025-12-11/cargo-1.92.0-aarch64-pc-windows-gnullvm.tar.xz=56d38a6a89e2a38ec777938d74feb93a3498bc8788df96a94fcb4eac2e07338b +dist/2025-12-11/cargo-1.92.0-aarch64-pc-windows-msvc.tar.gz=c283f18461a840191b2e03d19a8ac0e6441646b668a94a03a3e76e11b75296fb +dist/2025-12-11/cargo-1.92.0-aarch64-pc-windows-msvc.tar.xz=3fc47cc29781190c5075f807836c4b98d411aaf27c59598fbfb2aa781ccf6190 +dist/2025-12-11/cargo-1.92.0-aarch64-unknown-linux-gnu.tar.gz=f0bc99a9990f722c3c795bd778cae6aa7927a9907100698a1eed272beb4bef20 +dist/2025-12-11/cargo-1.92.0-aarch64-unknown-linux-gnu.tar.xz=cb2ce6be6411b986e25c71ad8a813f9dfbe3461738136fd684e3644f8dd75df4 +dist/2025-12-11/cargo-1.92.0-aarch64-unknown-linux-musl.tar.gz=92287147c07b5b31b69b355eb8040f4d3cb22cede8418ee77f806a93e90cc005 +dist/2025-12-11/cargo-1.92.0-aarch64-unknown-linux-musl.tar.xz=492614aa4fab1d58cdf495ab040426174e740038f715145bbbce7a87716a4c8b +dist/2025-12-11/cargo-1.92.0-arm-unknown-linux-gnueabi.tar.gz=09dc930cf59637c3bd48ff5bc0b53200949e5194e39fbba374f139a7a03f69a8 +dist/2025-12-11/cargo-1.92.0-arm-unknown-linux-gnueabi.tar.xz=d09d3e8402f868b784aa17f2e8268de91d8f4634c34bfb5be65596abc6043d35 +dist/2025-12-11/cargo-1.92.0-arm-unknown-linux-gnueabihf.tar.gz=401b054bc35f33835e6234352b519858ca9fe009bd01b85766dbcacce986dc48 +dist/2025-12-11/cargo-1.92.0-arm-unknown-linux-gnueabihf.tar.xz=dbeb44e4924218afc7c57db5f7a48058fe0bd0653c292fab5cc4a8b9016b2096 +dist/2025-12-11/cargo-1.92.0-armv7-unknown-linux-gnueabihf.tar.gz=861561f65347eb9020cb93daa51eb43592f994dca7c392a3e8d9771ab797435a +dist/2025-12-11/cargo-1.92.0-armv7-unknown-linux-gnueabihf.tar.xz=713f7d2ca8776ce537c0a5e716f7bdf644d54949c78c0a98ca4113f80bd670e7 +dist/2025-12-11/cargo-1.92.0-i686-pc-windows-gnu.tar.gz=c7f394ac5eb52bb9790feedbc2a22bbf5770c614f94ac899004e895580fe8955 +dist/2025-12-11/cargo-1.92.0-i686-pc-windows-gnu.tar.xz=8b6368d75f20c3cdfbb0c03f2cd7c386b9224bbf3717fbd635fff6ace0260660 +dist/2025-12-11/cargo-1.92.0-i686-pc-windows-msvc.tar.gz=25035fc699d3d907e0ac3c77ee4b524455b29d762b98951dd4f8084c64d0c416 +dist/2025-12-11/cargo-1.92.0-i686-pc-windows-msvc.tar.xz=a734070e84d1d9124bd0f4157eadf66c5b2030e49162f209ad0a0ebf895333ff +dist/2025-12-11/cargo-1.92.0-i686-unknown-linux-gnu.tar.gz=f95a54f1aabc6b4611d80f2bd5dda8f27719266f7cd829c5b9c2edcbf190a42c +dist/2025-12-11/cargo-1.92.0-i686-unknown-linux-gnu.tar.xz=63001bbde1c036fae9ad624807bfb18117c7e7cb4a04de81adc4acc7e8580c07 +dist/2025-12-11/cargo-1.92.0-loongarch64-unknown-linux-gnu.tar.gz=572a85632fcf90dd9fa359dd6eaed16266b75eaccc7d47e2c6974a01b0139b27 +dist/2025-12-11/cargo-1.92.0-loongarch64-unknown-linux-gnu.tar.xz=32f4b393f1471d7d50c9a50512f02116187b3ea6a885c26ff2d74f87fa72baa8 +dist/2025-12-11/cargo-1.92.0-loongarch64-unknown-linux-musl.tar.gz=0a02be499899e8a59fdf97e08bd1c2eaeb2bcb1328e230d8966eb1c0c0fc736e +dist/2025-12-11/cargo-1.92.0-loongarch64-unknown-linux-musl.tar.xz=edf8ae60bbe7821dfd02434951cca3b8c3ea63dc075b8a425ca45ac84da5796e +dist/2025-12-11/cargo-1.92.0-powerpc-unknown-linux-gnu.tar.gz=f33e2312126f52f0da9e5073b4311e9cad114228607e0fb5c3ae51b3add2a624 +dist/2025-12-11/cargo-1.92.0-powerpc-unknown-linux-gnu.tar.xz=1249c64f95d8187b3a89cf8429329bdbc98f53a9fc538e898c95c487e3234d90 +dist/2025-12-11/cargo-1.92.0-powerpc64-unknown-linux-gnu.tar.gz=414cfee5d5c39b757fb4bead92af90018601f8e40a447c2d2ee172a235605ecb +dist/2025-12-11/cargo-1.92.0-powerpc64-unknown-linux-gnu.tar.xz=e94a8f97c3143158e285b4f8ade1fae844961caca30c0eeed44f6c14da484f05 +dist/2025-12-11/cargo-1.92.0-powerpc64le-unknown-linux-gnu.tar.gz=69f56f4df9722d1a50273a69d32ed4593e84ec81f61ec949e58684e2ab1fac5c +dist/2025-12-11/cargo-1.92.0-powerpc64le-unknown-linux-gnu.tar.xz=49dd01f5d10e3f368181223db0fbf7dc191161f7d80a295de4909bf87e53da58 +dist/2025-12-11/cargo-1.92.0-powerpc64le-unknown-linux-musl.tar.gz=37a3d27d185abf8e3af51912f5f28b6acbd768445d1ca78e97acab5de4741b8a +dist/2025-12-11/cargo-1.92.0-powerpc64le-unknown-linux-musl.tar.xz=0f64d4df6bfad74ac9a60dfccf0c574ef56cd092d3207931b100e9b9130f7640 +dist/2025-12-11/cargo-1.92.0-riscv64gc-unknown-linux-gnu.tar.gz=6e6e42f0fbe0d0f8aca38946b3884b8d0cde6513ffe59fe9c2bcccd89d40f0e4 +dist/2025-12-11/cargo-1.92.0-riscv64gc-unknown-linux-gnu.tar.xz=e8708d0a929ad15941ecde368e8a156911927a805b492afafc737124b6aa55d4 +dist/2025-12-11/cargo-1.92.0-s390x-unknown-linux-gnu.tar.gz=8efdf1355d3eb6107854dcd3ab5b4396bed7b09910099dc791633740859cf5f2 +dist/2025-12-11/cargo-1.92.0-s390x-unknown-linux-gnu.tar.xz=a290edf359a5632dfda3b2325a309d9edeb58c97de97e3cc67274335b58adf05 +dist/2025-12-11/cargo-1.92.0-sparcv9-sun-solaris.tar.gz=535bf08187504fc5b157be2443973310e94ce75ab029ccf54f39f59b0f2d4c88 +dist/2025-12-11/cargo-1.92.0-sparcv9-sun-solaris.tar.xz=a0749eb1c52b8b6488fa0515ce0ae945f5a8dee331762334e1462776dfa0ec96 +dist/2025-12-11/cargo-1.92.0-x86_64-apple-darwin.tar.gz=3423880db7c38ba0259dbe8106039ad9cfb650c65b7bf311a33addd05aec3cb5 +dist/2025-12-11/cargo-1.92.0-x86_64-apple-darwin.tar.xz=b033a7c33aba8af947c9d0ab2785f9696347cded228ffe731897f1c627466262 +dist/2025-12-11/cargo-1.92.0-x86_64-pc-solaris.tar.gz=6f6f2a5b13fdde3ebcdb4e3f9a0a62104616940400bad050d27dec9c9cb00b25 +dist/2025-12-11/cargo-1.92.0-x86_64-pc-solaris.tar.xz=cbfc3e9543990f65dff8c76f0cc87b22b15f5ed6777cfb71b7eb7ea634a4d27f +dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-gnu.tar.gz=e2c59ffc93e18049f0ee829e6a9b768aa97a7aee480a28576cf786fd4aeb95dd +dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-gnu.tar.xz=962e0350346b417719cc36db333424a03e368d602fb411676c901f15487ea29c +dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-gnullvm.tar.gz=8c5de85558085a3e0f3b3280865236d3ea6d06c6e39fc458318c6b4becb7ad7f +dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-gnullvm.tar.xz=c27d5936e1c11feb33f3221b85741c33f783c8723fca84552e7c2a5a73959352 +dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-msvc.tar.gz=9f6178ddcaed7c9190c454db5da801e2fe6c8fde8600258a9bdd0e107e81ac3b +dist/2025-12-11/cargo-1.92.0-x86_64-pc-windows-msvc.tar.xz=f4057534ec58708ed3554957582a6c8e8c6abfee011b5c8ad45c3ab27c0b3076 +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-freebsd.tar.gz=a43043c5bbc907260594d542ea0dd17630d432024dd0af0b90c99b7397227f9e +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-freebsd.tar.xz=7bf1853c6ac4b426d7b4b67ee4ecf60f4a3e83151147a13b4cf04f81ccff3c4b +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-illumos.tar.gz=4c679e0c8c18649ca280096b1d6b7856a26540a6ac37e4fca371576c1dc0811e +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-illumos.tar.xz=a620fd5c893261ac0f9b59dfe6062f4a8e1eaf517b8116b64d3c0925dc1a5d1d +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-linux-gnu.tar.gz=2aa2b1c1df189d346f3937b4887c901b737df2663a667de17beb8f1098442bb9 +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-linux-gnu.tar.xz=e5e12be2c7126a7036c8adf573078a28b92611f5767cc9bd0a6f7c83081df103 +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-linux-musl.tar.gz=df116b5f1400daffd0074125e6c7cb98e5763ae9aefe341e3605b623042b7b11 +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-linux-musl.tar.xz=b37ef0ce8c49103a904559f17c83c6e5a182f0f165f158e7be00e9036ca8c6d5 +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-netbsd.tar.gz=e6ddc2363ad9073d101368110eeedb2bd91fa7a318f3823295edab3bc191747a +dist/2025-12-11/cargo-1.92.0-x86_64-unknown-netbsd.tar.xz=19065f32ac1edae4f000695d3814b5b1ae2649e218304d223e8af1634f465b37 +dist/2025-12-11/clippy-1.92.0-aarch64-apple-darwin.tar.gz=02cb1fb33fead2b4378c37db711fda2945b7487ccc462ee1abeeb3a4ffcff312 +dist/2025-12-11/clippy-1.92.0-aarch64-apple-darwin.tar.xz=08c65b6cf8faae3861706f8c97acf2aa6b784ed9455354c3b13495a7cfe5cb84 +dist/2025-12-11/clippy-1.92.0-aarch64-pc-windows-gnullvm.tar.gz=8a7fcc3e006b5fe1160011f692adec30a8c772585572541c52fc5647b9ec74d4 +dist/2025-12-11/clippy-1.92.0-aarch64-pc-windows-gnullvm.tar.xz=ea3e63c684273f629f918e8f50d510225c48a35ec28eaf026fa68c27f273bbd6 +dist/2025-12-11/clippy-1.92.0-aarch64-pc-windows-msvc.tar.gz=4fa5ed26256ad52a5f5f2039c3b2fa008ee890a6c366153806368c912d74b0db +dist/2025-12-11/clippy-1.92.0-aarch64-pc-windows-msvc.tar.xz=2aa2f1288072ea1f870d6d860d09f5911c1305d506f344b65cf5e27b5070e262 +dist/2025-12-11/clippy-1.92.0-aarch64-unknown-linux-gnu.tar.gz=37c0bc5ea8a2421d2353bbb871620617ac5de0c3aaa7548a0952d0d64d551222 +dist/2025-12-11/clippy-1.92.0-aarch64-unknown-linux-gnu.tar.xz=333ab38c673b589468b8293b525e5704fb52515d9d516ee28d3d34dd5a63d3c3 +dist/2025-12-11/clippy-1.92.0-aarch64-unknown-linux-musl.tar.gz=8e7a88b0bee51760b9c416dce4a0b355a74cf8681de115ef55bee14a6bf9ba46 +dist/2025-12-11/clippy-1.92.0-aarch64-unknown-linux-musl.tar.xz=8aecf9e71c9a8b349587e5c0c69dc91e373264ffc55d946a00ab8f9aff072e64 +dist/2025-12-11/clippy-1.92.0-arm-unknown-linux-gnueabi.tar.gz=39ce64be0c9878f2fd20f9bdda70f6cdf7bfc5928986c65719d93580cd784a11 +dist/2025-12-11/clippy-1.92.0-arm-unknown-linux-gnueabi.tar.xz=957d0c8bb77f6589d579d6133e98aaf351dfbbcec3ef1603659a90d9d7c2ce41 +dist/2025-12-11/clippy-1.92.0-arm-unknown-linux-gnueabihf.tar.gz=27ac4e9184be7e3a245ce6dddf438a2728a6b4fd8959e665e9f02b63ef99f671 +dist/2025-12-11/clippy-1.92.0-arm-unknown-linux-gnueabihf.tar.xz=0c360081ff01d1319cf9667b1c46f9ee684276bfbabce268589342e304c32299 +dist/2025-12-11/clippy-1.92.0-armv7-unknown-linux-gnueabihf.tar.gz=b85d187bb8f896383e349ec91699501205644152fce229c2ffbc87723e44d4ff +dist/2025-12-11/clippy-1.92.0-armv7-unknown-linux-gnueabihf.tar.xz=c47e0bb86ac299c36492a125f0231bc715787fc65ab28de5a2dd576ac613cbd3 +dist/2025-12-11/clippy-1.92.0-i686-pc-windows-gnu.tar.gz=4f8cecf22d6ba620ed2739ef84463f546da12b1b4320ac97144f4a1adda12e23 +dist/2025-12-11/clippy-1.92.0-i686-pc-windows-gnu.tar.xz=37bf65d4d059534ff633996963e497cc470fbd8f3d52a87af45298c1d3785473 +dist/2025-12-11/clippy-1.92.0-i686-pc-windows-msvc.tar.gz=5291a3c1f8c1ba513575b1240613eabf1fc423570d1fec8ed2927b8d7110b70f +dist/2025-12-11/clippy-1.92.0-i686-pc-windows-msvc.tar.xz=974ed40fe323ea3a6c2de1226aed5634d168b29113ac25d87370d4934c956ea5 +dist/2025-12-11/clippy-1.92.0-i686-unknown-linux-gnu.tar.gz=987e71ce7fd0b633db9fc0ab37eb149cb6d67add4e767d0fe30870cd6a6d2e62 +dist/2025-12-11/clippy-1.92.0-i686-unknown-linux-gnu.tar.xz=f21090ddb01503ab7e326ff8b1ab44121611121e83572aa2dba2c5ceffe12d22 +dist/2025-12-11/clippy-1.92.0-loongarch64-unknown-linux-gnu.tar.gz=bfd0bd79f87e61f99645cdc439be58b7fd64a4a9ef0ef32aeab2ec59ec250d1a +dist/2025-12-11/clippy-1.92.0-loongarch64-unknown-linux-gnu.tar.xz=70783e0b31682938db53b78f87c948acfe589e3ece5dee6ae6aa5b667a384f3c +dist/2025-12-11/clippy-1.92.0-loongarch64-unknown-linux-musl.tar.gz=cf38e7b7abb35fff475847285c8e6d71651bc230fc69df91d8b5d9fa7c09c277 +dist/2025-12-11/clippy-1.92.0-loongarch64-unknown-linux-musl.tar.xz=790b5b921c6423a007951f3839a083c4c73a9b64fb6c5019e1e117f98975d9f9 +dist/2025-12-11/clippy-1.92.0-powerpc-unknown-linux-gnu.tar.gz=162f860ee371105f141aa2ac9024d6c597615f4511b7bc628f33d6346625f4f3 +dist/2025-12-11/clippy-1.92.0-powerpc-unknown-linux-gnu.tar.xz=93ed9fdd6fc2655c7789ed096d57a47178532b6bda1ec4480adca7920563e934 +dist/2025-12-11/clippy-1.92.0-powerpc64-unknown-linux-gnu.tar.gz=d430546bbad6c5710d68bb88e6c6f405bd79b191af2da1ca2760b7d1adfd1b93 +dist/2025-12-11/clippy-1.92.0-powerpc64-unknown-linux-gnu.tar.xz=7912584254f455b90ed6ce6089c4efded33bb753d1bf948286ef2f4f782d2f30 +dist/2025-12-11/clippy-1.92.0-powerpc64le-unknown-linux-gnu.tar.gz=46c0b94dbf705439bebd9cb47de7fb6925e462b62db8885375205e4b48db518f +dist/2025-12-11/clippy-1.92.0-powerpc64le-unknown-linux-gnu.tar.xz=873047278043e6506f5c98b8f633a9b96dc49ff83869a86a151fe5b1b9455044 +dist/2025-12-11/clippy-1.92.0-powerpc64le-unknown-linux-musl.tar.gz=d630a37d6b9ff16c17a0b363adf6ace44bfbf71cd61db1c11f9e4d5ac135774f +dist/2025-12-11/clippy-1.92.0-powerpc64le-unknown-linux-musl.tar.xz=b0b1ebe31d7b2ec101cb0464c64bdcd28e1ca4172f765fcc8478ebd8b2f90b39 +dist/2025-12-11/clippy-1.92.0-riscv64gc-unknown-linux-gnu.tar.gz=7a5d3773d578649f3b683463c3d7559b8788370d8c79b4fb6036e3d72ced8e6d +dist/2025-12-11/clippy-1.92.0-riscv64gc-unknown-linux-gnu.tar.xz=bdedabeedd48080e6ef70376c52338fbb45ff80d1fbb12a81aa2d8cabbb706c8 +dist/2025-12-11/clippy-1.92.0-s390x-unknown-linux-gnu.tar.gz=80bd8a76913069a8f467f5121a0d2fa969a9dc525813d033f2234c3304531a06 +dist/2025-12-11/clippy-1.92.0-s390x-unknown-linux-gnu.tar.xz=41aa44f1cf37cac87b83e450eb19148c539ff266bb40dc146207ad5b9e1e1acc +dist/2025-12-11/clippy-1.92.0-sparcv9-sun-solaris.tar.gz=b73f28698ae974ebdb03f89cac3933fd34bd048ec2b4392d13fd082302b44720 +dist/2025-12-11/clippy-1.92.0-sparcv9-sun-solaris.tar.xz=c8e6cfbfe8442f9e34c0e6d2d2a6ae8f7fec5278b800c8adc4446c7ca89fc6d7 +dist/2025-12-11/clippy-1.92.0-x86_64-apple-darwin.tar.gz=4bdbc9b3a0dcbf04f1bf807dc74311fe4a4fbadc1887e57e01f3bae1d16bd801 +dist/2025-12-11/clippy-1.92.0-x86_64-apple-darwin.tar.xz=39cce87aab3d8b71350edcb3f943fba7bc59581ce1e65e158ee01e64cf0f1cf5 +dist/2025-12-11/clippy-1.92.0-x86_64-pc-solaris.tar.gz=8d9b266efa76ef5e4514705c61b7f92a0829a15bcc9e492895b551e7d9811ae1 +dist/2025-12-11/clippy-1.92.0-x86_64-pc-solaris.tar.xz=4cd9a59b61ba75146a20d24c016a14b971ffefbc9256fdd2145f31987520b8d7 +dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-gnu.tar.gz=c4a858e83cea2aab2eb101285b61df663eb08042226c4c13f4cdc18b3e94698e +dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-gnu.tar.xz=e9084ced75940856b57e61e3dda7ccce08d57890dff9c2caa8c814c356fa34d2 +dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-gnullvm.tar.gz=4495c4d97736105fe93fbe9bce954ba21508ebb8d31b473ebc0f6cf57ac981c3 +dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-gnullvm.tar.xz=b22f615210f328aabafa8d0eab3fed62784fa771956c51a92ae24a4dfd2073ed +dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-msvc.tar.gz=c4f5bf37194bf71a872ab0c7248338d7d6ddf28d0cf35cfde9bad94745bd9f9e +dist/2025-12-11/clippy-1.92.0-x86_64-pc-windows-msvc.tar.xz=51a9a67931a3e50eb0c26b4c6a7ec2ef6ddd633319343a2d4767710c1e33b21f +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-freebsd.tar.gz=617ef6d0be4bc2accc80909037e80d450fb1c0cbf797f0d6152fb50a26356437 +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-freebsd.tar.xz=73d799e51800ebe4af40395c63c46ec60fc51b7b5f56467b550d5a29f213075a +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-illumos.tar.gz=031f313032ef7c704f6212a5a84a798a828e9775a61e40ed7b246dcce43c12a7 +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-illumos.tar.xz=8b7383dfc99c026917b037c0fbad8f42da494a898d71fb7ff6c98ebfea4e9448 +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-linux-gnu.tar.gz=cd63fc19e6047742b735e959ed615f2013df5a0653913ec37a7e17fe9b0f99d7 +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-linux-gnu.tar.xz=2c1bf6e7da8ec50feba03fe188fc9a744ba59e2c6ece7970c13e201d08defa9a +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-linux-musl.tar.gz=81596511aa023876b881869224188d98d803bf393b6d5a5abe32b486f7fc1dc7 +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-linux-musl.tar.xz=8051ed46eb7c3650361dc26dc348dcdcbffb765ef099f9f44bbf8141e223050a +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-netbsd.tar.gz=55678429c5dd5370cb455bb6600dbb2c9383662789bf75577282a7c8b1a2ff10 +dist/2025-12-11/clippy-1.92.0-x86_64-unknown-netbsd.tar.xz=66ab46b59f74700d99b5554a191877011aa465e805b52118b65f4964c4ce3563 +dist/2025-12-11/rust-1.92.0-aarch64-pc-windows-msvc.msi=dbb09f213d5a9ebb3b2f4c7d65ba7c3c6cad7d9a76927d079604020c3ea0ad5a +dist/2025-12-11/rust-1.92.0-i686-pc-windows-gnu.msi=95a4922605093c67f6527c44c0e982026727b38a1e25979fcd8b2b0ff9cc7968 +dist/2025-12-11/rust-1.92.0-i686-pc-windows-msvc.msi=b73f851252fe3ae340b9be8e1f9cc05e34210498c0c3321a46243be633454909 +dist/2025-12-11/rust-1.92.0-x86_64-pc-windows-gnu.msi=899c79a6a68c59470d5f721ae90718f83cabd613e0a7fb595fe87ab6429a0fc6 +dist/2025-12-11/rust-1.92.0-x86_64-pc-windows-msvc.msi=bd3fd270e92d12094151aae3a67435b7fef2164b10d96e99a94230929cda09fd +dist/2025-12-11/rust-1.92.0-aarch64-apple-darwin.pkg=ce8eca0010032eb9ccb1baa8d3527d3ed7099c06db5a048205d0940c3866b0c9 +dist/2025-12-11/rust-1.92.0-x86_64-apple-darwin.pkg=d8b439cbabd4db21a3958d6cf9126bd216257f29c1457bba524363d06f4b1eec +dist/2025-12-11/rustc-1.92.0-src.tar.gz=9e0d2ca75c7e275fdc758255bf4b03afb3d65d1543602746907c933b6901c3b8 +dist/2025-12-11/rustc-1.92.0-src.tar.xz=ebee170bfe4c4dfc59521a101de651e5534f4dae889756a5c97ca9ea40d0c307 diff --git a/src/tools/cargo b/src/tools/cargo index 2c283a9a5c59..083ac5135f96 160000 --- a/src/tools/cargo +++ b/src/tools/cargo @@ -1 +1 @@ -Subproject commit 2c283a9a5c5968eeb9a8f12313f04feb1ff8dfac +Subproject commit 083ac5135f967fd9dc906ab057a2315861c7a80d diff --git a/src/tools/clippy/clippy_lints/src/unwrap.rs b/src/tools/clippy/clippy_lints/src/unwrap.rs index 8ed3df8731b3..a95f2b681add 100644 --- a/src/tools/clippy/clippy_lints/src/unwrap.rs +++ b/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::>(); 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() - && iter::zip(&place.projections, field_indices.iter().copied().rev()).all(|(proj, field_idx)| { + && field_projections.len() <= field_indices.len() + && 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 diff --git a/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs b/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs index c6476a7507a1..bab20b091d38 100644 --- a/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs +++ b/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs @@ -472,3 +472,22 @@ fn issue15321() { //~^ unnecessary_unwrap } } + +mod issue16188 { + struct Foo { + value: Option, + } + + 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()); + } + } + } +} diff --git a/src/tools/miri/src/shims/x86/avx2.rs b/src/tools/miri/src/shims/x86/avx2.rs index 8fe225c494d5..16d8235f8dbc 100644 --- a/src/tools/miri/src/shims/x86/avx2.rs +++ b/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) diff --git a/src/tools/miri/src/shims/x86/sse2.rs b/src/tools/miri/src/shims/x86/sse2.rs index 838981390307..3fbab9ba789e 100644 --- a/src/tools/miri/src/shims/x86/sse2.rs +++ b/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) diff --git a/src/tools/rust-analyzer/crates/proc-macro-api/src/process.rs b/src/tools/rust-analyzer/crates/proc-macro-api/src/process.rs index e31ab86bdd2d..d6a8d27bfc42 100644 --- a/src/tools/rust-analyzer/crates/proc-macro-api/src/process.rs +++ b/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 }), diff --git a/src/version b/src/version index 95784efddbc4..d8ac93bea02e 100644 --- a/src/version +++ b/src/version @@ -1 +1 @@ -1.93.0 +1.93.1 diff --git a/tests/codegen-llvm/hint/likely.rs b/tests/codegen-llvm/hint/likely.rs index 75f9e7aae367..c588b6b8a8e8 100644 --- a/tests/codegen-llvm/hint/likely.rs +++ b/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: diff --git a/tests/codegen-llvm/hint/unlikely.rs b/tests/codegen-llvm/hint/unlikely.rs index 248b1e2537e9..8a75be50cfc9 100644 --- a/tests/codegen-llvm/hint/unlikely.rs +++ b/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: diff --git a/tests/debuginfo/dummy_span.rs b/tests/debuginfo/dummy_span.rs index fec4f33e3d56..cbdd7c109f36 100644 --- a/tests/debuginfo/dummy_span.rs +++ b/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 =================================================================================== diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff index 6baa902b6f4b..519be6e1e93e 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-abort.diff +++ b/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 _25: u16; + let mut _24: u32; + 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); - _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG); - StorageDead(_23); - switchInt(move _22) -> [0: bb10, otherwise: bb11]; + StorageLive(_24); + _24 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32); + _23 = BitAnd(move _24, const core::fmt::flags::PRECISION_FLAG); + 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); - switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12]; + StorageDead(_23); + _6 = const Option::::None; + goto -> bb11; } bb10: { - StorageDead(_22); - _6 = const Option::::None; - goto -> bb9; + StorageDead(_23); + StorageLive(_25); + StorageLive(_26); + _26 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16); + _25 = move _26 as usize (IntToInt); + StorageDead(_26); + _6 = Option::::Some(move _25); + StorageDead(_25); + goto -> bb11; } bb11: { StorageDead(_22); - StorageLive(_24); - StorageLive(_25); - _25 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16); - _24 = move _25 as usize (IntToInt); - StorageDead(_25); - _6 = Option::::Some(move _24); - StorageDead(_24); - goto -> bb9; + _7 = discriminant(_6); + switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12]; } bb12: { diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff index 36540e038654..3d97e19218dd 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.32bit.panic-unwind.diff +++ b/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 _25: u16; + let mut _24: u32; + 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); - _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG); - StorageDead(_23); - switchInt(move _22) -> [0: bb10, otherwise: bb11]; + StorageLive(_24); + _24 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32); + _23 = BitAnd(move _24, const core::fmt::flags::PRECISION_FLAG); + 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); - switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12]; + StorageDead(_23); + _6 = const Option::::None; + goto -> bb11; } bb10: { - StorageDead(_22); - _6 = const Option::::None; - goto -> bb9; + StorageDead(_23); + StorageLive(_25); + StorageLive(_26); + _26 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16); + _25 = move _26 as usize (IntToInt); + StorageDead(_26); + _6 = Option::::Some(move _25); + StorageDead(_25); + goto -> bb11; } bb11: { StorageDead(_22); - StorageLive(_24); - StorageLive(_25); - _25 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16); - _24 = move _25 as usize (IntToInt); - StorageDead(_25); - _6 = Option::::Some(move _24); - StorageDead(_24); - goto -> bb9; + _7 = discriminant(_6); + switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12]; } bb12: { diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff index 41c350f3eaeb..c6477f0e055c 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-abort.diff +++ b/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 _25: u16; + let mut _24: u32; + 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); - _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG); - StorageDead(_23); - switchInt(move _22) -> [0: bb10, otherwise: bb11]; + StorageLive(_24); + _24 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32); + _23 = BitAnd(move _24, const core::fmt::flags::PRECISION_FLAG); + 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); - switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12]; + StorageDead(_23); + _6 = const Option::::None; + goto -> bb11; } bb10: { - StorageDead(_22); - _6 = const Option::::None; - goto -> bb9; + StorageDead(_23); + StorageLive(_25); + StorageLive(_26); + _26 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16); + _25 = move _26 as usize (IntToInt); + StorageDead(_26); + _6 = Option::::Some(move _25); + StorageDead(_25); + goto -> bb11; } bb11: { StorageDead(_22); - StorageLive(_24); - StorageLive(_25); - _25 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16); - _24 = move _25 as usize (IntToInt); - StorageDead(_25); - _6 = Option::::Some(move _24); - StorageDead(_24); - goto -> bb9; + _7 = discriminant(_6); + switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12]; } bb12: { diff --git a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff b/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff index b839bf81eaf4..d491e2a5e4c7 100644 --- a/tests/mir-opt/funky_arms.float_to_exponential_common.GVN.64bit.panic-unwind.diff +++ b/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 _25: u16; + let mut _24: u32; + 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); - _22 = BitAnd(move _23, const core::fmt::flags::PRECISION_FLAG); - StorageDead(_23); - switchInt(move _22) -> [0: bb10, otherwise: bb11]; + StorageLive(_24); + _24 = copy (((*_1).0: std::fmt::FormattingOptions).0: u32); + _23 = BitAnd(move _24, const core::fmt::flags::PRECISION_FLAG); + 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); - switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12]; + StorageDead(_23); + _6 = const Option::::None; + goto -> bb11; } bb10: { - StorageDead(_22); - _6 = const Option::::None; - goto -> bb9; + StorageDead(_23); + StorageLive(_25); + StorageLive(_26); + _26 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16); + _25 = move _26 as usize (IntToInt); + StorageDead(_26); + _6 = Option::::Some(move _25); + StorageDead(_25); + goto -> bb11; } bb11: { StorageDead(_22); - StorageLive(_24); - StorageLive(_25); - _25 = copy (((*_1).0: std::fmt::FormattingOptions).2: u16); - _24 = move _25 as usize (IntToInt); - StorageDead(_25); - _6 = Option::::Some(move _24); - StorageDead(_24); - goto -> bb9; + _7 = discriminant(_6); + switchInt(move _7) -> [1: bb4, 0: bb6, otherwise: bb12]; } bb12: { diff --git a/tests/mir-opt/issue_76432.rs b/tests/mir-opt/issue_76432.rs index 6d884063caaf..bc2552d82c2e 100644 --- a/tests/mir-opt/issue_76432.rs +++ b/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; diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir index b5c23822162c..cdb8ce66a77a 100644 --- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-abort.mir +++ b/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; + let mut _4: bool; + let mut _5: std::option::Option; scope 1 (inlined char::methods::::is_digit) { let _2: std::option::Option; scope 2 (inlined Option::::is_some) { @@ -13,13 +14,14 @@ fn num_to_digit(_1: char) -> u32 { } } scope 4 (inlined #[track_caller] Option::::unwrap) { - let mut _5: isize; - let mut _6: !; + let mut _6: isize; + let mut _7: !; scope 5 { } } bb0: { + StorageLive(_4); StorageLive(_2); _2 = char::methods::::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); - StorageLive(_4); - _4 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb3, unwind unreachable]; + _0 = const 0_u32; + goto -> bb7; } bb3: { StorageLive(_5); - _5 = discriminant(_4); - switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6]; + _5 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb4, unwind unreachable]; } 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); - StorageDead(_5); - StorageDead(_4); - goto -> bb8; + _7 = option::unwrap_failed() -> unwind unreachable; } bb6: { - unreachable; + _0 = move ((_5 as Some).0: u32); + StorageDead(_6); + StorageDead(_5); + goto -> bb7; } bb7: { - StorageDead(_3); - _0 = const 0_u32; - goto -> bb8; + StorageDead(_4); + return; } bb8: { - return; + unreachable; } } diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir index f22b8835735d..ad0e4dfa0f33 100644 --- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.32bit.panic-unwind.mir +++ b/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; + let mut _4: bool; + let mut _5: std::option::Option; scope 1 (inlined char::methods::::is_digit) { let _2: std::option::Option; scope 2 (inlined Option::::is_some) { @@ -13,13 +14,14 @@ fn num_to_digit(_1: char) -> u32 { } } scope 4 (inlined #[track_caller] Option::::unwrap) { - let mut _5: isize; - let mut _6: !; + let mut _6: isize; + let mut _7: !; scope 5 { } } bb0: { + StorageLive(_4); StorageLive(_2); _2 = char::methods::::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); - StorageLive(_4); - _4 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb3, unwind continue]; + _0 = const 0_u32; + goto -> bb7; } bb3: { StorageLive(_5); - _5 = discriminant(_4); - switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6]; + _5 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb4, unwind continue]; } 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); - StorageDead(_5); - StorageDead(_4); - goto -> bb8; + _7 = option::unwrap_failed() -> unwind continue; } bb6: { - unreachable; + _0 = move ((_5 as Some).0: u32); + StorageDead(_6); + StorageDead(_5); + goto -> bb7; } bb7: { - StorageDead(_3); - _0 = const 0_u32; - goto -> bb8; + StorageDead(_4); + return; } bb8: { - return; + unreachable; } } diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir index b5c23822162c..cdb8ce66a77a 100644 --- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-abort.mir +++ b/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; + let mut _4: bool; + let mut _5: std::option::Option; scope 1 (inlined char::methods::::is_digit) { let _2: std::option::Option; scope 2 (inlined Option::::is_some) { @@ -13,13 +14,14 @@ fn num_to_digit(_1: char) -> u32 { } } scope 4 (inlined #[track_caller] Option::::unwrap) { - let mut _5: isize; - let mut _6: !; + let mut _6: isize; + let mut _7: !; scope 5 { } } bb0: { + StorageLive(_4); StorageLive(_2); _2 = char::methods::::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); - StorageLive(_4); - _4 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb3, unwind unreachable]; + _0 = const 0_u32; + goto -> bb7; } bb3: { StorageLive(_5); - _5 = discriminant(_4); - switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6]; + _5 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb4, unwind unreachable]; } 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); - StorageDead(_5); - StorageDead(_4); - goto -> bb8; + _7 = option::unwrap_failed() -> unwind unreachable; } bb6: { - unreachable; + _0 = move ((_5 as Some).0: u32); + StorageDead(_6); + StorageDead(_5); + goto -> bb7; } bb7: { - StorageDead(_3); - _0 = const 0_u32; - goto -> bb8; + StorageDead(_4); + return; } bb8: { - return; + unreachable; } } diff --git a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir index f22b8835735d..ad0e4dfa0f33 100644 --- a/tests/mir-opt/issues/issue_59352.num_to_digit.PreCodegen.after.64bit.panic-unwind.mir +++ b/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; + let mut _4: bool; + let mut _5: std::option::Option; scope 1 (inlined char::methods::::is_digit) { let _2: std::option::Option; scope 2 (inlined Option::::is_some) { @@ -13,13 +14,14 @@ fn num_to_digit(_1: char) -> u32 { } } scope 4 (inlined #[track_caller] Option::::unwrap) { - let mut _5: isize; - let mut _6: !; + let mut _6: isize; + let mut _7: !; scope 5 { } } bb0: { + StorageLive(_4); StorageLive(_2); _2 = char::methods::::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); - StorageLive(_4); - _4 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb3, unwind continue]; + _0 = const 0_u32; + goto -> bb7; } bb3: { StorageLive(_5); - _5 = discriminant(_4); - switchInt(move _5) -> [0: bb4, 1: bb5, otherwise: bb6]; + _5 = char::methods::::to_digit(move _1, const 8_u32) -> [return: bb4, unwind continue]; } 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); - StorageDead(_5); - StorageDead(_4); - goto -> bb8; + _7 = option::unwrap_failed() -> unwind continue; } bb6: { - unreachable; + _0 = move ((_5 as Some).0: u32); + StorageDead(_6); + StorageDead(_5); + goto -> bb7; } bb7: { - StorageDead(_3); - _0 = const 0_u32; - goto -> bb8; + StorageDead(_4); + return; } bb8: { - return; + unreachable; } } diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir index 791d6b71a6f7..49f8465326b0 100644 --- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-abort.mir +++ b/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 ::deallocate) { - let mut _9: *mut u8; + let mut _10: *mut u8; scope 19 (inlined Layout::size) { } scope 20 (inlined NonNull::::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); - _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable]; + _10 = copy _3 as *mut u8 (PtrToPtr); + 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; } diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir index 791d6b71a6f7..49f8465326b0 100644 --- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.32bit.panic-unwind.mir +++ b/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 ::deallocate) { - let mut _9: *mut u8; + let mut _10: *mut u8; scope 19 (inlined Layout::size) { } scope 20 (inlined NonNull::::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); - _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable]; + _10 = copy _3 as *mut u8 (PtrToPtr); + 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; } diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir index 791d6b71a6f7..49f8465326b0 100644 --- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-abort.mir +++ b/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 ::deallocate) { - let mut _9: *mut u8; + let mut _10: *mut u8; scope 19 (inlined Layout::size) { } scope 20 (inlined NonNull::::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); - _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable]; + _10 = copy _3 as *mut u8 (PtrToPtr); + 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; } diff --git a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir b/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir index 791d6b71a6f7..49f8465326b0 100644 --- a/tests/mir-opt/pre-codegen/drop_boxed_slice.generic_in_place.PreCodegen.after.64bit.panic-unwind.mir +++ b/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 ::deallocate) { - let mut _9: *mut u8; + let mut _10: *mut u8; scope 19 (inlined Layout::size) { } scope 20 (inlined NonNull::::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); - _11 = alloc::alloc::__rust_dealloc(move _9, move _5, move _10) -> [return: bb3, unwind unreachable]; + _10 = copy _3 as *mut u8 (PtrToPtr); + 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; } diff --git a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir index 4260ec3eaedf..e537dd6a28ef 100644 --- a/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir +++ b/tests/mir-opt/pre-codegen/loops.vec_move.PreCodegen.after.mir @@ -3,316 +3,72 @@ fn vec_move(_1: Vec) -> () { debug v => _1; let mut _0: (); - let mut _21: std::vec::IntoIter; - let mut _22: std::vec::IntoIter; - let mut _23: &mut std::vec::IntoIter; - let mut _24: std::option::Option; - let mut _25: isize; - let _27: (); + let mut _2: std::vec::IntoIter; + let mut _3: std::vec::IntoIter; + let mut _4: &mut std::vec::IntoIter; + let mut _5: std::option::Option; + let mut _6: isize; + let _8: (); scope 1 { - debug iter => _22; - let _26: impl Sized; + debug iter => _3; + let _7: impl Sized; scope 2 { - debug x => _26; - } - } - scope 3 (inlined as IntoIterator>::into_iter) { - debug self => _1; - let _2: std::mem::ManuallyDrop>; - 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; - let mut _29: &std::mem::ManuallyDrop>; - let mut _30: &alloc::raw_vec::RawVec; - let mut _31: &std::mem::ManuallyDrop>; - let _32: &std::vec::Vec; - let mut _33: &std::mem::ManuallyDrop>; - let _34: &std::vec::Vec; - let mut _35: &std::mem::ManuallyDrop>; - let mut _36: &alloc::raw_vec::RawVec; - let mut _37: &std::mem::ManuallyDrop>; - scope 4 { - debug me => _2; - scope 5 { - debug alloc => const ManuallyDrop:: {{ value: std::alloc::Global }}; - let _6: std::ptr::NonNull; - 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 > as Deref>::deref) { - debug self => _37; - } - scope 40 (inlined alloc::raw_vec::RawVec::::capacity) { - debug self => _36; - let mut _38: &alloc::raw_vec::RawVecInner; - scope 41 (inlined std::mem::size_of::) { - } - scope 42 (inlined alloc::raw_vec::RawVecInner::capacity) { - debug self => _38; - debug elem_size => const ::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 > as Deref>::deref) { - debug self => _33; - } - scope 26 (inlined Vec::::len) { - debug self => _32; - let mut _13: bool; - scope 27 { - } - } - scope 28 (inlined std::ptr::mut_ptr::::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::::cast::) { - debug self => _7; - } - scope 30 (inlined std::ptr::mut_ptr::::wrapping_add) { - debug self => _14; - debug count => _12; - let mut _15: isize; - scope 31 (inlined std::ptr::mut_ptr::::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::::with_metadata_of::) { - debug self => _18; - debug meta => _5; - scope 33 (inlined std::ptr::metadata::) { - debug ptr => _5; - } - scope 34 (inlined std::ptr::from_raw_parts_mut::) { - } - } - } - scope 35 (inlined > as Deref>::deref) { - debug self => _35; - } - scope 36 (inlined Vec::::len) { - debug self => _34; - let mut _9: bool; - scope 37 { - } - } - scope 38 (inlined #[track_caller] std::ptr::mut_ptr::::add) { - debug self => _7; - debug count => _8; - } - } - scope 24 (inlined NonNull::::as_ptr) { - debug self => _6; - } - } - scope 17 (inlined > as Deref>::deref) { - debug self => _31; - } - scope 18 (inlined alloc::raw_vec::RawVec::::non_null) { - debug self => _30; - scope 19 (inlined alloc::raw_vec::RawVecInner::non_null::) { - let mut _4: std::ptr::NonNull; - scope 20 (inlined Unique::::cast::) { - scope 21 (inlined NonNull::::cast::) { - let mut _5: *const impl Sized; - scope 22 (inlined NonNull::::as_ptr) { - } - } - } - scope 23 (inlined Unique::::as_non_null_ptr) { - } - } - } - } - scope 11 (inlined > as Deref>::deref) { - debug self => _29; - } - scope 12 (inlined Vec::::allocator) { - debug self => _28; - scope 13 (inlined alloc::raw_vec::RawVec::::allocator) { - scope 14 (inlined alloc::raw_vec::RawVecInner::allocator) { - } - } - } - scope 15 (inlined #[track_caller] std::ptr::read::) { - debug src => _3; - } - scope 16 (inlined ManuallyDrop::::new) { - debug value => const std::alloc::Global; - } - } - scope 10 (inlined ManuallyDrop::>::new) { - debug value => _1; + debug x => _7; } } bb0: { - StorageLive(_21); - StorageLive(_6); - StorageLive(_7); - StorageLive(_11); - StorageLive(_19); - StorageLive(_5); - StorageLive(_4); - StorageLive(_17); StorageLive(_2); - _2 = ManuallyDrop::> { value: copy _1 }; - StorageLive(_3); - // DBG: _29 = &_2; - // DBG: _28 = &(_2.0: std::vec::Vec); - _3 = &raw const ((((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).2: std::alloc::Global); - StorageDead(_3); - // DBG: _31 = &_2; - // DBG: _30 = &((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec); - _4 = copy (((((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner).0: std::ptr::Unique).0: std::ptr::NonNull); - _5 = copy _4 as *const impl Sized (Transmute); - _6 = NonNull:: { pointer: copy _5 }; - _7 = copy _4 as *mut impl Sized (Transmute); - switchInt(const ::IS_ZST) -> [0: bb1, otherwise: bb2]; + _2 = as IntoIterator>::into_iter(move _1) -> [return: bb1, unwind continue]; } bb1: { - StorageLive(_10); - StorageLive(_8); - // DBG: _35 = &_2; - // DBG: _34 = &(_2.0: std::vec::Vec); - _8 = copy ((_2.0: std::vec::Vec).1: usize); - StorageLive(_9); - _9 = Le(copy _8, const ::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; + StorageLive(_3); + _3 = move _2; + goto -> bb2; } bb2: { - StorageLive(_12); - // DBG: _33 = &_2; - // DBG: _32 = &(_2.0: std::vec::Vec); - _12 = copy ((_2.0: std::vec::Vec).1: usize); - StorageLive(_13); - _13 = Le(copy _12, const ::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::(move _16, move _15) -> [return: bb3, unwind unreachable]; + StorageLive(_5); + _4 = &mut _3; + _5 = as Iterator>::next(move _4) -> [return: bb3, unwind: bb9]; } bb3: { - StorageDead(_16); - _18 = copy _17 as *mut u8 (PtrToPtr); - StorageDead(_15); - StorageDead(_14); - StorageDead(_18); - StorageDead(_12); - _11 = copy _17 as *const impl Sized (PtrToPtr); - goto -> bb4; + _6 = discriminant(_5); + switchInt(move _6) -> [0: bb4, 1: bb6, otherwise: bb8]; } bb4: { - // DBG: _37 = &_2; - // DBG: _36 = &((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec); - // DBG: _38 = &(((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec).0: alloc::raw_vec::RawVecInner); - switchInt(const ::SIZE) -> [0: bb5, otherwise: bb6]; + StorageDead(_5); + drop(_3) -> [return: bb5, unwind continue]; } bb5: { - _19 = const usize::MAX; - goto -> bb7; - } - - bb6: { - StorageLive(_20); - _20 = copy ((((_2.0: std::vec::Vec).0: alloc::raw_vec::RawVec).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:: { buf: copy _6, phantom: const ZeroSized: PhantomData, cap: move _19, alloc: const ManuallyDrop:: {{ value: std::alloc::Global }}, ptr: copy _6, end: copy _11 }; + StorageDead(_3); 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 = 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: { - _26 = move ((_24 as Some).0: impl Sized); - _27 = opaque::(move _26) -> [return: bb13, unwind: bb15]; + bb6: { + _7 = move ((_5 as Some).0: impl Sized); + _8 = opaque::(move _7) -> [return: bb7, unwind: bb9]; } - bb13: { - StorageDead(_24); - goto -> bb8; + bb7: { + StorageDead(_5); + goto -> bb2; } - bb14: { + bb8: { unreachable; } - bb15 (cleanup): { - drop(_22) -> [return: bb16, unwind terminate(cleanup)]; + bb9 (cleanup): { + drop(_3) -> [return: bb10, unwind terminate(cleanup)]; } - bb16 (cleanup): { + bb10 (cleanup): { resume; } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir index f72611b7cb8e..fffd39c0c4ab 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.enumerated_loop.PreCodegen.after.panic-abort.mir +++ b/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 _31: &impl Fn(usize, &T); - let mut _32: (usize, &T); - let _33: (); + let mut _29: std::option::Option<(usize, &T)>; + let mut _32: &impl Fn(usize, &T); + let mut _33: (usize, &T); + let _34: (); scope 1 { debug (((iter: Enumerate>).0: std::slice::Iter<'_, T>).0: std::ptr::NonNull) => _6; debug (((iter: Enumerate>).0: std::slice::Iter<'_, T>).1: *const T) => _9; debug (((iter: Enumerate>).0: std::slice::Iter<'_, T>).2: std::marker::PhantomData<&T>) => const ZeroSized: PhantomData<&T>; debug ((iter: Enumerate>).1: usize) => _10; - let _29: usize; - let _30: &T; + let _30: usize; + let _31: &T; scope 2 { - debug i => _29; - debug x => _30; + debug i => _30; + debug x => _31; } scope 18 (inlined > as Iterator>::next) { - let mut _23: std::option::Option<&T>; - let mut _26: (usize, bool); - let mut _27: (usize, &T); + let mut _24: std::option::Option<&T>; + let mut _27: (usize, bool); + 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 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; let _13: std::ptr::NonNull; let mut _16: bool; - let mut _20: usize; - let _22: &T; + let mut _20: bool; + 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::::as_ref::<'_>) { - let _21: *const T; + let _22: *const T; scope 44 (inlined NonNull::::as_ptr) { } scope 45 (inlined std::ptr::mut_ptr::::cast_const) { @@ -169,16 +170,16 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { } bb4: { - StorageLive(_28); - StorageLive(_25); + StorageLive(_29); 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 ::IS_ZST) -> [0: bb5, otherwise: bb8]; @@ -206,88 +207,92 @@ fn enumerated_loop(_1: &[T], _2: impl Fn(usize, &T)) -> () { StorageDead(_17); _6 = NonNull:: { 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); - StorageDead(_26); - StorageDead(_25); - StorageDead(_28); - StorageDead(_10); - drop(_2) -> [return: bb11, unwind unreachable]; + _25 = copy ((_24 as Some).0: &T); + StorageDead(_24); + _26 = copy _10; + _27 = AddWithOverflow(copy _10, const 1_usize); + assert(!move (_27.1: bool), "attempt to compute `{} + {}`, which would overflow", copy _10, const 1_usize) -> [success: 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 = >::call(move _32, move _33) -> [return: bb12, unwind unreachable]; } bb12: { - _20 = SubUnchecked(copy _19, const 1_usize); - _9 = copy _20 as *const T (Transmute); - goto -> bb13; + StorageDead(_33); + StorageDead(_32); + 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); - 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]; + goto -> bb14; } bb14: { - _10 = move (_26.0: usize); - StorageLive(_27); - _27 = (copy _25, copy _24); - _28 = Option::<(usize, &T)>::Some(move _27); + StorageDead(_23); + StorageDead(_13); + StorageDead(_21); + StorageDead(_19); + StorageDead(_12); + StorageDead(_11); + StorageDead(_24); StorageDead(_27); StorageDead(_26); - StorageDead(_25); - _29 = copy (((_28 as Some).0: (usize, &T)).0: usize); - _30 = copy (((_28 as Some).0: (usize, &T)).1: &T); - StorageLive(_31); - _31 = &_2; - StorageLive(_32); - _32 = (copy _29, copy _30); - _33 = >::call(move _31, move _32) -> [return: bb15, unwind unreachable]; + StorageDead(_29); + StorageDead(_10); + drop(_2) -> [return: bb15, unwind unreachable]; } bb15: { - StorageDead(_32); - StorageDead(_31); - StorageDead(_28); - goto -> bb4; + return; } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir index b210efb1f46c..208739042172 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-abort.mir +++ b/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 _24: &impl Fn(&T); - let mut _25: (&T,); - let _26: (); + let mut _23: std::option::Option<&T>; + let mut _25: &impl Fn(&T); + let mut _26: (&T,); + let _27: (); scope 1 { debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull) => _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 as Iterator>::next) { let mut _6: std::ptr::NonNull; let _10: std::ptr::NonNull; let _12: std::ptr::NonNull; let mut _15: bool; - let mut _19: usize; - let _21: &T; + let mut _19: bool; + 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::::as_ref::<'_>) { - let _20: *const T; + let _21: *const T; scope 32 (inlined NonNull::::as_ptr) { } scope 33 (inlined std::ptr::mut_ptr::::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 ::IS_ZST) -> [0: bb5, otherwise: bb8]; @@ -168,68 +169,72 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_16); _6 = NonNull:: { 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); - drop(_2) -> [return: bb11, unwind unreachable]; + _24 = copy ((_23 as Some).0: &T); + StorageLive(_25); + _25 = &_2; + StorageLive(_26); + _26 = (copy _24,); + _27 = >::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); - _9 = copy _19 as *const T (Transmute); + StorageDead(_19); 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(_22); StorageDead(_12); - StorageDead(_19); + StorageDead(_20); StorageDead(_18); StorageDead(_11); StorageDead(_10); - _23 = copy ((_22 as Some).0: &T); - StorageLive(_24); - _24 = &_2; - StorageLive(_25); - _25 = (copy _23,); - _26 = >::call(move _24, move _25) -> [return: bb14, unwind unreachable]; + StorageDead(_23); + drop(_2) -> [return: bb14, unwind unreachable]; } bb14: { - StorageDead(_25); - StorageDead(_24); - StorageDead(_22); - goto -> bb4; + return; } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir index ab6e2bf0b36b..3f8ed2c47c0e 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.forward_loop.PreCodegen.after.panic-unwind.mir +++ b/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 _24: &impl Fn(&T); - let mut _25: (&T,); - let _26: (); + let mut _23: std::option::Option<&T>; + let mut _25: &impl Fn(&T); + let mut _26: (&T,); + let _27: (); scope 1 { debug ((iter: std::slice::Iter<'_, T>).0: std::ptr::NonNull) => _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 as Iterator>::next) { let mut _6: std::ptr::NonNull; let _10: std::ptr::NonNull; let _12: std::ptr::NonNull; let mut _15: bool; - let mut _19: usize; - let _21: &T; + let mut _19: bool; + 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::::as_ref::<'_>) { - let _20: *const T; + let _21: *const T; scope 32 (inlined NonNull::::as_ptr) { } scope 33 (inlined std::ptr::mut_ptr::::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 ::IS_ZST) -> [0: bb5, otherwise: bb8]; @@ -168,76 +169,80 @@ fn forward_loop(_1: &[T], _2: impl Fn(&T)) -> () { StorageDead(_16); _6 = NonNull:: { 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); - drop(_2) -> [return: bb11, unwind continue]; + _24 = copy ((_23 as Some).0: &T); + StorageLive(_25); + _25 = &_2; + StorageLive(_26); + _26 = (copy _24,); + _27 = >::call(move _25, move _26) -> [return: bb11, unwind: bb12]; } bb11: { - return; - } - - 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 = >::call(move _24, move _25) -> [return: bb14, unwind: bb15]; - } - - bb14: { + StorageDead(_26); StorageDead(_25); - StorageDead(_24); - StorageDead(_22); + StorageDead(_23); goto -> bb4; } - bb15 (cleanup): { - drop(_2) -> [return: bb16, unwind terminate(cleanup)]; + bb12 (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; + } } diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir index cc0fce26149e..b14022b283dc 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-abort.mir +++ b/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; let mut _7: bool; let mut _10: std::ptr::NonNull; - let mut _12: usize; - let _14: &T; + let mut _12: bool; + 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::::as_ref::<'_>) { - let _13: *const T; + let _14: *const T; scope 17 (inlined NonNull::::as_ptr) { } scope 18 (inlined std::ptr::mut_ptr::::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); _3 = copy ((*_1).1: *const T); switchInt(const ::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) = 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>}; - goto -> bb8; + StorageDead(_12); + _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); - ((*_1).1: *const T) = copy _12 as *const T (Transmute); - goto -> bb7; + StorageLive(_14); + _14 = copy _2 as *const T (Transmute); + _15 = &(*_14); + StorageDead(_14); + _0 = Option::<&T>::Some(copy _15); + goto -> bb8; } bb7: { - StorageLive(_13); - _13 = copy _2 as *const T (Transmute); - _14 = &(*_13); - StorageDead(_13); - _0 = Option::<&T>::Some(copy _14); + _0 = const {transmute(0x0000000000000000): Option<&T>}; + StorageDead(_12); goto -> bb8; } bb8: { - StorageDead(_14); + StorageDead(_15); StorageDead(_4); - StorageDead(_12); + StorageDead(_13); StorageDead(_11); StorageDead(_3); StorageDead(_2); diff --git a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir b/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir index cc0fce26149e..b14022b283dc 100644 --- a/tests/mir-opt/pre-codegen/slice_iter.slice_iter_next.PreCodegen.after.panic-unwind.mir +++ b/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; let mut _7: bool; let mut _10: std::ptr::NonNull; - let mut _12: usize; - let _14: &T; + let mut _12: bool; + 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::::as_ref::<'_>) { - let _13: *const T; + let _14: *const T; scope 17 (inlined NonNull::::as_ptr) { } scope 18 (inlined std::ptr::mut_ptr::::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); _3 = copy ((*_1).1: *const T); switchInt(const ::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) = 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>}; - goto -> bb8; + StorageDead(_12); + _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); - ((*_1).1: *const T) = copy _12 as *const T (Transmute); - goto -> bb7; + StorageLive(_14); + _14 = copy _2 as *const T (Transmute); + _15 = &(*_14); + StorageDead(_14); + _0 = Option::<&T>::Some(copy _15); + goto -> bb8; } bb7: { - StorageLive(_13); - _13 = copy _2 as *const T (Transmute); - _14 = &(*_13); - StorageDead(_13); - _0 = Option::<&T>::Some(copy _14); + _0 = const {transmute(0x0000000000000000): Option<&T>}; + StorageDead(_12); goto -> bb8; } bb8: { - StorageDead(_14); + StorageDead(_15); StorageDead(_4); - StorageDead(_12); + StorageDead(_13); StorageDead(_11); StorageDead(_3); StorageDead(_2); diff --git a/tests/rustdoc-gui/globals.goml b/tests/rustdoc-gui/globals.goml deleted file mode 100644 index 89f57add8161..000000000000 --- a/tests/rustdoc-gui/globals.goml +++ /dev/null @@ -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} diff --git a/tests/rustdoc-gui/headers-color.goml b/tests/rustdoc-gui/headers-color.goml deleted file mode 100644 index 81346fc12d06..000000000000 --- a/tests/rustdoc-gui/headers-color.goml +++ /dev/null @@ -1,71 +0,0 @@ -// This test check for headings text and background colors for the different themes. - -include: "utils.goml" - -define-function: ( - "check-colors", - [theme, color, code_header_color, focus_background_color, headings_color], - block { - go-to: "file://" + |DOC_PATH| + "/test_docs/struct.Foo.html" - // This is needed so that the text color is computed. - show-text: true - call-function: ("switch-theme", {"theme": |theme|}) - assert-css: ( - ".impl", - {"color": |color|, "background-color": "rgba(0, 0, 0, 0)"}, - ALL, - ) - assert-css: ( - ".impl .code-header", - {"color": |code_header_color|, "background-color": "rgba(0, 0, 0, 0)"}, - ALL, - ) - go-to: "file://" + |DOC_PATH| + "/test_docs/struct.Foo.html#impl-Foo" - assert-css: ( - "#impl-Foo", - {"color": |color|, "background-color": |focus_background_color|}, - ) - go-to: "file://" + |DOC_PATH| + "/test_docs/struct.Foo.html#method.must_use" - assert-css: ( - "#method\.must_use", - {"color": |color|, "background-color": |focus_background_color|}, - ALL, - ) - go-to: "file://" + |DOC_PATH| + "/test_docs/index.html" - assert-css: (".section-header a", {"color": |color|}, ALL) - go-to: "file://" + |DOC_PATH| + "/test_docs/struct.HeavilyDocumentedStruct.html" - // We select headings (h2, h3, h...). - assert-css: (".docblock > :not(p) > a", {"color": |headings_color|}, ALL) - }, -) - -call-function: ( - "check-colors", - { - "theme": "ayu", - "color": "#c5c5c5", - "code_header_color": "#e6e1cf", - "focus_background_color": "rgba(255, 236, 164, 0.06)", - "headings_color": "#c5c5c5", - }, -) -call-function: ( - "check-colors", - { - "theme": "dark", - "color": "#ddd", - "code_header_color": "#ddd", - "focus_background_color": "#494a3d", - "headings_color": "#ddd", - }, -) -call-function: ( - "check-colors", - { - "theme": "light", - "color": "black", - "code_header_color": "black", - "focus_background_color": "#fdffd3", - "headings_color": "black", - }, -) diff --git a/tests/rustdoc-gui/notable-trait.goml b/tests/rustdoc-gui/notable-trait.goml deleted file mode 100644 index 6bd4661ac8f4..000000000000 --- a/tests/rustdoc-gui/notable-trait.goml +++ /dev/null @@ -1,257 +0,0 @@ -// This test checks the position of the `i` for the notable traits. -include: "utils.goml" -go-to: "file://" + |DOC_PATH| + "/test_docs/struct.NotableStructWithLongName.html" -show-text: true - -define-function: ( - "check-notable-tooltip-position", - [x, i_x], - block { - // Checking they have the same y position. - compare-elements-position-near: ( - "//*[@id='method.create_an_iterator_from_read']//a[normalize-space()='NotableStructWithLongName']", - "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']", - {"y": 1}, - ) - // Checking they don't have the same x position. - compare-elements-position-false: ( - "//*[@id='method.create_an_iterator_from_read']//a[normalize-space()='NotableStructWithLongName']", - "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']", - ["x"], - ) - // The `i` should be *after* the type. - assert-position: ( - "//*[@id='method.create_an_iterator_from_read']//a[normalize-space()='NotableStructWithLongName']", - {"x": |x|}, - ) - assert-position: ( - "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']", - {"x": |i_x|}, - ) - }, -) - -define-function: ( - "check-notable-tooltip-position-complete", - [x, i_x, popover_x], - block { - call-function: ("check-notable-tooltip-position", {"x": |x|, "i_x": |i_x|}) - assert-count: ("//*[@class='tooltip popover']", 0) - click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" - assert-count: ("//*[@class='tooltip popover']", 1) - compare-elements-position-near: ( - "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']", - "//*[@class='tooltip popover']", - {"y": 30} - ) - compare-elements-position-false: ( - "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']", - "//*[@class='tooltip popover']", - ["x"] - ) - assert-position: ( - "//*[@class='tooltip popover']", - {"x": |popover_x|} - ) - click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" - move-cursor-to: "//h1" - assert-count: ("//*[@class='tooltip popover']", 0) - }, -) - -// We start with a wide screen. -set-window-size: (1100, 600) -call-function: ("check-notable-tooltip-position-complete", { - "x": 682, - "i_x": 960, - "popover_x": 468, -}) - -// Now only the `i` should be on the next line. -set-window-size: (1055, 600) -compare-elements-position-false: ( - "//*[@id='method.create_an_iterator_from_read']//a[normalize-space()='NotableStructWithLongName']", - "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']", - ["y", "x"], -) - -// Now both the `i` and the struct name should be on the next line. -set-window-size: (980, 600) -call-function: ("check-notable-tooltip-position", { - "x": 250, - "i_x": 528, -}) - -// Now check the colors. -define-function: ( - "check-colors", - [theme, header_color, content_color, type_color, trait_color, link_color], - block { - go-to: "file://" + |DOC_PATH| + "/test_docs/struct.NotableStructWithLongName.html" - // This is needed to ensure that the text color is computed. - show-text: true - - call-function: ("switch-theme", {"theme": |theme|}) - - assert-css: ( - "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']", - {"color": |content_color|}, - ALL, - ) - - move-cursor-to: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" - wait-for-count: (".tooltip.popover", 1) - - assert-css: ( - "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']", - {"color": |link_color|}, - ALL, - ) - - assert-css: ( - ".tooltip.popover h3", - {"color": |header_color|}, - ALL, - ) - assert-css: ( - ".tooltip.popover pre", - {"color": |content_color|}, - ALL, - ) - assert-css: ( - ".tooltip.popover pre a.struct", - {"color": |type_color|}, - ALL, - ) - assert-css: ( - ".tooltip.popover pre a.trait", - {"color": |trait_color|}, - ALL, - ) - }, -) - -call-function: ( - "check-colors", - { - "theme": "ayu", - "link_color": "#39afd7", - "content_color": "#e6e1cf", - "header_color": "#fff", - "type_color": "#ffa0a5", - "trait_color": "#39afd7", - }, -) - -call-function: ( - "check-colors", - { - "theme": "dark", - "link_color": "#d2991d", - "content_color": "#ddd", - "header_color": "#ddd", - "type_color": "#2dbfb8", - "trait_color": "#b78cf2", - }, -) - -call-function: ( - "check-colors", - { - "theme": "light", - "link_color": "#3873ad", - "content_color": "black", - "header_color": "black", - "type_color": "#ad378a", - "trait_color": "#6e4fc9", - }, -) - -// Checking on mobile now. -set-window-size: (650, 600) -wait-for-size: ("body", {"width": 650}) -call-function: ("check-notable-tooltip-position-complete", { - "x": 26, - "i_x": 305, - "popover_x": 0, -}) - -reload: - -// Check that pressing escape works -click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" -move-cursor-to: "//*[@class='tooltip popover']" -assert-count: ("//*[@class='tooltip popover']", 1) -press-key: "Escape" -assert-count: ("//*[@class='tooltip popover']", 0) -assert: "#method\.create_an_iterator_from_read .tooltip:focus" - -// Check that clicking outside works. -click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" -assert-count: ("//*[@class='tooltip popover']", 1) -click: ".main-heading h1" -assert-count: ("//*[@class='tooltip popover']", 0) -assert-false: "#method\.create_an_iterator_from_read .tooltip:focus" - -// Check that pressing tab over and over works. -click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" -move-cursor-to: "//*[@class='tooltip popover']" -assert-count: ("//*[@class='tooltip popover']", 1) -press-key: "Tab" -press-key: "Tab" -press-key: "Tab" -press-key: "Tab" -press-key: "Tab" -press-key: "Tab" -press-key: "Tab" -assert-count: ("//*[@class='tooltip popover']", 0) -assert: "#method\.create_an_iterator_from_read .tooltip:focus" - -define-function: ( - "setup-popup", - [], - block { - store-window-property: {"scrollY": scroll} - click: "#method\.create_an_iterator_from_read .fn" - // We ensure that the scroll position changed. - assert-window-property-false: {"scrollY": |scroll|} - // Store the new position. - store-window-property: {"scrollY": scroll} - click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" - wait-for: "//*[@class='tooltip popover']" - click: ".main-heading h1" - } -) - -// Now we check that the focus isn't given back to the wrong item when opening -// another popover. -call-function: ("setup-popup", {}) -click: ".main-heading h1" -// We ensure we didn't come back to the previous focused item. -assert-window-property-false: {"scrollY": |scroll|} - -// Same but with Escape handling. -call-function: ("setup-popup", {}) -press-key: "Escape" -// We ensure we didn't come back to the previous focused item. -assert-window-property-false: {"scrollY": |scroll|} - -// Opening the mobile sidebar should close the popover. -set-window-size: (650, 600) -click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" -assert-count: ("//*[@class='tooltip popover']", 1) -click: ".sidebar-menu-toggle" -assert: "//*[@class='sidebar shown']" -assert-count: ("//*[@class='tooltip popover']", 0) -assert-false: "#method\.create_an_iterator_from_read .tooltip:focus" - -// Also check the focus handling for the settings button. -set-window-size: (1100, 600) -reload: -assert-count: ("//*[@class='tooltip popover']", 0) -click: "//*[@id='method.create_an_iterator_from_read']//*[@class='tooltip']" -assert-count: ("//*[@class='tooltip popover']", 1) -click: "rustdoc-toolbar .settings-menu a" -wait-for: "#settings" -assert-count: ("//*[@class='tooltip popover']", 0) -assert-false: "#method\.create_an_iterator_from_read .tooltip:focus" diff --git a/tests/rustdoc-gui/search-filter.goml b/tests/rustdoc-gui/search-filter.goml deleted file mode 100644 index d92d522c119d..000000000000 --- a/tests/rustdoc-gui/search-filter.goml +++ /dev/null @@ -1,88 +0,0 @@ -// Checks that the crate search filtering is handled correctly and changes the results. -include: "utils.goml" -go-to: "file://" + |DOC_PATH| + "/test_docs/index.html" -show-text: true -call-function: ("perform-search", {"query": "test"}) -assert-text: ("#results .externcrate", "test_docs") - -wait-for: "#crate-search" -// We now want to change the crate filter. -click: "#crate-search" -// We select "lib2" option then press enter to change the filter. -press-key: "ArrowDown" -press-key: "ArrowDown" -press-key: "ArrowDown" -press-key: "ArrowDown" -press-key: "ArrowDown" -press-key: "Enter" -// Waiting for the search results to appear... -wait-for: "#search-tabs" -wait-for-false: "#search-tabs .count.loading" -assert-document-property: ({"URL": "&filter-crate="}, CONTAINS) -// We check that there is no more "test_docs" appearing. -assert-false: "#results .externcrate" -// We also check that "lib2" is the filter crate. -assert-property: ("#crate-search", {"value": "lib2"}) - -// Now we check that leaving the search results and putting them back keeps the -// crate filtering. -press-key: "Escape" -wait-for-css: ("#main-content", {"display": "block"}) -click: "#search-button" -wait-for: ".search-input" -wait-for-css: ("#main-content", {"display": "none"}) -// We check that there is no more "test_docs" appearing. -assert-false: "#results .externcrate" -assert-property: ("#crate-search", {"value": "lib2"}) - -// Selecting back "All crates" -click: "#crate-search" -press-key: "ArrowUp" -press-key: "ArrowUp" -press-key: "ArrowUp" -press-key: "ArrowUp" -press-key: "ArrowUp" -press-key: "Enter" -// Waiting for the search results to appear... -wait-for: "#search-tabs" -wait-for-false: "#search-tabs .count.loading" -assert-property: ("#crate-search", {"value": "all crates"}) - -// Checking that the URL parameter is taken into account for crate filtering. -go-to: "file://" + |DOC_PATH| + "/test_docs/index.html?search=test&filter-crate=lib2" -wait-for: "#crate-search" -assert-property: ("#crate-search", {"value": "lib2"}) -assert-false: "#results .externcrate" - -// Checking that the text for the "title" is correct (the "all crates" comes from the "` is correctly handled when it goes to next line. -// To do so we need to update the length of one of its `