bjoernager/rust
bjoernager/rust
1
Fork 0
Code Activity

Auto merge of #95678 - pietroalbini:pa-1.62.0-bootstrap, r=Mark-Simulacrum

Browse source 
Bump bootstrap compiler to 1.61.0 beta

This PR bumps the bootstrap compiler to the 1.61.0 beta. The first commit changes the stage0 compiler, the second commit applies the "mechanical" changes and the third and fourth commits apply changes explained in the relevant comments.

r? `@Mark-Simulacrum`
This commit is contained in:
bors 2022-04-07 07:34:04 +00:00
commit f565016edd
50 changed files with 524 additions and 697 deletions
Download patch file Download diff file Expand all files Collapse all files

1
compiler/rustc_llvm/src/lib.rs
View file

@ -1,5 +1,4 @@
#![feature(nll)] #![feature(nll)]
#![cfg_attr(bootstrap, feature(native_link_modifiers))]
#![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")] #![doc(html_root_url = "https://doc.rust-lang.org/nightly/nightly-rustc/")]
// NOTE: This crate only exists to allow linking on mingw targets. // NOTE: This crate only exists to allow linking on mingw targets.

2
compiler/rustc_middle/src/mir/interpret/allocation.rs
View file

@ -58,7 +58,7 @@ pub struct Allocation<Tag = AllocId, Extra = ()> {
/// means that both the inner type (`Allocation`) and the outer type /// means that both the inner type (`Allocation`) and the outer type
/// (`ConstAllocation`) are used quite a bit. /// (`ConstAllocation`) are used quite a bit.
#[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable)] #[derive(Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, HashStable)]
#[cfg_attr(not(bootstrap), rustc_pass_by_value)] #[rustc_pass_by_value]
pub struct ConstAllocation<'tcx, Tag = AllocId, Extra = ()>( pub struct ConstAllocation<'tcx, Tag = AllocId, Extra = ()>(
pub Interned<'tcx, Allocation<Tag, Extra>>, pub Interned<'tcx, Allocation<Tag, Extra>>,
); );

2
compiler/rustc_middle/src/ty/adt.rs
View file

@ -161,7 +161,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for AdtDefData {
} }
#[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, HashStable)] #[derive(Copy, Clone, PartialEq, Eq, Hash, Ord, PartialOrd, HashStable)]
#[cfg_attr(not(bootstrap), rustc_pass_by_value)] #[rustc_pass_by_value]
pub struct AdtDef<'tcx>(pub Interned<'tcx, AdtDefData>); pub struct AdtDef<'tcx>(pub Interned<'tcx, AdtDefData>);
impl<'tcx> AdtDef<'tcx> { impl<'tcx> AdtDef<'tcx> {

2
compiler/rustc_target/src/abi/mod.rs
View file

@ -1262,7 +1262,7 @@ impl<'a> fmt::Debug for LayoutS<'a> {
} }
#[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic)] #[derive(Copy, Clone, PartialEq, Eq, Hash, HashStable_Generic)]
#[cfg_attr(not(bootstrap), rustc_pass_by_value)] #[rustc_pass_by_value]
pub struct Layout<'a>(pub Interned<'a, LayoutS<'a>>); pub struct Layout<'a>(pub Interned<'a, LayoutS<'a>>);
impl<'a> fmt::Debug for Layout<'a> { impl<'a> fmt::Debug for Layout<'a> {

11
compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
View file

@ -307,17 +307,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
self.assemble_builtin_bound_candidates(sized_conditions, &mut candidates); self.assemble_builtin_bound_candidates(sized_conditions, &mut candidates);
} else if lang_items.unsize_trait() == Some(def_id) { } else if lang_items.unsize_trait() == Some(def_id) {
self.assemble_candidates_for_unsizing(obligation, &mut candidates); self.assemble_candidates_for_unsizing(obligation, &mut candidates);
} else if lang_items.drop_trait() == Some(def_id)
&& obligation.predicate.is_const_if_const()
{
// holds to make it easier to transition
// FIXME(fee1-dead): add a note for selection error of `~const Drop`
// when beta is bumped
// FIXME: remove this when beta is bumped
#[cfg(bootstrap)]
{}
candidates.vec.push(SelectionCandidate::ConstDestructCandidate(None))
} else if lang_items.destruct_trait() == Some(def_id) { } else if lang_items.destruct_trait() == Some(def_id) {
self.assemble_const_destruct_candidates(obligation, &mut candidates); self.assemble_const_destruct_candidates(obligation, &mut candidates);
} else { } else {

7
compiler/rustc_trait_selection/src/traits/select/confirmation.rs
View file

@ -1106,13 +1106,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
} }
let drop_trait = self.tcx().require_lang_item(LangItem::Drop, None); let drop_trait = self.tcx().require_lang_item(LangItem::Drop, None);
// FIXME: remove if statement below when beta is bumped
#[cfg(bootstrap)]
{}
if obligation.predicate.skip_binder().def_id() == drop_trait {
return Ok(ImplSourceConstDestructData { nested: vec![] });
}
let tcx = self.tcx(); let tcx = self.tcx();
let self_ty = self.infcx.shallow_resolve(obligation.self_ty()); let self_ty = self.infcx.shallow_resolve(obligation.self_ty());

6
library/alloc/src/alloc.rs
View file

@ -326,16 +326,12 @@ unsafe fn exchange_malloc(size: usize, align: usize) -> *mut u8 {
#[cfg_attr(not(test), lang = "box_free")] #[cfg_attr(not(test), lang = "box_free")]
#[inline] #[inline]
#[rustc_const_unstable(feature = "const_box", issue = "92521")] #[rustc_const_unstable(feature = "const_box", issue = "92521")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
// This signature has to be the same as `Box`, otherwise an ICE will happen. // This signature has to be the same as `Box`, otherwise an ICE will happen.
// When an additional parameter to `Box` is added (like `A: Allocator`), this has to be added here as // When an additional parameter to `Box` is added (like `A: Allocator`), this has to be added here as
// well. // well.
// For example if `Box` is changed to `struct Box<T: ?Sized, A: Allocator>(Unique<T>, A)`, // For example if `Box` is changed to `struct Box<T: ?Sized, A: Allocator>(Unique<T>, A)`,
// this function has to be changed to `fn box_free<T: ?Sized, A: Allocator>(Unique<T>, A)` as well. // this function has to be changed to `fn box_free<T: ?Sized, A: Allocator>(Unique<T>, A)` as well.
pub(crate) const unsafe fn box_free< pub(crate) const unsafe fn box_free<T: ?Sized, A: ~const Allocator + ~const Destruct>(
T: ?Sized,
A: ~const Allocator + ~const Drop + ~const Destruct,
>(
ptr: Unique<T>, ptr: Unique<T>,
alloc: A, alloc: A,
) { ) {

1
library/alloc/src/borrow.rs
View file

@ -331,7 +331,6 @@ impl<B: ?Sized + ToOwned> Cow<'_, B> {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_deref", issue = "88955")] #[rustc_const_unstable(feature = "const_deref", issue = "88955")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
impl<B: ?Sized + ToOwned> const Deref for Cow<'_, B> impl<B: ?Sized + ToOwned> const Deref for Cow<'_, B>
where where
B::Owned: ~const Borrow<B>, B::Owned: ~const Borrow<B>,

26
library/alloc/src/boxed.rs
View file

@ -349,10 +349,9 @@ impl<T, A: Allocator> Box<T, A> {
#[rustc_const_unstable(feature = "const_box", issue = "92521")] #[rustc_const_unstable(feature = "const_box", issue = "92521")]
#[must_use] #[must_use]
#[inline] #[inline]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn new_in(x: T, alloc: A) -> Self pub const fn new_in(x: T, alloc: A) -> Self
where where
A: ~const Allocator + ~const Drop + ~const Destruct, A: ~const Allocator + ~const Destruct,
{ {
let mut boxed = Self::new_uninit_in(alloc); let mut boxed = Self::new_uninit_in(alloc);
unsafe { unsafe {
@ -379,11 +378,10 @@ impl<T, A: Allocator> Box<T, A> {
#[unstable(feature = "allocator_api", issue = "32838")] #[unstable(feature = "allocator_api", issue = "32838")]
#[rustc_const_unstable(feature = "const_box", issue = "92521")] #[rustc_const_unstable(feature = "const_box", issue = "92521")]
#[inline] #[inline]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn try_new_in(x: T, alloc: A) -> Result<Self, AllocError> pub const fn try_new_in(x: T, alloc: A) -> Result<Self, AllocError>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
A: ~const Allocator + ~const Drop + ~const Destruct, A: ~const Allocator + ~const Destruct,
{ {
let mut boxed = Self::try_new_uninit_in(alloc)?; let mut boxed = Self::try_new_uninit_in(alloc)?;
unsafe { unsafe {
@ -417,10 +415,9 @@ impl<T, A: Allocator> Box<T, A> {
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[must_use] #[must_use]
// #[unstable(feature = "new_uninit", issue = "63291")] // #[unstable(feature = "new_uninit", issue = "63291")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn new_uninit_in(alloc: A) -> Box<mem::MaybeUninit<T>, A> pub const fn new_uninit_in(alloc: A) -> Box<mem::MaybeUninit<T>, A>
where where
A: ~const Allocator + ~const Drop + ~const Destruct, A: ~const Allocator + ~const Destruct,
{ {
let layout = Layout::new::<mem::MaybeUninit<T>>(); let layout = Layout::new::<mem::MaybeUninit<T>>();
// NOTE: Prefer match over unwrap_or_else since closure sometimes not inlineable. // NOTE: Prefer match over unwrap_or_else since closure sometimes not inlineable.
@ -456,10 +453,9 @@ impl<T, A: Allocator> Box<T, A> {
#[unstable(feature = "allocator_api", issue = "32838")] #[unstable(feature = "allocator_api", issue = "32838")]
// #[unstable(feature = "new_uninit", issue = "63291")] // #[unstable(feature = "new_uninit", issue = "63291")]
#[rustc_const_unstable(feature = "const_box", issue = "92521")] #[rustc_const_unstable(feature = "const_box", issue = "92521")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn try_new_uninit_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError> pub const fn try_new_uninit_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError>
where where
A: ~const Allocator + ~const Drop + ~const Destruct, A: ~const Allocator + ~const Destruct,
{ {
let layout = Layout::new::<mem::MaybeUninit<T>>(); let layout = Layout::new::<mem::MaybeUninit<T>>();
let ptr = alloc.allocate(layout)?.cast(); let ptr = alloc.allocate(layout)?.cast();
@ -491,10 +487,9 @@ impl<T, A: Allocator> Box<T, A> {
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
// #[unstable(feature = "new_uninit", issue = "63291")] // #[unstable(feature = "new_uninit", issue = "63291")]
#[must_use] #[must_use]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn new_zeroed_in(alloc: A) -> Box<mem::MaybeUninit<T>, A> pub const fn new_zeroed_in(alloc: A) -> Box<mem::MaybeUninit<T>, A>
where where
A: ~const Allocator + ~const Drop + ~const Destruct, A: ~const Allocator + ~const Destruct,
{ {
let layout = Layout::new::<mem::MaybeUninit<T>>(); let layout = Layout::new::<mem::MaybeUninit<T>>();
// NOTE: Prefer match over unwrap_or_else since closure sometimes not inlineable. // NOTE: Prefer match over unwrap_or_else since closure sometimes not inlineable.
@ -530,10 +525,9 @@ impl<T, A: Allocator> Box<T, A> {
#[unstable(feature = "allocator_api", issue = "32838")] #[unstable(feature = "allocator_api", issue = "32838")]
// #[unstable(feature = "new_uninit", issue = "63291")] // #[unstable(feature = "new_uninit", issue = "63291")]
#[rustc_const_unstable(feature = "const_box", issue = "92521")] #[rustc_const_unstable(feature = "const_box", issue = "92521")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn try_new_zeroed_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError> pub const fn try_new_zeroed_in(alloc: A) -> Result<Box<mem::MaybeUninit<T>, A>, AllocError>
where where
A: ~const Allocator + ~const Drop + ~const Destruct, A: ~const Allocator + ~const Destruct,
{ {
let layout = Layout::new::<mem::MaybeUninit<T>>(); let layout = Layout::new::<mem::MaybeUninit<T>>();
let ptr = alloc.allocate_zeroed(layout)?.cast(); let ptr = alloc.allocate_zeroed(layout)?.cast();
@ -547,10 +541,9 @@ impl<T, A: Allocator> Box<T, A> {
#[rustc_const_unstable(feature = "const_box", issue = "92521")] #[rustc_const_unstable(feature = "const_box", issue = "92521")]
#[must_use] #[must_use]
#[inline(always)] #[inline(always)]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn pin_in(x: T, alloc: A) -> Pin<Self> pub const fn pin_in(x: T, alloc: A) -> Pin<Self>
where where
A: 'static + ~const Allocator + ~const Drop + ~const Destruct, A: 'static + ~const Allocator + ~const Destruct,
{ {
Self::into_pin(Self::new_in(x, alloc)) Self::into_pin(Self::new_in(x, alloc))
} }
@ -579,10 +572,9 @@ impl<T, A: Allocator> Box<T, A> {
#[unstable(feature = "box_into_inner", issue = "80437")] #[unstable(feature = "box_into_inner", issue = "80437")]
#[rustc_const_unstable(feature = "const_box", issue = "92521")] #[rustc_const_unstable(feature = "const_box", issue = "92521")]
#[inline] #[inline]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn into_inner(boxed: Self) -> T pub const fn into_inner(boxed: Self) -> T
where where
Self: ~const Drop + ~const Destruct, Self: ~const Destruct,
{ {
*boxed *boxed
} }

1
library/alloc/src/lib.rs
View file

@ -141,7 +141,6 @@
#![feature(box_syntax)] #![feature(box_syntax)]
#![feature(cfg_sanitize)] #![feature(cfg_sanitize)]
#![feature(const_deref)] #![feature(const_deref)]
#![cfg_attr(bootstrap, feature(const_fn_trait_bound))]
#![feature(const_mut_refs)] #![feature(const_mut_refs)]
#![feature(const_ptr_write)] #![feature(const_ptr_write)]
#![feature(const_precise_live_drops)] #![feature(const_precise_live_drops)]

28
library/alloc/src/slice.rs
View file

@ -237,7 +237,6 @@ mod hack {
} }
} }
#[cfg_attr(bootstrap, lang = "slice_alloc")]
#[cfg(not(test))] #[cfg(not(test))]
impl<T> [T] { impl<T> [T] {
/// Sorts the slice. /// Sorts the slice.
@ -267,7 +266,7 @@ impl<T> [T] {
/// assert!(v == [-5, -3, 1, 2, 4]); /// assert!(v == [-5, -3, 1, 2, 4]);
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
pub fn sort(&mut self) pub fn sort(&mut self)
@ -323,7 +322,7 @@ impl<T> [T] {
/// assert!(v == [5, 4, 3, 2, 1]); /// assert!(v == [5, 4, 3, 2, 1]);
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
pub fn sort_by<F>(&mut self, mut compare: F) pub fn sort_by<F>(&mut self, mut compare: F)
@ -365,7 +364,7 @@ impl<T> [T] {
/// assert!(v == [1, 2, -3, 4, -5]); /// assert!(v == [1, 2, -3, 4, -5]);
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "slice_sort_by_key", since = "1.7.0")] #[stable(feature = "slice_sort_by_key", since = "1.7.0")]
#[inline] #[inline]
pub fn sort_by_key<K, F>(&mut self, mut f: F) pub fn sort_by_key<K, F>(&mut self, mut f: F)
@ -412,7 +411,7 @@ impl<T> [T] {
/// ///
/// [pdqsort]: https://github.com/orlp/pdqsort /// [pdqsort]: https://github.com/orlp/pdqsort
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "slice_sort_by_cached_key", since = "1.34.0")] #[stable(feature = "slice_sort_by_cached_key", since = "1.34.0")]
#[inline] #[inline]
pub fn sort_by_cached_key<K, F>(&mut self, f: F) pub fn sort_by_cached_key<K, F>(&mut self, f: F)
@ -471,7 +470,7 @@ impl<T> [T] {
/// // Here, `s` and `x` can be modified independently. /// // Here, `s` and `x` can be modified independently.
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[rustc_conversion_suggestion] #[rustc_conversion_suggestion]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -496,7 +495,7 @@ impl<T> [T] {
/// // Here, `s` and `x` can be modified independently. /// // Here, `s` and `x` can be modified independently.
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[inline] #[inline]
#[unstable(feature = "allocator_api", issue = "32838")] #[unstable(feature = "allocator_api", issue = "32838")]
pub fn to_vec_in<A: Allocator>(&self, alloc: A) -> Vec<T, A> pub fn to_vec_in<A: Allocator>(&self, alloc: A) -> Vec<T, A>
@ -521,7 +520,7 @@ impl<T> [T] {
/// ///
/// assert_eq!(x, vec![10, 40, 30]); /// assert_eq!(x, vec![10, 40, 30]);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> { pub fn into_vec<A: Allocator>(self: Box<Self, A>) -> Vec<T, A> {
@ -549,7 +548,7 @@ impl<T> [T] {
/// // this will panic at runtime /// // this will panic at runtime
/// b"0123456789abcdef".repeat(usize::MAX); /// b"0123456789abcdef".repeat(usize::MAX);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[stable(feature = "repeat_generic_slice", since = "1.40.0")] #[stable(feature = "repeat_generic_slice", since = "1.40.0")]
pub fn repeat(&self, n: usize) -> Vec<T> pub fn repeat(&self, n: usize) -> Vec<T>
@ -618,7 +617,7 @@ impl<T> [T] {
/// assert_eq!(["hello", "world"].concat(), "helloworld"); /// assert_eq!(["hello", "world"].concat(), "helloworld");
/// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]); /// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub fn concat<Item: ?Sized>(&self) -> <Self as Concat<Item>>::Output pub fn concat<Item: ?Sized>(&self) -> <Self as Concat<Item>>::Output
where where
@ -637,7 +636,7 @@ impl<T> [T] {
/// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]); /// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
/// assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]); /// assert_eq!([[1, 2], [3, 4]].join(&[0, 0][..]), [1, 2, 0, 0, 3, 4]);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "rename_connect_to_join", since = "1.3.0")] #[stable(feature = "rename_connect_to_join", since = "1.3.0")]
pub fn join<Separator>(&self, sep: Separator) -> <Self as Join<Separator>>::Output pub fn join<Separator>(&self, sep: Separator) -> <Self as Join<Separator>>::Output
where where
@ -656,7 +655,7 @@ impl<T> [T] {
/// assert_eq!(["hello", "world"].connect(" "), "hello world"); /// assert_eq!(["hello", "world"].connect(" "), "hello world");
/// assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]); /// assert_eq!([[1, 2], [3, 4]].connect(&0), [1, 2, 0, 3, 4]);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_deprecated(since = "1.3.0", reason = "renamed to join")] #[rustc_deprecated(since = "1.3.0", reason = "renamed to join")]
pub fn connect<Separator>(&self, sep: Separator) -> <Self as Join<Separator>>::Output pub fn connect<Separator>(&self, sep: Separator) -> <Self as Join<Separator>>::Output
@ -667,7 +666,6 @@ impl<T> [T] {
} }
} }
#[cfg_attr(bootstrap, lang = "slice_u8_alloc")]
#[cfg(not(test))] #[cfg(not(test))]
impl [u8] { impl [u8] {
/// Returns a vector containing a copy of this slice where each byte /// Returns a vector containing a copy of this slice where each byte
@ -680,7 +678,7 @@ impl [u8] {
/// ///
/// [`make_ascii_uppercase`]: slice::make_ascii_uppercase /// [`make_ascii_uppercase`]: slice::make_ascii_uppercase
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "this returns the uppercase bytes as a new Vec, \ #[must_use = "this returns the uppercase bytes as a new Vec, \
without modifying the original"] without modifying the original"]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
@ -701,7 +699,7 @@ impl [u8] {
/// ///
/// [`make_ascii_lowercase`]: slice::make_ascii_lowercase /// [`make_ascii_lowercase`]: slice::make_ascii_lowercase
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "this returns the lowercase bytes as a new Vec, \ #[must_use = "this returns the lowercase bytes as a new Vec, \
without modifying the original"] without modifying the original"]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]

19
library/alloc/src/str.rs
View file

@ -235,7 +235,6 @@ impl ToOwned for str {
} }
/// Methods for string slices. /// Methods for string slices.
#[cfg_attr(bootstrap, lang = "str_alloc")]
#[cfg(not(test))] #[cfg(not(test))]
impl str { impl str {
/// Converts a `Box<str>` into a `Box<[u8]>` without copying or allocating. /// Converts a `Box<str>` into a `Box<[u8]>` without copying or allocating.
@ -250,7 +249,7 @@ impl str {
/// let boxed_bytes = boxed_str.into_boxed_bytes(); /// let boxed_bytes = boxed_str.into_boxed_bytes();
/// assert_eq!(*boxed_bytes, *s.as_bytes()); /// assert_eq!(*boxed_bytes, *s.as_bytes());
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "str_box_extras", since = "1.20.0")] #[stable(feature = "str_box_extras", since = "1.20.0")]
#[must_use = "`self` will be dropped if the result is not used"] #[must_use = "`self` will be dropped if the result is not used"]
#[inline] #[inline]
@ -281,7 +280,7 @@ impl str {
/// assert_eq!(s, s.replace("cookie monster", "little lamb")); /// assert_eq!(s, s.replace("cookie monster", "little lamb"));
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "this returns the replaced string as a new allocation, \ #[must_use = "this returns the replaced string as a new allocation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
@ -322,7 +321,7 @@ impl str {
/// assert_eq!(s, s.replacen("cookie monster", "little lamb", 10)); /// assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "this returns the replaced string as a new allocation, \ #[must_use = "this returns the replaced string as a new allocation, \
without modifying the original"] without modifying the original"]
#[stable(feature = "str_replacen", since = "1.16.0")] #[stable(feature = "str_replacen", since = "1.16.0")]
@ -379,7 +378,7 @@ impl str {
/// assert_eq!(new_year, new_year.to_lowercase()); /// assert_eq!(new_year, new_year.to_lowercase());
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "this returns the lowercase string as a new String, \ #[must_use = "this returns the lowercase string as a new String, \
without modifying the original"] without modifying the original"]
#[stable(feature = "unicode_case_mapping", since = "1.2.0")] #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
@ -462,7 +461,7 @@ impl str {
/// assert_eq!("TSCHÜSS", s.to_uppercase()); /// assert_eq!("TSCHÜSS", s.to_uppercase());
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "this returns the uppercase string as a new String, \ #[must_use = "this returns the uppercase string as a new String, \
without modifying the original"] without modifying the original"]
#[stable(feature = "unicode_case_mapping", since = "1.2.0")] #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
@ -498,7 +497,7 @@ impl str {
/// assert_eq!(boxed_str.into_string(), string); /// assert_eq!(boxed_str.into_string(), string);
/// ``` /// ```
#[stable(feature = "box_str", since = "1.4.0")] #[stable(feature = "box_str", since = "1.4.0")]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "`self` will be dropped if the result is not used"] #[must_use = "`self` will be dropped if the result is not used"]
#[inline] #[inline]
pub fn into_string(self: Box<str>) -> String { pub fn into_string(self: Box<str>) -> String {
@ -527,7 +526,7 @@ impl str {
/// let huge = "0123456789abcdef".repeat(usize::MAX); /// let huge = "0123456789abcdef".repeat(usize::MAX);
/// ``` /// ```
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use] #[must_use]
#[stable(feature = "repeat_str", since = "1.16.0")] #[stable(feature = "repeat_str", since = "1.16.0")]
pub fn repeat(&self, n: usize) -> String { pub fn repeat(&self, n: usize) -> String {
@ -556,7 +555,7 @@ impl str {
/// [`make_ascii_uppercase`]: str::make_ascii_uppercase /// [`make_ascii_uppercase`]: str::make_ascii_uppercase
/// [`to_uppercase`]: #method.to_uppercase /// [`to_uppercase`]: #method.to_uppercase
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "to uppercase the value in-place, use `make_ascii_uppercase()`"] #[must_use = "to uppercase the value in-place, use `make_ascii_uppercase()`"]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
#[inline] #[inline]
@ -589,7 +588,7 @@ impl str {
/// [`make_ascii_lowercase`]: str::make_ascii_lowercase /// [`make_ascii_lowercase`]: str::make_ascii_lowercase
/// [`to_lowercase`]: #method.to_lowercase /// [`to_lowercase`]: #method.to_lowercase
#[cfg(not(no_global_oom_handling))] #[cfg(not(no_global_oom_handling))]
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "to lowercase the value in-place, use `make_ascii_lowercase()`"] #[must_use = "to lowercase the value in-place, use `make_ascii_lowercase()`"]
#[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")] #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
#[inline] #[inline]

1
library/core/src/array/mod.rs
View file

@ -395,7 +395,6 @@ macro_rules! array_impl_default {
array_impl_default! {32, T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T} array_impl_default! {32, T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T T}
#[cfg_attr(bootstrap, lang = "array")]
impl<T, const N: usize> [T; N] { impl<T, const N: usize> [T; N] {
/// Returns an array of the same size as `self`, with function `f` applied to each element /// Returns an array of the same size as `self`, with function `f` applied to each element
/// in order. /// in order.

7
library/core/src/bool.rs
View file

@ -2,7 +2,6 @@
use crate::marker::Destruct; use crate::marker::Destruct;
#[cfg_attr(bootstrap, lang = "bool")]
impl bool { impl bool {
/// Returns `Some(t)` if the `bool` is [`true`](../std/keyword.true.html), /// Returns `Some(t)` if the `bool` is [`true`](../std/keyword.true.html),
/// or `None` otherwise. /// or `None` otherwise.
@ -18,10 +17,9 @@ impl bool {
#[unstable(feature = "bool_to_option", issue = "80967")] #[unstable(feature = "bool_to_option", issue = "80967")]
#[rustc_const_unstable(feature = "const_bool_to_option", issue = "91917")] #[rustc_const_unstable(feature = "const_bool_to_option", issue = "91917")]
#[inline] #[inline]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn then_some<T>(self, t: T) -> Option<T> pub const fn then_some<T>(self, t: T) -> Option<T>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
{ {
if self { Some(t) } else { None } if self { Some(t) } else { None }
} }
@ -38,11 +36,10 @@ impl bool {
#[stable(feature = "lazy_bool_to_option", since = "1.50.0")] #[stable(feature = "lazy_bool_to_option", since = "1.50.0")]
#[rustc_const_unstable(feature = "const_bool_to_option", issue = "91917")] #[rustc_const_unstable(feature = "const_bool_to_option", issue = "91917")]
#[inline] #[inline]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn then<T, F>(self, f: F) -> Option<T> pub const fn then<T, F>(self, f: F) -> Option<T>
where where
F: ~const FnOnce() -> T, F: ~const FnOnce() -> T,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
if self { Some(f()) } else { None } if self { Some(f()) } else { None }
} }

1
library/core/src/char/methods.rs
View file

@ -7,7 +7,6 @@ use crate::unicode::{self, conversions};
use super::*; use super::*;
#[cfg_attr(bootstrap, lang = "char")]
impl char { impl char {
/// The highest valid code point a `char` can have, `'\u{10FFFF}'`. /// The highest valid code point a `char` can have, `'\u{10FFFF}'`.
/// ///

3
library/core/src/clone.rs
View file

@ -130,10 +130,9 @@ pub trait Clone: Sized {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[default_method_body_is_const] #[default_method_body_is_const]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
fn clone_from(&mut self, source: &Self) fn clone_from(&mut self, source: &Self)
where where
Self: ~const Drop + ~const Destruct, Self: ~const Destruct,
{ {
*self = source.clone() *self = source.clone()
} }

6
library/core/src/intrinsics.rs
View file

@ -2358,7 +2358,6 @@ pub const unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize) {
#[rustc_const_unstable(feature = "const_eval_select", issue = "none")] #[rustc_const_unstable(feature = "const_eval_select", issue = "none")]
#[lang = "const_eval_select"] #[lang = "const_eval_select"]
#[rustc_do_not_const_check] #[rustc_do_not_const_check]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const unsafe fn const_eval_select<ARG, F, G, RET>( pub const unsafe fn const_eval_select<ARG, F, G, RET>(
arg: ARG, arg: ARG,
_called_in_const: F, _called_in_const: F,
@ -2366,7 +2365,7 @@ pub const unsafe fn const_eval_select<ARG, F, G, RET>(
) -> RET ) -> RET
where where
F: ~const FnOnce<ARG, Output = RET>, F: ~const FnOnce<ARG, Output = RET>,
G: FnOnce<ARG, Output = RET> + ~const Drop + ~const Destruct, G: FnOnce<ARG, Output = RET> + ~const Destruct,
{ {
called_at_rt.call_once(arg) called_at_rt.call_once(arg)
} }
@ -2378,7 +2377,6 @@ where
)] )]
#[rustc_const_unstable(feature = "const_eval_select", issue = "none")] #[rustc_const_unstable(feature = "const_eval_select", issue = "none")]
#[lang = "const_eval_select_ct"] #[lang = "const_eval_select_ct"]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const unsafe fn const_eval_select_ct<ARG, F, G, RET>( pub const unsafe fn const_eval_select_ct<ARG, F, G, RET>(
arg: ARG, arg: ARG,
called_in_const: F, called_in_const: F,
@ -2386,7 +2384,7 @@ pub const unsafe fn const_eval_select_ct<ARG, F, G, RET>(
) -> RET ) -> RET
where where
F: ~const FnOnce<ARG, Output = RET>, F: ~const FnOnce<ARG, Output = RET>,
G: FnOnce<ARG, Output = RET> + ~const Drop + ~const Destruct, G: FnOnce<ARG, Output = RET> + ~const Destruct,
{ {
called_in_const.call_once(arg) called_in_const.call_once(arg)
} }

9
library/core/src/lib.rs
View file

@ -84,7 +84,7 @@
target_has_atomic_load_store = "ptr", target_has_atomic_load_store = "ptr",
))] ))]
#![no_core] #![no_core]
#![cfg_attr(not(bootstrap), rustc_coherence_is_core)] #![rustc_coherence_is_core]
// //
// Lints: // Lints:
#![deny(rust_2021_incompatible_or_patterns)] #![deny(rust_2021_incompatible_or_patterns)]
@ -163,15 +163,12 @@
#![feature(cfg_target_has_atomic)] #![feature(cfg_target_has_atomic)]
#![feature(cfg_target_has_atomic_equal_alignment)] #![feature(cfg_target_has_atomic_equal_alignment)]
#![feature(const_fn_floating_point_arithmetic)] #![feature(const_fn_floating_point_arithmetic)]
#![cfg_attr(bootstrap, feature(const_fn_fn_ptr_basics))]
#![cfg_attr(bootstrap, feature(const_fn_trait_bound))]
#![cfg_attr(bootstrap, feature(const_impl_trait))]
#![feature(const_mut_refs)] #![feature(const_mut_refs)]
#![feature(const_precise_live_drops)] #![feature(const_precise_live_drops)]
#![feature(const_refs_to_cell)] #![feature(const_refs_to_cell)]
#![feature(decl_macro)] #![feature(decl_macro)]
#![feature(derive_default_enum)] #![feature(derive_default_enum)]
#![cfg_attr(not(bootstrap), feature(deprecated_suggestion))] #![feature(deprecated_suggestion)]
#![feature(doc_cfg)] #![feature(doc_cfg)]
#![feature(doc_notable_trait)] #![feature(doc_notable_trait)]
#![feature(rustdoc_internals)] #![feature(rustdoc_internals)]
@ -208,7 +205,6 @@
#![feature(asm_const)] #![feature(asm_const)]
// //
// Target features: // Target features:
#![cfg_attr(bootstrap, feature(aarch64_target_feature))]
#![feature(arm_target_feature)] #![feature(arm_target_feature)]
#![feature(avx512_target_feature)] #![feature(avx512_target_feature)]
#![feature(cmpxchg16b_target_feature)] #![feature(cmpxchg16b_target_feature)]
@ -220,7 +216,6 @@
#![feature(sse4a_target_feature)] #![feature(sse4a_target_feature)]
#![feature(tbm_target_feature)] #![feature(tbm_target_feature)]
#![feature(wasm_target_feature)] #![feature(wasm_target_feature)]
#![cfg_attr(bootstrap, feature(adx_target_feature))]
// allow using `core::` in intra-doc links // allow using `core::` in intra-doc links
#[allow(unused_extern_crates)] #[allow(unused_extern_crates)]

11
library/core/src/marker.rs
View file

@ -797,17 +797,10 @@ impl<T: ?Sized> Unpin for *mut T {}
/// This should be used for `~const` bounds, /// This should be used for `~const` bounds,
/// as non-const bounds will always hold for every type. /// as non-const bounds will always hold for every type.
#[unstable(feature = "const_trait_impl", issue = "67792")] #[unstable(feature = "const_trait_impl", issue = "67792")]
#[cfg_attr(not(bootstrap), lang = "destruct")] #[lang = "destruct"]
#[cfg_attr( #[rustc_on_unimplemented(message = "can't drop `{Self}`", append_const_msg)]
not(bootstrap),
rustc_on_unimplemented(message = "can't drop `{Self}`", append_const_msg,)
)]
pub trait Destruct {} pub trait Destruct {}
#[cfg(bootstrap)]
#[unstable(feature = "const_trait_impl", issue = "67792")]
impl<T: ?Sized> const Destruct for T {}
/// Implementations of `Copy` for primitive types. /// Implementations of `Copy` for primitive types.
/// ///
/// Implementations that cannot be described in Rust /// Implementations that cannot be described in Rust

1
library/core/src/num/f32.rs
View file

@ -370,7 +370,6 @@ pub mod consts {
pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32; pub const LN_10: f32 = 2.30258509299404568401799145468436421_f32;
} }
#[cfg_attr(bootstrap, lang = "f32")]
#[cfg(not(test))] #[cfg(not(test))]
impl f32 { impl f32 {
/// The radix or base of the internal representation of `f32`. /// The radix or base of the internal representation of `f32`.

1
library/core/src/num/f64.rs
View file

@ -370,7 +370,6 @@ pub mod consts {
pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64; pub const LN_10: f64 = 2.30258509299404568401799145468436421_f64;
} }
#[cfg_attr(bootstrap, lang = "f64")]
#[cfg(not(test))] #[cfg(not(test))]
impl f64 { impl f64 {
/// The radix or base of the internal representation of `f64`. /// The radix or base of the internal representation of `f64`.

16
library/core/src/num/mod.rs
View file

@ -193,26 +193,22 @@ macro_rules! widening_impl {
}; };
} }
#[cfg_attr(bootstrap, lang = "i8")]
impl i8 { impl i8 {
int_impl! { i8, i8, u8, 8, 7, -128, 127, 2, "-0x7e", "0xa", "0x12", "0x12", "0x48", int_impl! { i8, i8, u8, 8, 7, -128, 127, 2, "-0x7e", "0xa", "0x12", "0x12", "0x48",
"[0x12]", "[0x12]", "", "" } "[0x12]", "[0x12]", "", "" }
} }
#[cfg_attr(bootstrap, lang = "i16")]
impl i16 { impl i16 {
int_impl! { i16, i16, u16, 16, 15, -32768, 32767, 4, "-0x5ffd", "0x3a", "0x1234", "0x3412", int_impl! { i16, i16, u16, 16, 15, -32768, 32767, 4, "-0x5ffd", "0x3a", "0x1234", "0x3412",
"0x2c48", "[0x34, 0x12]", "[0x12, 0x34]", "", "" } "0x2c48", "[0x34, 0x12]", "[0x12, 0x34]", "", "" }
} }
#[cfg_attr(bootstrap, lang = "i32")]
impl i32 { impl i32 {
int_impl! { i32, i32, u32, 32, 31, -2147483648, 2147483647, 8, "0x10000b3", "0xb301", int_impl! { i32, i32, u32, 32, 31, -2147483648, 2147483647, 8, "0x10000b3", "0xb301",
"0x12345678", "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "0x12345678", "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]",
"[0x12, 0x34, 0x56, 0x78]", "", "" } "[0x12, 0x34, 0x56, 0x78]", "", "" }
} }
#[cfg_attr(bootstrap, lang = "i64")]
impl i64 { impl i64 {
int_impl! { i64, i64, u64, 64, 63, -9223372036854775808, 9223372036854775807, 12, int_impl! { i64, i64, u64, 64, 63, -9223372036854775808, 9223372036854775807, 12,
"0xaa00000000006e1", "0x6e10aa", "0x1234567890123456", "0x5634129078563412", "0xaa00000000006e1", "0x6e10aa", "0x1234567890123456", "0x5634129078563412",
@ -220,7 +216,6 @@ impl i64 {
"[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]", "", "" } "[0x12, 0x34, 0x56, 0x78, 0x90, 0x12, 0x34, 0x56]", "", "" }
} }
#[cfg_attr(bootstrap, lang = "i128")]
impl i128 { impl i128 {
int_impl! { i128, i128, u128, 128, 127, -170141183460469231731687303715884105728, int_impl! { i128, i128, u128, 128, 127, -170141183460469231731687303715884105728,
170141183460469231731687303715884105727, 16, 170141183460469231731687303715884105727, 16,
@ -233,7 +228,6 @@ impl i128 {
} }
#[cfg(target_pointer_width = "16")] #[cfg(target_pointer_width = "16")]
#[cfg_attr(bootstrap, lang = "isize")]
impl isize { impl isize {
int_impl! { isize, i16, usize, 16, 15, -32768, 32767, 4, "-0x5ffd", "0x3a", "0x1234", int_impl! { isize, i16, usize, 16, 15, -32768, 32767, 4, "-0x5ffd", "0x3a", "0x1234",
"0x3412", "0x2c48", "[0x34, 0x12]", "[0x12, 0x34]", "0x3412", "0x2c48", "[0x34, 0x12]", "[0x12, 0x34]",
@ -241,7 +235,6 @@ impl isize {
} }
#[cfg(target_pointer_width = "32")] #[cfg(target_pointer_width = "32")]
#[cfg_attr(bootstrap, lang = "isize")]
impl isize { impl isize {
int_impl! { isize, i32, usize, 32, 31, -2147483648, 2147483647, 8, "0x10000b3", "0xb301", int_impl! { isize, i32, usize, 32, 31, -2147483648, 2147483647, 8, "0x10000b3", "0xb301",
"0x12345678", "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "0x12345678", "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]",
@ -250,7 +243,6 @@ impl isize {
} }
#[cfg(target_pointer_width = "64")] #[cfg(target_pointer_width = "64")]
#[cfg_attr(bootstrap, lang = "isize")]
impl isize { impl isize {
int_impl! { isize, i64, usize, 64, 63, -9223372036854775808, 9223372036854775807, int_impl! { isize, i64, usize, 64, 63, -9223372036854775808, 9223372036854775807,
12, "0xaa00000000006e1", "0x6e10aa", "0x1234567890123456", "0x5634129078563412", 12, "0xaa00000000006e1", "0x6e10aa", "0x1234567890123456", "0x5634129078563412",
@ -262,7 +254,6 @@ impl isize {
/// If 6th bit set ascii is upper case. /// If 6th bit set ascii is upper case.
const ASCII_CASE_MASK: u8 = 0b0010_0000; const ASCII_CASE_MASK: u8 = 0b0010_0000;
#[cfg_attr(bootstrap, lang = "u8")]
impl u8 { impl u8 {
uint_impl! { u8, u8, i8, NonZeroU8, 8, 255, 2, "0x82", "0xa", "0x12", "0x12", "0x48", "[0x12]", uint_impl! { u8, u8, i8, NonZeroU8, 8, 255, 2, "0x82", "0xa", "0x12", "0x12", "0x48", "[0x12]",
"[0x12]", "", "" } "[0x12]", "", "" }
@ -816,7 +807,6 @@ impl u8 {
} }
} }
#[cfg_attr(bootstrap, lang = "u16")]
impl u16 { impl u16 {
uint_impl! { u16, u16, i16, NonZeroU16, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48", uint_impl! { u16, u16, i16, NonZeroU16, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
"[0x34, 0x12]", "[0x12, 0x34]", "", "" } "[0x34, 0x12]", "[0x12, 0x34]", "", "" }
@ -848,14 +838,12 @@ impl u16 {
} }
} }
#[cfg_attr(bootstrap, lang = "u32")]
impl u32 { impl u32 {
uint_impl! { u32, u32, i32, NonZeroU32, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678", uint_impl! { u32, u32, i32, NonZeroU32, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
"0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]", "", "" } "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]", "", "" }
widening_impl! { u32, u64, 32, unsigned } widening_impl! { u32, u64, 32, unsigned }
} }
#[cfg_attr(bootstrap, lang = "u64")]
impl u64 { impl u64 {
uint_impl! { u64, u64, i64, NonZeroU64, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa", uint_impl! { u64, u64, i64, NonZeroU64, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa",
"0x1234567890123456", "0x5634129078563412", "0x6a2c48091e6a2c48", "0x1234567890123456", "0x5634129078563412", "0x6a2c48091e6a2c48",
@ -865,7 +853,6 @@ impl u64 {
widening_impl! { u64, u128, 64, unsigned } widening_impl! { u64, u128, 64, unsigned }
} }
#[cfg_attr(bootstrap, lang = "u128")]
impl u128 { impl u128 {
uint_impl! { u128, u128, i128, NonZeroU128, 128, 340282366920938463463374607431768211455, 16, uint_impl! { u128, u128, i128, NonZeroU128, 128, 340282366920938463463374607431768211455, 16,
"0x13f40000000000000000000000004f76", "0x4f7613f4", "0x12345678901234567890123456789012", "0x13f40000000000000000000000004f76", "0x4f7613f4", "0x12345678901234567890123456789012",
@ -878,7 +865,6 @@ impl u128 {
} }
#[cfg(target_pointer_width = "16")] #[cfg(target_pointer_width = "16")]
#[cfg_attr(bootstrap, lang = "usize")]
impl usize { impl usize {
uint_impl! { usize, u16, isize, NonZeroUsize, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48", uint_impl! { usize, u16, isize, NonZeroUsize, 16, 65535, 4, "0xa003", "0x3a", "0x1234", "0x3412", "0x2c48",
"[0x34, 0x12]", "[0x12, 0x34]", "[0x34, 0x12]", "[0x12, 0x34]",
@ -886,7 +872,6 @@ impl usize {
widening_impl! { usize, u32, 16, unsigned } widening_impl! { usize, u32, 16, unsigned }
} }
#[cfg(target_pointer_width = "32")] #[cfg(target_pointer_width = "32")]
#[cfg_attr(bootstrap, lang = "usize")]
impl usize { impl usize {
uint_impl! { usize, u32, isize, NonZeroUsize, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678", uint_impl! { usize, u32, isize, NonZeroUsize, 32, 4294967295, 8, "0x10000b3", "0xb301", "0x12345678",
"0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]", "0x78563412", "0x1e6a2c48", "[0x78, 0x56, 0x34, 0x12]", "[0x12, 0x34, 0x56, 0x78]",
@ -895,7 +880,6 @@ impl usize {
} }
#[cfg(target_pointer_width = "64")] #[cfg(target_pointer_width = "64")]
#[cfg_attr(bootstrap, lang = "usize")]
impl usize { impl usize {
uint_impl! { usize, u64, isize, NonZeroUsize, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa", uint_impl! { usize, u64, isize, NonZeroUsize, 64, 18446744073709551615, 12, "0xaa00000000006e1", "0x6e10aa",
"0x1234567890123456", "0x5634129078563412", "0x6a2c48091e6a2c48", "0x1234567890123456", "0x5634129078563412", "0x6a2c48091e6a2c48",

74
library/core/src/option.rs
View file

@ -773,10 +773,9 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn unwrap_or(self, default: T) -> T pub const fn unwrap_or(self, default: T) -> T
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
{ {
match self { match self {
Some(x) => x, Some(x) => x,
@ -796,11 +795,10 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn unwrap_or_else<F>(self, f: F) -> T pub const fn unwrap_or_else<F>(self, f: F) -> T
where where
F: ~const FnOnce() -> T, F: ~const FnOnce() -> T,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
match self { match self {
Some(x) => x, Some(x) => x,
@ -902,11 +900,10 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn map<U, F>(self, f: F) -> Option<U> pub const fn map<U, F>(self, f: F) -> Option<U>
where where
F: ~const FnOnce(T) -> U, F: ~const FnOnce(T) -> U,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
match self { match self {
Some(x) => Some(f(x)), Some(x) => Some(f(x)),
@ -932,11 +929,10 @@ impl<T> Option<T> {
#[inline] #[inline]
#[unstable(feature = "result_option_inspect", issue = "91345")] #[unstable(feature = "result_option_inspect", issue = "91345")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn inspect<F>(self, f: F) -> Self pub const fn inspect<F>(self, f: F) -> Self
where where
F: ~const FnOnce(&T), F: ~const FnOnce(&T),
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
if let Some(ref x) = self { if let Some(ref x) = self {
f(x); f(x);
@ -966,12 +962,11 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn map_or<U, F>(self, default: U, f: F) -> U pub const fn map_or<U, F>(self, default: U, f: F) -> U
where where
F: ~const FnOnce(T) -> U, F: ~const FnOnce(T) -> U,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
U: ~const Drop + ~const Destruct, U: ~const Destruct,
{ {
match self { match self {
Some(t) => f(t), Some(t) => f(t),
@ -996,13 +991,12 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn map_or_else<U, D, F>(self, default: D, f: F) -> U pub const fn map_or_else<U, D, F>(self, default: D, f: F) -> U
where where
D: ~const FnOnce() -> U, D: ~const FnOnce() -> U,
D: ~const Drop + ~const Destruct, D: ~const Destruct,
F: ~const FnOnce(T) -> U, F: ~const FnOnce(T) -> U,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
match self { match self {
Some(t) => f(t), Some(t) => f(t),
@ -1034,10 +1028,9 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn ok_or<E>(self, err: E) -> Result<T, E> pub const fn ok_or<E>(self, err: E) -> Result<T, E>
where where
E: ~const Drop + ~const Destruct, E: ~const Destruct,
{ {
match self { match self {
Some(v) => Ok(v), Some(v) => Ok(v),
@ -1064,11 +1057,10 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn ok_or_else<E, F>(self, err: F) -> Result<T, E> pub const fn ok_or_else<E, F>(self, err: F) -> Result<T, E>
where where
F: ~const FnOnce() -> E, F: ~const FnOnce() -> E,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
match self { match self {
Some(v) => Ok(v), Some(v) => Ok(v),
@ -1199,11 +1191,10 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn and<U>(self, optb: Option<U>) -> Option<U> pub const fn and<U>(self, optb: Option<U>) -> Option<U>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
U: ~const Drop + ~const Destruct, U: ~const Destruct,
{ {
match self { match self {
Some(_) => optb, Some(_) => optb,
@ -1242,11 +1233,10 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn and_then<U, F>(self, f: F) -> Option<U> pub const fn and_then<U, F>(self, f: F) -> Option<U>
where where
F: ~const FnOnce(T) -> Option<U>, F: ~const FnOnce(T) -> Option<U>,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
match self { match self {
Some(x) => f(x), Some(x) => f(x),
@ -1281,12 +1271,11 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "option_filter", since = "1.27.0")] #[stable(feature = "option_filter", since = "1.27.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn filter<P>(self, predicate: P) -> Self pub const fn filter<P>(self, predicate: P) -> Self
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
P: ~const FnOnce(&T) -> bool, P: ~const FnOnce(&T) -> bool,
P: ~const Drop + ~const Destruct, P: ~const Destruct,
{ {
if let Some(x) = self { if let Some(x) = self {
if predicate(&x) { if predicate(&x) {
@ -1326,10 +1315,9 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn or(self, optb: Option<T>) -> Option<T> pub const fn or(self, optb: Option<T>) -> Option<T>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
{ {
match self { match self {
Some(x) => Some(x), Some(x) => Some(x),
@ -1353,11 +1341,10 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn or_else<F>(self, f: F) -> Option<T> pub const fn or_else<F>(self, f: F) -> Option<T>
where where
F: ~const FnOnce() -> Option<T>, F: ~const FnOnce() -> Option<T>,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
match self { match self {
Some(x) => Some(x), Some(x) => Some(x),
@ -1389,10 +1376,9 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "option_xor", since = "1.37.0")] #[stable(feature = "option_xor", since = "1.37.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn xor(self, optb: Option<T>) -> Option<T> pub const fn xor(self, optb: Option<T>) -> Option<T>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
{ {
match (self, optb) { match (self, optb) {
(Some(a), None) => Some(a), (Some(a), None) => Some(a),
@ -1428,10 +1414,9 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "option_insert", since = "1.53.0")] #[stable(feature = "option_insert", since = "1.53.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn insert(&mut self, value: T) -> &mut T pub const fn insert(&mut self, value: T) -> &mut T
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
{ {
*self = Some(value); *self = Some(value);
@ -1462,10 +1447,9 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "option_entry", since = "1.20.0")] #[stable(feature = "option_entry", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn get_or_insert(&mut self, value: T) -> &mut T pub const fn get_or_insert(&mut self, value: T) -> &mut T
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
{ {
if let None = *self { if let None = *self {
*self = Some(value); *self = Some(value);
@ -1530,11 +1514,10 @@ impl<T> Option<T> {
#[inline] #[inline]
#[stable(feature = "option_entry", since = "1.20.0")] #[stable(feature = "option_entry", since = "1.20.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn get_or_insert_with<F>(&mut self, f: F) -> &mut T pub const fn get_or_insert_with<F>(&mut self, f: F) -> &mut T
where where
F: ~const FnOnce() -> T, F: ~const FnOnce() -> T,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
if let None = *self { if let None = *self {
// the compiler isn't smart enough to know that we are not dropping a `T` // the compiler isn't smart enough to know that we are not dropping a `T`
@ -1645,11 +1628,10 @@ impl<T> Option<T> {
/// ``` /// ```
#[stable(feature = "option_zip_option", since = "1.46.0")] #[stable(feature = "option_zip_option", since = "1.46.0")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn zip<U>(self, other: Option<U>) -> Option<(T, U)> pub const fn zip<U>(self, other: Option<U>) -> Option<(T, U)>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
U: ~const Drop + ~const Destruct, U: ~const Destruct,
{ {
match (self, other) { match (self, other) {
(Some(a), Some(b)) => Some((a, b)), (Some(a), Some(b)) => Some((a, b)),
@ -1687,13 +1669,12 @@ impl<T> Option<T> {
/// ``` /// ```
#[unstable(feature = "option_zip", issue = "70086")] #[unstable(feature = "option_zip", issue = "70086")]
#[rustc_const_unstable(feature = "const_option_ext", issue = "91930")] #[rustc_const_unstable(feature = "const_option_ext", issue = "91930")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
pub const fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R> pub const fn zip_with<U, F, R>(self, other: Option<U>, f: F) -> Option<R>
where where
F: ~const FnOnce(T, U) -> R, F: ~const FnOnce(T, U) -> R,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
T: ~const Drop + ~const Destruct, T: ~const Destruct,
U: ~const Drop + ~const Destruct, U: ~const Destruct,
{ {
match (self, other) { match (self, other) {
(Some(a), Some(b)) => Some(f(a, b)), (Some(a), Some(b)) => Some(f(a, b)),
@ -1880,10 +1861,9 @@ const fn expect_failed(msg: &str) -> ! {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_clone", issue = "91805")] #[rustc_const_unstable(feature = "const_clone", issue = "91805")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
impl<T> const Clone for Option<T> impl<T> const Clone for Option<T>
where where
T: ~const Clone + ~const Drop + ~const Destruct, T: ~const Clone + ~const Destruct,
{ {
#[inline] #[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {

1
library/core/src/panicking.rs
View file

@ -88,7 +88,6 @@ fn panic_bounds_check(index: usize, len: usize) -> ! {
// any extra arguments (including those synthesized by track_caller). // any extra arguments (including those synthesized by track_caller).
#[cold] #[cold]
#[inline(never)] #[inline(never)]
#[cfg_attr(bootstrap, track_caller)]
#[lang = "panic_no_unwind"] // needed by codegen for panic in nounwind function #[lang = "panic_no_unwind"] // needed by codegen for panic in nounwind function
fn panic_no_unwind() -> ! { fn panic_no_unwind() -> ! {
if cfg!(feature = "panic_immediate_abort") { if cfg!(feature = "panic_immediate_abort") {

2
library/core/src/ptr/const_ptr.rs
View file

@ -4,7 +4,6 @@ use crate::intrinsics;
use crate::mem; use crate::mem;
use crate::slice::{self, SliceIndex}; use crate::slice::{self, SliceIndex};
#[cfg_attr(bootstrap, lang = "const_ptr")]
impl<T: ?Sized> *const T { impl<T: ?Sized> *const T {
/// Returns `true` if the pointer is null. /// Returns `true` if the pointer is null.
/// ///
@ -1086,7 +1085,6 @@ impl<T: ?Sized> *const T {
} }
} }
#[cfg_attr(bootstrap, lang = "const_slice_ptr")]
impl<T> *const [T] { impl<T> *const [T] {
/// Returns the length of a raw slice. /// Returns the length of a raw slice.
/// ///

2
library/core/src/ptr/mut_ptr.rs
View file

@ -3,7 +3,6 @@ use crate::cmp::Ordering::{self, Equal, Greater, Less};
use crate::intrinsics; use crate::intrinsics;
use crate::slice::{self, SliceIndex}; use crate::slice::{self, SliceIndex};
#[cfg_attr(bootstrap, lang = "mut_ptr")]
impl<T: ?Sized> *mut T { impl<T: ?Sized> *mut T {
/// Returns `true` if the pointer is null. /// Returns `true` if the pointer is null.
/// ///
@ -1357,7 +1356,6 @@ impl<T: ?Sized> *mut T {
} }
} }
#[cfg_attr(bootstrap, lang = "mut_slice_ptr")]
impl<T> *mut [T] { impl<T> *mut [T] {
/// Returns the length of a raw slice. /// Returns the length of a raw slice.
/// ///

25
library/core/src/result.rs
View file

@ -636,7 +636,7 @@ impl<T, E> Result<T, E> {
#[rustc_const_unstable(feature = "const_result_drop", issue = "92384")] #[rustc_const_unstable(feature = "const_result_drop", issue = "92384")]
pub const fn ok(self) -> Option<T> pub const fn ok(self) -> Option<T>
where where
E: ~const Drop + ~const Destruct, E: ~const Destruct,
{ {
match self { match self {
Ok(x) => Some(x), Ok(x) => Some(x),
@ -667,7 +667,7 @@ impl<T, E> Result<T, E> {
#[rustc_const_unstable(feature = "const_result_drop", issue = "92384")] #[rustc_const_unstable(feature = "const_result_drop", issue = "92384")]
pub const fn err(self) -> Option<E> pub const fn err(self) -> Option<E>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
{ {
match self { match self {
// FIXME: ~const Drop doesn't quite work right yet // FIXME: ~const Drop doesn't quite work right yet
@ -1283,9 +1283,9 @@ impl<T, E> Result<T, E> {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub const fn and<U>(self, res: Result<U, E>) -> Result<U, E> pub const fn and<U>(self, res: Result<U, E>) -> Result<U, E>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
U: ~const Drop + ~const Destruct, U: ~const Destruct,
E: ~const Drop + ~const Destruct, E: ~const Destruct,
{ {
match self { match self {
// FIXME: ~const Drop doesn't quite work right yet // FIXME: ~const Drop doesn't quite work right yet
@ -1368,9 +1368,9 @@ impl<T, E> Result<T, E> {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub const fn or<F>(self, res: Result<T, F>) -> Result<T, F> pub const fn or<F>(self, res: Result<T, F>) -> Result<T, F>
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
E: ~const Drop + ~const Destruct, E: ~const Destruct,
F: ~const Drop + ~const Destruct, F: ~const Destruct,
{ {
match self { match self {
Ok(v) => Ok(v), Ok(v) => Ok(v),
@ -1432,8 +1432,8 @@ impl<T, E> Result<T, E> {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
pub const fn unwrap_or(self, default: T) -> T pub const fn unwrap_or(self, default: T) -> T
where where
T: ~const Drop + ~const Destruct, T: ~const Destruct,
E: ~const Drop + ~const Destruct, E: ~const Destruct,
{ {
match self { match self {
Ok(t) => t, Ok(t) => t,
@ -1803,11 +1803,10 @@ fn unwrap_failed<T>(_msg: &str, _error: &T) -> ! {
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[rustc_const_unstable(feature = "const_clone", issue = "91805")] #[rustc_const_unstable(feature = "const_clone", issue = "91805")]
#[cfg_attr(not(bootstrap), allow(drop_bounds))] // FIXME remove `~const Drop` and this attr when bumping
impl<T, E> const Clone for Result<T, E> impl<T, E> const Clone for Result<T, E>
where where
T: ~const Clone + ~const Drop + ~const Destruct, T: ~const Clone + ~const Destruct,
E: ~const Clone + ~const Drop + ~const Destruct, E: ~const Clone + ~const Destruct,
{ {
#[inline] #[inline]
fn clone(&self) -> Self { fn clone(&self) -> Self {

1
library/core/src/slice/ascii.rs
View file

@ -6,7 +6,6 @@ use crate::iter;
use crate::mem; use crate::mem;
use crate::ops; use crate::ops;
#[cfg_attr(bootstrap, lang = "slice_u8")]
#[cfg(not(test))] #[cfg(not(test))]
impl [u8] { impl [u8] {
/// Checks if all bytes in this slice are within the ASCII range. /// Checks if all bytes in this slice are within the ASCII range.

1
library/core/src/slice/mod.rs
View file

@ -110,7 +110,6 @@ enum Direction {
Back, Back,
} }
#[cfg_attr(bootstrap, lang = "slice")]
#[cfg(not(test))] #[cfg(not(test))]
impl<T> [T] { impl<T> [T] {
/// Returns the number of elements in the slice. /// Returns the number of elements in the slice.

1
library/core/src/str/mod.rs
View file

@ -130,7 +130,6 @@ fn slice_error_fail_rt(s: &str, begin: usize, end: usize) -> ! {
); );
} }
#[cfg_attr(bootstrap, lang = "str")]
#[cfg(not(test))] #[cfg(not(test))]
impl str { impl str {
/// Returns the length of `self`. /// Returns the length of `self`.

2
library/proc_macro/src/lib.rs
View file

@ -20,8 +20,6 @@
#![feature(rustc_allow_const_fn_unstable)] #![feature(rustc_allow_const_fn_unstable)]
#![feature(nll)] #![feature(nll)]
#![feature(staged_api)] #![feature(staged_api)]
#![cfg_attr(bootstrap, feature(const_fn_trait_bound))]
#![cfg_attr(bootstrap, feature(const_fn_fn_ptr_basics))]
#![feature(allow_internal_unstable)] #![feature(allow_internal_unstable)]
#![feature(decl_macro)] #![feature(decl_macro)]
#![feature(extern_types)] #![feature(extern_types)]

3
library/std/src/alloc.rs
View file

@ -315,14 +315,11 @@ pub fn take_alloc_error_hook() -> fn(Layout) {
} }
fn default_alloc_error_hook(layout: Layout) { fn default_alloc_error_hook(layout: Layout) {
#[cfg(not(bootstrap))]
extern "Rust" { extern "Rust" {
// This symbol is emitted by rustc next to __rust_alloc_error_handler. // This symbol is emitted by rustc next to __rust_alloc_error_handler.
// Its value depends on the -Zoom={panic,abort} compiler option. // Its value depends on the -Zoom={panic,abort} compiler option.
static __rust_alloc_error_handler_should_panic: u8; static __rust_alloc_error_handler_should_panic: u8;
} }
#[cfg(bootstrap)]
let __rust_alloc_error_handler_should_panic = 0;
#[allow(unused_unsafe)] #[allow(unused_unsafe)]
if unsafe { __rust_alloc_error_handler_should_panic != 0 } { if unsafe { __rust_alloc_error_handler_should_panic != 0 } {

79
library/std/src/f32.rs
View file

@ -28,7 +28,6 @@ pub use core::f32::{
}; };
#[cfg(not(test))] #[cfg(not(test))]
#[cfg_attr(bootstrap, lang = "f32_runtime")]
impl f32 { impl f32 {
/// Returns the largest integer less than or equal to a number. /// Returns the largest integer less than or equal to a number.
/// ///
@ -43,7 +42,7 @@ impl f32 {
/// assert_eq!(g.floor(), 3.0); /// assert_eq!(g.floor(), 3.0);
/// assert_eq!(h.floor(), -4.0); /// assert_eq!(h.floor(), -4.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -62,7 +61,7 @@ impl f32 {
/// assert_eq!(f.ceil(), 4.0); /// assert_eq!(f.ceil(), 4.0);
/// assert_eq!(g.ceil(), 4.0); /// assert_eq!(g.ceil(), 4.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -82,7 +81,7 @@ impl f32 {
/// assert_eq!(f.round(), 3.0); /// assert_eq!(f.round(), 3.0);
/// assert_eq!(g.round(), -3.0); /// assert_eq!(g.round(), -3.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -103,7 +102,7 @@ impl f32 {
/// assert_eq!(g.trunc(), 3.0); /// assert_eq!(g.trunc(), 3.0);
/// assert_eq!(h.trunc(), -3.0); /// assert_eq!(h.trunc(), -3.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -124,7 +123,7 @@ impl f32 {
/// assert!(abs_difference_x <= f32::EPSILON); /// assert!(abs_difference_x <= f32::EPSILON);
/// assert!(abs_difference_y <= f32::EPSILON); /// assert!(abs_difference_y <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -149,7 +148,7 @@ impl f32 {
/// ///
/// assert!(f32::NAN.abs().is_nan()); /// assert!(f32::NAN.abs().is_nan());
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -173,7 +172,7 @@ impl f32 {
/// ///
/// assert!(f32::NAN.signum().is_nan()); /// assert!(f32::NAN.signum().is_nan());
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -200,7 +199,7 @@ impl f32 {
/// ///
/// assert!(f32::NAN.copysign(1.0).is_nan()); /// assert!(f32::NAN.copysign(1.0).is_nan());
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[inline] #[inline]
#[stable(feature = "copysign", since = "1.35.0")] #[stable(feature = "copysign", since = "1.35.0")]
@ -228,7 +227,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -253,7 +252,7 @@ impl f32 {
/// assert_eq!(a.div_euclid(-b), -1.0); // 7.0 >= -4.0 * -1.0 /// assert_eq!(a.div_euclid(-b), -1.0); // 7.0 >= -4.0 * -1.0
/// assert_eq!((-a).div_euclid(-b), 2.0); // -7.0 >= -4.0 * 2.0 /// assert_eq!((-a).div_euclid(-b), 2.0); // -7.0 >= -4.0 * 2.0
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[inline] #[inline]
#[stable(feature = "euclidean_division", since = "1.38.0")] #[stable(feature = "euclidean_division", since = "1.38.0")]
@ -288,7 +287,7 @@ impl f32 {
/// // limitation due to round-off error /// // limitation due to round-off error
/// assert!((-f32::EPSILON).rem_euclid(3.0) != 0.0); /// assert!((-f32::EPSILON).rem_euclid(3.0) != 0.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[inline] #[inline]
#[stable(feature = "euclidean_division", since = "1.38.0")] #[stable(feature = "euclidean_division", since = "1.38.0")]
@ -309,7 +308,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -327,7 +326,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -352,7 +351,7 @@ impl f32 {
/// assert!(negative.sqrt().is_nan()); /// assert!(negative.sqrt().is_nan());
/// assert!(negative_zero.sqrt() == negative_zero); /// assert!(negative_zero.sqrt() == negative_zero);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -374,7 +373,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -394,7 +393,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -416,7 +415,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -440,7 +439,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -460,7 +459,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -483,7 +482,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -508,7 +507,7 @@ impl f32 {
/// assert!(abs_difference_x <= f32::EPSILON); /// assert!(abs_difference_x <= f32::EPSILON);
/// assert!(abs_difference_y <= f32::EPSILON); /// assert!(abs_difference_y <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -538,7 +537,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -560,7 +559,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -579,7 +578,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -598,7 +597,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -616,7 +615,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -638,7 +637,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -660,7 +659,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -681,7 +680,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -715,7 +714,7 @@ impl f32 {
/// assert!(abs_difference_1 <= f32::EPSILON); /// assert!(abs_difference_1 <= f32::EPSILON);
/// assert!(abs_difference_2 <= f32::EPSILON); /// assert!(abs_difference_2 <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -738,7 +737,7 @@ impl f32 {
/// assert!(abs_difference_0 <= f32::EPSILON); /// assert!(abs_difference_0 <= f32::EPSILON);
/// assert!(abs_difference_1 <= f32::EPSILON); /// assert!(abs_difference_1 <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
pub fn sin_cos(self) -> (f32, f32) { pub fn sin_cos(self) -> (f32, f32) {
@ -759,7 +758,7 @@ impl f32 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -781,7 +780,7 @@ impl f32 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -804,7 +803,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -827,7 +826,7 @@ impl f32 {
/// // Same result /// // Same result
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -850,7 +849,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -870,7 +869,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -890,7 +889,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= f32::EPSILON); /// assert!(abs_difference <= f32::EPSILON);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -910,7 +909,7 @@ impl f32 {
/// ///
/// assert!(abs_difference <= 1e-5); /// assert!(abs_difference <= 1e-5);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]

81
library/std/src/f64.rs
View file

@ -28,7 +28,6 @@ pub use core::f64::{
}; };
#[cfg(not(test))] #[cfg(not(test))]
#[cfg_attr(bootstrap, lang = "f64_runtime")]
impl f64 { impl f64 {
/// Returns the largest integer less than or equal to a number. /// Returns the largest integer less than or equal to a number.
/// ///
@ -43,7 +42,7 @@ impl f64 {
/// assert_eq!(g.floor(), 3.0); /// assert_eq!(g.floor(), 3.0);
/// assert_eq!(h.floor(), -4.0); /// assert_eq!(h.floor(), -4.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -62,7 +61,7 @@ impl f64 {
/// assert_eq!(f.ceil(), 4.0); /// assert_eq!(f.ceil(), 4.0);
/// assert_eq!(g.ceil(), 4.0); /// assert_eq!(g.ceil(), 4.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -82,7 +81,7 @@ impl f64 {
/// assert_eq!(f.round(), 3.0); /// assert_eq!(f.round(), 3.0);
/// assert_eq!(g.round(), -3.0); /// assert_eq!(g.round(), -3.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -103,7 +102,7 @@ impl f64 {
/// assert_eq!(g.trunc(), 3.0); /// assert_eq!(g.trunc(), 3.0);
/// assert_eq!(h.trunc(), -3.0); /// assert_eq!(h.trunc(), -3.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -124,7 +123,7 @@ impl f64 {
/// assert!(abs_difference_x < 1e-10); /// assert!(abs_difference_x < 1e-10);
/// assert!(abs_difference_y < 1e-10); /// assert!(abs_difference_y < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -149,7 +148,7 @@ impl f64 {
/// ///
/// assert!(f64::NAN.abs().is_nan()); /// assert!(f64::NAN.abs().is_nan());
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -173,7 +172,7 @@ impl f64 {
/// ///
/// assert!(f64::NAN.signum().is_nan()); /// assert!(f64::NAN.signum().is_nan());
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -200,7 +199,7 @@ impl f64 {
/// ///
/// assert!(f64::NAN.copysign(1.0).is_nan()); /// assert!(f64::NAN.copysign(1.0).is_nan());
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "copysign", since = "1.35.0")] #[stable(feature = "copysign", since = "1.35.0")]
#[inline] #[inline]
@ -228,7 +227,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -253,7 +252,7 @@ impl f64 {
/// assert_eq!(a.div_euclid(-b), -1.0); // 7.0 >= -4.0 * -1.0 /// assert_eq!(a.div_euclid(-b), -1.0); // 7.0 >= -4.0 * -1.0
/// assert_eq!((-a).div_euclid(-b), 2.0); // -7.0 >= -4.0 * 2.0 /// assert_eq!((-a).div_euclid(-b), 2.0); // -7.0 >= -4.0 * 2.0
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[inline] #[inline]
#[stable(feature = "euclidean_division", since = "1.38.0")] #[stable(feature = "euclidean_division", since = "1.38.0")]
@ -288,7 +287,7 @@ impl f64 {
/// // limitation due to round-off error /// // limitation due to round-off error
/// assert!((-f64::EPSILON).rem_euclid(3.0) != 0.0); /// assert!((-f64::EPSILON).rem_euclid(3.0) != 0.0);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[inline] #[inline]
#[stable(feature = "euclidean_division", since = "1.38.0")] #[stable(feature = "euclidean_division", since = "1.38.0")]
@ -309,7 +308,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -327,7 +326,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -352,7 +351,7 @@ impl f64 {
/// assert!(negative.sqrt().is_nan()); /// assert!(negative.sqrt().is_nan());
/// assert!(negative_zero.sqrt() == negative_zero); /// assert!(negative_zero.sqrt() == negative_zero);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -374,7 +373,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -394,7 +393,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -416,7 +415,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -440,7 +439,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -460,7 +459,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -485,7 +484,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -510,7 +509,7 @@ impl f64 {
/// assert!(abs_difference_x < 1e-10); /// assert!(abs_difference_x < 1e-10);
/// assert!(abs_difference_y < 1e-10); /// assert!(abs_difference_y < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -540,7 +539,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -562,7 +561,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -581,7 +580,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -600,7 +599,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -618,7 +617,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-14); /// assert!(abs_difference < 1e-14);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -640,7 +639,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -662,7 +661,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -683,7 +682,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -717,7 +716,7 @@ impl f64 {
/// assert!(abs_difference_1 < 1e-10); /// assert!(abs_difference_1 < 1e-10);
/// assert!(abs_difference_2 < 1e-10); /// assert!(abs_difference_2 < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -740,7 +739,7 @@ impl f64 {
/// assert!(abs_difference_0 < 1e-10); /// assert!(abs_difference_0 < 1e-10);
/// assert!(abs_difference_1 < 1e-10); /// assert!(abs_difference_1 < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
pub fn sin_cos(self) -> (f64, f64) { pub fn sin_cos(self) -> (f64, f64) {
@ -761,7 +760,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-20); /// assert!(abs_difference < 1e-20);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -783,7 +782,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-20); /// assert!(abs_difference < 1e-20);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -806,7 +805,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1e-10); /// assert!(abs_difference < 1e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -829,7 +828,7 @@ impl f64 {
/// // Same result /// // Same result
/// assert!(abs_difference < 1.0e-10); /// assert!(abs_difference < 1.0e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -852,7 +851,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1.0e-10); /// assert!(abs_difference < 1.0e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -872,7 +871,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1.0e-10); /// assert!(abs_difference < 1.0e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -892,7 +891,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1.0e-10); /// assert!(abs_difference < 1.0e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -912,7 +911,7 @@ impl f64 {
/// ///
/// assert!(abs_difference < 1.0e-10); /// assert!(abs_difference < 1.0e-10);
/// ``` /// ```
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
#[must_use = "method returns a new number and does not mutate the original value"] #[must_use = "method returns a new number and does not mutate the original value"]
#[stable(feature = "rust1", since = "1.0.0")] #[stable(feature = "rust1", since = "1.0.0")]
#[inline] #[inline]
@ -923,7 +922,7 @@ impl f64 {
// Solaris/Illumos requires a wrapper around log, log2, and log10 functions // Solaris/Illumos requires a wrapper around log, log2, and log10 functions
// because of their non-standard behavior (e.g., log(-n) returns -Inf instead // because of their non-standard behavior (e.g., log(-n) returns -Inf instead
// of expected NaN). // of expected NaN).
#[cfg_attr(not(bootstrap), rustc_allow_incoherent_impl)] #[rustc_allow_incoherent_impl]
fn log_wrapper<F: Fn(f64) -> f64>(self, log_fn: F) -> f64 { fn log_wrapper<F: Fn(f64) -> f64>(self, log_fn: F) -> f64 {
if !cfg!(any(target_os = "solaris", target_os = "illumos")) { if !cfg!(any(target_os = "solaris", target_os = "illumos")) {
log_fn(self) log_fn(self)

4
library/std/src/lib.rs
View file

@ -228,12 +228,10 @@
#![feature(c_unwind)] #![feature(c_unwind)]
#![feature(cfg_target_thread_local)] #![feature(cfg_target_thread_local)]
#![feature(concat_idents)] #![feature(concat_idents)]
#![cfg_attr(bootstrap, feature(const_fn_fn_ptr_basics))]
#![cfg_attr(bootstrap, feature(const_fn_trait_bound))]
#![feature(const_mut_refs)] #![feature(const_mut_refs)]
#![feature(const_trait_impl)] #![feature(const_trait_impl)]
#![feature(decl_macro)] #![feature(decl_macro)]
#![cfg_attr(not(bootstrap), feature(deprecated_suggestion))] #![feature(deprecated_suggestion)]
#![feature(doc_cfg)] #![feature(doc_cfg)]
#![feature(doc_cfg_hide)] #![feature(doc_cfg_hide)]
#![feature(doc_masked)] #![feature(doc_masked)]

10
library/test/src/console.rs
View file

@ -103,12 +103,7 @@ impl ConsoleTestState {
exec_time: Option<&TestExecTime>, exec_time: Option<&TestExecTime>,
) -> io::Result<()> { ) -> io::Result<()> {
self.write_log(|| { self.write_log(|| {
let TestDesc { let TestDesc { name, ignore_message, .. } = test;
name,
#[cfg(not(bootstrap))]
ignore_message,
..
} = test;
format!( format!(
"{} {}", "{} {}",
match *result { match *result {
@ -116,14 +111,11 @@ impl ConsoleTestState {
TestResult::TrFailed => "failed".to_owned(), TestResult::TrFailed => "failed".to_owned(),
TestResult::TrFailedMsg(ref msg) => format!("failed: {msg}"), TestResult::TrFailedMsg(ref msg) => format!("failed: {msg}"),
TestResult::TrIgnored => { TestResult::TrIgnored => {
#[cfg(not(bootstrap))]
if let Some(msg) = ignore_message { if let Some(msg) = ignore_message {
format!("ignored: {msg}") format!("ignored: {msg}")
} else { } else {
"ignored".to_owned() "ignored".to_owned()
} }
#[cfg(bootstrap)]
"ignored".to_owned()
} }
TestResult::TrBench(ref bs) => fmt_bench_samples(bs), TestResult::TrBench(ref bs) => fmt_bench_samples(bs),
TestResult::TrTimedFail => "failed (time limit exceeded)".to_owned(), TestResult::TrTimedFail => "failed (time limit exceeded)".to_owned(),

26
library/test/src/formatters/json.rs
View file

@ -120,22 +120,16 @@ impl<T: Write> OutputFormatter for JsonFormatter<T> {
Some(&*format!(r#""message": "{}""#, EscapedString(m))), Some(&*format!(r#""message": "{}""#, EscapedString(m))),
), ),
TestResult::TrIgnored => { TestResult::TrIgnored => self.write_event(
#[cfg(not(bootstrap))] "test",
return self.write_event( desc.name.as_slice(),
"test", "ignored",
desc.name.as_slice(), exec_time,
"ignored", stdout,
exec_time, desc.ignore_message
stdout, .map(|msg| format!(r#""message": "{}""#, EscapedString(msg)))
desc.ignore_message .as_deref(),
.map(|msg| format!(r#""message": "{}""#, EscapedString(msg))) ),
.as_deref(),
);
#[cfg(bootstrap)]
self.write_event("test", desc.name.as_slice(), "ignored", exec_time, stdout, None)
}
TestResult::TrBench(ref bs) => { TestResult::TrBench(ref bs) => {
let median = bs.ns_iter_summ.median as usize; let median = bs.ns_iter_summ.median as usize;

7
library/test/src/formatters/pretty.rs
View file

@ -218,12 +218,7 @@ impl<T: Write> OutputFormatter for PrettyFormatter<T> {
match *result { match *result {
TestResult::TrOk => self.write_ok()?, TestResult::TrOk => self.write_ok()?,
TestResult::TrFailed | TestResult::TrFailedMsg(_) => self.write_failed()?, TestResult::TrFailed | TestResult::TrFailedMsg(_) => self.write_failed()?,
TestResult::TrIgnored => { TestResult::TrIgnored => self.write_ignored(desc.ignore_message)?,
#[cfg(not(bootstrap))]
self.write_ignored(desc.ignore_message)?;
#[cfg(bootstrap)]
self.write_ignored(None)?;
}
TestResult::TrBench(ref bs) => { TestResult::TrBench(ref bs) => {
self.write_bench()?; self.write_bench()?;
self.write_plain(&format!(": {}", fmt_bench_samples(bs)))?; self.write_plain(&format!(": {}", fmt_bench_samples(bs)))?;

19
library/test/src/tests.rs
View file

@ -61,7 +61,6 @@ fn one_ignored_one_unignored_test() -> Vec<TestDescAndFn> {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("1"), name: StaticTestName("1"),
ignore: true, ignore: true,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -74,7 +73,6 @@ fn one_ignored_one_unignored_test() -> Vec<TestDescAndFn> {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("2"), name: StaticTestName("2"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -95,7 +93,6 @@ pub fn do_not_run_ignored_tests() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: true, ignore: true,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -117,7 +114,6 @@ pub fn ignored_tests_result_in_ignored() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: true, ignore: true,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -143,7 +139,6 @@ fn test_should_panic() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::Yes, should_panic: ShouldPanic::Yes,
compile_fail: false, compile_fail: false,
@ -169,7 +164,6 @@ fn test_should_panic_good_message() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::YesWithMessage("error message"), should_panic: ShouldPanic::YesWithMessage("error message"),
compile_fail: false, compile_fail: false,
@ -200,7 +194,6 @@ fn test_should_panic_bad_message() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::YesWithMessage(expected), should_panic: ShouldPanic::YesWithMessage(expected),
compile_fail: false, compile_fail: false,
@ -235,7 +228,6 @@ fn test_should_panic_non_string_message_type() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::YesWithMessage(expected), should_panic: ShouldPanic::YesWithMessage(expected),
compile_fail: false, compile_fail: false,
@ -262,7 +254,6 @@ fn test_should_panic_but_succeeds() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic, should_panic,
compile_fail: false, compile_fail: false,
@ -297,7 +288,6 @@ fn report_time_test_template(report_time: bool) -> Option<TestExecTime> {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -333,7 +323,6 @@ fn time_test_failure_template(test_type: TestType) -> TestResult {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -373,7 +362,6 @@ fn typed_test_desc(test_type: TestType) -> TestDesc {
TestDesc { TestDesc {
name: StaticTestName("whatever"), name: StaticTestName("whatever"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -486,7 +474,6 @@ pub fn exclude_should_panic_option() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName("3"), name: StaticTestName("3"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::Yes, should_panic: ShouldPanic::Yes,
compile_fail: false, compile_fail: false,
@ -511,7 +498,6 @@ pub fn exact_filter_match() {
desc: TestDesc { desc: TestDesc {
name: StaticTestName(name), name: StaticTestName(name),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -601,7 +587,6 @@ fn sample_tests() -> Vec<TestDescAndFn> {
desc: TestDesc { desc: TestDesc {
name: DynTestName((*name).clone()), name: DynTestName((*name).clone()),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -753,7 +738,6 @@ pub fn test_bench_no_iter() {
let desc = TestDesc { let desc = TestDesc {
name: StaticTestName("f"), name: StaticTestName("f"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -776,7 +760,6 @@ pub fn test_bench_iter() {
let desc = TestDesc { let desc = TestDesc {
name: StaticTestName("f"), name: StaticTestName("f"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -793,7 +776,6 @@ fn should_sort_failures_before_printing_them() {
let test_a = TestDesc { let test_a = TestDesc {
name: StaticTestName("a"), name: StaticTestName("a"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,
@ -804,7 +786,6 @@ fn should_sort_failures_before_printing_them() {
let test_b = TestDesc { let test_b = TestDesc {
name: StaticTestName("b"), name: StaticTestName("b"),
ignore: false, ignore: false,
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
should_panic: ShouldPanic::No, should_panic: ShouldPanic::No,
compile_fail: false, compile_fail: false,

1
library/test/src/types.rs
View file

@ -117,7 +117,6 @@ pub struct TestId(pub usize);
pub struct TestDesc { pub struct TestDesc {
pub name: TestName, pub name: TestName,
pub ignore: bool, pub ignore: bool,
#[cfg(not(bootstrap))]
pub ignore_message: Option<&'static str>, pub ignore_message: Option<&'static str>,
pub should_panic: options::ShouldPanic, pub should_panic: options::ShouldPanic,
pub compile_fail: bool, pub compile_fail: bool,

1
library/unwind/src/lib.rs
View file

@ -1,7 +1,6 @@
#![no_std] #![no_std]
#![unstable(feature = "panic_unwind", issue = "32837")] #![unstable(feature = "panic_unwind", issue = "32837")]
#![feature(link_cfg)] #![feature(link_cfg)]
#![cfg_attr(bootstrap, feature(native_link_modifiers))]
#![feature(native_link_modifiers_bundle)] #![feature(native_link_modifiers_bundle)]
#![feature(nll)] #![feature(nll)]
#![feature(staged_api)] #![feature(staged_api)]

1
src/bootstrap/dist.rs
View file

@ -896,6 +896,7 @@ impl Step for PlainSourceTarball {
cmd.arg("vendor") cmd.arg("vendor")
.arg("--sync") .arg("--sync")
.arg(builder.src.join("./src/tools/rust-analyzer/Cargo.toml")) .arg(builder.src.join("./src/tools/rust-analyzer/Cargo.toml"))
.arg("--sync")
.arg(builder.src.join("./compiler/rustc_codegen_cranelift/Cargo.toml")) .arg(builder.src.join("./compiler/rustc_codegen_cranelift/Cargo.toml"))
.current_dir(&plain_dst_src); .current_dir(&plain_dst_src);
builder.run(&mut cmd); builder.run(&mut cmd);

12
src/librustdoc/clean/mod.rs
View file

@ -116,22 +116,14 @@ impl Clean<Option<GenericBound>> for hir::GenericBound<'_> {
) )
} }
hir::GenericBound::Trait(ref t, modifier) => { hir::GenericBound::Trait(ref t, modifier) => {
// `T: ~const Drop` is not equivalent to `T: Drop`, and we don't currently document `~const` bounds
// because of its experimental status, so just don't show these.
// `T: ~const Destruct` is hidden because `T: Destruct` is a no-op. // `T: ~const Destruct` is hidden because `T: Destruct` is a no-op.
if modifier == hir::TraitBoundModifier::MaybeConst if modifier == hir::TraitBoundModifier::MaybeConst
&& [cx.tcx.lang_items().drop_trait(), cx.tcx.lang_items().destruct_trait()] && cx.tcx.lang_items().destruct_trait()
.iter() == Some(t.trait_ref.trait_def_id().unwrap())
.any(|tr| *tr == Some(t.trait_ref.trait_def_id().unwrap()))
{ {
return None; return None;
} }
#[cfg(bootstrap)]
{
// FIXME: remove `lang_items().drop_trait()` from above logic,
// as well as the comment about `~const Drop` because it was renamed to `Destruct`.
}
GenericBound::TraitBound(t.clean(cx), modifier) GenericBound::TraitBound(t.clean(cx), modifier)
} }
}) })

1
src/librustdoc/doctest.rs
View file

@ -1019,7 +1019,6 @@ impl Tester for Collector {
Ignore::None => false, Ignore::None => false,
Ignore::Some(ref ignores) => ignores.iter().any(|s| target_str.contains(s)), Ignore::Some(ref ignores) => ignores.iter().any(|s| target_str.contains(s)),
}, },
#[cfg(not(bootstrap))]
ignore_message: None, ignore_message: None,
// compiler failures are test failures // compiler failures are test failures
should_panic: test::ShouldPanic::No, should_panic: test::ShouldPanic::No,

672
src/stage0.json
View file

@ -2,347 +2,347 @@
"__comment": "Generated by `./x.py run src/tools/bump-stage0`. Run that command again to update the bootstrap compiler.", "__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", "dist_server": "https://static.rust-lang.org",
"compiler": { "compiler": {
"date": "2022-02-22", "date": "2022-04-05",
"version": "beta" "version": "beta"
}, },
"rustfmt": { "rustfmt": {
"date": "2022-02-23", "date": "2022-04-05",
"version": "nightly" "version": "nightly"
}, },
"checksums_sha256": { "checksums_sha256": {
"dist/2022-02-22/cargo-beta-aarch64-apple-darwin.tar.gz": "5b23653987a4157a80be39e7c3560f79b1b40ecdb30ae156170e02f659020e78", "dist/2022-04-05/cargo-beta-aarch64-apple-darwin.tar.gz": "d522845ac8c2644378575b25a742fa1e77030a0ef3e45703fa40b3fc96e2fb28",
"dist/2022-02-22/cargo-beta-aarch64-apple-darwin.tar.xz": "f2e8b34a2b57d9aa876b60d081689371aa2802e4e6ea38329785f2cba3c40dec", "dist/2022-04-05/cargo-beta-aarch64-apple-darwin.tar.xz": "9ebed4b378565e9218f4d415d84b36fc78c92ff8f2a0b5360d5199353dbb2402",
"dist/2022-02-22/cargo-beta-aarch64-pc-windows-msvc.tar.gz": "57d51d004175a2c05892b4edb347300c42cf5764d52f6aabc905e8cd8cb60330", "dist/2022-04-05/cargo-beta-aarch64-pc-windows-msvc.tar.gz": "88e973cd6c4fd1307ed614b7480984ef9b0101b06571f6d241082904acfc4b6b",
"dist/2022-02-22/cargo-beta-aarch64-pc-windows-msvc.tar.xz": "5c0c7698b31394e531dc005b48b6ab78dbf74914cf7daef8e7cc41791adaa061", "dist/2022-04-05/cargo-beta-aarch64-pc-windows-msvc.tar.xz": "dd13d493e02853f7399d886a8a74bfa621c5b2552ae2f50b6000c1dcbb76bd82",
"dist/2022-02-22/cargo-beta-aarch64-unknown-linux-gnu.tar.gz": "1257e6ba753b1328a22730b53da7db3064797d4bda5e02ee79566bec31cf60c3", "dist/2022-04-05/cargo-beta-aarch64-unknown-linux-gnu.tar.gz": "d1d46f8492b1ebd9c3e1845e14d83d49bd03490c6f11f7be9f046c16d8040602",
"dist/2022-02-22/cargo-beta-aarch64-unknown-linux-gnu.tar.xz": "12289ddd9564f7bd25eadfb182d67fbff275244faeb281d918998ba578f5923a", "dist/2022-04-05/cargo-beta-aarch64-unknown-linux-gnu.tar.xz": "95d521fb4530f9fed33ad82227cf0ab517d6ea160549fda8ebefaf66d44e400d",
"dist/2022-02-22/cargo-beta-aarch64-unknown-linux-musl.tar.gz": "8d4d767930996e35c66b2208056b3c57da7cce642650ff3e12ca3e7f8c612d9d", "dist/2022-04-05/cargo-beta-aarch64-unknown-linux-musl.tar.gz": "28f126c940bdf7fbbe27b64e7057f13a5fe03364b38c9898df2aaac9f682a60f",
"dist/2022-02-22/cargo-beta-aarch64-unknown-linux-musl.tar.xz": "a0e0ceeb786273d33d79e939e6aeb015d1e960c88675bd582815ff31312c0948", "dist/2022-04-05/cargo-beta-aarch64-unknown-linux-musl.tar.xz": "ad107be697369008d1fade995cc20c044f9ee53713835a3641f91b2b93dd9e2c",
"dist/2022-02-22/cargo-beta-arm-unknown-linux-gnueabi.tar.gz": "bd92f426ee10d84d162a78955e29d4da7c4c76808d17a81ad599777e76dc8869", "dist/2022-04-05/cargo-beta-arm-unknown-linux-gnueabi.tar.gz": "7fd5000abc9afe72cab7117f64dcdd737003a57302b7289c3113cf1a14d8e454",
"dist/2022-02-22/cargo-beta-arm-unknown-linux-gnueabi.tar.xz": "844c40ed33b03d1cd7a0a82995ef02e33a450155cf1bab36e7b5cddf61ce7ebf", "dist/2022-04-05/cargo-beta-arm-unknown-linux-gnueabi.tar.xz": "5b7576d67dacc763d4d9be0e3be53aa7a1753cb71cd52d82cde79a142afe3541",
"dist/2022-02-22/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz": "0a8e1a8ca38be1356aadf8f6e2f51d2b83ec27c87f3c63c0dc85dba5337b3139", "dist/2022-04-05/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz": "6ec9fbbc71d5e98535673e1e568cd5440c241ce466e1fc9eddf1cac99af7f86d",
"dist/2022-02-22/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz": "de54fbd0cdd17e74e576fc1ad2147542fb82a845ac336c7efb284c6ffaab21c9", "dist/2022-04-05/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz": "4e534c1960382f6084a0250060a048254470c1f498bbc28064878c1029232271",
"dist/2022-02-22/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz": "561b7566dd155b6ea6ae2dd1f6de6ae49b3104df7f6ad5bba59e2505e4a2386b", "dist/2022-04-05/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz": "b59bf7b126c91ac4bda9daefa2403bdc25f7240d72e7bd651d1e9f8e53041d61",
"dist/2022-02-22/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz": "eff55c73491c83b109c2cd4e67f8e82314ddd9abcdbfcc358fb8c2423b31aa8c", "dist/2022-04-05/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz": "e71597532634725eba7dcd85faf0fcb9bdf2fcf372c0a03e9d507ab1420b5576",
"dist/2022-02-22/cargo-beta-i686-pc-windows-gnu.tar.gz": "3766d773de8332b0b6bbff26bdbeb090eaddf12badc37c91280cf26825400796", "dist/2022-04-05/cargo-beta-i686-pc-windows-gnu.tar.gz": "38b0ec02eb2acc51c7088542d3642b2c55c0e042f6d8c1ab3de84652c587411f",
"dist/2022-02-22/cargo-beta-i686-pc-windows-gnu.tar.xz": "55e3553aacaab2139e15d231cb7c328f3abedf6c7014be64fab98b657b12dff3", "dist/2022-04-05/cargo-beta-i686-pc-windows-gnu.tar.xz": "a194fe60bee39f765e4478107c4a5cc23ccb0d25042b0fa9dd1d5a758e7ae5cf",
"dist/2022-02-22/cargo-beta-i686-pc-windows-msvc.tar.gz": "b59118825ceee16f18a73de57da9de3db35715d9c53fe50c9dd3eaaaac0cf234", "dist/2022-04-05/cargo-beta-i686-pc-windows-msvc.tar.gz": "4467065f716670ef5c305d70b68e5375bf542514fdf6645dc92b43759e76213a",
"dist/2022-02-22/cargo-beta-i686-pc-windows-msvc.tar.xz": "f530b478e8de8a1e23f73d0a7f9467835c02f5d5c29cabcaf6b7c8191753d23d", "dist/2022-04-05/cargo-beta-i686-pc-windows-msvc.tar.xz": "78829f8a16ca9e5c389141b050c7b120115420f966a37888320fdc76886ead1d",
"dist/2022-02-22/cargo-beta-i686-unknown-linux-gnu.tar.gz": "40354386ce0a62ae2851ed9cd82e86ff7da8fbce0a0232ba63b71b1ea583af8f", "dist/2022-04-05/cargo-beta-i686-unknown-linux-gnu.tar.gz": "26c423f1667bb0bbede80069be29272877e9ce8f75345f7391f5d1260ec900c1",
"dist/2022-02-22/cargo-beta-i686-unknown-linux-gnu.tar.xz": "d480890b820adf734e4c952e7fc78636b679684ed9bcceb73c4596fb1d45c8e3", "dist/2022-04-05/cargo-beta-i686-unknown-linux-gnu.tar.xz": "b9753f612d59e7d30c3775bcfcaad76df7d0607ad5bdb81041cd40b5690b6239",
"dist/2022-02-22/cargo-beta-mips-unknown-linux-gnu.tar.gz": "36575bdbde3af9f33467608d123b145a35a708c6814e8e66be3736cf38fcf4b8", "dist/2022-04-05/cargo-beta-mips-unknown-linux-gnu.tar.gz": "5e200db1460c1f0bf43fce499debc9602b09c518f13570f6f6f8c86f83ee0f11",
"dist/2022-02-22/cargo-beta-mips-unknown-linux-gnu.tar.xz": "977da6dd9a6865b125222d0a2067d95de6dc1042533df14bb8598e3160cd26f8", "dist/2022-04-05/cargo-beta-mips-unknown-linux-gnu.tar.xz": "8c60fa42bf03826c4cd1eea5d96b57e1772381713d780ea3810cbff62ec23041",
"dist/2022-02-22/cargo-beta-mips64-unknown-linux-gnuabi64.tar.gz": "bac180c4c4d26acb42916f489abdc9bcc98683de2f9437ef56b00b624338db74", "dist/2022-04-05/cargo-beta-mips64-unknown-linux-gnuabi64.tar.gz": "9fcdd60c22211be46e50103a315e0f905d225c61aa42c468760fcd7894dce62d",
"dist/2022-02-22/cargo-beta-mips64-unknown-linux-gnuabi64.tar.xz": "48640b94de8f38bc1c285c6c7a3f973c461d7336acfbec1b2f1eab09294929bf", "dist/2022-04-05/cargo-beta-mips64-unknown-linux-gnuabi64.tar.xz": "ba188f3ab64897109d2039756c01b43b30008479687a76aa236f50ffc99b9b2d",
"dist/2022-02-22/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "870e51831fdb84e927b4556d3f6e1882bd8d3a542d36fd9c59a52333b7671e9d", "dist/2022-04-05/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "18717f3f965fe3b2182f5791451caa938eb8f0ca5e8c1c6ee0eb32b735c50392",
"dist/2022-02-22/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "898ea5ba25d4503092cdbeda226947c4465515e684945dbd16b9009881f1c2c0", "dist/2022-04-05/cargo-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "ba6d2dc52ce330745d8b543906cd0c81114c2f7e22900f6565d1bede93667d59",
"dist/2022-02-22/cargo-beta-mipsel-unknown-linux-gnu.tar.gz": "b5177d9199b585710cf0f9cf65b9d5e9e3372e869a6a1445119566878737358c", "dist/2022-04-05/cargo-beta-mipsel-unknown-linux-gnu.tar.gz": "47e74be39cf947641e37a8f2d41c49b63aba4467b86c89219edee5933b6c92d1",
"dist/2022-02-22/cargo-beta-mipsel-unknown-linux-gnu.tar.xz": "9aa14abb02c8ccd4f9b684c02a544776e0936919f8f7e46698f85a69b7dbcd2d", "dist/2022-04-05/cargo-beta-mipsel-unknown-linux-gnu.tar.xz": "dea6a2f11dd8fa9f93f8e1781d3c7faa04d29dded20f4938cbee60b15e523feb",
"dist/2022-02-22/cargo-beta-powerpc-unknown-linux-gnu.tar.gz": "9d6bd864f629a957172c7fbd20c7549d88248a42f259e6be9f779b4bbb4b09bd", "dist/2022-04-05/cargo-beta-powerpc-unknown-linux-gnu.tar.gz": "f559462b323bf183e8f1f20fb509309e4e88b593f872becd42214f771e860973",
"dist/2022-02-22/cargo-beta-powerpc-unknown-linux-gnu.tar.xz": "988929cb1e75d053c1b081a8a672310447e630195175fd1e54dc5d0ec35783df", "dist/2022-04-05/cargo-beta-powerpc-unknown-linux-gnu.tar.xz": "bd5e9774ddec783e085c9837204de7122eb0469098f93d0768e30ebe3ee165f1",
"dist/2022-02-22/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz": "1b32b43d0ec4989d048223ffdc914656c693ea978e38543b45b1d0c78a6f2c2e", "dist/2022-04-05/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz": "78cba227c038364f02c7ed5d01c5e26ac1bf069f7f0a97e54b9911dde8114c3a",
"dist/2022-02-22/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz": "cd52c1191291ad23dee3a5eea11cb30d2b39e5be56cfbeba72d63add0c1f8689", "dist/2022-04-05/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz": "63514e4afb11b57b58304f246a603ad336b6e95ce6d288cd9d4b834b8e531eab",
"dist/2022-02-22/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz": "54126eee55aadba389058e4114e57898604398a3638cec33cb06f0b08f19c293", "dist/2022-04-05/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz": "5495f5a77fd354c2d8ed9de86052a1c6528092afdc8af66be532859dddafcd5d",
"dist/2022-02-22/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz": "04c0333e2ed44f0c6c24583f8dd08041bff444024407b5b15ca4679830d00748", "dist/2022-04-05/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz": "4ab4e7674bb927919dc7e4a3a6037978c260ff97966a18409c4b9ae4e1802c4a",
"dist/2022-02-22/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz": "d06c620327fbfbff716ac80c569fa3f93d21a137653226c3417a32978d7c21fa", "dist/2022-04-05/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz": "9baf8bceb40d728eb1ed47ea572d1b890fd36762ad7b119c9de6f7378682fe7b",
"dist/2022-02-22/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz": "dc9c6058c0612b9e75f17785571f334e3ab07d7d41e7e6892a9f176a032efbfb", "dist/2022-04-05/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz": "0ef8e9ed9e401a688af6aab9f928ff6b860ddd5449f0becb2216d2206f45ec45",
"dist/2022-02-22/cargo-beta-s390x-unknown-linux-gnu.tar.gz": "41740c9043a17a6f94ccc9b1ce3e651bd5c1d40082573c2603fc467e3e7211d6", "dist/2022-04-05/cargo-beta-s390x-unknown-linux-gnu.tar.gz": "d442fb0a4b8f56f7c008d53b15ba2a34d6e08701e0a69b2204e9c64ef32eb4c9",
"dist/2022-02-22/cargo-beta-s390x-unknown-linux-gnu.tar.xz": "9f35c90f54fd109dc89101dc4f400c1e2274c73dd830ea47032f6669f17d2281", "dist/2022-04-05/cargo-beta-s390x-unknown-linux-gnu.tar.xz": "5a4d757fbdbd0581e26ce997e33663789630d20620cd3fefc70ab866849c3850",
"dist/2022-02-22/cargo-beta-x86_64-apple-darwin.tar.gz": "bb2df47156ed411068df28b2f3da9cbd1a43e87da92b79b08f49c9ec1b7acf9a", "dist/2022-04-05/cargo-beta-x86_64-apple-darwin.tar.gz": "03d0ec29bdffbe606e70a96614e44e0e65eaba38ecae4a9aca2e202a8891eb56",
"dist/2022-02-22/cargo-beta-x86_64-apple-darwin.tar.xz": "1e28f97bba0788d8666ea99dc6794f14246248d2215ca954523a022f32f0032a", "dist/2022-04-05/cargo-beta-x86_64-apple-darwin.tar.xz": "76149cbf429502b9c1fc71a6bff9d38b24f575bc43caf26143552e2658bde544",
"dist/2022-02-22/cargo-beta-x86_64-pc-windows-gnu.tar.gz": "ec819340d489948ca3376011e504163b2b8aa4a795757b76c680d7827a894d51", "dist/2022-04-05/cargo-beta-x86_64-pc-windows-gnu.tar.gz": "ef7bbf4aaf758aa8c3ef74e68f8a39a6b1b2bad0ecfc90a0a49ceee41f5aef80",
"dist/2022-02-22/cargo-beta-x86_64-pc-windows-gnu.tar.xz": "74e39561dec9a133d98e85f05659353fe5123b813e2042a6e1d1aeff44f8f018", "dist/2022-04-05/cargo-beta-x86_64-pc-windows-gnu.tar.xz": "23d15d39aacfbb1cc382cf2e88d9d688827c867e1b4778ab24d66579e766bd22",
"dist/2022-02-22/cargo-beta-x86_64-pc-windows-msvc.tar.gz": "43c4071dde2a487211ccb8b70738dd9f2bff6d629c10c676387bcf3dd1bbdbe5", "dist/2022-04-05/cargo-beta-x86_64-pc-windows-msvc.tar.gz": "20b0427583732b542b1274837d61b4f25a72c3810433d91bd31013daebfca54d",
"dist/2022-02-22/cargo-beta-x86_64-pc-windows-msvc.tar.xz": "14aa403752daef201d9c62efaf342fa9070f1acd15417a212840dec9b04e0bf6", "dist/2022-04-05/cargo-beta-x86_64-pc-windows-msvc.tar.xz": "827699b4f5ad3a810d2cbae8fb0c0e3b2724b054d7b7505cebd1af5efbeb592c",
"dist/2022-02-22/cargo-beta-x86_64-unknown-freebsd.tar.gz": "dd186508224dddd5fd701741913bfabfc0a11ac4ec3268e4089ff20a9e6db851", "dist/2022-04-05/cargo-beta-x86_64-unknown-freebsd.tar.gz": "bcbd4379d77d42bdb665a8583daae4bf101b0f3f6588c148c80d72f1c60c5267",
"dist/2022-02-22/cargo-beta-x86_64-unknown-freebsd.tar.xz": "051a08c9a74150e706f683c96ed1a89531d75622a379e738f27c838317f1aa0e", "dist/2022-04-05/cargo-beta-x86_64-unknown-freebsd.tar.xz": "832c90d532ffcba10039f1244bf06c7121ddd3b7fd7c0d913b62fd0ad82e1dce",
"dist/2022-02-22/cargo-beta-x86_64-unknown-illumos.tar.gz": "ed980715be8e3e8354656e09b0b8fd265a1009c7af3c77a0da7ee297c746d465", "dist/2022-04-05/cargo-beta-x86_64-unknown-illumos.tar.gz": "7af1097744bfaa50b7d019025fc8b940363f9f5665f5247edf8374115ce074cd",
"dist/2022-02-22/cargo-beta-x86_64-unknown-illumos.tar.xz": "119943b8a0c62839de252a372960c93124b99de1b918122d2798dadac8658918", "dist/2022-04-05/cargo-beta-x86_64-unknown-illumos.tar.xz": "f6d2a741b41e26877a3c5f0a8337ebd563370b839c69091acf9535a1c2d6046c",
"dist/2022-02-22/cargo-beta-x86_64-unknown-linux-gnu.tar.gz": "1738f1416773c85571414162ba894a753db03fcac9770012358f64db341fedd3", "dist/2022-04-05/cargo-beta-x86_64-unknown-linux-gnu.tar.gz": "477b6914f38919af61ecb2889032ffc2b12fee6ef85967a28bab6baf71df4baf",
"dist/2022-02-22/cargo-beta-x86_64-unknown-linux-gnu.tar.xz": "eac6a6deb3a7cf0d9d6c0d474cf3af2c3fb6a27f047c59e39549af219a04e487", "dist/2022-04-05/cargo-beta-x86_64-unknown-linux-gnu.tar.xz": "e91b851cd4a2cac68264bb47431943556e6b8c30df74d8a755e655df171acb47",
"dist/2022-02-22/cargo-beta-x86_64-unknown-linux-musl.tar.gz": "20d7ee9d7234395840b2478681ce4d79bf71045ae218d61f6b54ab9476dc39a1", "dist/2022-04-05/cargo-beta-x86_64-unknown-linux-musl.tar.gz": "3218da520fd9fa9f70f78b1fbf2d69b74842d1cfd3e578eb5b4233b0632d2525",
"dist/2022-02-22/cargo-beta-x86_64-unknown-linux-musl.tar.xz": "3eaf0ea2187a5483738aef57c1a72e90fd7d2f1f43d161b4312a88a2afb5fb36", "dist/2022-04-05/cargo-beta-x86_64-unknown-linux-musl.tar.xz": "5e492a006cef711748772bf3b6e25fdf400316d1392a8391fc005a88d6d8cf0f",
"dist/2022-02-22/cargo-beta-x86_64-unknown-netbsd.tar.gz": "7359595da468c6a22e42c8cc1918034e1efada2458281354d378c6921fd839bb", "dist/2022-04-05/cargo-beta-x86_64-unknown-netbsd.tar.gz": "b5164be552ff72bb0f19076c8ae3d0057ef6cf219df032d34130f98abfa07feb",
"dist/2022-02-22/cargo-beta-x86_64-unknown-netbsd.tar.xz": "901fced3b888c3d117b7ce5dae9f670b5a3251572d6e2dc2b143c734e38ac683", "dist/2022-04-05/cargo-beta-x86_64-unknown-netbsd.tar.xz": "d641e7e17c4720f961f52353a0a5214683b019a3acf1c1939d9f9710053496cb",
"dist/2022-02-22/rust-std-beta-aarch64-apple-darwin.tar.gz": "dca112bb73d3db03df91770cda1a90f130fa19e80657bae8c70c9737a1739f0b", "dist/2022-04-05/rust-std-beta-aarch64-apple-darwin.tar.gz": "d81a9d0e3e6fe59849977a77acb3b3aebbf76465176a03a45cde34982488dc80",
"dist/2022-02-22/rust-std-beta-aarch64-apple-darwin.tar.xz": "5d86a54ac7a3da08eee4401cbdca416b88f47e3f873bf77aa09f9d8259bde015", "dist/2022-04-05/rust-std-beta-aarch64-apple-darwin.tar.xz": "001be52129c7e9d08cad4c337eee8515dbe71c17bf06dccbb4b17b6deb59eaed",
"dist/2022-02-22/rust-std-beta-aarch64-apple-ios-sim.tar.gz": "7496f9dc8cab45f14ff01c3ceb7938dd2532b802903aade5775f1311e29a2191", "dist/2022-04-05/rust-std-beta-aarch64-apple-ios-sim.tar.gz": "ebf3720b48a89422c473aa40645f8b4e02164b2e57a66e477c320836dfda8589",
"dist/2022-02-22/rust-std-beta-aarch64-apple-ios-sim.tar.xz": "fb0704f0b2dd9cbee2a7b887963c15fd5c3391425632362161d59e94c81b608e", "dist/2022-04-05/rust-std-beta-aarch64-apple-ios-sim.tar.xz": "dcaea0924b93a34f8ed5a3043fc752a7fdd74e93747584b4852582601ad4e0c7",
"dist/2022-02-22/rust-std-beta-aarch64-apple-ios.tar.gz": "b63c47df8f9ee3a498248898d465dd24c2de842d3a61e2a7850fc10348c65080", "dist/2022-04-05/rust-std-beta-aarch64-apple-ios.tar.gz": "713438516e54c2451327d15b62ec02439fb1734897e5193dbef4c74a72c3b3d9",
"dist/2022-02-22/rust-std-beta-aarch64-apple-ios.tar.xz": "d25ee7959831231a1661f95ca11bd3fbd5cb177ae8cd82bb3fb33889e8a081df", "dist/2022-04-05/rust-std-beta-aarch64-apple-ios.tar.xz": "6ddc798abdeb7b10389fbd1d4870df7c64983a1f2a2aaddebe3ec3a10c7124b9",
"dist/2022-02-22/rust-std-beta-aarch64-fuchsia.tar.gz": "06fa5e122904ff03b1e0e9218a58b7c492c3cbb57e2d26e255171f6c7734f5b7", "dist/2022-04-05/rust-std-beta-aarch64-fuchsia.tar.gz": "7d74750469755e6171e5ee467eb82f9da6fc659f54eb0713656bcdd0effb1770",
"dist/2022-02-22/rust-std-beta-aarch64-fuchsia.tar.xz": "8b4a60e54a255c5eb45545c78c4b43d78527777f874a8a9b215999b414c3dbec", "dist/2022-04-05/rust-std-beta-aarch64-fuchsia.tar.xz": "c1023c97eb2be40c80f83e7fe5b20367cffb3e52515f5e0ecf45201835088d78",
"dist/2022-02-22/rust-std-beta-aarch64-linux-android.tar.gz": "7209d2f4fb41fe00afee1d49246228fecd955930abac317f7ae608a4eb27f834", "dist/2022-04-05/rust-std-beta-aarch64-linux-android.tar.gz": "7819b5e29f097b32408fead0fc281ac8fa477cec0141688e0a82233cf37789ab",
"dist/2022-02-22/rust-std-beta-aarch64-linux-android.tar.xz": "ad8aac4d753c357fb39408c01567a95710f95c73b5589d37304f6d8eedf43ea9", "dist/2022-04-05/rust-std-beta-aarch64-linux-android.tar.xz": "51ff2b862d2d6bbc2610041011ed0ef3fae0647d422dbda1613cfc9d900652e9",
"dist/2022-02-22/rust-std-beta-aarch64-pc-windows-msvc.tar.gz": "0e25c7a39e32cd3dff61a2972df5e5a08f743d505d0a1e99a26768b3d0abc44a", "dist/2022-04-05/rust-std-beta-aarch64-pc-windows-msvc.tar.gz": "ab90419c8552c7bd7e5381ae6d15788d7b4f8f903395ec2b5b7ef1d561453805",
"dist/2022-02-22/rust-std-beta-aarch64-pc-windows-msvc.tar.xz": "63f7d6967c920135bfdc45e4867579ffe5858d1608777bae0c64e3bb74180bc9", "dist/2022-04-05/rust-std-beta-aarch64-pc-windows-msvc.tar.xz": "6b293b6df7f7b22ddd0dc1dada083176ae60df3624ee29430106c04f0ee4f262",
"dist/2022-02-22/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz": "e1688baa8a9681e8975885def8ef160da31f79d4b767fdfffda0eb4a281c4a20", "dist/2022-04-05/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz": "104c2f1c3b84024fb03e13da89a0a416d67659a8dc8b582e28c7697fe3f43224",
"dist/2022-02-22/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz": "07acb0382de4c967421ad62367c4585e567ac16f82b2c6d2bac4218999ea217e", "dist/2022-04-05/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz": "35d7787bc6c2d123e6b5e8ccb0ea0070a674050ff3dab80283e4c193b8617f37",
"dist/2022-02-22/rust-std-beta-aarch64-unknown-linux-musl.tar.gz": "9abe9e57210890632319ae175e4ff10d4c05d505820e6e6d4b694a84e57b3e53", "dist/2022-04-05/rust-std-beta-aarch64-unknown-linux-musl.tar.gz": "00fd161285c90a65134a31152dcab92dafd82ca41f94bde84b6beb94dd98e934",
"dist/2022-02-22/rust-std-beta-aarch64-unknown-linux-musl.tar.xz": "cf9edb113ce62b71b7e6d535c2d0c153fb0041a86ccf22393c7fa1bde99ff589", "dist/2022-04-05/rust-std-beta-aarch64-unknown-linux-musl.tar.xz": "c3bf923b7025fd3ddb70f79b36ac540f1a3a0d065eefe0e650ce8a3cdadb7a7f",
"dist/2022-02-22/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz": "1d378a8eff18de4487f6edda01f9c9f991b0f3dc575be062d5faa04f0489dff1", "dist/2022-04-05/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz": "05788212f632c0b83c7aa83ceace41efaba1b90066dccdb40e2ba8e5ebc1b405",
"dist/2022-02-22/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz": "84c23145e5ce8fe37088d413e3bc4072cbe662feb0400895e91e924515c4d8ac", "dist/2022-04-05/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz": "3095a6a9d5ed80cece5ea0dade7bc00790055ac789866c0c51c6e05134f4b26f",
"dist/2022-02-22/rust-std-beta-aarch64-unknown-none.tar.gz": "04a154058d8014608bbde9e70a85bb1943c58053ac64119ea84be70a1a085c35", "dist/2022-04-05/rust-std-beta-aarch64-unknown-none.tar.gz": "9cc86be630b5ec83447fb1595a0afecb22a05d9ce89d73af39fb4edc43c37a8c",
"dist/2022-02-22/rust-std-beta-aarch64-unknown-none.tar.xz": "6edde8a372c29756b54fccf54232fee7899625eb6c5529658024028ae4f8a471", "dist/2022-04-05/rust-std-beta-aarch64-unknown-none.tar.xz": "43437ce5b50c45e757957d2d7df354ca6e244b77081d03bde8e519cac2d03fa1",
"dist/2022-02-22/rust-std-beta-arm-linux-androideabi.tar.gz": "b1670696b4aa52daa390a5c9ce26056507a11ff883d98ed6e84a7f04b38ee7a2", "dist/2022-04-05/rust-std-beta-arm-linux-androideabi.tar.gz": "1f30c740549ab4ee2641ab08f7339798a69a13edf4ee928462d7fe5c3d49e1c2",
"dist/2022-02-22/rust-std-beta-arm-linux-androideabi.tar.xz": "2cb4a03fb3b8d8556c359c4d4f1823dbef3a22f0483e43f41ee154333a202ec8", "dist/2022-04-05/rust-std-beta-arm-linux-androideabi.tar.xz": "64032f816c38fb0ea0db6be3c69de702ba6301800cb7c437f547257c3c88ad72",
"dist/2022-02-22/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz": "46f7ba3b96a9088f242a0ad191ca320529d9798d8842d41accd14622fb7b6750", "dist/2022-04-05/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz": "54de198103c4a8c2463261e7e4fbbf0104294e5a56e663fc75b4f6606d7e5609",
"dist/2022-02-22/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz": "091190cccf966aeb6d387fb6542ad43f7f38b6843a13309f92df2f759a4045dd", "dist/2022-04-05/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz": "50e690bb090230e61a70d34d4191a3a8aedc7e2079ceeb70bc780ae718fa5719",
"dist/2022-02-22/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz": "4d1740f7d33566e2642d1618d9c6cd0c0650d39af5d428dfd993a4f65e27e3c6", "dist/2022-04-05/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz": "56040245d9707a90f62ce33ed45c75110b1f5de50c98b4276d3b0303ca457ca0",
"dist/2022-02-22/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz": "4d4c2f1fb3319030b978d1343b80a34c22b3c4df58ef1dbce9eddc42a0e9ac41", "dist/2022-04-05/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz": "ea33048f8bd7057b80db565ead072ba3830ac54e9cd9120514d86c0a71398138",
"dist/2022-02-22/rust-std-beta-arm-unknown-linux-musleabi.tar.gz": "d7ad7df20a41f7df39fd0973f37740d0c732468de6e099febc13db7f871860b4", "dist/2022-04-05/rust-std-beta-arm-unknown-linux-musleabi.tar.gz": "627ff5136cb18eeaae03303cb265f5492a57f53fb329fe0d362084697d4de4d5",
"dist/2022-02-22/rust-std-beta-arm-unknown-linux-musleabi.tar.xz": "598c5ab98d3a3ffeb4f3aaf5535d8947e6ae6d45aa0071438f9490dd63acf7b5", "dist/2022-04-05/rust-std-beta-arm-unknown-linux-musleabi.tar.xz": "d996b8ee3452f5d4dfd758b5ac835dd77ee9f050496d1745fa553901812b843f",
"dist/2022-02-22/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz": "46d2276ab614e5f4d1f990824fd2b67c9398c669a01698c8a4b157bd45e3eedb", "dist/2022-04-05/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz": "86303fe3be5da53633630de44f58ee11475624d4ef4bce4f8a91d48f80bc03da",
"dist/2022-02-22/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz": "f404d2c3d89ae820112a324a3c5bf127efb6fb31813138c0fde99948eea7d76f", "dist/2022-04-05/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz": "14dc9ed9584f7c55967831c97862cfd3cc7ae5e6cbc65936e4ecd0bd9d75fb30",
"dist/2022-02-22/rust-std-beta-armebv7r-none-eabi.tar.gz": "8c8c547387db74673c1954b8ac1cdeff5b726d432581649bc60f988acb0352e2", "dist/2022-04-05/rust-std-beta-armebv7r-none-eabi.tar.gz": "be874fc36bf175eed366db71d0905974153a3339bc84f8abda83c482197a4235",
"dist/2022-02-22/rust-std-beta-armebv7r-none-eabi.tar.xz": "2942966353af6f1a29c3266e1f35e3f1bf49a7d555a6034dda72c31b7e83b89d", "dist/2022-04-05/rust-std-beta-armebv7r-none-eabi.tar.xz": "c10c6cf39bf5f5360eddc1a6caedb79ba04ab227336e718b3a45f4a2f3c357c6",
"dist/2022-02-22/rust-std-beta-armebv7r-none-eabihf.tar.gz": "3b80afad86c655b5be24ddb8348c3d5781006053c14932ab2855be525c35108b", "dist/2022-04-05/rust-std-beta-armebv7r-none-eabihf.tar.gz": "6b429165fe0d52c6dfa74beef81d6b136f7fc35cd60ba2637af64f5195c7a018",
"dist/2022-02-22/rust-std-beta-armebv7r-none-eabihf.tar.xz": "3b55016a3f27aa0381eb502e2d732aa9397aac117e98d4fb4721587b62ac7842", "dist/2022-04-05/rust-std-beta-armebv7r-none-eabihf.tar.xz": "c4913f09cc858f0f2b9870f12714de055e1658b4b708ec78a1cc14428e72912c",
"dist/2022-02-22/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz": "2c17d2a504c4f7aa581731bbfa9eecc1638b9bdc8800d136da1a6d248ec70e76", "dist/2022-04-05/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz": "64ab028aa4d304c7a4a09bcaadb45f094f3c76fd17eb72afb29cc57d127ef743",
"dist/2022-02-22/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz": "78dcb72afa5187b7ae91a1ccc2e7978b30cab8eaaa46cb09a62266868c866ad3", "dist/2022-04-05/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz": "4e2de3902e62ced0910bcc63d425a06e46c003ebc7111d0308637385817582f2",
"dist/2022-02-22/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz": "d42741e9ea6f23fc88dada5e9339cf7fb3015d3713335b77543afeaafdfcbb53", "dist/2022-04-05/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz": "8847d73f6da535f4cb700c5da8e9f330710663cd8486bb014c0c67dfe238237e",
"dist/2022-02-22/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz": "ecd0e30fbd08fc8dbf478ddfb7a48b619b84b04c687bdcd56259b64f9ccedea1", "dist/2022-04-05/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz": "85568b12784c98a331ccf6e2719a6d56261356d87a1142e4a72b9f7438a82380",
"dist/2022-02-22/rust-std-beta-armv7-linux-androideabi.tar.gz": "b4fedc281f748c443232bf061fde9dccbf415eec62053103a270613689c4cf1a", "dist/2022-04-05/rust-std-beta-armv7-linux-androideabi.tar.gz": "825fb7e878534ac9e3c05240ba52110bf253602cb39aba8aef31f54695d06cc5",
"dist/2022-02-22/rust-std-beta-armv7-linux-androideabi.tar.xz": "bae884d552a8d234efa795b5b56524cb834f06c77000e926bc0bd1446387174d", "dist/2022-04-05/rust-std-beta-armv7-linux-androideabi.tar.xz": "8ec0897de57b4e920a2419aa5af36fe421276306e61e6e0263f056f6769ff0b0",
"dist/2022-02-22/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz": "116c08ac9ca36e0d3d0bb86d0d25db8f19b508d851b93c6a738711400e1faf93", "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz": "6664d7becfe4bcfda1e86eccf3f20cd549d9b7f3d3fc72f70f53da36a91016b8",
"dist/2022-02-22/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz": "d15b7e02a7fdf7d45d0269b4c739a96dda4f22ef70d7a3a2b098527b34f81b76", "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz": "13da845aab759efa0e690731beee1a51d662083aac6bb03451501bd21332397e",
"dist/2022-02-22/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz": "86390d1528d0382109ae094005b35d84ccb5e6bc670a490d2c8e27010efafb13", "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz": "fe311715bee972d5b5ef669c93fa9d5d39a6ff5309d9f82150c0f3be72222d3b",
"dist/2022-02-22/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz": "fb23bfcadc53baf72793718b051710a6bfa6575f8fb7104925157681b1efdc3f", "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz": "e2937e4c67a6e5af57e79149d8595a24a6114bc877cd13dd568e719dce28162e",
"dist/2022-02-22/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz": "f34cce7af6d123b9c509f28d63f10397ebbea74b6181b819d022f700521dec7d", "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz": "24209ff3a9431b58f0f7846a8f673c81488429efe6947049ac9c19523d071d83",
"dist/2022-02-22/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz": "2777e62cbd8ddd5dce730f4a6671dffac132ecf194a8840178d178296264879e", "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz": "ed1cde412c615ffa422f27cf347b8276c68281528cdd6d2642f290ccfbdf2ba5",
"dist/2022-02-22/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz": "4e6f11b82e57c60ab5e4329bcb0c5384f9bc2044ee8f194c3022949855389ab8", "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz": "b028af36212e244ce2eaf213bcc68c52783425a982465d422202fe2d1ad806ab",
"dist/2022-02-22/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz": "a45eaf577ddf69ebd8eb7b112bf2b79ffa7a3360ef959f6bfb5f0a5e634ede48", "dist/2022-04-05/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz": "5b4fe3ec165f16cb29d7660b762ad8de84d9c56d9cac90b11d521de3162485d4",
"dist/2022-02-22/rust-std-beta-armv7a-none-eabi.tar.gz": "66fc6787cf5060b8d279d325ef745dc37206335a9e279bb7f3687b6564f3bdab", "dist/2022-04-05/rust-std-beta-armv7a-none-eabi.tar.gz": "2cfab91a43151c6680932212732f4bb689dd93a7252e08b291ec56a02ea7642f",
"dist/2022-02-22/rust-std-beta-armv7a-none-eabi.tar.xz": "3996d7a5e7721262fed35af65949523510544eb3942c97dbcd231f84770edb7a", "dist/2022-04-05/rust-std-beta-armv7a-none-eabi.tar.xz": "503cb200deab12a4cbe8f907823d1e3b63bf2729d1a878e7b7a3d495415f4036",
"dist/2022-02-22/rust-std-beta-armv7r-none-eabi.tar.gz": "be50c97fd48c7209b2b452f3f9c00cca1fd26f8482b4c5bec46b9a32dbbf9cf1", "dist/2022-04-05/rust-std-beta-armv7r-none-eabi.tar.gz": "b4b756f4c8100a377211cc74d5040fd23bb0231b45841fc8929067f8435a3871",
"dist/2022-02-22/rust-std-beta-armv7r-none-eabi.tar.xz": "4f74859110079c69ff3a84a4c4110ec4df7d4ce7bf4886a9115defc11174f41e", "dist/2022-04-05/rust-std-beta-armv7r-none-eabi.tar.xz": "44de1090cf49659dd983c081af9c675c9d24721e7510c2748f50befd92810c6e",
"dist/2022-02-22/rust-std-beta-armv7r-none-eabihf.tar.gz": "1d29241da65cedfd665917fdc0ae8d66eaf847280c57ebfa630d6e4993232642", "dist/2022-04-05/rust-std-beta-armv7r-none-eabihf.tar.gz": "d6bca5dbb5f985b4c3a4b917311e3ceeefc3ba43fd6b4416b1d07136f405e47c",
"dist/2022-02-22/rust-std-beta-armv7r-none-eabihf.tar.xz": "a3898ab71f6fb6f0a0b85f706d74fc75330eaded7e4fde7e9903ad375b2c4c9e", "dist/2022-04-05/rust-std-beta-armv7r-none-eabihf.tar.xz": "4f9acc7d81e54d6a725d69bbfaaadb10a0bf4481495548513ff0b96fb3b4f85a",
"dist/2022-02-22/rust-std-beta-asmjs-unknown-emscripten.tar.gz": "6c895e95c55cb55a40a24cbe381a5ce6ed5d50a6ce97781c33429fb846449a9d", "dist/2022-04-05/rust-std-beta-asmjs-unknown-emscripten.tar.gz": "01b157479a25a19f8ff499d3993521c3d1b7920880b247599279c428146d9de7",
"dist/2022-02-22/rust-std-beta-asmjs-unknown-emscripten.tar.xz": "524b781dc177afef5fa70b13a80961d26ecfae25c331dc967127ed9964c29f98", "dist/2022-04-05/rust-std-beta-asmjs-unknown-emscripten.tar.xz": "b1393e5f200af7d3bcebfbcffb95a9edbb66005cf9413283884e520cd0105eaa",
"dist/2022-02-22/rust-std-beta-i586-pc-windows-msvc.tar.gz": "43fae07717c4b20690c6d0843f43e10581e656346fcc1363cbb2f90efcbab93c", "dist/2022-04-05/rust-std-beta-i586-pc-windows-msvc.tar.gz": "4086ce54630c7444d886900877bcfb3af0a33fa9c5770f42172a6963c20207f4",
"dist/2022-02-22/rust-std-beta-i586-pc-windows-msvc.tar.xz": "20c2d659ed82a128cb31d4fed737d79245edf84101b1ad58e4b694784c181aa1", "dist/2022-04-05/rust-std-beta-i586-pc-windows-msvc.tar.xz": "ada0ff31c61640d247f709964322001ef187ef96864618d225ce66af76868b85",
"dist/2022-02-22/rust-std-beta-i586-unknown-linux-gnu.tar.gz": "240c51132bb92b3e5d0b3abd281c1d317aae0cdc23ac5d06b465fd6a3a783913", "dist/2022-04-05/rust-std-beta-i586-unknown-linux-gnu.tar.gz": "137d56c7afa91f9a53191cf213e5f457604a1ee4d13e9132bf730bb5045eedc8",
"dist/2022-02-22/rust-std-beta-i586-unknown-linux-gnu.tar.xz": "b8aafd530bc9f888b2d73d2ddb232501e481999faed06026994bfbc479adc892", "dist/2022-04-05/rust-std-beta-i586-unknown-linux-gnu.tar.xz": "985d7efef52c800a839d8cf7bceeaa1ed44863e83596516507c617619ce744cd",
"dist/2022-02-22/rust-std-beta-i586-unknown-linux-musl.tar.gz": "0f36dd856386e03f34288c0fb720b86cb31969b1db5c90f6ab6329319b344b40", "dist/2022-04-05/rust-std-beta-i586-unknown-linux-musl.tar.gz": "73d9aab23a0674c9816a987ca24c584a75a934ced077e04787161208c8ccc92c",
"dist/2022-02-22/rust-std-beta-i586-unknown-linux-musl.tar.xz": "5bc340d21f80eb420ceafe5d7eb40651dc00dbbbb8ccde59ff88d6843ac93cda", "dist/2022-04-05/rust-std-beta-i586-unknown-linux-musl.tar.xz": "6c6e1bdc49286fe1dbad8a597902e8ea73c0562057e43d78fec9024cd31fc255",
"dist/2022-02-22/rust-std-beta-i686-linux-android.tar.gz": "9eed175b238e5b7f2d7600233cda65efe570050f501680be8e08d98a54028123", "dist/2022-04-05/rust-std-beta-i686-linux-android.tar.gz": "6cebb5c0ab887358d2d948d072d3c436e9f987cf482423d9d55364e9416d492d",
"dist/2022-02-22/rust-std-beta-i686-linux-android.tar.xz": "d6b106f23ac95537191b460847ce38b7e7f6ebb120561cb2b4497ec40d53217d", "dist/2022-04-05/rust-std-beta-i686-linux-android.tar.xz": "a04b26ae9b558489dcc7abc5e632c0382ebe248803152407b0ca8702ead246ef",
"dist/2022-02-22/rust-std-beta-i686-pc-windows-gnu.tar.gz": "51b91d661906c4c6e54bfd34c16aa874447da706f15413c9f6caa7943e49b165", "dist/2022-04-05/rust-std-beta-i686-pc-windows-gnu.tar.gz": "78dad5e34af6dd72549d04e59bf059bb28ada4bc6a2d2396b07b9d6eddc5b1d0",
"dist/2022-02-22/rust-std-beta-i686-pc-windows-gnu.tar.xz": "1d8b8c856e3eb75578a187a483074b2d78ea6c6047018a8110d685a9b6f59812", "dist/2022-04-05/rust-std-beta-i686-pc-windows-gnu.tar.xz": "03cfd3a7b6ac10338cd6219811cd2b9e67e5e40adcfef6c725e14c571c9c00ef",
"dist/2022-02-22/rust-std-beta-i686-pc-windows-msvc.tar.gz": "be373ef9dbc40c44be1cce66d6a37379670d8c6073d2e3ee0c010e08b8d0290e", "dist/2022-04-05/rust-std-beta-i686-pc-windows-msvc.tar.gz": "61df958b515e51e2e44e2130f19a1e2a41e246af99e2ebe73b08fd2203b38268",
"dist/2022-02-22/rust-std-beta-i686-pc-windows-msvc.tar.xz": "97a8cabc18f4745c856e8a51deeb3b2cfaad15aa854dd8bf50d742c498375802", "dist/2022-04-05/rust-std-beta-i686-pc-windows-msvc.tar.xz": "aec3ba484f261d9feb4f81525b56b656dac1ad9af584b946dd85b643ee201202",
"dist/2022-02-22/rust-std-beta-i686-unknown-freebsd.tar.gz": "4dfdaa7fa0d282dfcc8a919fbc077fb5a987820ea920a3f443ad286c3f16e134", "dist/2022-04-05/rust-std-beta-i686-unknown-freebsd.tar.gz": "62669de085e1cdd6bebfc0a6ed74ece54807104c67256c75753e3d2269b450ad",
"dist/2022-02-22/rust-std-beta-i686-unknown-freebsd.tar.xz": "e9fef55eaf2302ae80b411bef7d3c52b9a2f8e5e80b1e629541722508aea629c", "dist/2022-04-05/rust-std-beta-i686-unknown-freebsd.tar.xz": "7bb82ba3e26bb4ae4558719d474322012cb09b1fdcab570d1d7dc7c3562023a6",
"dist/2022-02-22/rust-std-beta-i686-unknown-linux-gnu.tar.gz": "05b2bdc3bdcc5853d4b44423031e82452d040c74d5b3832e03910c25c752e70f", "dist/2022-04-05/rust-std-beta-i686-unknown-linux-gnu.tar.gz": "22324f33d7be09df91263375535ca93d92372b8dfb320df0ba909f333a900458",
"dist/2022-02-22/rust-std-beta-i686-unknown-linux-gnu.tar.xz": "1038a6415b9f68c63cecb98b0ad860a0f424d7053e4fc6cc52c3054cdd9b3c56", "dist/2022-04-05/rust-std-beta-i686-unknown-linux-gnu.tar.xz": "8911af3a77bf067dd9ef4ee556ab2e13feafee33b0bb1c63b3cc1ae80042a30f",
"dist/2022-02-22/rust-std-beta-i686-unknown-linux-musl.tar.gz": "588b13f016e2fd49c4261a230dde062f68de10d8b128e1b801071f6fb04e42b4", "dist/2022-04-05/rust-std-beta-i686-unknown-linux-musl.tar.gz": "34b7b615bb5ff1bc7910683ae6f6fa7750119a6e0512df945979969b695a5fd0",
"dist/2022-02-22/rust-std-beta-i686-unknown-linux-musl.tar.xz": "91dd6f3c85b28dc1aa0636bcfda1156c97fbb1322156c2a600bc66e2bac22627", "dist/2022-04-05/rust-std-beta-i686-unknown-linux-musl.tar.xz": "d8614a9116f07ca652e15d7809d79ac50228dbf553ed1d7123a3e9d74a297f1f",
"dist/2022-02-22/rust-std-beta-mips-unknown-linux-gnu.tar.gz": "140af043ae006d47e7b19badfede6aa684c455b18df6d7da4a7c2437a9d303e8", "dist/2022-04-05/rust-std-beta-mips-unknown-linux-gnu.tar.gz": "803aec35491c632565c178100ea8803bb90f841cab99453ee726b846b887f7db",
"dist/2022-02-22/rust-std-beta-mips-unknown-linux-gnu.tar.xz": "0ec24313945e2fe853c1139e729fa40e5ffec406070bd52468a23b96efd08c5d", "dist/2022-04-05/rust-std-beta-mips-unknown-linux-gnu.tar.xz": "a85292e8eeef5a2eee4a16d0188f432602893a6bca6d971daebb1bbaa3d7cf4b",
"dist/2022-02-22/rust-std-beta-mips-unknown-linux-musl.tar.gz": "3b4c2aa34c84d5cf6460f8fe46ba0e0596fe83403f38f0f53d8b14ecab3d7de3", "dist/2022-04-05/rust-std-beta-mips-unknown-linux-musl.tar.gz": "faaf96182517e399d73b7242ad1ba8798cb49da0bed66fdc31aa04eb916bfcea",
"dist/2022-02-22/rust-std-beta-mips-unknown-linux-musl.tar.xz": "53c3476fb78702570ba096d2f6becaef2b402bf8c5afa58b8d559ddbe7a379c5", "dist/2022-04-05/rust-std-beta-mips-unknown-linux-musl.tar.xz": "6ceb46cb6495a76960e08f041b5595f954a2ffa41b786b951d58fefa6753dc51",
"dist/2022-02-22/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.gz": "e2963c7aaa7ae70a341a67d93d52ac2911309cb1977639e85750b0dd8061bb21", "dist/2022-04-05/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.gz": "0be7806f821b84cf53001964f1985c3a7a5c2df22575ba81e1f925fbf06b6e5f",
"dist/2022-02-22/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.xz": "76444714fb5cdc40797c0d217536b4328484c12f2ad0f47e3635d88fc31aa958", "dist/2022-04-05/rust-std-beta-mips64-unknown-linux-gnuabi64.tar.xz": "b71f46228685f926bdb6bf675fb6c0b2a32e28a5b095b7375c5fed2c9067b423",
"dist/2022-02-22/rust-std-beta-mips64-unknown-linux-muslabi64.tar.gz": "0eeef057018f809ef008d23df65ede61b1d1695d2d5ffb6cf322e73939f789fb", "dist/2022-04-05/rust-std-beta-mips64-unknown-linux-muslabi64.tar.gz": "55662bfa7ae485b1a2d655179588ec2b5936aae4f9998533559330d382f5731e",
"dist/2022-02-22/rust-std-beta-mips64-unknown-linux-muslabi64.tar.xz": "efb4db958a03894289570b0383eedf47e3d3723793eab95a1336a8e4fac0a909", "dist/2022-04-05/rust-std-beta-mips64-unknown-linux-muslabi64.tar.xz": "e58994d0a1b3624c36ba0c547ff621ca3ec331ac0bd3d58222919ddab0beb3ce",
"dist/2022-02-22/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "59a15a0870013712d2d5162d180bfae71388eefb63d0ff0ee3dd30471c4feaf0", "dist/2022-04-05/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "e0c0bb542516fa0159285e3770a469833ac95ec5fc663d39c3e01906f467b094",
"dist/2022-02-22/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "46d9a7e326d582ec0d9cc674b4f2976da877b16197b0aec2ac783b3cbca8d0e2", "dist/2022-04-05/rust-std-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "21ef3db32ea221d631c0a81f5034fb63e8bf76f7f39c1957c5d16929bd64bf17",
"dist/2022-02-22/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.gz": "c6f88389945fc1802fbd271bcdfe77172d60b27b6416a6a899c29854748f93b0", "dist/2022-04-05/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.gz": "ad3da919ca0fcbffdb84ea8f415bed2a2fb2f61e816aaaf28e8854a9850103f6",
"dist/2022-02-22/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.xz": "16ac29879c3fadb76ebc8ae1234dc4c2aed1809f329a95c67e5e54aa2730e9a7", "dist/2022-04-05/rust-std-beta-mips64el-unknown-linux-muslabi64.tar.xz": "cb02f50e74534bbd805094b1e83c35d0a2e00dcbd75dd85f3517774f42e8fe1c",
"dist/2022-02-22/rust-std-beta-mipsel-unknown-linux-gnu.tar.gz": "6c93eab95575a3327ec019c45f57564bf8c2bf92df1c9cc895de6f6b6514c695", "dist/2022-04-05/rust-std-beta-mipsel-unknown-linux-gnu.tar.gz": "64350c36afa85b35b02dc1255fcc09abf2592e08a05aa0ea67794ef13442dcd8",
"dist/2022-02-22/rust-std-beta-mipsel-unknown-linux-gnu.tar.xz": "81e560c30f477cee45c866c6653fcf2b7942287547321f939ab68a849d1c680e", "dist/2022-04-05/rust-std-beta-mipsel-unknown-linux-gnu.tar.xz": "894e0337a31935a13d26d2710a70b4526e1caa26aa0c9cd37981d2569b8ada31",
"dist/2022-02-22/rust-std-beta-mipsel-unknown-linux-musl.tar.gz": "612d4169406b20abaa38362dad969008d5d3eea1b7c5a376f5ff33870879e70b", "dist/2022-04-05/rust-std-beta-mipsel-unknown-linux-musl.tar.gz": "cd5e15813a24234812e4a281fccb76f6aa2110c87a0043d4b5c60fdf3b272701",
"dist/2022-02-22/rust-std-beta-mipsel-unknown-linux-musl.tar.xz": "d39459a64250838ac6b46352de106fbd199e4e586f066123a1ffe78f52291d1d", "dist/2022-04-05/rust-std-beta-mipsel-unknown-linux-musl.tar.xz": "dea915cd8f79c3d78b063bebd86a9c6e88749f6a436ac16c6dee463bc9504f0a",
"dist/2022-02-22/rust-std-beta-nvptx64-nvidia-cuda.tar.gz": "ef9ada210252cf9f66e7ff6aa43855318ac6030b6a963f4f25ef227c3b50a51d", "dist/2022-04-05/rust-std-beta-nvptx64-nvidia-cuda.tar.gz": "af860ff78396796a125c9d3029f85e898ac0c0fb738956d5a9fb9432efd61770",
"dist/2022-02-22/rust-std-beta-nvptx64-nvidia-cuda.tar.xz": "7ba46c4171c4776770d8a5e590e8b3e12fc85d519fe85c5db166569d353fa371", "dist/2022-04-05/rust-std-beta-nvptx64-nvidia-cuda.tar.xz": "a6470fa586262bf78b91bb4b59e6f15c6df9028f4b3aace8589ddeb12dbf7ea6",
"dist/2022-02-22/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz": "11e163b7e4884078185ac92fdba62a77468b70ffe0e4f22a6c420ff8441d12cd", "dist/2022-04-05/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz": "9b147bfd00a0f2cd7aeefb67b03cb08b7d2eb2661410dbc3afee30dcb1c7931c",
"dist/2022-02-22/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz": "3f88f0163078a219730898a77f3bf8db3df3967100931a4685bcd9d43f2b4668", "dist/2022-04-05/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz": "4791c88990892a0aa3e41bd5e0d3c70a3e08714e0d46c00e58a14944f4be3d6a",
"dist/2022-02-22/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz": "68742e04b7fa9f398945363b41e8988040f53c46de6fb7b481647052d54f23ad", "dist/2022-04-05/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz": "d5ddb7a2ada5c0f10a1cfaa18ed9f454ba044bcc20070be35e104e33eca2a954",
"dist/2022-02-22/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz": "f978bff9ae78b26c439a3817648a63cd9e9e149bf08cf2124ef2372b5863c52e", "dist/2022-04-05/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz": "8eaa648476c02b86662d0eb20255d63f49295853733082aa7200e1d22565aa5c",
"dist/2022-02-22/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz": "715d0512df81db8266b1264721704ef069a78ae5ec615c772e876c119723df80", "dist/2022-04-05/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz": "fecc0c637feeaf867ed63d198169948373dd6b00cecb7c5deb00e2719a70f403",
"dist/2022-02-22/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz": "65739553817038796c9364f8e92f7b492872cc46cab9ea3535b74ce55a1b6474", "dist/2022-04-05/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz": "77932b3620e2a9642b91e7526f0c08f6fc7d96eb1506aae9382b9ceba5098ab8",
"dist/2022-02-22/rust-std-beta-riscv32i-unknown-none-elf.tar.gz": "65815e6f296c5651f4185820c2bfe9a6929d3a4aba555b453b1e21791e98586e", "dist/2022-04-05/rust-std-beta-riscv32i-unknown-none-elf.tar.gz": "37b5042d8d1dfc8f0edbd02766b0e47dd90f68a7465cc3f8a2ffb09ef605b11d",
"dist/2022-02-22/rust-std-beta-riscv32i-unknown-none-elf.tar.xz": "51f1a45d7fea68806220a31877c4ae2aa0be171aa594fab847ee295682afe9d2", "dist/2022-04-05/rust-std-beta-riscv32i-unknown-none-elf.tar.xz": "73b317b51e033076205f7c7c7c28877fa61e837cadfc97bd1899211c22ab1160",
"dist/2022-02-22/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz": "25199052e5e2f39611c60cfb6c071337c3621eef7203090a1f1abba9959a05e5", "dist/2022-04-05/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz": "8f82803e3fd1304c8fc03d49cf9e41e8f7b605f84c94739706e0c7606c448e6e",
"dist/2022-02-22/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz": "ac272237e72fc06a2c940f643df7d614267182acdaaa883cdc2ed86baa83e955", "dist/2022-04-05/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz": "1e6b7f7d5732446bfe865ee16183efc30fedfdb9dae45131c8cb59bf683348bf",
"dist/2022-02-22/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz": "8b6b8235a671d0ca3b0548b64197ec320975d9866f13435c069b279f95e8d8d9", "dist/2022-04-05/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz": "beef2e14c29146435c9a3bdfad2a98298294b916672a73131202c72cc697df6c",
"dist/2022-02-22/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz": "f0136a97c8338e72e05bf4390ac0a828f52559b73727a9a075c137dbaa249637", "dist/2022-04-05/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz": "f9aab3ca9bb4072a5e2e4682ab23fb5b4a071da7cc8b8e3844a4407e8e33fe6b",
"dist/2022-02-22/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz": "7be9a45ddbdf281496520d76372a004f16b927fc6bade0ae97ad8b92d34d3d7c", "dist/2022-04-05/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz": "eda983cd1775f24b96b660ef3536f06df30385c40bfec46d8cfb8d35c27763d9",
"dist/2022-02-22/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz": "47f3a3d69b0819dc681e37437618a2130f4c5aa199cad3bbbbee8bd442374ac6", "dist/2022-04-05/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz": "3168538fc3a537c15c0c994f3ccd46548b14727b46f95f8244e9068e68bb64e5",
"dist/2022-02-22/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz": "8a7d37d7e022c4513877f428361312963d555f35e78978efc27f4eac2e411b6a", "dist/2022-04-05/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz": "6e8681fc5c2b6258b669780438f3d10544a9236f288ae6a173bdd293ab710544",
"dist/2022-02-22/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz": "d530edb2ceadba90b840a691b61f267388b9022003318f489fd46c84560459b9", "dist/2022-04-05/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz": "5abe0a935eaca18193ede75b59780b33c98dcfef2d38e96ea3dda10c30d192f6",
"dist/2022-02-22/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz": "012398447b0236c20a3ceab1e4f6126bac120c361875f15d304e9ecb7c6781a3", "dist/2022-04-05/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz": "94c55ad771f08611bebbb9395357cbd6001e0c3fe575c9dde2ad683015743cdf",
"dist/2022-02-22/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz": "c092dc1d8ee387e1ac8496b3bb412175a03efe4cf923b82ac4ec47c880986e72", "dist/2022-04-05/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz": "77fc488d1ac4e4c6418980ec33a82aa0fd1f8c4a58cf14b681037d170bcd597f",
"dist/2022-02-22/rust-std-beta-s390x-unknown-linux-gnu.tar.gz": "acaeda013557588d8c9643fd0aa7ad0da5cc7c64f7aca0fc383b00f7b4a174ac", "dist/2022-04-05/rust-std-beta-s390x-unknown-linux-gnu.tar.gz": "5f909d74e47c38cdcdbfe784e78e2aafdfbca5d5cd385c8d0b466628030e5433",
"dist/2022-02-22/rust-std-beta-s390x-unknown-linux-gnu.tar.xz": "99c1a499bb9cfa343bf03da8abfa8f18595fedc3fb354e893fa62f67d067bd89", "dist/2022-04-05/rust-std-beta-s390x-unknown-linux-gnu.tar.xz": "cb11de42adff210b131519581a11287ec67740bab4478f16bc1cfd56f7dcfc9f",
"dist/2022-02-22/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz": "e07bcd62f79c9f764b6c6ea8d3744506beb8e1ee1ddb202276f116e9ee44ecc5", "dist/2022-04-05/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz": "68dc6686aa0b27e569d50c5ca0d607d4efe4c9d8990ba87ad8a2aa328dec8616",
"dist/2022-02-22/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz": "2283784176fc003b8ce29899b747dbdbe848fc226f963ec36a95d79b1afb0c0e", "dist/2022-04-05/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz": "b2bf5ba8a83a15dfcc41598f794e3d3c83dbf915215b4f919e07a9047b1ffdb9",
"dist/2022-02-22/rust-std-beta-sparcv9-sun-solaris.tar.gz": "80c1613f9598db047a95be40494870942a5a4ef54c7e4a72c9fa3df9b23f64b1", "dist/2022-04-05/rust-std-beta-sparcv9-sun-solaris.tar.gz": "86a21737572edd36cb91e45941923c672252630d195f58fb94d7d8d49b8617c9",
"dist/2022-02-22/rust-std-beta-sparcv9-sun-solaris.tar.xz": "9b33ce8b938978caa4164af52bbb982183fa2fa86e5f079805fb6f479c8c9aae", "dist/2022-04-05/rust-std-beta-sparcv9-sun-solaris.tar.xz": "7aec356bec19a94d15b117e774cb42a8eb3564308ca02f60d79b65f43bd36af6",
"dist/2022-02-22/rust-std-beta-thumbv6m-none-eabi.tar.gz": "794c9b2cbe3e76e2dbab31d89817a7c21bdc19a59022ee652862aac025db6914", "dist/2022-04-05/rust-std-beta-thumbv6m-none-eabi.tar.gz": "d755a31f9facef7dbc1476fb803f1bb912a4eabf70facbceaa2c23b5d38a482b",
"dist/2022-02-22/rust-std-beta-thumbv6m-none-eabi.tar.xz": "0a7afdedd20874df94e9604669926b1ce82b68774db7756312d43bbbea3e9334", "dist/2022-04-05/rust-std-beta-thumbv6m-none-eabi.tar.xz": "d62dadcb8bbfc1018937daaaacb28118e63fd7fc539ef62e88cf6e1efe7be0b8",
"dist/2022-02-22/rust-std-beta-thumbv7em-none-eabi.tar.gz": "19821e7291f4363f37b5ef2a1b505163cdf02e38d5b47aa980892e794e918c73", "dist/2022-04-05/rust-std-beta-thumbv7em-none-eabi.tar.gz": "df0f49f983f0c9d110bdf170643f08d0206e7979cc654bdddd70eac717334efc",
"dist/2022-02-22/rust-std-beta-thumbv7em-none-eabi.tar.xz": "a4e0b594b756316bbaa05ebd4d0559edc9a733d5ffe84797c6e096882969ad36", "dist/2022-04-05/rust-std-beta-thumbv7em-none-eabi.tar.xz": "6fe836a2ea7df03c1a88d823cb0557af888b0020c2389bf5027735c9dbccbcd0",
"dist/2022-02-22/rust-std-beta-thumbv7em-none-eabihf.tar.gz": "222e15bb1db6e80459616a001ca8fcad8aba9921b1161e8b9ce9e38fd9fb2d10", "dist/2022-04-05/rust-std-beta-thumbv7em-none-eabihf.tar.gz": "facb752255f0f86ef7a03d8013cf77221263423658d0dce9b75b94e518947de3",
"dist/2022-02-22/rust-std-beta-thumbv7em-none-eabihf.tar.xz": "72ae8a9dba6c2913ba3eaea2e96d7e744985f6c5badf170daa678c00b89e93e8", "dist/2022-04-05/rust-std-beta-thumbv7em-none-eabihf.tar.xz": "8d63d9acd7af3e43bafdbef1953c111f4c13088af4c962802f12b38ae38073b8",
"dist/2022-02-22/rust-std-beta-thumbv7m-none-eabi.tar.gz": "74b4d65d13262964ef180fd7a63a3d2f62c529aa3b99883e3e83815338129631", "dist/2022-04-05/rust-std-beta-thumbv7m-none-eabi.tar.gz": "e5e1eb0bd5fc3a5af561dd9bcf0839c53e36672a11c4dec55ade5a2f59804508",
"dist/2022-02-22/rust-std-beta-thumbv7m-none-eabi.tar.xz": "7dfacadec18736016520db4a07a677f74771db955418f4b1df6c09d871e159e9", "dist/2022-04-05/rust-std-beta-thumbv7m-none-eabi.tar.xz": "3ee0776ff315bcc48d62ace2aa8f8e520fee1a5c27a75abdb89a5093cbd70212",
"dist/2022-02-22/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz": "6bf0482aecbe5d1dba551319cffa074e0a72e6ce8c2e636ead98733429bdf09c", "dist/2022-04-05/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz": "83150b0bd0827db25739e21afdc28a571cab9cf528eb7bde39d6457ab26fd28b",
"dist/2022-02-22/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz": "81e9ff4577785f9d11cfbf92ee18dc6a1202147500ffa474f4a0ab099af0f7e4", "dist/2022-04-05/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz": "1d24ee3b0e3b34f88c54e76bff867a77a35ce74c055311d82f3bde23cae0988b",
"dist/2022-02-22/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz": "bf073994172580e7b9e5a0a618ae5f58759801a8e949d2137f69191d05b146eb", "dist/2022-04-05/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz": "87411b8d0954c450b83dc1b805c94af4cc7907ccfc346e129e5d6909e716cebc",
"dist/2022-02-22/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz": "8c21d837cd9e1c98db78b4c37dc03f07373184e2354880a1dd9501fc62f8b6f7", "dist/2022-04-05/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz": "de9ab4a162f426eba6eb5a355ca0d2d12ba1286599cdc1adc8f4a779e507052e",
"dist/2022-02-22/rust-std-beta-thumbv8m.base-none-eabi.tar.gz": "167f9fc5aa4d3dd68044110a346d5888d9bacc5c8d3fb1140d2687f312ddb057", "dist/2022-04-05/rust-std-beta-thumbv8m.base-none-eabi.tar.gz": "24ca6e156c3eda6c8c790eb5d7c99e39c4394deb9224b495c90641bc828639b4",
"dist/2022-02-22/rust-std-beta-thumbv8m.base-none-eabi.tar.xz": "c64177f1aab599a25d97497124c5d4e9449ecffaf96caefecc8b0a2552aacb4d", "dist/2022-04-05/rust-std-beta-thumbv8m.base-none-eabi.tar.xz": "00bc42ff2b31965cce526f46ed43301966da1b57b694e4c4e5089928ecd13f31",
"dist/2022-02-22/rust-std-beta-thumbv8m.main-none-eabi.tar.gz": "95de6b1fbd95287258f9caac1f805492afc9657adfada82295736d85b1b20c3c", "dist/2022-04-05/rust-std-beta-thumbv8m.main-none-eabi.tar.gz": "3ea54fc5075d6f99db9e2d31a92fd000108500017d80cae6e6349e2ea43a7708",
"dist/2022-02-22/rust-std-beta-thumbv8m.main-none-eabi.tar.xz": "d3f8c5ed80c59b1bd2c538aab63be8b39db78db3c2f49d7447092a8b97e2963c", "dist/2022-04-05/rust-std-beta-thumbv8m.main-none-eabi.tar.xz": "8809512122417753d6e72b2ae90637e8b339a3f72a51bd4ad53b3a152a992b16",
"dist/2022-02-22/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz": "aa0ec6f6b0d652ebde2694a8153252928cc1f41c565912da8bee5b0d225b786b", "dist/2022-04-05/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz": "bcff8f5e765b8bbfdc3a5c6cb08cb796c90f3435986587b0744d40c226e8f551",
"dist/2022-02-22/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz": "1f23bcb96112bdec4a1f45c41afef3faa95cddc5be2f693ee3e1f4f3e584c49f", "dist/2022-04-05/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz": "925605849a16cc8e9a0d5ae5b523a321fd7e80ebb8fced627d7ac90845e20261",
"dist/2022-02-22/rust-std-beta-wasm32-unknown-emscripten.tar.gz": "49d6ea925560f3eed75da2c7d9cefe404525702504ce0cc4cbfb3fe638814566", "dist/2022-04-05/rust-std-beta-wasm32-unknown-emscripten.tar.gz": "64ef3fc95b97e5dc6a4e70bf383ffaab836a227f86427c8eadb01c1ed1d85a08",
"dist/2022-02-22/rust-std-beta-wasm32-unknown-emscripten.tar.xz": "13b93becc017bb6bb60212ba30d6717a1be6af139b965b15000264b48e163991", "dist/2022-04-05/rust-std-beta-wasm32-unknown-emscripten.tar.xz": "377aa739f9c9aec814031b260def0629b87d932f06bedbc6cff9c997911c7263",
"dist/2022-02-22/rust-std-beta-wasm32-unknown-unknown.tar.gz": "27f3dffa92ccdc8d2b3342e737b5f80b7b2dbc53a994249bf318810f4d8b4643", "dist/2022-04-05/rust-std-beta-wasm32-unknown-unknown.tar.gz": "2f8d832b5cbcf8072e5ebccd5d569b351a3265aab0ac60f580fe326def9f40a4",
"dist/2022-02-22/rust-std-beta-wasm32-unknown-unknown.tar.xz": "2236cab6b48c9c564731913dc652a2e0cc6af0d6b9a64b66cf39a6b943c410da", "dist/2022-04-05/rust-std-beta-wasm32-unknown-unknown.tar.xz": "4b6582d922280377297412496e443becae006a0c7b170dec0b75885322615876",
"dist/2022-02-22/rust-std-beta-wasm32-wasi.tar.gz": "35ca9a19558512fc1758e9c7482246bf6a518e48d4a93a8748c07ebdb4be9d6c", "dist/2022-04-05/rust-std-beta-wasm32-wasi.tar.gz": "31487c5f709ac9bb89bc20215cb806b5c83cc604f6fbf858939c7f1be9759a3c",
"dist/2022-02-22/rust-std-beta-wasm32-wasi.tar.xz": "3bbae2bf8423e3323155f3f336435fbd53b58cfa16107f9fa567ea77923e5ff4", "dist/2022-04-05/rust-std-beta-wasm32-wasi.tar.xz": "712f2663bfcc2e67a797390a872e2d440f24474c92644818667b2bf741f938e6",
"dist/2022-02-22/rust-std-beta-x86_64-apple-darwin.tar.gz": "9a6c1808797c92da862f706f08a6482a4412e52dc9a492d06645f03c8b1c0fc6", "dist/2022-04-05/rust-std-beta-x86_64-apple-darwin.tar.gz": "120f9ce8080d7fb25d50f0a055e708a14570c6ec98543008580c72d0037fb1db",
"dist/2022-02-22/rust-std-beta-x86_64-apple-darwin.tar.xz": "2a658172c220c047542e992a8b1440d887d809f301f3a0e23a811d586ff43dc2", "dist/2022-04-05/rust-std-beta-x86_64-apple-darwin.tar.xz": "969c54f4aa028ad51087a41b556d6692b02ae240b805cc0a6d52cf0f4a5ae2b9",
"dist/2022-02-22/rust-std-beta-x86_64-apple-ios.tar.gz": "2da9affdcc01bc9369192b40feb0797349d2084fb6ddff55e61d7b0a831272cc", "dist/2022-04-05/rust-std-beta-x86_64-apple-ios.tar.gz": "6a6b2485d5e012e53345a777b112c94563e0c8ce28845a8c68aa04b09196b59e",
"dist/2022-02-22/rust-std-beta-x86_64-apple-ios.tar.xz": "dcf403a1d670bdb0e29d61161d268a2be9a6d31ea4055dff562e06cb72ba1c78", "dist/2022-04-05/rust-std-beta-x86_64-apple-ios.tar.xz": "58a8643415ba08bda6cff638012de2b2d3d3d8c953808006dda74f65efae8210",
"dist/2022-02-22/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz": "506ad99d890f0c1ff525a8c9f28aa4f7aec349afd78279b21d7486a88f548ef0", "dist/2022-04-05/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz": "c757c0e207d77edac9305714e056984affe6e97d6fb59a7b70dfe62de39458a1",
"dist/2022-02-22/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz": "4f20a7b59e32266fc01c67d36ec27f68e9a44105819e1c5a1dc8823367c4914a", "dist/2022-04-05/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz": "561bb7ddb8eb5cdf33e4608f772c2a021504d0a9eb73536c66b30095545da05d",
"dist/2022-02-22/rust-std-beta-x86_64-fuchsia.tar.gz": "0705d9ad7e640a8a4b48c88d1997ffa57f849d1fa4cf3ae4185afd2122ed6b60", "dist/2022-04-05/rust-std-beta-x86_64-fuchsia.tar.gz": "d8fa9b75e173766ecafe150aa8162860dcf93f2340a5dad5fa2529619a5ae05a",
"dist/2022-02-22/rust-std-beta-x86_64-fuchsia.tar.xz": "2b5382417346f07f105704eac3fdd4a8bfa0285804715a64d1e314a0c9ce4ef6", "dist/2022-04-05/rust-std-beta-x86_64-fuchsia.tar.xz": "182c4809af23b0a0f6a0d3ef5f9f7f4cbd846ecc62d459f5aef840871f9fe7d5",
"dist/2022-02-22/rust-std-beta-x86_64-linux-android.tar.gz": "03404906af39d9111316c624835a09a4326f6172f52a405b82f831c3b408ea9f", "dist/2022-04-05/rust-std-beta-x86_64-linux-android.tar.gz": "44f09c699a1543581bfcbea834b654dbd165826d80476d6bf4fa3cbf4e90dff9",
"dist/2022-02-22/rust-std-beta-x86_64-linux-android.tar.xz": "5ff2b24d8fc552a791b609de6373afc57a8661d2769e89f4e19c5cf85be864b4", "dist/2022-04-05/rust-std-beta-x86_64-linux-android.tar.xz": "6c019c7ecaf340f27b42a87885e4918b736f9a8ef139773092a33bc42d8f27cf",
"dist/2022-02-22/rust-std-beta-x86_64-pc-solaris.tar.gz": "a90e13d0e45a71843caa1dd960a7b032120034aa0caa4148f825e3493d65640e", "dist/2022-04-05/rust-std-beta-x86_64-pc-solaris.tar.gz": "fff1f8b4192be1bd4f701b356094c0a5ce3fc8da4878d29cbf6dfb7476c371f2",
"dist/2022-02-22/rust-std-beta-x86_64-pc-solaris.tar.xz": "d176219f6fb41aa0bbb59b11801f45af29edeb24423325b162686d3fc3d3ff93", "dist/2022-04-05/rust-std-beta-x86_64-pc-solaris.tar.xz": "b8991973df37f86ccb4c09082caff85f7ddae365d2fa554db6ba26795b263051",
"dist/2022-02-22/rust-std-beta-x86_64-pc-windows-gnu.tar.gz": "dd8da303ff2740b3b9ea565ed9a335f62de8c1357884660abbc4e7a9ccef7a74", "dist/2022-04-05/rust-std-beta-x86_64-pc-windows-gnu.tar.gz": "fdab2938d8f835dc6244b8aae81989de11c46adb413a9feeca11986453dc5f2c",
"dist/2022-02-22/rust-std-beta-x86_64-pc-windows-gnu.tar.xz": "d807829b1328527f49d318ce942dea5fd8e71a8fa16cbfe2d7444fb5a962e158", "dist/2022-04-05/rust-std-beta-x86_64-pc-windows-gnu.tar.xz": "4d860de3ff0b5327736d23296365bb65761b4c14dbbc683201286d9fee2fd58e",
"dist/2022-02-22/rust-std-beta-x86_64-pc-windows-msvc.tar.gz": "7ba1551ce159030125ce74ae7321e0365fb2d33758fd2a578693dec8ff817c66", "dist/2022-04-05/rust-std-beta-x86_64-pc-windows-msvc.tar.gz": "b0e1942912bed10275f65bd525971a7c5fbf03c92bb3a3d2934b35004ca9f109",
"dist/2022-02-22/rust-std-beta-x86_64-pc-windows-msvc.tar.xz": "55ab2bcc5469ff433e15c06f490af3721abd6dc468eed68ce3fb2842dacaf28e", "dist/2022-04-05/rust-std-beta-x86_64-pc-windows-msvc.tar.xz": "40ba2150b24081cb1a1268c196fc27a15d771cda3136fbb838d6cfa8535758bd",
"dist/2022-02-22/rust-std-beta-x86_64-sun-solaris.tar.gz": "1e1b97a4840415f7efada876ddbeebf336ea4c6a0d0fab4238ce1f490e6450a3", "dist/2022-04-05/rust-std-beta-x86_64-sun-solaris.tar.gz": "4d4a43484120e6c0cd46ad66f2c3b9bb46532d8cedb3d899e11aa575638bee2e",
"dist/2022-02-22/rust-std-beta-x86_64-sun-solaris.tar.xz": "20377a3a7eb39727c3c4202a35569c52362f486fdc3ea451a0d9cc5ccc95ae4f", "dist/2022-04-05/rust-std-beta-x86_64-sun-solaris.tar.xz": "546cfcbc48405ea55f702866e7ab2581dcf99abf3d38d97a8736db5ebad72eda",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-freebsd.tar.gz": "5c3116945faee33a8a45f911d270c19ad979f3c3f11af2dc769173b6b8f93564", "dist/2022-04-05/rust-std-beta-x86_64-unknown-freebsd.tar.gz": "dc84510940fd620db639ebfb127e398adbbb13639979cc8855d4a8485363da52",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-freebsd.tar.xz": "852b0fa691ce59a509cf8c414407a8ea1bed362cf52007ceaa0d240533a3b6d1", "dist/2022-04-05/rust-std-beta-x86_64-unknown-freebsd.tar.xz": "d457f1c09dd446e30e94e4bcb1e3b5fde9cc54080cbe5e0a329ee810ab07d312",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-illumos.tar.gz": "66081135debd54f351c3117428aae95ca160895effd7c8c5d3c9eacdcc18dafd", "dist/2022-04-05/rust-std-beta-x86_64-unknown-illumos.tar.gz": "1e6b9a255ece3599af1614f47a086422632082ab2e4dd8382f4a23c48865bc84",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-illumos.tar.xz": "80bd080495367c9cad59a356e410aa200aee03690ad38d817ff9020e2c46b7eb", "dist/2022-04-05/rust-std-beta-x86_64-unknown-illumos.tar.xz": "7420f5442c1835830c93340ed4cec54c58a104978b54fccb80c4015b9614b9bd",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz": "42b513b8d24d66f582c4cab8d61414012c34a25d7f65679985ab68e2cdfc0fed", "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz": "b3e69ff8e1725c8a0b61c79be8d2f2d396cda1dd13d2a3d1f87667ca426253ed",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz": "18c5bdfc09da2789c79d4b7ec8e0703699acbd2528efc13a249043517e415031", "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz": "beaff8b113d35826c062d7c7f76b773e45d0e878e059c42de5411406906368a6",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz": "f12be56fd501f1305be77f31e7021c79749e60286d27f68c4c6fbaf9326b6b18", "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz": "bc27fd39c6e67451235aa8f14bd6f4a1018379cf52131ab3924134d6294ea54f",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz": "f9445ebb056c31cce13267e7ca1416aa01c482e6d0968044c1c90193a4ab7ecf", "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz": "4b2ada52b6bd53e786cd5494b6bbbcbc8d7ec6812359b4d1a1a5a25c64e190f6",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-linux-musl.tar.gz": "46724764c0c9ef57ca9e74ebcfefbfc4053d0aec9827219e3a8f70d7661d4f00", "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-musl.tar.gz": "7f1464a804086c7709d5198abde76f6470fd1c36fdebca664e41ebaeeff8b1a0",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-linux-musl.tar.xz": "9ec841afae859c5d2f386a0ba333cb7f1055718645de6a46cc429e1ab6388a8d", "dist/2022-04-05/rust-std-beta-x86_64-unknown-linux-musl.tar.xz": "6c570824abd6478c104a55147d6d54e6b785222ea15ffd00c59caee373a78bfe",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-netbsd.tar.gz": "224c80a3babc99ed5ab0f2c2376a730606a49adf99b26ac1039b98e96972bb49", "dist/2022-04-05/rust-std-beta-x86_64-unknown-netbsd.tar.gz": "17c6e9204cfdf32fb8db4a7ade73dda300a35c515fc017804593d76590f537d9",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-netbsd.tar.xz": "a6011d4c075ac5f7c8fb64dca3388e659c18fb95b104ff5ba661e614015607e4", "dist/2022-04-05/rust-std-beta-x86_64-unknown-netbsd.tar.xz": "738f9f96914b20a9e97195d75bc806563fbe4554dc30e02fda58dece420a2790",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-redox.tar.gz": "ca11ca60fc78827a87e202060f6892b2513c4e7ee7af637c9f5ffc73512258b5", "dist/2022-04-05/rust-std-beta-x86_64-unknown-redox.tar.gz": "f0846eed5e5692deb83d01ea36792691232b2449f430c0433375e13efa014142",
"dist/2022-02-22/rust-std-beta-x86_64-unknown-redox.tar.xz": "a2df3333acdda56303a8607151538d4e3f0ccbb5e7ad0ce538c2daa16927a2aa", "dist/2022-04-05/rust-std-beta-x86_64-unknown-redox.tar.xz": "2ea808655537de27b207fb61b2245048d124cff21edd52ac388838fcbd1d13c1",
"dist/2022-02-22/rustc-beta-aarch64-apple-darwin.tar.gz": "14e52bfeaaa4e1040c9ac2a1ef5ce55c6f862187d789ff07bfc10397d5302b2d", "dist/2022-04-05/rustc-beta-aarch64-apple-darwin.tar.gz": "ee587d1e4f90b0662ca8fd845b5b945b5bdeaf09ef51a48c082ccd5ad5582060",
"dist/2022-02-22/rustc-beta-aarch64-apple-darwin.tar.xz": "43e8d608a04b8c1037e3d6fae9c90aad0317b109176a9016b8327bca34346e4d", "dist/2022-04-05/rustc-beta-aarch64-apple-darwin.tar.xz": "4d7f7800088d21ec7450a7b7cfe1a00d10ef832919895b7eadd948cc60c2ea51",
"dist/2022-02-22/rustc-beta-aarch64-pc-windows-msvc.tar.gz": "507d7533e80f022031e27698664bedd4c0e02334b008fa1276e0b4094c616a11", "dist/2022-04-05/rustc-beta-aarch64-pc-windows-msvc.tar.gz": "2e96658cea6c5dd9a05490a2a03062e9faa8a19dc359e0751e36834fe0ef8d37",
"dist/2022-02-22/rustc-beta-aarch64-pc-windows-msvc.tar.xz": "798d75848e5fe551d70feeaab10cd77709e218c34d65fefc8392667942e5da93", "dist/2022-04-05/rustc-beta-aarch64-pc-windows-msvc.tar.xz": "401257ac9451f86f2a8306805dffcc77b2d02d2957c2509e7397d640c650a971",
"dist/2022-02-22/rustc-beta-aarch64-unknown-linux-gnu.tar.gz": "ce50f8abc2070654681d073db6d36ca0e36806a9af0e23d7273771713756b3c9", "dist/2022-04-05/rustc-beta-aarch64-unknown-linux-gnu.tar.gz": "8ed21a78a71fcad7ef9c37d5da5f6bfc728947b036996ce280f49076526d41a4",
"dist/2022-02-22/rustc-beta-aarch64-unknown-linux-gnu.tar.xz": "4654ae2341a8a62d7bc2facf85bcba483f3bb083d51e7127c8b3c18a63a31180", "dist/2022-04-05/rustc-beta-aarch64-unknown-linux-gnu.tar.xz": "cf81292f92477f22220feaf07d4c151ef59a6f3fc73770a52ed02064cca3eb65",
"dist/2022-02-22/rustc-beta-aarch64-unknown-linux-musl.tar.gz": "e66559d3acd1fd17c0fed9f106e51865e5de85438ff2eb2add4032a29ee4947b", "dist/2022-04-05/rustc-beta-aarch64-unknown-linux-musl.tar.gz": "8d64fa488a87a8bb8a7ac4bdf4cd5bf258e5231b98b84361199ff414833ba354",
"dist/2022-02-22/rustc-beta-aarch64-unknown-linux-musl.tar.xz": "648ca772d54e95a6066115dedc6b04b9874875bb0950f1cabef99d91c16083d2", "dist/2022-04-05/rustc-beta-aarch64-unknown-linux-musl.tar.xz": "4e1ccc5114bbc888a382db706dea497e9a5cfe95de221fc5ddb07942de804964",
"dist/2022-02-22/rustc-beta-arm-unknown-linux-gnueabi.tar.gz": "737c865a96af5ea78492bccb1341025b25dcd6449229cbf085524296bcd232d9", "dist/2022-04-05/rustc-beta-arm-unknown-linux-gnueabi.tar.gz": "bead69bf19b04a5dfba77da2831e034224cf87d91867c4f14abdd4c0efdf862c",
"dist/2022-02-22/rustc-beta-arm-unknown-linux-gnueabi.tar.xz": "484ecf1f2f940e4d46596dbf6697ff6d94edd90739769f63985415a360e65703", "dist/2022-04-05/rustc-beta-arm-unknown-linux-gnueabi.tar.xz": "cf5f6849862fe528ffa3f7620d04150b3ac034ee985bbd0a45d6139e14b1314e",
"dist/2022-02-22/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz": "503e5827abbe658d4caa91432506121e3f3ed5d3d1896a7fe1f6b4dd38c5ba1a", "dist/2022-04-05/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz": "21d2f05ec33cf2c11359e785a74ee2997076f8aa11777e241855266f6d7b68a6",
"dist/2022-02-22/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz": "c0001b8f07436a1765569b857b7f1c0ed81dfb87de8ada1e534c2cde1ce866e8", "dist/2022-04-05/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz": "299a57e0d25333e1de955a12c69f1cd97da6163ebea681aba4a52601b08d7b26",
"dist/2022-02-22/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz": "e39e0f013d02d2a340c62abfa58b37095fb0df828e5678c94f6611e3b03e3670", "dist/2022-04-05/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz": "f7460821d2f4289e72f4be807a72c16ac61496bf5732b3c846f6b6e8a43fd669",
"dist/2022-02-22/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz": "9aa60dba618f60f3099c0b2b14ca55a15187fc6858c45bde482bc40d324acefa", "dist/2022-04-05/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz": "da22ccbaafafd05b18587c1c33ea8c12c083129d4accdfe728c32a9c341d8b12",
"dist/2022-02-22/rustc-beta-i686-pc-windows-gnu.tar.gz": "4ee632be637fea478c42f2c77a24f8146b6b982bb0c9c9a19d5e83a6cf0d49ca", "dist/2022-04-05/rustc-beta-i686-pc-windows-gnu.tar.gz": "7be21e73f6d48e0765c102f2dc5b2e3ce57f00e5f9dae6cdcc354b7444acf6bc",
"dist/2022-02-22/rustc-beta-i686-pc-windows-gnu.tar.xz": "ba4d659c22647102ed0ce4fa1b7121df788479838b6de08058a7ccd14923293c", "dist/2022-04-05/rustc-beta-i686-pc-windows-gnu.tar.xz": "b964692919697ec8d5d8d4d4b41579d9fa805ce93c5efb56c3106e5c223f86bd",
"dist/2022-02-22/rustc-beta-i686-pc-windows-msvc.tar.gz": "9d37026d3efcd15c18eae8a35d5c91089b0094ca3fa2a09c07a9022a246ab5bf", "dist/2022-04-05/rustc-beta-i686-pc-windows-msvc.tar.gz": "629942cacf1ab50e5273de51bb786c4258f4efe83748180c27caecbedae6e2c8",
"dist/2022-02-22/rustc-beta-i686-pc-windows-msvc.tar.xz": "2edb8490cc2a02821f1c088f0bb9576e8c6a511654209da940de0aec42210dca", "dist/2022-04-05/rustc-beta-i686-pc-windows-msvc.tar.xz": "7a3b57b8f34c5ea10bee2142edd625b70bd8765761593da9fb0ffb76f30e0e7b",
"dist/2022-02-22/rustc-beta-i686-unknown-linux-gnu.tar.gz": "3cd3297af97a6343bdd92457837aaa80f775f2efe64417856a51f6540b703151", "dist/2022-04-05/rustc-beta-i686-unknown-linux-gnu.tar.gz": "7cae7e0c0690f302064b768ef7daffe500a7b8767c1ea985d5f9706f41137f5e",
"dist/2022-02-22/rustc-beta-i686-unknown-linux-gnu.tar.xz": "c3497504066a953efbcc28840b6b7f1bf2799ec7aaa987d806cd56b874a9304a", "dist/2022-04-05/rustc-beta-i686-unknown-linux-gnu.tar.xz": "74395a6013a4589b5d39af2d5780c8bf6420256d7159030f248f584bfec018b4",
"dist/2022-02-22/rustc-beta-mips-unknown-linux-gnu.tar.gz": "a15c0cc57cee5ba21dcfba2c9e6ebc940e4aab635832d487e5db3adaf9749325", "dist/2022-04-05/rustc-beta-mips-unknown-linux-gnu.tar.gz": "cfd2fe4c26207346f04d6c4e2e8dee1c9a42fef6663b6eff1029f30c06492efc",
"dist/2022-02-22/rustc-beta-mips-unknown-linux-gnu.tar.xz": "95d249a9c96253771e197adc86175acde4fa866f84aac84dc299df7bfee4985c", "dist/2022-04-05/rustc-beta-mips-unknown-linux-gnu.tar.xz": "aafea47e80244a136f87640e0b482898362d73a8b4f80ebcf6a539a268713350",
"dist/2022-02-22/rustc-beta-mips64-unknown-linux-gnuabi64.tar.gz": "7c0b48e2e3af9807a5b460cc453534f821850522b43ca66e918f42312f634a16", "dist/2022-04-05/rustc-beta-mips64-unknown-linux-gnuabi64.tar.gz": "0d23c8b6e50d1788b46b45c7df4720076829cfe45a926edece8b99223ec02f35",
"dist/2022-02-22/rustc-beta-mips64-unknown-linux-gnuabi64.tar.xz": "aeb58f5b1dc9c96813f421763fa75b19219cdfa24100faa5ff833f70b56b8087", "dist/2022-04-05/rustc-beta-mips64-unknown-linux-gnuabi64.tar.xz": "89a452f3820732daa166adc30b232261b86019ded316efdb42266b0bbaa09957",
"dist/2022-02-22/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "1ad4c58f78cf006b1243bdb3e4261ffc9d21c6eaa7ac2adad588173fa6bcba73", "dist/2022-04-05/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.gz": "30ba547c1e6b802b99d01ebbab93e7209a9abc701174079fd8f4651146926545",
"dist/2022-02-22/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "c119c341da94a30f569fbc1edeaf7d6e0083f6e16ef7aa219d3c499aae351ba5", "dist/2022-04-05/rustc-beta-mips64el-unknown-linux-gnuabi64.tar.xz": "172dcf58d1b68b56ad28dc00571a31457da8e9cd9a02be0a0eb816924ef5617d",
"dist/2022-02-22/rustc-beta-mipsel-unknown-linux-gnu.tar.gz": "b61616e8eeac33c979ee37f5938dd6ee5c308f58a6c2beb8a1f50c7e3506820f", "dist/2022-04-05/rustc-beta-mipsel-unknown-linux-gnu.tar.gz": "829459c4f165c80a8009c75860122c93dfbe7984b0ec4517a605973a82f86e42",
"dist/2022-02-22/rustc-beta-mipsel-unknown-linux-gnu.tar.xz": "bc5a46ef0c7e761f619e8cffb8dd1818a32551ca14be88649b2e2582f905bdec", "dist/2022-04-05/rustc-beta-mipsel-unknown-linux-gnu.tar.xz": "46c50f7d1e84abcd31160de933be9a4557da5e141ee60e84dfb8bff5fc99efd5",
"dist/2022-02-22/rustc-beta-powerpc-unknown-linux-gnu.tar.gz": "6331d582c1130652d939f22eda45ce1b321b577d34affefc0cc0d54050460d28", "dist/2022-04-05/rustc-beta-powerpc-unknown-linux-gnu.tar.gz": "313bf23cfa02982a59a2fed4301af0abc787969a493e437124a7bde76e73559c",
"dist/2022-02-22/rustc-beta-powerpc-unknown-linux-gnu.tar.xz": "bc5cb07aef32ef637b25850e443e737725c4cac7f513207d79f9520bd41888d7", "dist/2022-04-05/rustc-beta-powerpc-unknown-linux-gnu.tar.xz": "c5599b35c68a06c16d7a467b4a7fbf4584b4e4ec2ef6ce8504e6d2cc57ea78c0",
"dist/2022-02-22/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz": "a00742e6898e49363ee8478ec4f3d2cbfc778c540233d308b7ce88bdc7bc5dc0", "dist/2022-04-05/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz": "29d148d3b71f344d63d4fc8ca3809ea11dd4de58afaa0eac11047ee7772f7690",
"dist/2022-02-22/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz": "ad3a5f983ce1ff07948c962f885bf7adf182543e8cb04630a3feaafe43b8a56a", "dist/2022-04-05/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz": "c5614d7fe9c4a388d7e5902ee37aaaada479ff3ba0eebb63f5539fd83b5200ae",
"dist/2022-02-22/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz": "4b620d1c6e97436100dd2135ea4e380c5c7f5a480a9dc615601343dfbe30bab6", "dist/2022-04-05/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz": "29ce9644866ee2bbcf60668efb389255081b9c905ab1ccb34781c4b4258b5964",
"dist/2022-02-22/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz": "92ef427c03064dbb5e5f3cdd00fa86a754a6b67961534c37256d8dbe127a097e", "dist/2022-04-05/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz": "98eb0d3a369a39ba71b10c140986305c29fe56f79cdb3144e5a6d1eb9cfa6a82",
"dist/2022-02-22/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz": "4e050159e2a61217dcf3b622f5fab7bc18a1110ab2e87f161879545b7da52fe4", "dist/2022-04-05/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz": "0a510b176d2583b52873ca444122e8aff5b17183d87eb984cc3042b70125f685",
"dist/2022-02-22/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz": "bea23024681fb2bac5f1531969d494a421e48d19148a77b7be797298c6e162d0", "dist/2022-04-05/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz": "85231536c338281263cf9f4f9fc4c4148f0ad87e436b368a13e45bf75dab382a",
"dist/2022-02-22/rustc-beta-s390x-unknown-linux-gnu.tar.gz": "efc8e427beffd618501b1c14562c9b1a78958831737eb849507c00ebf0ad6e90", "dist/2022-04-05/rustc-beta-s390x-unknown-linux-gnu.tar.gz": "c998a37c27666f5eab87133df5b2b5f6c636df0375321a2dba149f8375bb2adc",
"dist/2022-02-22/rustc-beta-s390x-unknown-linux-gnu.tar.xz": "c361166049cfdc1de3a3fa8f11061ea770d76f38623db0ede269366bb7f82d99", "dist/2022-04-05/rustc-beta-s390x-unknown-linux-gnu.tar.xz": "50551f01002b91c14bf6e9232555764594e041fb3953b2d4c64ed48e904dc8f2",
"dist/2022-02-22/rustc-beta-x86_64-apple-darwin.tar.gz": "4c2c12f423036eadae0b328381426e7e43d7cb7a83e4fe06a4c88576e164d010", "dist/2022-04-05/rustc-beta-x86_64-apple-darwin.tar.gz": "9dc62cef50cc1af0e5b790aefb475ab002a3e6e9abfe449bbd35c33c0e2694b0",
"dist/2022-02-22/rustc-beta-x86_64-apple-darwin.tar.xz": "628d767591c8e5ece33de3e23e262fc55d6294513bbb537efbdb4b81f29f40a1", "dist/2022-04-05/rustc-beta-x86_64-apple-darwin.tar.xz": "088b67dcdc7bd2b79b438666fc1013d7fea31d603d50548dceddbdb6149f1c69",
"dist/2022-02-22/rustc-beta-x86_64-pc-windows-gnu.tar.gz": "06a2f1e96caf3737c5bfed4bdfb219a4f8b3484339d42651005dbc03eea634ed", "dist/2022-04-05/rustc-beta-x86_64-pc-windows-gnu.tar.gz": "95ecf36825fd88d6f7b1717248a8dd1863c8e249af69d66594912964c4b9d06a",
"dist/2022-02-22/rustc-beta-x86_64-pc-windows-gnu.tar.xz": "1892a79bb57dc0498db1ea467ea70455ec6bf4f55b5d014bd53170be81abb9d0", "dist/2022-04-05/rustc-beta-x86_64-pc-windows-gnu.tar.xz": "3ea5b4bc1e4e07e45a01df5519bd905c99726a0962e984059ad500243061f3e2",
"dist/2022-02-22/rustc-beta-x86_64-pc-windows-msvc.tar.gz": "1d55ec78eb3be79cffe3cd3dbaf300f9fec74f2f0d7559098c7a04002da75788", "dist/2022-04-05/rustc-beta-x86_64-pc-windows-msvc.tar.gz": "31f9226104cc55f67ea01db73a76e631937dee4e8b7e9561cb199cbbb02b33db",
"dist/2022-02-22/rustc-beta-x86_64-pc-windows-msvc.tar.xz": "6bf18b2583840dddebdd2f71b65e6986afb2c5ce03d9641a112afcdb443e3850", "dist/2022-04-05/rustc-beta-x86_64-pc-windows-msvc.tar.xz": "b054a6eadbfeebf1d8ccdbad8f323e65f32830095aaf512df80e65ec63900480",
"dist/2022-02-22/rustc-beta-x86_64-unknown-freebsd.tar.gz": "047906362381a6ea3c575e508fb80d12c269b104866c9a2b816c0702b67753f0", "dist/2022-04-05/rustc-beta-x86_64-unknown-freebsd.tar.gz": "17774e9e0678f1825b92fee1e9bed6fe56c8baf76ee43c9608b13985359f2911",
"dist/2022-02-22/rustc-beta-x86_64-unknown-freebsd.tar.xz": "b186691e919123365da36a4368ed5d1b78b81e46583b9c282a909004998a396c", "dist/2022-04-05/rustc-beta-x86_64-unknown-freebsd.tar.xz": "5b461322da60b08554f2557deb69485d3991abf13b75750a307c004d6547a42f",
"dist/2022-02-22/rustc-beta-x86_64-unknown-illumos.tar.gz": "c8c60d2aa4645a18578eba0a637b4f9ebfabeec0992cf75515013be87fb34a00", "dist/2022-04-05/rustc-beta-x86_64-unknown-illumos.tar.gz": "404e9bc04cc7330989d34cb8597814ee576ceee31fccbb932576171cd0dc2fca",
"dist/2022-02-22/rustc-beta-x86_64-unknown-illumos.tar.xz": "a126ae90761c130a1e9afd69b547b2c37486472a6fdc5c21f07f4298a2b92f65", "dist/2022-04-05/rustc-beta-x86_64-unknown-illumos.tar.xz": "5fa0cde302fb7abe148315116f5a499a76971d7bd7353043f1a4361510030a4d",
"dist/2022-02-22/rustc-beta-x86_64-unknown-linux-gnu.tar.gz": "ebea0afac2fab2a014c11ed97d6beb75578cc0ec985e5f8f8bc09b1c01615307", "dist/2022-04-05/rustc-beta-x86_64-unknown-linux-gnu.tar.gz": "a38030a213dc78b5030c03e40f1e6d533518e89fb88eed4632526c9297c7bd45",
"dist/2022-02-22/rustc-beta-x86_64-unknown-linux-gnu.tar.xz": "c40d047cda71b01faf5048b8cebc3ac7315da6f8bd47e080183e154c3f4eb651", "dist/2022-04-05/rustc-beta-x86_64-unknown-linux-gnu.tar.xz": "8595bf3845f559a9f7ddf63807ac535739592f4b61a62b028b63dd3db812fd6c",
"dist/2022-02-22/rustc-beta-x86_64-unknown-linux-musl.tar.gz": "6f017936f0bcb0b98ff733887383a8ae8902eba9014b6fe674a7aa379d681ade", "dist/2022-04-05/rustc-beta-x86_64-unknown-linux-musl.tar.gz": "c8184f26eed43d4d059f0d39eb58da781ac8cd1546ae26be55d5e4aaf617bfc7",
"dist/2022-02-22/rustc-beta-x86_64-unknown-linux-musl.tar.xz": "e89205f8583ea948ed82d7ff576c102bd18dd77bb9234835b3cd7c814951d69f", "dist/2022-04-05/rustc-beta-x86_64-unknown-linux-musl.tar.xz": "2cdf12d740ec570ae6999cb1334b84c24b5a5e4c0a97863b6085423c814caa93",
"dist/2022-02-22/rustc-beta-x86_64-unknown-netbsd.tar.gz": "f6fa66459dc4b58a1b4c19c7b0590293c7ebe2685021ba0ac382b541072965d7", "dist/2022-04-05/rustc-beta-x86_64-unknown-netbsd.tar.gz": "24bf12c22c765678cf4ea6860b3caaaccfd2762f473db40a6617a377df11b098",
"dist/2022-02-22/rustc-beta-x86_64-unknown-netbsd.tar.xz": "a65546bf3b63618ee16316c1ce552edf24f6d3d2d60dff63515ca61e69ee45a7", "dist/2022-04-05/rustc-beta-x86_64-unknown-netbsd.tar.xz": "64e3a7fd4027e3c93a147196b9ba1e0a2d43f1263d053c71e179fd2529c66a95",
"dist/2022-02-23/rustfmt-nightly-aarch64-apple-darwin.tar.gz": "8f4bc35d8e2b03db96a5d9faedb5e25155082d96621c26b90734219468904c62", "dist/2022-04-05/rustfmt-nightly-aarch64-apple-darwin.tar.gz": "63a0c7abc8a755a6946a7f17dcf04ee925f138d1c50d2ccce9ae8af53526d95f",
"dist/2022-02-23/rustfmt-nightly-aarch64-apple-darwin.tar.xz": "c83c48eae807ab73ebeb6324778faa1430b7efe0da6e32acb013cad9e2bb505c", "dist/2022-04-05/rustfmt-nightly-aarch64-apple-darwin.tar.xz": "a1ecb5efe8f1232336f9f8c0d3b7ed87d6de64ec8ec11f1aca0cc08ed46fef42",
"dist/2022-02-23/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz": "00b0beac51b53a7469a6b6ef9d99309baa4b9da3e6ef08d9e5a84dcd4697ba2c", "dist/2022-04-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz": "fdee076495e8314a4b24de97736da154eb5db6dcecfe629153a05dcd903e9b45",
"dist/2022-02-23/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz": "2d6dc8a6a02327d7d1fa3ab08f5a0a1cfb567a78ef6564a91050028d5f7e1eb0", "dist/2022-04-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz": "5d845c73478bc38ab42fb16dd138b82c8a44fab6b0787b5635140eb418516b79",
"dist/2022-02-23/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz": "88691ff2cefa6880cb4bbe2d717b5419cd0440ee0d000ff8a70f9d86d714b866", "dist/2022-04-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz": "dec1f8535a8edee8aaade80c87dacad690c0a158c4775ee0c9d9e580e1ea47bd",
"dist/2022-02-23/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz": "c075a7fe36931eff39f1880fce0dbb2d6d691bd4eee6f8db88b49f123e0117d0", "dist/2022-04-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz": "2b91b40a7b2af113210b386991c966758da6defab7e6c5c610574496513ab5ed",
"dist/2022-02-23/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz": "394ee236b37b687963a0c42e40b3c6863460c302429ad00ca37c7931ea896233", "dist/2022-04-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz": "85da42f4c758c88418f952dfe919b8eeba654ee75c72d87f2d56257fb2248efd",
"dist/2022-02-23/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz": "74b68d4c1a7d36cca7fd1dab686bd43b04af1be5a9a07f7c42c52b0d5ebe35e4", "dist/2022-04-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz": "0c4aade052166886439598db875872efa8fa5b2aa49e27271f57cec68e6a464a",
"dist/2022-02-23/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz": "d53edb376291a80362d4b51c8bf889f5cd3221e3e92c8db149f1d869024d4834", "dist/2022-04-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz": "44312f3a088159f78f6cb5e6518aea2727d61681b8a37d71bc414fd1310d1160",
"dist/2022-02-23/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz": "f26b9f9f97fce1c2de87b9d2168df0e4c3c995572dc6dcb5ac08ebb9185e8e77", "dist/2022-04-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz": "1cf420d4c8e8af78d5bd5aa95e662182c7a90a24e549cbf23f59e7444b0e45da",
"dist/2022-02-23/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz": "2771d7d805b9fe3604d47640f969ebab005944f8b77e4d30b2b48adeec62a1f8", "dist/2022-04-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz": "019fa75361e72cfd813c4ba9be8d48774a4a0cff1870b0e343278527dc62dedb",
"dist/2022-02-23/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz": "78f7160f9ad76a3dd6c5ac6021b9fb60ed758cbd90ae34ed2e16f3fd0a646add", "dist/2022-04-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz": "1be1e449ef8c299ef269baeba36c612746afdb16d59d9af8575ef67d5a4a4a3a",
"dist/2022-02-23/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz": "f46da2d33597142d7b6d344b03cb17c5f6d9345421781b071aa84d52c3c13488", "dist/2022-04-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz": "8a03f3f1126fe7312c3e86fd0162ae7ce82111f477c00f7884b47e74776e4192",
"dist/2022-02-23/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz": "f95d077c5a5f713b26330aec15f14430731c53f4d297853d23e8a0158cb7818a", "dist/2022-04-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz": "05345ba340c9eff4dc2893438a1bdeb047269a54f66cb2fcfd6f05f5a6706b07",
"dist/2022-02-23/rustfmt-nightly-i686-pc-windows-gnu.tar.gz": "fd2db83f3a984d3834b8ecb1450846fd514e4ed1941095fe89d8e4217abd8c81", "dist/2022-04-05/rustfmt-nightly-i686-pc-windows-gnu.tar.gz": "9e5cc2cae5e40b9a964f4f52c20f9566d1d401b696a3eeeb322f34c907eb1d45",
"dist/2022-02-23/rustfmt-nightly-i686-pc-windows-gnu.tar.xz": "9a031255581634341287da672c7a0d7e893927faefdc9bafee50f5af53633bcc", "dist/2022-04-05/rustfmt-nightly-i686-pc-windows-gnu.tar.xz": "db8991874c2f3a1e1ab92c2160cda4c9b1b567fd7b73a610f071e3a59682f585",
"dist/2022-02-23/rustfmt-nightly-i686-pc-windows-msvc.tar.gz": "13efc17049a0c032165eb8de8931069548acb2a282248f0a9a29656e8a97a5a8", "dist/2022-04-05/rustfmt-nightly-i686-pc-windows-msvc.tar.gz": "4729ed2d654cc84e4afc4cdbad7a2609783c2e01ff1442aa2b7209cc1793eeeb",
"dist/2022-02-23/rustfmt-nightly-i686-pc-windows-msvc.tar.xz": "7c684d51fd30c54203220b1505db629b37e2730686d0906d87e2b435093b52e7", "dist/2022-04-05/rustfmt-nightly-i686-pc-windows-msvc.tar.xz": "1c92a4124af30627a44690177dfb9a47aae9794bb2a6f22dd0171c4d0740ce7d",
"dist/2022-02-23/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz": "8d6ca92b75866a8c238a401476f3cbf4314e8cafa098d9bbc45769926b77e534", "dist/2022-04-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz": "4efb1ceabe3387eb9cb6663718ebef3cdcfc401ebd57557a1f71075c82db5443",
"dist/2022-02-23/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz": "c0609adb3c8cb75dd8e7351243fc6bf8f70701222097964262be0be3d8b6407d", "dist/2022-04-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz": "1485487c0fe779ea52c387a41776418f82649bf11dff56c65eebc9836c447741",
"dist/2022-02-23/rustfmt-nightly-mips-unknown-linux-gnu.tar.gz": "66eb9b3684e1f96765001989b6e8eaf03be016b9aa903ebc428f604a468ebf94", "dist/2022-04-05/rustfmt-nightly-mips-unknown-linux-gnu.tar.gz": "83af3e32a9e04e89fc0db69c96ee4de144464fc63daa9c15b5339b2b98dc29b3",
"dist/2022-02-23/rustfmt-nightly-mips-unknown-linux-gnu.tar.xz": "7300327d6ffc0950943c480e9831e63a23af477816a9f971278e8bbc6c0e3514", "dist/2022-04-05/rustfmt-nightly-mips-unknown-linux-gnu.tar.xz": "6cd906bfac78de1ec92a53ddee54fbaa437280c413411aae678fd87db9df11c6",
"dist/2022-02-23/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.gz": "670c81aed32cbe72b12b5c5b9de8ca65446ae201a3e547a7039bce015884acf8", "dist/2022-04-05/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.gz": "00bd1e70d9cf308fe4b48cae7188272068d8f98e782e40c74d6e1af20dad3984",
"dist/2022-02-23/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.xz": "9e86bddbbb0b755a7ad43fb2e20ff4cda4bd2e36d864112c75d69d142509e779", "dist/2022-04-05/rustfmt-nightly-mips64-unknown-linux-gnuabi64.tar.xz": "51b3192cfa8a9ad4e6981a6fc7a57fd50059d3182e67425a1c036db37b67c1c7",
"dist/2022-02-23/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.gz": "53f068e73ed65ad2a3903e7bbf80095d7dbc671e41d80780f52ffd1e1b101804", "dist/2022-04-05/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.gz": "b81e01d392d4d498be39b99ba4cbf24324248647d15eb470526421954596f2bf",
"dist/2022-02-23/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.xz": "519a29e54063cbee1dca22a17624e1508d1b1a3f1d27cfdac08226c4a7d76092", "dist/2022-04-05/rustfmt-nightly-mips64el-unknown-linux-gnuabi64.tar.xz": "e8c6a23e762c4f81030e8c7449e0d49fb60c058893e4ca2110012db8d4a9be43",
"dist/2022-02-23/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.gz": "56180120aa97452fff9016b87d8e97d15e35080e65a6dde9892059d20e09cb80", "dist/2022-04-05/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.gz": "64e38687c204feb1dcfd19aec7af93cea724548d5c1e74b38a69a29017c6d721",
"dist/2022-02-23/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.xz": "20604ae6826adfae2fbd67815a770a46d51f6aea7d5da73a54c66118645e76a3", "dist/2022-04-05/rustfmt-nightly-mipsel-unknown-linux-gnu.tar.xz": "0bc3ac22801cdd0fd6e71d172f61cc3249c6e61b6333e748eb47624d4ef60748",
"dist/2022-02-23/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz": "3f0c4fa31ff93aab3b586def6202a9a2b63c7ce2509e707992f941b7bbd43ecb", "dist/2022-04-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz": "9d03b1724dbacf126f626abc9c71c4461f75f6b1c71c5132c1ab1b4ae39363ee",
"dist/2022-02-23/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz": "d4eb5cb900b51018d83a0e1f0f50b12bd61f19cb7afc69f614c2fdeff446d323", "dist/2022-04-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz": "3fda672627eaa0f69d7492f55cae4d769bd421c671a74960d77bfd5021dc71c7",
"dist/2022-02-23/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz": "3991a0259b758588ad2166ba5b7b10c79e777941a87f27bcbad4ee7422a240e0", "dist/2022-04-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz": "265c0238b9878c454d65c361968d63b6d55b69f82adbf27fc626d333d093c212",
"dist/2022-02-23/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz": "2f507613d2cf82288f318bcd70c2d750dd06228699486ba7233ffb08f27baa03", "dist/2022-04-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz": "c50dc03c50d8e0222c959867f621772e7cac5df72d4487f6f6082898ed1fd1b0",
"dist/2022-02-23/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz": "811a37b83c293cf05780f62befaeecc69d5e847c407df3f355c27a69fffacd9c", "dist/2022-04-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz": "3b28fb9c8b8050fc3a06a4591bd90c7c2a42859aa61177572f60f1fed0bbd46a",
"dist/2022-02-23/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz": "99d5577c5766c6ddbba567306ba798ce62fbf92f9a6a227e46cb8c78ba04dda0", "dist/2022-04-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz": "2153976482c3bb6babf8602d7751a4bfa99ee96397d42efb91c38652e652bde9",
"dist/2022-02-23/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz": "bac95ae187e4bae372de1ae20fe87eac02a45956bd4dcca71870cf2431b5abb5", "dist/2022-04-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz": "7c2fdd326f5ebfcb7ad3c732954c2ca34191d40422eb7b318331219d282f34b7",
"dist/2022-02-23/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz": "a2501c6790552f2472891bd3298b0c9038e6dc3e826d060772ed396b2ca45f53", "dist/2022-04-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz": "38fe0ede661a71ca4010359c9e6d8c4656c2da4e13dbc9c7cd0b98481406bcd4",
"dist/2022-02-23/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz": "1e7a476248c2dc64ac2f65cfa74c0949f170c418674cb692ccf1c1cdccfdabd6", "dist/2022-04-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz": "4b682444c300d130087d77ab595fe829d1cfd4d08bc22aeda4042ad818b0402d",
"dist/2022-02-23/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz": "85fbac21530f0007da71dc979056f69cf267b2ed870e1d9deb71538a0f46b4c2", "dist/2022-04-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz": "c9d39631dae71e15702b194b7f4dd3dced040fa731dd2f8aeb892368f3637cbc",
"dist/2022-02-23/rustfmt-nightly-x86_64-apple-darwin.tar.gz": "6e7ba1d83b61ce690c857bc197f3c0a1cf0cb2afd3c4c7f16fdb4079f460ce6f", "dist/2022-04-05/rustfmt-nightly-x86_64-apple-darwin.tar.gz": "ee7c5a878da4b33761eb2991792833da41673d5bd5916ad8aefec83350e9cf3d",
"dist/2022-02-23/rustfmt-nightly-x86_64-apple-darwin.tar.xz": "6611703fcd9ec8ba9fa1837be5736c2b2833532cdcc152c5e3429d1994ac624a", "dist/2022-04-05/rustfmt-nightly-x86_64-apple-darwin.tar.xz": "54147e40db10a73e22d6aa20b40d5cd64c79b0b1afa57758cbd6809bd7ba62a0",
"dist/2022-02-23/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz": "e1350f9b420888776ab85bf2bc3e762c04a0ca8fe72e82d2d21215d4601f67ee", "dist/2022-04-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz": "e019b5a55a66755794f03eeadd927cfc839a2745c5865c5a53230bd5a961a296",
"dist/2022-02-23/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz": "0cd5343e4e2db2f68026a2d55ae5e91cff2402dd1657bc03d9bf131264d9a75f", "dist/2022-04-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz": "a7c0a92a4e34e2bb3d58166525bf10a400b643a0791b352b29ff25d8eee9a842",
"dist/2022-02-23/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz": "e1a81be6159fb9e28cb1f35ac4508a09a0be86edf6ab39db08988a5bbefa9e76", "dist/2022-04-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz": "4a9f16df3b8bbd38d43a1a585c29ba5b95dd7d60e4ee6df3063fdd36d1b64acb",
"dist/2022-02-23/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz": "d5073cb4c148ef6e664c1fe17b02900e5f6ee0cf39710cad55887ebd919e797d", "dist/2022-04-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz": "4af11a257914be44e8aff5e6d0e586282b12b52f326ecc95d2c58a921154606c",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz": "63a0018ed3b7bf94dca3db30be7a1d6940a7559cdd0ca408c366551e2f5e6863", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz": "06cb18eb062ac90f1d77f2b0f09d0220a265790e0b80c3549360eef72af14dee",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz": "85924719f0bfa06024496e550edfb6556a7b90e42d7d2d810b52f5bcef4401b0", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz": "37b671df4350aa5320174965eac84e05063a35dc0549f1aec035724fff143f0d",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-illumos.tar.gz": "ddd2d19ef69ecebb3d654769b06cba5da5c366f01167298ee581f7cd934c637e", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-illumos.tar.gz": "4949b3846cb5dfd7e52abd081631397d7614c16782b8f4eec90aefdac927dfad",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-illumos.tar.xz": "9178284a64238c7778b521c5a105034efbbb85039b619e3ebb1247b83334bd7d", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-illumos.tar.xz": "35a92e775b602d21d23bae702c5ac0de2c9eeba1da6e009084a95b448af8a689",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz": "7ab236ced294c39de4bb563e9ebaed04c906a4ccfd1932138d37d6d03f75cae7", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz": "f595603b8c255486801e62716133fa8460b63130e94a5c935dd48ec1189b1074",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz": "f392f5b890506e63407204998c3b9b9529dea8a7bdff2319bc202da6fa07c3b9", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz": "dc67ea19eb872659763784b716b8d264e654db5897d2a6766810623605af94b0",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz": "647da2183d93846ac5225b99117846a07a90975bdf1b5075e86601dcf97d1ecf", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz": "3e969a8904fe06c1299534d5bb334dea7b9b45321a155d189f2ab6c0781299a2",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz": "9c3be22743d1d9120d16ae47d035f788ba809207bdddeb8746828ea914dd90e4", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz": "b7a8f67c8da8c148bf1c33df7bffc76c8c3ca430d4e0ab8c4b261a2aaa98dc67",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz": "4c396836a92122b0594568a288fedaca9f5bdd58a7a2013882a1afd17ef69de2", "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz": "7b0e15340585812b597a68c5e6ab778346db3de5d6af7c41fa0cb710e6bf130b",
"dist/2022-02-23/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz": "0ae2188987be65bfad882878e7a1365310c2cc28504f7ad8400fd759dbc40684" "dist/2022-04-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz": "9fdb4e1e5afb2c3b110a605383ae2da844e1a5d87285a2475af4bf8d8dde5291"
} }
} }

20
src/test/rustdoc/rfc-2632-const-trait-impl.rs
View file

@ -11,50 +11,40 @@
pub struct S<T>(T); pub struct S<T>(T);
// @!has foo/trait.Tr.html '//pre[@class="rust trait"]/code/a[@class="trait"]' '~const' // @!has foo/trait.Tr.html '//pre[@class="rust trait"]/code/a[@class="trait"]' '~const'
// @!has - '//pre[@class="rust trait"]/code/a[@class="trait"]' 'Drop'
// @has - '//pre[@class="rust trait"]/code/a[@class="trait"]' 'Clone' // @has - '//pre[@class="rust trait"]/code/a[@class="trait"]' 'Clone'
// @!has - '//pre[@class="rust trait"]/code/span[@class="where"]' '~const' // @!has - '//pre[@class="rust trait"]/code/span[@class="where"]' '~const'
// @!has - '//pre[@class="rust trait"]/code/span[@class="where"]' 'Drop'
// @has - '//pre[@class="rust trait"]/code/span[@class="where"]' ': Clone' // @has - '//pre[@class="rust trait"]/code/span[@class="where"]' ': Clone'
pub trait Tr<T> { pub trait Tr<T> {
// @!has - '//div[@id="method.a"]/h4[@class="code-header"]' '~const' // @!has - '//div[@id="method.a"]/h4[@class="code-header"]' '~const'
// @!has - '//div[@id="method.a"]/h4[@class="code-header"]/a[@class="trait"]' 'Drop'
// @has - '//div[@id="method.a"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone' // @has - '//div[@id="method.a"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone'
// @!has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where"]' '~const' // @!has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where"]' '~const'
// @!has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' 'Drop'
// @has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone' // @has - '//div[@id="method.a"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
#[default_method_body_is_const] #[default_method_body_is_const]
fn a<A: ~const Drop + ~const Clone>() where Option<A>: ~const Drop + ~const Clone {} fn a<A: ~const Clone>() where Option<A>: ~const Clone {}
} }
// @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]' '~const' // @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]' '~const'
// @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/a[@class="trait"]' 'Drop'
// @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/a[@class="trait"]' 'Clone' // @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/a[@class="trait"]' 'Clone'
// @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where"]' '~const' // @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where"]' '~const'
// @!has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where fmt-newline"]' 'Drop'
// @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where fmt-newline"]' ': Clone' // @has - '//section[@id="impl-Tr%3CT%3E"]/h3[@class="code-header in-band"]/span[@class="where fmt-newline"]' ': Clone'
impl<T: ~const Drop + ~const Clone> const Tr<T> for T where Option<T>: ~const Drop + ~const Clone { impl<T: ~const Clone> const Tr<T> for T where Option<T>: ~const Clone {
fn a<A: ~const Drop + ~const Clone>() where Option<A>: ~const Drop + ~const Clone {} fn a<A: ~const Clone>() where Option<A>: ~const Clone {}
} }
// @!has foo/fn.foo.html '//pre[@class="rust fn"]/code/a[@class="trait"]' '~const' // @!has foo/fn.foo.html '//pre[@class="rust fn"]/code/a[@class="trait"]' '~const'
// @!has - '//pre[@class="rust fn"]/code/a[@class="trait"]' 'Drop'
// @has - '//pre[@class="rust fn"]/code/a[@class="trait"]' 'Clone' // @has - '//pre[@class="rust fn"]/code/a[@class="trait"]' 'Clone'
// @!has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' '~const' // @!has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' '~const'
// @!has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' 'Drop'
// @has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' ': Clone' // @has - '//pre[@class="rust fn"]/code/span[@class="where fmt-newline"]' ': Clone'
pub const fn foo<F: ~const Drop + ~const Clone>() where Option<F>: ~const Drop + ~const Clone { pub const fn foo<F: ~const Clone>() where Option<F>: ~const Clone {
F::a() F::a()
} }
impl<T> S<T> { impl<T> S<T> {
// @!has foo/struct.S.html '//section[@id="method.foo"]/h4[@class="code-header"]' '~const' // @!has foo/struct.S.html '//section[@id="method.foo"]/h4[@class="code-header"]' '~const'
// @!has - '//section[@id="method.foo"]/h4[@class="code-header"]/a[@class="trait"]' 'Drop'
// @has - '//section[@id="method.foo"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone' // @has - '//section[@id="method.foo"]/h4[@class="code-header"]/a[@class="trait"]' 'Clone'
// @!has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where"]' '~const' // @!has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where"]' '~const'
// @!has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' 'Drop'
// @has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone' // @has - '//section[@id="method.foo"]/h4[@class="code-header"]/span[@class="where fmt-newline"]' ': Clone'
pub const fn foo<B: ~const Drop + ~const Clone>() where B: ~const Drop + ~const Clone { pub const fn foo<B: ~const Clone>() where B: ~const Clone {
B::a() B::a()
} }
} }

4
src/test/ui/intrinsics/const-eval-select-bad.stderr
View file

@ -48,7 +48,7 @@ LL | const_eval_select((), 42, 0xDEADBEEF);
note: required by a bound in `const_eval_select` note: required by a bound in `const_eval_select`
--> $SRC_DIR/core/src/intrinsics.rs:LL:COL --> $SRC_DIR/core/src/intrinsics.rs:LL:COL
| |
LL | G: FnOnce<ARG, Output = RET> + ~const Drop + ~const Destruct, LL | G: FnOnce<ARG, Output = RET> + ~const Destruct,
| ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `const_eval_select` | ^^^^^^^^^^^^^^^^^^^^^^^^^ required by this bound in `const_eval_select`
error[E0271]: type mismatch resolving `<fn(i32) -> bool {bar} as FnOnce<(i32,)>>::Output == i32` error[E0271]: type mismatch resolving `<fn(i32) -> bool {bar} as FnOnce<(i32,)>>::Output == i32`
@ -60,7 +60,7 @@ LL | const_eval_select((1,), foo, bar);
note: required by a bound in `const_eval_select` note: required by a bound in `const_eval_select`
--> $SRC_DIR/core/src/intrinsics.rs:LL:COL --> $SRC_DIR/core/src/intrinsics.rs:LL:COL
| |
LL | G: FnOnce<ARG, Output = RET> + ~const Drop + ~const Destruct, LL | G: FnOnce<ARG, Output = RET> + ~const Destruct,
| ^^^^^^^^^^^^ required by this bound in `const_eval_select` | ^^^^^^^^^^^^ required by this bound in `const_eval_select`
error[E0631]: type mismatch in function arguments error[E0631]: type mismatch in function arguments

1
src/test/ui/target-feature/tied-features.rs
View file

@ -1,7 +1,6 @@
// build-fail // build-fail
// compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu // compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
// needs-llvm-components: aarch64 // needs-llvm-components: aarch64
#![cfg_attr(bootstrap, feature(aarch64_target_feature))]
#![feature(no_core, lang_items)] #![feature(no_core, lang_items)]
#![no_core] #![no_core]

4
src/test/ui/target-feature/tied-features.stderr
View file

@ -1,5 +1,5 @@
error: the target features paca, pacg must all be either enabled or disabled together error: the target features paca, pacg must all be either enabled or disabled together
--> $DIR/tied-features.rs:13:5 --> $DIR/tied-features.rs:12:5
| |
LL | #[target_feature(enable = "pacg")] LL | #[target_feature(enable = "pacg")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@ -7,7 +7,7 @@ LL | #[target_feature(enable = "pacg")]
= help: add the missing features in a `target_feature` attribute = help: add the missing features in a `target_feature` attribute
error: the target features paca, pacg must all be either enabled or disabled together error: the target features paca, pacg must all be either enabled or disabled together
--> $DIR/tied-features.rs:25:1 --> $DIR/tied-features.rs:24:1
| |
LL | #[target_feature(enable = "paca")] LL | #[target_feature(enable = "paca")]
| ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

4
src/tools/compiletest/src/header.rs
View file

@ -806,8 +806,7 @@ pub fn make_test_description<R: Read>(
cfg: Option<&str>, cfg: Option<&str>,
) -> test::TestDesc { ) -> test::TestDesc {
let mut ignore = false; let mut ignore = false;
#[cfg(not(bootstrap))] let ignore_message = None;
let ignore_message: Option<String> = None;
let mut should_fail = false; let mut should_fail = false;
let rustc_has_profiler_support = env::var_os("RUSTC_PROFILER_SUPPORT").is_some(); let rustc_has_profiler_support = env::var_os("RUSTC_PROFILER_SUPPORT").is_some();
@ -879,7 +878,6 @@ pub fn make_test_description<R: Read>(
test::TestDesc { test::TestDesc {
name, name,
ignore, ignore,
#[cfg(not(bootstrap))]
ignore_message, ignore_message,
should_panic, should_panic,
compile_fail: false, compile_fail: false,