diff options
52 files changed, 962 insertions, 628 deletions
diff --git a/.mailmap b/.mailmap index 30c3212810c..564a68955d3 100644 --- a/.mailmap +++ b/.mailmap @@ -105,10 +105,13 @@ Chris Vittal <christopher.vittal@gmail.com> Christopher Vittal <christopher.vitt Christiaan Dirkx <christiaan@dirkx.email> <christiaan@dirkx.com> Christiaan Dirkx <christiaan@dirkx.email> CDirkx <christiaan@dirkx.com> Christiaan Dirkx <christiaan@dirkx.email> CDirkx <christiaan@dirkx.email> -Christian Poveda <git@christianpoveda.xyz> <christianpoveda@protonmail.com> -Christian Poveda <git@christianpoveda.xyz> <cn.poveda.ruiz@gmail.com> -Christian Poveda <git@christianpoveda.xyz> <z1mvader@protonmail.com> -Christian Poveda <git@christianpoveda.xyz> <cpovedar@fnal.gov> +Christian Poveda <git@pvdrz.com> <christianpoveda@protonmail.com> +Christian Poveda <git@pvdrz.com> <cn.poveda.ruiz@gmail.com> +Christian Poveda <git@pvdrz.com> <z1mvader@protonmail.com> +Christian Poveda <git@pvdrz.com> <cpovedar@fnal.gov> +Christian Poveda <git@pvdrz.com> <git@christianpoveda.xyz> +Christian Poveda <git@pvdrz.com> <31802960+christianpoveda@users.noreply.github.com> +Christian Poveda <git@pvdrz.com> <christianpoveda@uhura.edef.eu> Christian Vallentin <vallentinsource@gmail.com> Christoffer Buchholz <chris@chrisbuchholz.me> Christopher Durham <cad97@cad97.com> diff --git a/Cargo.lock b/Cargo.lock index afe1814de67..2f143b097b7 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -364,7 +364,7 @@ dependencies = [ "tar", "tempfile", "termcolor", - "toml_edit 0.14.3", + "toml_edit", "unicode-width", "unicode-xid", "url 2.2.2", @@ -451,7 +451,7 @@ dependencies = [ "snapbox", "tar", "termcolor", - "toml_edit 0.14.3", + "toml_edit", "url 2.2.2", ] @@ -2043,15 +2043,6 @@ dependencies = [ [[package]] name = "kstring" -version = "1.0.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "8b310ccceade8121d7d77fee406160e457c2f4e7c7982d589da3499bc7ea4526" -dependencies = [ - "serde", -] - -[[package]] -name = "kstring" version = "2.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ec3066350882a1cd6d950d055997f379ac37fd39f81cd4d8ed186032eb3c5747" @@ -3003,8 +2994,6 @@ dependencies = [ [[package]] name = "racer" version = "2.2.2" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "64954e44fc0d1dcc64e0b9f2b155249ad62849eba25354b76ae1598d1e8f0fa0" dependencies = [ "bitflags", "clap 2.34.0", @@ -3012,11 +3001,29 @@ dependencies = [ "env_logger 0.7.1", "humantime 2.0.1", "lazy_static", + "lazycell", "log", + "racer-cargo-metadata", "rls-span", ] [[package]] +name = "racer-cargo-metadata" +version = "0.1.2" +dependencies = [ + "racer-interner", + "serde", + "serde_json", +] + +[[package]] +name = "racer-interner" +version = "0.1.0" +dependencies = [ + "serde", +] + +[[package]] name = "rand" version = "0.7.3" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -3246,7 +3253,7 @@ dependencies = [ "tokio-stream", "tokio-util", "toml", - "toml_edit 0.13.4", + "toml_edit", "url 2.2.2", "walkdir", ] @@ -5322,19 +5329,6 @@ dependencies = [ [[package]] name = "toml_edit" -version = "0.13.4" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "744e9ed5b352340aa47ce033716991b5589e23781acb97cad37d4ea70560f55b" -dependencies = [ - "combine", - "indexmap", - "itertools", - "kstring 1.0.6", - "serde", -] - -[[package]] -name = "toml_edit" version = "0.14.3" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "ba98375fd631b83696f87c64e4ed8e29e6a1f3404d6aed95fa95163bad38e705" @@ -5342,7 +5336,7 @@ dependencies = [ "combine", "indexmap", "itertools", - "kstring 2.0.0", + "kstring", "serde", ] diff --git a/RELEASES.md b/RELEASES.md index 0965e37574d..0e118fb939f 100644 --- a/RELEASES.md +++ b/RELEASES.md @@ -1,3 +1,129 @@ +Version 1.61.0 (2022-05-19) +========================== + +Language +-------- + +- [`const fn` signatures can now include generic trait bounds][93827] +- [`const fn` signatures can now use `impl Trait` in argument and return position][93827] +- [Function pointers can now be created, cast, and passed around in a `const fn`][93827] +- [Recursive calls can now set the value of a function's opaque `impl Trait` return type][94081] + +Compiler +-------- + +- [Linking modifier syntax in `#[link]` attributes and on the command line, as well as the `whole-archive` modifier specifically, are now supported][93901] +- [The `char` type is now described as UTF-32 in debuginfo][89887] +- The [`#[target_feature]`][target_feature] attribute [can now be used with aarch64 features][90621] +- X86 [`#[target_feature = "adx"]` is now stable][93745] + +Libraries +--------- + +- [`ManuallyDrop<T>` is now documented to have the same layout as `T`][88375] +- [`#[ignore = "…"]` messages are printed when running tests][92714] +- [Consistently show absent stdio handles on Windows as NULL handles][93263] +- [Make `std::io::stdio::lock()` return `'static` handles.][93965] Previously, the creation of locked handles to stdin/stdout/stderr would borrow the handles being locked, which prevented writing `let out = std::io::stdout().lock();` because `out` would outlive the return value of `stdout()`. Such code now works, eliminating a common pitfall that affected many Rust users. +- [`Vec::from_raw_parts` is now less restrictive about its inputs][95016] +- [`std::thread::available_parallelism` now takes cgroup quotas into account.][92697] Since `available_parallelism` is often used to create a thread pool for parallel computation, which may be CPU-bound for performance, `available_parallelism` will return a value consistent with the ability to use that many threads continuously, if possible. For instance, in a container with 8 virtual CPUs but quotas only allowing for 50% usage, `available_parallelism` will return 4. + +Stabilized APIs +--------------- + +- [`Pin::static_mut`] +- [`Pin::static_ref`] +- [`Vec::retain_mut`] +- [`VecDeque::retain_mut`] +- [`Write` for `Cursor<[u8; N]>`][cursor-write-array] +- [`std::os::unix::net::SocketAddr::from_pathname`] +- [`std::process::ExitCode`] and [`std::process::Termination`]. The stabilization of these two APIs now makes it possible for programs to return errors from `main` with custom exit codes. +- [`std::thread::JoinHandle::is_finished`] + +These APIs are now usable in const contexts: + +- [`<*const T>::offset` and `<*mut T>::offset`][ptr-offset] +- [`<*const T>::wrapping_offset` and `<*mut T>::wrapping_offset`][ptr-wrapping_offset] +- [`<*const T>::add` and `<*mut T>::add`][ptr-add] +- [`<*const T>::sub` and `<*mut T>::sub`][ptr-sub] +- [`<*const T>::wrapping_add` and `<*mut T>::wrapping_add`][ptr-wrapping_add] +- [`<*const T>::wrapping_sub` and `<*mut T>::wrapping_sub`][ptr-wrapping_sub] +- [`<[T]>::as_mut_ptr`][slice-as_mut_ptr] +- [`<[T]>::as_ptr_range`][slice-as_ptr_range] +- [`<[T]>::as_mut_ptr_range`][slice-as_mut_ptr_range] + +Cargo +----- + +No feature changes, but see compatibility notes. + +Compatibility Notes +------------------- + +- Previously native static libraries were linked as `whole-archive` in some cases, but now rustc tries not to use `whole-archive` unless explicitly requested. This [change][93901] may result in linking errors in some cases. To fix such errors, native libraries linked from the command line, build scripts, or [`#[link]` attributes][link-attr] need to + - (more common) either be reordered to respect dependencies between them (if `a` depends on `b` then `a` should go first and `b` second) + - (less common) or be updated to use the [`+whole-archive`] modifier. +- [Catching a second unwind from FFI code while cleaning up from a Rust panic now causes the process to abort][92911] +- [Proc macros no longer see `ident` matchers wrapped in groups][92472] +- [The number of `#` in `r#` raw string literals is now required to be less than 256][95251] +- [When checking that a dyn type satisfies a trait bound, supertrait bounds are now enforced][92285] +- [`cargo vendor` now only accepts one value for each `--sync` flag][cargo/10448] +- [`cfg` predicates in `all()` and `any()` are always evaluated to detect errors, instead of short-circuiting.][94295] The compatibility considerations here arise in nightly-only code that used the short-circuiting behavior of `all` to write something like `cfg(all(feature = "nightly", syntax-requiring-nightly))`, which will now fail to compile. Instead, use either `cfg_attr(feature = "nightly", ...)` or nested uses of `cfg`. +- [bootstrap: static-libstdcpp is now enabled by default, and can now be disabled when llvm-tools is enabled][94832] + +Internal Changes +---------------- + +These changes provide no direct user facing benefits, but represent significant +improvements to the internals and overall performance of rustc +and related tools. + +- [debuginfo: Refactor debuginfo generation for types][94261] +- [Remove the everybody loops pass][93913] + +[88375]: https://github.com/rust-lang/rust/pull/88375/ +[89887]: https://github.com/rust-lang/rust/pull/89887/ +[90621]: https://github.com/rust-lang/rust/pull/90621/ +[92285]: https://github.com/rust-lang/rust/pull/92285/ +[92472]: https://github.com/rust-lang/rust/pull/92472/ +[92697]: https://github.com/rust-lang/rust/pull/92697/ +[92714]: https://github.com/rust-lang/rust/pull/92714/ +[92911]: https://github.com/rust-lang/rust/pull/92911/ +[93263]: https://github.com/rust-lang/rust/pull/93263/ +[93745]: https://github.com/rust-lang/rust/pull/93745/ +[93827]: https://github.com/rust-lang/rust/pull/93827/ +[93901]: https://github.com/rust-lang/rust/pull/93901/ +[93913]: https://github.com/rust-lang/rust/pull/93913/ +[93965]: https://github.com/rust-lang/rust/pull/93965/ +[94081]: https://github.com/rust-lang/rust/pull/94081/ +[94261]: https://github.com/rust-lang/rust/pull/94261/ +[94295]: https://github.com/rust-lang/rust/pull/94295/ +[94832]: https://github.com/rust-lang/rust/pull/94832/ +[95016]: https://github.com/rust-lang/rust/pull/95016/ +[95251]: https://github.com/rust-lang/rust/pull/95251/ +[`+whole-archive`]: https://doc.rust-lang.org/stable/rustc/command-line-arguments.html#linking-modifiers-whole-archive +[`Pin::static_mut`]: https://doc.rust-lang.org/stable/std/pin/struct.Pin.html#method.static_mut +[`Pin::static_ref`]: https://doc.rust-lang.org/stable/std/pin/struct.Pin.html#method.static_ref +[`Vec::retain_mut`]: https://doc.rust-lang.org/stable/std/vec/struct.Vec.html#method.retain_mut +[`VecDeque::retain_mut`]: https://doc.rust-lang.org/stable/std/collections/struct.VecDeque.html#method.retain_mut +[`std::os::unix::net::SocketAddr::from_pathname`]: https://doc.rust-lang.org/stable/std/os/unix/net/struct.SocketAddr.html#method.from_pathname +[`std::process::ExitCode`]: https://doc.rust-lang.org/stable/std/process/struct.ExitCode.html +[`std::process::Termination`]: https://doc.rust-lang.org/stable/std/process/trait.Termination.html +[`std::thread::JoinHandle::is_finished`]: https://doc.rust-lang.org/stable/std/thread/struct.JoinHandle.html#method.is_finished +[cargo/10448]: https://github.com/rust-lang/cargo/pull/10448/ +[cursor-write-array]: https://doc.rust-lang.org/stable/std/io/struct.Cursor.html#impl-Write-4 +[link-attr]: https://doc.rust-lang.org/stable/reference/items/external-blocks.html#the-link-attribute +[ptr-add]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.add +[ptr-offset]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.offset +[ptr-sub]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.sub +[ptr-wrapping_add]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.wrapping_add +[ptr-wrapping_offset]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.wrapping_offset +[ptr-wrapping_sub]: https://doc.rust-lang.org/stable/std/primitive.pointer.html#method.wrapping_sub +[slice-as_mut_ptr]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.as_mut_ptr +[slice-as_mut_ptr_range]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.as_mut_ptr_range +[slice-as_ptr_range]: https://doc.rust-lang.org/stable/std/primitive.slice.html#method.as_ptr_range +[target_feature]: https://doc.rust-lang.org/reference/attributes/codegen.html#the-target_feature-attribute + + Version 1.60.0 (2022-04-07) ========================== diff --git a/compiler/rustc_const_eval/src/interpret/cast.rs b/compiler/rustc_const_eval/src/interpret/cast.rs index 92eeafc5df0..7cd2ba34b04 100644 --- a/compiler/rustc_const_eval/src/interpret/cast.rs +++ b/compiler/rustc_const_eval/src/interpret/cast.rs @@ -225,9 +225,6 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { let addr = u64::try_from(size.truncate(v)).unwrap(); let ptr = M::ptr_from_addr_cast(&self, addr); - if addr == 0 { - assert!(ptr.provenance.is_none(), "null pointer can never have an AllocId"); - } Scalar::from_maybe_pointer(ptr, self) } diff --git a/compiler/rustc_const_eval/src/interpret/machine.rs b/compiler/rustc_const_eval/src/interpret/machine.rs index a79751ccb55..1dcd50a5b70 100644 --- a/compiler/rustc_const_eval/src/interpret/machine.rs +++ b/compiler/rustc_const_eval/src/interpret/machine.rs @@ -133,9 +133,11 @@ pub trait Machine<'mir, 'tcx>: Sized { /// Whether to enforce the validity invariant fn enforce_validity(ecx: &InterpCx<'mir, 'tcx, Self>) -> bool; - /// Whether to enforce validity (e.g., initialization and not having ptr provenance) - /// of integers and floats. - fn enforce_number_validity(ecx: &InterpCx<'mir, 'tcx, Self>) -> bool; + /// Whether to enforce integers and floats being initialized. + fn enforce_number_init(ecx: &InterpCx<'mir, 'tcx, Self>) -> bool; + + /// Whether to enforce integers and floats not having provenance. + fn enforce_number_no_provenance(ecx: &InterpCx<'mir, 'tcx, Self>) -> bool; /// Whether function calls should be [ABI](Abi)-checked. fn enforce_abi(_ecx: &InterpCx<'mir, 'tcx, Self>) -> bool { @@ -453,7 +455,12 @@ pub macro compile_time_machine(<$mir: lifetime, $tcx: lifetime>) { } #[inline(always)] - fn enforce_number_validity(_ecx: &InterpCx<$mir, $tcx, Self>) -> bool { + fn enforce_number_init(_ecx: &InterpCx<$mir, $tcx, Self>) -> bool { + true + } + + #[inline(always)] + fn enforce_number_no_provenance(_ecx: &InterpCx<$mir, $tcx, Self>) -> bool { true } diff --git a/compiler/rustc_const_eval/src/interpret/memory.rs b/compiler/rustc_const_eval/src/interpret/memory.rs index 33162a01ed2..721abff689a 100644 --- a/compiler/rustc_const_eval/src/interpret/memory.rs +++ b/compiler/rustc_const_eval/src/interpret/memory.rs @@ -924,10 +924,15 @@ impl<'tcx, 'a, Tag: Provenance, Extra> AllocRef<'a, 'tcx, Tag, Extra> { self.read_scalar(alloc_range(offset, self.tcx.data_layout().pointer_size)) } - pub fn check_bytes(&self, range: AllocRange, allow_uninit_and_ptr: bool) -> InterpResult<'tcx> { + pub fn check_bytes( + &self, + range: AllocRange, + allow_uninit: bool, + allow_ptr: bool, + ) -> InterpResult<'tcx> { Ok(self .alloc - .check_bytes(&self.tcx, self.range.subrange(range), allow_uninit_and_ptr) + .check_bytes(&self.tcx, self.range.subrange(range), allow_uninit, allow_ptr) .map_err(|e| e.to_interp_error(self.alloc_id))?) } } @@ -1144,11 +1149,7 @@ impl<'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> InterpCx<'mir, 'tcx, M> { Err(ptr) => ptr.into(), Ok(bits) => { let addr = u64::try_from(bits).unwrap(); - let ptr = M::ptr_from_addr_transmute(&self, addr); - if addr == 0 { - assert!(ptr.provenance.is_none(), "null pointer can never have an AllocId"); - } - ptr + M::ptr_from_addr_transmute(&self, addr) } }, ) diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs index 8770ed956e6..b39a33aff09 100644 --- a/compiler/rustc_const_eval/src/interpret/validity.rs +++ b/compiler/rustc_const_eval/src/interpret/validity.rs @@ -536,15 +536,21 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, ' let value = self.read_scalar(value)?; // NOTE: Keep this in sync with the array optimization for int/float // types below! - if M::enforce_number_validity(self.ecx) { - // Integers/floats with number validity: Must be scalar bits, pointers are dangerous. + if M::enforce_number_init(self.ecx) { + try_validation!( + value.check_init(), + self.path, + err_ub!(InvalidUninitBytes(..)) => + { "{:x}", value } expected { "initialized bytes" } + ); + } + if M::enforce_number_no_provenance(self.ecx) { // As a special exception we *do* match on a `Scalar` here, since we truly want // to know its underlying representation (and *not* cast it to an integer). - let is_bits = - value.check_init().map_or(false, |v| matches!(v, Scalar::Int(..))); - if !is_bits { + let is_ptr = value.check_init().map_or(false, |v| matches!(v, Scalar::Ptr(..))); + if is_ptr { throw_validation_failure!(self.path, - { "{:x}", value } expected { "initialized plain (non-pointer) bytes" } + { "{:x}", value } expected { "plain (non-pointer) bytes" } ) } } @@ -651,7 +657,7 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValidityVisitor<'rt, 'mir, ' let size = scalar_layout.size(self.ecx); let is_full_range = match scalar_layout { ScalarAbi::Initialized { .. } => { - if M::enforce_number_validity(self.ecx) { + if M::enforce_number_init(self.ecx) { false // not "full" since uninit is not accepted } else { scalar_layout.is_always_valid(self.ecx) @@ -910,10 +916,10 @@ impl<'rt, 'mir, 'tcx: 'mir, M: Machine<'mir, 'tcx>> ValueVisitor<'mir, 'tcx, M> return Ok(()); }; - let allow_uninit_and_ptr = !M::enforce_number_validity(self.ecx); match alloc.check_bytes( alloc_range(Size::ZERO, size), - allow_uninit_and_ptr, + /*allow_uninit*/ !M::enforce_number_init(self.ecx), + /*allow_ptr*/ !M::enforce_number_no_provenance(self.ecx), ) { // In the happy case, we needn't check anything else. Ok(()) => {} diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs index 81d544c7b96..57655365cca 100644 --- a/compiler/rustc_hir/src/hir.rs +++ b/compiler/rustc_hir/src/hir.rs @@ -1323,6 +1323,20 @@ pub enum Guard<'hir> { IfLet(&'hir Let<'hir>), } +impl<'hir> Guard<'hir> { + /// Returns the body of the guard + /// + /// In other words, returns the e in either of the following: + /// + /// - `if e` + /// - `if let x = e` + pub fn body(&self) -> &'hir Expr<'hir> { + match self { + Guard::If(e) | Guard::IfLet(Let { init: e, .. }) => e, + } + } +} + #[derive(Debug, HashStable_Generic)] pub struct ExprField<'hir> { #[stable_hasher(ignore)] diff --git a/compiler/rustc_middle/src/mir/interpret/allocation.rs b/compiler/rustc_middle/src/mir/interpret/allocation.rs index 5564852f305..760fe1edbdb 100644 --- a/compiler/rustc_middle/src/mir/interpret/allocation.rs +++ b/compiler/rustc_middle/src/mir/interpret/allocation.rs @@ -350,19 +350,22 @@ impl<Tag: Provenance, Extra> Allocation<Tag, Extra> { /// Reading and writing. impl<Tag: Provenance, Extra> Allocation<Tag, Extra> { /// Validates that `ptr.offset` and `ptr.offset + size` do not point to the middle of a - /// relocation. If `allow_uninit_and_ptr` is `false`, also enforces that the memory in the - /// given range contains neither relocations nor uninitialized bytes. + /// relocation. If `allow_uninit`/`allow_ptr` is `false`, also enforces that the memory in the + /// given range contains no uninitialized bytes/relocations. pub fn check_bytes( &self, cx: &impl HasDataLayout, range: AllocRange, - allow_uninit_and_ptr: bool, + allow_uninit: bool, + allow_ptr: bool, ) -> AllocResult { // Check bounds and relocations on the edges. self.get_bytes_with_uninit_and_ptr(cx, range)?; // Check uninit and ptr. - if !allow_uninit_and_ptr { + if !allow_uninit { self.check_init(range)?; + } + if !allow_ptr { self.check_relocations(cx, range)?; } Ok(()) diff --git a/compiler/rustc_mir_transform/src/inline.rs b/compiler/rustc_mir_transform/src/inline.rs index a73fd13ce2d..85b7fb5eb25 100644 --- a/compiler/rustc_mir_transform/src/inline.rs +++ b/compiler/rustc_mir_transform/src/inline.rs @@ -554,7 +554,8 @@ impl<'tcx> Inliner<'tcx> { new_scopes: SourceScope::new(caller_body.source_scopes.len()).., new_blocks: BasicBlock::new(caller_body.basic_blocks().len()).., destination: dest, - return_block: callsite.target, + callsite_scope: caller_body.source_scopes[callsite.source_info.scope].clone(), + callsite, cleanup_block: cleanup, in_cleanup_block: false, tcx: self.tcx, @@ -566,31 +567,6 @@ impl<'tcx> Inliner<'tcx> { // (or existing ones, in a few special cases) in the caller. integrator.visit_body(&mut callee_body); - for scope in &mut callee_body.source_scopes { - // FIXME(eddyb) move this into a `fn visit_scope_data` in `Integrator`. - if scope.parent_scope.is_none() { - let callsite_scope = &caller_body.source_scopes[callsite.source_info.scope]; - - // Attach the outermost callee scope as a child of the callsite - // scope, via the `parent_scope` and `inlined_parent_scope` chains. - scope.parent_scope = Some(callsite.source_info.scope); - assert_eq!(scope.inlined_parent_scope, None); - scope.inlined_parent_scope = if callsite_scope.inlined.is_some() { - Some(callsite.source_info.scope) - } else { - callsite_scope.inlined_parent_scope - }; - - // Mark the outermost callee scope as an inlined one. - assert_eq!(scope.inlined, None); - scope.inlined = Some((callsite.callee, callsite.source_info.span)); - } else if scope.inlined_parent_scope.is_none() { - // Make it easy to find the scope with `inlined` set above. - scope.inlined_parent_scope = - Some(integrator.map_scope(OUTERMOST_SOURCE_SCOPE)); - } - } - // If there are any locals without storage markers, give them storage only for the // duration of the call. for local in callee_body.vars_and_temps_iter() { @@ -786,7 +762,8 @@ struct Integrator<'a, 'tcx> { new_scopes: RangeFrom<SourceScope>, new_blocks: RangeFrom<BasicBlock>, destination: Place<'tcx>, - return_block: Option<BasicBlock>, + callsite_scope: SourceScopeData<'tcx>, + callsite: &'a CallSite<'tcx>, cleanup_block: Option<BasicBlock>, in_cleanup_block: bool, tcx: TyCtxt<'tcx>, @@ -832,6 +809,28 @@ impl<'tcx> MutVisitor<'tcx> for Integrator<'_, 'tcx> { *local = self.map_local(*local); } + fn visit_source_scope_data(&mut self, scope_data: &mut SourceScopeData<'tcx>) { + self.super_source_scope_data(scope_data); + if scope_data.parent_scope.is_none() { + // Attach the outermost callee scope as a child of the callsite + // scope, via the `parent_scope` and `inlined_parent_scope` chains. + scope_data.parent_scope = Some(self.callsite.source_info.scope); + assert_eq!(scope_data.inlined_parent_scope, None); + scope_data.inlined_parent_scope = if self.callsite_scope.inlined.is_some() { + Some(self.callsite.source_info.scope) + } else { + self.callsite_scope.inlined_parent_scope + }; + + // Mark the outermost callee scope as an inlined one. + assert_eq!(scope_data.inlined, None); + scope_data.inlined = Some((self.callsite.callee, self.callsite.source_info.span)); + } else if scope_data.inlined_parent_scope.is_none() { + // Make it easy to find the scope with `inlined` set above. + scope_data.inlined_parent_scope = Some(self.map_scope(OUTERMOST_SOURCE_SCOPE)); + } + } + fn visit_source_scope(&mut self, scope: &mut SourceScope) { *scope = self.map_scope(*scope); } @@ -938,7 +937,7 @@ impl<'tcx> MutVisitor<'tcx> for Integrator<'_, 'tcx> { } } TerminatorKind::Return => { - terminator.kind = if let Some(tgt) = self.return_block { + terminator.kind = if let Some(tgt) = self.callsite.target { TerminatorKind::Goto { target: tgt } } else { TerminatorKind::Unreachable diff --git a/compiler/rustc_typeck/src/check/cast.rs b/compiler/rustc_typeck/src/check/cast.rs index a153997599a..d9aaf730efc 100644 --- a/compiler/rustc_typeck/src/check/cast.rs +++ b/compiler/rustc_typeck/src/check/cast.rs @@ -347,16 +347,22 @@ impl<'a, 'tcx> CastCheck<'tcx> { ); err.span_label(self.span, "invalid cast"); if self.expr_ty.is_numeric() { - err.span_help( - self.span, - if self.expr_ty == fcx.tcx.types.i8 { - "try casting from `u8` instead" - } else if self.expr_ty == fcx.tcx.types.u32 { - "try `char::from_u32` instead" - } else { - "try `char::from_u32` instead (via a `u32`)" - }, - ); + if self.expr_ty == fcx.tcx.types.u32 { + match fcx.tcx.sess.source_map().span_to_snippet(self.expr.span) { + Ok(snippet) => err.span_suggestion( + self.span, + "try `char::from_u32` instead", + format!("char::from_u32({snippet})"), + Applicability::MachineApplicable, + ), + + Err(_) => err.span_help(self.span, "try `char::from_u32` instead"), + }; + } else if self.expr_ty == fcx.tcx.types.i8 { + err.span_help(self.span, "try casting from `u8` instead"); + } else { + err.span_help(self.span, "try `char::from_u32` instead (via a `u32`)"); + }; } err.emit(); } diff --git a/compiler/rustc_typeck/src/check/generator_interior.rs b/compiler/rustc_typeck/src/check/generator_interior.rs index 92a2584a6de..60d19405bcf 100644 --- a/compiler/rustc_typeck/src/check/generator_interior.rs +++ b/compiler/rustc_typeck/src/check/generator_interior.rs @@ -17,7 +17,6 @@ use rustc_middle::middle::region::{self, Scope, ScopeData, YieldData}; use rustc_middle::ty::{self, Ty, TyCtxt}; use rustc_span::symbol::sym; use rustc_span::Span; -use smallvec::SmallVec; use tracing::debug; mod drop_ranges; @@ -29,13 +28,6 @@ struct InteriorVisitor<'a, 'tcx> { expr_count: usize, kind: hir::GeneratorKind, prev_unresolved_span: Option<Span>, - /// Match arm guards have temporary borrows from the pattern bindings. - /// In case there is a yield point in a guard with a reference to such bindings, - /// such borrows can span across this yield point. - /// As such, we need to track these borrows and record them despite of the fact - /// that they may succeed the said yield point in the post-order. - guard_bindings: SmallVec<[SmallVec<[HirId; 4]>; 1]>, - guard_bindings_set: HirIdSet, linted_values: HirIdSet, drop_ranges: DropRanges, } @@ -48,7 +40,6 @@ impl<'a, 'tcx> InteriorVisitor<'a, 'tcx> { scope: Option<region::Scope>, expr: Option<&'tcx Expr<'tcx>>, source_span: Span, - guard_borrowing_from_pattern: bool, ) { use rustc_span::DUMMY_SP; @@ -89,8 +80,7 @@ impl<'a, 'tcx> InteriorVisitor<'a, 'tcx> { // If it is a borrowing happening in the guard, // it needs to be recorded regardless because they // do live across this yield point. - guard_borrowing_from_pattern - || yield_data.expr_and_pat_count >= self.expr_count + yield_data.expr_and_pat_count >= self.expr_count }) .cloned() }) @@ -196,8 +186,6 @@ pub fn resolve_interior<'a, 'tcx>( expr_count: 0, kind, prev_unresolved_span: None, - guard_bindings: <_>::default(), - guard_bindings_set: <_>::default(), linted_values: <_>::default(), drop_ranges: drop_ranges::compute_drop_ranges(fcx, def_id, body), }; @@ -284,15 +272,47 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { let Arm { guard, pat, body, .. } = arm; self.visit_pat(pat); if let Some(ref g) = guard { - self.guard_bindings.push(<_>::default()); - ArmPatCollector { - guard_bindings_set: &mut self.guard_bindings_set, - guard_bindings: self - .guard_bindings - .last_mut() - .expect("should have pushed at least one earlier"), + { + // If there is a guard, we need to count all variables bound in the pattern as + // borrowed for the entire guard body, regardless of whether they are accessed. + // We do this by walking the pattern bindings and recording `&T` for any `x: T` + // that is bound. + + struct ArmPatCollector<'a, 'b, 'tcx> { + interior_visitor: &'a mut InteriorVisitor<'b, 'tcx>, + scope: Scope, + } + + impl<'a, 'b, 'tcx> Visitor<'tcx> for ArmPatCollector<'a, 'b, 'tcx> { + fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>) { + intravisit::walk_pat(self, pat); + if let PatKind::Binding(_, id, ident, ..) = pat.kind { + let ty = + self.interior_visitor.fcx.typeck_results.borrow().node_type(id); + let tcx = self.interior_visitor.fcx.tcx; + let ty = tcx.mk_ref( + // Use `ReErased` as `resolve_interior` is going to replace all the + // regions anyway. + tcx.mk_region(ty::ReErased), + ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }, + ); + self.interior_visitor.record( + ty, + id, + Some(self.scope), + None, + ident.span, + ); + } + } + } + + ArmPatCollector { + interior_visitor: self, + scope: Scope { id: g.body().hir_id.local_id, data: ScopeData::Node }, + } + .visit_pat(pat); } - .visit_pat(pat); match g { Guard::If(ref e) => { @@ -302,12 +322,6 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { self.visit_let_expr(l); } } - - let mut scope_var_ids = - self.guard_bindings.pop().expect("should have pushed at least one earlier"); - for var_id in scope_var_ids.drain(..) { - self.guard_bindings_set.remove(&var_id); - } } self.visit_expr(body); } @@ -320,13 +334,11 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { if let PatKind::Binding(..) = pat.kind { let scope = self.region_scope_tree.var_scope(pat.hir_id.local_id).unwrap(); let ty = self.fcx.typeck_results.borrow().pat_ty(pat); - self.record(ty, pat.hir_id, Some(scope), None, pat.span, false); + self.record(ty, pat.hir_id, Some(scope), None, pat.span); } } fn visit_expr(&mut self, expr: &'tcx Expr<'tcx>) { - let mut guard_borrowing_from_pattern = false; - match &expr.kind { ExprKind::Call(callee, args) => match &callee.kind { ExprKind::Path(qpath) => { @@ -353,16 +365,6 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { } _ => intravisit::walk_expr(self, expr), }, - ExprKind::Path(qpath) => { - intravisit::walk_expr(self, expr); - let res = self.fcx.typeck_results.borrow().qpath_res(qpath, expr.hir_id); - match res { - Res::Local(id) if self.guard_bindings_set.contains(&id) => { - guard_borrowing_from_pattern = true; - } - _ => {} - } - } _ => intravisit::walk_expr(self, expr), } @@ -391,14 +393,7 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { // If there are adjustments, then record the final type -- // this is the actual value that is being produced. if let Some(adjusted_ty) = self.fcx.typeck_results.borrow().expr_ty_adjusted_opt(expr) { - self.record( - adjusted_ty, - expr.hir_id, - scope, - Some(expr), - expr.span, - guard_borrowing_from_pattern, - ); + self.record(adjusted_ty, expr.hir_id, scope, Some(expr), expr.span); } // Also record the unadjusted type (which is the only type if @@ -426,54 +421,13 @@ impl<'a, 'tcx> Visitor<'tcx> for InteriorVisitor<'a, 'tcx> { // The type table might not have information for this expression // if it is in a malformed scope. (#66387) if let Some(ty) = self.fcx.typeck_results.borrow().expr_ty_opt(expr) { - if guard_borrowing_from_pattern { - // Match guards create references to all the bindings in the pattern that are used - // in the guard, e.g. `y if is_even(y) => ...` becomes `is_even(*r_y)` where `r_y` - // is a reference to `y`, so we must record a reference to the type of the binding. - let tcx = self.fcx.tcx; - let ref_ty = tcx.mk_ref( - // Use `ReErased` as `resolve_interior` is going to replace all the regions anyway. - tcx.mk_region(ty::ReErased), - ty::TypeAndMut { ty, mutbl: hir::Mutability::Not }, - ); - self.record( - ref_ty, - expr.hir_id, - scope, - Some(expr), - expr.span, - guard_borrowing_from_pattern, - ); - } - self.record( - ty, - expr.hir_id, - scope, - Some(expr), - expr.span, - guard_borrowing_from_pattern, - ); + self.record(ty, expr.hir_id, scope, Some(expr), expr.span); } else { self.fcx.tcx.sess.delay_span_bug(expr.span, "no type for node"); } } } -struct ArmPatCollector<'a> { - guard_bindings_set: &'a mut HirIdSet, - guard_bindings: &'a mut SmallVec<[HirId; 4]>, -} - -impl<'a, 'tcx> Visitor<'tcx> for ArmPatCollector<'a> { - fn visit_pat(&mut self, pat: &'tcx Pat<'tcx>) { - intravisit::walk_pat(self, pat); - if let PatKind::Binding(_, id, ..) = pat.kind { - self.guard_bindings.push(id); - self.guard_bindings_set.insert(id); - } - } -} - #[derive(Default)] pub struct SuspendCheckData<'a, 'tcx> { expr: Option<&'tcx Expr<'tcx>>, diff --git a/compiler/rustc_typeck/src/expr_use_visitor.rs b/compiler/rustc_typeck/src/expr_use_visitor.rs index 6de6b6ee479..ad44adb68c6 100644 --- a/compiler/rustc_typeck/src/expr_use_visitor.rs +++ b/compiler/rustc_typeck/src/expr_use_visitor.rs @@ -17,6 +17,7 @@ use rustc_middle::hir::place::ProjectionKind; use rustc_middle::mir::FakeReadCause; use rustc_middle::ty::{self, adjustment, AdtKind, Ty, TyCtxt}; use rustc_target::abi::VariantIdx; +use ty::BorrowKind::ImmBorrow; use crate::mem_categorization as mc; @@ -621,7 +622,7 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> { FakeReadCause::ForMatchedPlace(closure_def_id), discr_place.hir_id, ); - self.walk_pat(discr_place, arm.pat); + self.walk_pat(discr_place, arm.pat, arm.guard.is_some()); if let Some(hir::Guard::If(e)) = arm.guard { self.consume_expr(e) @@ -645,12 +646,17 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> { FakeReadCause::ForLet(closure_def_id), discr_place.hir_id, ); - self.walk_pat(discr_place, pat); + self.walk_pat(discr_place, pat, false); } /// The core driver for walking a pattern - fn walk_pat(&mut self, discr_place: &PlaceWithHirId<'tcx>, pat: &hir::Pat<'_>) { - debug!("walk_pat(discr_place={:?}, pat={:?})", discr_place, pat); + fn walk_pat( + &mut self, + discr_place: &PlaceWithHirId<'tcx>, + pat: &hir::Pat<'_>, + has_guard: bool, + ) { + debug!("walk_pat(discr_place={:?}, pat={:?}, has_guard={:?})", discr_place, pat, has_guard); let tcx = self.tcx(); let ExprUseVisitor { ref mc, body_owner: _, ref mut delegate } = *self; @@ -671,6 +677,13 @@ impl<'a, 'tcx> ExprUseVisitor<'a, 'tcx> { delegate.bind(binding_place, binding_place.hir_id); } + // Subtle: MIR desugaring introduces immutable borrows for each pattern + // binding when lowering pattern guards to ensure that the guard does not + // modify the scrutinee. + if has_guard { + delegate.borrow(place, discr_place.hir_id, ImmBorrow); + } + // It is also a borrow or copy/move of the value being matched. // In a cases of pattern like `let pat = upvar`, don't use the span // of the pattern, as this just looks confusing, instead use the span diff --git a/library/core/src/cell.rs b/library/core/src/cell.rs index 2a49017de3c..5448ced803a 100644 --- a/library/core/src/cell.rs +++ b/library/core/src/cell.rs @@ -194,10 +194,10 @@ use crate::cmp::Ordering; use crate::fmt::{self, Debug, Display}; -use crate::marker::Unsize; +use crate::marker::{PhantomData, Unsize}; use crate::mem; use crate::ops::{CoerceUnsized, Deref, DerefMut}; -use crate::ptr; +use crate::ptr::{self, NonNull}; /// A mutable memory location. /// @@ -896,7 +896,8 @@ impl<T: ?Sized> RefCell<T> { // SAFETY: `BorrowRef` ensures that there is only immutable access // to the value while borrowed. - Ok(Ref { value: unsafe { &*self.value.get() }, borrow: b }) + let value = unsafe { NonNull::new_unchecked(self.value.get()) }; + Ok(Ref { value, borrow: b }) } None => Err(BorrowError { // If a borrow occurred, then we must already have an outstanding borrow, @@ -980,8 +981,9 @@ impl<T: ?Sized> RefCell<T> { self.borrowed_at.set(Some(crate::panic::Location::caller())); } - // SAFETY: `BorrowRef` guarantees unique access. - Ok(RefMut { value: unsafe { &mut *self.value.get() }, borrow: b }) + // SAFETY: `BorrowRefMut` guarantees unique access. + let value = unsafe { NonNull::new_unchecked(self.value.get()) }; + Ok(RefMut { value, borrow: b, marker: PhantomData }) } None => Err(BorrowMutError { // If a borrow occurred, then we must already have an outstanding borrow, @@ -1314,7 +1316,10 @@ impl Clone for BorrowRef<'_> { #[stable(feature = "rust1", since = "1.0.0")] #[must_not_suspend = "holding a Ref across suspend points can cause BorrowErrors"] pub struct Ref<'b, T: ?Sized + 'b> { - value: &'b T, + // NB: we use a pointer instead of `&'b T` to avoid `noalias` violations, because a + // `Ref` argument doesn't hold immutability for its whole scope, only until it drops. + // `NonNull` is also covariant over `T`, just like we would have with `&T`. + value: NonNull<T>, borrow: BorrowRef<'b>, } @@ -1324,7 +1329,8 @@ impl<T: ?Sized> Deref for Ref<'_, T> { #[inline] fn deref(&self) -> &T { - self.value + // SAFETY: the value is accessible as long as we hold our borrow. + unsafe { self.value.as_ref() } } } @@ -1368,7 +1374,7 @@ impl<'b, T: ?Sized> Ref<'b, T> { where F: FnOnce(&T) -> &U, { - Ref { value: f(orig.value), borrow: orig.borrow } + Ref { value: NonNull::from(f(&*orig)), borrow: orig.borrow } } /// Makes a new `Ref` for an optional component of the borrowed data. The @@ -1399,8 +1405,8 @@ impl<'b, T: ?Sized> Ref<'b, T> { where F: FnOnce(&T) -> Option<&U>, { - match f(orig.value) { - Some(value) => Ok(Ref { value, borrow: orig.borrow }), + match f(&*orig) { + Some(value) => Ok(Ref { value: NonNull::from(value), borrow: orig.borrow }), None => Err(orig), } } @@ -1431,9 +1437,12 @@ impl<'b, T: ?Sized> Ref<'b, T> { where F: FnOnce(&T) -> (&U, &V), { - let (a, b) = f(orig.value); + let (a, b) = f(&*orig); let borrow = orig.borrow.clone(); - (Ref { value: a, borrow }, Ref { value: b, borrow: orig.borrow }) + ( + Ref { value: NonNull::from(a), borrow }, + Ref { value: NonNull::from(b), borrow: orig.borrow }, + ) } /// Convert into a reference to the underlying data. @@ -1467,7 +1476,8 @@ impl<'b, T: ?Sized> Ref<'b, T> { // unique reference to the borrowed RefCell. No further mutable references can be created // from the original cell. mem::forget(orig.borrow); - orig.value + // SAFETY: after forgetting, we can form a reference for the rest of lifetime `'b`. + unsafe { orig.value.as_ref() } } } @@ -1507,13 +1517,12 @@ impl<'b, T: ?Sized> RefMut<'b, T> { /// ``` #[stable(feature = "cell_map", since = "1.8.0")] #[inline] - pub fn map<U: ?Sized, F>(orig: RefMut<'b, T>, f: F) -> RefMut<'b, U> + pub fn map<U: ?Sized, F>(mut orig: RefMut<'b, T>, f: F) -> RefMut<'b, U> where F: FnOnce(&mut T) -> &mut U, { - // FIXME(nll-rfc#40): fix borrow-check - let RefMut { value, borrow } = orig; - RefMut { value: f(value), borrow } + let value = NonNull::from(f(&mut *orig)); + RefMut { value, borrow: orig.borrow, marker: PhantomData } } /// Makes a new `RefMut` for an optional component of the borrowed data. The @@ -1548,23 +1557,19 @@ impl<'b, T: ?Sized> RefMut<'b, T> { /// ``` #[unstable(feature = "cell_filter_map", reason = "recently added", issue = "81061")] #[inline] - pub fn filter_map<U: ?Sized, F>(orig: RefMut<'b, T>, f: F) -> Result<RefMut<'b, U>, Self> + pub fn filter_map<U: ?Sized, F>(mut orig: RefMut<'b, T>, f: F) -> Result<RefMut<'b, U>, Self> where F: FnOnce(&mut T) -> Option<&mut U>, { - // FIXME(nll-rfc#40): fix borrow-check - let RefMut { value, borrow } = orig; - let value = value as *mut T; // SAFETY: function holds onto an exclusive reference for the duration // of its call through `orig`, and the pointer is only de-referenced // inside of the function call never allowing the exclusive reference to // escape. - match f(unsafe { &mut *value }) { - Some(value) => Ok(RefMut { value, borrow }), - None => { - // SAFETY: same as above. - Err(RefMut { value: unsafe { &mut *value }, borrow }) + match f(&mut *orig) { + Some(value) => { + Ok(RefMut { value: NonNull::from(value), borrow: orig.borrow, marker: PhantomData }) } + None => Err(orig), } } @@ -1596,15 +1601,18 @@ impl<'b, T: ?Sized> RefMut<'b, T> { #[stable(feature = "refcell_map_split", since = "1.35.0")] #[inline] pub fn map_split<U: ?Sized, V: ?Sized, F>( - orig: RefMut<'b, T>, + mut orig: RefMut<'b, T>, f: F, ) -> (RefMut<'b, U>, RefMut<'b, V>) where F: FnOnce(&mut T) -> (&mut U, &mut V), { - let (a, b) = f(orig.value); let borrow = orig.borrow.clone(); - (RefMut { value: a, borrow }, RefMut { value: b, borrow: orig.borrow }) + let (a, b) = f(&mut *orig); + ( + RefMut { value: NonNull::from(a), borrow, marker: PhantomData }, + RefMut { value: NonNull::from(b), borrow: orig.borrow, marker: PhantomData }, + ) } /// Convert into a mutable reference to the underlying data. @@ -1630,14 +1638,15 @@ impl<'b, T: ?Sized> RefMut<'b, T> { /// assert!(cell.try_borrow_mut().is_err()); /// ``` #[unstable(feature = "cell_leak", issue = "69099")] - pub fn leak(orig: RefMut<'b, T>) -> &'b mut T { + pub fn leak(mut orig: RefMut<'b, T>) -> &'b mut T { // By forgetting this BorrowRefMut we ensure that the borrow counter in the RefCell can't // go back to UNUSED within the lifetime `'b`. Resetting the reference tracking state would // require a unique reference to the borrowed RefCell. No further references can be created // from the original cell within that lifetime, making the current borrow the only // reference for the remaining lifetime. mem::forget(orig.borrow); - orig.value + // SAFETY: after forgetting, we can form a reference for the rest of lifetime `'b`. + unsafe { orig.value.as_mut() } } } @@ -1692,8 +1701,12 @@ impl<'b> BorrowRefMut<'b> { #[stable(feature = "rust1", since = "1.0.0")] #[must_not_suspend = "holding a RefMut across suspend points can cause BorrowErrors"] pub struct RefMut<'b, T: ?Sized + 'b> { - value: &'b mut T, + // NB: we use a pointer instead of `&'b mut T` to avoid `noalias` violations, because a + // `RefMut` argument doesn't hold exclusivity for its whole scope, only until it drops. + value: NonNull<T>, borrow: BorrowRefMut<'b>, + // `NonNull` is covariant over `T`, so we need to reintroduce invariance. + marker: PhantomData<&'b mut T>, } #[stable(feature = "rust1", since = "1.0.0")] @@ -1702,7 +1715,8 @@ impl<T: ?Sized> Deref for RefMut<'_, T> { #[inline] fn deref(&self) -> &T { - self.value + // SAFETY: the value is accessible as long as we hold our borrow. + unsafe { self.value.as_ref() } } } @@ -1710,7 +1724,8 @@ impl<T: ?Sized> Deref for RefMut<'_, T> { impl<T: ?Sized> DerefMut for RefMut<'_, T> { #[inline] fn deref_mut(&mut self) -> &mut T { - self.value + // SAFETY: the value is accessible as long as we hold our borrow. + unsafe { self.value.as_mut() } } } diff --git a/library/core/src/lib.rs b/library/core/src/lib.rs index d1936b6b566..7b04e4423b7 100644 --- a/library/core/src/lib.rs +++ b/library/core/src/lib.rs @@ -171,7 +171,6 @@ #![feature(const_precise_live_drops)] #![feature(const_refs_to_cell)] #![feature(decl_macro)] -#![cfg_attr(bootstrap, feature(derive_default_enum))] #![feature(deprecated_suggestion)] #![feature(doc_cfg)] #![feature(doc_notable_trait)] diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs index a226dea54a4..7ac7573b43c 100644 --- a/library/core/src/slice/mod.rs +++ b/library/core/src/slice/mod.rs @@ -4016,7 +4016,6 @@ impl<T> [T] { } } -#[cfg(not(bootstrap))] impl<T, const N: usize> [[T; N]] { /// Takes a `&[[T; N]]`, and flattens it to a `&[T]`. /// diff --git a/library/core/src/sync/atomic.rs b/library/core/src/sync/atomic.rs index a01f3fbad56..36df5c3beb3 100644 --- a/library/core/src/sync/atomic.rs +++ b/library/core/src/sync/atomic.rs @@ -2830,7 +2830,7 @@ unsafe fn atomic_umin<T: Copy>(dst: *mut T, val: T, order: Ordering) -> T { /// A fence 'A' which has (at least) [`Release`] ordering semantics, synchronizes /// with a fence 'B' with (at least) [`Acquire`] semantics, if and only if there /// exist operations X and Y, both operating on some atomic object 'M' such -/// that A is sequenced before X, Y is synchronized before B and Y observes +/// that A is sequenced before X, Y is sequenced before B and Y observes /// the change to M. This provides a happens-before dependence between A and B. /// /// ```text diff --git a/library/core/tests/slice.rs b/library/core/tests/slice.rs index 872786ed1bd..5751a91721d 100644 --- a/library/core/tests/slice.rs +++ b/library/core/tests/slice.rs @@ -2518,7 +2518,6 @@ fn test_slice_from_ptr_range() { } #[test] -#[cfg(not(bootstrap))] #[should_panic = "slice len overflow"] fn test_flatten_size_overflow() { let x = &[[(); usize::MAX]; 2][..]; @@ -2526,7 +2525,6 @@ fn test_flatten_size_overflow() { } #[test] -#[cfg(not(bootstrap))] #[should_panic = "slice len overflow"] fn test_flatten_mut_size_overflow() { let x = &mut [[(); usize::MAX]; 2][..]; diff --git a/library/std/src/process.rs b/library/std/src/process.rs index e253f46406f..28e802d07e1 100644 --- a/library/std/src/process.rs +++ b/library/std/src/process.rs @@ -2136,7 +2136,7 @@ pub trait Termination { impl Termination for () { #[inline] fn report(self) -> ExitCode { - ExitCode::SUCCESS.report() + ExitCode::SUCCESS } } @@ -2162,7 +2162,7 @@ impl<E: fmt::Debug> Termination for Result<!, E> { fn report(self) -> ExitCode { let Err(err) = self; eprintln!("Error: {err:?}"); - ExitCode::FAILURE.report() + ExitCode::FAILURE } } diff --git a/library/std/src/sync/mutex.rs b/library/std/src/sync/mutex.rs index aacc893ba06..3d8281fe593 100644 --- a/library/std/src/sync/mutex.rs +++ b/library/std/src/sync/mutex.rs @@ -364,6 +364,45 @@ impl<T: ?Sized> Mutex<T> { self.poison.get() } + /// Clear the poisoned state from a mutex + /// + /// If the mutex is poisoned, it will remain poisoned until this function is called. This + /// allows recovering from a poisoned state and marking that it has recovered. For example, if + /// the value is overwritten by a known-good value, then the mutex can be marked as + /// un-poisoned. Or possibly, the value could be inspected to determine if it is in a + /// consistent state, and if so the poison is removed. + /// + /// # Examples + /// + /// ``` + /// #![feature(mutex_unpoison)] + /// + /// use std::sync::{Arc, Mutex}; + /// use std::thread; + /// + /// let mutex = Arc::new(Mutex::new(0)); + /// let c_mutex = Arc::clone(&mutex); + /// + /// let _ = thread::spawn(move || { + /// let _lock = c_mutex.lock().unwrap(); + /// panic!(); // the mutex gets poisoned + /// }).join(); + /// + /// assert_eq!(mutex.is_poisoned(), true); + /// let x = mutex.lock().unwrap_or_else(|mut e| { + /// **e.get_mut() = 1; + /// mutex.clear_poison(); + /// e.into_inner() + /// }); + /// assert_eq!(mutex.is_poisoned(), false); + /// assert_eq!(*x, 1); + /// ``` + #[inline] + #[unstable(feature = "mutex_unpoison", issue = "96469")] + pub fn clear_poison(&self) { + self.poison.clear(); + } + /// Consumes this mutex, returning the underlying data. /// /// # Errors diff --git a/library/std/src/sync/poison.rs b/library/std/src/sync/poison.rs index 07a90da449c..ba91fb0499f 100644 --- a/library/std/src/sync/poison.rs +++ b/library/std/src/sync/poison.rs @@ -40,6 +40,11 @@ impl Flag { pub fn get(&self) -> bool { self.failed.load(Ordering::Relaxed) } + + #[inline] + pub fn clear(&self) { + self.failed.store(false, Ordering::Relaxed) + } } pub struct Guard { diff --git a/library/std/src/sync/rwlock.rs b/library/std/src/sync/rwlock.rs index 9ec0903f037..4f1b4bedaab 100644 --- a/library/std/src/sync/rwlock.rs +++ b/library/std/src/sync/rwlock.rs @@ -368,6 +368,45 @@ impl<T: ?Sized> RwLock<T> { self.poison.get() } + /// Clear the poisoned state from a lock + /// + /// If the lock is poisoned, it will remain poisoned until this function is called. This allows + /// recovering from a poisoned state and marking that it has recovered. For example, if the + /// value is overwritten by a known-good value, then the mutex can be marked as un-poisoned. Or + /// possibly, the value could be inspected to determine if it is in a consistent state, and if + /// so the poison is removed. + /// + /// # Examples + /// + /// ``` + /// #![feature(mutex_unpoison)] + /// + /// use std::sync::{Arc, RwLock}; + /// use std::thread; + /// + /// let lock = Arc::new(RwLock::new(0)); + /// let c_lock = Arc::clone(&lock); + /// + /// let _ = thread::spawn(move || { + /// let _lock = c_lock.write().unwrap(); + /// panic!(); // the mutex gets poisoned + /// }).join(); + /// + /// assert_eq!(lock.is_poisoned(), true); + /// let guard = lock.write().unwrap_or_else(|mut e| { + /// **e.get_mut() = 1; + /// lock.clear_poison(); + /// e.into_inner() + /// }); + /// assert_eq!(lock.is_poisoned(), false); + /// assert_eq!(*guard, 1); + /// ``` + #[inline] + #[unstable(feature = "mutex_unpoison", issue = "96469")] + pub fn clear_poison(&self) { + self.poison.clear(); + } + /// Consumes this `RwLock`, returning the underlying data. /// /// # Errors diff --git a/src/etc/natvis/libcore.natvis b/src/etc/natvis/libcore.natvis index 643590fc977..a4e8a57e4b1 100644 --- a/src/etc/natvis/libcore.natvis +++ b/src/etc/natvis/libcore.natvis @@ -7,15 +7,15 @@ </Expand> </Type> <Type Name="core::cell::Ref<*>"> - <DisplayString>{value}</DisplayString> + <DisplayString>{value.pointer}</DisplayString> <Expand> - <ExpandedItem>value</ExpandedItem> + <ExpandedItem>value.pointer</ExpandedItem> </Expand> </Type> <Type Name="core::cell::RefMut<*>"> - <DisplayString>{value}</DisplayString> + <DisplayString>{value.pointer}</DisplayString> <Expand> - <ExpandedItem>value</ExpandedItem> + <ExpandedItem>value.pointer</ExpandedItem> </Expand> </Type> <Type Name="core::cell::RefCell<*>"> diff --git a/src/librustdoc/formats/cache.rs b/src/librustdoc/formats/cache.rs index 9dc30d8a189..28648e25d90 100644 --- a/src/librustdoc/formats/cache.rs +++ b/src/librustdoc/formats/cache.rs @@ -3,7 +3,7 @@ use std::mem; use rustc_data_structures::fx::{FxHashMap, FxHashSet}; use rustc_hir::def_id::{CrateNum, DefId}; use rustc_middle::middle::privacy::AccessLevels; -use rustc_middle::ty::TyCtxt; +use rustc_middle::ty::{self, TyCtxt}; use rustc_span::{sym, Symbol}; use crate::clean::{self, types::ExternalLocation, ExternalCrate, ItemId, PrimitiveType}; @@ -452,6 +452,15 @@ impl<'a, 'tcx> DocFolder for CacheBuilder<'a, 'tcx> { clean::Type::Path { ref path } | clean::BorrowedRef { type_: box clean::Type::Path { ref path }, .. } => { dids.insert(path.def_id()); + if let Some(generics) = path.generics() && + let ty::Adt(adt, _) = self.tcx.type_of(path.def_id()).kind() && + adt.is_fundamental() { + for ty in generics { + if let Some(did) = ty.def_id(&self.cache) { + dids.insert(did); + } + } + } } clean::DynTrait(ref bounds, _) | clean::BorrowedRef { type_: box clean::DynTrait(ref bounds, _), .. } => { diff --git a/src/librustdoc/html/static/.eslintrc.js b/src/librustdoc/html/static/.eslintrc.js index 7634a15b9bd..9d4c45b8a62 100644 --- a/src/librustdoc/html/static/.eslintrc.js +++ b/src/librustdoc/html/static/.eslintrc.js @@ -34,5 +34,9 @@ module.exports = { "1tbs", { "allowSingleLine": false } ], + "keyword-spacing": [ + "error", + { "before": true, "after": true } + ], } }; diff --git a/src/librustdoc/html/static/js/storage.js b/src/librustdoc/html/static/js/storage.js index 948885cd30a..3fcf66a817e 100644 --- a/src/librustdoc/html/static/js/storage.js +++ b/src/librustdoc/html/static/js/storage.js @@ -103,7 +103,7 @@ function onEachLazy(lazyArray, func, reversed) { function updateLocalStorage(name, value) { try { window.localStorage.setItem("rustdoc-" + name, value); - } catch(e) { + } catch (e) { // localStorage is not accessible, do nothing } } @@ -111,7 +111,7 @@ function updateLocalStorage(name, value) { function getCurrentValue(name) { try { return window.localStorage.getItem("rustdoc-" + name); - } catch(e) { + } catch (e) { return null; } } diff --git a/src/stage0.json b/src/stage0.json index 952fc7817d4..ddd517b5a62 100644 --- a/src/stage0.json +++ b/src/stage0.json @@ -2,347 +2,347 @@ "__comment": "Generated by `./x.py run src/tools/bump-stage0`. Run that command again to update the bootstrap compiler.", "dist_server": "https://static.rust-lang.org", "compiler": { - "date": "2022-04-05", + "date": "2022-05-15", "version": "beta" }, "rustfmt": { - "date": "2022-04-05", + "date": "2022-05-18", "version": "nightly" }, "checksums_sha256": { - "dist/2022-04-05/cargo-beta-aarch64-apple-darwin.tar.gz": "d522845ac8c2644378575b25a742fa1e77030a0ef3e45703fa40b3fc96e2fb28", - "dist/2022-04-05/cargo-beta-aarch64-apple-darwin.tar.xz": "9ebed4b378565e9218f4d415d84b36fc78c92ff8f2a0b5360d5199353dbb2402", - "dist/2022-04-05/cargo-beta-aarch64-pc-windows-msvc.tar.gz": "88e973cd6c4fd1307ed614b7480984ef9b0101b06571f6d241082904acfc4b6b", - "dist/2022-04-05/cargo-beta-aarch64-pc-windows-msvc.tar.xz": "dd13d493e02853f7399d886a8a74bfa621c5b2552ae2f50b6000c1dcbb76bd82", - "dist/2022-04-05/cargo-beta-aarch64-unknown-linux-gnu.tar.gz": "d1d46f8492b1ebd9c3e1845e14d83d49bd03490c6f11f7be9f046c16d8040602", - "dist/2022-04-05/cargo-beta-aarch64-unknown-linux-gnu.tar.xz": "95d521fb4530f9fed33ad82227cf0ab517d6ea160549fda8ebefaf66d44e400d", - "dist/2022-04-05/cargo-beta-aarch64-unknown-linux-musl.tar.gz": "28f126c940bdf7fbbe27b64e7057f13a5fe03364b38c9898df2aaac9f682a60f", - "dist/2022-04-05/cargo-beta-aarch64-unknown-linux-musl.tar.xz": "ad107be697369008d1fade995cc20c044f9ee53713835a3641f91b2b93dd9e2c", - "dist/2022-04-05/cargo-beta-arm-unknown-linux-gnueabi.tar.gz": "7fd5000abc9afe72cab7117f64dcdd737003a57302b7289c3113cf1a14d8e454", - "dist/2022-04-05/cargo-beta-arm-unknown-linux-gnueabi.tar.xz": "5b7576d67dacc763d4d9be0e3be53aa7a1753cb71cd52d82cde79a142afe3541", - "dist/2022-04-05/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz": "6ec9fbbc71d5e98535673e1e568cd5440c241ce466e1fc9eddf1cac99af7f86d", - "dist/2022-04-05/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz": "4e534c1960382f6084a0250060a048254470c1f498bbc28064878c1029232271", - "dist/2022-04-05/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz": "b59bf7b126c91ac4bda9daefa2403bdc25f7240d72e7bd651d1e9f8e53041d61", - "dist/2022-04-05/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz": "e71597532634725eba7dcd85faf0fcb9bdf2fcf372c0a03e9d507ab1420b5576", - "dist/2022-04-05/cargo-beta-i686-pc-windows-gnu.tar.gz": "38b0ec02eb2acc51c7088542d3642b2c55c0e042f6d8c1ab3de84652c587411f", - "dist/2022-04-05/cargo-beta-i686-pc-windows-gnu.tar.xz": "a194fe60bee39f765e4478107c4a5cc23ccb0d25042b0fa9dd1d5a758e7ae5cf", - "dist/2022-04-05/cargo-beta-i686-pc-windows-msvc.tar.gz": "4467065f716670ef5c305d70b68e5375bf542514fdf6645dc92b43759e76213a", - "dist/2022-04-05/cargo-beta-i686-pc-windows-msvc.tar.xz": "78829f8a16ca9e5c389141b050c7b120115420f966a37888320fdc76886ead1d", - "dist/2022-04-05/cargo-beta-i686-unknown-linux-gnu.tar.gz": "26c423f1667bb0bbede80069be29272877e9ce8f75345f7391f5d1260ec900c1", - "dist/2022-04-05/cargo-beta-i686-unknown-linux-gnu.tar.xz": "b9753f612d59e7d30c3775bcfcaad76df7d0607ad5bdb81041cd40b5690b6239", - "dist/2022-04-05/cargo-beta-mips-unknown-linux-gnu.tar.gz": "5e200db1460c1f0bf43fce499debc9602b09c518f13570f6f6f8c86f83ee0f11", - "dist/2022-04-05/cargo-beta-mips-unknown-linux-gnu.tar.xz": "8c60fa42bf03826c4cd1eea5d96b57e1772381713d780ea3810cbff62ec23041", - "dist/2022-04-05/cargo-beta-mips64-unknown-linux-gnuabi64.tar.gz": "9fcdd60c22211be46e50103a315e0f905d225c61aa42c468760fcd7894dce62d", - "dist/2022-04-05/cargo-beta-mips64-unknown-linux-gnuabi64.tar.xz": "ba188f3ab64897109d2039756c01b43b30008479687a76aa236f50ffc99b9b2d", - "dist/2022-04-05/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "18717f3f965fe3b2182f5791451caa938eb8f0ca5e8c1c6ee0eb32b735c50392", - "dist/2022-04-05/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "ba6d2dc52ce330745d8b543906cd0c81114c2f7e22900f6565d1bede93667d59", - "dist/2022-04-05/cargo-beta-mipsel-unknown-linux-gnu.tar.gz": "47e74be39cf947641e37a8f2d41c49b63aba4467b86c89219edee5933b6c92d1", - "dist/2022-04-05/cargo-beta-mipsel-unknown-linux-gnu.tar.xz": "dea6a2f11dd8fa9f93f8e1781d3c7faa04d29dded20f4938cbee60b15e523feb", - "dist/2022-04-05/cargo-beta-powerpc-unknown-linux-gnu.tar.gz": "f559462b323bf183e8f1f20fb509309e4e88b593f872becd42214f771e860973", - "dist/2022-04-05/cargo-beta-powerpc-unknown-linux-gnu.tar.xz": "bd5e9774ddec783e085c9837204de7122eb0469098f93d0768e30ebe3ee165f1", - "dist/2022-04-05/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz": "78cba227c038364f02c7ed5d01c5e26ac1bf069f7f0a97e54b9911dde8114c3a", - "dist/2022-04-05/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz": "63514e4afb11b57b58304f246a603ad336b6e95ce6d288cd9d4b834b8e531eab", - "dist/2022-04-05/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz": "5495f5a77fd354c2d8ed9de86052a1c6528092afdc8af66be532859dddafcd5d", - "dist/2022-04-05/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz": "4ab4e7674bb927919dc7e4a3a6037978c260ff97966a18409c4b9ae4e1802c4a", - "dist/2022-04-05/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz": "9baf8bceb40d728eb1ed47ea572d1b890fd36762ad7b119c9de6f7378682fe7b", - "dist/2022-04-05/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz": "0ef8e9ed9e401a688af6aab9f928ff6b860ddd5449f0becb2216d2206f45ec45", - "dist/2022-04-05/cargo-beta-s390x-unknown-linux-gnu.tar.gz": "d442fb0a4b8f56f7c008d53b15ba2a34d6e08701e0a69b2204e9c64ef32eb4c9", - "dist/2022-04-05/cargo-beta-s390x-unknown-linux-gnu.tar.xz": "5a4d757fbdbd0581e26ce997e33663789630d20620cd3fefc70ab866849c3850", - "dist/2022-04-05/cargo-beta-x86_64-apple-darwin.tar.gz": "03d0ec29bdffbe606e70a96614e44e0e65eaba38ecae4a9aca2e202a8891eb56", - "dist/2022-04-05/cargo-beta-x86_64-apple-darwin.tar.xz": "76149cbf429502b9c1fc71a6bff9d38b24f575bc43caf26143552e2658bde544", - "dist/2022-04-05/cargo-beta-x86_64-pc-windows-gnu.tar.gz": "ef7bbf4aaf758aa8c3ef74e68f8a39a6b1b2bad0ecfc90a0a49ceee41f5aef80", - "dist/2022-04-05/cargo-beta-x86_64-pc-windows-gnu.tar.xz": "23d15d39aacfbb1cc382cf2e88d9d688827c867e1b4778ab24d66579e766bd22", - "dist/2022-04-05/cargo-beta-x86_64-pc-windows-msvc.tar.gz": "20b0427583732b542b1274837d61b4f25a72c3810433d91bd31013daebfca54d", - "dist/2022-04-05/cargo-beta-x86_64-pc-windows-msvc.tar.xz": "827699b4f5ad3a810d2cbae8fb0c0e3b2724b054d7b7505cebd1af5efbeb592c", - "dist/2022-04-05/cargo-beta-x86_64-unknown-freebsd.tar.gz": "bcbd4379d77d42bdb665a8583daae4bf101b0f3f6588c148c80d72f1c60c5267", - "dist/2022-04-05/cargo-beta-x86_64-unknown-freebsd.tar.xz": "832c90d532ffcba10039f1244bf06c7121ddd3b7fd7c0d913b62fd0ad82e1dce", - "dist/2022-04-05/cargo-beta-x86_64-unknown-illumos.tar.gz": "7af1097744bfaa50b7d019025fc8b940363f9f5665f5247edf8374115ce074cd", - "dist/2022-04-05/cargo-beta-x86_64-unknown-illumos.tar.xz": "f6d2a741b41e26877a3c5f0a8337ebd563370b839c69091acf9535a1c2d6046c", - "dist/2022-04-05/cargo-beta-x86_64-unknown-linux-gnu.tar.gz": "477b6914f38919af61ecb2889032ffc2b12fee6ef85967a28bab6baf71df4baf", - "dist/2022-04-05/cargo-beta-x86_64-unknown-linux-gnu.tar.xz": "e91b851cd4a2cac68264bb47431943556e6b8c30df74d8a755e655df171acb47", - "dist/2022-04-05/cargo-beta-x86_64-unknown-linux-musl.tar.gz": "3218da520fd9fa9f70f78b1fbf2d69b74842d1cfd3e578eb5b4233b0632d2525", - "dist/2022-04-05/cargo-beta-x86_64-unknown-linux-musl.tar.xz": "5e492a006cef711748772bf3b6e25fdf400316d1392a8391fc005a88d6d8cf0f", - "dist/2022-04-05/cargo-beta-x86_64-unknown-netbsd.tar.gz": "b5164be552ff72bb0f19076c8ae3d0057ef6cf219df032d34130f98abfa07feb", - "dist/2022-04-05/cargo-beta-x86_64-unknown-netbsd.tar.xz": "d641e7e17c4720f961f52353a0a5214683b019a3acf1c1939d9f9710053496cb", - "dist/2022-04-05/rust-std-beta-aarch64-apple-darwin.tar.gz": "d81a9d0e3e6fe59849977a77acb3b3aebbf76465176a03a45cde34982488dc80", - "dist/2022-04-05/rust-std-beta-aarch64-apple-darwin.tar.xz": "001be52129c7e9d08cad4c337eee8515dbe71c17bf06dccbb4b17b6deb59eaed", - "dist/2022-04-05/rust-std-beta-aarch64-apple-ios-sim.tar.gz": "ebf3720b48a89422c473aa40645f8b4e02164b2e57a66e477c320836dfda8589", - "dist/2022-04-05/rust-std-beta-aarch64-apple-ios-sim.tar.xz": "dcaea0924b93a34f8ed5a3043fc752a7fdd74e93747584b4852582601ad4e0c7", - "dist/2022-04-05/rust-std-beta-aarch64-apple-ios.tar.gz": "713438516e54c2451327d15b62ec02439fb1734897e5193dbef4c74a72c3b3d9", - "dist/2022-04-05/rust-std-beta-aarch64-apple-ios.tar.xz": "6ddc798abdeb7b10389fbd1d4870df7c64983a1f2a2aaddebe3ec3a10c7124b9", - "dist/2022-04-05/rust-std-beta-aarch64-fuchsia.tar.gz": "7d74750469755e6171e5ee467eb82f9da6fc659f54eb0713656bcdd0effb1770", - "dist/2022-04-05/rust-std-beta-aarch64-fuchsia.tar.xz": "c1023c97eb2be40c80f83e7fe5b20367cffb3e52515f5e0ecf45201835088d78", - "dist/2022-04-05/rust-std-beta-aarch64-linux-android.tar.gz": "7819b5e29f097b32408fead0fc281ac8fa477cec0141688e0a82233cf37789ab", - "dist/2022-04-05/rust-std-beta-aarch64-linux-android.tar.xz": "51ff2b862d2d6bbc2610041011ed0ef3fae0647d422dbda1613cfc9d900652e9", - "dist/2022-04-05/rust-std-beta-aarch64-pc-windows-msvc.tar.gz": "ab90419c8552c7bd7e5381ae6d15788d7b4f8f903395ec2b5b7ef1d561453805", - "dist/2022-04-05/rust-std-beta-aarch64-pc-windows-msvc.tar.xz": "6b293b6df7f7b22ddd0dc1dada083176ae60df3624ee29430106c04f0ee4f262", - "dist/2022-04-05/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz": "104c2f1c3b84024fb03e13da89a0a416d67659a8dc8b582e28c7697fe3f43224", - "dist/2022-04-05/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz": "35d7787bc6c2d123e6b5e8ccb0ea0070a674050ff3dab80283e4c193b8617f37", - "dist/2022-04-05/rust-std-beta-aarch64-unknown-linux-musl.tar.gz": "00fd161285c90a65134a31152dcab92dafd82ca41f94bde84b6beb94dd98e934", - "dist/2022-04-05/rust-std-beta-aarch64-unknown-linux-musl.tar.xz": "c3bf923b7025fd3ddb70f79b36ac540f1a3a0d065eefe0e650ce8a3cdadb7a7f", - "dist/2022-04-05/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz": "05788212f632c0b83c7aa83ceace41efaba1b90066dccdb40e2ba8e5ebc1b405", - "dist/2022-04-05/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz": "3095a6a9d5ed80cece5ea0dade7bc00790055ac789866c0c51c6e05134f4b26f", - "dist/2022-04-05/rust-std-beta-aarch64-unknown-none.tar.gz": "9cc86be630b5ec83447fb1595a0afecb22a05d9ce89d73af39fb4edc43c37a8c", - "dist/2022-04-05/rust-std-beta-aarch64-unknown-none.tar.xz": "43437ce5b50c45e757957d2d7df354ca6e244b77081d03bde8e519cac2d03fa1", - "dist/2022-04-05/rust-std-beta-arm-linux-androideabi.tar.gz": "1f30c740549ab4ee2641ab08f7339798a69a13edf4ee928462d7fe5c3d49e1c2", - "dist/2022-04-05/rust-std-beta-arm-linux-androideabi.tar.xz": "64032f816c38fb0ea0db6be3c69de702ba6301800cb7c437f547257c3c88ad72", - "dist/2022-04-05/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz": "54de198103c4a8c2463261e7e4fbbf0104294e5a56e663fc75b4f6606d7e5609", - "dist/2022-04-05/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz": "50e690bb090230e61a70d34d4191a3a8aedc7e2079ceeb70bc780ae718fa5719", - "dist/2022-04-05/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz": "56040245d9707a90f62ce33ed45c75110b1f5de50c98b4276d3b0303ca457ca0", - "dist/2022-04-05/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz": "ea33048f8bd7057b80db565ead072ba3830ac54e9cd9120514d86c0a71398138", - "dist/2022-04-05/rust-std-beta-arm-unknown-linux-musleabi.tar.gz": "627ff5136cb18eeaae03303cb265f5492a57f53fb329fe0d362084697d4de4d5", - "dist/2022-04-05/rust-std-beta-arm-unknown-linux-musleabi.tar.xz": "d996b8ee3452f5d4dfd758b5ac835dd77ee9f050496d1745fa553901812b843f", - "dist/2022-04-05/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz": "86303fe3be5da53633630de44f58ee11475624d4ef4bce4f8a91d48f80bc03da", - "dist/2022-04-05/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz": "14dc9ed9584f7c55967831c97862cfd3cc7ae5e6cbc65936e4ecd0bd9d75fb30", - "dist/2022-04-05/rust-std-beta-armebv7r-none-eabi.tar.gz": "be874fc36bf175eed366db71d0905974153a3339bc84f8abda83c482197a4235", - "dist/2022-04-05/rust-std-beta-armebv7r-none-eabi.tar.xz": "c10c6cf39bf5f5360eddc1a6caedb79ba04ab227336e718b3a45f4a2f3c357c6", - "dist/2022-04-05/rust-std-beta-armebv7r-none-eabihf.tar.gz": "6b429165fe0d52c6dfa74beef81d6b136f7fc35cd60ba2637af64f5195c7a018", - "dist/2022-04-05/rust-std-beta-armebv7r-none-eabihf.tar.xz": "c4913f09cc858f0f2b9870f12714de055e1658b4b708ec78a1cc14428e72912c", - "dist/2022-04-05/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz": "64ab028aa4d304c7a4a09bcaadb45f094f3c76fd17eb72afb29cc57d127ef743", - "dist/2022-04-05/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz": "4e2de3902e62ced0910bcc63d425a06e46c003ebc7111d0308637385817582f2", - "dist/2022-04-05/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz": "8847d73f6da535f4cb700c5da8e9f330710663cd8486bb014c0c67dfe238237e", - "dist/2022-04-05/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz": "85568b12784c98a331ccf6e2719a6d56261356d87a1142e4a72b9f7438a82380", - "dist/2022-04-05/rust-std-beta-armv7-linux-androideabi.tar.gz": "825fb7e878534ac9e3c05240ba52110bf253602cb39aba8aef31f54695d06cc5", - "dist/2022-04-05/rust-std-beta-armv7-linux-androideabi.tar.xz": "8ec0897de57b4e920a2419aa5af36fe421276306e61e6e0263f056f6769ff0b0", - "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz": "6664d7becfe4bcfda1e86eccf3f20cd549d9b7f3d3fc72f70f53da36a91016b8", - "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz": "13da845aab759efa0e690731beee1a51d662083aac6bb03451501bd21332397e", - "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz": "fe311715bee972d5b5ef669c93fa9d5d39a6ff5309d9f82150c0f3be72222d3b", - "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz": "e2937e4c67a6e5af57e79149d8595a24a6114bc877cd13dd568e719dce28162e", - "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz": "24209ff3a9431b58f0f7846a8f673c81488429efe6947049ac9c19523d071d83", - "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz": "ed1cde412c615ffa422f27cf347b8276c68281528cdd6d2642f290ccfbdf2ba5", - "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz": "b028af36212e244ce2eaf213bcc68c52783425a982465d422202fe2d1ad806ab", - "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz": "5b4fe3ec165f16cb29d7660b762ad8de84d9c56d9cac90b11d521de3162485d4", - "dist/2022-04-05/rust-std-beta-armv7a-none-eabi.tar.gz": "2cfab91a43151c6680932212732f4bb689dd93a7252e08b291ec56a02ea7642f", - "dist/2022-04-05/rust-std-beta-armv7a-none-eabi.tar.xz": "503cb200deab12a4cbe8f907823d1e3b63bf2729d1a878e7b7a3d495415f4036", - "dist/2022-04-05/rust-std-beta-armv7r-none-eabi.tar.gz": "b4b756f4c8100a377211cc74d5040fd23bb0231b45841fc8929067f8435a3871", - "dist/2022-04-05/rust-std-beta-armv7r-none-eabi.tar.xz": "44de1090cf49659dd983c081af9c675c9d24721e7510c2748f50befd92810c6e", - "dist/2022-04-05/rust-std-beta-armv7r-none-eabihf.tar.gz": "d6bca5dbb5f985b4c3a4b917311e3ceeefc3ba43fd6b4416b1d07136f405e47c", - "dist/2022-04-05/rust-std-beta-armv7r-none-eabihf.tar.xz": "4f9acc7d81e54d6a725d69bbfaaadb10a0bf4481495548513ff0b96fb3b4f85a", - "dist/2022-04-05/rust-std-beta-asmjs-unknown-emscripten.tar.gz": "01b157479a25a19f8ff499d3993521c3d1b7920880b247599279c428146d9de7", - "dist/2022-04-05/rust-std-beta-asmjs-unknown-emscripten.tar.xz": "b1393e5f200af7d3bcebfbcffb95a9edbb66005cf9413283884e520cd0105eaa", - "dist/2022-04-05/rust-std-beta-i586-pc-windows-msvc.tar.gz": "4086ce54630c7444d886900877bcfb3af0a33fa9c5770f42172a6963c20207f4", - "dist/2022-04-05/rust-std-beta-i586-pc-windows-msvc.tar.xz": "ada0ff31c61640d247f709964322001ef187ef96864618d225ce66af76868b85", - "dist/2022-04-05/rust-std-beta-i586-unknown-linux-gnu.tar.gz": "137d56c7afa91f9a53191cf213e5f457604a1ee4d13e9132bf730bb5045eedc8", - "dist/2022-04-05/rust-std-beta-i586-unknown-linux-gnu.tar.xz": "985d7efef52c800a839d8cf7bceeaa1ed44863e83596516507c617619ce744cd", - "dist/2022-04-05/rust-std-beta-i586-unknown-linux-musl.tar.gz": "73d9aab23a0674c9816a987ca24c584a75a934ced077e04787161208c8ccc92c", - "dist/2022-04-05/rust-std-beta-i586-unknown-linux-musl.tar.xz": "6c6e1bdc49286fe1dbad8a597902e8ea73c0562057e43d78fec9024cd31fc255", - "dist/2022-04-05/rust-std-beta-i686-linux-android.tar.gz": "6cebb5c0ab887358d2d948d072d3c436e9f987cf482423d9d55364e9416d492d", - "dist/2022-04-05/rust-std-beta-i686-linux-android.tar.xz": "a04b26ae9b558489dcc7abc5e632c0382ebe248803152407b0ca8702ead246ef", - "dist/2022-04-05/rust-std-beta-i686-pc-windows-gnu.tar.gz": "78dad5e34af6dd72549d04e59bf059bb28ada4bc6a2d2396b07b9d6eddc5b1d0", - "dist/2022-04-05/rust-std-beta-i686-pc-windows-gnu.tar.xz": "03cfd3a7b6ac10338cd6219811cd2b9e67e5e40adcfef6c725e14c571c9c00ef", - "dist/2022-04-05/rust-std-beta-i686-pc-windows-msvc.tar.gz": "61df958b515e51e2e44e2130f19a1e2a41e246af99e2ebe73b08fd2203b38268", - "dist/2022-04-05/rust-std-beta-i686-pc-windows-msvc.tar.xz": "aec3ba484f261d9feb4f81525b56b656dac1ad9af584b946dd85b643ee201202", - "dist/2022-04-05/rust-std-beta-i686-unknown-freebsd.tar.gz": "62669de085e1cdd6bebfc0a6ed74ece54807104c67256c75753e3d2269b450ad", - "dist/2022-04-05/rust-std-beta-i686-unknown-freebsd.tar.xz": "7bb82ba3e26bb4ae4558719d474322012cb09b1fdcab570d1d7dc7c3562023a6", - "dist/2022-04-05/rust-std-beta-i686-unknown-linux-gnu.tar.gz": "22324f33d7be09df91263375535ca93d92372b8dfb320df0ba909f333a900458", - "dist/2022-04-05/rust-std-beta-i686-unknown-linux-gnu.tar.xz": "8911af3a77bf067dd9ef4ee556ab2e13feafee33b0bb1c63b3cc1ae80042a30f", - "dist/2022-04-05/rust-std-beta-i686-unknown-linux-musl.tar.gz": "34b7b615bb5ff1bc7910683ae6f6fa7750119a6e0512df945979969b695a5fd0", - "dist/2022-04-05/rust-std-beta-i686-unknown-linux-musl.tar.xz": "d8614a9116f07ca652e15d7809d79ac50228dbf553ed1d7123a3e9d74a297f1f", - "dist/2022-04-05/rust-std-beta-mips-unknown-linux-gnu.tar.gz": "803aec35491c632565c178100ea8803bb90f841cab99453ee726b846b887f7db", - "dist/2022-04-05/rust-std-beta-mips-unknown-linux-gnu.tar.xz": "a85292e8eeef5a2eee4a16d0188f432602893a6bca6d971daebb1bbaa3d7cf4b", - "dist/2022-04-05/rust-std-beta-mips-unknown-linux-musl.tar.gz": "faaf96182517e399d73b7242ad1ba8798cb49da0bed66fdc31aa04eb916bfcea", - "dist/2022-04-05/rust-std-beta-mips-unknown-linux-musl.tar.xz": "6ceb46cb6495a76960e08f041b5595f954a2ffa41b786b951d58fefa6753dc51", - "dist/2022-04-05/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.gz": "0be7806f821b84cf53001964f1985c3a7a5c2df22575ba81e1f925fbf06b6e5f", - "dist/2022-04-05/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.xz": "b71f46228685f926bdb6bf675fb6c0b2a32e28a5b095b7375c5fed2c9067b423", - "dist/2022-04-05/rust-std-beta-mips64-unknown-linux-muslabi64.tar.gz": "55662bfa7ae485b1a2d655179588ec2b5936aae4f9998533559330d382f5731e", - "dist/2022-04-05/rust-std-beta-mips64-unknown-linux-muslabi64.tar.xz": "e58994d0a1b3624c36ba0c547ff621ca3ec331ac0bd3d58222919ddab0beb3ce", - "dist/2022-04-05/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "e0c0bb542516fa0159285e3770a469833ac95ec5fc663d39c3e01906f467b094", - "dist/2022-04-05/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "21ef3db32ea221d631c0a81f5034fb63e8bf76f7f39c1957c5d16929bd64bf17", - "dist/2022-04-05/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.gz": "ad3da919ca0fcbffdb84ea8f415bed2a2fb2f61e816aaaf28e8854a9850103f6", - "dist/2022-04-05/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.xz": "cb02f50e74534bbd805094b1e83c35d0a2e00dcbd75dd85f3517774f42e8fe1c", - "dist/2022-04-05/rust-std-beta-mipsel-unknown-linux-gnu.tar.gz": "64350c36afa85b35b02dc1255fcc09abf2592e08a05aa0ea67794ef13442dcd8", - "dist/2022-04-05/rust-std-beta-mipsel-unknown-linux-gnu.tar.xz": "894e0337a31935a13d26d2710a70b4526e1caa26aa0c9cd37981d2569b8ada31", - "dist/2022-04-05/rust-std-beta-mipsel-unknown-linux-musl.tar.gz": "cd5e15813a24234812e4a281fccb76f6aa2110c87a0043d4b5c60fdf3b272701", - "dist/2022-04-05/rust-std-beta-mipsel-unknown-linux-musl.tar.xz": "dea915cd8f79c3d78b063bebd86a9c6e88749f6a436ac16c6dee463bc9504f0a", - "dist/2022-04-05/rust-std-beta-nvptx64-nvidia-cuda.tar.gz": "af860ff78396796a125c9d3029f85e898ac0c0fb738956d5a9fb9432efd61770", - "dist/2022-04-05/rust-std-beta-nvptx64-nvidia-cuda.tar.xz": "a6470fa586262bf78b91bb4b59e6f15c6df9028f4b3aace8589ddeb12dbf7ea6", - "dist/2022-04-05/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz": "9b147bfd00a0f2cd7aeefb67b03cb08b7d2eb2661410dbc3afee30dcb1c7931c", - "dist/2022-04-05/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz": "4791c88990892a0aa3e41bd5e0d3c70a3e08714e0d46c00e58a14944f4be3d6a", - "dist/2022-04-05/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz": "d5ddb7a2ada5c0f10a1cfaa18ed9f454ba044bcc20070be35e104e33eca2a954", - "dist/2022-04-05/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz": "8eaa648476c02b86662d0eb20255d63f49295853733082aa7200e1d22565aa5c", - "dist/2022-04-05/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz": "fecc0c637feeaf867ed63d198169948373dd6b00cecb7c5deb00e2719a70f403", - "dist/2022-04-05/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz": "77932b3620e2a9642b91e7526f0c08f6fc7d96eb1506aae9382b9ceba5098ab8", - "dist/2022-04-05/rust-std-beta-riscv32i-unknown-none-elf.tar.gz": "37b5042d8d1dfc8f0edbd02766b0e47dd90f68a7465cc3f8a2ffb09ef605b11d", - "dist/2022-04-05/rust-std-beta-riscv32i-unknown-none-elf.tar.xz": "73b317b51e033076205f7c7c7c28877fa61e837cadfc97bd1899211c22ab1160", - "dist/2022-04-05/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz": "8f82803e3fd1304c8fc03d49cf9e41e8f7b605f84c94739706e0c7606c448e6e", - "dist/2022-04-05/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz": "1e6b7f7d5732446bfe865ee16183efc30fedfdb9dae45131c8cb59bf683348bf", - "dist/2022-04-05/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz": "beef2e14c29146435c9a3bdfad2a98298294b916672a73131202c72cc697df6c", - "dist/2022-04-05/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz": "f9aab3ca9bb4072a5e2e4682ab23fb5b4a071da7cc8b8e3844a4407e8e33fe6b", - "dist/2022-04-05/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz": "eda983cd1775f24b96b660ef3536f06df30385c40bfec46d8cfb8d35c27763d9", - "dist/2022-04-05/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz": "3168538fc3a537c15c0c994f3ccd46548b14727b46f95f8244e9068e68bb64e5", - "dist/2022-04-05/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz": "6e8681fc5c2b6258b669780438f3d10544a9236f288ae6a173bdd293ab710544", - "dist/2022-04-05/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz": "5abe0a935eaca18193ede75b59780b33c98dcfef2d38e96ea3dda10c30d192f6", - "dist/2022-04-05/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz": "94c55ad771f08611bebbb9395357cbd6001e0c3fe575c9dde2ad683015743cdf", - "dist/2022-04-05/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz": "77fc488d1ac4e4c6418980ec33a82aa0fd1f8c4a58cf14b681037d170bcd597f", - "dist/2022-04-05/rust-std-beta-s390x-unknown-linux-gnu.tar.gz": "5f909d74e47c38cdcdbfe784e78e2aafdfbca5d5cd385c8d0b466628030e5433", - "dist/2022-04-05/rust-std-beta-s390x-unknown-linux-gnu.tar.xz": "cb11de42adff210b131519581a11287ec67740bab4478f16bc1cfd56f7dcfc9f", - "dist/2022-04-05/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz": "68dc6686aa0b27e569d50c5ca0d607d4efe4c9d8990ba87ad8a2aa328dec8616", - "dist/2022-04-05/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz": "b2bf5ba8a83a15dfcc41598f794e3d3c83dbf915215b4f919e07a9047b1ffdb9", - "dist/2022-04-05/rust-std-beta-sparcv9-sun-solaris.tar.gz": "86a21737572edd36cb91e45941923c672252630d195f58fb94d7d8d49b8617c9", - "dist/2022-04-05/rust-std-beta-sparcv9-sun-solaris.tar.xz": "7aec356bec19a94d15b117e774cb42a8eb3564308ca02f60d79b65f43bd36af6", - "dist/2022-04-05/rust-std-beta-thumbv6m-none-eabi.tar.gz": "d755a31f9facef7dbc1476fb803f1bb912a4eabf70facbceaa2c23b5d38a482b", - "dist/2022-04-05/rust-std-beta-thumbv6m-none-eabi.tar.xz": "d62dadcb8bbfc1018937daaaacb28118e63fd7fc539ef62e88cf6e1efe7be0b8", - "dist/2022-04-05/rust-std-beta-thumbv7em-none-eabi.tar.gz": "df0f49f983f0c9d110bdf170643f08d0206e7979cc654bdddd70eac717334efc", - "dist/2022-04-05/rust-std-beta-thumbv7em-none-eabi.tar.xz": "6fe836a2ea7df03c1a88d823cb0557af888b0020c2389bf5027735c9dbccbcd0", - "dist/2022-04-05/rust-std-beta-thumbv7em-none-eabihf.tar.gz": "facb752255f0f86ef7a03d8013cf77221263423658d0dce9b75b94e518947de3", - "dist/2022-04-05/rust-std-beta-thumbv7em-none-eabihf.tar.xz": "8d63d9acd7af3e43bafdbef1953c111f4c13088af4c962802f12b38ae38073b8", - "dist/2022-04-05/rust-std-beta-thumbv7m-none-eabi.tar.gz": "e5e1eb0bd5fc3a5af561dd9bcf0839c53e36672a11c4dec55ade5a2f59804508", - "dist/2022-04-05/rust-std-beta-thumbv7m-none-eabi.tar.xz": "3ee0776ff315bcc48d62ace2aa8f8e520fee1a5c27a75abdb89a5093cbd70212", - "dist/2022-04-05/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz": "83150b0bd0827db25739e21afdc28a571cab9cf528eb7bde39d6457ab26fd28b", - "dist/2022-04-05/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz": "1d24ee3b0e3b34f88c54e76bff867a77a35ce74c055311d82f3bde23cae0988b", - "dist/2022-04-05/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz": "87411b8d0954c450b83dc1b805c94af4cc7907ccfc346e129e5d6909e716cebc", - "dist/2022-04-05/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz": "de9ab4a162f426eba6eb5a355ca0d2d12ba1286599cdc1adc8f4a779e507052e", - "dist/2022-04-05/rust-std-beta-thumbv8m.base-none-eabi.tar.gz": "24ca6e156c3eda6c8c790eb5d7c99e39c4394deb9224b495c90641bc828639b4", - "dist/2022-04-05/rust-std-beta-thumbv8m.base-none-eabi.tar.xz": "00bc42ff2b31965cce526f46ed43301966da1b57b694e4c4e5089928ecd13f31", - "dist/2022-04-05/rust-std-beta-thumbv8m.main-none-eabi.tar.gz": "3ea54fc5075d6f99db9e2d31a92fd000108500017d80cae6e6349e2ea43a7708", - "dist/2022-04-05/rust-std-beta-thumbv8m.main-none-eabi.tar.xz": "8809512122417753d6e72b2ae90637e8b339a3f72a51bd4ad53b3a152a992b16", - "dist/2022-04-05/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz": "bcff8f5e765b8bbfdc3a5c6cb08cb796c90f3435986587b0744d40c226e8f551", - "dist/2022-04-05/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz": "925605849a16cc8e9a0d5ae5b523a321fd7e80ebb8fced627d7ac90845e20261", - "dist/2022-04-05/rust-std-beta-wasm32-unknown-emscripten.tar.gz": "64ef3fc95b97e5dc6a4e70bf383ffaab836a227f86427c8eadb01c1ed1d85a08", - "dist/2022-04-05/rust-std-beta-wasm32-unknown-emscripten.tar.xz": "377aa739f9c9aec814031b260def0629b87d932f06bedbc6cff9c997911c7263", - "dist/2022-04-05/rust-std-beta-wasm32-unknown-unknown.tar.gz": "2f8d832b5cbcf8072e5ebccd5d569b351a3265aab0ac60f580fe326def9f40a4", - "dist/2022-04-05/rust-std-beta-wasm32-unknown-unknown.tar.xz": "4b6582d922280377297412496e443becae006a0c7b170dec0b75885322615876", - "dist/2022-04-05/rust-std-beta-wasm32-wasi.tar.gz": "31487c5f709ac9bb89bc20215cb806b5c83cc604f6fbf858939c7f1be9759a3c", - "dist/2022-04-05/rust-std-beta-wasm32-wasi.tar.xz": "712f2663bfcc2e67a797390a872e2d440f24474c92644818667b2bf741f938e6", - "dist/2022-04-05/rust-std-beta-x86_64-apple-darwin.tar.gz": "120f9ce8080d7fb25d50f0a055e708a14570c6ec98543008580c72d0037fb1db", - "dist/2022-04-05/rust-std-beta-x86_64-apple-darwin.tar.xz": "969c54f4aa028ad51087a41b556d6692b02ae240b805cc0a6d52cf0f4a5ae2b9", - "dist/2022-04-05/rust-std-beta-x86_64-apple-ios.tar.gz": "6a6b2485d5e012e53345a777b112c94563e0c8ce28845a8c68aa04b09196b59e", - "dist/2022-04-05/rust-std-beta-x86_64-apple-ios.tar.xz": "58a8643415ba08bda6cff638012de2b2d3d3d8c953808006dda74f65efae8210", - "dist/2022-04-05/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz": "c757c0e207d77edac9305714e056984affe6e97d6fb59a7b70dfe62de39458a1", - "dist/2022-04-05/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz": "561bb7ddb8eb5cdf33e4608f772c2a021504d0a9eb73536c66b30095545da05d", - "dist/2022-04-05/rust-std-beta-x86_64-fuchsia.tar.gz": "d8fa9b75e173766ecafe150aa8162860dcf93f2340a5dad5fa2529619a5ae05a", - "dist/2022-04-05/rust-std-beta-x86_64-fuchsia.tar.xz": "182c4809af23b0a0f6a0d3ef5f9f7f4cbd846ecc62d459f5aef840871f9fe7d5", - "dist/2022-04-05/rust-std-beta-x86_64-linux-android.tar.gz": "44f09c699a1543581bfcbea834b654dbd165826d80476d6bf4fa3cbf4e90dff9", - "dist/2022-04-05/rust-std-beta-x86_64-linux-android.tar.xz": "6c019c7ecaf340f27b42a87885e4918b736f9a8ef139773092a33bc42d8f27cf", - "dist/2022-04-05/rust-std-beta-x86_64-pc-solaris.tar.gz": "fff1f8b4192be1bd4f701b356094c0a5ce3fc8da4878d29cbf6dfb7476c371f2", - "dist/2022-04-05/rust-std-beta-x86_64-pc-solaris.tar.xz": "b8991973df37f86ccb4c09082caff85f7ddae365d2fa554db6ba26795b263051", - "dist/2022-04-05/rust-std-beta-x86_64-pc-windows-gnu.tar.gz": "fdab2938d8f835dc6244b8aae81989de11c46adb413a9feeca11986453dc5f2c", - "dist/2022-04-05/rust-std-beta-x86_64-pc-windows-gnu.tar.xz": "4d860de3ff0b5327736d23296365bb65761b4c14dbbc683201286d9fee2fd58e", - "dist/2022-04-05/rust-std-beta-x86_64-pc-windows-msvc.tar.gz": "b0e1942912bed10275f65bd525971a7c5fbf03c92bb3a3d2934b35004ca9f109", - "dist/2022-04-05/rust-std-beta-x86_64-pc-windows-msvc.tar.xz": "40ba2150b24081cb1a1268c196fc27a15d771cda3136fbb838d6cfa8535758bd", - "dist/2022-04-05/rust-std-beta-x86_64-sun-solaris.tar.gz": "4d4a43484120e6c0cd46ad66f2c3b9bb46532d8cedb3d899e11aa575638bee2e", - "dist/2022-04-05/rust-std-beta-x86_64-sun-solaris.tar.xz": "546cfcbc48405ea55f702866e7ab2581dcf99abf3d38d97a8736db5ebad72eda", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-freebsd.tar.gz": "dc84510940fd620db639ebfb127e398adbbb13639979cc8855d4a8485363da52", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-freebsd.tar.xz": "d457f1c09dd446e30e94e4bcb1e3b5fde9cc54080cbe5e0a329ee810ab07d312", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-illumos.tar.gz": "1e6b9a255ece3599af1614f47a086422632082ab2e4dd8382f4a23c48865bc84", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-illumos.tar.xz": "7420f5442c1835830c93340ed4cec54c58a104978b54fccb80c4015b9614b9bd", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz": "b3e69ff8e1725c8a0b61c79be8d2f2d396cda1dd13d2a3d1f87667ca426253ed", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz": "beaff8b113d35826c062d7c7f76b773e45d0e878e059c42de5411406906368a6", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz": "bc27fd39c6e67451235aa8f14bd6f4a1018379cf52131ab3924134d6294ea54f", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz": "4b2ada52b6bd53e786cd5494b6bbbcbc8d7ec6812359b4d1a1a5a25c64e190f6", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-musl.tar.gz": "7f1464a804086c7709d5198abde76f6470fd1c36fdebca664e41ebaeeff8b1a0", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-musl.tar.xz": "6c570824abd6478c104a55147d6d54e6b785222ea15ffd00c59caee373a78bfe", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-netbsd.tar.gz": "17c6e9204cfdf32fb8db4a7ade73dda300a35c515fc017804593d76590f537d9", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-netbsd.tar.xz": "738f9f96914b20a9e97195d75bc806563fbe4554dc30e02fda58dece420a2790", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-redox.tar.gz": "f0846eed5e5692deb83d01ea36792691232b2449f430c0433375e13efa014142", - "dist/2022-04-05/rust-std-beta-x86_64-unknown-redox.tar.xz": "2ea808655537de27b207fb61b2245048d124cff21edd52ac388838fcbd1d13c1", - "dist/2022-04-05/rustc-beta-aarch64-apple-darwin.tar.gz": "ee587d1e4f90b0662ca8fd845b5b945b5bdeaf09ef51a48c082ccd5ad5582060", - "dist/2022-04-05/rustc-beta-aarch64-apple-darwin.tar.xz": "4d7f7800088d21ec7450a7b7cfe1a00d10ef832919895b7eadd948cc60c2ea51", - "dist/2022-04-05/rustc-beta-aarch64-pc-windows-msvc.tar.gz": "2e96658cea6c5dd9a05490a2a03062e9faa8a19dc359e0751e36834fe0ef8d37", - "dist/2022-04-05/rustc-beta-aarch64-pc-windows-msvc.tar.xz": "401257ac9451f86f2a8306805dffcc77b2d02d2957c2509e7397d640c650a971", - "dist/2022-04-05/rustc-beta-aarch64-unknown-linux-gnu.tar.gz": "8ed21a78a71fcad7ef9c37d5da5f6bfc728947b036996ce280f49076526d41a4", - "dist/2022-04-05/rustc-beta-aarch64-unknown-linux-gnu.tar.xz": "cf81292f92477f22220feaf07d4c151ef59a6f3fc73770a52ed02064cca3eb65", - "dist/2022-04-05/rustc-beta-aarch64-unknown-linux-musl.tar.gz": "8d64fa488a87a8bb8a7ac4bdf4cd5bf258e5231b98b84361199ff414833ba354", - "dist/2022-04-05/rustc-beta-aarch64-unknown-linux-musl.tar.xz": "4e1ccc5114bbc888a382db706dea497e9a5cfe95de221fc5ddb07942de804964", - "dist/2022-04-05/rustc-beta-arm-unknown-linux-gnueabi.tar.gz": "bead69bf19b04a5dfba77da2831e034224cf87d91867c4f14abdd4c0efdf862c", - "dist/2022-04-05/rustc-beta-arm-unknown-linux-gnueabi.tar.xz": "cf5f6849862fe528ffa3f7620d04150b3ac034ee985bbd0a45d6139e14b1314e", - "dist/2022-04-05/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz": "21d2f05ec33cf2c11359e785a74ee2997076f8aa11777e241855266f6d7b68a6", - "dist/2022-04-05/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz": "299a57e0d25333e1de955a12c69f1cd97da6163ebea681aba4a52601b08d7b26", - "dist/2022-04-05/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz": "f7460821d2f4289e72f4be807a72c16ac61496bf5732b3c846f6b6e8a43fd669", - "dist/2022-04-05/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz": "da22ccbaafafd05b18587c1c33ea8c12c083129d4accdfe728c32a9c341d8b12", - "dist/2022-04-05/rustc-beta-i686-pc-windows-gnu.tar.gz": "7be21e73f6d48e0765c102f2dc5b2e3ce57f00e5f9dae6cdcc354b7444acf6bc", - "dist/2022-04-05/rustc-beta-i686-pc-windows-gnu.tar.xz": "b964692919697ec8d5d8d4d4b41579d9fa805ce93c5efb56c3106e5c223f86bd", - "dist/2022-04-05/rustc-beta-i686-pc-windows-msvc.tar.gz": "629942cacf1ab50e5273de51bb786c4258f4efe83748180c27caecbedae6e2c8", - "dist/2022-04-05/rustc-beta-i686-pc-windows-msvc.tar.xz": "7a3b57b8f34c5ea10bee2142edd625b70bd8765761593da9fb0ffb76f30e0e7b", - "dist/2022-04-05/rustc-beta-i686-unknown-linux-gnu.tar.gz": "7cae7e0c0690f302064b768ef7daffe500a7b8767c1ea985d5f9706f41137f5e", - "dist/2022-04-05/rustc-beta-i686-unknown-linux-gnu.tar.xz": "74395a6013a4589b5d39af2d5780c8bf6420256d7159030f248f584bfec018b4", - "dist/2022-04-05/rustc-beta-mips-unknown-linux-gnu.tar.gz": "cfd2fe4c26207346f04d6c4e2e8dee1c9a42fef6663b6eff1029f30c06492efc", - "dist/2022-04-05/rustc-beta-mips-unknown-linux-gnu.tar.xz": "aafea47e80244a136f87640e0b482898362d73a8b4f80ebcf6a539a268713350", - "dist/2022-04-05/rustc-beta-mips64-unknown-linux-gnuabi64.tar.gz": "0d23c8b6e50d1788b46b45c7df4720076829cfe45a926edece8b99223ec02f35", - "dist/2022-04-05/rustc-beta-mips64-unknown-linux-gnuabi64.tar.xz": "89a452f3820732daa166adc30b232261b86019ded316efdb42266b0bbaa09957", - "dist/2022-04-05/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "30ba547c1e6b802b99d01ebbab93e7209a9abc701174079fd8f4651146926545", - "dist/2022-04-05/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "172dcf58d1b68b56ad28dc00571a31457da8e9cd9a02be0a0eb816924ef5617d", - "dist/2022-04-05/rustc-beta-mipsel-unknown-linux-gnu.tar.gz": "829459c4f165c80a8009c75860122c93dfbe7984b0ec4517a605973a82f86e42", - "dist/2022-04-05/rustc-beta-mipsel-unknown-linux-gnu.tar.xz": "46c50f7d1e84abcd31160de933be9a4557da5e141ee60e84dfb8bff5fc99efd5", - "dist/2022-04-05/rustc-beta-powerpc-unknown-linux-gnu.tar.gz": "313bf23cfa02982a59a2fed4301af0abc787969a493e437124a7bde76e73559c", - "dist/2022-04-05/rustc-beta-powerpc-unknown-linux-gnu.tar.xz": "c5599b35c68a06c16d7a467b4a7fbf4584b4e4ec2ef6ce8504e6d2cc57ea78c0", - "dist/2022-04-05/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz": "29d148d3b71f344d63d4fc8ca3809ea11dd4de58afaa0eac11047ee7772f7690", - "dist/2022-04-05/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz": "c5614d7fe9c4a388d7e5902ee37aaaada479ff3ba0eebb63f5539fd83b5200ae", - "dist/2022-04-05/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz": "29ce9644866ee2bbcf60668efb389255081b9c905ab1ccb34781c4b4258b5964", - "dist/2022-04-05/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz": "98eb0d3a369a39ba71b10c140986305c29fe56f79cdb3144e5a6d1eb9cfa6a82", - "dist/2022-04-05/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz": "0a510b176d2583b52873ca444122e8aff5b17183d87eb984cc3042b70125f685", - "dist/2022-04-05/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz": "85231536c338281263cf9f4f9fc4c4148f0ad87e436b368a13e45bf75dab382a", - "dist/2022-04-05/rustc-beta-s390x-unknown-linux-gnu.tar.gz": "c998a37c27666f5eab87133df5b2b5f6c636df0375321a2dba149f8375bb2adc", - "dist/2022-04-05/rustc-beta-s390x-unknown-linux-gnu.tar.xz": "50551f01002b91c14bf6e9232555764594e041fb3953b2d4c64ed48e904dc8f2", - "dist/2022-04-05/rustc-beta-x86_64-apple-darwin.tar.gz": "9dc62cef50cc1af0e5b790aefb475ab002a3e6e9abfe449bbd35c33c0e2694b0", - "dist/2022-04-05/rustc-beta-x86_64-apple-darwin.tar.xz": "088b67dcdc7bd2b79b438666fc1013d7fea31d603d50548dceddbdb6149f1c69", - "dist/2022-04-05/rustc-beta-x86_64-pc-windows-gnu.tar.gz": "95ecf36825fd88d6f7b1717248a8dd1863c8e249af69d66594912964c4b9d06a", - "dist/2022-04-05/rustc-beta-x86_64-pc-windows-gnu.tar.xz": "3ea5b4bc1e4e07e45a01df5519bd905c99726a0962e984059ad500243061f3e2", - "dist/2022-04-05/rustc-beta-x86_64-pc-windows-msvc.tar.gz": "31f9226104cc55f67ea01db73a76e631937dee4e8b7e9561cb199cbbb02b33db", - "dist/2022-04-05/rustc-beta-x86_64-pc-windows-msvc.tar.xz": "b054a6eadbfeebf1d8ccdbad8f323e65f32830095aaf512df80e65ec63900480", - "dist/2022-04-05/rustc-beta-x86_64-unknown-freebsd.tar.gz": "17774e9e0678f1825b92fee1e9bed6fe56c8baf76ee43c9608b13985359f2911", - "dist/2022-04-05/rustc-beta-x86_64-unknown-freebsd.tar.xz": "5b461322da60b08554f2557deb69485d3991abf13b75750a307c004d6547a42f", - "dist/2022-04-05/rustc-beta-x86_64-unknown-illumos.tar.gz": "404e9bc04cc7330989d34cb8597814ee576ceee31fccbb932576171cd0dc2fca", - "dist/2022-04-05/rustc-beta-x86_64-unknown-illumos.tar.xz": "5fa0cde302fb7abe148315116f5a499a76971d7bd7353043f1a4361510030a4d", - "dist/2022-04-05/rustc-beta-x86_64-unknown-linux-gnu.tar.gz": "a38030a213dc78b5030c03e40f1e6d533518e89fb88eed4632526c9297c7bd45", - "dist/2022-04-05/rustc-beta-x86_64-unknown-linux-gnu.tar.xz": "8595bf3845f559a9f7ddf63807ac535739592f4b61a62b028b63dd3db812fd6c", - "dist/2022-04-05/rustc-beta-x86_64-unknown-linux-musl.tar.gz": "c8184f26eed43d4d059f0d39eb58da781ac8cd1546ae26be55d5e4aaf617bfc7", - "dist/2022-04-05/rustc-beta-x86_64-unknown-linux-musl.tar.xz": "2cdf12d740ec570ae6999cb1334b84c24b5a5e4c0a97863b6085423c814caa93", - "dist/2022-04-05/rustc-beta-x86_64-unknown-netbsd.tar.gz": "24bf12c22c765678cf4ea6860b3caaaccfd2762f473db40a6617a377df11b098", - "dist/2022-04-05/rustc-beta-x86_64-unknown-netbsd.tar.xz": "64e3a7fd4027e3c93a147196b9ba1e0a2d43f1263d053c71e179fd2529c66a95", - "dist/2022-04-05/rustfmt-nightly-aarch64-apple-darwin.tar.gz": "63a0c7abc8a755a6946a7f17dcf04ee925f138d1c50d2ccce9ae8af53526d95f", - "dist/2022-04-05/rustfmt-nightly-aarch64-apple-darwin.tar.xz": "a1ecb5efe8f1232336f9f8c0d3b7ed87d6de64ec8ec11f1aca0cc08ed46fef42", - "dist/2022-04-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz": "fdee076495e8314a4b24de97736da154eb5db6dcecfe629153a05dcd903e9b45", - "dist/2022-04-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz": "5d845c73478bc38ab42fb16dd138b82c8a44fab6b0787b5635140eb418516b79", - "dist/2022-04-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz": "dec1f8535a8edee8aaade80c87dacad690c0a158c4775ee0c9d9e580e1ea47bd", - "dist/2022-04-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz": "2b91b40a7b2af113210b386991c966758da6defab7e6c5c610574496513ab5ed", - "dist/2022-04-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz": "85da42f4c758c88418f952dfe919b8eeba654ee75c72d87f2d56257fb2248efd", - "dist/2022-04-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz": "0c4aade052166886439598db875872efa8fa5b2aa49e27271f57cec68e6a464a", - "dist/2022-04-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz": "44312f3a088159f78f6cb5e6518aea2727d61681b8a37d71bc414fd1310d1160", - "dist/2022-04-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz": "1cf420d4c8e8af78d5bd5aa95e662182c7a90a24e549cbf23f59e7444b0e45da", - "dist/2022-04-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz": "019fa75361e72cfd813c4ba9be8d48774a4a0cff1870b0e343278527dc62dedb", - "dist/2022-04-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz": "1be1e449ef8c299ef269baeba36c612746afdb16d59d9af8575ef67d5a4a4a3a", - "dist/2022-04-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz": "8a03f3f1126fe7312c3e86fd0162ae7ce82111f477c00f7884b47e74776e4192", - "dist/2022-04-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz": "05345ba340c9eff4dc2893438a1bdeb047269a54f66cb2fcfd6f05f5a6706b07", - "dist/2022-04-05/rustfmt-nightly-i686-pc-windows-gnu.tar.gz": "9e5cc2cae5e40b9a964f4f52c20f9566d1d401b696a3eeeb322f34c907eb1d45", - "dist/2022-04-05/rustfmt-nightly-i686-pc-windows-gnu.tar.xz": "db8991874c2f3a1e1ab92c2160cda4c9b1b567fd7b73a610f071e3a59682f585", - "dist/2022-04-05/rustfmt-nightly-i686-pc-windows-msvc.tar.gz": "4729ed2d654cc84e4afc4cdbad7a2609783c2e01ff1442aa2b7209cc1793eeeb", - "dist/2022-04-05/rustfmt-nightly-i686-pc-windows-msvc.tar.xz": "1c92a4124af30627a44690177dfb9a47aae9794bb2a6f22dd0171c4d0740ce7d", - "dist/2022-04-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz": "4efb1ceabe3387eb9cb6663718ebef3cdcfc401ebd57557a1f71075c82db5443", - "dist/2022-04-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz": "1485487c0fe779ea52c387a41776418f82649bf11dff56c65eebc9836c447741", - "dist/2022-04-05/rustfmt-nightly-mips-unknown-linux-gnu.tar.gz": "83af3e32a9e04e89fc0db69c96ee4de144464fc63daa9c15b5339b2b98dc29b3", - "dist/2022-04-05/rustfmt-nightly-mips-unknown-linux-gnu.tar.xz": "6cd906bfac78de1ec92a53ddee54fbaa437280c413411aae678fd87db9df11c6", - "dist/2022-04-05/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.gz": "00bd1e70d9cf308fe4b48cae7188272068d8f98e782e40c74d6e1af20dad3984", - "dist/2022-04-05/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.xz": "51b3192cfa8a9ad4e6981a6fc7a57fd50059d3182e67425a1c036db37b67c1c7", - "dist/2022-04-05/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.gz": "b81e01d392d4d498be39b99ba4cbf24324248647d15eb470526421954596f2bf", - "dist/2022-04-05/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.xz": "e8c6a23e762c4f81030e8c7449e0d49fb60c058893e4ca2110012db8d4a9be43", - "dist/2022-04-05/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.gz": "64e38687c204feb1dcfd19aec7af93cea724548d5c1e74b38a69a29017c6d721", - "dist/2022-04-05/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.xz": "0bc3ac22801cdd0fd6e71d172f61cc3249c6e61b6333e748eb47624d4ef60748", - "dist/2022-04-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz": "9d03b1724dbacf126f626abc9c71c4461f75f6b1c71c5132c1ab1b4ae39363ee", - "dist/2022-04-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz": "3fda672627eaa0f69d7492f55cae4d769bd421c671a74960d77bfd5021dc71c7", - "dist/2022-04-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz": "265c0238b9878c454d65c361968d63b6d55b69f82adbf27fc626d333d093c212", - "dist/2022-04-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz": "c50dc03c50d8e0222c959867f621772e7cac5df72d4487f6f6082898ed1fd1b0", - "dist/2022-04-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz": "3b28fb9c8b8050fc3a06a4591bd90c7c2a42859aa61177572f60f1fed0bbd46a", - "dist/2022-04-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz": "2153976482c3bb6babf8602d7751a4bfa99ee96397d42efb91c38652e652bde9", - "dist/2022-04-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz": "7c2fdd326f5ebfcb7ad3c732954c2ca34191d40422eb7b318331219d282f34b7", - "dist/2022-04-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz": "38fe0ede661a71ca4010359c9e6d8c4656c2da4e13dbc9c7cd0b98481406bcd4", - "dist/2022-04-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz": "4b682444c300d130087d77ab595fe829d1cfd4d08bc22aeda4042ad818b0402d", - "dist/2022-04-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz": "c9d39631dae71e15702b194b7f4dd3dced040fa731dd2f8aeb892368f3637cbc", - "dist/2022-04-05/rustfmt-nightly-x86_64-apple-darwin.tar.gz": "ee7c5a878da4b33761eb2991792833da41673d5bd5916ad8aefec83350e9cf3d", - "dist/2022-04-05/rustfmt-nightly-x86_64-apple-darwin.tar.xz": "54147e40db10a73e22d6aa20b40d5cd64c79b0b1afa57758cbd6809bd7ba62a0", - "dist/2022-04-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz": "e019b5a55a66755794f03eeadd927cfc839a2745c5865c5a53230bd5a961a296", - "dist/2022-04-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz": "a7c0a92a4e34e2bb3d58166525bf10a400b643a0791b352b29ff25d8eee9a842", - "dist/2022-04-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz": "4a9f16df3b8bbd38d43a1a585c29ba5b95dd7d60e4ee6df3063fdd36d1b64acb", - "dist/2022-04-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz": "4af11a257914be44e8aff5e6d0e586282b12b52f326ecc95d2c58a921154606c", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz": "06cb18eb062ac90f1d77f2b0f09d0220a265790e0b80c3549360eef72af14dee", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz": "37b671df4350aa5320174965eac84e05063a35dc0549f1aec035724fff143f0d", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-illumos.tar.gz": "4949b3846cb5dfd7e52abd081631397d7614c16782b8f4eec90aefdac927dfad", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-illumos.tar.xz": "35a92e775b602d21d23bae702c5ac0de2c9eeba1da6e009084a95b448af8a689", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz": "f595603b8c255486801e62716133fa8460b63130e94a5c935dd48ec1189b1074", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz": "dc67ea19eb872659763784b716b8d264e654db5897d2a6766810623605af94b0", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz": "3e969a8904fe06c1299534d5bb334dea7b9b45321a155d189f2ab6c0781299a2", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz": "b7a8f67c8da8c148bf1c33df7bffc76c8c3ca430d4e0ab8c4b261a2aaa98dc67", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz": "7b0e15340585812b597a68c5e6ab778346db3de5d6af7c41fa0cb710e6bf130b", - "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz": "9fdb4e1e5afb2c3b110a605383ae2da844e1a5d87285a2475af4bf8d8dde5291" + "dist/2022-05-15/cargo-beta-aarch64-apple-darwin.tar.gz": "931663cf8152d1d7b901f8b19bb768859ce5514c4edeaa09d081a2799e4d77f0", + "dist/2022-05-15/cargo-beta-aarch64-apple-darwin.tar.xz": "53fac222672e063fbb309ef60dae6c8ed999b947d05a04957ed217ddd17b45dd", + "dist/2022-05-15/cargo-beta-aarch64-pc-windows-msvc.tar.gz": "5fd4140963b6678e2ca09c0b83f9931a6a84e1fb13c66b1461e86012361777c0", + "dist/2022-05-15/cargo-beta-aarch64-pc-windows-msvc.tar.xz": "f8dedd6157d5c971cf8f4435d666ea745b9757115556fd764ce6fd0a6eb992d4", + "dist/2022-05-15/cargo-beta-aarch64-unknown-linux-gnu.tar.gz": "48f1b488b7d28c16192360b465facb10c6f4b0f109f5370a2e8baea16c23e415", + "dist/2022-05-15/cargo-beta-aarch64-unknown-linux-gnu.tar.xz": "b3b515bead06578a2fb7fc00e7151fb2a105a13095c2b6f438dd2134975754ae", + "dist/2022-05-15/cargo-beta-aarch64-unknown-linux-musl.tar.gz": "a44f1aaf0076e15d7d4ed96c267b5875a2d5a28686130c65d4597ab157a66f49", + "dist/2022-05-15/cargo-beta-aarch64-unknown-linux-musl.tar.xz": "65d47b5eb5a76fa56e8614309ff5db6ec9b07a6dd35af6c51507b5d196c007ae", + "dist/2022-05-15/cargo-beta-arm-unknown-linux-gnueabi.tar.gz": "33ae8617706db5e518b1db53be4543fa26ccb1518695e803511975e427422119", + "dist/2022-05-15/cargo-beta-arm-unknown-linux-gnueabi.tar.xz": "cb27f1a27279332c936c7f59a7e71cca16620f27dd99727e34487d0471f7fb41", + "dist/2022-05-15/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz": "4ba2a633b72b21205ca84120d196fb05891d71ddf84d7f006c0d36df4f7aec16", + "dist/2022-05-15/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz": "011687d1804e220b5b9e7eb8c61ab075605bc433470f6601db624218fc082b61", + "dist/2022-05-15/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz": "269d55a027ae7bac5b4db77ac61d449f8d05c541dd9595841a42b10c9c5efbb6", + "dist/2022-05-15/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz": "83dd01e269cf3ccfffa3bea6677d7de9d8edef8baa86a350af0d30e6f5fe0408", + "dist/2022-05-15/cargo-beta-i686-pc-windows-gnu.tar.gz": "46a8d011ff65055753b3d2a50a7134a360b89d39928ae7caabb52eade492aee4", + "dist/2022-05-15/cargo-beta-i686-pc-windows-gnu.tar.xz": "7c302975604b591dac901b7d4f9d5c204e0f7cfe8eb38dd2c4695d8ad7bc2340", + "dist/2022-05-15/cargo-beta-i686-pc-windows-msvc.tar.gz": "32a1d89d3f44afb1f649fa5c231b84a088c57bacb3b6a6f36d103abaf17fc5ed", + "dist/2022-05-15/cargo-beta-i686-pc-windows-msvc.tar.xz": "f23bc47c2b5c29697f6b360aa8b0660a50ffd4a8cee0960709c44bf0c8bb5573", + "dist/2022-05-15/cargo-beta-i686-unknown-linux-gnu.tar.gz": "9f6d01148131bc2fac2f30d5233cbc6c0134aefcc4544ed8c16550019783e16c", + "dist/2022-05-15/cargo-beta-i686-unknown-linux-gnu.tar.xz": "d9489a4ef2cb35f77bed204a3b1d1ac61226f39ebe4ce89ac3d9af73c5480e9f", + "dist/2022-05-15/cargo-beta-mips-unknown-linux-gnu.tar.gz": "11f0b817a31bf2021a40b4c1baf1d3a4a83a9a7f518077a6e714dc983f0e6e6f", + "dist/2022-05-15/cargo-beta-mips-unknown-linux-gnu.tar.xz": "e317fd319ae19746c682567ef78ef071e004adf7d1f725336fb6a70fd0c8d48b", + "dist/2022-05-15/cargo-beta-mips64-unknown-linux-gnuabi64.tar.gz": "e0b917fab4565fffaa38acb3b169759a8a3a1df63c8a6bb2bc769e5fcd7d1590", + "dist/2022-05-15/cargo-beta-mips64-unknown-linux-gnuabi64.tar.xz": "8f948b3e678a390e79c6b1eb24da2ce8d30446dfbe1f5afeeeb5eb8e233ea9ad", + "dist/2022-05-15/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "24d1e72887b1b3bddf34b8dcfcff81a0fce41c73c750f22762762a0df92f423c", + "dist/2022-05-15/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "cf29a692eadfe259b59500ba05ab6b43a6290dd1c6788cfff7e8059b62f5c048", + "dist/2022-05-15/cargo-beta-mipsel-unknown-linux-gnu.tar.gz": "7b5d4789723eb41cf8c3c49d2be42049b4f9123c7685402e3168ceba27bd57cb", + "dist/2022-05-15/cargo-beta-mipsel-unknown-linux-gnu.tar.xz": "ca7297df2754c33e029dfae698b31fe4c07f6a708ab2f2264c7d8b0a05b0168d", + "dist/2022-05-15/cargo-beta-powerpc-unknown-linux-gnu.tar.gz": "82e3e710c2203a0f4cbf3f49f414bf9b6f4200af813d474459880ae5971d8674", + "dist/2022-05-15/cargo-beta-powerpc-unknown-linux-gnu.tar.xz": "987af55d7c07a58ba50c423d26fa6019373d0176305494e2ccd380b2251f0b40", + "dist/2022-05-15/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz": "1eb54cce9881eab327de3424a5b0069afb3fcc74589872848f36d90d6417d15f", + "dist/2022-05-15/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz": "d0bcfe665eaa158db9d81b25856f70e9836baaaece11366ee9bae76e6984dfe7", + "dist/2022-05-15/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz": "9bc8f8c4f18f3011d07299e72163dccb20762dcfe1acb163a179519a05302e5f", + "dist/2022-05-15/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz": "72e087ed022a7bbd291daf3961bdc463e15b62847d826f72d2c762ff71ec9f05", + "dist/2022-05-15/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz": "a889d78d3f4fd5f042a7477e700423db488422966eb40cc8ea4ca2f04767d8a9", + "dist/2022-05-15/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz": "28274f9b5281f476a64c400a65faf893fe3edbca0744e882ed17c4c8d14d5cae", + "dist/2022-05-15/cargo-beta-s390x-unknown-linux-gnu.tar.gz": "15fa0b37bf5b51c283b7637024f75910122197df1a341a1c107c2630a909bd7f", + "dist/2022-05-15/cargo-beta-s390x-unknown-linux-gnu.tar.xz": "840de4e0240a21604d237b718790971b97b9e1dfaa738d61edd007c36fd0cf47", + "dist/2022-05-15/cargo-beta-x86_64-apple-darwin.tar.gz": "5bf8bc0f735d6fc778c016156233b8fd2332a5f9c71481cee23e5308bb45f0bd", + "dist/2022-05-15/cargo-beta-x86_64-apple-darwin.tar.xz": "021f7f9d1d3e43069bd3a2402428d45bed5ae7d7974a484dcd68ab767ab01381", + "dist/2022-05-15/cargo-beta-x86_64-pc-windows-gnu.tar.gz": "36b185ce0f08c4c89c8311533a131ba22fbc74e7a4d125f6bdce4ae4e2e77373", + "dist/2022-05-15/cargo-beta-x86_64-pc-windows-gnu.tar.xz": "279889ff01f005bcff9594ba55d9089108f7cd2d63b2117fa82ce910697383a5", + "dist/2022-05-15/cargo-beta-x86_64-pc-windows-msvc.tar.gz": "17a79bde4594574e48a16bbf524758c0a58ccb120d401c00886caf509b27c283", + "dist/2022-05-15/cargo-beta-x86_64-pc-windows-msvc.tar.xz": "05fc5d03c5f069d318b7576935293974866dee7581b94cb35286dbaa8f77d6ca", + "dist/2022-05-15/cargo-beta-x86_64-unknown-freebsd.tar.gz": "001398ed5dbf27afc1c192e5095d961452a2e3a2c6005986d0ca21824cd7180c", + "dist/2022-05-15/cargo-beta-x86_64-unknown-freebsd.tar.xz": "0f1503b4202cd6c4561bfa52b2727388524bdc83b8f1ba0886c8e258de6fb5f6", + "dist/2022-05-15/cargo-beta-x86_64-unknown-illumos.tar.gz": "dae4cb279218ba071d1ca757037888ca52dd81cece07228b5be7bb87123f67a1", + "dist/2022-05-15/cargo-beta-x86_64-unknown-illumos.tar.xz": "c95ce2cdc05a4d1d221b452db93ac27bed8953ec8b6471f0246106aa8ee1b833", + "dist/2022-05-15/cargo-beta-x86_64-unknown-linux-gnu.tar.gz": "fb452e5191233a9d856ffc924fb3d3d0e43c9629e0e5202984d45e454519ebef", + "dist/2022-05-15/cargo-beta-x86_64-unknown-linux-gnu.tar.xz": "4c035237f5b5bb82c938bd2d99e6f04823efef57e7f7568743b18df9ed6a1a12", + "dist/2022-05-15/cargo-beta-x86_64-unknown-linux-musl.tar.gz": "bfb44f9a41910af148ea21ba02508254854f41ebb13efab2dd81321e70c76d88", + "dist/2022-05-15/cargo-beta-x86_64-unknown-linux-musl.tar.xz": "f43a6a3d72402dbb615d1a28e6f18017c7a207ba482c479f37eaaa1e18ec1bc5", + "dist/2022-05-15/cargo-beta-x86_64-unknown-netbsd.tar.gz": "4ab6cd8863c382a62cbde74d8f4bd4a08d7cab022c6b21a189ce411577d0d660", + "dist/2022-05-15/cargo-beta-x86_64-unknown-netbsd.tar.xz": "073b065dbc325562f271fe621823700e0f318e868c0631813215c81bea515d6e", + "dist/2022-05-15/rust-std-beta-aarch64-apple-darwin.tar.gz": "3cc60c7861053739bd6c77d23689ddd0a4a3864f89f7257898d3afb728d9e4e7", + "dist/2022-05-15/rust-std-beta-aarch64-apple-darwin.tar.xz": "3663fd6df9bc5cf589f641a5ade1d330a08619606d9b24a8d45396d705599972", + "dist/2022-05-15/rust-std-beta-aarch64-apple-ios-sim.tar.gz": "d8d2762ba7850dbf2166ab0085b70b17a9a84dfb9579061983b8593b8cc21086", + "dist/2022-05-15/rust-std-beta-aarch64-apple-ios-sim.tar.xz": "57b1ef52a3432eade28b0c8f8bd60365c4be58382306740a3d862155fbb6aefa", + "dist/2022-05-15/rust-std-beta-aarch64-apple-ios.tar.gz": "9fc1e25e74b6e085fa5d5650dd71846a1a48c3d5e1319f8e96359e44a57cecda", + "dist/2022-05-15/rust-std-beta-aarch64-apple-ios.tar.xz": "653f9cf398a793af53172d3fdf7becd69229e7b010a4c56659eb7ece0167b755", + "dist/2022-05-15/rust-std-beta-aarch64-fuchsia.tar.gz": "09ff4fc84566d3a1b84b4f105ed89929f09c35f090b2fcd5b333b32972c56156", + "dist/2022-05-15/rust-std-beta-aarch64-fuchsia.tar.xz": "7d0528e2f112813caaf7fe6d8020ecf9767cffb747fe5d56bea8cba27689a4d3", + "dist/2022-05-15/rust-std-beta-aarch64-linux-android.tar.gz": "a4cf06b2d8b74ca06ac8d3db7bb8264b648b33bd48887f54c2fffe8a48f3d7da", + "dist/2022-05-15/rust-std-beta-aarch64-linux-android.tar.xz": "df13e515dfee5a39db13431aca109fad0bf2b650c5e794432468dc29310e28ef", + "dist/2022-05-15/rust-std-beta-aarch64-pc-windows-msvc.tar.gz": "6f935618e6c11391f75f746e46b8b08f82471caaf975f7bf485546482bd414b8", + "dist/2022-05-15/rust-std-beta-aarch64-pc-windows-msvc.tar.xz": "3bf7588ea5336e4492e50047633e6574b10c9064efd2168e18d9233e9256f21b", + "dist/2022-05-15/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz": "b0c5fcb3af2a09c44bd5904defbabfd9f3227df437b122ff929479cc139c3344", + "dist/2022-05-15/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz": "3bc8c858d33dcf76ec4665c3eb93cde8d3eec917cc384b4e3e2bed411b31c9fd", + "dist/2022-05-15/rust-std-beta-aarch64-unknown-linux-musl.tar.gz": "dfb2c8d6ca07467f75a4a91634912c87c8305c4f9ff2c3237ff955a30d9347c1", + "dist/2022-05-15/rust-std-beta-aarch64-unknown-linux-musl.tar.xz": "ac2babae2bee599d9ea9f929383eaabecf50993502a26f47195d86d273744e27", + "dist/2022-05-15/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz": "37d66eb28251e0a4fca32282ab26e25502e61dc6da5147bf5ce59c2f31d7b284", + "dist/2022-05-15/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz": "f62c76ddb1bc12ea566f06e752a1dc9bfa0122936745b074bf3ff279a83d0973", + "dist/2022-05-15/rust-std-beta-aarch64-unknown-none.tar.gz": "0f3ee36121485d7840fd4eba2c583799eccf3008feed112a0e89dd1ce377278a", + "dist/2022-05-15/rust-std-beta-aarch64-unknown-none.tar.xz": "8415fbf7dfe369a529d02b70c8d79656979790ca4a45ff0a35d098ac75fe9583", + "dist/2022-05-15/rust-std-beta-arm-linux-androideabi.tar.gz": "a352cd8a5462ab18e84b4bc594602e6cf0f29f41d56dfe8b556fe524e2b65bcf", + "dist/2022-05-15/rust-std-beta-arm-linux-androideabi.tar.xz": "7fc1f4315036c98b1c7f6ef9895231bcff28675ec27e5d8203eee2b7038d3b25", + "dist/2022-05-15/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz": "912584b80e9432f43a3a36f7b0b6b5b98263f6a10a926bc6aca17a00804bded9", + "dist/2022-05-15/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz": "327166c179af81f4a5ad9fbd846150c65a7a2c694c21ad68d3f3f6206c150a77", + "dist/2022-05-15/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz": "1694c97dd2c9cc1b22ad9402a69d0f87535aca70accbababb57f582367e55d9c", + "dist/2022-05-15/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz": "4a1832e126319eeebb1ab2a025dab8b4ae7b0474bdeaa789dd3f61d27b77ebd1", + "dist/2022-05-15/rust-std-beta-arm-unknown-linux-musleabi.tar.gz": "7d36909b6d13970e2ead8c34500c9f52e9e51b85d0ca75cc292e51189149d971", + "dist/2022-05-15/rust-std-beta-arm-unknown-linux-musleabi.tar.xz": "9fc925baf53f11a56f2a6ced409f1c275f22985b8b27f83674a46189b6f2dbdb", + "dist/2022-05-15/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz": "58c0a4f2b3ef5b084dca71b4fdc0dffc275e8d04e90240b8da0952be53820dc2", + "dist/2022-05-15/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz": "7794ee2be244d9696a340f13d9b3b104badf522386cec2d4ff6ca7a9e879b696", + "dist/2022-05-15/rust-std-beta-armebv7r-none-eabi.tar.gz": "f870bcc07d65aa7e55beb218fc137c6f6eb45e7c33ea99b4e038f55c5e3b4605", + "dist/2022-05-15/rust-std-beta-armebv7r-none-eabi.tar.xz": "523533f0f2726ec960027b9b225b5e37ebfcfc9083703529ec523a71af261a57", + "dist/2022-05-15/rust-std-beta-armebv7r-none-eabihf.tar.gz": "c55210073135dcfb2c1d64ad067235f4d9b8312441ca264b5eb07a8dfe1ee408", + "dist/2022-05-15/rust-std-beta-armebv7r-none-eabihf.tar.xz": "a283e38f74b3a14cc25e21ea48fda1c2ce48df92824100aa19074d4bab1f8fd9", + "dist/2022-05-15/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz": "c92a162280e600de891a07c374d058ce9e8ba862e00e50855cbbb3d756c3476f", + "dist/2022-05-15/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz": "13db2214cbe3adaaadb1115073db1e17bdfb337814d7a8a56fbb10b693885585", + "dist/2022-05-15/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz": "ce38f33ca996fa10effafd9973a5b7def70754e914034452a77f36d29fca7c2d", + "dist/2022-05-15/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz": "b3340b44408e2b1ca1a7b1cd2b5c951e2caa60385c4b804c6e5e1d0360f63a78", + "dist/2022-05-15/rust-std-beta-armv7-linux-androideabi.tar.gz": "7ac1ebb3841222c60f0d734a0c6aa4f555b31d7de3763cc730b4cc6706278a4a", + "dist/2022-05-15/rust-std-beta-armv7-linux-androideabi.tar.xz": "c3a04f1ff8118b65dad980f54cb7d525593e220973fe7a2f832016c52d19043f", + "dist/2022-05-15/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz": "62ed3c996512c1dca845bff2ab60a83ab039fa12771f811c8bc9de3a00b49c7d", + "dist/2022-05-15/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz": "a5cebdc64d68b54b283b0a70671d05ff6bd4a912f63e6a38a06e68907064c2c0", + "dist/2022-05-15/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz": "da718fb547ea2406d3a26100021a5774bc96cf826ae4dbd7f65d8f59a4e818f6", + "dist/2022-05-15/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz": "56caca78d0df376459f6df8d289148a33054bbe2b35d05e3a7dd3a19d99099cf", + "dist/2022-05-15/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz": "1b929cf4926b58282b70ddcb6d5b0290b42576cfac511037abb8ab61cc02aada", + "dist/2022-05-15/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz": "efb35a3aa6e82cdd5ac97bc5714034db29de1f28a7c3a2df771704f8a452a224", + "dist/2022-05-15/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz": "d22b5f23c4828ebeba32c66aefbfab9ab371e32546d546e6edcc740bdc470646", + "dist/2022-05-15/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz": "3ec719bf182c09f46347c6613f0d9ff2e39347f76c9391153908552376c38917", + "dist/2022-05-15/rust-std-beta-armv7a-none-eabi.tar.gz": "7d3f9a4c03bf6d8ce8ae3952abd69aa43c31da74a3dc4fa63202fd974b9f92ce", + "dist/2022-05-15/rust-std-beta-armv7a-none-eabi.tar.xz": "3f6ec85ef9334cc53bc226db9141c391e1be5218cb3878378cf088de7697404a", + "dist/2022-05-15/rust-std-beta-armv7r-none-eabi.tar.gz": "212415e5de010793a72ce2cbf71798cc4fd611b6dabb39c1ea205e5eef1836e7", + "dist/2022-05-15/rust-std-beta-armv7r-none-eabi.tar.xz": "2babe6e770beb293a4c73bbb1e29476d1f59fda9b85a2465c96f7ef3e614475e", + "dist/2022-05-15/rust-std-beta-armv7r-none-eabihf.tar.gz": "32f0f58fd4b0cd8954c712aac2b7a4c491121a1dd478c6e51f315896f4e99511", + "dist/2022-05-15/rust-std-beta-armv7r-none-eabihf.tar.xz": "f44e04c4f92a2006a952368e9cfbccd6919cb447b58e8f76a4c1b9f1ed9cb038", + "dist/2022-05-15/rust-std-beta-asmjs-unknown-emscripten.tar.gz": "5c521e63d5b4d5383e4956b9287424e562de4314c19d6fb24849fbaee89222a7", + "dist/2022-05-15/rust-std-beta-asmjs-unknown-emscripten.tar.xz": "49ca37f4bdf0f0bd2d42f1a72678153aaafec37f7b90a58ed406b8ff95933733", + "dist/2022-05-15/rust-std-beta-i586-pc-windows-msvc.tar.gz": "b93d7e26939055daaec45800a667912fda2363e3530832c6681bdf0c74a062cb", + "dist/2022-05-15/rust-std-beta-i586-pc-windows-msvc.tar.xz": "96ca5343465a7f732f52deb3677b9cf85c3c101001fd0bfca2850e5439a9e306", + "dist/2022-05-15/rust-std-beta-i586-unknown-linux-gnu.tar.gz": "6f1a9eddb73684574370d4ff0274470585755125ca803079e4c3738957585a18", + "dist/2022-05-15/rust-std-beta-i586-unknown-linux-gnu.tar.xz": "c26b563abc3dc6d77a972f2a9e0d790bccfc810a9e72f8517e0fcfba3ccbbe05", + "dist/2022-05-15/rust-std-beta-i586-unknown-linux-musl.tar.gz": "3394f4b32e7ba37eae9d3805b1ca920aa91d79b695217348de1906c342755188", + "dist/2022-05-15/rust-std-beta-i586-unknown-linux-musl.tar.xz": "1e32eac8b34d425d48e9d91438a17adda573d3f57e76f0a43dc9e2c5d44e0eec", + "dist/2022-05-15/rust-std-beta-i686-linux-android.tar.gz": "488c11d780f44af3ab108523ace9dbaa5148fdee535e05270d70226146cbe3ca", + "dist/2022-05-15/rust-std-beta-i686-linux-android.tar.xz": "eedf8af64ca64b451dcea9617fb112dc6427aebcb51455bf979979c902b916bf", + "dist/2022-05-15/rust-std-beta-i686-pc-windows-gnu.tar.gz": "109b2a0a41e2c7c867d6620c3ca7ae3591e9a0da0c7539069b6b262efda361e2", + "dist/2022-05-15/rust-std-beta-i686-pc-windows-gnu.tar.xz": "5dc4a6dd82091671a2c7fca18fe0f9565424dfde737b1a8cfaa477a0c4a70097", + "dist/2022-05-15/rust-std-beta-i686-pc-windows-msvc.tar.gz": "2a770dcf91f4749a507f2fa5141b0c3c66b699cc21a5459d23251f7785a7dcbd", + "dist/2022-05-15/rust-std-beta-i686-pc-windows-msvc.tar.xz": "cd98928f15d080e2f8170851e6f7965e4b19cd85e8c5a96dc6682c36f34131e5", + "dist/2022-05-15/rust-std-beta-i686-unknown-freebsd.tar.gz": "3192f2e185daf9e5b9eeb03560539c16d72092c45efc0c14bf9353414f18e8a1", + "dist/2022-05-15/rust-std-beta-i686-unknown-freebsd.tar.xz": "e2e959b54a4abdedf9e12bcf9b726090bdd4616202bf45048735393b64e5b6e8", + "dist/2022-05-15/rust-std-beta-i686-unknown-linux-gnu.tar.gz": "9b9064b161eaf12acd96cad07962561340919c6567c04c173d4d6dc799614238", + "dist/2022-05-15/rust-std-beta-i686-unknown-linux-gnu.tar.xz": "c2df74e25f86555b73eecf9492248720ccaeacc7b37a970066748d645c4ef428", + "dist/2022-05-15/rust-std-beta-i686-unknown-linux-musl.tar.gz": "f64400f5fe5e0a5bbf466185ce5d609434c1bbe99535407a9fac5e8f44fa38b7", + "dist/2022-05-15/rust-std-beta-i686-unknown-linux-musl.tar.xz": "9f18402c684cbd11e9b91eb38f634ee061fdbff7feee7c6024a5d91c5a6754bc", + "dist/2022-05-15/rust-std-beta-mips-unknown-linux-gnu.tar.gz": "9ac75b21772312051929cf3dd7fee3a5924aefd0f1d77673f15836ca98db380d", + "dist/2022-05-15/rust-std-beta-mips-unknown-linux-gnu.tar.xz": "e3e9fae8edb565e90c66a69352771aa56f82a2d1f281be112b465746b31c3796", + "dist/2022-05-15/rust-std-beta-mips-unknown-linux-musl.tar.gz": "5305e11f00cce2bf043d37897c35dd9f7630f979e496f5be9ea2fe34cac62831", + "dist/2022-05-15/rust-std-beta-mips-unknown-linux-musl.tar.xz": "d9f9f87c4cbb625919909ec5d4c3a718713c9b1779c150e6d0fed4573a39e593", + "dist/2022-05-15/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.gz": "973e333923d99cbbf51b15f0e224b1136bac14393c0caea28d7be5470e967031", + "dist/2022-05-15/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.xz": "8263d2868eb2deee8a7f3526e934ac502cb0a12e33691fc876e062b5e3de7e24", + "dist/2022-05-15/rust-std-beta-mips64-unknown-linux-muslabi64.tar.gz": "656e2e4e138a4a5aaba31bfaa8eec94bcee1c5ac91f01c3e41975686c5bf4f03", + "dist/2022-05-15/rust-std-beta-mips64-unknown-linux-muslabi64.tar.xz": "9433cb4e2ff2d4f2a680fa21b18f74ac108377754db56cf93293c3ef9db9c683", + "dist/2022-05-15/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "6d10aa227cd495c972422c0cce7e605744a79057df4b63762b416d16ae7db687", + "dist/2022-05-15/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "40763878df8b7312c3042e3fb0ca993af4c601b6817af8f8187d7e70ab3df0d6", + "dist/2022-05-15/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.gz": "9273fb0f6e578ef1e2344f783be40bc7277c70d0dabf45a276b0562a2716cc0a", + "dist/2022-05-15/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.xz": "fd3d514556cfab0159700ee4935b42fad8a049d8becf82f4e3391611317f81e9", + "dist/2022-05-15/rust-std-beta-mipsel-unknown-linux-gnu.tar.gz": "4c25598ff62f2c9b2584fcabbac2afcde0a1376876ce3605de7585b72b87444f", + "dist/2022-05-15/rust-std-beta-mipsel-unknown-linux-gnu.tar.xz": "4a31d313f0a996bba38113a530f5da16cbf40100b18dc5f0de631b4d0a4db487", + "dist/2022-05-15/rust-std-beta-mipsel-unknown-linux-musl.tar.gz": "07958772b033e983d4624552e16e8b7aba4bcadddcedc7c8c3f57ca5b5dc35cc", + "dist/2022-05-15/rust-std-beta-mipsel-unknown-linux-musl.tar.xz": "d55cd4ecd93af0958df506e32718920b1137b1246ca0d154838e2ee18b372489", + "dist/2022-05-15/rust-std-beta-nvptx64-nvidia-cuda.tar.gz": "64e65f32acd561b1b0303661bcff0563371f5451eec8bd11efc287c1db539fef", + "dist/2022-05-15/rust-std-beta-nvptx64-nvidia-cuda.tar.xz": "01e60d037b0771d1588d6232ab5ca21e7a925a85be670208eb78ee460b2129a0", + "dist/2022-05-15/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz": "66b6d3ea076d9b23efe2ad9cf49e78d300d6ea51d8725695688845c4003ec3cf", + "dist/2022-05-15/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz": "6a3c0b48876d496d6610e8932bd105fb4c6775ebf994f3ea123535a97a003ab3", + "dist/2022-05-15/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz": "4d6ace6b44c9c6932c14d9c034123f74bbf0ebdbfb55b78de0cacce35f94716e", + "dist/2022-05-15/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz": "da1fcdf7d4812213ab81084a091bf80e25674a49b24af736a6224a64cbbb9f49", + "dist/2022-05-15/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz": "118671964e8c483e656cbc98f938f23f0ef359a336c494da8774d6acf7422ced", + "dist/2022-05-15/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz": "03cddafe6af3898afba8f97f4d09ae597d2dd9d82383fa5a3f0fb63534057f8d", + "dist/2022-05-15/rust-std-beta-riscv32i-unknown-none-elf.tar.gz": "efea64fd95274820dd6bca3ef929b310bde7744fcd9bb135451964dde8461889", + "dist/2022-05-15/rust-std-beta-riscv32i-unknown-none-elf.tar.xz": "d9264f9204a6464bba25cb5d76e4a1c32b90b55bbffedfe58d0a3b9dc84b3cc9", + "dist/2022-05-15/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz": "5d0b2d2e6417acc7aee36e8ea87dbcd6ce401dd8e892e4163ef3abfa451fcc93", + "dist/2022-05-15/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz": "8f4830ae1de95295a2b435c35374f2ab6f499c8cec15a28a38c6eefb1e418596", + "dist/2022-05-15/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz": "092c4bbc90d1388dd86cacc112ab68b53fa8a619d7ec1c353ba4da872f0b593d", + "dist/2022-05-15/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz": "9348fe3382c9ed79bacb305b654f763779b68515867d7cee82e46db0165419ec", + "dist/2022-05-15/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz": "52df2249e0f73e8b057385ccb74f9913339b4c9a4a1e237936b45962d68e2adb", + "dist/2022-05-15/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz": "4368de63026d8c0c0492bf6c1a651440fdccae53f231673e67bd73da243a070d", + "dist/2022-05-15/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz": "db7ac19cea829f62c27d766ba3048e019954116bcb8e86ccc929d4d15739e9ab", + "dist/2022-05-15/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz": "441003923ca55af35af8a5afdba2aec4b83042edcdde0600322d633f5dd56d8a", + "dist/2022-05-15/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz": "c046e7dd6e31c9367a3fae8f991fd6cde3a9f1e15ce147b72fb43f273218c304", + "dist/2022-05-15/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz": "345933e675d4221981a3a5c6f537e3633d0c16c9c232f4d9aff1d99f2e955569", + "dist/2022-05-15/rust-std-beta-s390x-unknown-linux-gnu.tar.gz": "fcc4c0a8fe9ef58d265b8dbae8e9536da2897e20c33023c1b4e9f2fc8376d80c", + "dist/2022-05-15/rust-std-beta-s390x-unknown-linux-gnu.tar.xz": "a5496de6d3dd01d0da3b62c9291cf6fe38f2637ae32afc0e355bb25c674ffa0d", + "dist/2022-05-15/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz": "1a54eceb33e6556a21fa55b98018ef8ef2f1d714b6c0d34381187bf4d433fa0e", + "dist/2022-05-15/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz": "f8cc960f4beb309cc4d5192d2691f28203173a8167faa8bf726f8ce7678d367f", + "dist/2022-05-15/rust-std-beta-sparcv9-sun-solaris.tar.gz": "8e20288ff6bac2a85a8feaa0c6be488c050ce19861e329344b6796d9780a1b41", + "dist/2022-05-15/rust-std-beta-sparcv9-sun-solaris.tar.xz": "ed28ad90f993b5b5b546d377350c34439a5554371e4946903f963a68ba5ed42e", + "dist/2022-05-15/rust-std-beta-thumbv6m-none-eabi.tar.gz": "a1108a74fee69a25820812addd5c448a6add0911c66a56e310cad70f0df01b1b", + "dist/2022-05-15/rust-std-beta-thumbv6m-none-eabi.tar.xz": "31f45b086ae17e3d08981b9117a1e4cd464254c142d043f14670a33985bc3706", + "dist/2022-05-15/rust-std-beta-thumbv7em-none-eabi.tar.gz": "95ac8ac649231cfbbbf682b1be57cc4d9eab2123b7ae5edbe14f073868b2c963", + "dist/2022-05-15/rust-std-beta-thumbv7em-none-eabi.tar.xz": "880b8a43aa16da212bdf64596d9b900c45a21d5befd63c94f6ef67ad42b5c0bf", + "dist/2022-05-15/rust-std-beta-thumbv7em-none-eabihf.tar.gz": "2da779d7a236cb899b62f53350006a4c8edfb840e11569af61af57fe00189c17", + "dist/2022-05-15/rust-std-beta-thumbv7em-none-eabihf.tar.xz": "d65dcd12d8d2c7e385ef15fa9a914e797f699cefbe2cfce083a397f4d5cd993b", + "dist/2022-05-15/rust-std-beta-thumbv7m-none-eabi.tar.gz": "419062295c0f886d26051253e13e6ab8fd089710e31006bea36b6fe5de774282", + "dist/2022-05-15/rust-std-beta-thumbv7m-none-eabi.tar.xz": "d21d279b335fb6989cd0f5b2a1105aeaccfc9a3d3b64795a8bcb9f17ceab89ce", + "dist/2022-05-15/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz": "18b1e77d88455bbedca324f6802b69785c475d4ddfab641e40eee5d1300a0777", + "dist/2022-05-15/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz": "e7db88016e6ba4c9318a09b32d18b23e9599388324a5d4eebec770deabb90624", + "dist/2022-05-15/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz": "2518881956ed81df2ab852458b6a425f94f03f9f65a14170933438924b709f7a", + "dist/2022-05-15/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz": "6f003f26b8b9098ff7a46fd81c4635f52b4c936f3d2879a0882977c2eca504b3", + "dist/2022-05-15/rust-std-beta-thumbv8m.base-none-eabi.tar.gz": "050fd2a897ceef9f90d803e97de2e19fb7b342f2c9bfc4cc22682f94ce446358", + "dist/2022-05-15/rust-std-beta-thumbv8m.base-none-eabi.tar.xz": "71f0c6fdb0abb009fb53ef0ffba20427323d924b03ba691850346fe232d9f286", + "dist/2022-05-15/rust-std-beta-thumbv8m.main-none-eabi.tar.gz": "049d9a17f156efe44073a57f24201da5afc166b68752894d46e0dd91ddb2a429", + "dist/2022-05-15/rust-std-beta-thumbv8m.main-none-eabi.tar.xz": "76c030a10641819bafc47bd79f866577e89abe0d54565f3640e698e5ce4c59a5", + "dist/2022-05-15/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz": "5b00086c26648dbc64d74fa8a73eac85e5f8ad8712901786aebca01a207fe143", + "dist/2022-05-15/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz": "68a59a7d91a471bb1e3e077089c313e4e1eadd638455ca43b2ad3509b86d530a", + "dist/2022-05-15/rust-std-beta-wasm32-unknown-emscripten.tar.gz": "eee9b448d17f4e69b36d7da64cb4e06fc3860c454ff4f11f44e5076cae6365c7", + "dist/2022-05-15/rust-std-beta-wasm32-unknown-emscripten.tar.xz": "12363fa98e538e5da87f2df4f406606e57f9e44ce59289d86b875609cfa808f6", + "dist/2022-05-15/rust-std-beta-wasm32-unknown-unknown.tar.gz": "4b5fa47f713722a95ffd40d791d886a1c43b060388e09465fa47d55c55d79da0", + "dist/2022-05-15/rust-std-beta-wasm32-unknown-unknown.tar.xz": "f8e1e5384c5a0bad89c137fa8b380d689d2b4cfb71afd680efa2b2ef88757eab", + "dist/2022-05-15/rust-std-beta-wasm32-wasi.tar.gz": "a822e197078750eca42a311313b81b23c5dee6aa9b4ad46afe7f46faad5fc88e", + "dist/2022-05-15/rust-std-beta-wasm32-wasi.tar.xz": "67c1a1a5b538059785bc76322a888f2e07b96da16f470471b3ee07cdb131d248", + "dist/2022-05-15/rust-std-beta-x86_64-apple-darwin.tar.gz": "636d53737ddaadc30392dd22534080e47e08d1e0922125113ec3e2c3d060aba4", + "dist/2022-05-15/rust-std-beta-x86_64-apple-darwin.tar.xz": "a01dc133848b9b19b78664b27254fa3d41e003c509cecc7f59710fc3c440945c", + "dist/2022-05-15/rust-std-beta-x86_64-apple-ios.tar.gz": "191795cb994735ce16f1a5ab5290784bb62c152f27f3b11eaeafceaf68951dd7", + "dist/2022-05-15/rust-std-beta-x86_64-apple-ios.tar.xz": "36cab9d0fc7b1dbd3caf95ca36ebf832f11968467b71b98c7f9882c1de15c71b", + "dist/2022-05-15/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz": "0f64395a7b9bff51dbfd3f6d8339c63c667f86a5653dd66b293e2853904721c4", + "dist/2022-05-15/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz": "f29decc0f726a04cb115bb5df519d08f77f23f5dca2901d98bdd466620c9e9e3", + "dist/2022-05-15/rust-std-beta-x86_64-fuchsia.tar.gz": "47f0fea8cecd49607a726c09efa6fa7d5367e1e9a39bdd194f5362e52fcc0618", + "dist/2022-05-15/rust-std-beta-x86_64-fuchsia.tar.xz": "b6aa688f5726ddcff999545de4429e3d90d93f047de58cf1a28230349b5aa96f", + "dist/2022-05-15/rust-std-beta-x86_64-linux-android.tar.gz": "92e3341a0c511fb50ff3e73f2b1b9854747e3ef8e52e78868f92034f383b1182", + "dist/2022-05-15/rust-std-beta-x86_64-linux-android.tar.xz": "16dde8e0299d6aa8a03ef71794eea46c22af9096e3c3b2da287245ded0d3072d", + "dist/2022-05-15/rust-std-beta-x86_64-pc-solaris.tar.gz": "49f7f5e3acefe885fef77ad623f279298ff801241b52cfd13f262283b7d00f12", + "dist/2022-05-15/rust-std-beta-x86_64-pc-solaris.tar.xz": "80cc6f6275a074aae3e78f3e5f89884bef16ca15c2f0c81a348676ef62d96689", + "dist/2022-05-15/rust-std-beta-x86_64-pc-windows-gnu.tar.gz": "bc874662867c0f11b87ead49b9f0e46505583ad791f13cb7bd66d11b96069cd8", + "dist/2022-05-15/rust-std-beta-x86_64-pc-windows-gnu.tar.xz": "1c5bcb2348ac2a4f8abb5c9e6c25ae49224f341b93f3df537c080c0645f99d98", + "dist/2022-05-15/rust-std-beta-x86_64-pc-windows-msvc.tar.gz": "9d40e38894068547c6755d7a4a2b34cd371f7d976c560b0ab479b197a760083c", + "dist/2022-05-15/rust-std-beta-x86_64-pc-windows-msvc.tar.xz": "1a809e979891ec11e0b3b2fd0babf490a2532a9eef243fe6a697bd8eeedec1bb", + "dist/2022-05-15/rust-std-beta-x86_64-sun-solaris.tar.gz": "cd4302658d02f47b966f6dc31e21fc3e150afdd5471683c78a2e7cb21b1f6dd4", + "dist/2022-05-15/rust-std-beta-x86_64-sun-solaris.tar.xz": "687e1b81bfc6fa1e81f34b84323fe530ca4de841e69b664117471cf0b08218e9", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-freebsd.tar.gz": "edc708ebd4546cb9c53f31dfe90207b0e4e7a8ae59926e585f2f736aef939c46", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-freebsd.tar.xz": "95528eb26dc37e4302a49fe52e0fcb9540f89d2148c42638885c54f1dcc2841f", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-illumos.tar.gz": "8a4440a558724de8da3539a81b82c28a9568818f27157487251447f863597e2d", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-illumos.tar.xz": "a6dc1ddf701027b73cda0a2f481500c5f6f5330fb10cf85dea62dcf1fe2b6a27", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz": "b9448d9f24c17a1f39a28b6a8c93ef3025b379c31ca178a330f6be8e2361054f", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz": "06bbf2f3de0fde2d79c2eeaabb51e6d06bcdd636d1435919ff97be9690638bd9", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz": "7fb00102d9190e2b10618ccd14a9847df49f798c400431d195333ddc3a8c2f54", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz": "b91fc9123982cc5220349fcee974cb64144cef965f4cfb38f4adea0f9854fe10", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-linux-musl.tar.gz": "4df9d722bdb8e30c969bd23b5eb99ca617afa8b7dac85c95f6c6abf00c9a9a35", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-linux-musl.tar.xz": "6ebff034202127c16fa64a866a81de5d6ba0640abfbb3fb9c2f71d7a457f68db", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-netbsd.tar.gz": "d1334f4fe989e99f1571f79a1463d09d18dbc65432336d4bd5df8821fadaf854", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-netbsd.tar.xz": "692e0a547bfad2321cccc99ecfdec14c8536d21a02711025ebf1ac3b1dcbbf43", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-redox.tar.gz": "9acd38f90ca2750fe60a6a6326b8ade6b8205a095e2fbbd471f9da5b63dcad0b", + "dist/2022-05-15/rust-std-beta-x86_64-unknown-redox.tar.xz": "e990289844fb967666bebc5815cd9efdfe7d8b0e493cbe5f0d22c47c6f2989d2", + "dist/2022-05-15/rustc-beta-aarch64-apple-darwin.tar.gz": "8d2965de7d1716d335ac35c8bb9e889588cd0c1c0c7793a50bd60d0cd4ac2ce1", + "dist/2022-05-15/rustc-beta-aarch64-apple-darwin.tar.xz": "ab14bf20da511c4b4de1e82a3303f9beab171fe97d5eb2f6ace33d3a7dcd0edc", + "dist/2022-05-15/rustc-beta-aarch64-pc-windows-msvc.tar.gz": "e0e2d9982da503be22cf1dda80d765d926e39a3ced7cf865446477f733953ce5", + "dist/2022-05-15/rustc-beta-aarch64-pc-windows-msvc.tar.xz": "adb54040dc9acd42649da4d347e0e43c029554b7f36e6a722c6c55d144491efa", + "dist/2022-05-15/rustc-beta-aarch64-unknown-linux-gnu.tar.gz": "dbdd409d63e9d1c2e031fec11641b366ddb5f480de8cc6d32b5394b39b3e6355", + "dist/2022-05-15/rustc-beta-aarch64-unknown-linux-gnu.tar.xz": "663f9f2193116db80a94f7560f370a6a0e502739f110a790f0d4684b3d12558e", + "dist/2022-05-15/rustc-beta-aarch64-unknown-linux-musl.tar.gz": "c8f3b8ab61a0365a8fe56ddab83e5b988b26a67d82482a0cbfc7c677d9425cbc", + "dist/2022-05-15/rustc-beta-aarch64-unknown-linux-musl.tar.xz": "95c1f99bec9519e9bd3892603126b146ebce9a17c1ba1a2530277809d0259bfc", + "dist/2022-05-15/rustc-beta-arm-unknown-linux-gnueabi.tar.gz": "47f10b2a6e92c14cc1d0ce9dddc525d7aec7ea4923c0ab9af1bbcbb1aa43d7dd", + "dist/2022-05-15/rustc-beta-arm-unknown-linux-gnueabi.tar.xz": "37cd5f486ca7f41e7be6329565be17553a2a7a82417673ea786583904a914190", + "dist/2022-05-15/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz": "644b37e9a927596d765b4e89444231931b2a69be294d3017d53d67370834ec04", + "dist/2022-05-15/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz": "9c3e0a1431bfce1d59a6a1ebbc61a704a0bb21fb128d4c6bffd422c0b14ff3f2", + "dist/2022-05-15/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz": "0df8e7aba80f0732e6ddd4bae0d46dac65addf77366894373dfb84cd180328c7", + "dist/2022-05-15/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz": "c66c2dba9abd4a1c8b79b24a8c1af66ef37a83a50c27faf642f483a295749a57", + "dist/2022-05-15/rustc-beta-i686-pc-windows-gnu.tar.gz": "6335cd59c76e9760ea3fec9c0ccdde63cb49653dd0beb2ebee64a8d0693ed2f8", + "dist/2022-05-15/rustc-beta-i686-pc-windows-gnu.tar.xz": "39a9ab5ab8174cc9ae3bcbfd1e3c0cc7c04790cebeae9bbfa30c0a2530303bf5", + "dist/2022-05-15/rustc-beta-i686-pc-windows-msvc.tar.gz": "a0a9858205f817efe15d4b5a6818817126f60af9e68267a0c856a78864f8670a", + "dist/2022-05-15/rustc-beta-i686-pc-windows-msvc.tar.xz": "4b0183872d832055af1c3ed4ba2179f1b1f0ddf74925b7bcc1d0da51090b49d4", + "dist/2022-05-15/rustc-beta-i686-unknown-linux-gnu.tar.gz": "c7c833188ce3071b317086f330d6b99c1f8a549e2a8dd03af4287f0734c3ca1f", + "dist/2022-05-15/rustc-beta-i686-unknown-linux-gnu.tar.xz": "7d065f3f9a1663822e0813f9b311c34827b4b2c5f324d5b9389b80f48741b52c", + "dist/2022-05-15/rustc-beta-mips-unknown-linux-gnu.tar.gz": "2fe3b9b9087a1ebaff15a92a617dfe8377e9980342e364d7d7fe7152473d936e", + "dist/2022-05-15/rustc-beta-mips-unknown-linux-gnu.tar.xz": "ddc97e3f1c31181f0a2c5e513009b44310ac8bc33c0f3d8e18fd9bf2f5d52f7d", + "dist/2022-05-15/rustc-beta-mips64-unknown-linux-gnuabi64.tar.gz": "44a2f53634a79f7e785c00918fe9c2e040b00b21a925c7f1d0d575901f3e0468", + "dist/2022-05-15/rustc-beta-mips64-unknown-linux-gnuabi64.tar.xz": "eab6086d3b346f3405746fa3e075afa7f9f4b97059ea7497b62c89e104ff4486", + "dist/2022-05-15/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "070fc2a6e13f12040cd13fce0656ba30a1a8932cc130cf9bf0e29e02d8f97b2c", + "dist/2022-05-15/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "8f15b56270088db0602f7657d46324a1134daa53fb122fe56ef0723be11a2043", + "dist/2022-05-15/rustc-beta-mipsel-unknown-linux-gnu.tar.gz": "caf6523d1e8f1749d6abcb9323608f8e87639ea8f4257a02e3f8276aa3a76737", + "dist/2022-05-15/rustc-beta-mipsel-unknown-linux-gnu.tar.xz": "7456bb944ac9b96f87a0be2e52c739aafddb96c20c31936afcb02528bbc6a3f2", + "dist/2022-05-15/rustc-beta-powerpc-unknown-linux-gnu.tar.gz": "9939e47e8207724b9fc9b7312a489ee258b95ff4526c79d46dd725353b7e4f6a", + "dist/2022-05-15/rustc-beta-powerpc-unknown-linux-gnu.tar.xz": "f8210ba8fde072638bbb8db6b530b97d4ab6d71599d423e3464f3bc9340b9f63", + "dist/2022-05-15/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz": "56c2958cca74047fc781e79a6ef6f00b8037a88d306a0357ca2c2c1815d00e06", + "dist/2022-05-15/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz": "f4d8341bd3ce49a4de357d8f41a53bb0942077ae8da4dfce33eee3a30ad67f5e", + "dist/2022-05-15/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz": "80cc42095ea1ca6e485a5510daeeb9f419cfd6f50a6ec7c2c9ea8b0b66a69ad2", + "dist/2022-05-15/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz": "103332feb2992b73872c13356d3ced526d096a71eb1508096ee641ef99f91db0", + "dist/2022-05-15/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz": "73d7b0e782439df5d05e239e58c9e3d40311a89f70995832f63c61e5d7776cb1", + "dist/2022-05-15/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz": "7303edb4265b86d728f4ce56b77dd30f094899e010a49fec1b0a4954d984d403", + "dist/2022-05-15/rustc-beta-s390x-unknown-linux-gnu.tar.gz": "2a857fa297331165e0b288e28107c5ecbd02a0d00e2d798d2e78139086b40b8a", + "dist/2022-05-15/rustc-beta-s390x-unknown-linux-gnu.tar.xz": "a6b6213a18c405e3feefafb2f5aa7546cae44a1dbd994417f029086353187139", + "dist/2022-05-15/rustc-beta-x86_64-apple-darwin.tar.gz": "90ce793faeed84dfc0f306a7926f81b2879b787cfe3ad38e890725fa21dfb467", + "dist/2022-05-15/rustc-beta-x86_64-apple-darwin.tar.xz": "65b62725f6bd7cb5b5b768b1046e1d7ccf1a3acd977d3148b6510503d09672f0", + "dist/2022-05-15/rustc-beta-x86_64-pc-windows-gnu.tar.gz": "800ca122fda89878abecb2299da146eda4bc39af065191b779c4d99446d4915a", + "dist/2022-05-15/rustc-beta-x86_64-pc-windows-gnu.tar.xz": "22ebec1efd990b4e078bc15e1447fcb9cc71f732954fe1fdb5d4b08d816ea111", + "dist/2022-05-15/rustc-beta-x86_64-pc-windows-msvc.tar.gz": "ea00cdb4f9ca59a904afc18c9b22ac9955c52d87e5f088af901f1af17ccf142c", + "dist/2022-05-15/rustc-beta-x86_64-pc-windows-msvc.tar.xz": "0853c1cf84dffdb39f535562c47c9f7e221e6c9c09f88118a8d4b9684bd7b136", + "dist/2022-05-15/rustc-beta-x86_64-unknown-freebsd.tar.gz": "4c2a50a764fe0ded90d7894523ab2c919941cd1c64da4128d6795fa4bddc2afb", + "dist/2022-05-15/rustc-beta-x86_64-unknown-freebsd.tar.xz": "c7007c94c12c6468f5dfaaefff3c2efa9afd9b65df4bbd862ec9e967e62b0c31", + "dist/2022-05-15/rustc-beta-x86_64-unknown-illumos.tar.gz": "b36f91ddf5022d1d42371fffc324d838545dee0fdb0933853b12fe4122954625", + "dist/2022-05-15/rustc-beta-x86_64-unknown-illumos.tar.xz": "b398940b4e3bb8d39d6ea745ac4e3e77e4a9d578c08f1a92a4e91046e4725605", + "dist/2022-05-15/rustc-beta-x86_64-unknown-linux-gnu.tar.gz": "744377b75a0cb842ab163fb8505da872d1596793783d14885cdf6fd1435e596a", + "dist/2022-05-15/rustc-beta-x86_64-unknown-linux-gnu.tar.xz": "ec1a84d914ef754eef1503aa1920828e8e50a1126387fd9a1aa3f76314c2cb6e", + "dist/2022-05-15/rustc-beta-x86_64-unknown-linux-musl.tar.gz": "9f418fe29bc3e9037b854296863f4f4276dc4e877352ef0317cd785cfa74ece2", + "dist/2022-05-15/rustc-beta-x86_64-unknown-linux-musl.tar.xz": "73592efa8ea065c797f3dfedaee8bf2304e98ffc4ede56650b65760ba5bb5692", + "dist/2022-05-15/rustc-beta-x86_64-unknown-netbsd.tar.gz": "e5194de510989f18001cf5610b3154c60fb10e48dba4325affb27892924007bf", + "dist/2022-05-15/rustc-beta-x86_64-unknown-netbsd.tar.xz": "831a62072088158913fdb763597c8abaa08b789b6eafb592fcdea65a3eb46555", + "dist/2022-05-18/rustfmt-nightly-aarch64-apple-darwin.tar.gz": "f66359bcf7bceca51d3076eb8f8c2b672a1a470886e85ab6a1ab3fcb07b5c1cb", + "dist/2022-05-18/rustfmt-nightly-aarch64-apple-darwin.tar.xz": "1fca39d4668132bb76d638efd0e44d9b702f715797d73c0766ab468aa9b45856", + "dist/2022-05-18/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz": "70300b04b19264a9d6f3d7458066a797f21c49b31bf740d279bb473f2af14977", + "dist/2022-05-18/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz": "8e715a5aac261aa77f4fbf87ed4833693bb85c96c7fd8e34ff690bd5a251ec88", + "dist/2022-05-18/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz": "812c8822e501423f3ad60b6a935d5f10d19156ef5df39616bf6a3d4291b5016e", + "dist/2022-05-18/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz": "3075b9d30fbf22345aab1909cbd1dc0c5c8a479db9e9f68cffa37b1aedc1e058", + "dist/2022-05-18/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz": "dcccce185bcc5fb912d9eee96ad6202eab97d6703a29c5ce8b5135971e985d79", + "dist/2022-05-18/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz": "48b18d83d344ed4b4ddd242a7426e44709971eaf91b1ef0bf2d88c0cbba4caf9", + "dist/2022-05-18/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz": "b32d753039f2f076658dcb4cd5c28d93dc8d626154aa43c5e8c1fc9bfd874db9", + "dist/2022-05-18/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz": "5dcaa6713cbd50582acb640335e844f67a306be31aafd1c24115886c6622b602", + "dist/2022-05-18/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz": "1e3fc097535211c4c7cb52712e3181455e19fd06f09b434c1b67c85ef11b6bf2", + "dist/2022-05-18/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz": "bb3d0118f2a97dfff6be455b5811a2b891a9b09f6215367a97cd2794aa2cf65e", + "dist/2022-05-18/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz": "0cb30a0ca7dbc0af3060a0d82287428911cfde031b3e32995a620f938af4c79e", + "dist/2022-05-18/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz": "ede46721e0b15e2cae47faa9f038c64ab31f287c8a3cbad5529a7c48e1129499", + "dist/2022-05-18/rustfmt-nightly-i686-pc-windows-gnu.tar.gz": "05cbfcbf0b9c751970dafa8ecb80e6392cc7bd64c15239f3e22e8365c7e12f61", + "dist/2022-05-18/rustfmt-nightly-i686-pc-windows-gnu.tar.xz": "5d581e299fcd5f2bf3795394c7b9b6b259d051928dc03c9cce747742a6495e02", + "dist/2022-05-18/rustfmt-nightly-i686-pc-windows-msvc.tar.gz": "fb8377500c78a20aebce804171079c15105b3854641ceb736f30e31dd8979120", + "dist/2022-05-18/rustfmt-nightly-i686-pc-windows-msvc.tar.xz": "984e3c63cf8bb83055f0b048d5071e87d0f96bd7c610eb675f9ef669ee3661cd", + "dist/2022-05-18/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz": "589e44137a4da0c8fa03ef7ea62834fe0c0d9bdcfc08ea94de26c77e2b105af7", + "dist/2022-05-18/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz": "ad49f4858c276f7a46393e6684d5d6645fe1ac4995460edc40987a54205d7b68", + "dist/2022-05-18/rustfmt-nightly-mips-unknown-linux-gnu.tar.gz": "89fb9814eb75946030d41ab02bc7e73f8e7dd17b1ac42db29d3f704b72a1b68f", + "dist/2022-05-18/rustfmt-nightly-mips-unknown-linux-gnu.tar.xz": "4fa8f26e840a2e583c54f710e097f2f5b54cc5ec7e9080da47caa9c504d116b2", + "dist/2022-05-18/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.gz": "7c45543ef6f875ab16638164e06490eeb159be08d4a6e35b0dd2dbba0a1b9646", + "dist/2022-05-18/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.xz": "c12ab34a9d3cc8882025b0cb5b558d1876db3811309f8cd3cf6e9e80e9bc34a4", + "dist/2022-05-18/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.gz": "a9e3beb29c0ea22ce570815eab9d148088b39a59ca5640a158e21424c746e354", + "dist/2022-05-18/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.xz": "90cde88b518c2865d2155cb8e5598f07144955621128547b16b83fd02ede5584", + "dist/2022-05-18/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.gz": "1faed2184c47b998c4e9c85cb41769ed93dbc075628a2af029354033526c55ee", + "dist/2022-05-18/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.xz": "2c611b3ec94872c618d43a2ae7c20d0117f4d75ad23d04ae022b854ee035f776", + "dist/2022-05-18/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz": "47b3029884e9240ffc19debb0a5060a9ae79f9613f7812c80c89aeb23591d690", + "dist/2022-05-18/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz": "accc4a1852b3846b01eed4e66be16162637875b3a7d333f153327bd4828b1bb5", + "dist/2022-05-18/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz": "dd13801f56833505dcdcd91046e0690bcea04aa35a8366873b6d325044b5c720", + "dist/2022-05-18/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz": "b847f604660cf4e16fab08ca89c5ff40d2ae1b5c897ab0c1c3cd42bfa0d29a2c", + "dist/2022-05-18/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz": "6b6d2eb8c58644a09afa469da136b9375f28f039cd87edecdcc22786cbb582ba", + "dist/2022-05-18/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz": "515fbc35a82e7bd421e4d83b90b3a9262646d07fa75c0ee72114dff58d860d39", + "dist/2022-05-18/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz": "7ce7079b2fcd4f41f0bf1dda590308ee4c63bebac38ef0786ca5988369bf6a65", + "dist/2022-05-18/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz": "3d98e3a39d84e37a0875f44a7936132162d8c4e32b806026abcf4e6848f27e12", + "dist/2022-05-18/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz": "f6b48045a12b7b96c710a694937d9233fc1ae23081be4395fb579b8996a49c68", + "dist/2022-05-18/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz": "74ab28a5901ba138394fa366fcecc65cbbc17af0266b5ded5fa528de6cb7b308", + "dist/2022-05-18/rustfmt-nightly-x86_64-apple-darwin.tar.gz": "ea94217424805ad9afb7d66008b5a18207d89ee2598796ec9b44c377ad54d446", + "dist/2022-05-18/rustfmt-nightly-x86_64-apple-darwin.tar.xz": "b26d779cf977804866df5ddb9cdf354ac6dad39c610cfe483a35b990511cf807", + "dist/2022-05-18/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz": "354acb2e31fefc740f45e79c023f569c64f4fb4e2710cd5fc79f0d87a300bd3e", + "dist/2022-05-18/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz": "1635ada8fbd65294106ddf01173dcc653cc2d187a151faadeacf0654eb9875d0", + "dist/2022-05-18/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz": "788a5248787c7fc897a1ef6d463b4a8e8eaaa67482e2710d5508598eb22d3e68", + "dist/2022-05-18/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz": "b5e2bd19cb9d3b3396d25ff46b5db46eaac845fbbf4bcb6bb579955142c0c0f7", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz": "202dc8dde4fdc89a279f8fbb9e9c8a4381cbd2b2ad665da3404d6a9ed210cc82", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz": "9d439c395f763a04cff46256ca9bffa55cef8e355674eafb618838ee8bce83d9", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-illumos.tar.gz": "f108991678ebd4e9ffb4f26c210c8e2592fa6a3fc1e1bc09b80962be0d1df404", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-illumos.tar.xz": "7ff50e06d3172871584635f50070fdb0ba2fd58deae79145f2f919bcc9c78596", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz": "7d64f8f9c998bcc6f85a1aae3ec5ed937fe089e802a88262446e4ab039630276", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz": "8c845d9e919779e9bb411e734826d6fff39445658e0bd9bb5295f05a1c5c3b3c", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz": "3a4faa7f23d5e8cac33962115f01a24d9ad35c344f88786f24154072cd70a35b", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz": "9fe8ef55062ae747e0db84c391b59a5c402727ac4441c020c3bebaa6ec56717f", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz": "175724592c39b929f9162ee13cc543e49aed5e1c058c700a475caeb434d72555", + "dist/2022-05-18/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz": "ca66d3bae9a1a23edc8fa25ecea0d283c6b15d7d0f429c6b1ab7601019f1eced" } } diff --git a/src/test/codegen/noalias-refcell.rs b/src/test/codegen/noalias-refcell.rs new file mode 100644 index 00000000000..dba73937abf --- /dev/null +++ b/src/test/codegen/noalias-refcell.rs @@ -0,0 +1,14 @@ +// compile-flags: -O -C no-prepopulate-passes -Z mutable-noalias=yes + +#![crate_type = "lib"] + +use std::cell::{Ref, RefCell, RefMut}; + +// Make sure that none of the arguments get a `noalias` attribute, because +// the `RefCell` might alias writes after either `Ref`/`RefMut` is dropped. + +// CHECK-LABEL: @maybe_aliased( +// CHECK-NOT: noalias +// CHECK-SAME: %_refcell +#[no_mangle] +pub unsafe fn maybe_aliased(_: Ref<'_, i32>, _: RefMut<'_, i32>, _refcell: &RefCell<i32>) {} diff --git a/src/test/rustdoc/impl-box.rs b/src/test/rustdoc/impl-box.rs new file mode 100644 index 00000000000..a371db135cf --- /dev/null +++ b/src/test/rustdoc/impl-box.rs @@ -0,0 +1,16 @@ +// https://github.com/rust-lang/rust/issues/92940 +// +// Show traits implemented on fundamental types that wrap local ones. + +pub struct MyType; + +// @has 'impl_box/struct.MyType.html' +// @has '-' '//*[@id="impl-Iterator"]' 'impl Iterator for Box<MyType>' + +impl Iterator for Box<MyType> { + type Item = (); + + fn next(&mut self) -> Option<Self::Item> { + todo!() + } +} diff --git a/src/test/ui/const-generics/issues/issue-88119.rs b/src/test/ui/const-generics/issues/issue-88119.rs new file mode 100644 index 00000000000..70dfa7f708b --- /dev/null +++ b/src/test/ui/const-generics/issues/issue-88119.rs @@ -0,0 +1,35 @@ +// check-pass + +#![allow(incomplete_features)] +#![feature(const_trait_impl, generic_const_exprs)] + +trait ConstName { + const NAME_BYTES: &'static [u8]; +} + +impl const ConstName for u8 { + const NAME_BYTES: &'static [u8] = b"u8"; +} + +const fn name_len<T: ?Sized + ConstName>() -> usize { + T::NAME_BYTES.len() +} + +impl<T: ?Sized + ConstName> const ConstName for &T +where + [(); name_len::<T>()]:, +{ + const NAME_BYTES: &'static [u8] = b"&T"; +} + +impl<T: ?Sized + ConstName> const ConstName for &mut T +where + [(); name_len::<T>()]:, +{ + const NAME_BYTES: &'static [u8] = b"&mut T"; +} + +pub const ICE_1: &'static [u8] = <&&mut u8 as ConstName>::NAME_BYTES; +pub const ICE_2: &'static [u8] = <&mut &u8 as ConstName>::NAME_BYTES; + +fn main() {} diff --git a/src/test/ui/consts/const-err4.32bit.stderr b/src/test/ui/consts/const-err4.32bit.stderr index 1dbda8cbcd0..922569f66cf 100644 --- a/src/test/ui/consts/const-err4.32bit.stderr +++ b/src/test/ui/consts/const-err4.32bit.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-err4.rs:9:11 | LL | Boo = [unsafe { Foo { b: () }.a }; 4][3], - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { diff --git a/src/test/ui/consts/const-err4.64bit.stderr b/src/test/ui/consts/const-err4.64bit.stderr index 2eea3ea7096..d7b848e8345 100644 --- a/src/test/ui/consts/const-err4.64bit.stderr +++ b/src/test/ui/consts/const-err4.64bit.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-err4.rs:9:11 | LL | Boo = [unsafe { Foo { b: () }.a }; 4][3], - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { diff --git a/src/test/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr b/src/test/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr index 5f23cc2311d..7c2df205cbf 100644 --- a/src/test/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr +++ b/src/test/ui/consts/const-eval/const-pointer-values-in-various-types.64bit.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:26:5 | LL | const I32_REF_USIZE_UNION: usize = unsafe { Nonsense { int_32_ref: &3 }.u }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc3, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc3, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -47,7 +47,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:41:5 | LL | const I32_REF_U64_UNION: u64 = unsafe { Nonsense { int_32_ref: &3 }.uint_64 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc19, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc19, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -58,7 +58,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:44:5 | LL | const I32_REF_U128_UNION: u128 = unsafe { Nonsense { int_32_ref: &3 }.uint_128 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 16, align: 8) { @@ -102,7 +102,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:59:5 | LL | const I32_REF_I64_UNION: i64 = unsafe { Nonsense { int_32_ref: &3 }.int_64 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc39, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc39, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -113,7 +113,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:62:5 | LL | const I32_REF_I128_UNION: i128 = unsafe { Nonsense { int_32_ref: &3 }.int_128 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 16, align: 8) { @@ -135,7 +135,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:69:5 | LL | const I32_REF_F64_UNION: f64 = unsafe { Nonsense { int_32_ref: &3 }.float_64 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc51, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc51, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -201,7 +201,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:92:5 | LL | const STR_U64_UNION: u64 = unsafe { Nonsense { stringy: "3" }.uint_64 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc72, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc72, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -256,7 +256,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:111:5 | LL | const STR_I64_UNION: i64 = unsafe { Nonsense { stringy: "3" }.int_64 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc87, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc87, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -289,7 +289,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/const-pointer-values-in-various-types.rs:122:5 | LL | const STR_F64_UNION: f64 = unsafe { Nonsense { stringy: "3" }.float_64 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc96, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc96, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { diff --git a/src/test/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr b/src/test/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr index 597703de01e..2ec058806ce 100644 --- a/src/test/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr +++ b/src/test/ui/consts/const-eval/heap/alloc_intrinsic_uninit.32bit.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/alloc_intrinsic_uninit.rs:8:1 | LL | const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<deref>: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<deref>: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { diff --git a/src/test/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr b/src/test/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr index 08fbb67b371..5144378dba2 100644 --- a/src/test/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr +++ b/src/test/ui/consts/const-eval/heap/alloc_intrinsic_uninit.64bit.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/alloc_intrinsic_uninit.rs:8:1 | LL | const BAR: &i32 = unsafe { &*(intrinsics::const_allocate(4, 4) as *mut i32) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<deref>: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<deref>: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { diff --git a/src/test/ui/consts/const-eval/ref_to_int_match.32bit.stderr b/src/test/ui/consts/const-eval/ref_to_int_match.32bit.stderr index aa5ba53fb1b..01ae1349947 100644 --- a/src/test/ui/consts/const-eval/ref_to_int_match.32bit.stderr +++ b/src/test/ui/consts/const-eval/ref_to_int_match.32bit.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ref_to_int_match.rs:25:1 | LL | const BAR: Int = unsafe { Foo { r: &42 }.f }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc3, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc3, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { diff --git a/src/test/ui/consts/const-eval/ref_to_int_match.64bit.stderr b/src/test/ui/consts/const-eval/ref_to_int_match.64bit.stderr index 525a6217506..7847330f9ce 100644 --- a/src/test/ui/consts/const-eval/ref_to_int_match.64bit.stderr +++ b/src/test/ui/consts/const-eval/ref_to_int_match.64bit.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ref_to_int_match.rs:25:1 | LL | const BAR: Int = unsafe { Foo { r: &42 }.f }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc3, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc3, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { diff --git a/src/test/ui/consts/const-eval/ub-enum-overwrite.stderr b/src/test/ui/consts/const-eval/ub-enum-overwrite.stderr index 88de7acb496..d5a1f1dad61 100644 --- a/src/test/ui/consts/const-eval/ub-enum-overwrite.stderr +++ b/src/test/ui/consts/const-eval/ub-enum-overwrite.stderr @@ -8,7 +8,7 @@ LL | | let p = if let E::A(x) = &mut e { x as *mut u8 } else { unreachable!( ... | LL | | unsafe { *p } LL | | }; - | |__^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | |__^ type validation failed: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 1, align: 1) { diff --git a/src/test/ui/consts/const-eval/ub-enum.32bit.stderr b/src/test/ui/consts/const-eval/ub-enum.32bit.stderr index b60bac541f4..655e1823843 100644 --- a/src/test/ui/consts/const-eval/ub-enum.32bit.stderr +++ b/src/test/ui/consts/const-eval/ub-enum.32bit.stderr @@ -13,7 +13,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:27:1 | LL | const BAD_ENUM_PTR: Enum = unsafe { mem::transmute(&1) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc9, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc9, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { @@ -24,7 +24,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:30:1 | LL | const BAD_ENUM_WRAPPED: Wrap<Enum> = unsafe { mem::transmute(&1) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0.<enum-tag>: encountered pointer to alloc13, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0.<enum-tag>: encountered pointer to alloc13, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { @@ -46,7 +46,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:44:1 | LL | const BAD_ENUM2_PTR: Enum2 = unsafe { mem::transmute(&0) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc19, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc19, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { @@ -57,7 +57,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:47:1 | LL | const BAD_ENUM2_WRAPPED: Wrap<Enum2> = unsafe { mem::transmute(&0) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0.<enum-tag>: encountered pointer to alloc23, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0.<enum-tag>: encountered pointer to alloc23, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { @@ -68,7 +68,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:56:1 | LL | const BAD_ENUM2_UNDEF : Enum2 = unsafe { MaybeUninit { uninit: () }.init }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { @@ -79,7 +79,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:60:1 | LL | const BAD_ENUM2_OPTION_PTR: Option<Enum2> = unsafe { mem::transmute(&0) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc30, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc30, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { diff --git a/src/test/ui/consts/const-eval/ub-enum.64bit.stderr b/src/test/ui/consts/const-eval/ub-enum.64bit.stderr index 1d81e2b3eed..2273487a0fb 100644 --- a/src/test/ui/consts/const-eval/ub-enum.64bit.stderr +++ b/src/test/ui/consts/const-eval/ub-enum.64bit.stderr @@ -13,7 +13,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:27:1 | LL | const BAD_ENUM_PTR: Enum = unsafe { mem::transmute(&1) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc9, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc9, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -24,7 +24,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:30:1 | LL | const BAD_ENUM_WRAPPED: Wrap<Enum> = unsafe { mem::transmute(&1) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0.<enum-tag>: encountered pointer to alloc13, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0.<enum-tag>: encountered pointer to alloc13, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -46,7 +46,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:44:1 | LL | const BAD_ENUM2_PTR: Enum2 = unsafe { mem::transmute(&0) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc19, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc19, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -57,7 +57,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:47:1 | LL | const BAD_ENUM2_WRAPPED: Wrap<Enum2> = unsafe { mem::transmute(&0) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0.<enum-tag>: encountered pointer to alloc23, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0.<enum-tag>: encountered pointer to alloc23, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -68,7 +68,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:56:1 | LL | const BAD_ENUM2_UNDEF : Enum2 = unsafe { MaybeUninit { uninit: () }.init }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -79,7 +79,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-enum.rs:60:1 | LL | const BAD_ENUM2_OPTION_PTR: Option<Enum2> = unsafe { mem::transmute(&0) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc30, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .<enum-tag>: encountered pointer to alloc30, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { diff --git a/src/test/ui/consts/const-eval/ub-nonnull.32bit.stderr b/src/test/ui/consts/const-eval/ub-nonnull.32bit.stderr index e44f3249454..e5091397e83 100644 --- a/src/test/ui/consts/const-eval/ub-nonnull.32bit.stderr +++ b/src/test/ui/consts/const-eval/ub-nonnull.32bit.stderr @@ -41,7 +41,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-nonnull.rs:33:1 | LL | const UNINIT: NonZeroU8 = unsafe { MaybeUninit { uninit: () }.init }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 1, align: 1) { diff --git a/src/test/ui/consts/const-eval/ub-nonnull.64bit.stderr b/src/test/ui/consts/const-eval/ub-nonnull.64bit.stderr index 1ce87bc7c1c..80c694fc83e 100644 --- a/src/test/ui/consts/const-eval/ub-nonnull.64bit.stderr +++ b/src/test/ui/consts/const-eval/ub-nonnull.64bit.stderr @@ -41,7 +41,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-nonnull.rs:33:1 | LL | const UNINIT: NonZeroU8 = unsafe { MaybeUninit { uninit: () }.init }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed at .0: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 1, align: 1) { diff --git a/src/test/ui/consts/const-eval/ub-ref-ptr.32bit.stderr b/src/test/ui/consts/const-eval/ub-ref-ptr.32bit.stderr index 6f80da9cda9..eebe7d090a3 100644 --- a/src/test/ui/consts/const-eval/ub-ref-ptr.32bit.stderr +++ b/src/test/ui/consts/const-eval/ub-ref-ptr.32bit.stderr @@ -46,7 +46,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-ref-ptr.rs:31:1 | LL | const REF_AS_USIZE: usize = unsafe { mem::transmute(&0) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc15, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc15, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 4, align: 4) { diff --git a/src/test/ui/consts/const-eval/ub-ref-ptr.64bit.stderr b/src/test/ui/consts/const-eval/ub-ref-ptr.64bit.stderr index 9b636761557..f2acb934070 100644 --- a/src/test/ui/consts/const-eval/ub-ref-ptr.64bit.stderr +++ b/src/test/ui/consts/const-eval/ub-ref-ptr.64bit.stderr @@ -46,7 +46,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/ub-ref-ptr.rs:31:1 | LL | const REF_AS_USIZE: usize = unsafe { mem::transmute(&0) }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc15, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered pointer to alloc15, but expected plain (non-pointer) bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { diff --git a/src/test/ui/consts/const-eval/union-const-eval-field.stderr b/src/test/ui/consts/const-eval/union-const-eval-field.stderr index 8f818462781..94ab6eeff28 100644 --- a/src/test/ui/consts/const-eval/union-const-eval-field.stderr +++ b/src/test/ui/consts/const-eval/union-const-eval-field.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/union-const-eval-field.rs:28:5 | LL | const FIELD3: Field3 = unsafe { UNION.field3 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { diff --git a/src/test/ui/consts/const-eval/union-ice.stderr b/src/test/ui/consts/const-eval/union-ice.stderr index b1ab03400c1..7f77f2c16ae 100644 --- a/src/test/ui/consts/const-eval/union-ice.stderr +++ b/src/test/ui/consts/const-eval/union-ice.stderr @@ -2,7 +2,7 @@ error[E0080]: it is undefined behavior to use this value --> $DIR/union-ice.rs:14:1 | LL | const FIELD3: Field3 = unsafe { UNION.field3 }; - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ type validation failed: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 8, align: 8) { @@ -16,7 +16,7 @@ LL | / const FIELD_PATH: Struct = Struct { LL | | a: 42, LL | | b: unsafe { UNION.field3 }, LL | | }; - | |__^ type validation failed at .b: encountered uninitialized bytes, but expected initialized plain (non-pointer) bytes + | |__^ type validation failed at .b: encountered uninitialized bytes, but expected initialized bytes | = note: The rules on what exactly is undefined behavior aren't clear, so this check might be overzealous. Please open an issue on the rustc repository if you believe it should not be considered undefined behavior. = note: the raw bytes of the constant (size: 16, align: 8) { diff --git a/src/test/ui/error-codes/E0604.stderr b/src/test/ui/error-codes/E0604.stderr index d715d28b73c..68da03928b7 100644 --- a/src/test/ui/error-codes/E0604.stderr +++ b/src/test/ui/error-codes/E0604.stderr @@ -2,13 +2,10 @@ error[E0604]: only `u8` can be cast as `char`, not `u32` --> $DIR/E0604.rs:2:5 | LL | 1u32 as char; - | ^^^^^^^^^^^^ invalid cast - | -help: try `char::from_u32` instead - --> $DIR/E0604.rs:2:5 - | -LL | 1u32 as char; | ^^^^^^^^^^^^ + | | + | invalid cast + | help: try `char::from_u32` instead: `char::from_u32(1u32)` error: aborting due to previous error diff --git a/src/test/ui/error-festival.stderr b/src/test/ui/error-festival.stderr index 0ddb6fc99b0..81aa268cacc 100644 --- a/src/test/ui/error-festival.stderr +++ b/src/test/ui/error-festival.stderr @@ -57,13 +57,10 @@ error[E0604]: only `u8` can be cast as `char`, not `u32` --> $DIR/error-festival.rs:25:5 | LL | 0u32 as char; - | ^^^^^^^^^^^^ invalid cast - | -help: try `char::from_u32` instead - --> $DIR/error-festival.rs:25:5 - | -LL | 0u32 as char; | ^^^^^^^^^^^^ + | | + | invalid cast + | help: try `char::from_u32` instead: `char::from_u32(0u32)` error[E0605]: non-primitive cast: `u8` as `Vec<u8>` --> $DIR/error-festival.rs:29:5 diff --git a/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs new file mode 100644 index 00000000000..646365e4359 --- /dev/null +++ b/src/test/ui/generator/drop-tracking-yielding-in-match-guards.rs @@ -0,0 +1,12 @@ +// build-pass +// edition:2018 +// compile-flags: -Zdrop-tracking + +#![feature(generators)] + +fn main() { + let _ = static |x: u8| match x { + y if { yield } == y + 1 => (), + _ => (), + }; +} diff --git a/src/test/ui/issues/issue-63787.rs b/src/test/ui/issues/issue-63787.rs new file mode 100644 index 00000000000..cba079b2315 --- /dev/null +++ b/src/test/ui/issues/issue-63787.rs @@ -0,0 +1,36 @@ +// run-pass +// compile-flags: -O + +// Make sure that `Ref` and `RefMut` do not make false promises about aliasing, +// because once they drop, their reference/pointer can alias other writes. + +// Adapted from comex's proof of concept: +// https://github.com/rust-lang/rust/issues/63787#issuecomment-523588164 + +use std::cell::RefCell; +use std::ops::Deref; + +pub fn break_if_r_is_noalias(rc: &RefCell<i32>, r: impl Deref<Target = i32>) -> i32 { + let ptr1 = &*r as *const i32; + let a = *r; + drop(r); + *rc.borrow_mut() = 2; + let r2 = rc.borrow(); + let ptr2 = &*r2 as *const i32; + if ptr2 != ptr1 { + panic!(); + } + // If LLVM knows the pointers are the same, and if `r` was `noalias`, + // then it may replace this with `a + a`, ignoring the earlier write. + a + *r2 +} + +fn main() { + let mut rc = RefCell::new(1); + let res = break_if_r_is_noalias(&rc, rc.borrow()); + assert_eq!(res, 3); + + *rc.get_mut() = 1; + let res = break_if_r_is_noalias(&rc, rc.borrow_mut()); + assert_eq!(res, 3); +} diff --git a/src/test/ui/mismatched_types/cast-rfc0401.stderr b/src/test/ui/mismatched_types/cast-rfc0401.stderr index 84220ea172a..3a508459cc0 100644 --- a/src/test/ui/mismatched_types/cast-rfc0401.stderr +++ b/src/test/ui/mismatched_types/cast-rfc0401.stderr @@ -98,13 +98,10 @@ error[E0604]: only `u8` can be cast as `char`, not `u32` --> $DIR/cast-rfc0401.rs:41:13 | LL | let _ = 0x61u32 as char; - | ^^^^^^^^^^^^^^^ invalid cast - | -help: try `char::from_u32` instead - --> $DIR/cast-rfc0401.rs:41:13 - | -LL | let _ = 0x61u32 as char; | ^^^^^^^^^^^^^^^ + | | + | invalid cast + | help: try `char::from_u32` instead: `char::from_u32(0x61u32)` error[E0606]: casting `bool` as `f32` is invalid --> $DIR/cast-rfc0401.rs:43:13 diff --git a/src/tools/rls b/src/tools/rls -Subproject e6f71c9cadf9bbd2eff21334d1d51016c7f5e19 +Subproject 7241c6cc45badc0e30cefd6c123a539f82c50cd |