Auto merge of #155416 - Zalathar:rollup-D1EWnrR, r=Zalathar

Rollup of 19 pull requests

Successful merges:

 - rust-lang/rust#141633 (Suggest to bind `self.x` to `x` when field `x` may be in format string)
 - rust-lang/rust#152980 (c-variadic: fix implementation on `avr`)
 - rust-lang/rust#154491 (Extend `core::char`'s documentation of casing issues (and fix a rustdoc bug))
 - rust-lang/rust#155318 (Use mutable pointers for Unix path buffers)
 - rust-lang/rust#155335 (Bump bootstrap to 1.96 beta)
 - rust-lang/rust#155354 (Remove AttributeSafety from BUILTIN_ATTRIBUTES)
 - rust-lang/rust#154970 (rustdoc: preserve `doc(cfg)` on locally re-exported type aliases)
 - rust-lang/rust#155095 (changed the information provided by (mut x) to mut x (Fix 155030))
 - rust-lang/rust#155305 (Make `convert_while_ascii` unsafe)
 - rust-lang/rust#155358 (ImproperCTypes: Move erasing_region_normalisation into helper function)
 - rust-lang/rust#155377 (tests/debuginfo/basic-stepping.rs: Remove FIXME related to ZSTs)
 - rust-lang/rust#155383 (Rearrange `rustc_ast_pretty`)
 - rust-lang/rust#155384 (triagebot: notify on diagnostic attribute changes)
 - rust-lang/rust#155386 (Use `box_new` diagnostic item for Box::new suggestions)
 - rust-lang/rust#155391 (Small refactor of `QueryJob::latch` method)
 - rust-lang/rust#155395 (Tweak how the "copy path" rustdoc button works to allow some accessibility tool to work with rustdoc)
 - rust-lang/rust#155396 (`as_ref_unchecked` docs link fix)
 - rust-lang/rust#155411 (compiletest: Remove the `//@ should-ice` directive)
 - rust-lang/rust#155413 (fix: typo in `std::fs::hard_link` documentation)

compiler/rustc_ast_pretty/src/helpers.rs

@@ -1,49 +0,0 @@
-use std::borrow::Cow;
-
-use crate::pp::Printer;
-
-impl Printer {
-    pub fn word_space<W: Into<Cow<'static, str>>>(&mut self, w: W) {
-        self.word(w);
-        self.space();
-    }
-
-    pub fn popen(&mut self) {
-        self.word("(");
-    }
-
-    pub fn pclose(&mut self) {
-        self.word(")");
-    }
-
-    pub fn hardbreak_if_not_bol(&mut self) {
-        if !self.is_beginning_of_line() {
-            self.hardbreak()
-        }
-    }
-
-    pub fn space_if_not_bol(&mut self) {
-        if !self.is_beginning_of_line() {
-            self.space();
-        }
-    }
-
-    pub fn nbsp(&mut self) {
-        self.word(" ")
-    }
-
-    pub fn word_nbsp<S: Into<Cow<'static, str>>>(&mut self, w: S) {
-        self.word(w);
-        self.nbsp()
-    }
-
-    /// Synthesizes a comment that was not textually present in the original
-    /// source file.
-    pub fn synth_comment(&mut self, text: impl Into<Cow<'static, str>>) {
-        self.word("/*");
-        self.space();
-        self.word(text);
-        self.space();
-        self.word("*/")
-    }
-}

compiler/rustc_ast_pretty/src/lib.rs

@@ -3,6 +3,5 @@
 #![feature(negative_impls)]
 // tidy-alphabetical-end
 
-mod helpers;
 pub mod pp;
 pub mod pprust;

compiler/rustc_ast_pretty/src/pp.rs

@@ -132,7 +132,6 @@
 //! methods called `Printer::scan_*`, and the 'PRINT' process is the
 //! method called `Printer::print`.
 
-mod convenience;
 mod ring;
 
 use std::borrow::Cow;
@@ -188,6 +187,12 @@ pub(crate) enum Token {
     End,
 }
 
+impl Token {
+    pub(crate) fn is_hardbreak_tok(&self) -> bool {
+        *self == Printer::hardbreak_tok_offset(0)
+    }
+}
+
 #[derive(Copy, Clone)]
 enum PrintFrame {
     Fits,
@@ -479,4 +484,132 @@ fn print_string(&mut self, string: &str) {
         self.out.push_str(string);
         self.space -= string.len() as isize;
     }
+
+    /// Synthesizes a comment that was not textually present in the original
+    /// source file.
+    pub fn synth_comment(&mut self, text: impl Into<Cow<'static, str>>) {
+        self.word("/*");
+        self.space();
+        self.word(text);
+        self.space();
+        self.word("*/")
+    }
+
+    /// "raw box"
+    pub fn rbox(&mut self, indent: isize, breaks: Breaks) -> BoxMarker {
+        self.scan_begin(BeginToken { indent: IndentStyle::Block { offset: indent }, breaks })
+    }
+
+    /// Inconsistent breaking box
+    pub fn ibox(&mut self, indent: isize) -> BoxMarker {
+        self.rbox(indent, Breaks::Inconsistent)
+    }
+
+    /// Consistent breaking box
+    pub fn cbox(&mut self, indent: isize) -> BoxMarker {
+        self.rbox(indent, Breaks::Consistent)
+    }
+
+    pub fn visual_align(&mut self) -> BoxMarker {
+        self.scan_begin(BeginToken { indent: IndentStyle::Visual, breaks: Breaks::Consistent })
+    }
+
+    pub fn break_offset(&mut self, n: usize, off: isize) {
+        self.scan_break(BreakToken {
+            offset: off,
+            blank_space: n as isize,
+            ..BreakToken::default()
+        });
+    }
+
+    pub fn end(&mut self, b: BoxMarker) {
+        self.scan_end(b)
+    }
+
+    pub fn eof(mut self) -> String {
+        self.scan_eof();
+        self.out
+    }
+
+    pub fn word<S: Into<Cow<'static, str>>>(&mut self, wrd: S) {
+        let string = wrd.into();
+        self.scan_string(string)
+    }
+
+    pub fn word_space<W: Into<Cow<'static, str>>>(&mut self, w: W) {
+        self.word(w);
+        self.space();
+    }
+
+    pub fn nbsp(&mut self) {
+        self.word(" ")
+    }
+
+    pub fn word_nbsp<S: Into<Cow<'static, str>>>(&mut self, w: S) {
+        self.word(w);
+        self.nbsp()
+    }
+
+    fn spaces(&mut self, n: usize) {
+        self.break_offset(n, 0)
+    }
+
+    pub fn zerobreak(&mut self) {
+        self.spaces(0)
+    }
+
+    pub fn space(&mut self) {
+        self.spaces(1)
+    }
+
+    pub fn popen(&mut self) {
+        self.word("(");
+    }
+
+    pub fn pclose(&mut self) {
+        self.word(")");
+    }
+
+    pub fn hardbreak(&mut self) {
+        self.spaces(SIZE_INFINITY as usize)
+    }
+
+    pub fn is_beginning_of_line(&self) -> bool {
+        match self.last_token() {
+            Some(last_token) => last_token.is_hardbreak_tok(),
+            None => true,
+        }
+    }
+
+    pub fn hardbreak_if_not_bol(&mut self) {
+        if !self.is_beginning_of_line() {
+            self.hardbreak()
+        }
+    }
+
+    pub fn space_if_not_bol(&mut self) {
+        if !self.is_beginning_of_line() {
+            self.space();
+        }
+    }
+
+    pub(crate) fn hardbreak_tok_offset(off: isize) -> Token {
+        Token::Break(BreakToken {
+            offset: off,
+            blank_space: SIZE_INFINITY,
+            ..BreakToken::default()
+        })
+    }
+
+    pub fn trailing_comma(&mut self) {
+        self.scan_break(BreakToken { pre_break: Some(','), ..BreakToken::default() });
+    }
+
+    pub fn trailing_comma_or_space(&mut self) {
+        self.scan_break(BreakToken {
+            blank_space: 1,
+            pre_break: Some(','),
+            ..BreakToken::default()
+        });
+    }
 }

compiler/rustc_ast_pretty/src/pp/convenience.rs

@@ -1,97 +0,0 @@
-use std::borrow::Cow;
-
-use crate::pp::{
-    BeginToken, BoxMarker, BreakToken, Breaks, IndentStyle, Printer, SIZE_INFINITY, Token,
-};
-
-impl Printer {
-    /// "raw box"
-    pub fn rbox(&mut self, indent: isize, breaks: Breaks) -> BoxMarker {
-        self.scan_begin(BeginToken { indent: IndentStyle::Block { offset: indent }, breaks })
-    }
-
-    /// Inconsistent breaking box
-    pub fn ibox(&mut self, indent: isize) -> BoxMarker {
-        self.rbox(indent, Breaks::Inconsistent)
-    }
-
-    /// Consistent breaking box
-    pub fn cbox(&mut self, indent: isize) -> BoxMarker {
-        self.rbox(indent, Breaks::Consistent)
-    }
-
-    pub fn visual_align(&mut self) -> BoxMarker {
-        self.scan_begin(BeginToken { indent: IndentStyle::Visual, breaks: Breaks::Consistent })
-    }
-
-    pub fn break_offset(&mut self, n: usize, off: isize) {
-        self.scan_break(BreakToken {
-            offset: off,
-            blank_space: n as isize,
-            ..BreakToken::default()
-        });
-    }
-
-    pub fn end(&mut self, b: BoxMarker) {
-        self.scan_end(b)
-    }
-
-    pub fn eof(mut self) -> String {
-        self.scan_eof();
-        self.out
-    }
-
-    pub fn word<S: Into<Cow<'static, str>>>(&mut self, wrd: S) {
-        let string = wrd.into();
-        self.scan_string(string)
-    }
-
-    fn spaces(&mut self, n: usize) {
-        self.break_offset(n, 0)
-    }
-
-    pub fn zerobreak(&mut self) {
-        self.spaces(0)
-    }
-
-    pub fn space(&mut self) {
-        self.spaces(1)
-    }
-
-    pub fn hardbreak(&mut self) {
-        self.spaces(SIZE_INFINITY as usize)
-    }
-
-    pub fn is_beginning_of_line(&self) -> bool {
-        match self.last_token() {
-            Some(last_token) => last_token.is_hardbreak_tok(),
-            None => true,
-        }
-    }
-
-    pub(crate) fn hardbreak_tok_offset(off: isize) -> Token {
-        Token::Break(BreakToken {
-            offset: off,
-            blank_space: SIZE_INFINITY,
-            ..BreakToken::default()
-        })
-    }
-
-    pub fn trailing_comma(&mut self) {
-        self.scan_break(BreakToken { pre_break: Some(','), ..BreakToken::default() });
-    }
-
-    pub fn trailing_comma_or_space(&mut self) {
-        self.scan_break(BreakToken {
-            blank_space: 1,
-            pre_break: Some(','),
-            ..BreakToken::default()
-        });
-    }
-}
-
-impl Token {
-    pub(crate) fn is_hardbreak_tok(&self) -> bool {
-        *self == Printer::hardbreak_tok_offset(0)
-    }
-}

compiler/rustc_attr_parsing/src/attributes/cfg.rs

@@ -19,6 +19,7 @@
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 use thin_vec::ThinVec;
 
+use crate::attributes::AttributeSafety;
 use crate::context::{AcceptContext, ShouldEmit, Stage};
 use crate::parser::{
     AllowExprMetavar, ArgParser, MetaItemListParser, MetaItemOrLitParser, NameValueParser,
@@ -410,6 +411,7 @@ fn parse_cfg_attr_internal<'a>(
         attribute.style,
         AttrPath { segments: attribute.path().into_boxed_slice(), span: attribute.span },
         Some(attribute.get_normal_item().unsafety),
+        AttributeSafety::Normal,
         ParsedDescription::Attribute,
         pred_span,
         lint_node_id,

compiler/rustc_attr_parsing/src/attributes/cfg_select.rs

@@ -12,6 +12,7 @@
 use rustc_session::lint::builtin::UNREACHABLE_CFG_SELECT_PREDICATES;
 use rustc_span::{ErrorGuaranteed, Span, Symbol, sym};
 
+use crate::attributes::AttributeSafety;
 use crate::parser::{AllowExprMetavar, MetaItemOrLitParser};
 use crate::{AttributeParser, ParsedDescription, ShouldEmit, errors, parse_cfg_entry};
 
@@ -105,6 +106,7 @@ pub fn parse_cfg_select(
                 AttrStyle::Inner,
                 AttrPath { segments: vec![sym::cfg_select].into_boxed_slice(), span: cfg_span },
                 None,
+                AttributeSafety::Normal,
                 ParsedDescription::Macro,
                 cfg_span,
                 lint_node_id,

compiler/rustc_attr_parsing/src/attributes/codegen_attrs.rs

@@ -1,7 +1,9 @@
 use rustc_hir::attrs::{CoverageAttrKind, OptimizeAttr, RtsanSetting, SanitizerSet, UsedBy};
 use rustc_session::parse::feature_err;
+use rustc_span::edition::Edition::Edition2024;
 
 use super::prelude::*;
+use crate::attributes::AttributeSafety;
 use crate::session_diagnostics::{
     NakedFunctionIncompatibleAttribute, NullOnExport, NullOnObjcClass, NullOnObjcSelector,
     ObjcClassExpectedStringLiteral, ObjcSelectorExpectedStringLiteral,
@@ -103,6 +105,7 @@ fn convert(cx: &mut AcceptContext<'_, '_, S>, args: &ArgParser) -> Option<Attrib
 impl<S: Stage> SingleAttributeParser<S> for ExportNameParser {
     const PATH: &[rustc_span::Symbol] = &[sym::export_name];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+    const SAFETY: AttributeSafety = AttributeSafety::Unsafe { unsafe_since: Some(Edition2024) };
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Static),
         Allow(Target::Fn),
@@ -220,6 +223,7 @@ impl<S: Stage> AttributeParser<S> for NakedParser {
                 this.span = Some(cx.attr_span);
             }
         })];
+    const SAFETY: AttributeSafety = AttributeSafety::Unsafe { unsafe_since: None };
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[
         Allow(Target::Fn),
         Allow(Target::Method(MethodKind::Inherent)),
@@ -340,6 +344,7 @@ impl<S: Stage> NoArgsAttributeParser<S> for TrackCallerParser {
 impl<S: Stage> NoArgsAttributeParser<S> for NoMangleParser {
     const PATH: &[Symbol] = &[sym::no_mangle];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const SAFETY: AttributeSafety = AttributeSafety::Unsafe { unsafe_since: Some(Edition2024) };
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
         Allow(Target::Fn),
         Allow(Target::Static),
@@ -542,6 +547,7 @@ fn extend(
 impl<S: Stage> CombineAttributeParser<S> for ForceTargetFeatureParser {
     type Item = (Symbol, Span);
     const PATH: &[Symbol] = &[sym::force_target_feature];
+    const SAFETY: AttributeSafety = AttributeSafety::Unsafe { unsafe_since: None };
     const CONVERT: ConvertFn<Self::Item> = |items, span| AttributeKind::TargetFeature {
         features: items,
         attr_span: span,

compiler/rustc_attr_parsing/src/attributes/link_attrs.rs

@@ -5,11 +5,13 @@
 use rustc_session::Session;
 use rustc_session::lint::builtin::ILL_FORMED_ATTRIBUTE_INPUT;
 use rustc_session::parse::feature_err;
+use rustc_span::edition::Edition::Edition2024;
 use rustc_span::kw;
 use rustc_target::spec::{Arch, BinaryFormat};
 
 use super::prelude::*;
 use super::util::parse_single_integer;
+use crate::attributes::AttributeSafety;
 use crate::attributes::cfg::parse_cfg_entry;
 use crate::session_diagnostics::{
     AsNeededCompatibility, BundleNeedsStatic, EmptyLinkName, ExportSymbolsNeedsStatic,
@@ -463,6 +465,7 @@ fn parse_link_import_name_type<S: Stage>(
 impl<S: Stage> SingleAttributeParser<S> for LinkSectionParser {
     const PATH: &[Symbol] = &[sym::link_section];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::WarnButFutureError;
+    const SAFETY: AttributeSafety = AttributeSafety::Unsafe { unsafe_since: Some(Edition2024) };
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowListWarnRest(&[
         Allow(Target::Static),
         Allow(Target::Fn),
@@ -508,6 +511,7 @@ impl<S: Stage> NoArgsAttributeParser<S> for ExportStableParser {
 impl<S: Stage> NoArgsAttributeParser<S> for FfiConstParser {
     const PATH: &[Symbol] = &[sym::ffi_const];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const SAFETY: AttributeSafety = AttributeSafety::Unsafe { unsafe_since: None };
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::ForeignFn)]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::FfiConst;
 }
@@ -516,6 +520,7 @@ impl<S: Stage> NoArgsAttributeParser<S> for FfiConstParser {
 impl<S: Stage> NoArgsAttributeParser<S> for FfiPureParser {
     const PATH: &[Symbol] = &[sym::ffi_pure];
     const ON_DUPLICATE: OnDuplicate<S> = OnDuplicate::Warn;
+    const SAFETY: AttributeSafety = AttributeSafety::Unsafe { unsafe_since: None };
     const ALLOWED_TARGETS: AllowedTargets = AllowedTargets::AllowList(&[Allow(Target::ForeignFn)]);
     const CREATE: fn(Span) -> AttributeKind = AttributeKind::FfiPure;
 }

compiler/rustc_attr_parsing/src/attributes/mod.rs

@@ -18,6 +18,7 @@
 
 use rustc_feature::{AttributeTemplate, template};
 use rustc_hir::attrs::AttributeKind;
+use rustc_span::edition::Edition;
 use rustc_span::{Span, Symbol};
 use thin_vec::ThinVec;
 
@@ -97,6 +98,7 @@ pub(crate) trait AttributeParser<S: Stage>: Default + 'static {
     /// If an attribute has this symbol, the `accept` function will be called on it.
     const ATTRIBUTES: AcceptMapping<Self, S>;
     const ALLOWED_TARGETS: AllowedTargets;
+    const SAFETY: AttributeSafety = AttributeSafety::Normal;
 
     /// The parser has gotten a chance to accept the attributes on an item,
     /// here it can produce an attribute.
@@ -127,6 +129,7 @@ pub(crate) trait SingleAttributeParser<S: Stage>: 'static {
     /// Configures what to do when when the same attribute is
     /// applied more than once on the same syntax node.
     const ON_DUPLICATE: OnDuplicate<S>;
+    const SAFETY: AttributeSafety = AttributeSafety::Normal;
 
     const ALLOWED_TARGETS: AllowedTargets;
 
@@ -165,6 +168,7 @@ impl<T: SingleAttributeParser<S>, S: Stage> AttributeParser<S> for Single<T, S>
         },
     )];
     const ALLOWED_TARGETS: AllowedTargets = T::ALLOWED_TARGETS;
+    const SAFETY: AttributeSafety = T::SAFETY;
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         Some(self.1?.0)
@@ -217,6 +221,18 @@ fn exec<P: SingleAttributeParser<S>>(
     }
 }
 
+#[derive(Copy, Clone, PartialEq, Debug)]
+pub enum AttributeSafety {
+    /// Normal attribute that does not need `#[unsafe(...)]`
+    Normal,
+    /// Unsafe attribute that requires safety obligations to be discharged.
+    ///
+    /// An error is emitted when `#[unsafe(...)]` is omitted, except when the attribute's edition
+    /// is less than the one stored in `unsafe_since`. This handles attributes that were safe in
+    /// earlier editions, but become unsafe in later ones.
+    Unsafe { unsafe_since: Option<Edition> },
+}
+
 /// An even simpler version of [`SingleAttributeParser`]:
 /// now automatically check that there are no arguments provided to the attribute.
 ///
@@ -226,6 +242,7 @@ pub(crate) trait NoArgsAttributeParser<S: Stage>: 'static {
     const PATH: &[Symbol];
     const ON_DUPLICATE: OnDuplicate<S>;
     const ALLOWED_TARGETS: AllowedTargets;
+    const SAFETY: AttributeSafety = AttributeSafety::Normal;
 
     /// Create the [`AttributeKind`] given attribute's [`Span`].
     const CREATE: fn(Span) -> AttributeKind;
@@ -242,6 +259,7 @@ fn default() -> Self {
 impl<T: NoArgsAttributeParser<S>, S: Stage> SingleAttributeParser<S> for WithoutArgs<T, S> {
     const PATH: &[Symbol] = T::PATH;
     const ON_DUPLICATE: OnDuplicate<S> = T::ON_DUPLICATE;
+    const SAFETY: AttributeSafety = T::SAFETY;
     const ALLOWED_TARGETS: AllowedTargets = T::ALLOWED_TARGETS;
     const TEMPLATE: AttributeTemplate = template!(Word);
 
@@ -271,6 +289,7 @@ pub(crate) trait CombineAttributeParser<S: Stage>: 'static {
     /// For example, individual representations from `#[repr(...)]` attributes into an `AttributeKind::Repr(x)`,
     ///  where `x` is a vec of these individual reprs.
     const CONVERT: ConvertFn<Self::Item>;
+    const SAFETY: AttributeSafety = AttributeSafety::Normal;
 
     const ALLOWED_TARGETS: AllowedTargets;
 
@@ -312,6 +331,7 @@ impl<T: CombineAttributeParser<S>, S: Stage> AttributeParser<S> for Combine<T, S
             group.items.extend(T::extend(cx, args))
         })];
     const ALLOWED_TARGETS: AllowedTargets = T::ALLOWED_TARGETS;
+    const SAFETY: AttributeSafety = T::SAFETY;
 
     fn finalize(self, _cx: &FinalizeContext<'_, '_, S>) -> Option<AttributeKind> {
         if let Some(first_span) = self.first_span {

compiler/rustc_attr_parsing/src/context.rs

@@ -59,7 +59,7 @@
 use crate::attributes::test_attrs::*;
 use crate::attributes::traits::*;
 use crate::attributes::transparency::*;
-use crate::attributes::{AttributeParser as _, Combine, Single, WithoutArgs};
+use crate::attributes::{AttributeParser as _, AttributeSafety, Combine, Single, WithoutArgs};
 use crate::parser::{ArgParser, MetaItemOrLitParser, RefPathParser};
 use crate::session_diagnostics::{
     AttributeParseError, AttributeParseErrorReason, AttributeParseErrorSuggestions,
@@ -76,6 +76,7 @@ pub(super) struct GroupTypeInnerAccept<S: Stage> {
     pub(super) template: AttributeTemplate,
     pub(super) accept_fn: AcceptFn<S>,
     pub(super) allowed_targets: AllowedTargets,
+    pub(super) safety: AttributeSafety,
     pub(super) finalizer: FinalizeFn<S>,
 }
 
@@ -126,6 +127,7 @@ mod late {
                                             accept_fn(s, cx, args)
                                         })
                                     }),
+                                    safety: <$names as crate::attributes::AttributeParser<$stage>>::SAFETY,
                                     allowed_targets: <$names as crate::attributes::AttributeParser<$stage>>::ALLOWED_TARGETS,
                                     finalizer: Box::new(|cx| {
                                         let state = STATE_OBJECT.take();

compiler/rustc_attr_parsing/src/interface.rs

@@ -12,6 +12,7 @@
 use rustc_session::lint::LintId;
 use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 
+use crate::attributes::AttributeSafety;
 use crate::context::{AcceptContext, FinalizeContext, FinalizeFn, SharedContext, Stage};
 use crate::early_parsed::{EARLY_PARSED_ATTRIBUTES, EarlyParsedState};
 use crate::parser::{AllowExprMetavar, ArgParser, PathParser, RefPathParser};
@@ -135,6 +136,7 @@ pub fn parse_single<T>(
         parse_fn: fn(cx: &mut AcceptContext<'_, '_, Early>, item: &ArgParser) -> Option<T>,
         template: &AttributeTemplate,
         allow_expr_metavar: AllowExprMetavar,
+        expected_safety: AttributeSafety,
     ) -> Option<T> {
         let ast::AttrKind::Normal(normal_attr) = &attr.kind else {
             panic!("parse_single called on a doc attr")
@@ -157,6 +159,7 @@ pub fn parse_single<T>(
             attr.style,
             path,
             Some(normal_attr.item.unsafety),
+            expected_safety,
             ParsedDescription::Attribute,
             target_span,
             target_node_id,
@@ -178,6 +181,7 @@ pub fn parse_single_args<T, I>(
         attr_style: AttrStyle,
         attr_path: AttrPath,
         attr_safety: Option<Safety>,
+        expected_safety: AttributeSafety,
         parsed_description: ParsedDescription,
         target_span: Span,
         target_node_id: NodeId,
@@ -199,7 +203,13 @@ pub fn parse_single_args<T, I>(
             sess.psess.buffer_lint(lint_id.lint, span, target_node_id, kind)
         };
         if let Some(safety) = attr_safety {
-            parser.check_attribute_safety(&attr_path, inner_span, safety, &mut emit_lint)
+            parser.check_attribute_safety(
+                &attr_path,
+                inner_span,
+                safety,
+                expected_safety,
+                &mut emit_lint,
+            )
         }
         let mut cx: AcceptContext<'_, 'sess, Early> = AcceptContext {
             shared: SharedContext {
@@ -314,17 +324,18 @@ pub fn parse_attribute_list(
                         }
                     };
 
-                    self.check_attribute_safety(
-                        &attr_path,
-                        lower_span(n.item.span()),
-                        n.item.unsafety,
-                        &mut emit_lint,
-                    );
-
                     let parts =
                         n.item.path.segments.iter().map(|seg| seg.ident.name).collect::<Vec<_>>();
 
                     if let Some(accept) = S::parsers().accepters.get(parts.as_slice()) {
+                        self.check_attribute_safety(
+                            &attr_path,
+                            lower_span(n.item.span()),
+                            n.item.unsafety,
+                            accept.safety,
+                            &mut emit_lint,
+                        );
+
                         let Some(args) = ArgParser::from_attr_args(
                             args,
                             &parts,
@@ -397,6 +408,14 @@ pub fn parse_attribute_list(
                             span: attr_span,
                         };
 
+                        self.check_attribute_safety(
+                            &attr_path,
+                            lower_span(n.item.span()),
+                            n.item.unsafety,
+                            AttributeSafety::Normal,
+                            &mut emit_lint,
+                        );
+
                         if !matches!(self.stage.should_emit(), ShouldEmit::Nothing)
                             && target == Target::Crate
                         {

compiler/rustc_attr_parsing/src/lib.rs

@@ -106,6 +106,7 @@
 mod target_checking;
 pub mod validate_attr;
 
+pub use attributes::AttributeSafety;
 pub use attributes::cfg::{
     CFG_TEMPLATE, EvalConfigResult, eval_config_entry, parse_cfg, parse_cfg_attr, parse_cfg_entry,
 };

compiler/rustc_attr_parsing/src/safety.rs

@@ -1,12 +1,12 @@
 use rustc_ast::Safety;
 use rustc_errors::MultiSpan;
-use rustc_feature::{AttributeSafety, BUILTIN_ATTRIBUTE_MAP};
 use rustc_hir::AttrPath;
 use rustc_hir::lints::AttributeLintKind;
 use rustc_session::lint::LintId;
 use rustc_session::lint::builtin::UNSAFE_ATTR_OUTSIDE_UNSAFE;
 use rustc_span::Span;
 
+use crate::attributes::AttributeSafety;
 use crate::context::Stage;
 use crate::{AttributeParser, ShouldEmit};
 
@@ -16,28 +16,23 @@ pub fn check_attribute_safety(
         attr_path: &AttrPath,
         attr_span: Span,
         attr_safety: Safety,
+        expected_safety: AttributeSafety,
         emit_lint: &mut impl FnMut(LintId, MultiSpan, AttributeLintKind),
     ) {
         if matches!(self.stage.should_emit(), ShouldEmit::Nothing) {
             return;
         }
 
-        let name = (attr_path.segments.len() == 1).then_some(attr_path.segments[0]);
-
-        // FIXME: We should retrieve this information from the attribute parsers instead of from `BUILTIN_ATTRIBUTE_MAP`
-        let builtin_attr_info = name.and_then(|name| BUILTIN_ATTRIBUTE_MAP.get(&name));
-        let builtin_attr_safety = builtin_attr_info.map(|x| x.safety);
-
-        match (builtin_attr_safety, attr_safety) {
+        match (expected_safety, attr_safety) {
             // - Unsafe builtin attribute
             // - User wrote `#[unsafe(..)]`, which is permitted on any edition
-            (Some(AttributeSafety::Unsafe { .. }), Safety::Unsafe(..)) => {
+            (AttributeSafety::Unsafe { .. }, Safety::Unsafe(..)) => {
                 // OK
             }
 
             // - Unsafe builtin attribute
             // - User did not write `#[unsafe(..)]`
-            (Some(AttributeSafety::Unsafe { unsafe_since }), Safety::Default) => {
+            (AttributeSafety::Unsafe { unsafe_since }, Safety::Default) => {
                 let path_span = attr_path.span;
 
                 // If the `attr_item`'s span is not from a macro, then just suggest
@@ -96,7 +91,7 @@ pub fn check_attribute_safety(
 
             // - Normal builtin attribute
             // - Writing `#[unsafe(..)]` is not permitted on normal builtin attributes
-            (None | Some(AttributeSafety::Normal), Safety::Unsafe(unsafe_span)) => {
+            (AttributeSafety::Normal, Safety::Unsafe(unsafe_span)) => {
                 self.stage.emit_err(
                     self.sess,
                     crate::session_diagnostics::InvalidAttrUnsafe {
@@ -108,14 +103,11 @@ pub fn check_attribute_safety(
 
             // - Normal builtin attribute
             // - No explicit `#[unsafe(..)]` written.
-            (None | Some(AttributeSafety::Normal), Safety::Default) => {
+            (AttributeSafety::Normal, Safety::Default) => {
                 // OK
             }
 
-            (
-                Some(AttributeSafety::Unsafe { .. } | AttributeSafety::Normal) | None,
-                Safety::Safe(..),
-            ) => {
+            (_, Safety::Safe(..)) => {
                 self.sess.dcx().span_delayed_bug(
                     attr_span,
                     "`check_attribute_safety` does not expect `Safety::Safe` on attributes",

compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs

@@ -4040,23 +4040,74 @@ pub(crate) fn report_illegal_reassignment(
         if let Some(decl) = local_decl
             && decl.can_be_made_mutable()
         {
-            let is_for_loop = matches!(
-                            decl.local_info(),
-                            LocalInfo::User(BindingForm::Var(VarBindingForm {
-                                opt_match_place: Some((_, match_span)),
-                                ..
-                            })) if matches!(match_span.desugaring_kind(), Some(DesugaringKind::ForLoop))
-            );
-            let message = if is_for_loop
+            let mut is_for_loop = false;
+            let mut is_ref_pattern = false;
+            if let LocalInfo::User(BindingForm::Var(VarBindingForm {
+                opt_match_place: Some((_, match_span)),
+                ..
+            })) = *decl.local_info()
+            {
+                if matches!(match_span.desugaring_kind(), Some(DesugaringKind::ForLoop)) {
+                    is_for_loop = true;
+
+                    if let Some(body) = self.infcx.tcx.hir_maybe_body_owned_by(self.mir_def_id()) {
+                        struct RefPatternFinder<'tcx> {
+                            tcx: TyCtxt<'tcx>,
+                            binding_span: Span,
+                            is_ref_pattern: bool,
+                        }
+
+                        impl<'tcx> Visitor<'tcx> for RefPatternFinder<'tcx> {
+                            type NestedFilter = OnlyBodies;
+
+                            fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
+                                self.tcx
+                            }
+
+                            fn visit_pat(&mut self, pat: &'tcx hir::Pat<'tcx>) {
+                                if !self.is_ref_pattern
+                                    && let hir::PatKind::Binding(_, _, ident, _) = pat.kind
+                                    && ident.span == self.binding_span
+                                {
+                                    self.is_ref_pattern =
+                                        self.tcx.hir_parent_iter(pat.hir_id).any(|(_, node)| {
+                                            matches!(
+                                                node,
+                                                hir::Node::Pat(hir::Pat {
+                                                    kind: hir::PatKind::Ref(..),
+                                                    ..
+                                                })
+                                            )
+                                        });
+                                }
+                                hir::intravisit::walk_pat(self, pat);
+                            }
+                        }
+
+                        let mut finder = RefPatternFinder {
+                            tcx: self.infcx.tcx,
+                            binding_span: decl.source_info.span,
+                            is_ref_pattern: false,
+                        };
+
+                        finder.visit_body(body);
+                        is_ref_pattern = finder.is_ref_pattern;
+                    }
+                }
+            }
+
+            let (span, message) = if is_for_loop
+                && is_ref_pattern
                 && let Ok(binding_name) =
                     self.infcx.tcx.sess.source_map().span_to_snippet(decl.source_info.span)
             {
-                format!("(mut {}) ", binding_name)
+                (decl.source_info.span, format!("(mut {})", binding_name))
             } else {
-                "mut ".to_string()
+                (decl.source_info.span.shrink_to_lo(), "mut ".to_string())
             };
+
             err.span_suggestion_verbose(
-                decl.source_info.span.shrink_to_lo(),
+                span,
                 "consider making this binding mutable",
                 message,
                 Applicability::MachineApplicable,

compiler/rustc_builtin_macros/src/cfg.rs

@@ -6,7 +6,8 @@
 use rustc_ast::{AttrStyle, token};
 use rustc_attr_parsing::parser::{AllowExprMetavar, MetaItemOrLitParser};
 use rustc_attr_parsing::{
-    self as attr, AttributeParser, CFG_TEMPLATE, ParsedDescription, ShouldEmit, parse_cfg_entry,
+    self as attr, AttributeParser, AttributeSafety, CFG_TEMPLATE, ParsedDescription, ShouldEmit,
+    parse_cfg_entry,
 };
 use rustc_expand::base::{DummyResult, ExpandResult, ExtCtxt, MacEager, MacroExpanderResult};
 use rustc_hir::attrs::CfgEntry;
@@ -53,6 +54,7 @@ fn parse_cfg(cx: &ExtCtxt<'_>, span: Span, tts: TokenStream) -> Result<CfgEntry,
         AttrStyle::Inner,
         AttrPath { segments: vec![sym::cfg].into_boxed_slice(), span },
         None,
+        AttributeSafety::Normal,
         ParsedDescription::Macro,
         span,
         cx.current_expansion.lint_node_id,

compiler/rustc_codegen_llvm/src/intrinsic.rs

@@ -285,37 +285,47 @@ fn codegen_intrinsic_call(
             }
             sym::breakpoint => self.call_intrinsic("llvm.debugtrap", &[], &[]),
             sym::va_arg => {
-                match result.layout.backend_repr {
-                    BackendRepr::Scalar(scalar) => {
-                        match scalar.primitive() {
-                            Primitive::Int(..) => {
-                                if self.cx().size_of(result.layout.ty).bytes() < 4 {
-                                    // `va_arg` should not be called on an integer type
-                                    // less than 4 bytes in length. If it is, promote
-                                    // the integer to an `i32` and truncate the result
-                                    // back to the smaller type.
-                                    let promoted_result = emit_va_arg(self, args[0], tcx.types.i32);
-                                    self.trunc(promoted_result, result.layout.llvm_type(self))
-                                } else {
-                                    emit_va_arg(self, args[0], result.layout.ty)
-                                }
-                            }
-                            Primitive::Float(Float::F16) => {
-                                bug!("the va_arg intrinsic does not work with `f16`")
-                            }
-                            Primitive::Float(Float::F64) | Primitive::Pointer(_) => {
-                                emit_va_arg(self, args[0], result.layout.ty)
-                            }
-                            // `va_arg` should never be used with the return type f32.
-                            Primitive::Float(Float::F32) => {
-                                bug!("the va_arg intrinsic does not work with `f32`")
-                            }
-                            Primitive::Float(Float::F128) => {
-                                bug!("the va_arg intrinsic does not work with `f128`")
-                            }
+                let BackendRepr::Scalar(scalar) = result.layout.backend_repr else {
+                    bug!("the va_arg intrinsic does not support non-scalar types")
+                };
+
+                match scalar.primitive() {
+                    Primitive::Pointer(_) => {
+                        // Pointers are always OK.
+                        emit_va_arg(self, args[0], result.layout.ty)
+                    }
+                    Primitive::Int(..) => {
+                        let int_width = self.cx().size_of(result.layout.ty).bits();
+                        let target_c_int_width = self.cx().sess().target.options.c_int_width;
+                        if int_width < u64::from(target_c_int_width) {
+                            // Smaller integer types are automatically promototed and `va_arg`
+                            // should not be called on them.
+                            bug!(
+                                "va_arg got i{} but needs at least c_int (an i{})",
+                                int_width,
+                                target_c_int_width
+                            );
+                        }
+                        emit_va_arg(self, args[0], result.layout.ty)
+                    }
+                    Primitive::Float(Float::F16) => {
+                        bug!("the va_arg intrinsic does not support `f16`")
+                    }
+                    Primitive::Float(Float::F32) => {
+                        if self.cx().sess().target.arch == Arch::Avr {
+                            // c_double is actually f32 on avr.
+                            emit_va_arg(self, args[0], result.layout.ty)
+                        } else {
+                            bug!("the va_arg intrinsic does not support `f32` on this target")
                         }
                     }
-                    _ => bug!("the va_arg intrinsic does not work with non-scalar types"),
+                    Primitive::Float(Float::F64) => {
+                        // 64-bit floats are always OK.
+                        emit_va_arg(self, args[0], result.layout.ty)
+                    }
+                    Primitive::Float(Float::F128) => {
+                        bug!("the va_arg intrinsic does not support `f128`")
+                    }
                 }
             }
 

compiler/rustc_data_structures/src/aligned.rs

@@ -1,8 +1,5 @@
 use std::marker::PointeeSized;
-#[cfg(not(bootstrap))]
 use std::mem::Alignment;
-#[cfg(bootstrap)]
-use std::ptr::Alignment;
 
 /// Returns the ABI-required minimum alignment of a type in bytes.
 ///

compiler/rustc_data_structures/src/tagged_ptr.rs

@@ -56,9 +56,6 @@ pub unsafe trait Tag: Copy {
 /// (this is based on `T`'s alignment).
 pub const fn bits_for<T: ?Sized + Aligned>() -> u32 {
     let alignment = crate::aligned::align_of::<T>();
-    #[cfg(bootstrap)]
-    let alignment = alignment.as_nonzero();
-    #[cfg(not(bootstrap))]
     let alignment = alignment.as_nonzero_usize();
     alignment.trailing_zeros()
 }

compiler/rustc_expand/src/config.rs

@@ -12,8 +12,8 @@
 };
 use rustc_attr_parsing::parser::AllowExprMetavar;
 use rustc_attr_parsing::{
-    self as attr, AttributeParser, CFG_TEMPLATE, EvalConfigResult, ShouldEmit, eval_config_entry,
-    parse_cfg,
+    self as attr, AttributeParser, AttributeSafety, CFG_TEMPLATE, EvalConfigResult, ShouldEmit,
+    eval_config_entry, parse_cfg,
 };
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_errors::msg;
@@ -398,6 +398,7 @@ pub(crate) fn cfg_true(&self, attr: &Attribute, emit_errors: ShouldEmit) -> Eval
             parse_cfg,
             &CFG_TEMPLATE,
             AllowExprMetavar::Yes,
+            AttributeSafety::Normal,
         ) else {
             // Cfg attribute was not parsable, give up
             return EvalConfigResult::True;

compiler/rustc_expand/src/expand.rs

@@ -15,8 +15,8 @@
 use rustc_ast_pretty::pprust;
 use rustc_attr_parsing::parser::AllowExprMetavar;
 use rustc_attr_parsing::{
-    AttributeParser, CFG_TEMPLATE, Early, EvalConfigResult, ShouldEmit, eval_config_entry,
-    parse_cfg, validate_attr,
+    AttributeParser, AttributeSafety, CFG_TEMPLATE, Early, EvalConfigResult, ShouldEmit,
+    eval_config_entry, parse_cfg, validate_attr,
 };
 use rustc_data_structures::flat_map_in_place::FlatMapInPlace;
 use rustc_data_structures::stack::ensure_sufficient_stack;
@@ -2331,6 +2331,7 @@ fn expand_cfg_true(
             parse_cfg,
             &CFG_TEMPLATE,
             AllowExprMetavar::Yes,
+            AttributeSafety::Normal,
         ) else {
             // Cfg attribute was not parsable, give up
             return EvalConfigResult::True;

compiler/rustc_feature/src/builtin_attrs.rs

@@ -5,7 +5,6 @@
 use AttributeGate::*;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::AttrStyle;
-use rustc_span::edition::Edition;
 use rustc_span::{Symbol, sym};
 
 use crate::Features;
@@ -67,23 +66,6 @@ pub fn find_gated_cfg(pred: impl Fn(Symbol) -> bool) -> Option<&'static GatedCfg
     GATED_CFGS.iter().find(|(cfg_sym, ..)| pred(*cfg_sym))
 }
 
-// If you change this, please modify `src/doc/unstable-book` as well. You must
-// move that documentation into the relevant place in the other docs, and
-// remove the chapter on the flag.
-
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub enum AttributeSafety {
-    /// Normal attribute that does not need `#[unsafe(...)]`
-    Normal,
-
-    /// Unsafe attribute that requires safety obligations to be discharged.
-    ///
-    /// An error is emitted when `#[unsafe(...)]` is omitted, except when the attribute's edition
-    /// is less than the one stored in `unsafe_since`. This handles attributes that were safe in
-    /// earlier editions, but become unsafe in later ones.
-    Unsafe { unsafe_since: Option<Edition> },
-}
-
 #[derive(Clone, Debug, Copy)]
 pub enum AttributeGate {
     /// A gated attribute which requires a feature gate to be enabled.
@@ -205,54 +187,15 @@ macro_rules! template {
 }
 
 macro_rules! ungated {
-    (unsafe($edition:ident) $attr:ident $(,)?) => {
-        BuiltinAttribute {
-            name: sym::$attr,
-            safety: AttributeSafety::Unsafe { unsafe_since: Some(Edition::$edition) },
-            gate: Ungated,
-        }
-    };
-    (unsafe $attr:ident $(,)?) => {
-        BuiltinAttribute {
-            name: sym::$attr,
-            safety: AttributeSafety::Unsafe { unsafe_since: None },
-            gate: Ungated,
-        }
-    };
     ($attr:ident $(,)?) => {
-        BuiltinAttribute { name: sym::$attr, safety: AttributeSafety::Normal, gate: Ungated }
+        BuiltinAttribute { name: sym::$attr, gate: Ungated }
     };
 }
 
 macro_rules! gated {
-    (unsafe $attr:ident, $gate:ident, $message:expr $(,)?) => {
-        BuiltinAttribute {
-            name: sym::$attr,
-            safety: AttributeSafety::Unsafe { unsafe_since: None },
-            gate: Gated {
-                feature: sym::$gate,
-                message: $message,
-                check: Features::$gate,
-                notes: &[],
-            },
-        }
-    };
-    (unsafe $attr:ident, $message:expr $(,)?) => {
-        BuiltinAttribute {
-            name: sym::$attr,
-            safety: AttributeSafety::Unsafe { unsafe_since: None },
-            gate: Gated {
-                feature: sym::$attr,
-                message: $message,
-                check: Features::$attr,
-                notes: &[],
-            },
-        }
-    };
     ($attr:ident, $gate:ident, $message:expr $(,)?) => {
         BuiltinAttribute {
             name: sym::$attr,
-            safety: AttributeSafety::Normal,
             gate: Gated {
                 feature: sym::$gate,
                 message: $message,
@@ -264,7 +207,6 @@ macro_rules! gated {
     ($attr:ident, $message:expr $(,)?) => {
         BuiltinAttribute {
             name: sym::$attr,
-            safety: AttributeSafety::Normal,
             gate: Gated {
                 feature: sym::$attr,
                 message: $message,
@@ -289,7 +231,6 @@ macro_rules! rustc_attr {
     ($attr:ident $(, $notes:expr)* $(,)?) => {
         BuiltinAttribute {
             name: sym::$attr,
-            safety: AttributeSafety::Normal,
             gate: Gated {
                 feature: sym::rustc_attrs,
                 message: "use of an internal attribute",
@@ -299,7 +240,7 @@ macro_rules! rustc_attr {
                     stringify!($attr),
                     "]` attribute is an internal implementation detail that will never be stable"),
                     $($notes),*
-                    ]
+                ]
             },
         }
     };
@@ -313,7 +254,6 @@ macro_rules! experimental {
 
 pub struct BuiltinAttribute {
     pub name: Symbol,
-    pub safety: AttributeSafety,
     pub gate: AttributeGate,
 }
 
@@ -348,10 +288,7 @@ pub struct BuiltinAttribute {
     ungated!(forbid),
     ungated!(deny),
     ungated!(must_use),
-    gated!(
-        must_not_suspend,
-        experimental!(must_not_suspend)
-    ),
+    gated!(must_not_suspend, experimental!(must_not_suspend)),
     ungated!(deprecated),
 
     // Crate properties:
@@ -366,222 +303,103 @@ pub struct BuiltinAttribute {
     // FIXME(#82232, #143834): temporarily renamed to mitigate `#[align]` nameres ambiguity
     gated!(rustc_align, fn_align, experimental!(rustc_align)),
     gated!(rustc_align_static, static_align, experimental!(rustc_align_static)),
-    ungated!(
-        unsafe(Edition2024) export_name,
-    ),
-    ungated!(
-        unsafe(Edition2024) link_section,
-    ),
-    ungated!(
-        unsafe(Edition2024) no_mangle,
-    ),
-    ungated!(
-        used,
-    ),
-    ungated!(
-        link_ordinal,
-    ),
-    ungated!(
-        unsafe naked,
-    ),
+    ungated!(export_name),
+    ungated!(link_section),
+    ungated!(no_mangle),
+    ungated!(used),
+    ungated!(link_ordinal),
+    ungated!(naked),
     // See `TyAndLayout::pass_indirectly_in_non_rustic_abis` for details.
-    rustc_attr!(
-        rustc_pass_indirectly_in_non_rustic_abis,
-        "types marked with `#[rustc_pass_indirectly_in_non_rustic_abis]` are always passed indirectly by non-Rustic ABIs"
-    ),
+    rustc_attr!(rustc_pass_indirectly_in_non_rustic_abis, "types marked with `#[rustc_pass_indirectly_in_non_rustic_abis]` are always passed indirectly by non-Rustic ABIs"),
 
     // Limits:
-    ungated!(
-        recursion_limit,
-    ),
-    ungated!(
-        type_length_limit,
-    ),
-    gated!(
-        move_size_limit,
-        large_assignments, experimental!(move_size_limit)
-    ),
+    ungated!(recursion_limit),
+    ungated!(type_length_limit),
+    gated!(move_size_limit, large_assignments, experimental!(move_size_limit)),
 
     // Entry point:
-    ungated!(
-        no_main,
-    ),
+    ungated!(no_main),
 
     // Modules, prelude, and resolution:
-    ungated!(
-        path,
-    ),
-    ungated!(
-        no_std,
-    ),
-    ungated!(
-        no_implicit_prelude,
-    ),
-    ungated!(
-        non_exhaustive,
-    ),
+    ungated!(path),
+    ungated!(no_std),
+    ungated!(no_implicit_prelude),
+    ungated!(non_exhaustive),
 
     // Runtime
-    ungated!(
-        windows_subsystem,
-    ),
-    ungated!( // RFC 2070
-        panic_handler,
-    ),
+    ungated!(windows_subsystem),
+    ungated!(panic_handler), // RFC 2070
 
     // Code generation:
-    ungated!(
-        inline,
-    ),
-    ungated!(
-        cold,
-    ),
-    ungated!(
-        no_builtins,
-    ),
-    ungated!(
-        target_feature,
-    ),
-    ungated!(
-        track_caller,
-    ),
-    ungated!(
-        instruction_set,
-    ),
-    gated!(
-        unsafe force_target_feature,
-        effective_target_features, experimental!(force_target_feature)
-    ),
-    gated!(
-        sanitize,
-        sanitize, experimental!(sanitize),
-    ),
-    gated!(
-        coverage,
-        coverage_attribute, experimental!(coverage)
-    ),
+    ungated!(inline),
+    ungated!(cold),
+    ungated!(no_builtins),
+    ungated!(target_feature),
+    ungated!(track_caller),
+    ungated!(instruction_set),
+    gated!(force_target_feature, effective_target_features, experimental!(force_target_feature)),
+    gated!(sanitize, sanitize, experimental!(sanitize)),
+    gated!(coverage, coverage_attribute, experimental!(coverage)),
 
-    ungated!(
-        doc,
-    ),
+    ungated!(doc),
 
     // Debugging
-    ungated!(
-        debugger_visualizer,
-    ),
-    ungated!(
-        collapse_debuginfo,
-    ),
+    ungated!(debugger_visualizer),
+    ungated!(collapse_debuginfo),
 
     // ==========================================================================
     // Unstable attributes:
     // ==========================================================================
 
     // Linking:
-    gated!(
-        export_stable,
-        experimental!(export_stable)
-    ),
+    gated!(export_stable, experimental!(export_stable)),
 
     // Testing:
-    gated!(
-        test_runner,
-        custom_test_frameworks,
-        "custom test frameworks are an unstable feature",
-    ),
+    gated!(test_runner, custom_test_frameworks, "custom test frameworks are an unstable feature"),
 
-    gated!(
-        reexport_test_harness_main,
-        custom_test_frameworks,
-        "custom test frameworks are an unstable feature",
-    ),
+    gated!(reexport_test_harness_main, custom_test_frameworks, "custom test frameworks are an unstable feature"),
 
     // RFC #1268
-    gated!(
-        marker,
-        marker_trait_attr, experimental!(marker)
-    ),
-    gated!(
-        thread_local,
-        "`#[thread_local]` is an experimental feature, and does not currently handle destructors",
-    ),
-    gated!(
-        no_core,
-        experimental!(no_core)
-    ),
+    gated!(marker, marker_trait_attr, experimental!(marker)),
+    gated!(thread_local, "`#[thread_local]` is an experimental feature, and does not currently handle destructors"),
+    gated!(no_core, experimental!(no_core)),
     // RFC 2412
-    gated!(
-        optimize,
-        optimize_attribute, experimental!(optimize)
-    ),
+    gated!(optimize, optimize_attribute, experimental!(optimize)),
 
-    gated!(
-        unsafe ffi_pure,
-        experimental!(ffi_pure)
-    ),
-    gated!(
-        unsafe ffi_const,
-        experimental!(ffi_const)
-    ),
-    gated!(
-        register_tool,
-        experimental!(register_tool),
-    ),
+    gated!(ffi_pure, experimental!(ffi_pure)),
+    gated!(ffi_const, experimental!(ffi_const)),
+    gated!(register_tool, experimental!(register_tool)),
     // `#[cfi_encoding = ""]`
-    gated!(
-        cfi_encoding,
-        experimental!(cfi_encoding)
-    ),
+    gated!(cfi_encoding, experimental!(cfi_encoding)),
 
     // `#[coroutine]` attribute to be applied to closures to make them coroutines instead
-    gated!(
-        coroutine,
-        coroutines, experimental!(coroutine)
-    ),
+    gated!(coroutine, coroutines, experimental!(coroutine)),
 
     // RFC 3543
     // `#[patchable_function_entry(prefix_nops = m, entry_nops = n)]`
-    gated!(
-        patchable_function_entry,
-        experimental!(patchable_function_entry)
-    ),
+    gated!(patchable_function_entry, experimental!(patchable_function_entry)),
 
     // The `#[loop_match]` and `#[const_continue]` attributes are part of the
     // lang experiment for RFC 3720 tracked in:
     //
     // - https://github.com/rust-lang/rust/issues/132306
-    gated!(
-        const_continue,
-        loop_match, experimental!(const_continue)
-    ),
-    gated!(
-        loop_match,
-        loop_match, experimental!(loop_match)
-    ),
+    gated!(const_continue, loop_match, experimental!(const_continue)),
+    gated!(loop_match, loop_match, experimental!(loop_match)),
 
     // The `#[pin_v2]` attribute is part of the `pin_ergonomics` experiment
     // that allows structurally pinning, tracked in:
     //
     // - https://github.com/rust-lang/rust/issues/130494
-    gated!(
-        pin_v2,
-        pin_ergonomics, experimental!(pin_v2),
-    ),
+    gated!(pin_v2, pin_ergonomics, experimental!(pin_v2)),
 
     // ==========================================================================
     // Internal attributes: Stability, deprecation, and unsafe:
     // ==========================================================================
 
-    ungated!(
-        feature,
-    ),
+    ungated!(feature),
     // DuplicatesOk since it has its own validation
-    ungated!(
-        stable,
-    ),
-    ungated!(
-        unstable,
-    ),
+    ungated!(stable),
+    ungated!(unstable),
     ungated!(unstable_feature_bound),
     ungated!(unstable_removed),
     ungated!(rustc_const_unstable),
@@ -636,24 +454,12 @@ pub struct BuiltinAttribute {
     // Internal attributes: Runtime related:
     // ==========================================================================
 
-    rustc_attr!(
-        rustc_allocator,
-    ),
-    rustc_attr!(
-        rustc_nounwind,
-    ),
-    rustc_attr!(
-        rustc_reallocator,
-    ),
-    rustc_attr!(
-        rustc_deallocator,
-    ),
-    rustc_attr!(
-        rustc_allocator_zeroed,
-    ),
-    rustc_attr!(
-        rustc_allocator_zeroed_variant,
-    ),
+    rustc_attr!(rustc_allocator),
+    rustc_attr!(rustc_nounwind),
+    rustc_attr!(rustc_reallocator),
+    rustc_attr!(rustc_deallocator),
+    rustc_attr!(rustc_allocator_zeroed),
+    rustc_attr!(rustc_allocator_zeroed_variant),
     gated!(
         default_lib_allocator,
         allocator_internals, experimental!(default_lib_allocator),
@@ -720,49 +526,31 @@ pub struct BuiltinAttribute {
         rustc_on_unimplemented,
         "see `#[diagnostic::on_unimplemented]` for the stable equivalent of this attribute"
     ),
-    rustc_attr!(
-        rustc_confusables,
-    ),
+    rustc_attr!(rustc_confusables),
     // Enumerates "identity-like" conversion methods to suggest on type mismatch.
-    rustc_attr!(
-        rustc_conversion_suggestion,
-    ),
+    rustc_attr!(rustc_conversion_suggestion),
     // Prevents field reads in the marked trait or method to be considered
     // during dead code analysis.
-    rustc_attr!(
-        rustc_trivial_field_reads,
-    ),
+    rustc_attr!(rustc_trivial_field_reads),
     // Used by the `rustc::potential_query_instability` lint to warn methods which
     // might not be stable during incremental compilation.
-    rustc_attr!(
-        rustc_lint_query_instability,
-    ),
+    rustc_attr!(rustc_lint_query_instability),
     // Used by the `rustc::untracked_query_information` lint to warn methods which
     // might not be stable during incremental compilation.
-    rustc_attr!(
-        rustc_lint_untracked_query_information,
-    ),
+    rustc_attr!(rustc_lint_untracked_query_information),
     // Used by the `rustc::bad_opt_access` lint to identify `DebuggingOptions` and `CodegenOptions`
     // types (as well as any others in future).
-    rustc_attr!(
-        rustc_lint_opt_ty,
-    ),
+    rustc_attr!(rustc_lint_opt_ty),
     // Used by the `rustc::bad_opt_access` lint on fields
     // types (as well as any others in future).
-    rustc_attr!(
-        rustc_lint_opt_deny_field_access,
-    ),
+    rustc_attr!(rustc_lint_opt_deny_field_access),
 
     // ==========================================================================
     // Internal attributes, Const related:
     // ==========================================================================
 
-    rustc_attr!(
-        rustc_promotable,
-    ),
-    rustc_attr!(
-        rustc_legacy_const_generics,
-    ),
+    rustc_attr!(rustc_promotable),
+    rustc_attr!(rustc_legacy_const_generics),
     // Do not const-check this function's body. It will always get replaced during CTFE via `hook_special_const_fn`.
     rustc_attr!(
         rustc_do_not_const_check,
@@ -873,7 +661,6 @@ pub struct BuiltinAttribute {
 
     BuiltinAttribute {
         name: sym::rustc_diagnostic_item,
-        safety: AttributeSafety::Normal,
         gate: Gated {
             feature: sym::rustc_attrs,
             message: "use of an internal attribute",
@@ -965,99 +752,39 @@ pub struct BuiltinAttribute {
     // ==========================================================================
 
     rustc_attr!(TEST, rustc_effective_visibility),
-    rustc_attr!(
-        TEST, rustc_dump_inferred_outlives,
-    ),
-    rustc_attr!(
-        TEST, rustc_capture_analysis,
-    ),
-    rustc_attr!(
-        TEST, rustc_insignificant_dtor,
-    ),
-    rustc_attr!(
-        TEST, rustc_no_implicit_bounds,
-    ),
-    rustc_attr!(
-        TEST, rustc_strict_coherence,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_variances,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_variances_of_opaques,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_hidden_type_of_opaques,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_layout,
-    ),
-    rustc_attr!(
-        TEST, rustc_abi,
-    ),
-    rustc_attr!(
-        TEST, rustc_regions,
-    ),
-    rustc_attr!(
-        TEST, rustc_delayed_bug_from_inside_query,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_user_args,
-    ),
-    rustc_attr!(
-        TEST, rustc_evaluate_where_clauses,
-    ),
-    rustc_attr!(
-        TEST, rustc_if_this_changed,
-    ),
-    rustc_attr!(
-        TEST, rustc_then_this_would_need,
-    ),
-    rustc_attr!(
-        TEST, rustc_clean,
-    ),
-    rustc_attr!(
-        TEST, rustc_partition_reused,
-    ),
-    rustc_attr!(
-        TEST, rustc_partition_codegened,
-    ),
-    rustc_attr!(
-        TEST, rustc_expected_cgu_reuse,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_symbol_name,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_def_path,
-    ),
-    rustc_attr!(
-        TEST, rustc_mir,
-    ),
+    rustc_attr!(TEST, rustc_dump_inferred_outlives),
+    rustc_attr!(TEST, rustc_capture_analysis,),
+    rustc_attr!(TEST, rustc_insignificant_dtor),
+    rustc_attr!(TEST, rustc_no_implicit_bounds),
+    rustc_attr!(TEST, rustc_strict_coherence),
+    rustc_attr!(TEST, rustc_dump_variances),
+    rustc_attr!(TEST, rustc_dump_variances_of_opaques),
+    rustc_attr!(TEST, rustc_dump_hidden_type_of_opaques),
+    rustc_attr!(TEST, rustc_dump_layout),
+    rustc_attr!(TEST, rustc_abi),
+    rustc_attr!(TEST, rustc_regions),
+    rustc_attr!(TEST, rustc_delayed_bug_from_inside_query),
+    rustc_attr!(TEST, rustc_dump_user_args),
+    rustc_attr!(TEST, rustc_evaluate_where_clauses),
+    rustc_attr!(TEST, rustc_if_this_changed),
+    rustc_attr!(TEST, rustc_then_this_would_need),
+    rustc_attr!(TEST, rustc_clean),
+    rustc_attr!(TEST, rustc_partition_reused),
+    rustc_attr!(TEST, rustc_partition_codegened),
+    rustc_attr!(TEST, rustc_expected_cgu_reuse),
+    rustc_attr!(TEST, rustc_dump_symbol_name),
+    rustc_attr!(TEST, rustc_dump_def_path),
+    rustc_attr!(TEST, rustc_mir),
     gated!(
         custom_mir, "the `#[custom_mir]` attribute is just used for the Rust test suite",
     ),
-    rustc_attr!(
-        TEST, rustc_dump_item_bounds,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_predicates,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_def_parents,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_object_lifetime_defaults,
-    ),
-    rustc_attr!(
-        TEST, rustc_dump_vtable,
-    ),
-    rustc_attr!(
-        TEST, rustc_dummy,
-    ),
-    rustc_attr!(
-        TEST, pattern_complexity_limit,
-    ),
+    rustc_attr!(TEST, rustc_dump_item_bounds),
+    rustc_attr!(TEST, rustc_dump_predicates),
+    rustc_attr!(TEST, rustc_dump_def_parents),
+    rustc_attr!(TEST, rustc_dump_object_lifetime_defaults),
+    rustc_attr!(TEST, rustc_dump_vtable),
+    rustc_attr!(TEST, rustc_dummy),
+    rustc_attr!(TEST, pattern_complexity_limit),
 ];
 
 pub fn is_builtin_attr_name(name: Symbol) -> bool {

compiler/rustc_feature/src/lib.rs

@@ -129,7 +129,7 @@ pub fn find_feature_issue(feature: Symbol, issue: GateIssue) -> Option<NonZero<u
 
 pub use accepted::ACCEPTED_LANG_FEATURES;
 pub use builtin_attrs::{
-    AttrSuggestionStyle, AttributeGate, AttributeSafety, AttributeTemplate, BUILTIN_ATTRIBUTE_MAP,
+    AttrSuggestionStyle, AttributeGate, AttributeTemplate, BUILTIN_ATTRIBUTE_MAP,
     BUILTIN_ATTRIBUTES, BuiltinAttribute, GatedCfg, find_gated_cfg, is_builtin_attr_name,
 };
 pub use removed::REMOVED_LANG_FEATURES;

compiler/rustc_feature/src/unstable.rs

@@ -234,7 +234,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Implementation details of externally implementable items
     (internal, eii_internals, "1.94.0", None),
     /// Implementation details of field representing types.
-    (internal, field_representing_type_raw, "CURRENT_RUSTC_VERSION", None),
+    (internal, field_representing_type_raw, "1.96.0", None),
     /// Outputs useful `assert!` messages
     (unstable, generic_assert, "1.63.0", None),
     /// Allows using the #[rustc_intrinsic] attribute.
@@ -258,7 +258,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Allows using the `#[stable]` and `#[unstable]` attributes.
     (internal, staged_api, "1.0.0", None),
     /// Perma-unstable, only used to test the `incomplete_features` lint.
-    (incomplete, test_incomplete_feature, "CURRENT_RUSTC_VERSION", None),
+    (incomplete, test_incomplete_feature, "1.96.0", None),
     /// Added for testing unstable lints; perma-unstable.
     (internal, test_unstable_lint, "1.60.0", None),
     /// Use for stable + negative coherence and strict coherence depending on trait's
@@ -475,9 +475,9 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Allows giving non-const impls custom diagnostic messages if attempted to be used as const
     (unstable, diagnostic_on_const, "1.93.0", Some(143874)),
     /// Allows giving on-move borrowck custom diagnostic messages for a type
-    (unstable, diagnostic_on_move, "CURRENT_RUSTC_VERSION", Some(154181)),
+    (unstable, diagnostic_on_move, "1.96.0", Some(154181)),
     /// Allows giving unresolved imports a custom diagnostic message
-    (unstable, diagnostic_on_unknown, "CURRENT_RUSTC_VERSION", Some(152900)),
+    (unstable, diagnostic_on_unknown, "1.96.0", Some(152900)),
     /// Allows `#[doc(cfg(...))]`.
     (unstable, doc_cfg, "1.21.0", Some(43781)),
     /// Allows `#[doc(masked)]`.
@@ -509,7 +509,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Allows the use of `#[ffi_pure]` on foreign functions.
     (unstable, ffi_pure, "1.45.0", Some(58329)),
     /// Experimental field projections.
-    (incomplete, field_projections, "CURRENT_RUSTC_VERSION", Some(145383)),
+    (incomplete, field_projections, "1.96.0", Some(145383)),
     /// Allows marking trait functions as `final` to prevent overriding impls
     (unstable, final_associated_functions, "1.95.0", Some(131179)),
     /// fma4 target feature on x86.
@@ -545,7 +545,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Target features on hexagon.
     (unstable, hexagon_target_feature, "1.27.0", Some(150250)),
     /// Allows `impl(crate) trait Foo` restrictions.
-    (incomplete, impl_restriction, "CURRENT_RUSTC_VERSION", Some(105077)),
+    (incomplete, impl_restriction, "1.96.0", Some(105077)),
     /// Allows `impl Trait` to be used inside associated types (RFC 2515).
     (unstable, impl_trait_in_assoc_type, "1.70.0", Some(63063)),
     /// Allows `impl Trait` in bindings (`let`).
@@ -578,7 +578,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     /// Allow `macro_rules!` derive rules
     (unstable, macro_derive, "1.91.0", Some(143549)),
     /// Allow `$x:guard` matcher in macros
-    (unstable, macro_guard_matcher, "CURRENT_RUSTC_VERSION", Some(153104)),
+    (unstable, macro_guard_matcher, "1.96.0", Some(153104)),
     /// Give access to additional metadata about declarative macro meta-variables.
     (unstable, macro_metavar_expr, "1.61.0", Some(83527)),
     /// Provides a way to concatenate identifiers using metavariable expressions.
@@ -589,7 +589,7 @@ pub fn internal(&self, feature: Symbol) -> bool {
     (incomplete, mgca_type_const_syntax, "1.95.0", Some(132980)),
     /// Allows additional const parameter types, such as [u8; 10] or user defined types.
     /// User defined types must not have fields more private than the type itself.
-    (unstable, min_adt_const_params, "CURRENT_RUSTC_VERSION", Some(154042)),
+    (unstable, min_adt_const_params, "1.96.0", Some(154042)),
     /// Enables the generic const args MVP (only bare paths, not arbitrary computation).
     (incomplete, min_generic_const_args, "1.84.0", Some(132980)),
     /// A minimal, sound subset of specialization intended to be used by the

compiler/rustc_hir/src/lang_items.rs

@@ -221,6 +221,7 @@ fn hash_stable(&self, _: &mut Hcx, hasher: &mut StableHasher) {
     UnsafeCell,              sym::unsafe_cell,         unsafe_cell_type,           Target::Struct,         GenericRequirement::None;
     UnsafePinned,            sym::unsafe_pinned,       unsafe_pinned_type,         Target::Struct,         GenericRequirement::None;
 
+    VaArgSafe,               sym::va_arg_safe,         va_arg_safe,                Target::Trait,          GenericRequirement::None;
     VaList,                  sym::va_list,             va_list,                    Target::Struct,         GenericRequirement::None;
 
     Deref,                   sym::deref,               deref_trait,                Target::Trait,          GenericRequirement::Exact(0);

compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs

@@ -494,7 +494,21 @@ fn variadic_error<'tcx>(
 
                 // There are a few types which get autopromoted when passed via varargs
                 // in C but we just error out instead and require explicit casts.
+                //
+                // We use implementations of VaArgSafe as the source of truth. On some embedded
+                // targets, c_double is f32 and c_int/c_uing are i16/u16, and these types implement
+                // VaArgSafe there. On all other targets, these types do not implement VaArgSafe.
+                //
+                // cfg(bootstrap): change the if let to an unwrap.
                 let arg_ty = self.structurally_resolve_type(arg.span, arg_ty);
+                if let Some(trait_def_id) = tcx.lang_items().va_arg_safe()
+                    && self
+                        .type_implements_trait(trait_def_id, [arg_ty], self.param_env)
+                        .must_apply_modulo_regions()
+                {
+                    continue;
+                }
+
                 match arg_ty.kind() {
                     ty::Float(ty::FloatTy::F32) => {
                         variadic_error(tcx.sess, arg.span, arg_ty, "c_double");

compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs

@@ -3107,14 +3107,11 @@ pub(crate) fn suggest_deref_or_ref(
                     {
                         let deref_kind = if checked_ty.is_box() {
                             // detect Box::new(..)
-                            // FIXME: use `box_new` diagnostic item instead?
                             if let ExprKind::Call(box_new, [_]) = expr.kind
                                 && let ExprKind::Path(qpath) = &box_new.kind
                                 && let Res::Def(DefKind::AssocFn, fn_id) =
                                     self.typeck_results.borrow().qpath_res(qpath, box_new.hir_id)
-                                && let Some(impl_id) = self.tcx.inherent_impl_of_assoc(fn_id)
-                                && self.tcx.type_of(impl_id).skip_binder().is_box()
-                                && self.tcx.item_name(fn_id) == sym::new
+                                && self.tcx.is_diagnostic_item(sym::box_new, fn_id)
                             {
                                 let l_paren = self.tcx.sess.source_map().next_point(box_new.span);
                                 let r_paren = self.tcx.sess.source_map().end_point(expr.span);

compiler/rustc_index/src/lib.rs

@@ -4,11 +4,6 @@
 #![cfg_attr(feature = "nightly", feature(extend_one, step_trait))]
 // tidy-alphabetical-end
 
-// FIXME(#125687): new_range_api recently stabilized
-// Remove this when it hits stable. cfg(bootstrap)
-#![allow(stable_features)]
-#![cfg_attr(feature = "nightly", feature(new_range_api))]
-
 pub mod bit_set;
 #[cfg(feature = "nightly")]
 pub mod interval;

compiler/rustc_lint/src/types/improper_ctypes.rs

@@ -138,6 +138,17 @@
     USES_POWER_ALIGNMENT
 ]);
 
+/// Getting the (normalized) type out of a field (for, e.g., an enum variant or a tuple).
+#[inline]
+fn get_type_from_field<'tcx>(
+    cx: &LateContext<'tcx>,
+    field: &ty::FieldDef,
+    args: GenericArgsRef<'tcx>,
+) -> Ty<'tcx> {
+    let field_ty = field.ty(cx.tcx, args);
+    cx.tcx.try_normalize_erasing_regions(cx.typing_env(), field_ty).unwrap_or(field_ty)
+}
+
 /// Check a variant of a non-exhaustive enum for improper ctypes
 ///
 /// We treat `#[non_exhaustive] enum` as "ensure that code will compile if new variants are added".
@@ -365,22 +376,6 @@ fn new(cx: &'a LateContext<'tcx>, base_ty: Ty<'tcx>, base_fn_mode: CItemKind) ->
         Self { cx, base_ty, base_fn_mode, cache: FxHashSet::default() }
     }
 
-    /// Checks if the given field's type is "ffi-safe".
-    fn check_field_type_for_ffi(
-        &mut self,
-        state: VisitorState,
-        field: &ty::FieldDef,
-        args: GenericArgsRef<'tcx>,
-    ) -> FfiResult<'tcx> {
-        let field_ty = field.ty(self.cx.tcx, args);
-        let field_ty = self
-            .cx
-            .tcx
-            .try_normalize_erasing_regions(self.cx.typing_env(), field_ty)
-            .unwrap_or(field_ty);
-        self.visit_type(state, field_ty)
-    }
-
     /// Checks if the given `VariantDef`'s field types are "ffi-safe".
     fn check_variant_for_ffi(
         &mut self,
@@ -394,7 +389,8 @@ fn check_variant_for_ffi(
         let transparent_with_all_zst_fields = if def.repr().transparent() {
             if let Some(field) = super::transparent_newtype_field(self.cx.tcx, variant) {
                 // Transparent newtypes have at most one non-ZST field which needs to be checked..
-                match self.check_field_type_for_ffi(state, field, args) {
+                let field_ty = get_type_from_field(self.cx, field, args);
+                match self.visit_type(state, field_ty) {
                     FfiUnsafe { ty, .. } if ty.is_unit() => (),
                     r => return r,
                 }
@@ -412,7 +408,8 @@ fn check_variant_for_ffi(
         // We can't completely trust `repr(C)` markings, so make sure the fields are actually safe.
         let mut all_phantom = !variant.fields.is_empty();
         for field in &variant.fields {
-            all_phantom &= match self.check_field_type_for_ffi(state, field, args) {
+            let field_ty = get_type_from_field(self.cx, field, args);
+            all_phantom &= match self.visit_type(state, field_ty) {
                 FfiSafe => false,
                 // `()` fields are FFI-safe!
                 FfiUnsafe { ty, .. } if ty.is_unit() => false,
@@ -723,22 +720,11 @@ fn visit_ty(&mut self, ty: Ty<'tcx>) -> Self::Result {
             }
         }
 
-        if let Some(ty) = self
-            .cx
-            .tcx
-            .try_normalize_erasing_regions(self.cx.typing_env(), ty)
-            .unwrap_or(ty)
-            .visit_with(&mut ProhibitOpaqueTypes)
-            .break_value()
-        {
-            Some(FfiResult::FfiUnsafe {
-                ty,
-                reason: msg!("opaque types have no C equivalent"),
-                help: None,
-            })
-        } else {
-            None
-        }
+        ty.visit_with(&mut ProhibitOpaqueTypes).break_value().map(|ty| FfiResult::FfiUnsafe {
+            ty,
+            reason: msg!("opaque types have no C equivalent"),
+            help: None,
+        })
     }
 
     /// Check if the type is array and emit an unsafe type lint.
@@ -756,12 +742,11 @@ fn check_for_array_ty(&mut self, ty: Ty<'tcx>) -> PartialFfiResult<'tcx> {
 
     /// Determine the FFI-safety of a single (MIR) type, given the context of how it is used.
     fn check_type(&mut self, state: VisitorState, ty: Ty<'tcx>) -> FfiResult<'tcx> {
+        let ty = self.cx.tcx.try_normalize_erasing_regions(self.cx.typing_env(), ty).unwrap_or(ty);
         if let Some(res) = self.visit_for_opaque_ty(ty) {
             return res;
         }
 
-        let ty = self.cx.tcx.try_normalize_erasing_regions(self.cx.typing_env(), ty).unwrap_or(ty);
-
         // C doesn't really support passing arrays by value - the only way to pass an array by value
         // is through a struct. So, first test that the top level isn't an array, and then
         // recursively check the types inside.

compiler/rustc_lint_defs/src/builtin.rs

@@ -2720,13 +2720,12 @@
     ///
     /// ### Example
     ///
-    #[cfg_attr(bootstrap, doc = "```rust")]
-    #[cfg_attr(not(bootstrap), doc = "```rust,compile_fail")]
+    /// ```rust,compile_fail
     /// enum Void {}
     /// unsafe extern {
     ///     static EXTERN: Void;
     /// }
-    #[doc = "```"]
+    /// ```
     ///
     /// {{produces}}
     ///

compiler/rustc_middle/src/query/job.rs

@@ -36,10 +36,7 @@ pub fn new(id: QueryJobId, span: Span, parent: Option<QueryJobId>) -> Self {
     }
 
     pub fn latch(&mut self) -> QueryLatch<'tcx> {
-        if self.latch.is_none() {
-            self.latch = Some(QueryLatch::new());
-        }
-        self.latch.as_ref().unwrap().clone()
+        self.latch.get_or_insert_with(QueryLatch::new).clone()
     }
 
     /// Signals to waiters that the query is complete.

compiler/rustc_middle/src/ty/list.rs

@@ -275,9 +275,6 @@ unsafe impl<H: DynSync, T: DynSync> DynSync for RawList<H, T> {}
 // `_extern_ty` field (which is never instantiated in practice). Therefore,
 // aligns of `ListSkeleton<H, T>` and `RawList<H, T>` must be the same.
 unsafe impl<H, T> Aligned for RawList<H, T> {
-    #[cfg(bootstrap)]
-    const ALIGN: ptr::Alignment = align_of::<ListSkeleton<H, T>>();
-    #[cfg(not(bootstrap))]
     const ALIGN: mem::Alignment = align_of::<ListSkeleton<H, T>>();
 }
 

compiler/rustc_resolve/src/late/diagnostics.rs

@@ -26,7 +26,7 @@
 use rustc_session::{Session, lint};
 use rustc_span::edit_distance::{edit_distance, find_best_match_for_name};
 use rustc_span::edition::Edition;
-use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, kw, sym};
 use thin_vec::ThinVec;
 use tracing::debug;
 
@@ -978,12 +978,15 @@ fn try_lookup_name_relaxed(
                     AssocSuggestion::Field(field_span) => {
                         if self_is_available {
                             let source_map = self.r.tcx.sess.source_map();
-                            // check if the field is used in a format string, such as `"{x}"`
-                            let field_is_format_named_arg = source_map
+                            let field_is_format_named_arg = matches!(
+                                span.desugaring_kind(),
+                                Some(DesugaringKind::FormatLiteral { .. })
+                            ) && source_map
                                 .span_to_source(span, |s, start, _| {
-                                    Ok(s.get(start - 1..start) == Some("{"))
-                                });
-                            if let Ok(true) = field_is_format_named_arg {
+                                    Ok(s.get(start.saturating_sub(1)..start) == Some("{"))
+                                })
+                                .unwrap_or(false);
+                            if field_is_format_named_arg {
                                 err.help(
                                     format!("you might have meant to use the available field in a format string: `\"{{}}\", self.{}`", segment.ident.name),
                                 );

compiler/rustc_span/src/symbol.rs

@@ -2211,6 +2211,7 @@
         v1,
         v8plus,
         va_arg,
+        va_arg_safe,
         va_copy,
         va_end,
         va_list,

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -41,7 +41,7 @@
     feature = "nightly",
     derive(Encodable_NoContext, Decodable_NoContext, HashStable_NoContext)
 )]
-#[cfg_attr(feature = "nightly", cfg_attr(not(bootstrap), rustc_must_match_exhaustively))]
+#[cfg_attr(feature = "nightly", rustc_must_match_exhaustively)]
 pub enum TypingMode<I: Interner> {
     /// When checking whether impls overlap, we check whether any obligations
     /// are guaranteed to never hold when unifying the impls. This requires us

library/alloc/src/str.rs

@@ -335,13 +335,19 @@ pub fn replacen<P: Pattern>(&self, pat: P, to: &str, count: usize) -> String {
 
     /// Returns the lowercase equivalent of this string slice, as a new [`String`].
     ///
-    /// 'Lowercase' is defined according to the terms of the Unicode Derived Core Property
-    /// `Lowercase`.
+    /// 'Lowercase' is defined according to the terms of
+    /// [Chapter 3 (Conformance)](https://www.unicode.org/versions/latest/core-spec/chapter-3/#G34432)
+    /// of the Unicode standard.
     ///
     /// Since some characters can expand into multiple characters when changing
     /// the case, this function returns a [`String`] instead of modifying the
     /// parameter in-place.
     ///
+    /// Unlike [`char::to_lowercase()`], this method fully handles the context-dependent
+    /// casing of Greek sigma. However, like that method, it does not handle locale-specific
+    /// casing, like Turkish and Azeri I/ı/İ/i. See that method's documentation
+    /// for more information.
+    ///
     /// # Examples
     ///
     /// Basic usage:
@@ -378,7 +384,9 @@ pub fn replacen<P: Pattern>(&self, pat: P, to: &str, count: usize) -> String {
                   without modifying the original"]
     #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
     pub fn to_lowercase(&self) -> String {
-        let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_lowercase);
+        // SAFETY: `to_ascii_lowercase` preserves ASCII bytes, so the converted
+        // prefix remains valid UTF-8.
+        let (mut s, rest) = unsafe { convert_while_ascii(self, u8::to_ascii_lowercase) };
 
         let prefix_len = s.len();
 
@@ -426,13 +434,18 @@ fn case_ignorable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
 
     /// Returns the uppercase equivalent of this string slice, as a new [`String`].
     ///
-    /// 'Uppercase' is defined according to the terms of the Unicode Derived Core Property
-    /// `Uppercase`.
+    /// 'Uppercase' is defined according to the terms of
+    /// [Chapter 3 (Conformance)](https://www.unicode.org/versions/latest/core-spec/chapter-3/#G34431)
+    /// of the Unicode standard.
     ///
     /// Since some characters can expand into multiple characters when changing
     /// the case, this function returns a [`String`] instead of modifying the
     /// parameter in-place.
     ///
+    /// Like [`char::to_uppercase()`] this method does not handle language-specific
+    /// casing, like Turkish and Azeri I/ı/İ/i. See that method's documentation
+    /// for more information.
+    ///
     /// # Examples
     ///
     /// Basic usage:
@@ -463,7 +476,9 @@ fn case_ignorable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
                   without modifying the original"]
     #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
     pub fn to_uppercase(&self) -> String {
-        let (mut s, rest) = convert_while_ascii(self, u8::to_ascii_uppercase);
+        // SAFETY: `to_ascii_uppercase` preserves ASCII bytes, so the converted
+        // prefix remains valid UTF-8.
+        let (mut s, rest) = unsafe { convert_while_ascii(self, u8::to_ascii_uppercase) };
 
         for c in rest.chars() {
             match conversions::to_upper(c) {
@@ -626,11 +641,15 @@ pub unsafe fn from_boxed_utf8_unchecked(v: Box<[u8]>) -> Box<str> {
 ///
 /// This function is only public so that it can be verified in a codegen test,
 /// see `issue-123712-str-to-lower-autovectorization.rs`.
+///
+/// # Safety
+///
+/// `convert` must return an ASCII byte for every ASCII input byte.
 #[unstable(feature = "str_internals", issue = "none")]
 #[doc(hidden)]
 #[inline]
 #[cfg(not(no_global_oom_handling))]
-pub fn convert_while_ascii(s: &str, convert: fn(&u8) -> u8) -> (String, &str) {
+pub unsafe fn convert_while_ascii(s: &str, convert: fn(&u8) -> u8) -> (String, &str) {
     // Process the input in chunks of 16 bytes to enable auto-vectorization.
     // Previously the chunk size depended on the size of `usize`,
     // but on 32-bit platforms with sse or neon is also the better choice.

library/core/src/cell/lazy.rs

@@ -367,7 +367,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     }
 }
 
-#[stable(feature = "from_wrapper_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "from_wrapper_impls", since = "1.96.0")]
 impl<T, F> From<T> for LazyCell<T, F> {
     /// Constructs a `LazyCell` that starts already initialized
     /// with the provided value.

library/core/src/char/methods.rs

@@ -1151,13 +1151,14 @@ pub fn is_numeric(self) -> bool {
     /// [ucd]: https://www.unicode.org/reports/tr44/
     /// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
     ///
-    /// If this `char` requires special considerations (e.g. multiple `char`s) the iterator yields
-    /// the `char`(s) given by [`SpecialCasing.txt`].
+    /// If this `char` expands to multiple `char`s, the iterator yields the `char`s given by
+    /// [`SpecialCasing.txt`]. The maximum number of `char`s in a case mapping is 3.
     ///
     /// [`SpecialCasing.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
     ///
     /// This operation performs an unconditional mapping without tailoring. That is, the conversion
-    /// is independent of context and language.
+    /// is independent of context and language. See [below](#notes-on-context-and-locale)
+    /// for more information.
     ///
     /// In the [Unicode Standard], Chapter 4 (Character Properties) discusses case mapping in
     /// general and Chapter 3 (Conformance) discusses the default algorithm for case conversion.
@@ -1199,6 +1200,48 @@ pub fn is_numeric(self) -> bool {
     /// // convert into themselves.
     /// assert_eq!('山'.to_lowercase().to_string(), "山");
     /// ```
+    /// # Notes on context and locale
+    ///
+    /// As stated earlier, this method does not take into account language or context.
+    /// Below is a non-exhaustive list of situations where this can be relevant.
+    /// If you need to handle locale-depedendent casing in your code, consider using
+    /// an external crate, like [`icu_casemap`](https://crates.io/crates/icu_casemap)
+    /// which is developed by Unicode.
+    ///
+    /// ## Greek sigma
+    ///
+    /// In Greek, the letter simga (uppercase Σ) has two lowercase forms:
+    /// ς which is used only at the end of a word, and σ which is used everywhere else.
+    /// `to_lowercase()` always uses the second form:
+    ///
+    /// ```
+    /// assert_eq!('Σ'.to_lowercase().to_string(), "σ");
+    /// ```
+    ///
+    /// ## Turkish and Azeri I/ı/İ/i
+    ///
+    /// In Turkish and Azeri, the equivalent of 'i' in Latin has five forms instead of two:
+    ///
+    /// * 'Dotless': I / ı, sometimes written ï
+    /// * 'Dotted': İ / i
+    ///
+    /// Note that the uppercase undotted 'I' is the same as the Latin. Therefore:
+    ///
+    /// ```
+    /// let lower_i = 'I'.to_lowercase().to_string();
+    /// ```
+    ///
+    /// The value of `lower_i` here relies on the language of the text: if we're
+    /// in `en-US`, it should be `"i"`, but if we're in `tr-TR` or `az-AZ`, it should
+    /// be `"ı"`. `to_lowercase()` does not take this into account, and so:
+    ///
+    /// ```
+    /// let lower_i = 'I'.to_lowercase().to_string();
+    ///
+    /// assert_eq!(lower_i, "i");
+    /// ```
+    ///
+    /// holds across languages.
     #[must_use = "this returns the lowercased character as a new iterator, \
                   without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -1211,8 +1254,10 @@ pub fn to_lowercase(self) -> ToLowercase {
     /// `char`s.
     ///
     /// This is usually, but not always, equivalent to the uppercase mapping
-    /// returned by [`Self::to_uppercase`]. Prefer this method when seeking to capitalize
-    /// Only The First Letter of a word, but use [`Self::to_uppercase`] for ALL CAPS.
+    /// returned by [`to_uppercase()`]. Prefer this method when seeking to capitalize
+    /// Only The First Letter of a word, but use [`to_uppercase()`] for ALL CAPS.
+    /// See [below](#difference-from-uppercase) for a thorough explanation
+    /// of the difference between the two methods.
     ///
     /// If this `char` does not have a titlecase mapping, the iterator yields the same `char`.
     ///
@@ -1222,13 +1267,14 @@ pub fn to_lowercase(self) -> ToLowercase {
     /// [ucd]: https://www.unicode.org/reports/tr44/
     /// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
     ///
-    /// If this `char` requires special considerations (e.g. multiple `char`s) the iterator yields
-    /// the `char`(s) given by [`SpecialCasing.txt`].
+    /// If this `char` expands to multiple `char`s, the iterator yields the `char`s given by
+    /// [`SpecialCasing.txt`]. The maximum number of `char`s in a case mapping is 3.
     ///
     /// [`SpecialCasing.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
     ///
     /// This operation performs an unconditional mapping without tailoring. That is, the conversion
-    /// is independent of context and language.
+    /// is independent of context and language. See [below](#note-on-locale)
+    /// for more information.
     ///
     /// In the [Unicode Standard], Chapter 4 (Character Properties) discusses case mapping in
     /// general and Chapter 3 (Conformance) discusses the default algorithm for case conversion.
@@ -1265,8 +1311,9 @@ pub fn to_lowercase(self) -> ToLowercase {
     /// ```
     /// #![feature(titlecase)]
     /// assert_eq!('c'.to_titlecase().to_string(), "C");
+    /// assert_eq!('ა'.to_titlecase().to_string(), "ა");
     /// assert_eq!('dž'.to_titlecase().to_string(), "Dž");
-    /// assert_eq!('ῼ'.to_titlecase().to_string(), "ῼ");
+    /// assert_eq!('ᾨ'.to_titlecase().to_string(), "ᾨ");
     ///
     /// // Sometimes the result is more than one character:
     /// assert_eq!('ß'.to_titlecase().to_string(), "Ss");
@@ -1276,8 +1323,78 @@ pub fn to_lowercase(self) -> ToLowercase {
     /// assert_eq!('山'.to_titlecase().to_string(), "山");
     /// ```
     ///
+    /// # Difference from uppercase
+    ///
+    /// Currently, there are three classes of characters where [`to_uppercase()`]
+    /// and `to_titlecase()` give different results:
+    ///
+    /// ## Georgian script
+    ///
+    /// Each letter in the modern Georgian alphabet can be written in one of two forms:
+    /// the typical lowercase-like "mkhedruli" form, and a variant uppercase-like "mtavruli"
+    /// form. However, unlike uppercase in most cased scripts, mtavruli is not typically used
+    /// to start sentences, denote proper nouns, or for any other purpose
+    /// in running text. It is instead confined to titles and headings, which are written entirely
+    /// in mtavruli. For this reason, [`to_uppercase()`] applied to a Georgian letter
+    /// will return the mtavruli form, but `to_titlecase()` will return the mkhedruli form.
+    ///
+    /// ```
+    /// #![feature(titlecase)]
+    /// let ani = 'ა'; // First letter of the Georgian alphabet, in mkhedruli form
+    ///
+    /// // Titlecasing mkhedruli maps it to itself...
+    /// assert_eq!(ani.to_titlecase().to_string(), ani.to_string());
+    ///
+    /// // but uppercasing it maps it to mtavruli
+    /// assert_eq!(ani.to_uppercase().to_string(), "Ა");
+    /// ```
+    ///
+    /// ## Compatibility digraphs for Latin-alphabet Serbo-Croatian
+    ///
+    /// The standard Latin alphabet for the Serbo-Croatian language
+    /// (Bosnian, Croatian, Montenegrin, and Serbian) contains
+    /// three digraphs: Dž, Lj, and Nj. These are usually represented as
+    /// two characters. However, for compatibility with older character sets,
+    /// Unicode includes single-character versions of these digraphs.
+    /// Each has a uppercase, titlecase, and lowercase version:
+    ///
+    /// - `'DŽ'`, `'Dž'`, `'dž'`
+    /// - `'LJ'`, `'Lj'`, `'lj'`
+    /// - `'NJ'`, `'Nj'`, `'nj'`
+    ///
+    /// Unicode additionally encodes a casing triad for the Dz digraph
+    /// without the caron: `'DZ'`, `'Dz'`, `'dz'`.
+    ///
+    /// ## Iota-subscritped Greek vowels
+    ///
+    /// In ancient Greek, the long vowels alpha (α), eta (η), and omega (ω)
+    /// were sometimes followed by an iota (ι), forming a diphthong. Over time,
+    /// the diphthong pronunciation was slowly lost, with the iota becoming mute.
+    /// Eventually, the ι disappeared from the spelling as well.
+    /// However, there remains a need to represent ancient texts faithfully.
+    ///
+    /// Modern editions of ancient Greek texts commonly use a reduced-sized
+    /// ι symbol to denote mute iotas, while distinguishing them from ιs
+    /// which continued to affect pronunciation. The exact standard differs
+    /// between different publications. Some render the mute ι below its associated
+    /// vowel (subscript), while others place it to the right of said vowel (adscript).
+    /// The interaction of mute ι symbols with casing also varies.
+    ///
+    /// The Unicode Standard, for its default casing rules, chose to make lowercase
+    /// Greek vowels with iota subscipt (e.g. `'ᾠ'`) titlecase to the uppercase vowel
+    /// with iota subscript (`'ᾨ'`) but uppercase to the uppercase vowel followed by
+    /// full-size uppercase iota (`"ὨΙ"`). This is just one convention among many
+    /// in common use, but it is the one Unicode settled on,
+    /// so it is what this method does also.
+    ///
     /// # Note on locale
     ///
+    /// As stated above, this method is locale-insensitive.
+    /// If you need locale support, consider using an external crate,
+    /// like [`icu_casemap`](https://crates.io/crates/icu_casemap)
+    /// which is developed by Unicode. A description of a common
+    /// locale-dependent casing issue follows:
+    ///
     /// In Turkish and Azeri, the equivalent of 'i' in Latin has five forms instead of two:
     ///
     /// * 'Dotless': I / ı, sometimes written ï
@@ -1302,6 +1419,8 @@ pub fn to_lowercase(self) -> ToLowercase {
     /// ```
     ///
     /// holds across languages.
+    ///
+    /// [`to_uppercase()`]: Self::to_uppercase()
     #[must_use = "this returns the titlecased character as a new iterator, \
                   without modifying the original"]
     #[unstable(feature = "titlecase", issue = "153892")]
@@ -1313,8 +1432,9 @@ pub fn to_titlecase(self) -> ToTitlecase {
     /// Returns an iterator that yields the uppercase mapping of this `char` as one or more
     /// `char`s.
     ///
-    /// Prefer this method when converting a word into ALL CAPS, but consider [`Self::to_titlecase`]
-    /// instead if you seek to capitalize Only The First Letter.
+    /// Prefer this method when converting a word into ALL CAPS, but consider [`to_titlecase()`]
+    /// instead if you seek to capitalize Only The First Letter. See that method's documentation
+    /// for more information on the difference between the two.
     ///
     /// If this `char` does not have an uppercase mapping, the iterator yields the same `char`.
     ///
@@ -1324,13 +1444,14 @@ pub fn to_titlecase(self) -> ToTitlecase {
     /// [ucd]: https://www.unicode.org/reports/tr44/
     /// [`UnicodeData.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/UnicodeData.txt
     ///
-    /// If this `char` requires special considerations (e.g. multiple `char`s) the iterator yields
-    /// the `char`(s) given by [`SpecialCasing.txt`].
+    /// If this `char` expands to multiple `char`s, the iterator yields the `char`s given by
+    /// [`SpecialCasing.txt`]. The maximum number of `char`s in a case mapping is 3.
     ///
     /// [`SpecialCasing.txt`]: https://www.unicode.org/Public/UCD/latest/ucd/SpecialCasing.txt
     ///
     /// This operation performs an unconditional mapping without tailoring. That is, the conversion
-    /// is independent of context and language.
+    /// is independent of context and language. See [below](#note-on-locale)
+    /// for more information.
     ///
     /// In the [Unicode Standard], Chapter 4 (Character Properties) discusses case mapping in
     /// general and Chapter 3 (Conformance) discusses the default algorithm for case conversion.
@@ -1338,6 +1459,7 @@ pub fn to_titlecase(self) -> ToTitlecase {
     /// [Unicode Standard]: https://www.unicode.org/versions/latest/
     ///
     /// # Examples
+    ///
     /// `'ſt'` (U+FB05) is a single Unicode code point (a ligature) that maps to "ST" in uppercase.
     ///
     /// As an iterator:
@@ -1365,11 +1487,12 @@ pub fn to_titlecase(self) -> ToTitlecase {
     ///
     /// ```
     /// assert_eq!('c'.to_uppercase().to_string(), "C");
+    /// assert_eq!('ა'.to_uppercase().to_string(), "Ა");
     /// assert_eq!('dž'.to_uppercase().to_string(), "DŽ");
     ///
     /// // Sometimes the result is more than one character:
     /// assert_eq!('ſt'.to_uppercase().to_string(), "ST");
-    /// assert_eq!('ῼ'.to_uppercase().to_string(), "ΩΙ");
+    /// assert_eq!('ᾨ'.to_uppercase().to_string(), "ὨΙ");
     ///
     /// // Characters that do not have both uppercase and lowercase
     /// // convert into themselves.
@@ -1378,6 +1501,12 @@ pub fn to_titlecase(self) -> ToTitlecase {
     ///
     /// # Note on locale
     ///
+    /// As stated above, this method is locale-insensitive.
+    /// If you need locale support, consider using an external crate,
+    /// like [`icu_casemap`](https://crates.io/crates/icu_casemap)
+    /// which is developed by Unicode. A description of a common
+    /// locale-dependent casing issue follows:
+    ///
     /// In Turkish and Azeri, the equivalent of 'i' in Latin has five forms instead of two:
     ///
     /// * 'Dotless': I / ı, sometimes written ï
@@ -1400,6 +1529,8 @@ pub fn to_titlecase(self) -> ToTitlecase {
     /// ```
     ///
     /// holds across languages.
+    ///
+    /// [`to_titlecase()`]: Self::to_titlecase()
     #[must_use = "this returns the uppercased character as a new iterator, \
                   without modifying the original"]
     #[stable(feature = "rust1", since = "1.0.0")]

library/core/src/ffi/c_str.rs

@@ -716,7 +716,7 @@ fn index(&self, index: ops::RangeFrom<usize>) -> &CStr {
     }
 }
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 impl ops::Index<range::RangeFrom<usize>> for CStr {
     type Output = CStr;
 

library/core/src/ffi/va_list.rs

@@ -266,14 +266,17 @@ fn drop(&mut self) {
 mod sealed {
     pub trait Sealed {}
 
+    impl Sealed for i16 {}
     impl Sealed for i32 {}
     impl Sealed for i64 {}
     impl Sealed for isize {}
 
+    impl Sealed for u16 {}
     impl Sealed for u32 {}
     impl Sealed for u64 {}
     impl Sealed for usize {}
 
+    impl Sealed for f32 {}
     impl Sealed for f64 {}
 
     impl<T> Sealed for *mut T {}
@@ -297,24 +300,64 @@ impl<T> Sealed for *const T {}
 // We may unseal this trait in the future, but currently our `va_arg` implementations don't support
 // types with an alignment larger than 8, or with a non-scalar layout. Inline assembly can be used
 // to accept unsupported types in the meantime.
+#[lang = "va_arg_safe"]
 pub unsafe trait VaArgSafe: sealed::Sealed {}
 
-// i8 and i16 are implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.
+crate::cfg_select! {
+    any(target_arch = "avr", target_arch = "msp430") => {
+        // c_int/c_uint are i16/u16 on these targets.
+        //
+        // - i8 is implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.
+        // - u8 is implicitly promoted to c_uint in C, and cannot implement `VaArgSafe`.
+        unsafe impl VaArgSafe for i16 {}
+        unsafe impl VaArgSafe for u16 {}
+    }
+    _ => {
+        // c_int/c_uint are i32/u32 on this target.
+        //
+        // - i8 and i16 are implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.
+        // - u8 and u16 are implicitly promoted to c_uint in C, and cannot implement `VaArgSafe`.
+    }
+}
+
+crate::cfg_select! {
+    target_arch = "avr" => {
+        // c_double is f32 on this target.
+        unsafe impl VaArgSafe for f32 {}
+    }
+    _ => {
+        // c_double is f64 on this target.
+        //
+        // - f32 is implicitly promoted to c_double in C, and cannot implement `VaArgSafe`.
+    }
+}
+
 unsafe impl VaArgSafe for i32 {}
 unsafe impl VaArgSafe for i64 {}
 unsafe impl VaArgSafe for isize {}
 
-// u8 and u16 are implicitly promoted to c_int in C, and cannot implement `VaArgSafe`.
 unsafe impl VaArgSafe for u32 {}
 unsafe impl VaArgSafe for u64 {}
 unsafe impl VaArgSafe for usize {}
 
-// f32 is implicitly promoted to c_double in C, and cannot implement `VaArgSafe`.
 unsafe impl VaArgSafe for f64 {}
 
 unsafe impl<T> VaArgSafe for *mut T {}
 unsafe impl<T> VaArgSafe for *const T {}
 
+// Check that relevant `core::ffi` types implement `VaArgSafe`.
+const _: () = {
+    const fn va_arg_safe_check<T: VaArgSafe>() {}
+
+    va_arg_safe_check::<crate::ffi::c_int>();
+    va_arg_safe_check::<crate::ffi::c_uint>();
+    va_arg_safe_check::<crate::ffi::c_long>();
+    va_arg_safe_check::<crate::ffi::c_ulong>();
+    va_arg_safe_check::<crate::ffi::c_longlong>();
+    va_arg_safe_check::<crate::ffi::c_ulonglong>();
+    va_arg_safe_check::<crate::ffi::c_double>();
+};
+
 impl<'f> VaList<'f> {
     /// Read an argument from the variable argument list, and advance to the next argument.
     ///

library/core/src/mem/alignment.rs

@@ -178,7 +178,7 @@ pub const fn as_usize(self) -> usize {
     /// Returns the alignment as a <code>[NonZero]<[usize]></code>.
     #[unstable(feature = "ptr_alignment_type", issue = "102070")]
     #[deprecated(
-        since = "CURRENT_RUSTC_VERSION",
+        since = "1.96.0",
         note = "renamed to `as_nonzero_usize`",
         suggestion = "as_nonzero_usize"
     )]

library/core/src/ops/control_flow.rs

@@ -262,8 +262,8 @@ pub const fn break_value(self) -> Option<B>
     /// assert_eq!(res, Ok(&5));
     /// ```
     #[inline]
-    #[stable(feature = "control_flow_ok", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "control_flow_ok", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "control_flow_ok", since = "1.96.0")]
+    #[rustc_const_stable(feature = "control_flow_ok", since = "1.96.0")]
     #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
     pub const fn break_ok(self) -> Result<B, C> {
         match self {
@@ -374,8 +374,8 @@ pub const fn continue_value(self) -> Option<C>
     /// assert_eq!(res, Err("too big value detected"));
     /// ```
     #[inline]
-    #[stable(feature = "control_flow_ok", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_stable(feature = "control_flow_ok", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "control_flow_ok", since = "1.96.0")]
+    #[rustc_const_stable(feature = "control_flow_ok", since = "1.96.0")]
     #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
     pub const fn continue_ok(self) -> Result<C, B> {
         match self {

library/core/src/panic/unwind_safe.rs

@@ -317,7 +317,7 @@ fn size_hint(&self) -> (usize, Option<usize>) {
 
 /// If a value's type is already `UnwindSafe`,
 /// wrapping it in `AssertUnwindSafe` is never incorrect.
-#[stable(feature = "from_wrapper_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "from_wrapper_impls", since = "1.96.0")]
 impl<T> From<T> for AssertUnwindSafe<T>
 where
     T: UnwindSafe,

library/core/src/ptr/mod.rs

@@ -413,7 +413,7 @@
 use crate::{fmt, hash, intrinsics, ub_checks};
 
 #[unstable(feature = "ptr_alignment_type", issue = "102070")]
-#[deprecated(since = "CURRENT_RUSTC_VERSION", note = "moved from `ptr` to `mem`")]
+#[deprecated(since = "1.96.0", note = "moved from `ptr` to `mem`")]
 /// Deprecated re-export of [mem::Alignment].
 pub type Alignment = mem::Alignment;
 

library/core/src/ptr/mut_ptr.rs

@@ -594,7 +594,7 @@ pub fn mask(self, mask: usize) -> *mut T {
     ///
     /// [`as_mut`]: #method.as_mut
     /// [`as_uninit_mut`]: #method.as_uninit_mut
-    /// [`as_ref_unchecked`]: #method.as_mut_unchecked
+    /// [`as_ref_unchecked`]: #method.as_ref_unchecked
     ///
     /// # Safety
     ///

library/core/src/range.rs

@@ -24,13 +24,13 @@
 pub mod legacy;
 
 #[doc(inline)]
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 pub use iter::RangeFromIter;
 #[doc(inline)]
 #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
 pub use iter::RangeInclusiveIter;
 #[doc(inline)]
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 pub use iter::RangeIter;
 
 // FIXME(#125687): re-exports temporarily removed
@@ -68,17 +68,17 @@
 #[lang = "RangeCopy"]
 #[derive(Copy, Hash)]
 #[derive_const(Clone, Default, PartialEq, Eq)]
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 pub struct Range<Idx> {
     /// The lower bound of the range (inclusive).
-    #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_api", since = "1.96.0")]
     pub start: Idx,
     /// The upper bound of the range (exclusive).
-    #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_api", since = "1.96.0")]
     pub end: Idx,
 }
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 impl<Idx: fmt::Debug> fmt::Debug for Range<Idx> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.start.fmt(fmt)?;
@@ -103,7 +103,7 @@ impl<Idx: Step> Range<Idx> {
     /// assert_eq!(i.next(), Some(16));
     /// assert_eq!(i.next(), Some(25));
     /// ```
-    #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_api", since = "1.96.0")]
     #[inline]
     pub fn iter(&self) -> RangeIter<Idx> {
         self.clone().into_iter()
@@ -132,7 +132,7 @@ impl<Idx: PartialOrd<Idx>> Range<Idx> {
     /// assert!(!Range::from(f32::NAN..1.0).contains(&0.5));
     /// ```
     #[inline]
-    #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_api", since = "1.96.0")]
     #[rustc_const_unstable(feature = "const_range", issue = "none")]
     pub const fn contains<U>(&self, item: &U) -> bool
     where
@@ -164,7 +164,7 @@ pub const fn contains<U>(&self, item: &U) -> bool
     /// assert!( Range::from(f32::NAN..5.0).is_empty());
     /// ```
     #[inline]
-    #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_api", since = "1.96.0")]
     #[rustc_const_unstable(feature = "const_range", issue = "none")]
     pub const fn is_empty(&self) -> bool
     where
@@ -174,7 +174,7 @@ pub const fn is_empty(&self) -> bool
     }
 }
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for Range<T> {
     fn start_bound(&self) -> Bound<&T> {
@@ -191,7 +191,7 @@ fn end_bound(&self) -> Bound<&T> {
 /// If you need to use this implementation where `T` is unsized,
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..end` with `(Bound::Included(start), Bound::Excluded(end))`.
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for Range<&T> {
     fn start_bound(&self) -> Bound<&T> {
@@ -210,7 +210,7 @@ fn into_bounds(self) -> (Bound<T>, Bound<T>) {
     }
 }
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<Range<T>> for legacy::Range<T> {
     #[inline]
@@ -218,7 +218,7 @@ fn from(value: Range<T>) -> Self {
         Self { start: value.start, end: value.end }
     }
 }
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_convert", issue = "143773")]
 impl<T> const From<legacy::Range<T>> for Range<T> {
     #[inline]
@@ -444,14 +444,14 @@ fn from(value: legacy::RangeInclusive<T>) -> Self {
 #[lang = "RangeFromCopy"]
 #[derive(Copy, Hash)]
 #[derive_const(Clone, PartialEq, Eq)]
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 pub struct RangeFrom<Idx> {
     /// The lower bound of the range (inclusive).
-    #[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_from_api", since = "1.96.0")]
     pub start: Idx,
 }
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 impl<Idx: fmt::Debug> fmt::Debug for RangeFrom<Idx> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         self.start.fmt(fmt)?;
@@ -475,7 +475,7 @@ impl<Idx: Step> RangeFrom<Idx> {
     /// assert_eq!(i.next(), Some(16));
     /// assert_eq!(i.next(), Some(25));
     /// ```
-    #[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_from_api", since = "1.96.0")]
     #[inline]
     pub fn iter(&self) -> RangeFromIter<Idx> {
         self.clone().into_iter()
@@ -499,7 +499,7 @@ impl<Idx: PartialOrd<Idx>> RangeFrom<Idx> {
     /// assert!(!RangeFrom::from(f32::NAN..).contains(&0.5));
     /// ```
     #[inline]
-    #[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_from_api", since = "1.96.0")]
     #[rustc_const_unstable(feature = "const_range", issue = "none")]
     pub const fn contains<U>(&self, item: &U) -> bool
     where
@@ -510,7 +510,7 @@ pub const fn contains<U>(&self, item: &U) -> bool
     }
 }
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for RangeFrom<T> {
     fn start_bound(&self) -> Bound<&T> {
@@ -527,7 +527,7 @@ fn end_bound(&self) -> Bound<&T> {
 /// If you need to use this implementation where `T` is unsized,
 /// consider using the `RangeBounds` impl for a 2-tuple of [`Bound<&T>`][Bound],
 /// i.e. replace `start..` with `(Bound::Included(start), Bound::Unbounded)`.
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for RangeFrom<&T> {
     fn start_bound(&self) -> Bound<&T> {
@@ -557,7 +557,7 @@ fn bound(self) -> (OneSidedRangeBound, T) {
     }
 }
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 impl<T> const From<RangeFrom<T>> for legacy::RangeFrom<T> {
     #[inline]
@@ -565,7 +565,7 @@ fn from(value: RangeFrom<T>) -> Self {
         Self { start: value.start }
     }
 }
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 impl<T> const From<legacy::RangeFrom<T>> for RangeFrom<T> {
     #[inline]
@@ -619,14 +619,14 @@ fn from(value: legacy::RangeFrom<T>) -> Self {
 #[lang = "RangeToInclusiveCopy"]
 #[doc(alias = "..=")]
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]
-#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
 pub struct RangeToInclusive<Idx> {
     /// The upper bound of the range (inclusive)
-    #[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
     pub last: Idx,
 }
 
-#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
 impl<Idx: fmt::Debug> fmt::Debug for RangeToInclusive<Idx> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(fmt, "..=")?;
@@ -650,7 +650,7 @@ impl<Idx: PartialOrd<Idx>> RangeToInclusive<Idx> {
     /// assert!(!(..=f32::NAN).contains(&0.5));
     /// ```
     #[inline]
-    #[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
     #[rustc_const_unstable(feature = "const_range", issue = "none")]
     pub const fn contains<U>(&self, item: &U) -> bool
     where
@@ -661,13 +661,13 @@ pub const fn contains<U>(&self, item: &U) -> bool
     }
 }
 
-#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
 impl<T> From<legacy::RangeToInclusive<T>> for RangeToInclusive<T> {
     fn from(value: legacy::RangeToInclusive<T>) -> Self {
         Self { last: value.end }
     }
 }
-#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
 impl<T> From<RangeToInclusive<T>> for legacy::RangeToInclusive<T> {
     fn from(value: RangeToInclusive<T>) -> Self {
         Self { end: value.last }
@@ -677,7 +677,7 @@ fn from(value: RangeToInclusive<T>) -> Self {
 // RangeToInclusive<Idx> cannot impl From<RangeTo<Idx>>
 // because underflow would be possible with (..0).into()
 
-#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for RangeToInclusive<T> {
     fn start_bound(&self) -> Bound<&T> {
@@ -688,7 +688,7 @@ fn end_bound(&self) -> Bound<&T> {
     }
 }
 
-#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_range", issue = "none")]
 impl<T> const RangeBounds<T> for RangeToInclusive<&T> {
     fn start_bound(&self) -> Bound<&T> {

library/core/src/range/iter.rs

@@ -6,7 +6,7 @@
 use crate::{intrinsics, mem};
 
 /// By-value [`Range`] iterator.
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 #[derive(Debug, Clone)]
 pub struct RangeIter<A>(legacy::Range<A>);
 
@@ -64,7 +64,7 @@ unsafe impl TrustedRandomAccessNoCoerce for RangeIter<$t> {
     u64 i64
 }
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 impl<A: Step> Iterator for RangeIter<A> {
     type Item = A;
 
@@ -132,7 +132,7 @@ unsafe fn __iterator_get_unchecked(&mut self, idx: usize) -> Self::Item
     }
 }
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 impl<A: Step> DoubleEndedIterator for RangeIter<A> {
     #[inline]
     fn next_back(&mut self) -> Option<A> {
@@ -153,10 +153,10 @@ fn advance_back_by(&mut self, n: usize) -> Result<(), NonZero<usize>> {
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<A: TrustedStep> TrustedLen for RangeIter<A> {}
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 impl<A: Step> FusedIterator for RangeIter<A> {}
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 impl<A: Step> IntoIterator for Range<A> {
     type Item = A;
     type IntoIter = RangeIter<A>;
@@ -299,7 +299,7 @@ fn into_iter(self) -> Self::IntoIter {
 //   since e.g. `(0..=u64::MAX).len()` would be `u64::MAX + 1`.
 macro_rules! range_exact_iter_impl {
     ($($t:ty)*) => ($(
-        #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+        #[stable(feature = "new_range_api", since = "1.96.0")]
         impl ExactSizeIterator for RangeIter<$t> { }
     )*)
 }
@@ -322,7 +322,7 @@ impl ExactSizeIterator for RangeInclusiveIter<$t> { }
 }
 
 /// By-value [`RangeFrom`] iterator.
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 #[derive(Debug, Clone)]
 pub struct RangeFromIter<A> {
     start: A,
@@ -361,7 +361,7 @@ pub fn remainder(self) -> RangeFrom<A> {
     }
 }
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 impl<A: Step> Iterator for RangeFromIter<A> {
     type Item = A;
 
@@ -432,10 +432,10 @@ fn nth(&mut self, n: usize) -> Option<A> {
 #[unstable(feature = "trusted_len", issue = "37572")]
 unsafe impl<A: TrustedStep> TrustedLen for RangeFromIter<A> {}
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 impl<A: Step> FusedIterator for RangeFromIter<A> {}
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 impl<A: Step> IntoIterator for RangeFrom<A> {
     type Item = A;
     type IntoIter = RangeFromIter<A>;

library/core/src/slice/index.rs

@@ -125,13 +125,13 @@ impl Sealed for ops::RangeToInclusive<usize> {}
     #[stable(feature = "slice_index_with_ops_bound_pair", since = "1.53.0")]
     impl Sealed for (ops::Bound<usize>, ops::Bound<usize>) {}
 
-    #[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_api", since = "1.96.0")]
     impl Sealed for range::Range<usize> {}
     #[stable(feature = "new_range_inclusive_api", since = "1.95.0")]
     impl Sealed for range::RangeInclusive<usize> {}
-    #[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
     impl Sealed for range::RangeToInclusive<usize> {}
-    #[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+    #[stable(feature = "new_range_from_api", since = "1.96.0")]
     impl Sealed for range::RangeFrom<usize> {}
 
     impl Sealed for ops::IndexRange {}
@@ -458,7 +458,7 @@ fn index_mut(self, slice: &mut [T]) -> &mut [T] {
     }
 }
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl<T> const SliceIndex<[T]> for range::Range<usize> {
     type Output = [T];
@@ -588,7 +588,7 @@ fn index_mut(self, slice: &mut [T]) -> &mut [T] {
     }
 }
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl<T> const SliceIndex<[T]> for range::RangeFrom<usize> {
     type Output = [T];
@@ -801,7 +801,7 @@ fn index_mut(self, slice: &mut [T]) -> &mut [T] {
 }
 
 /// The methods `index` and `index_mut` panic if the end of the range is out of bounds.
-#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl<T> const SliceIndex<[T]> for range::RangeToInclusive<usize> {
     type Output = [T];

library/core/src/str/traits.rs

@@ -258,7 +258,7 @@ fn index_mut(self, slice: &mut str) -> &mut Self::Output {
     }
 }
 
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl const SliceIndex<str> for range::Range<usize> {
     type Output = str;
@@ -555,7 +555,7 @@ fn index_mut(self, slice: &mut str) -> &mut Self::Output {
     }
 }
 
-#[stable(feature = "new_range_from_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_from_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl const SliceIndex<str> for range::RangeFrom<usize> {
     type Output = str;
@@ -777,7 +777,7 @@ fn index_mut(self, slice: &mut str) -> &mut Self::Output {
 /// Panics if `last` does not point to the ending byte offset of a character
 /// (`last + 1` is either a starting byte offset as defined by
 /// `is_char_boundary`, or equal to `len`), or if `last >= len`.
-#[stable(feature = "new_range_to_inclusive_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_to_inclusive_api", since = "1.96.0")]
 #[rustc_const_unstable(feature = "const_index", issue = "143775")]
 unsafe impl const SliceIndex<str> for range::RangeToInclusive<usize> {
     type Output = str;

library/std/src/fs.rs

@@ -2896,7 +2896,7 @@ pub fn copy<P: AsRef<Path>, Q: AsRef<Path>>(from: P, to: Q) -> io::Result<u64> {
 ///
 /// # Platform-specific behavior
 ///
-/// This function currently corresponds the `CreateHardLink` function on Windows.
+/// This function currently corresponds to the `CreateHardLink` function on Windows.
 /// On most Unix systems, it corresponds to the `linkat` function with no flags.
 /// On Android, VxWorks, and Redox, it instead corresponds to the `link` function.
 /// On MacOS, it uses the `linkat` function if it is available, but on very old

library/std/src/lib.rs

@@ -545,7 +545,7 @@
 pub use core::pin;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::ptr;
-#[stable(feature = "new_range_api", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "new_range_api", since = "1.96.0")]
 pub use core::range;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use core::result;

library/std/src/sync/lazy_lock.rs

@@ -396,7 +396,7 @@ fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
     }
 }
 
-#[stable(feature = "from_wrapper_impls", since = "CURRENT_RUSTC_VERSION")]
+#[stable(feature = "from_wrapper_impls", since = "1.96.0")]
 impl<T, F> From<T> for LazyLock<T, F> {
     /// Constructs a `LazyLock` that starts already initialized
     /// with the provided value.

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

@@ -339,7 +339,7 @@ fn get_path(fd: c_int) -> Option<PathBuf> {
         // alternatives. If a better method is invented, it should be used
         // instead.
         let mut buf = vec![0; libc::PATH_MAX as usize];
-        let n = unsafe { libc::fcntl(fd, libc::F_GETPATH, buf.as_ptr()) };
+        let n = unsafe { libc::fcntl(fd, libc::F_GETPATH, buf.as_mut_ptr()) };
         if n == -1 {
             cfg_select! {
                 target_os = "netbsd" => {
@@ -375,7 +375,7 @@ fn get_path(fd: c_int) -> Option<PathBuf> {
     #[cfg(target_os = "vxworks")]
     fn get_path(fd: c_int) -> Option<PathBuf> {
         let mut buf = vec![0; libc::PATH_MAX as usize];
-        let n = unsafe { libc::ioctl(fd, libc::FIOGETNAME, buf.as_ptr()) };
+        let n = unsafe { libc::ioctl(fd, libc::FIOGETNAME, buf.as_mut_ptr()) };
         if n == -1 {
             return None;
         }

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

@@ -207,7 +207,7 @@ fn sysctl() -> io::Result<PathBuf> {
             cvt(libc::sysctl(
                 mib.as_ptr(),
                 mib.len() as libc::c_uint,
-                path.as_ptr() as *mut libc::c_void,
+                path.as_mut_ptr() as *mut libc::c_void,
                 &mut path_len,
                 ptr::null(),
                 0,

src/bootstrap/src/core/build_steps/doc.rs

@@ -932,13 +932,7 @@ fn run(self, builder: &Builder<'_>) {
         // see https://github.com/rust-lang/rust/pull/122066#issuecomment-1983049222
         // If there is any bug, please comment out the next line.
         cargo.rustdocflag("--generate-link-to-definition");
-        // FIXME: Currently, `--generate-macro-expansion` option is buggy in `beta` rustdoc. To
-        // allow CI to pass, we only enable the option in stage 2 and higher.
-        // cfg(bootstrap)
-        // ^ Adding this so it's not forgotten when the new release is done.
-        if builder.top_stage > 1 {
-            cargo.rustdocflag("--generate-macro-expansion");
-        }
+        cargo.rustdocflag("--generate-macro-expansion");
 
         compile::rustc_cargo(builder, &mut cargo, target, &build_compiler, &self.crates);
         cargo.arg("-Zskip-rustdoc-fingerprint");

src/bootstrap/src/core/sanity.rs

@@ -37,8 +37,6 @@ pub struct Finder {
 /// when the newly-bumped stage 0 compiler now knows about the formerly-missing targets.
 const STAGE0_MISSING_TARGETS: &[&str] = &[
     // just a dummy comment so the list doesn't get onelined
-    "x86_64-unknown-linux-gnumsan",
-    "x86_64-unknown-linux-gnutsan",
 ];
 
 /// Minimum version threshold for libstdc++ required when using prebuilt LLVM

src/doc/rustc-dev-guide/src/tests/compiletest.md

@@ -190,11 +190,6 @@ substring must not appear anywhere in the compiler output.
 This can be useful to ensure certain errors do not appear, but this can be fragile as error messages
 change over time, and a test may no longer be checking the right thing but will still pass.
 
-`cfail` tests support the `should-ice` directive to specify that a test should
-cause an Internal Compiler Error (ICE).
-This is a highly specialized directive
-to check that the incremental cache continues to work after an ICE.
-
 Incremental tests may use the attribute `#[rustc_clean(...)]` attribute.
 This attribute compares the fingerprint from the current compilation session with the previous one.
 The first revision should never have an active `rustc_clean` attribute, since it will always be dirty.

src/doc/rustc-dev-guide/src/tests/directives.md

@@ -80,8 +80,7 @@ See [Controlling pass/fail expectations](ui.md#controlling-passfail-expectations
 | `run-fail-or-crash`         | Program must `run-fail` or `run-crash`      | `ui`                                      | N/A             |
 | `ignore-pass`               | Ignore `--pass` flag                        | `ui`, `crashes`, `codegen`, `incremental` | N/A             |
 | `dont-check-failure-status` | Don't check exact failure status (i.e. `1`) | `ui`, `incremental`                       | N/A             |
-| `failure-status`            | Check                                       | `ui`, `crashes`                           | Any `u16`       |
-| `should-ice`                | Check failure status is `101`               | `coverage`, `incremental`                 | N/A             |
+| `failure-status`            | On failure, the compiler must exit with this status code. To expect an ICE, use `//@ failure-status: 101`. | `ui`, `crashes`, `incremental`            | Any `u16`       |
 | `should-fail`               | Compiletest self-test                       | All                                       | N/A             |
 
 ### Controlling output snapshots and normalizations
@@ -318,7 +317,6 @@ See [Pretty-printer](compiletest.md#pretty-printer-tests).
 - [`revisions`](compiletest.md#revisions) — compile multiple times
 -[`forbid-output`](compiletest.md#incremental-tests) — incremental cfail rejects
       output pattern
-- [`should-ice`](compiletest.md#incremental-tests) — incremental cfail should ICE
 - [`reference`] — an annotation linking to a rule in the reference
 - `disable-gdb-pretty-printers` — disable gdb pretty printers for debuginfo tests
 

src/librustdoc/clean/mod.rs

@@ -235,7 +235,8 @@ fn generate_item_with_correct_attrs(
             attrs.extend(get_all_import_attributes(cx, import_id, def_id, is_inline));
             is_inline = is_inline || import_is_inline;
         }
-        add_without_unwanted_attributes(&mut attrs, target_attrs, is_inline, None);
+        let keep_target_cfg = is_inline || matches!(kind, ItemKind::TypeAliasItem(..));
+        add_without_unwanted_attributes(&mut attrs, target_attrs, keep_target_cfg, None);
         attrs
     } else {
         // We only keep the item's attributes.

src/librustdoc/html/markdown.rs

@@ -582,6 +582,7 @@ fn next(&mut self) -> Option<Self::Item> {
                 }
             }
             let id = self.id_map.derive(id);
+            let percent_encoded_id = small_url_encode(id.clone());
 
             if let Some(ref mut builder) = self.toc {
                 let mut text_header = String::new();
@@ -596,8 +597,9 @@ fn next(&mut self) -> Option<Self::Item> {
                 std::cmp::min(level as u32 + (self.heading_offset as u32), MAX_HEADER_LEVEL);
             self.buf.push_back((Event::Html(format!("</h{level}>").into()), 0..0));
 
-            let start_tags =
-                format!("<h{level} id=\"{id}\"><a class=\"doc-anchor\" href=\"#{id}\">§</a>");
+            let start_tags = format!(
+                "<h{level} id=\"{id}\"><a class=\"doc-anchor\" href=\"#{percent_encoded_id}\">§</a>"
+            );
             return Some((Event::Html(start_tags.into()), 0..0));
         }
         event

src/librustdoc/html/static/js/main.js

@@ -2123,20 +2123,27 @@ function preLoadCss(cssUrl) {
         return;
     }
     but.onclick = () => {
-        // Most page titles are '<Item> in <path::to::module> - Rust', except
-        // modules (which don't have the first part) and keywords/primitives
-        // (which don't have a module path)
-        const titleElement = document.querySelector("title");
-        const title = titleElement && titleElement.textContent ?
-                      titleElement.textContent.replace(" - Rust", "") : "";
-        const [item, module] = title.split(" in ");
-        const path = [item];
-        if (module !== undefined) {
-            path.unshift(module);
-        }
+        // We get the path from the "breadcrumbs" and the actual item name.
+        let path = "";
+        // @ts-expect-error
+        const heading = document.getElementById(MAIN_ID).querySelector(".main-heading");
 
-        copyContentToClipboard(path.join("::"));
-        copyButtonAnimation(but);
+        if (heading) {
+            const breadcrumbs = heading.querySelector(".rustdoc-breadcrumbs");
+            if (breadcrumbs) {
+                // @ts-expect-error
+                path = breadcrumbs.innerText;
+                if (path.length > 0) {
+                    path += "::";
+                }
+            }
+
+            // @ts-expect-error
+            path += heading.querySelector("h1 > span").innerText;
+
+            copyContentToClipboard(path);
+            copyButtonAnimation(but);
+        }
     };
 
     /**

src/stage0

@@ -13,570 +13,574 @@ nightly_branch=main
 # All changes below this comment will be overridden the next time the
 # tool is executed.
 
-compiler_channel_manifest_hash=18261f24c2dc26c5bfc6647e837c2e820a478f52d55aea7ff98eb24f43c750dd
-compiler_git_commit_hash=ad726b5063362ec9897ef3d67452fc5606ee70fa
-compiler_date=2026-03-05
+compiler_channel_manifest_hash=6887616f401b27dd030fbcbfc4b009cbfb9ee3e9faa6b0c92d516211718c689d
+compiler_git_commit_hash=ef0fb8a2563200e322fa4419f09f65a63742038c
+compiler_date=2026-04-14
 compiler_version=beta
-rustfmt_channel_manifest_hash=b9fb9e2c2cb55ccaccfc5d359d1de156896d3d4bda1b59b8e2e2fc9f987f6d29
-rustfmt_git_commit_hash=b90dc1e597db0bbc0cab0eccb39747b1a9d7e607
-rustfmt_date=2026-03-05
+rustfmt_channel_manifest_hash=3668522db987dc630cd478b113f7d3c0963a1a7ee9fdd645841c10889a38af8f
+rustfmt_git_commit_hash=17584a181979f04f2aaad867332c22db1caa511a
+rustfmt_date=2026-04-14
 rustfmt_version=nightly
 
-dist/2026-03-05/rustc-beta-aarch64-apple-darwin.tar.gz=650b56e03e7154b0c186e0da55c9f041aa4cb3647df11463442dc537370ada85
-dist/2026-03-05/rustc-beta-aarch64-apple-darwin.tar.xz=381a0ef50b903bd25eab7e77527ccbe1587529402c97ce88622631494b242ffd
-dist/2026-03-05/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=ff3174cdc011b123932c36dc8b8aa4d621a335eb581b46e62f14c6fb006f22bc
-dist/2026-03-05/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=905581d7fddf56543fa1acda7fe4db6227de8ce042385c9bdd4c364fb84aa2c8
-dist/2026-03-05/rustc-beta-aarch64-pc-windows-msvc.tar.gz=00c91e988eab57c55190dc86ed999f702d829edd4710fd4e5e3634fbbbdbfeaf
-dist/2026-03-05/rustc-beta-aarch64-pc-windows-msvc.tar.xz=7d336f56d300b843a849da814c53a2beee7b691f30acb36593f6ec58360dc7d5
-dist/2026-03-05/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=81d3fbc4892b4258bcee80e80623cca3415884981a9917daada0dda12b367dde
-dist/2026-03-05/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=290438ff8ba8568c4d73934feaa306af9e7c4caa0c8661882ece05b939c163fa
-dist/2026-03-05/rustc-beta-aarch64-unknown-linux-musl.tar.gz=d6503532a5ab7b503f82fa9d351c01e9817d1cab6c25d46e314009d0dc75cf40
-dist/2026-03-05/rustc-beta-aarch64-unknown-linux-musl.tar.xz=083b52bf221707eacc293d71c9a5c28976564318af3c97ae6f58cd8773d855e6
-dist/2026-03-05/rustc-beta-aarch64-unknown-linux-ohos.tar.gz=60bc7c0341e6d5134e6ad906fd752ebbc882d06542a35af226a3b56eb59282cf
-dist/2026-03-05/rustc-beta-aarch64-unknown-linux-ohos.tar.xz=1332a554b15f83874c57ad6121ed4883cda66df8b44070491eec13ce39834b4e
-dist/2026-03-05/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=a01016314c662a96c03df4cf5380903796f13ca54848827381d99f4a7159957b
-dist/2026-03-05/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=325a6f5872936c2302823fd905d22eed59a78d2cbdf208f5b6017808e2263ad9
-dist/2026-03-05/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=7a46a409c4058189d22d1e48b3bd629343ac4ed5a3dfd618b689200b58ef95dc
-dist/2026-03-05/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=f7fb4b0d5f10b590ea2e4beaf75b6c6f4361ead7901d8fb897133632c9698856
-dist/2026-03-05/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=280725ea12cf056a4f03ff83e2d81f919346c2903e5791a126fa6d16efbcab16
-dist/2026-03-05/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=52835b250cc4727f8084f192e9344014cfad9bfb5522dc453da2746c15c4eb99
-dist/2026-03-05/rustc-beta-i686-pc-windows-gnu.tar.gz=7961a9dc51530f9e1adf5a59f53490d3dc2ca157f8b211d0ec5ec0877988bfb9
-dist/2026-03-05/rustc-beta-i686-pc-windows-gnu.tar.xz=ca668b08973f71f589e9d4f77de9f76f2ee4a82b7e5bb183f377769aa9fc0084
-dist/2026-03-05/rustc-beta-i686-pc-windows-msvc.tar.gz=b2ad97cd15048533ed9dc6f75b8ff57aedc2af81fda6f0ed6be34af36464fb93
-dist/2026-03-05/rustc-beta-i686-pc-windows-msvc.tar.xz=6523e6786f296d3ea28f4262a1c6ca04b516c2b4503e49c3c7d3ea327082071b
-dist/2026-03-05/rustc-beta-i686-unknown-linux-gnu.tar.gz=67e9bf000831d12df5c142ba00d3b8e7ecdbd83a743ef980268463e5afa4387e
-dist/2026-03-05/rustc-beta-i686-unknown-linux-gnu.tar.xz=62f9750fd2a2105d0fc13942c3641b5f6f134321a464380d2a723bc0fe52e738
-dist/2026-03-05/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=0b27d682292f44196fce7f6bf1eaa071a9a7601c3203afa3181510793294c0a1
-dist/2026-03-05/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=b749c18e1d118e4a8ecffb6686930afba2768df66dd34ff3fa6cb64ca7e6673e
-dist/2026-03-05/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=723aed06f88df2141444364b2edcb4813a12604742d4b96c919490e9010ddec7
-dist/2026-03-05/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=9cbe23a8790f009da41e84e2dfb6c435deca18a25f35a852c36decdc78a9dcbd
-dist/2026-03-05/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=a5789c1b290db71f2966dcbbaffc792c1c2980d2e86a53fcebb5328de2e8f73d
-dist/2026-03-05/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=5e8a86b1c8e8be1d48d965a289d5329a5c7127c518f8ba440622cd5312d2d442
-dist/2026-03-05/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=0c2a4a56dcdf62b0ccf4fa828730bd1ec5295eebace379609d678480d84980da
-dist/2026-03-05/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=190b49c000102e56bb9318edaf8e0fed179345ccc3cf78fb57989d57f3974cef
-dist/2026-03-05/rustc-beta-powerpc64-unknown-linux-musl.tar.gz=738add7773970131fd43f080410a8fae703ae6eb5dbc356a1a427ad173489e92
-dist/2026-03-05/rustc-beta-powerpc64-unknown-linux-musl.tar.xz=0faaed4c732ae9b771644d84739492fdc80bdcb350fed185c8736166e8ad9c20
-dist/2026-03-05/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=0a8f9660dc8a14bf2ff9b8c7a2df8fc23a45c14fc6b085fbd50a13877f042c04
-dist/2026-03-05/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=51429bf6500b7d09da100dd959cca5e88aa4e8545cc5beb09a7300b5eaee1412
-dist/2026-03-05/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=3ff09553efaf5d230dd4a0b3c8e5a0e6ae62d00fe815e9a0229dfff34e7e87ee
-dist/2026-03-05/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=b620eed0bd1ebda01b4119e15b5178b816fe96e366afd8814c786e006541c785
-dist/2026-03-05/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=6acf5d8fdeb2e7ecdc91da9294aa4a588b5791bf99cf4ad7765f3ed388a5dd80
-dist/2026-03-05/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=aa9769b54f698eb24acdfa5085130558a3571569d50c009dedd2ce9eb72345af
-dist/2026-03-05/rustc-beta-s390x-unknown-linux-gnu.tar.gz=4ebfdac050645cf9afc0e2607f62995455a0353d7653a66d2bb08f7fad804a48
-dist/2026-03-05/rustc-beta-s390x-unknown-linux-gnu.tar.xz=610496d4b784e3fdb2fc7a32668fe58b14268792bf6b4894d8fa0e833112a8c7
-dist/2026-03-05/rustc-beta-sparcv9-sun-solaris.tar.gz=030105e01ae63f958ecfa42987c256b07e5a585002ac1fbb6dcbc4c7df18c038
-dist/2026-03-05/rustc-beta-sparcv9-sun-solaris.tar.xz=0ccf23b879e50b3bf769cfcb7951434bc2ba59265139a0ffe00706dfa44dd5ee
-dist/2026-03-05/rustc-beta-x86_64-apple-darwin.tar.gz=83280a373b737caa5b6f216a3a556f8d869f0b54243cc53dd604d5cf0b5e07a1
-dist/2026-03-05/rustc-beta-x86_64-apple-darwin.tar.xz=2881512dfdf291dfa8cc690a765afeee80a742e25fed8b4639fd342d3b57dcf3
-dist/2026-03-05/rustc-beta-x86_64-pc-solaris.tar.gz=91e0e499456fd72682eda9e1110c3092d96c8a0b833e6c9e2ae4be8a2061d067
-dist/2026-03-05/rustc-beta-x86_64-pc-solaris.tar.xz=4c80df90c8894e10b8906ea822443313fd5081f2fbf4f18977357773f918e424
-dist/2026-03-05/rustc-beta-x86_64-pc-windows-gnu.tar.gz=1b64212003ff090df8de09c03c91f99a26c72c83aa36ccf8b2a1196a516fbaee
-dist/2026-03-05/rustc-beta-x86_64-pc-windows-gnu.tar.xz=554e356a2962b389f3dc45ac21ffca256e1ed21ee29f567d3d67b8a4b5ef085e
-dist/2026-03-05/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=fa4bec1bb19c64363eef9d8311aae96e44d06f10c5996d5f7a33ceae01372738
-dist/2026-03-05/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=1e38ff8b07ef3b70a5e334884346011fdcc1c3c30651d7099a66633d656e6e23
-dist/2026-03-05/rustc-beta-x86_64-pc-windows-msvc.tar.gz=8bb72e21316da6ab8e062dc70fce7f4f7f6768cd172c243c1057891aa358c9ff
-dist/2026-03-05/rustc-beta-x86_64-pc-windows-msvc.tar.xz=a88f497378e937eb37c5eceff9ee7de18153be3542c8aaa086644c1664832838
-dist/2026-03-05/rustc-beta-x86_64-unknown-freebsd.tar.gz=371760bc3d699b172f84b11eacffe8f2ca327ea3855a455252ad397f0fa2c8ca
-dist/2026-03-05/rustc-beta-x86_64-unknown-freebsd.tar.xz=c773c2e91b829ef50736baf135e34aaca6f85a6c3ba338a955b22934f0a0e007
-dist/2026-03-05/rustc-beta-x86_64-unknown-illumos.tar.gz=60bb8ae417384961616050d0f0b1a64e1f0a3e3a70454358f7e86ff57a2d088c
-dist/2026-03-05/rustc-beta-x86_64-unknown-illumos.tar.xz=85df1a6cae9cef7c4b1c937f00a1a3040e30e2607ab1432b962c2f078be98642
-dist/2026-03-05/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=7227d0c3367084f40b65adc970a5062b6b432eac74927859e5b561d5b205585b
-dist/2026-03-05/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=09f6ad1eac75fdd1fb9fec65896a89230af299764be7035610dbb257ff7db092
-dist/2026-03-05/rustc-beta-x86_64-unknown-linux-musl.tar.gz=4c4514a5809af869d8517f5eb0ce4c985203c8f4f29fca70f8acdce7d6b1a7ad
-dist/2026-03-05/rustc-beta-x86_64-unknown-linux-musl.tar.xz=cb915951bba6f4a0b6aeb8d15c262ac6f0bc0fe8449715ef856d7c31985a2961
-dist/2026-03-05/rustc-beta-x86_64-unknown-netbsd.tar.gz=af520fc931de40fdd053f04bda845c043fa03ea3816cf2543232b04c37faddbe
-dist/2026-03-05/rustc-beta-x86_64-unknown-netbsd.tar.xz=c7070141983633d890d41dfca8652b7c7fa84a965ac3e98d7e9c19237c54e5c7
-dist/2026-03-05/rust-std-beta-aarch64-apple-darwin.tar.gz=cafe606fb1d62c7181a65c44bab0fc74f4173a9e8fa832d2b3114a601e41ed50
-dist/2026-03-05/rust-std-beta-aarch64-apple-darwin.tar.xz=72ee3b3f8e51dbb05d543016fc58ca549eeabcc30d824717dff0252da4735d82
-dist/2026-03-05/rust-std-beta-aarch64-apple-ios.tar.gz=0730eff2b7e19e90cba3273702d16389f71a04f5bcf49116a2ad3d17a6aa75ac
-dist/2026-03-05/rust-std-beta-aarch64-apple-ios.tar.xz=74616504a19fe9c517bfa28eeb54b037092f12f44b85030bb52a5b9ac6d5faab
-dist/2026-03-05/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=1f03b91804fb2acb2c763d09fa8d8a7acc899c9d3c5294567bd8cadb6e9165bf
-dist/2026-03-05/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=268834b76808fa8727540d1e7932fd3e473821bdd099f8b86e79f7bba724f504
-dist/2026-03-05/rust-std-beta-aarch64-apple-ios-sim.tar.gz=7d850e86133f7bbacecd9148ada1c7ed30a733c9cd532e1abfd0f55d52087910
-dist/2026-03-05/rust-std-beta-aarch64-apple-ios-sim.tar.xz=b90fc4c1b4c09fc9d4c0caa74e5033809f3ee966f602dffdd91364dc83bd6cfe
-dist/2026-03-05/rust-std-beta-aarch64-apple-tvos.tar.gz=a7563c0d120528bfb2dc4080446ffcc3446374c0ca63c0ddddfc07c32c94c08b
-dist/2026-03-05/rust-std-beta-aarch64-apple-tvos.tar.xz=cca30889ac56c8c0896ec7c420d02192bc6d7a74cbf6721625c7a710e46abcb6
-dist/2026-03-05/rust-std-beta-aarch64-apple-tvos-sim.tar.gz=5a14b4402c1ec7aea207d22ca697b090b251210ba0694039fe4ea3a4c2e72715
-dist/2026-03-05/rust-std-beta-aarch64-apple-tvos-sim.tar.xz=a21c3eb2f3b5cc2ad646764022e1f88ba2c24a300ea10aa5aceb3e6b959e4d1a
-dist/2026-03-05/rust-std-beta-aarch64-apple-visionos.tar.gz=dc0a255f8e87880e91989c862328277d530f3a42a48f3efe33f90b5f862081e2
-dist/2026-03-05/rust-std-beta-aarch64-apple-visionos.tar.xz=86788e6c2f85a8423b7605927aea132623591247eef2e45aa84fb47f3101c1ff
-dist/2026-03-05/rust-std-beta-aarch64-apple-visionos-sim.tar.gz=074c5d2669def265508f3be284c518b0eedc81644052c001bf15dc3857557abd
-dist/2026-03-05/rust-std-beta-aarch64-apple-visionos-sim.tar.xz=80f3809c79778f83944bc35293cbf77031ca7734af119476ebf4dc38fff569dc
-dist/2026-03-05/rust-std-beta-aarch64-apple-watchos.tar.gz=906b636421c268f6d44ef80d9d1de8fd996edd3fcc157a19401126825a7c3cd6
-dist/2026-03-05/rust-std-beta-aarch64-apple-watchos.tar.xz=10b38ff3e2eae457831e22ed5970f4cd5b2e0f01275a733fa3eb27ec27015dbb
-dist/2026-03-05/rust-std-beta-aarch64-apple-watchos-sim.tar.gz=bd54cf3033bd31ee06e9991dd1a95c0cdb6a7c99164eea3fa9a5b0eca7faefa4
-dist/2026-03-05/rust-std-beta-aarch64-apple-watchos-sim.tar.xz=1e7c5ca89565862d74c7116f54e8f79c60ba73d84323dd0683f6790ba1de9bff
-dist/2026-03-05/rust-std-beta-aarch64-linux-android.tar.gz=c74d4fae56c3b2d8b3246e4162aac942d8572a55b998b7c817624f486afd99e3
-dist/2026-03-05/rust-std-beta-aarch64-linux-android.tar.xz=ce86ee64dd869f2d28d5acbc97c055e74b78c185ea6f78941e3d45b8138e52c3
-dist/2026-03-05/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=a93b191e685c3da24f76c6144b17cb112e124e1f8138de262bbbf548defd7f8d
-dist/2026-03-05/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=126d68941a10d43392ff6fe7814cf41512d2eb8142136b3ae044e554aafae662
-dist/2026-03-05/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=1a29244fa330079a71c2249c385b1b83f1bd5d10649ef5d13b707a13beeb3ea9
-dist/2026-03-05/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=2728145b39da6d8b2a2e29b3ce0f362dbc12a9e31911240a8c20a4dc26802f94
-dist/2026-03-05/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=76cbf59626d054792dff027a2316f8a797416b8e739bb5266541a37cbddf141d
-dist/2026-03-05/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=1747e64a0b09934cc79704be3ff9b10f505c159c0f7933e3181946adc4f8dd01
-dist/2026-03-05/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=fe62c8b9c1bab4f864ebd011f6b2a40ae6a9f7d6e060117972ea751eabaa6156
-dist/2026-03-05/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=a7c611051bc24de59e738d52b25f812d6faad70c2e0ee57af93828b19b596855
-dist/2026-03-05/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=b98fe0cc6e91e3734ffde23e49bebf303c6311ed6d8a213e653d21ed7239d8af
-dist/2026-03-05/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=bd6e61c0c69266fa5230ef9a29beb540d619c5cd426295139a4de504535aa76b
-dist/2026-03-05/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=d9a2e69d9db54f3a53f178fabb069764d1eee274e5b1c6b940ad652eb2d100ed
-dist/2026-03-05/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=bf9515a722bd9db2c7b481341fb624ebe2205a23ef2d31967a07d36ab65cf96e
-dist/2026-03-05/rust-std-beta-aarch64-unknown-none.tar.gz=ac686397718764da9b5c05302ac240aca033d2ea79f41f5678b793188d372566
-dist/2026-03-05/rust-std-beta-aarch64-unknown-none.tar.xz=f173adaf5053b9a552b7dd4eace60116a9fbb539acfb2de5409328ca5614adb2
-dist/2026-03-05/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=3f8e38efd4d5a688dfa543b600f54bfb1231203d3ed48d9971be6bdaddcb85d9
-dist/2026-03-05/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=3dae31453f6b3c16cfc753b066fe10e27dd93131411afc3c781997d5358bca7d
-dist/2026-03-05/rust-std-beta-aarch64-unknown-uefi.tar.gz=930dfd3a113977cdcc58b41e6174ed6c5c09046f022a95eccca503775359f093
-dist/2026-03-05/rust-std-beta-aarch64-unknown-uefi.tar.xz=55211bd94f6837282f6c7ca94ac10ab94090252eede5f48d508d82efb0d0f505
-dist/2026-03-05/rust-std-beta-arm-linux-androideabi.tar.gz=c53336c95ccab792659681c9ad1234bc100e30248c80aab6cb68943625d74529
-dist/2026-03-05/rust-std-beta-arm-linux-androideabi.tar.xz=ee221c73b41a4735cd1304aaccb877180f2caf7f539209d948c01b6d00f8b6c6
-dist/2026-03-05/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=745555f9758b4d40f2ebcc9ac7610ea509a2dbc0db1ee47c878c7d630af1309f
-dist/2026-03-05/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=8d8e5904ad91585b66caed20f715b345002202087ad0347179f4f093dc67a26a
-dist/2026-03-05/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=d245629790c3d9cdef797754caa2c0239df7222f583b4b2ebf1ca7126c2e17cb
-dist/2026-03-05/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=cc0fe3213fed72ca7e21807d4e063a815597d3152d209d45c23eff508d9adeab
-dist/2026-03-05/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=3471b6e04ebcc9b9fb768efdca01c7c0bddb5a52152941fc95ca576506307a66
-dist/2026-03-05/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=d59e7e19afc0b4f9a893fa94d41837710858d3fd0b61be28f79ec64445a83d75
-dist/2026-03-05/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=b3cfd42b65d7728b7448970d70e5db8ef33a7c0106be94a37b1c77d0a2d98f15
-dist/2026-03-05/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=a89ff710cce70389e619c880f38a8eee7b6e46b3ec72cc812909f8707bb22418
-dist/2026-03-05/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=dcdf512d4063007732b80ff57f9f3aaa834560a5ddbdfc536c68092f44a3ef5c
-dist/2026-03-05/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=7cb83f36f9eb618fa0e3e5b06b4180b2b28782f86e6ed0eca7f3370daa07537f
-dist/2026-03-05/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=fd5bf879cb8097aa315c24afb4349ca2d72d10399db97cbf8c3028c897e0046c
-dist/2026-03-05/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=fe9d351f6326d74068e97b5a04a63a8d5ad3506ccb29a0795d3bfba8b9218e62
-dist/2026-03-05/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=28d8fd235126127fb4079d877d512f119e12ca5c100986e9105bd2824c07017b
-dist/2026-03-05/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=5e951c5635ff4ecba02217bcd43c20960cc1eea2e900072c946731315e8afdd0
-dist/2026-03-05/rust-std-beta-armv7-linux-androideabi.tar.gz=966a7bc22853ccd129ebc7e4b53bbe46fd41685dc1fe55b0e98ead75642b9ad3
-dist/2026-03-05/rust-std-beta-armv7-linux-androideabi.tar.xz=806d1c02e46ef5133867cba9b60c3458bf020d1a5663a9686b6bb34f3054d376
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=59213be7a4cf1745cb285e93761ec905a6f2bec6e061c48069be628415630657
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=ef4b990defa339048b9c192064f23c3d89d11e3899a99c5c7312d76dc0abd605
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=d396e64ec5ac1c3f059b17714175031c63a019a01f397ee0664d7ca5ec5ab9c1
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=f496630dddab81fcedb318b65d1863f8f172c5c6f11a0e70ba14c0d64c764db7
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=4c6a244e898e2f02e480743b7e26d2f39c399678223d36b1a62fb3d5fe3c7bc4
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=23067c41381cec9ab7daab8f03698405cc23665a1ec75993d8dd9c37c7fcd21a
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=bc88e9d6c2a8260028563e453a03cf247204ac94a5d0b3705d7f85ca07ec82b0
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=7fe689bafeef2d918821741d8bb5d9ba73712a5636cf6d1ef0e8783ebd73fc15
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=e7d2973ece8536dd2c552881cb1d7af5c8ab9155a263e4a87261ed8a3420341f
-dist/2026-03-05/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=18cf4eb6f76c1a685aac70d43464344ecb92f0a44d8ed9186826db737ac7763f
-dist/2026-03-05/rust-std-beta-armv7a-none-eabi.tar.gz=5621e2c815e801c43f9541018cf86f4083e322c5b9d03457461a2d657d9b8f18
-dist/2026-03-05/rust-std-beta-armv7a-none-eabi.tar.xz=55875228a72dc62a4bba1c4696dd254ed5b9728da49df7bf24155a4401ae67d4
-dist/2026-03-05/rust-std-beta-armv7a-none-eabihf.tar.gz=37c60688dde6b2ffe7661984643f7bc853424ce50272265fe0dfd5baf89cad33
-dist/2026-03-05/rust-std-beta-armv7a-none-eabihf.tar.xz=72397894682178a725e8e3876f62bc77cfdaedd8180fb17da52b042acfb28994
-dist/2026-03-05/rust-std-beta-armv7r-none-eabi.tar.gz=b8da86b3c3c635fed5e5a7a83ae922d651dafcc2d74873a335cb669e7e773a25
-dist/2026-03-05/rust-std-beta-armv7r-none-eabi.tar.xz=577a8318914714b870ce3045cc5e68eb98b193d54b109ef24ed9af1caeeee727
-dist/2026-03-05/rust-std-beta-armv7r-none-eabihf.tar.gz=07d8e3c7182cc3f8b985ccaa6980ae2e1ed855d4e3d3fd7119ae77fca2feb593
-dist/2026-03-05/rust-std-beta-armv7r-none-eabihf.tar.xz=47cc02692e03192420a6994897051aa0e33d9940a6fc780c3de270e4b49deda3
-dist/2026-03-05/rust-std-beta-armv8r-none-eabihf.tar.gz=382aa1b05857096d321d5df98b683c99c10e866bada218190bdcf6a223d15cba
-dist/2026-03-05/rust-std-beta-armv8r-none-eabihf.tar.xz=17010738cb68f5e545a45e899a64c2a29716d679eb897a40356d5aafa3327228
-dist/2026-03-05/rust-std-beta-i586-unknown-linux-gnu.tar.gz=e56d2535e50e6fe644d350d7d98ca0afd7a0a4ee417b9aa18f4807c2ace433f9
-dist/2026-03-05/rust-std-beta-i586-unknown-linux-gnu.tar.xz=3643be85aab61baef1f841199d624b6a74d8eafa395125731d0b39d4b62acf18
-dist/2026-03-05/rust-std-beta-i586-unknown-linux-musl.tar.gz=b8c36eae5032af0cce2dbee4b97dda5790849f31ae03daef3729aaf52f1a5080
-dist/2026-03-05/rust-std-beta-i586-unknown-linux-musl.tar.xz=4fb8a1acefc27c554b7f9223ae56a267e732c7616e4932b9f9785c490495f49e
-dist/2026-03-05/rust-std-beta-i686-linux-android.tar.gz=f9d5f6d20f0615afc0bfc93798fa28afdcbdf97174686961fa82486001037b4e
-dist/2026-03-05/rust-std-beta-i686-linux-android.tar.xz=75b0977f263a1f6157798343ce94f2450ef6959f830e1088e9db4e17aba57090
-dist/2026-03-05/rust-std-beta-i686-pc-windows-gnu.tar.gz=58e534f8eea22babdf368655bb279fc9e31d06e1155d65a18912d1c993bc0c2a
-dist/2026-03-05/rust-std-beta-i686-pc-windows-gnu.tar.xz=7165c674d0f01a288ed0a8f555dd860b54c4b943765a74ab6ff25f60234ff91a
-dist/2026-03-05/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=19c5cc06bf4114967c025a83e786d70496b2f4c04b6476eda1cece711342e290
-dist/2026-03-05/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=699969c886699a54f1129928ece1620cd9e5d5a851836ba791c25ea6a7ded1ea
-dist/2026-03-05/rust-std-beta-i686-pc-windows-msvc.tar.gz=de2f6107d3e160f7c764fefd5845d6e39af3efddc82a0454ddb240b92e296867
-dist/2026-03-05/rust-std-beta-i686-pc-windows-msvc.tar.xz=3076bc9d5159f2ae64531eab5e4586d8b45a6621fc0ffde36dd89c6a0993d7d6
-dist/2026-03-05/rust-std-beta-i686-unknown-freebsd.tar.gz=920711cafd7d9474230a74e1432e9d3bcf10f34dacf506bc7c0e0cbc52f2490a
-dist/2026-03-05/rust-std-beta-i686-unknown-freebsd.tar.xz=b246d3036b85ec9c0633ec464e6009eeab80d0ebb913ed298e5feb5b5d5e5f51
-dist/2026-03-05/rust-std-beta-i686-unknown-linux-gnu.tar.gz=bce452a29f1be4a042979de40c4aa3c7d3a1f4220d15aa86828fb690c7ec09f6
-dist/2026-03-05/rust-std-beta-i686-unknown-linux-gnu.tar.xz=5477b47f5b02951ede4977d2e1e632fdd78ff62b7d247879a87a2ad870d453bc
-dist/2026-03-05/rust-std-beta-i686-unknown-linux-musl.tar.gz=c96f7dbd9413ab90e4392eec66431a11137961d12e4e0f3e28418ac8aa1f8966
-dist/2026-03-05/rust-std-beta-i686-unknown-linux-musl.tar.xz=46be6fee5b16eed761730038f4e4b0c6d25327882143f56ea2f409bc6c966cc3
-dist/2026-03-05/rust-std-beta-i686-unknown-uefi.tar.gz=f34bece05809ffecb6f452b8311116d6badd9500ee2232df20d02908e5c1370c
-dist/2026-03-05/rust-std-beta-i686-unknown-uefi.tar.xz=a66afe0de861f7604448855296268cdaac51f299b443f625503195d0bc32774c
-dist/2026-03-05/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=46f67b6383a7c95dab4c72485b62f2609bde64631190efc20368034029782e75
-dist/2026-03-05/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=f557985f9131c9f73c88f6b5825e104ec7b9288f34d072a29a4be9e9a9e2fe79
-dist/2026-03-05/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=e42191719d3362f473b9f59d067787e3b2483d8abc55358b56473a93d812db8b
-dist/2026-03-05/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=8556ff0160fec5905d1329aeef6ccc66eb757077840782f4171c5cfc7dc05e0e
-dist/2026-03-05/rust-std-beta-loongarch64-unknown-none.tar.gz=d9fd31dc58820a27a0e9b3b46ff010eb4b22ca69e95eacaa5563a41389817627
-dist/2026-03-05/rust-std-beta-loongarch64-unknown-none.tar.xz=672227214c74df4805879204fb97ac4f1cc7f1ea3e6afd63a238265311b09b39
-dist/2026-03-05/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=aca39f4f45d7c15bb3e3ced00d76e5897ba11825dd755b1ef3655ff1a972ff3a
-dist/2026-03-05/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=3ed71bf5a7595ee98ea2b3ab4cab5d8a0a35c69888517daabb1156104f631d3d
-dist/2026-03-05/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=45ba5e51950abe8b84a4187b7af01a48580d84ce4c27fd77ab93f193daf64013
-dist/2026-03-05/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=58d6e3c0159564c96767fe703661251f63b0fbb2696d8e508b1bb0bfa0d72614
-dist/2026-03-05/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=2cd713940e33a0aefbcc4d15c480b80b9595e8742144d5c08fa90ee233facc55
-dist/2026-03-05/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=cf3b4c722305630d4c3334c35ca862e349b88707e80a394a26acb43eb4408893
-dist/2026-03-05/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=14b1686a0ecf61e22f0993ddeba23209d01195ddbccab05972a6caa7edd2e2dc
-dist/2026-03-05/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=7931dbf858d47b3b0dbf5c5b5d35325fc95316c75fa760526de64ceeec8cba5d
-dist/2026-03-05/rust-std-beta-powerpc64-unknown-linux-musl.tar.gz=7c1ed0f1b20baf2d6b5647ac8813d046db03af9bc2f99e602665af84f28703b0
-dist/2026-03-05/rust-std-beta-powerpc64-unknown-linux-musl.tar.xz=0fa036221f2ff65621c5b862f739553e750bff0b0afd02544c30f3a781908b8d
-dist/2026-03-05/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=e3cda0ea3bdbe09a05df7e9f7a7e87dc96bc92f5559286679d1cf793ab9ecfd4
-dist/2026-03-05/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=1cd6d88de0723a3cbf9fa2644aa849d75e13e6a20e9b5aa59a974bd5c0e523a0
-dist/2026-03-05/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=745111404f52bda5dc4a5b9494fb68c050f82d9f0863d91da9578291b881d780
-dist/2026-03-05/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=6cd441a90549ac68ec0b4882fda352726391cf14f772b9daa5bc08056447d49b
-dist/2026-03-05/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=4a510bdbfdd74781f92c65a87146efc75d48f79fe0e7a9988b8ae82d74916de5
-dist/2026-03-05/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=2dcfd1be33ebce0d677af0cde3d04ca4d27dee380a334cc7fa5fd86c751d39d2
-dist/2026-03-05/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=a247a3dfc51bf8d13a27b443a1ff6731c45f5cccd905341fd1d69834bfa8403e
-dist/2026-03-05/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=990243746c631e1e5896edc278cbca5ca4a1680100495e5d6f8e05823ac26249
-dist/2026-03-05/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=3043d783c97867628079247d16ec9368bdef4e526643b4de7b89dd274d615c96
-dist/2026-03-05/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=2e2ae7d6e73ce1ef4638ac3f637bd71ca7e382ea4af9a71de0a6b1d406f55970
-dist/2026-03-05/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=600fe7eff97e1f351140c006652f42345c296580781d15e5cbb183647f2ac81e
-dist/2026-03-05/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=38317b15436642e33c4f7e88338896ed863df8eda59af0c917df4461a57dd655
-dist/2026-03-05/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=0090d73f5817a87c05406046fd5bd1f9c8a74f5af97acba0af5118fbb255be85
-dist/2026-03-05/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=44f5371edf183585e138520e7bb14993654f177d519446a30fc6c3dc0e8dd407
-dist/2026-03-05/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.gz=138dec05006d15b2def37de03894966c02f80806153050fdd618c7c6803e7dfb
-dist/2026-03-05/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.xz=b938e120861f65f23d1857dfcd4f04a8476f37a55ce7ee5fb35ed160faf5f66c
-dist/2026-03-05/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=7be51115ae17b46a0b5f5df77dd73d507d1b5731df268a7f308e87cba5f11743
-dist/2026-03-05/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=9077843e3719c10a126b6a74bcc94272d9c0439fc3b74e356c585cb57d8ce1b9
-dist/2026-03-05/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=db8e9eed4e00bf763f9fb406578395b73b8f81aa7c096537a8a5ea933de1afab
-dist/2026-03-05/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=88ab1dd67b4beb703d06ea02678e90903f1f7c20c9ba2b11bf3b4fb833f2111c
-dist/2026-03-05/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=e20c786852a0c0d33e39c145ddd3bd35ac7fe3c445d2e632f172b58459a2cf4f
-dist/2026-03-05/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=46c1a56d2eed59964262c04c724e8e299c1d7e835dfd73d5b7b48c96300fa9fd
-dist/2026-03-05/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=fbef02ac4da131b76ff6bf32e6ad174e3f5bfa7701380b6fc778a2a457a8266b
-dist/2026-03-05/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=d129fa880bd7667b03f6526354d33b25949ea0a426f8d27e4c62bd839c947b29
-dist/2026-03-05/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=a379f60908528d81c6d9c974ee51815ec9c784d9a0f7911936c9e8482fb1bf85
-dist/2026-03-05/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=39bc843baca7c9a0fa6d0474211707f250c1367bd118ad625ce17831a8811e36
-dist/2026-03-05/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=5f352b2d16abd3d1f907803c2e778452827a150c4e957f3883164333f37af51d
-dist/2026-03-05/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=99339ef8b8bfadbc8a5be2328afa80e562c445bfb8617f0f76ac382f9f1fa5ce
-dist/2026-03-05/rust-std-beta-sparcv9-sun-solaris.tar.gz=85264c7227613c2da8ce02e5a1fd83822b29c7958afd0e43525f5d5117552ff1
-dist/2026-03-05/rust-std-beta-sparcv9-sun-solaris.tar.xz=a0dde20f6796d574cc856bd25f83b953dba0e6d349e88c69d93ea170ee622e32
-dist/2026-03-05/rust-std-beta-thumbv6m-none-eabi.tar.gz=8d9933d10602cbb923a3ac4ec1f8fde22eb68a5ed9ac4f44cb8253ac90d0ab3d
-dist/2026-03-05/rust-std-beta-thumbv6m-none-eabi.tar.xz=d150465828f4e14e75b5c94cb8aa246367f6a77f9c9d7c3e6646dbf0427c49a3
-dist/2026-03-05/rust-std-beta-thumbv7em-none-eabi.tar.gz=69806cf3c03236b2db21dcdbab9b3f259fb9dd0aacc183082579333deb0469e1
-dist/2026-03-05/rust-std-beta-thumbv7em-none-eabi.tar.xz=19c2348369984cde9af45767e7c928e483bf3e1d6867dc1f544bc6dd0493c03d
-dist/2026-03-05/rust-std-beta-thumbv7em-none-eabihf.tar.gz=076f320b0e2b97c686771551b663adc27bcc3157a93f4cdff685865ca0194ef4
-dist/2026-03-05/rust-std-beta-thumbv7em-none-eabihf.tar.xz=878e4be6803cc6859511b9934c1402598727f1a303460f81aeb0d46087b15759
-dist/2026-03-05/rust-std-beta-thumbv7m-none-eabi.tar.gz=6bedf4e9200e569de8b7e5bcf02dace47ebf7f0b8a085c1e7fda62d9668538ad
-dist/2026-03-05/rust-std-beta-thumbv7m-none-eabi.tar.xz=a24920a8099a9fa06610b1882382a4119e7b122b853de975fceaa9ef84c89fbf
-dist/2026-03-05/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=f3bc9fc0b2a21d8d978620204eac013c2391433131f1883713b88f000ab20cd7
-dist/2026-03-05/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=d8617595c8cc3863bbe85b0dbd6ead1f27d7330032d2940d4c56617641a919d9
-dist/2026-03-05/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=28461e5f6a6de05d4f713c650a9a6410222821daf8b8f6063460746dda673bbd
-dist/2026-03-05/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=f34f81b3b83b28f4556e115d54885f0bf78a8cb99091651114d1a092486ee3b6
-dist/2026-03-05/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=f091d4713aefe32ff57514d9604e690cd76e294e497c8e3d62a8d16a1b01c483
-dist/2026-03-05/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=0be6ef7df0c74611cc424a3123be7af7457e42d4b0372fe61a781e5021a156ec
-dist/2026-03-05/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=4176487e2eee68463a2014173640c92dea7a3ea14765c46dff29004b1368cbb2
-dist/2026-03-05/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=b5c6a05971185a875fce49b4261b642ad5f68a4234f435d036baa33b2f343345
-dist/2026-03-05/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=1cc3d65237cdf408d230e0a4e14dac778fb1a4a17c14873b2b7247defbc3f26d
-dist/2026-03-05/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=9d22dcba260431b746eeb5bee5d3e3f056261106fedac3ce2c324a79a036e69f
-dist/2026-03-05/rust-std-beta-wasm32-unknown-emscripten.tar.gz=34a0f151d8df4a1fdc0fdfb736322fa8f73490f53c9ef707f75676a6777b11b4
-dist/2026-03-05/rust-std-beta-wasm32-unknown-emscripten.tar.xz=39de807d96bf396e504dfc158ece3f181393b6665815626ed80454876096de8e
-dist/2026-03-05/rust-std-beta-wasm32-unknown-unknown.tar.gz=9a81193806c6a612bee692d438cb2c309c0668d13ef37093a36509268229e73d
-dist/2026-03-05/rust-std-beta-wasm32-unknown-unknown.tar.xz=db8fc69516f290d40247c912ff1e1a5cd9171fd0dcdcfc129e13f1af41ea486f
-dist/2026-03-05/rust-std-beta-wasm32-wasip1.tar.gz=2c2534ac71433b9a34f10e19678b96b8058c92a86f071d53bedea9b0bc489fd7
-dist/2026-03-05/rust-std-beta-wasm32-wasip1.tar.xz=7a15fde2513490d977d2dea9bfdb80bb55f30caddb0c0b06334b5758b26eff42
-dist/2026-03-05/rust-std-beta-wasm32-wasip1-threads.tar.gz=bff299121c3a8cda52f3f43a5529d041b2bc995365e6eaf3b986926672eeffd4
-dist/2026-03-05/rust-std-beta-wasm32-wasip1-threads.tar.xz=5195e3672661961670f44b0d69396fa1695f1a6a2127f9f56ea31df5846f4397
-dist/2026-03-05/rust-std-beta-wasm32-wasip2.tar.gz=659bad1ef10f3c5b82e9894a306acfde6553c44217a74dde57b25e29dcfaf5c9
-dist/2026-03-05/rust-std-beta-wasm32-wasip2.tar.xz=05e263489efbb721bb66709a02881458a402fb4377267b7381caaa652e6306b3
-dist/2026-03-05/rust-std-beta-wasm32v1-none.tar.gz=b0cfc9a70fceae519bab310245abbdee0fd2f48048860a2598cc1e0a207059fd
-dist/2026-03-05/rust-std-beta-wasm32v1-none.tar.xz=33f52cf94437b72cc73255b40fa7631cac2fb29bed9d35f68c2e9335ccc13733
-dist/2026-03-05/rust-std-beta-x86_64-apple-darwin.tar.gz=27ba2cf7756d8564604a76cee8e3da28956cd3742a7644baa94edc5acdb67270
-dist/2026-03-05/rust-std-beta-x86_64-apple-darwin.tar.xz=038ea8ccb752f7ee3a0b2373db7a474624a13685c66149f1998aff0d4c66cd40
-dist/2026-03-05/rust-std-beta-x86_64-apple-ios.tar.gz=24034142c44ca1fea1c8198f49bc4516b92b529e2f608fe93d0cfeedf69c1999
-dist/2026-03-05/rust-std-beta-x86_64-apple-ios.tar.xz=0d4fa173a7424f09128dcb8acd1f2cace73f0e6935be5b1f018282853986285a
-dist/2026-03-05/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=e2a5e41d8ce11f82e1e243f043a606bacc978e9847d38b042b34b9957540ae9b
-dist/2026-03-05/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=1d37957f9d8bd35a5395e348a6d6d8304c4f6b4b3154e540ede580533b6da992
-dist/2026-03-05/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=1c5c3ecfc5a5d5e0e7b186e89a871cbe836b0817b7aa049ad67ba792a42b18c3
-dist/2026-03-05/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=5aca860c6f93dcb9fc148a4dbccabc6cb9680cad686c42d8253ad6328e26cd7a
-dist/2026-03-05/rust-std-beta-x86_64-linux-android.tar.gz=3ff05c6013c8313b67544006b7d8eda924f3b607bcfbf52753b6f2ddd2e57778
-dist/2026-03-05/rust-std-beta-x86_64-linux-android.tar.xz=6c3941c8b3f75f90c49d3ce68c1325b6bf2a2fe300ecbc927193f9fc732beab1
-dist/2026-03-05/rust-std-beta-x86_64-pc-solaris.tar.gz=d6a69b5ea4ec7f78c27b4507fa9e5d2f10364e707de76facaaeb9c2d151bc9fb
-dist/2026-03-05/rust-std-beta-x86_64-pc-solaris.tar.xz=266796034403f625824277f0e0b375b32c0d00b121449abfa7a1f40cf9eb37e0
-dist/2026-03-05/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=34911f2eebe9fca1264f72cf8d8ee6c030fbe53680cb12cb712cf15ff03a1616
-dist/2026-03-05/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=50bf5599e34e355ecd813481755f749b78761d061a49d99644bf2bbed0688254
-dist/2026-03-05/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=25ba06cc262257e71301cc0e165f60028fa16aecf65229ccab64f72a2720e603
-dist/2026-03-05/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=fab550da3f00d57eceab58704078b56efd501e068ddf32ea48b9dea117f6414d
-dist/2026-03-05/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=98d3000a287fb7affc240f85f4ce0a9ce679ce245b5ca98acc7f91bd17b5d522
-dist/2026-03-05/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=7a8d2216231450594439863e2aae5fbacc35777d33ba7138a5ac6a9f748a6090
-dist/2026-03-05/rust-std-beta-x86_64-unknown-freebsd.tar.gz=c9ec7f794ad24b4a7f6de7c4721438925a895f0a151dd6dfd8730bd43fcbfabe
-dist/2026-03-05/rust-std-beta-x86_64-unknown-freebsd.tar.xz=bf727d7b87bafcc2cfdd45a61e9b728a73024cd141fdc37dcfe9731545645e2d
-dist/2026-03-05/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=bedcfc98f1bfe9c190e2b62d6b64fbbe13dcf14a7bf0b0295dc0e8f4b78148be
-dist/2026-03-05/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=2a4b98d9f573199cd3fbf1bcc0b1c1f1a575bea95a452b225e153c20041a1dd9
-dist/2026-03-05/rust-std-beta-x86_64-unknown-illumos.tar.gz=ec8fe5df05705fed6426921eeeb170a6e2d02c0f6a0edab14a27c8a2a2e94baa
-dist/2026-03-05/rust-std-beta-x86_64-unknown-illumos.tar.xz=c44b9d327d7800bd72a28c5f27aa5e91caffc497e3e23bbb46e1264bd9920d7c
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=775c2706672c106587f3f23e5b8871f8e1952be852f07a6bbd9c3db06eb9bea3
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=bc2ffcdf3a4eae93774ac99397bde4d31a1aa0379b86836d01967e300aad58a7
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.gz=5ec7c93e79db0166f4dd9c32ab5c3efdf85e49a38315754ed1836a3b817926e4
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.xz=1f946d69a66fa343e4b4be30ce6e65ff09b74ab1fd6f0742977b49e1950585b8
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=8fcb20971f563fcc2b935da6f2c93bc533f48dcdf413cf1319ff9cc857d041cb
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=7b4172c848472dac3a7197b2ae9556929723849da36dbb9318f50dfd6faf85c2
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=0208ebe70f3328e386a80c76b8208109a44aae91201313f58d794478540e3cb0
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=cc0d53793d75abd53be4fcec42f07dd2c70ebc5ac3570df23cd51cdd216279eb
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=5d777d1abdac2788b656d1eef75cad1be06fbd36c11c0451581ea4e0450a2b01
-dist/2026-03-05/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=2309970fd19d7aaf3eef71791f372ddad7b4bbe9180735e3294905ad5362b035
-dist/2026-03-05/rust-std-beta-x86_64-unknown-netbsd.tar.gz=f5a6a65f5bb5188aa04a60a41a61fe393342bf16c653bf0000a30195d3ee63da
-dist/2026-03-05/rust-std-beta-x86_64-unknown-netbsd.tar.xz=b12f4589d40c99a0b226a2783d8fc3e1e65e9cd53d9cbd25833e7381e05aceaf
-dist/2026-03-05/rust-std-beta-x86_64-unknown-none.tar.gz=acb373525161a1a4a4ea598fecf17cbe6bbbb05e7fa8e4caad55fe5a8307f772
-dist/2026-03-05/rust-std-beta-x86_64-unknown-none.tar.xz=6442f6794054a5b0aead34aeb0ca128490cd779a1884622710ebbb6270d1f206
-dist/2026-03-05/rust-std-beta-x86_64-unknown-redox.tar.gz=b5e739c2ecd4dae331d66c36dec8af0314afb08db7685ad5033f895660ba5a36
-dist/2026-03-05/rust-std-beta-x86_64-unknown-redox.tar.xz=87e8ac22d6be02fee1dc399ab8481e6e060c663e28262f9ec22140b2bb16a71b
-dist/2026-03-05/rust-std-beta-x86_64-unknown-uefi.tar.gz=5806c818b6fbd642fd781c12d41118fc26a188508537d7f682cc37451c33a8a1
-dist/2026-03-05/rust-std-beta-x86_64-unknown-uefi.tar.xz=62b76fd0a9d2f24eaec6f56dd0f27035b216092baf83e148570da33c6cd52d8a
-dist/2026-03-05/cargo-beta-aarch64-apple-darwin.tar.gz=57a6b7b1e222528ab2ad8b66d6daf4a5990a95ee8ad2cd5f4c83bac4339f4846
-dist/2026-03-05/cargo-beta-aarch64-apple-darwin.tar.xz=449cdd485bcb58cdac7503020ba4b2ef732f3e7278815344fe2d777903bdf48b
-dist/2026-03-05/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=d5beb91b8342731bac0361a9d15231b33608e73a2d28bc6b127e5625e4bffe77
-dist/2026-03-05/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=a3430d8099bb2c143bad2975cf49e06fa033cea11efed2fa43fed40b84757672
-dist/2026-03-05/cargo-beta-aarch64-pc-windows-msvc.tar.gz=8a82b5a203d3237e2e30165f03528128d3bb41283d678e57ad9de3334630b619
-dist/2026-03-05/cargo-beta-aarch64-pc-windows-msvc.tar.xz=c8a83afb8c110453301ff7f601019740c23d584cb421c940704ab185d548bc1d
-dist/2026-03-05/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=860889eae0f10c3143c2dcfba5b35d1f7ded8604469e98042999a7bb78a5d6e4
-dist/2026-03-05/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=3270668bfca382dec633acee3712db180dd7c3b630bb5cc9bc286b2244ae906e
-dist/2026-03-05/cargo-beta-aarch64-unknown-linux-musl.tar.gz=38d13b7cda22ef1ddd3e79c1df45eb77948849c7c68c91ea37930f3c13f310d6
-dist/2026-03-05/cargo-beta-aarch64-unknown-linux-musl.tar.xz=dbdefc6c3dce5ce89a8e0c19f827f83a0210a7f1a201452df1bc0dbf3d426c54
-dist/2026-03-05/cargo-beta-aarch64-unknown-linux-ohos.tar.gz=b76846af95a5ba516658530a929f82ef19549291c8cd7eab4e34ed1cb2aa19b4
-dist/2026-03-05/cargo-beta-aarch64-unknown-linux-ohos.tar.xz=c4ee178a645c51710612a363486c38581b04cc956bd5c1d1f966d1a66ba2ba59
-dist/2026-03-05/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=13e6504ac6059030b3e20c7a2a60902113625e7f1b313abd7a90751e44fccce2
-dist/2026-03-05/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=d232746defa606f9a37968da702988c81554183abb7703703dcc20cd5211b51e
-dist/2026-03-05/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=b19d4e616e98901ac089cd023beffa7606815edfc7e5a6abb94a38823eaae3a1
-dist/2026-03-05/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=814634baf493641407e0ed443938283159ebeec3530304e3c05163e85e96ac9c
-dist/2026-03-05/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=5cd5bfe43ef31e7dfad23beb4510e311c098057a46457ef8d123cb155e2370d4
-dist/2026-03-05/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=337087164aa614eeb8272e06a5414ab7d15682f7f4d7d4e12f5536ae704adcc3
-dist/2026-03-05/cargo-beta-i686-pc-windows-gnu.tar.gz=74ccaa0f31de099e43be9dfe0a7a0f00202b371954adaf4a20e2ff64a6f95788
-dist/2026-03-05/cargo-beta-i686-pc-windows-gnu.tar.xz=d3bbe5570c9740adfb0409fadac59a8bbcbbb52465d292e35244a8a0bd9e0121
-dist/2026-03-05/cargo-beta-i686-pc-windows-msvc.tar.gz=6087ac3a8896e7b75b8f1636a2cb8620e0d1ce486e0714e5644acc4e49e478e4
-dist/2026-03-05/cargo-beta-i686-pc-windows-msvc.tar.xz=a5c2a704fed42d167b6a5e7ca950812aefae0d9348a00870dbaf10cc0f85752d
-dist/2026-03-05/cargo-beta-i686-unknown-linux-gnu.tar.gz=4ac578cd52e61e3952d64d6b68e19bd9646c61cf5b809e225eecb49dffa21879
-dist/2026-03-05/cargo-beta-i686-unknown-linux-gnu.tar.xz=09e4af4d94c6b1625f4e747773f9a18cb13d1e457b90193647f9ba13f67d4c5d
-dist/2026-03-05/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=11771e0ed31948bc3d5ca53f71390913b778cab0a315b3a3e5a4610d3ee6541a
-dist/2026-03-05/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=57ccc21558e8da88dab76215ab8b16b167c3206a8ec33ae17c8a918e1f13d062
-dist/2026-03-05/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=421d40079b804c4653da7b6ec9d54151deaeb80426054a17c030687b581b275c
-dist/2026-03-05/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=d93be442c7f8dfea9ddc2d9e39bfcd5dd4a53987050acecd9582e012f427cc66
-dist/2026-03-05/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=a0fc2ced0638aff22501acd64064fb9afaa2c86771161dd3e0120d67a3124062
-dist/2026-03-05/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=6f5499e146e8ee4b70c27e28c98a7c33cf5848fa65a820ce1e0031142abc7198
-dist/2026-03-05/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=7b9ab95407e7b434382db442bbbc5702f68bb906098d67a065e02cdc2e063032
-dist/2026-03-05/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=93adc6abc694c59b07794839e6a39576c7250da4c4e20cf79f328217e960bd33
-dist/2026-03-05/cargo-beta-powerpc64-unknown-linux-musl.tar.gz=1bb8e52c3ea595ef87576cdff3fd95fbec0d2b780de6ffcbfca7c1c375f91e94
-dist/2026-03-05/cargo-beta-powerpc64-unknown-linux-musl.tar.xz=cc286dd918dccc2116c9b9e884cb8c439ace42a81fc183d6070d6efb728e7acf
-dist/2026-03-05/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=194a1542da15f0ea8a55f2b010a4f575a64c48233534b6e534e15fcbefea76bf
-dist/2026-03-05/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=1370d4178aeba0877508b2fd5578577c651df9e6b5bdccb613a3ecbb0110d4c3
-dist/2026-03-05/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=3f2c01f54dfd209e9a2c67efab0dde8027316c3f8a89a6a62324a02962d076e8
-dist/2026-03-05/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=d86ee2b482cd251e9a0dd31bb3a444fb73f23bcb829802e5f490864de15c16ee
-dist/2026-03-05/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=56c22f5dcfd7c248d99f5333cfb8cdc1c09f918dee31eb699b510778d447e86d
-dist/2026-03-05/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=2ef47d8a112bdd00be5e40a1a96dc53ab455254b3d9d38d67053aed7761d0b42
-dist/2026-03-05/cargo-beta-s390x-unknown-linux-gnu.tar.gz=9556a3bfa4204454be0ceb75fd552ef833501a2244557d3a77267cb6b4a9dd95
-dist/2026-03-05/cargo-beta-s390x-unknown-linux-gnu.tar.xz=c1ba7e3f8fc09f014bd6cd7248cbe01a1bab6648cb21352109d75d7e6393f341
-dist/2026-03-05/cargo-beta-sparcv9-sun-solaris.tar.gz=6f14015a29be4f56aafc8246038abf7547e2fc703fdc49045360dbde27d7ef19
-dist/2026-03-05/cargo-beta-sparcv9-sun-solaris.tar.xz=6cbc9b545e39f3e6485576557bcb80a28a888fd70ef5a64a66e3185e9c8202b9
-dist/2026-03-05/cargo-beta-x86_64-apple-darwin.tar.gz=c77c0ad2a353f6b0240b85cdaab3a9f568d0f998a25276c2d8d819ad55699f18
-dist/2026-03-05/cargo-beta-x86_64-apple-darwin.tar.xz=59ac9372a168a88e2b1bd6cac129c469957e2bd0d5bed93a4c6f0528106bf4cb
-dist/2026-03-05/cargo-beta-x86_64-pc-solaris.tar.gz=4eb565eb6dab8823cb5c61596fab232d24d7c841bce34ccb6b35eed1a0dfc9e6
-dist/2026-03-05/cargo-beta-x86_64-pc-solaris.tar.xz=e8a97246c632bd492cabc27a9ff09edc058b20db964db378eac93846d6d10920
-dist/2026-03-05/cargo-beta-x86_64-pc-windows-gnu.tar.gz=e2703b785aa0a3091a06b4273aadcff174f5e6c4b4117d10cd9e7f14539409f2
-dist/2026-03-05/cargo-beta-x86_64-pc-windows-gnu.tar.xz=f10b1254e240a3864137c03257ee674a6e8fb4b0d9dd50de234db001034ff705
-dist/2026-03-05/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=41f7d406df80d4c1a0abf610498a8d224174ab2706e1946b6a15663d6eef65b0
-dist/2026-03-05/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=dcf721bcc2ae8d3c08124317e45f51b0a41925b6e28a2046f2111c7aa983d4ce
-dist/2026-03-05/cargo-beta-x86_64-pc-windows-msvc.tar.gz=aa55c73d9e1f90378fbb61c6d1a487cd983eb5776f6f2e4fd8120b8341543420
-dist/2026-03-05/cargo-beta-x86_64-pc-windows-msvc.tar.xz=18062197a5422213c8aaf1cdac396145e3773f298789bf364f9665d6ef254f2f
-dist/2026-03-05/cargo-beta-x86_64-unknown-freebsd.tar.gz=ae7bbbbbe966ea68e13b1976e745c782ea5b649a7c541596bcb44afbe4b367dd
-dist/2026-03-05/cargo-beta-x86_64-unknown-freebsd.tar.xz=203a9b205262c90cfa04870d8e5233ab65bf6ad8840579194455917e50e51736
-dist/2026-03-05/cargo-beta-x86_64-unknown-illumos.tar.gz=ea24f15a151c3f9d5d0ae9d5b21c14c6570ad0ae1bc749c4367e65f96d010c09
-dist/2026-03-05/cargo-beta-x86_64-unknown-illumos.tar.xz=49ea2b342ed92263ff57b56eeb3b9762ad48ae06ea5cc50f60fd4643adbb0afb
-dist/2026-03-05/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=2ace7395bea67d5f8e336f1a0c96a3d0b6deea580600a5e0f55bc95253d46496
-dist/2026-03-05/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=3330ec521c6d283934f756775be28b827ed0e04ad9f584245d14641ccde72dfc
-dist/2026-03-05/cargo-beta-x86_64-unknown-linux-musl.tar.gz=5b212696aa5b7dcf7845b85145e2ed012eee2bcec25f7cb4224d665b84c2ffe8
-dist/2026-03-05/cargo-beta-x86_64-unknown-linux-musl.tar.xz=f8398a2a545b8e795c412954b8f18ae773c12a3542b20cac92aa1e1556a38094
-dist/2026-03-05/cargo-beta-x86_64-unknown-netbsd.tar.gz=2839e430b2c7b98c80eede1219160104462d2b46d6eb8b79967e43dde397c482
-dist/2026-03-05/cargo-beta-x86_64-unknown-netbsd.tar.xz=2e34688fbba817738fb3c5a34601c83a55ac563d4bf9e8dc58b1256e6aa8db3a
-dist/2026-03-05/clippy-beta-aarch64-apple-darwin.tar.gz=32c4d827c0aa7af3c1ce66e5689418e9accb1578b6c8843c7f5cd00adf7fcf38
-dist/2026-03-05/clippy-beta-aarch64-apple-darwin.tar.xz=b95cae5d7a22da58fef7e9e58820adf7b5e16ebce72b600379b907a57e3ed9d0
-dist/2026-03-05/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=c38f756f294133f65835c84fa57bff9c7aa9614ccf3a722ef8984b8b70ea5957
-dist/2026-03-05/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=96f38c6ef8c3b7459c45c4900ece7c9a32ae024eb88ea623dfaca6a4d0591b7b
-dist/2026-03-05/clippy-beta-aarch64-pc-windows-msvc.tar.gz=532fa0e4ae7d44501dd8b4503b84d55582ef8c4badd505aede9145329d73a77a
-dist/2026-03-05/clippy-beta-aarch64-pc-windows-msvc.tar.xz=19606687be0915392385ca118f9931955887e4e15e7427e631b132e42dfad13a
-dist/2026-03-05/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=36218bed1dbaeba27b450190862218c2e87af7b366575d4ce3a6688eefa70aa7
-dist/2026-03-05/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=04d10dfa623df3be0e9a2d8f8d03ba7b094fed0585d9cde34014d5b65c72e981
-dist/2026-03-05/clippy-beta-aarch64-unknown-linux-musl.tar.gz=c9286a0b79141c973950c3ad28b82c3c9becb15504dc632c8875181d206b5c96
-dist/2026-03-05/clippy-beta-aarch64-unknown-linux-musl.tar.xz=5fd10f23a7a6c652d26e53f7f4715d72fe97465ecc844a2e24bedf76df56230e
-dist/2026-03-05/clippy-beta-aarch64-unknown-linux-ohos.tar.gz=de3a8e799292a9bde717fdf1ac41bf1f6d773641f6d9f07ed435440f91d8abdb
-dist/2026-03-05/clippy-beta-aarch64-unknown-linux-ohos.tar.xz=9ff3c0639362d398c8c6b259094bc2e8ebf58318666a4fe35e38bee3e54d02e3
-dist/2026-03-05/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=c38ba3fb8e40b7a543d759b70f66b0000a61f418713b20a50e0070f8f360b799
-dist/2026-03-05/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=aeea0f32d03becd509df70bc83ea74590f935517979460c05886a08c2715a013
-dist/2026-03-05/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=6e23bf9dc2c5d4b17c42d90015772ec0136402e47d36b49ecfa11c79c246a54e
-dist/2026-03-05/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=7f0945519df5a8f4ebb17ee36fc582af022942e6a08e30d53f7aba449f7736d8
-dist/2026-03-05/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=cd020f9fccf3b99a2128ea4a2225d82eb1a4266a5cc0e7014d44c5d43a909712
-dist/2026-03-05/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=de4559a9437eb2db35dc44f9a0c60d847e5fc46b857d164c055a583904c3683a
-dist/2026-03-05/clippy-beta-i686-pc-windows-gnu.tar.gz=35bcc1f3d81eac70e8f3d1ccb085add8fab6b7f4e46b002e5b87eb4553326ccc
-dist/2026-03-05/clippy-beta-i686-pc-windows-gnu.tar.xz=03e68c1bcf261c8cfa4caf707f1a64164ef4b65cebd27e6aa977494c4915fdfc
-dist/2026-03-05/clippy-beta-i686-pc-windows-msvc.tar.gz=0be0ce91b176b60d2c5f372bf795d1b2a8c67254013b37d35cda10c358947881
-dist/2026-03-05/clippy-beta-i686-pc-windows-msvc.tar.xz=2856ecfe58311108e53d3228f979a7fbeaf686f9e6ae5c410442eeef3965a07a
-dist/2026-03-05/clippy-beta-i686-unknown-linux-gnu.tar.gz=af2c7821f78ff6cba5778fd127502c885bc1eb3890d5a700f31ea28cd3cd9e30
-dist/2026-03-05/clippy-beta-i686-unknown-linux-gnu.tar.xz=d33cdb0e15e8df422d34ca77267c765a6694dd342f6072aa1f495fa937126638
-dist/2026-03-05/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=6325829f43a04cf485b4d6293289d466003fa5bf55f98bca104d377385f6c5cc
-dist/2026-03-05/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=35a0e71198ed24f8d8258d343647c472c915bca007ae8f23122c636d2ecd3820
-dist/2026-03-05/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=1fddbbf7398a38013db3809eb29b62f828a8f8ca52ae183f5620fcd00d6ec4d2
-dist/2026-03-05/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=66fbbfc003a30ea6a9a4fb389a0e2d88b16bb347802e8e718cf4250af24ca3a9
-dist/2026-03-05/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=42a7be84be5beebeaadbbe7bb184a5a0679b63d566e44522c930d78c77306645
-dist/2026-03-05/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=b27c6822586427072c973425a917b249d29b9284467c2c28e8dc7a5a804b74df
-dist/2026-03-05/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=4c9b7ee30c127add6ff3ba6cf443546a30955e30ca974f06abcce13ca19a321d
-dist/2026-03-05/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=b17c9b434cf1b171b307a3de511527bfc08edc3164714981679d709dd3f81306
-dist/2026-03-05/clippy-beta-powerpc64-unknown-linux-musl.tar.gz=9f0eba1790ea3d3193bf1f10af114baea823266a2164bd7109204c87026e6121
-dist/2026-03-05/clippy-beta-powerpc64-unknown-linux-musl.tar.xz=8db967689337ce7019e0c5a2e5bea2e5eda896b477ee6606db69ceed1d478fd4
-dist/2026-03-05/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=4d65345aec8590ca95a5929a544ef165fd9fae3a513ec986198af29f3082ccff
-dist/2026-03-05/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=3ef1c6ee769fa586f2f9ec78abc66a2ed24695e9bf2fbf85290316127c46026c
-dist/2026-03-05/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=17dadf88ba335fb69a8a393580444e45a04719bf43ef6e893f3c2bdc7880960b
-dist/2026-03-05/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=eeba6019f7788bda6e353bc277d8ab7ae9b91ca2512ce81185e6d3977520d3ad
-dist/2026-03-05/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=524db9643bea13f5787adba2b1f0bde5dee45f414a4f0ae54f23083dcd4a1a47
-dist/2026-03-05/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=c2f5a81757cf04ae2f6298b79007673a69e044a45775b362b1ca98dd2bf96d6f
-dist/2026-03-05/clippy-beta-s390x-unknown-linux-gnu.tar.gz=a3441cacd2ccf3afa5c82fa5f2b552c864ecbd2abcd393fadeb96b4d6e5c3883
-dist/2026-03-05/clippy-beta-s390x-unknown-linux-gnu.tar.xz=ebb5d7b5098a004be056c6f5ee111c02cad679db9d8c4616e19d6f027506b43c
-dist/2026-03-05/clippy-beta-sparcv9-sun-solaris.tar.gz=a230e3330c2fc952c58d52b9aa118511b3ce4f441862770a4136a6aaa85e72fe
-dist/2026-03-05/clippy-beta-sparcv9-sun-solaris.tar.xz=88496d17922c9cc19c70cdceb35b81423047644ceaa2295e92effcc6829f5c7a
-dist/2026-03-05/clippy-beta-x86_64-apple-darwin.tar.gz=94a9b2fc9f16587cf41230fd56ba71bd66fbfba60c2c2b914f9a667791de1c4d
-dist/2026-03-05/clippy-beta-x86_64-apple-darwin.tar.xz=5cf79b63ecbbf627d164b24123db5595e5c9e82708c6d7d672a1ff9bb1463b9b
-dist/2026-03-05/clippy-beta-x86_64-pc-solaris.tar.gz=cb69b7d5743d43722e6eaa963272fd58f41b326f7724b701606a9409941a105d
-dist/2026-03-05/clippy-beta-x86_64-pc-solaris.tar.xz=ff191a1112e48bc07d377fe8f85fab2791b0ad2c74c22caef2f9770a459b706a
-dist/2026-03-05/clippy-beta-x86_64-pc-windows-gnu.tar.gz=59088e23e324ec220581e5e163106989268c6897552f2284c435782d6161c8b5
-dist/2026-03-05/clippy-beta-x86_64-pc-windows-gnu.tar.xz=36ee7120604df50e8e2568e7c048bdbf1180d4ef903330520175606be0ae531e
-dist/2026-03-05/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=973540bc6b85bb7dc972ceddbd859e86aa2fb2de92e0e418a2390b1135243f50
-dist/2026-03-05/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=ce07888ae00182bcd2fdc0a40c1b8d6a66a5513afda14ca2dd13b7954020b606
-dist/2026-03-05/clippy-beta-x86_64-pc-windows-msvc.tar.gz=c51dc3262c9db4f1d394ca39a7f28780258b8718c32d1ddef68c64f256ef3682
-dist/2026-03-05/clippy-beta-x86_64-pc-windows-msvc.tar.xz=067098b54ce15773ca62cfd75a2696a95e961edc5027afa6605d99d2d5a3ae84
-dist/2026-03-05/clippy-beta-x86_64-unknown-freebsd.tar.gz=54a7297c31dfd6e11a0f127a9d51f4e4fc8878c317e8802a21f454140fe9aee5
-dist/2026-03-05/clippy-beta-x86_64-unknown-freebsd.tar.xz=7eb5bb64c781be9ba6ca4da2576019c0aeaf06f03c0dd420b9b6a2ca0091c57f
-dist/2026-03-05/clippy-beta-x86_64-unknown-illumos.tar.gz=7abdf2a821441ea77118f21f4741d6841529e552398f88bd8f1d26ca277c3611
-dist/2026-03-05/clippy-beta-x86_64-unknown-illumos.tar.xz=8962472a92f36dffe4dec76f8a8bf7d5eaf27a0ee39eac1bcd05e40f6b12b9ce
-dist/2026-03-05/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=e517ba027f5a06456f20ba2229c7538bc4d1cb2f5f6a601189a08053d5d55701
-dist/2026-03-05/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=8c4f7f679154ea734bd73cda9ac8c79cd12cc273c1c9dfdc0611ab34197d4d27
-dist/2026-03-05/clippy-beta-x86_64-unknown-linux-musl.tar.gz=a52b54b33b5ea3f4d43be459b952344fbc812e79e6d9e2fb4d41f3741c4db75b
-dist/2026-03-05/clippy-beta-x86_64-unknown-linux-musl.tar.xz=ef778799a516bbc9b2947afe5660a6435ce2a8e011e9ae74c7927e9b485d1048
-dist/2026-03-05/clippy-beta-x86_64-unknown-netbsd.tar.gz=19b24bb8f9df0c52461f692c365500a0f2b9c3f988d2ddfab017f152c766eac7
-dist/2026-03-05/clippy-beta-x86_64-unknown-netbsd.tar.xz=96d2797ef4d847a849a5dea25114c769d2671cd7ff5e2c0cc06902529d5ab7ea
-dist/2026-03-05/rust-beta-aarch64-pc-windows-gnullvm.msi=08afe58fc6635c05f6f62cbb2b6fa0ff0c747c456cd86780376236bace4d6a54
-dist/2026-03-05/rust-beta-aarch64-pc-windows-msvc.msi=8e6a83a419d809ac8621e266f72bd263a63d75dacdf38d7a7f1ddd3402a53893
-dist/2026-03-05/rust-beta-i686-pc-windows-gnu.msi=7989892eecd5378bcfe40609fd27592410fc658334cbd8142cd452f7bac00057
-dist/2026-03-05/rust-beta-i686-pc-windows-msvc.msi=4b7e475e8e52391b439c4c081facbce68ac369d7b09f6080762c6679894bfa48
-dist/2026-03-05/rust-beta-x86_64-pc-windows-gnu.msi=3f4714f30c3ef169bdf5942856fbe5599d7c63d16cc95be6d86e0d2fd837a596
-dist/2026-03-05/rust-beta-x86_64-pc-windows-gnullvm.msi=a2e1941f860be18fb26ef403f3baea3619827dd268e705e895f6d6d9186d2658
-dist/2026-03-05/rust-beta-x86_64-pc-windows-msvc.msi=e03da5bcaa71b11bc8d8d748da947af0a4d6b21ec7991b6c3e383556cc00198c
-dist/2026-03-05/rust-beta-aarch64-apple-darwin.pkg=809c3facc61f153caca8210b59340627b263b66fe6889456e43b9d080431174e
-dist/2026-03-05/rust-beta-x86_64-apple-darwin.pkg=0146d25460ee2dedd98718b25d6f394db8b4c7f0d447c58fb34c120a8bb8369f
-dist/2026-03-05/rustc-beta-src.tar.gz=7c1b2a4a591ba994cfb25b22675a749914eeec0d5ffd4e5b026d14067fab09b5
-dist/2026-03-05/rustc-beta-src.tar.xz=9f5053396fe6dced53ad64a463fb727ac7ea9294544db7408f5dc2005878c008
-dist/2026-03-05/rustfmt-nightly-aarch64-apple-darwin.tar.gz=e68b2b292526919eba5dd9f5ba441ae9b8f4ac823dd10a4d7b47bb872d3a21c2
-dist/2026-03-05/rustfmt-nightly-aarch64-apple-darwin.tar.xz=cb676f18bf6c90292e04effaa4d8401ea459ce93b66b5b737100aa103cefa402
-dist/2026-03-05/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=92e2a069130fa5b13170123e0d499800c0cea8e38fb4e9cc6b59ad1225894dba
-dist/2026-03-05/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=798f752757db5312f2d78699be4f031cc6a5695c791360e1bb1d422b19d69f7d
-dist/2026-03-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=fda191f803e26ec5eddea71c74e81763aeb3cdcbb8ff964ea8a85808e8da797b
-dist/2026-03-05/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=3fee26f428f04b1f5d0208bd3bc6f14c0cbd6d909505e77cbed642871efa606c
-dist/2026-03-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=1bb0c5ebfa96ed19cdb6bafd275ba770540b1c150c2dd92a34d810914d64c8ac
-dist/2026-03-05/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=82b607f58f9e87e9095b05266ed573ce58a0192201151c31d15a0e38f59bfabc
-dist/2026-03-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=6748cabbdec4552318a15069ba3cfc15d4c799b48996d95640a62e37a272d272
-dist/2026-03-05/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=54cc148fb9df3d76b2291e9492308cbd4c529c20240b43110fd0ab6d4cef4c35
-dist/2026-03-05/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.gz=962c11a988df29b7c7222b36a79aa4cf3ed3e7f9e5080bfc11e2bfce4bc914b8
-dist/2026-03-05/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.xz=2d051b5a08c069af69ee278ad0a773b5f3ef1ff25b13d124388ec4dd0c9302fd
-dist/2026-03-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=f9e96db6e45ed1044910213944457f8c1339e3486f0019ec89d646ab7d1889f8
-dist/2026-03-05/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=ae2467f98c25e7cb8f2848ff407f5d9906ba18b14ff170dac44cc525f9e4037b
-dist/2026-03-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=307d16c5eb1badd7d345233eb585fcba1e69a4060eb97bd9dbb6595541475fd9
-dist/2026-03-05/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=cf7ec96a6391a0d5bec32163f505ad13e629a9bbf73b4825a435048fec6f789f
-dist/2026-03-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=5a8a2ffe2d164655fdf5074a1f51da65b6ceccc9796324a90666677e7cef81cc
-dist/2026-03-05/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=6b9790ee4854caf73d4e230447f51ddfcccf74f9730d33d25b9929fd9d683309
-dist/2026-03-05/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=112ab32d3983596bc64040965c3e04cf850122ca81b20a1153ff53c28457b2b9
-dist/2026-03-05/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=40b5a446bf57d045306663e77aa03cab150d6f17e711f11175a095df5248a981
-dist/2026-03-05/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=ceadd70ba7ff5c3d91ee7774dbacf6017a16bdea5ee8870a7090d56824d983ab
-dist/2026-03-05/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=cc0b1b3a42888ebd54df2ac6b1f715bb348879b65a7436612c7e6975a9a6f2b8
-dist/2026-03-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=d7fe2972190a304deb4ac3824e8c2164b216c68c5b7c9b94610abe8e2bd0f3a1
-dist/2026-03-05/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=07cedc3db3af1cf5912f35b7703762bcbdcb936639b2007ffd83ea9f897e977c
-dist/2026-03-05/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=75411629c837bd6920d4c41caca3ef43c89e1f60fab3fbf603d073c379437e68
-dist/2026-03-05/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=ff352912831a559a6c5a089b3b6f172963be1653c21e47d65546f07be71bd89e
-dist/2026-03-05/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=ec2f4a5afc9e72217c3dff1c96587f06572b46c5dbb7d32b7dfb7105d0a2eb7d
-dist/2026-03-05/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=63085f7704f7c272d8923428fe8186cb28d683d94312fe42d9f36b548d1e8ad7
-dist/2026-03-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=199ab80531cf416a398954eca5b31a1206ecebdd7b09fbfe7c532d842388b7b2
-dist/2026-03-05/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=7b3f8936dde840abd4519a3a26de92fc4d1250f9611137bd0ff8528e2ab3b064
-dist/2026-03-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=7e684003264eb2392e920cd955af7fc263062d4fbc428ba0dea7179d6d47b83d
-dist/2026-03-05/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=905caff6ef52c86124edfe5f7c52821badbc89f358816443f52cbb7d1497d93a
-dist/2026-03-05/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.gz=7f03bb50fccc0a8aa1d8c1e092f6b06fd7dcf885d4d66ebcc90daf69d98c470c
-dist/2026-03-05/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.xz=ca3159c24af1a93ef3b3ec47902a0aca81b288b39f105acb6d337e7d88eb1c2d
-dist/2026-03-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=6affa4a366183dc49b687fd5c2867975e6b6f74f9a1cc6999392a46211a0e85f
-dist/2026-03-05/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=1053fa8fe7ee40eef933945c885ed6e3a7ced2beb1fd0549bc475cf30ab66113
-dist/2026-03-05/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=ade7c0d35f1da32d010e3e1787aa1d505b675bb72208c2141149cc82cb53b3ff
-dist/2026-03-05/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=535c441f349e3b2d14924bb308bf528c16d2e83f5a76755e2747b23ff3a94721
-dist/2026-03-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=bb784c051a0472dc1f89128beb012d1ffdeda4a213fd7cb4b3f3485e4ad9fd7f
-dist/2026-03-05/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=99fdbdee5bfa2c1071347727448cffbbe3a37fffcfe3f58fd5f21585ced2280b
-dist/2026-03-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=074564c8ee6f4e01adc5d5be5ad569147e6c14f075066e3739a23a3b1516bd9d
-dist/2026-03-05/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=420107a978280b0a1855d3b6b7c2bf52feaf806bc3c027e5948755ad31962ee2
-dist/2026-03-05/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=d391a08020fdb9e5a9dad91d48015185e376340d96265e82c3ff1dfa9fc50464
-dist/2026-03-05/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=6730256f48b4ef1e2f955bb40adf9c4107d413d41b5c96296cec9bdc4e464fce
-dist/2026-03-05/rustfmt-nightly-x86_64-apple-darwin.tar.gz=8a68468f5bb8e65f351239307d7f965a2c5824a60535a399b36786c2bb1419b5
-dist/2026-03-05/rustfmt-nightly-x86_64-apple-darwin.tar.xz=939077ad91115420b116a4b14e8d5b3c06ecee86a42b8ecd9451e551b19c8d2d
-dist/2026-03-05/rustfmt-nightly-x86_64-pc-solaris.tar.gz=a9938bc124c52b114a9b7c4a90d731a17c30bed1078b42e87e5bb1a62d49deeb
-dist/2026-03-05/rustfmt-nightly-x86_64-pc-solaris.tar.xz=8588faf0a7948b555cb585ecc547d69dbf7a03e51f520165ad052c0d74996e45
-dist/2026-03-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=a914ae0e5304dd6a1a3fa72b86e0de7c564c61470082c7e25f457335022c2517
-dist/2026-03-05/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=6492952e004f9ed6a35eb7454a84f4c4d595e197d8b31c832a2f96e808a7241c
-dist/2026-03-05/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=d611d10c86712ed57dc7e7db1c0cec3b0660b7d95a60ab6dfe7253dc7e88c379
-dist/2026-03-05/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=1f00cc4640dfec1694647f3ab7a18e3c0b15cccaf45eaa4fc10992044ce556cc
-dist/2026-03-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=48b36ad2d3df621ba56f0c092e014d8dc03abfb9af256169a0e309f11aa393a4
-dist/2026-03-05/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=46b61c73550605e0eccc9da9bb26141a56fa981f01432f1f1fcfcc8c755ae1f7
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=9ba9bfa29fb6f5a553180046cfd1b348fd2abce3997130eb063c7707d6e440f7
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=ef9e51529aba4607b55144c98d97f830f660addfef28aa51d0e1afae5212ab09
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=399f26b755ac7773d2bf5be27fe1e7fc8f74ce1af48250fc2ad8278de457b212
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=ff912b75d3f9042631c6536f037d68fa645714fe05b94eac6541f67d2e56d47c
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=fee5b8e5619b5ab9e1b53771e775b0456254e50c08cbeb032184491b77bd28e0
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=bde94b7cf7038ce8e8cf9f0215abe66624a22aa64437c02c72331ea86951c685
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=c13174e759b8546ddd7a998228737714ca58e559069f560bc89235dc6ca0386c
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=b90a54783e5514d739828100022beb88a721586b579f1e868d98d223497f3b1e
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=64487e30e104a34c89de7dfbd2f55a0c8c04750520c69c5076adcc870b1bd8bb
-dist/2026-03-05/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=c48d3dbf294d4bf9a7f7d775d57342fe2f4b912ac366beec43aa6d7aa861afe7
-dist/2026-03-05/rustc-nightly-aarch64-apple-darwin.tar.gz=1cc140ed9ade9e0797c91ae9c3e8796a5a097c90044d11fb7f6b7472e5198076
-dist/2026-03-05/rustc-nightly-aarch64-apple-darwin.tar.xz=d52a4f380fe5fe17c361f39f913062cf9d8498cb8a8f3d9f21a4280564b87123
-dist/2026-03-05/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=90e41e28ff254abf0eba0daf6c1a514125c5069bffde1edec390f1149cf7d1b0
-dist/2026-03-05/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=86bf30f294809011b2e2c40f5246405b230d2b5cbce21e28e5b582a6832a7cea
-dist/2026-03-05/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=590a16846d0fa0e4ea8c9c130f5653bc27669114527d2cbdb1ad407a48f5f60d
-dist/2026-03-05/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=4e7a34abffe1eb6e7119c43d4a79893abcac38c4090b2175d24c3d9156f71dc1
-dist/2026-03-05/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=ebb0d66ec5c6f5ad70663110e976ce7d43ebb3920eb0a4e1b1201994c03b9bfa
-dist/2026-03-05/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=88bcbec30877561aecb88ad475e96783c99cc525dbcaaecbb321c158c32cfc62
-dist/2026-03-05/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=e6aeb296405e0e94b7e966a590397085ecb8a31fbf162be2d568dac9c8b324dd
-dist/2026-03-05/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=a74f82126979cb77099e4f9499822c11a39507d71302dd51e483011ff88d28c4
-dist/2026-03-05/rustc-nightly-aarch64-unknown-linux-ohos.tar.gz=19a50ab74e4c1dad4c40402a6047730fd4529808a9c8eda4992517178631e2e4
-dist/2026-03-05/rustc-nightly-aarch64-unknown-linux-ohos.tar.xz=ffadce5f79c003218be6eb87208fbf641ccf69b93bce0356e1355d62e09ae656
-dist/2026-03-05/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=aaac22afb9b1ef407f588404a65462b406d98d444ce8a5f5db1f2bfd7e7defbd
-dist/2026-03-05/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=2a0b146e55528a5b47c5ff4ccc6b221e721e1a3a704a49618d0219bb85fe1a1b
-dist/2026-03-05/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=beab02beed24871b275814d214e6a35ce6ad20b1f23eba11f2ff1f0999b81f0b
-dist/2026-03-05/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=b3b2f5ff0a0363f5da8f75d8dcfc3032bb56feff6f85fe02151ebb5c6934b9bb
-dist/2026-03-05/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=d226f8ec83d863c1de1c8a869c0ed39def5c37ff15e8c5c3321fe938eb2dfe2e
-dist/2026-03-05/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=1c31fec36badcb08942c285918b49ae2eb83c84233ed62dfabeeab483954bece
-dist/2026-03-05/rustc-nightly-i686-pc-windows-gnu.tar.gz=530a9826095bdb19cd08f7574a442aff430f288eafcfe3af7d67a1c05f7893cc
-dist/2026-03-05/rustc-nightly-i686-pc-windows-gnu.tar.xz=75c12c03203a15528f8bee21a9a91b68fb42586a47d578940363624cada99b03
-dist/2026-03-05/rustc-nightly-i686-pc-windows-msvc.tar.gz=70c9a0389074801195ecef5ea2c54c146f1e44a560cdc28cb0e0708951c83c27
-dist/2026-03-05/rustc-nightly-i686-pc-windows-msvc.tar.xz=3c275d6fb85bb4062d8ef74906e03e030a391639782292b27b8f3cf75782ada6
-dist/2026-03-05/rustc-nightly-i686-unknown-linux-gnu.tar.gz=c6e2daa18250b1b54f6354405ff337e06611a87a65f8171e9aca9eb073523460
-dist/2026-03-05/rustc-nightly-i686-unknown-linux-gnu.tar.xz=313a837f74f788a8ba0406deea4362a406d1caafab33e215cd7f527cecf76849
-dist/2026-03-05/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=8978ea4c8c8f3fcdcd069a1e0df9ac457cddc1ca7ac01c59083e47ff1c957c8d
-dist/2026-03-05/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=a3be5275e2523d7cfb1d08e46db414c3c351743b87bc6579f666d124ab8bdeee
-dist/2026-03-05/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=7249ed32ade44739209f9a28cfbeb9e4d1242b431528567cfbe8f56b80653deb
-dist/2026-03-05/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=7e395037d4d0695701a74c758fc48606b553a42bfd48534f6f2b7bbf480e2e0b
-dist/2026-03-05/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=6e25c8fa0c20855c3bab253c95e882b56ab4e25b81400f60a577d55faef2483b
-dist/2026-03-05/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=92ce678053ad13dbec2d1fb8bc88c524326b9a00fce5820d41bf4409e69d4d90
-dist/2026-03-05/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=756472d5ddc4f6fe82364538b528a058c68c87367fb7f3df63efbc46949ef2c0
-dist/2026-03-05/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=9edbf2a91630a7a4e9af1ba70a353b8b5a828864bbcdeb5660f0db3ab35a189c
-dist/2026-03-05/rustc-nightly-powerpc64-unknown-linux-musl.tar.gz=05c2e2ae8fc194e21f4d6add34f6275484a4fed79634088b8e98a57f6b356bb8
-dist/2026-03-05/rustc-nightly-powerpc64-unknown-linux-musl.tar.xz=ac7ab3865ad8ad80d984dc25fa43ca6c393a863eff2ca6d6875e48d06ecaa3d4
-dist/2026-03-05/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=ddfbe0ab2e5ce9feb07ad38e5d1d3306caab7984d93062c1e8516f6c13d5ecca
-dist/2026-03-05/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=f3db3420bcab694e426fd66aaf7343f52429877ea4b0949977aeb72ecdaccdc7
-dist/2026-03-05/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=bf29889b4ce6e0e9ed505db3892e5e44001c2d35a655f81e42d804eb8923df32
-dist/2026-03-05/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=1da514153649cc32a98a96c669a3010743ca799a979e4d4af926f778f77f1d93
-dist/2026-03-05/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=126224ede47d98027afdd16eea4548f48883675b773e43ae6379ed8b6e2f2140
-dist/2026-03-05/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=8727382f858f4cf043f7fbcaf38857422c1eb18cfec72b8a2bd5399928983aa4
-dist/2026-03-05/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=27e7c9c68936945b8d4008aaabf1abcf0ca6c2a969384e448798f0f901360e46
-dist/2026-03-05/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=6a4bbc5a65648bff0cf0512a9e72f88d5e9eeeca4a4580c2f28f5d95e6152221
-dist/2026-03-05/rustc-nightly-sparcv9-sun-solaris.tar.gz=fa3c1c7c1e3eaf8be18a816e95c0f343b004065360e9d376695e56a3972b3bf4
-dist/2026-03-05/rustc-nightly-sparcv9-sun-solaris.tar.xz=e4bf12cc38be7431f19c7e291ccbfd410a0555314fc0e4099073cc879458efe4
-dist/2026-03-05/rustc-nightly-x86_64-apple-darwin.tar.gz=808e4839f09c0252c10aeb54276695f1e881dde4d1fe9d8583743fdb438f7a08
-dist/2026-03-05/rustc-nightly-x86_64-apple-darwin.tar.xz=7ac7a15dfbacf5a79ff0f1b596828f178327df77883d7a4af76b7abdcde4cd9d
-dist/2026-03-05/rustc-nightly-x86_64-pc-solaris.tar.gz=d4731e54154d2fd0c93ffddc5e3aa4ad74280b6978f7f3f58afc274cd1c410d1
-dist/2026-03-05/rustc-nightly-x86_64-pc-solaris.tar.xz=a5f5be4a5819e433dfbafb2ed4edae7f44b3d0de04610e7543279a3d0f88546c
-dist/2026-03-05/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=5ff330a7d68a8ddbd2438686d74ac8ae9e88d5a638f61e8f6e49c3669322f18d
-dist/2026-03-05/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=58c255026ed3088685aa2716828b21ac1e0537aea099176da9a55511e7e6e1c9
-dist/2026-03-05/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=75bab5e659f7d88441390b02a5f51a7768ebde0ec0c642a669da88367b2c9ed9
-dist/2026-03-05/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=2d60e6f303301b74627d7f222a8a5b946c07e0011a060ce86a1df0807d127b80
-dist/2026-03-05/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=cdea2da52b50aee1c460eebb28fe69a2c50b23540aa4e0471c30b15e3670492f
-dist/2026-03-05/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=f314218a65ce441498b988c29ab8f8f79d65d3c4184d4d99fb483b6f887f1505
-dist/2026-03-05/rustc-nightly-x86_64-unknown-freebsd.tar.gz=741e4cf53e080c3d063e7af230894842a4d3306af0984ce189c1b9da1b632883
-dist/2026-03-05/rustc-nightly-x86_64-unknown-freebsd.tar.xz=1f5b1a0f0c51da513009d6040b16b9e3cc40ec753a921143280d2fd6ee9db0b2
-dist/2026-03-05/rustc-nightly-x86_64-unknown-illumos.tar.gz=a55975f8a4547fd0bfbb0fdaa67dbfafba606d3016b0038ea6a6e7a013e10fcd
-dist/2026-03-05/rustc-nightly-x86_64-unknown-illumos.tar.xz=eb3e9776311af9c99de8f9a041247e94168797f1d6dee99f6ecaacbbc181381b
-dist/2026-03-05/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=fb153dccf3ca91404d502c7cbac9eb7374cde3a6c0838a46c8308a52ef67ed4f
-dist/2026-03-05/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=cda6cb941296a57229610ad32fa48c3df8408e8dddafad621f9f3e663e3b9868
-dist/2026-03-05/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=170926fba93656f78318cb26e0cdd8cce63a51b45ac876a0126e2f3a8fba6e61
-dist/2026-03-05/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=b1a7eee40476f172263c75c12c80797e982534fa85f704aaea762fb58235e06d
-dist/2026-03-05/rustc-nightly-x86_64-unknown-netbsd.tar.gz=b3ca488ee4a2b94e774e41018c11177f8cf212c10711fbccfd547711269ddbbe
-dist/2026-03-05/rustc-nightly-x86_64-unknown-netbsd.tar.xz=05bb7747133d824768473ec6619acbfa673d7996c697314e12b7861ebcbae157
-dist/2026-03-05/rust-nightly-aarch64-pc-windows-gnullvm.msi=aa745e99ed2fff3b3e9971cb877b50eefb7ec7b583341e56d15ff731471e09e3
-dist/2026-03-05/rust-nightly-aarch64-pc-windows-msvc.msi=e4f745b5e034bfa3f3b131ba161e51a4461c98968e54d0180883e2b60c227027
-dist/2026-03-05/rust-nightly-i686-pc-windows-gnu.msi=0ed6c3fdc7e64c629867ca746ba2581ff7441c3fa38ea5492f483e4166c78e1d
-dist/2026-03-05/rust-nightly-i686-pc-windows-msvc.msi=f766902a3563476dff0effb43b94c87d6630ee3c6a98de71fe73c9c6633d85cb
-dist/2026-03-05/rust-nightly-x86_64-pc-windows-gnu.msi=22cdd435bed4b20ebe4685c17ee4536f723f0f6b742fc744cb89a01cec66c9b3
-dist/2026-03-05/rust-nightly-x86_64-pc-windows-gnullvm.msi=dd0940ed9dd2de730dabc6298fd6d85a2c0ce46679863ac7d2b6e06c24dfa564
-dist/2026-03-05/rust-nightly-x86_64-pc-windows-msvc.msi=8c82372d71b9bfe9e6e70b391633409cf38f3409ef1d7f7851623ceaed721597
-dist/2026-03-05/rust-nightly-aarch64-apple-darwin.pkg=37504436eddf5f9ac1c493caed773eb7bef0839d0aef5bef770a392a042a4545
-dist/2026-03-05/rust-nightly-x86_64-apple-darwin.pkg=5b00f8e416966e84a5b8513b1f9990f790e921056e4bac8b898fdb00efcf371d
-dist/2026-03-05/rustc-nightly-src.tar.gz=75518893121190cd6716780637373d437c2d09b0dc49fa49fd90b69c1e5f315e
-dist/2026-03-05/rustc-nightly-src.tar.xz=74bae911bb195af3de63dd0d9f5c8c2848093bfbc6bd9acde4aee4122be0a5c7
+dist/2026-04-14/rustc-beta-aarch64-apple-darwin.tar.gz=35f25ddeafd7e641a8ffe09e5a84a132d4fd6bb471e09ba21a63b38f570bc715
+dist/2026-04-14/rustc-beta-aarch64-apple-darwin.tar.xz=473e64fbc9a2deac6f46b31edf71fc603cefacca8717be50c24d43a3f83f08f4
+dist/2026-04-14/rustc-beta-aarch64-pc-windows-gnullvm.tar.gz=07e340e93aef14aa31589d9b943f378a7f14161ba0aa22166f0088b23815a9a2
+dist/2026-04-14/rustc-beta-aarch64-pc-windows-gnullvm.tar.xz=c02bc76f45b04abcfbd8b1e3dadceda3449ece891687c269b76d4454d7842081
+dist/2026-04-14/rustc-beta-aarch64-pc-windows-msvc.tar.gz=4e7825713c1669ecabc919008038f6ccc43058cb28f868f934cfd05d4b1933ea
+dist/2026-04-14/rustc-beta-aarch64-pc-windows-msvc.tar.xz=8ab15aafba975b1bf9d23351bd79c166eb8373381095d62a711ae5b1e47f293e
+dist/2026-04-14/rustc-beta-aarch64-unknown-linux-gnu.tar.gz=be0ec6c0b1902dd46dc58ce4f8f87ac2c5e2d099413b0b591276f6faa340da4e
+dist/2026-04-14/rustc-beta-aarch64-unknown-linux-gnu.tar.xz=2b08bdbce7d9cd7278abf4842152f3957a1beff5d2c43814d0c6ac8f12825c55
+dist/2026-04-14/rustc-beta-aarch64-unknown-linux-musl.tar.gz=377a556df12cfd34bae6eeb7f86f9e698240172397c54faf0217a682a3149d95
+dist/2026-04-14/rustc-beta-aarch64-unknown-linux-musl.tar.xz=d9794218a33e6d4ca77c15b60484c889078f82652a5ee7a9077aac897419c978
+dist/2026-04-14/rustc-beta-aarch64-unknown-linux-ohos.tar.gz=556e659a00cfab1fcc383b220588c58409ab7173350d0fab723f355f38d8cdb9
+dist/2026-04-14/rustc-beta-aarch64-unknown-linux-ohos.tar.xz=25b78160b0beedc1fe55eb2012177c8c9a03bd515f2619a301a1b7a996d52ac8
+dist/2026-04-14/rustc-beta-arm-unknown-linux-gnueabi.tar.gz=da8ee89c4864aeafc89256f49f9d40371bd1dbbb2b91553176d2aaa51cfa4a5e
+dist/2026-04-14/rustc-beta-arm-unknown-linux-gnueabi.tar.xz=c62ac733b962cc8dc559c17aae4bb55fcd1c2d5fee93d04a47591a7374523e7c
+dist/2026-04-14/rustc-beta-arm-unknown-linux-gnueabihf.tar.gz=c042154d4dc18b8fdcd9734d60857d763d34a56f794a1f9a01c1d9b721145474
+dist/2026-04-14/rustc-beta-arm-unknown-linux-gnueabihf.tar.xz=891067bb73618e7e6ff113c838dc0a564fba2941f12613330d26ed8cc5ede956
+dist/2026-04-14/rustc-beta-armv7-unknown-linux-gnueabihf.tar.gz=68364bce32e6afea3041cf8c476b758530237da26000c3b413faa62a728333cd
+dist/2026-04-14/rustc-beta-armv7-unknown-linux-gnueabihf.tar.xz=21e91d05d546da1e98b256b094e1fb59a9a242fa599c3a664a499a90376de45f
+dist/2026-04-14/rustc-beta-i686-pc-windows-gnu.tar.gz=bd4b9dc494a5adf72743209d8aca90d24192583c3eb9977465f052153cfd29fe
+dist/2026-04-14/rustc-beta-i686-pc-windows-gnu.tar.xz=7577925f53dbc54a2872c702a17e7a1462c4fd6611b3daa12d38f4d08c0d5cde
+dist/2026-04-14/rustc-beta-i686-pc-windows-msvc.tar.gz=709cf263932ab4190afde559bdc0862a432df6ab7e30aa4e34d3b4148a4d5bff
+dist/2026-04-14/rustc-beta-i686-pc-windows-msvc.tar.xz=63b8831ea62b767007808e477298bda0acf31528f8ca7ce0de4c31890b9ed6b9
+dist/2026-04-14/rustc-beta-i686-unknown-linux-gnu.tar.gz=fb5d2be390ec9e6355698716f5fa292b41626a737f245dfb6c9d8c118cc3798f
+dist/2026-04-14/rustc-beta-i686-unknown-linux-gnu.tar.xz=bf11c8a24b4fcf42b8ea23a941527c1d0060f222c1870aac4175a924c449ccdb
+dist/2026-04-14/rustc-beta-loongarch64-unknown-linux-gnu.tar.gz=61b6e6c27e233bb9236215682c2e452074af77a5d383a76fe597913713ff3474
+dist/2026-04-14/rustc-beta-loongarch64-unknown-linux-gnu.tar.xz=1f7b6574bd9c8f3c58d854ef432db4c8c1007fdee14c7469966f5099aa05899c
+dist/2026-04-14/rustc-beta-loongarch64-unknown-linux-musl.tar.gz=b02f0c7e4c395768286626180f5e216d5dc6cb6e4adb71f9b55ab3d0e5c50312
+dist/2026-04-14/rustc-beta-loongarch64-unknown-linux-musl.tar.xz=1513939ceb7afc3b7447af603b3243efbf2cca37b4b098eb9f3d5088567c701c
+dist/2026-04-14/rustc-beta-powerpc-unknown-linux-gnu.tar.gz=57499fe1370d53c02ed33ea3ab0cd6baf131a6540b397c2f09916299c819923c
+dist/2026-04-14/rustc-beta-powerpc-unknown-linux-gnu.tar.xz=7680b0b82da4e15cef8d934ef5cd335c7153148f43b42757b9558f94429ef016
+dist/2026-04-14/rustc-beta-powerpc64-unknown-linux-gnu.tar.gz=d8caa79cfb8bc32f6f03c6a36724ba514d0e4df1e593f4ec5008952f4433ad2a
+dist/2026-04-14/rustc-beta-powerpc64-unknown-linux-gnu.tar.xz=d81a68da3d62ffbd0696d910918617d3595460b2c96001514f8975f6d7888e83
+dist/2026-04-14/rustc-beta-powerpc64-unknown-linux-musl.tar.gz=5de50635b8b3a30ebcd1771510e443b5937aeb772ab072e4ffda9994c9001983
+dist/2026-04-14/rustc-beta-powerpc64-unknown-linux-musl.tar.xz=6d80c9118b3b49393c6b0d00112cc4007f1edaed072e2e552dc9c610ca15eb6e
+dist/2026-04-14/rustc-beta-powerpc64le-unknown-linux-gnu.tar.gz=b3fe7785ab29c9bd9d7bd3e7dec03f9246573c9cf398363280341d447ed39c94
+dist/2026-04-14/rustc-beta-powerpc64le-unknown-linux-gnu.tar.xz=328679b15b417075d3de53c6a6265e7cf5bd4c8f364ea43e710490ba00d433eb
+dist/2026-04-14/rustc-beta-powerpc64le-unknown-linux-musl.tar.gz=ed6dc8119a3f7ab3377b2b9544ba5dbabb7e63dc6a49f8b4d73a61c0ea80d4b5
+dist/2026-04-14/rustc-beta-powerpc64le-unknown-linux-musl.tar.xz=cf7a33c3ff04e20f742b0ed412a32c8c79262efa9bffb32f47ff03d649c90beb
+dist/2026-04-14/rustc-beta-riscv64gc-unknown-linux-gnu.tar.gz=932d92f0697bc41c4389d4974ba99f748d1a3fcf8f5c1e8d9a8a53a02cc1d009
+dist/2026-04-14/rustc-beta-riscv64gc-unknown-linux-gnu.tar.xz=4570f362bf9e98cb0cac2ccf6e18f9a368bf48890b16f210b5ef859ee48fabb4
+dist/2026-04-14/rustc-beta-s390x-unknown-linux-gnu.tar.gz=03200e8cbc3e1fbba6134ed493cb14b09ca991c4aeb6086db9ee550fffa1d7a6
+dist/2026-04-14/rustc-beta-s390x-unknown-linux-gnu.tar.xz=d5650e8231957fdf3690aaf82b9537f0b62a5d0ee4efed72e4daebef37f2ff17
+dist/2026-04-14/rustc-beta-sparcv9-sun-solaris.tar.gz=73f228287087fa532f5044a11cc1aedc3378ab1afc965bdc84e53994100525e7
+dist/2026-04-14/rustc-beta-sparcv9-sun-solaris.tar.xz=010660cbf726fb142a9a6d3543963118866e0c4b4d52c2948fa9bee254a418d8
+dist/2026-04-14/rustc-beta-x86_64-apple-darwin.tar.gz=bbc772f0cd4a39df28611eeee0a0593ab43511ae67907bb2e984887855d7bcc4
+dist/2026-04-14/rustc-beta-x86_64-apple-darwin.tar.xz=e27070e6b35e442b86b2a4d6f8e0ed8f415113f3bd053fc4368fa9fe4e82c674
+dist/2026-04-14/rustc-beta-x86_64-pc-solaris.tar.gz=01520a9bd5adf08224f09e4d1e61641a87c54e091daea7269a5f259d5c9fea3c
+dist/2026-04-14/rustc-beta-x86_64-pc-solaris.tar.xz=41cd1a0146efbee090a0e3a2520413e27c4bf68889d61ce149bcf2a40e65dc73
+dist/2026-04-14/rustc-beta-x86_64-pc-windows-gnu.tar.gz=e6896b94e55f7ca6b6321ec699274dfdee1dc463c6ec6a693403c439f9337352
+dist/2026-04-14/rustc-beta-x86_64-pc-windows-gnu.tar.xz=bc45a96370da93dd620434a5ba8137634b721d0ce4162daf88c437d3cbfc3115
+dist/2026-04-14/rustc-beta-x86_64-pc-windows-gnullvm.tar.gz=5c8aea2aab8599728bb90a8be7b478c48419c17a4debede8163db7329ba0bf17
+dist/2026-04-14/rustc-beta-x86_64-pc-windows-gnullvm.tar.xz=8dcb3daa1e82820559d9a0669083f76b10333d1a048954d2e0299e11794d1380
+dist/2026-04-14/rustc-beta-x86_64-pc-windows-msvc.tar.gz=9996f298c0f7c3be6d9779dabff2e9060a826916b6d800b9a7b738c25dd9a389
+dist/2026-04-14/rustc-beta-x86_64-pc-windows-msvc.tar.xz=594d187719c353b51e7681b5d539831f11fadc92aa6c0f8c11acd92e5855db2d
+dist/2026-04-14/rustc-beta-x86_64-unknown-freebsd.tar.gz=d418464becfe0fcefee10ccdaa19d3dd64aaf243eb79413becd47290c99b192a
+dist/2026-04-14/rustc-beta-x86_64-unknown-freebsd.tar.xz=0bb7405b32596f9c4ada34687d15d4a264ac9b3fc081f58eae75837fd23a85ec
+dist/2026-04-14/rustc-beta-x86_64-unknown-illumos.tar.gz=c789b633bb6d0ac7f8a882afd122d3706fa71213f33acbf411480f3e114d03f4
+dist/2026-04-14/rustc-beta-x86_64-unknown-illumos.tar.xz=a807261bb4636143a601ac034cb7ff24c4ebc86e6abb26d7b08a356758facd72
+dist/2026-04-14/rustc-beta-x86_64-unknown-linux-gnu.tar.gz=202b2110c143dad291f88bb2b87434fdf212bd295cd0cb5d0ec5c9f052c1bb3a
+dist/2026-04-14/rustc-beta-x86_64-unknown-linux-gnu.tar.xz=cb641db912cbb560398b13b76d8125b59269d315642000b347b227401b2b7f54
+dist/2026-04-14/rustc-beta-x86_64-unknown-linux-musl.tar.gz=d64ffbe28d8257b4028bfb678894e33d30e30389b23a08b92edcae5c6045e07a
+dist/2026-04-14/rustc-beta-x86_64-unknown-linux-musl.tar.xz=c800e2b4529d16ea48dfc812e00d37ce9996ba481fee6f005bdc2307d86eba18
+dist/2026-04-14/rustc-beta-x86_64-unknown-netbsd.tar.gz=8b73e9015f0192a385a8d4ddcad7ecad6122bb30b1b2d8018037e30ca791d136
+dist/2026-04-14/rustc-beta-x86_64-unknown-netbsd.tar.xz=d591f95eb864c9c81f108b12479f67af3e42fe4b208c1464bf34e1ad8fa332ea
+dist/2026-04-14/rust-std-beta-aarch64-apple-darwin.tar.gz=6013c542875c4b7b06807389ce943eda6bf421a753953ff4a0ba478cf0f065bd
+dist/2026-04-14/rust-std-beta-aarch64-apple-darwin.tar.xz=dba5d472e74055928a7a491b3849be5e20d1d4c75e327943a5358cb8e2253027
+dist/2026-04-14/rust-std-beta-aarch64-apple-ios.tar.gz=9e0b167ef52cfae2ea2d8c6ca15618c78bb668967d542189c3896cb409428c06
+dist/2026-04-14/rust-std-beta-aarch64-apple-ios.tar.xz=f5a033f658cb9d93fde9d4ffe5f26d1d2ce58233ee17f92e39dc9ff76668a59a
+dist/2026-04-14/rust-std-beta-aarch64-apple-ios-macabi.tar.gz=735b6a2edab54666c12a3f1d3b5f9240b1441b94a975c5a88be8d926076072d3
+dist/2026-04-14/rust-std-beta-aarch64-apple-ios-macabi.tar.xz=eb305a445467e97178e9fff0793463e1dea44bf6c151407d2523ba2e5a38d246
+dist/2026-04-14/rust-std-beta-aarch64-apple-ios-sim.tar.gz=31af0e360e24eb1454f6baf45fe0630d0c65bd34282da7711d510b78447ad82d
+dist/2026-04-14/rust-std-beta-aarch64-apple-ios-sim.tar.xz=c1eaa173b821dba5734269037798ce8294dddf902d6f884ecacf394288799094
+dist/2026-04-14/rust-std-beta-aarch64-apple-tvos.tar.gz=71e2a7b730b09596e15ac381daff9d922d8ab30cbfa889f140a98ebd2cbbb4c4
+dist/2026-04-14/rust-std-beta-aarch64-apple-tvos.tar.xz=ea7c093c9207b2eff5400d81d21df012af45288aea2f995bcc1880db37f5353b
+dist/2026-04-14/rust-std-beta-aarch64-apple-tvos-sim.tar.gz=bc07c413c1404078d34f538a4bf40a29a5cea948c1be8063a76798d42f5a5bfe
+dist/2026-04-14/rust-std-beta-aarch64-apple-tvos-sim.tar.xz=1837af58ed6b5da3fd459b85688be51332d4fce184b5c8d38146d7f8af82f87a
+dist/2026-04-14/rust-std-beta-aarch64-apple-visionos.tar.gz=78978e79491e79ce51b89457cc8963902b76e716607d040a0ffd964a63b5459e
+dist/2026-04-14/rust-std-beta-aarch64-apple-visionos.tar.xz=6353c8dc2c985672f1a152d7ac54912a2c1d1674180d978fbcc21e690339ff17
+dist/2026-04-14/rust-std-beta-aarch64-apple-visionos-sim.tar.gz=94ef4b756be1ac66b070fb0fbadeacadc6c4757facd0dce31e085b106c6f0ca9
+dist/2026-04-14/rust-std-beta-aarch64-apple-visionos-sim.tar.xz=62620485e8b392afe687671fe35486fcabc63b3575ecbd44f5b51a114608ed88
+dist/2026-04-14/rust-std-beta-aarch64-apple-watchos.tar.gz=a052c22f70d8234638b84a7abedf0483db9e2613dcb2882398576ba1f9849b5c
+dist/2026-04-14/rust-std-beta-aarch64-apple-watchos.tar.xz=4552d9f691172dcde035ec51392cf91670309eafbbf2b9720ab7b09afc3c8cc3
+dist/2026-04-14/rust-std-beta-aarch64-apple-watchos-sim.tar.gz=8ead96cbdff29205ce3d5895ab7e8ff49113ca118b6ff2670db0934de56546f5
+dist/2026-04-14/rust-std-beta-aarch64-apple-watchos-sim.tar.xz=62617e7919793f7fc1b10a2e035f803b2b335b6b6ac0f502109b34b034abc994
+dist/2026-04-14/rust-std-beta-aarch64-linux-android.tar.gz=29737a87bb764152092cca224752ed6742844f743881ff838967f50999d8e111
+dist/2026-04-14/rust-std-beta-aarch64-linux-android.tar.xz=d6ebc87683d7a7a57b4ff185bfbc72ac50e8fca236d45f9413817639aad8aa22
+dist/2026-04-14/rust-std-beta-aarch64-pc-windows-gnullvm.tar.gz=16eea786343a6e6673e4de75cd6869773a0093125faa4e83c398ab499c04e41f
+dist/2026-04-14/rust-std-beta-aarch64-pc-windows-gnullvm.tar.xz=5dd472ff328477365a2d23d8db27446b512d37d164f471b0165ac1c9a8f78a7f
+dist/2026-04-14/rust-std-beta-aarch64-pc-windows-msvc.tar.gz=c7085f64ab100996c4ac3e28ff3a40f14a9a0fc9a3675aaa4ed791bb55a64687
+dist/2026-04-14/rust-std-beta-aarch64-pc-windows-msvc.tar.xz=9b4c2cbdac918a479c470a3bc201018e85e0d08da60645c9170d3428e763112d
+dist/2026-04-14/rust-std-beta-aarch64-unknown-fuchsia.tar.gz=c80021f80402373e2cfd6c32b582bf97c18f3ea16547ec5b22841e70418eaff9
+dist/2026-04-14/rust-std-beta-aarch64-unknown-fuchsia.tar.xz=22978a760d34ade1abb5f215a27c2f25a1ee06c07f54bee31de2f8f14fe0ae27
+dist/2026-04-14/rust-std-beta-aarch64-unknown-linux-gnu.tar.gz=2bf09520399cd185460d1f80d7fb43bee4687ac55e03f665efce36e8f4faedad
+dist/2026-04-14/rust-std-beta-aarch64-unknown-linux-gnu.tar.xz=4adb753ff1779d939082479c3fb24225b17e787c8216a591790a01e2c1510aae
+dist/2026-04-14/rust-std-beta-aarch64-unknown-linux-musl.tar.gz=431bc53cfe5d2af7df326ca828743c55e577dcaee221a774a89f76d05bea7752
+dist/2026-04-14/rust-std-beta-aarch64-unknown-linux-musl.tar.xz=fbc2ec3fcadc3be21fa7918eb5a48c15c67f24a89788cd7728554358fd2ad0e3
+dist/2026-04-14/rust-std-beta-aarch64-unknown-linux-ohos.tar.gz=4fcdf0a3f818680b824259b9706080ec72aa342546d9e1d0162ed0833972a91e
+dist/2026-04-14/rust-std-beta-aarch64-unknown-linux-ohos.tar.xz=6d24aefad9a2bfdd89322b28e2ab575fb4be439acdc167c397744bcd444ff539
+dist/2026-04-14/rust-std-beta-aarch64-unknown-none.tar.gz=34c67bcd0023e34fccb38e058dc27b27eb17ba48ee253a8fa6e4f4acc10d5853
+dist/2026-04-14/rust-std-beta-aarch64-unknown-none.tar.xz=fbe5279433bc7c596f09b500039c1a7a2d7276b4603f313b45d53d95dbb73d09
+dist/2026-04-14/rust-std-beta-aarch64-unknown-none-softfloat.tar.gz=963fd60c364013ca92907f811f0bcb55e877b10268eb00cd7691cbe6f5064295
+dist/2026-04-14/rust-std-beta-aarch64-unknown-none-softfloat.tar.xz=34442b8c9dbb730fb1f26cd7860c50be3e2820602db3aadc91cea6431128ea2b
+dist/2026-04-14/rust-std-beta-aarch64-unknown-uefi.tar.gz=e2081f1714511927cb7e9e40c60c0b22642acdc212c64a48f95cc74e8acc9516
+dist/2026-04-14/rust-std-beta-aarch64-unknown-uefi.tar.xz=eb1ed4fc8023833458ca440bc91a840d0b637d95318ae7afb7ca4fce491df148
+dist/2026-04-14/rust-std-beta-arm-linux-androideabi.tar.gz=0899ae7e5a589508fd0df89fd45d7a1abd94d36d805158dca97c2992c33a584e
+dist/2026-04-14/rust-std-beta-arm-linux-androideabi.tar.xz=f7d8f81f8240779461ea59e876abc5ca3e2f044ca6e52a6247e70c063a3d89cf
+dist/2026-04-14/rust-std-beta-arm-unknown-linux-gnueabi.tar.gz=5df31d51a698beca3102d435c1af4982977eaba1127882411943c52180793775
+dist/2026-04-14/rust-std-beta-arm-unknown-linux-gnueabi.tar.xz=98725b1a1d8c0424342d6266b928bef38149e77e897a22bb57a4f6580107b5a5
+dist/2026-04-14/rust-std-beta-arm-unknown-linux-gnueabihf.tar.gz=2647a387059502e99afaff27957a6e3ef720a913b60b0acdeb9a27c1d6d401c0
+dist/2026-04-14/rust-std-beta-arm-unknown-linux-gnueabihf.tar.xz=8b4b9d03b0eb3bac92edda744f1856e106d37e5ca043422c07a71b6272d4d0a3
+dist/2026-04-14/rust-std-beta-arm-unknown-linux-musleabi.tar.gz=3ece1c0e137abfaac49646fcdbd100158f9ee0d769dc797f9c3bb2a38430c134
+dist/2026-04-14/rust-std-beta-arm-unknown-linux-musleabi.tar.xz=cab1ee3d87656db41dad895c18d8433eb30c0745980108457199625be496eb39
+dist/2026-04-14/rust-std-beta-arm-unknown-linux-musleabihf.tar.gz=7fd296fc85874bd63f40173884f72134e1af4d072fc8e17cca4bc322a11857f9
+dist/2026-04-14/rust-std-beta-arm-unknown-linux-musleabihf.tar.xz=01e1760ed2b7bb0b22b1bdb74d49361354cc73a6a888b1c41644e736da8ca7be
+dist/2026-04-14/rust-std-beta-arm64ec-pc-windows-msvc.tar.gz=a7b3ef47be710c1b2cf0e00103e7ca84a127ab7831466ba0c246c9d5ebc25ab3
+dist/2026-04-14/rust-std-beta-arm64ec-pc-windows-msvc.tar.xz=4ddd59b23ba17f2082b1d17ffc86b9eab8961dbf6a415ac8deb04471272ab21d
+dist/2026-04-14/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.gz=a56cafa93dd40ee8282919d8dab0b2de139980c68f8620bd4930ee3fc89109da
+dist/2026-04-14/rust-std-beta-armv5te-unknown-linux-gnueabi.tar.xz=7bc9bfbcb43cab04c36b4e488eb56fd5cd9398cc98859734bf3244cbe8fa8d71
+dist/2026-04-14/rust-std-beta-armv5te-unknown-linux-musleabi.tar.gz=ce1ccf6e97504c9e3f23683a3c303be5cead92f09e8fad500a905140f63e7064
+dist/2026-04-14/rust-std-beta-armv5te-unknown-linux-musleabi.tar.xz=f439632779986064d0c01791a9d6a8751ec4a73158ae6f8f37b849d0df2f6d14
+dist/2026-04-14/rust-std-beta-armv7-linux-androideabi.tar.gz=d75524e780850e7002ddd0d1a6bf2deaf1ddeb7f5d0b7ace1b5c63960d3ff0b5
+dist/2026-04-14/rust-std-beta-armv7-linux-androideabi.tar.xz=5d1075a1ea9fa9ed6cc4cda2e5ce3d2ce36a26a19046acf03b8d089e6518a430
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-gnueabi.tar.gz=752e169ce834ebe749e85c5b488dc87c9e82c3426aa59dbb76ee5ca949862156
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-gnueabi.tar.xz=acd4eef57e45323ccf8723700c6fbd9eac5bd52c80789ebc8506531a5395be1d
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.gz=7e4461d47c5c5780c0e2d14f8ed6bc07a141a542f38d1b627ab8afd194a2faf6
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-gnueabihf.tar.xz=101299bd2db6e850418953e2782cf73f061b527ec1358747da3fe02510085bab
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-musleabi.tar.gz=26e4048241c1ab874733100979afe3e7e20e0f2442cbf4c11e95b2f9aa8e78ba
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-musleabi.tar.xz=61febc0edc1d7218fd8d954315cdb89a7ee1d90e6deab058acce1ad66ab9834c
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-musleabihf.tar.gz=408eac371812ec1b8de499211f789c1b482e922e13d7d363651fb32e51a39c35
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-musleabihf.tar.xz=b16eaead90adecd12f8381ee882ff2ada16e55db8e458754e1323c936bcd13cc
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-ohos.tar.gz=677263360535c84b3b97b24dbea5b13aabfe7031747d398caacdbe9b7321a17c
+dist/2026-04-14/rust-std-beta-armv7-unknown-linux-ohos.tar.xz=3b08ab85ec8007c61d24a01845a1f3e45004cb15b1db2e108e324d466420df27
+dist/2026-04-14/rust-std-beta-armv7a-none-eabi.tar.gz=9c7ef17269b7720c2253f7c144e04f9f35f59441f40f2b5436cb2ae4e8d80d3b
+dist/2026-04-14/rust-std-beta-armv7a-none-eabi.tar.xz=1f7739485143042f4790c21f4fdb0c75728097a51818f3347efc2d47963003da
+dist/2026-04-14/rust-std-beta-armv7a-none-eabihf.tar.gz=fec1cf11cc3ec00fa2ba8c1a94e8be086e816a6e97ae64cc6efaacfec128f118
+dist/2026-04-14/rust-std-beta-armv7a-none-eabihf.tar.xz=fff07a142494aac0211524a4068b2192a71a6247475294f2b82308a9c73b4076
+dist/2026-04-14/rust-std-beta-armv7r-none-eabi.tar.gz=f0f5e5727d0a056b7486331cd79ca6a29afc2cf9b1c685cb778273fd6d18b3a5
+dist/2026-04-14/rust-std-beta-armv7r-none-eabi.tar.xz=92c269149082ed79107ff60490a3ba918f10d2c6465b1360c1261e9ed09f8588
+dist/2026-04-14/rust-std-beta-armv7r-none-eabihf.tar.gz=8706ce7c43b54b1d60aff89dc6134078e1efcdd855e9824b8a0289021a4f731d
+dist/2026-04-14/rust-std-beta-armv7r-none-eabihf.tar.xz=87426a3b108879e926231621a65f45d52847c53162c64b5e7ae91db4f50be2a0
+dist/2026-04-14/rust-std-beta-armv8r-none-eabihf.tar.gz=b35d31f454cbf07b75132cb6d22b404bf391a84cc20972ea28ea6bf534fcc1ea
+dist/2026-04-14/rust-std-beta-armv8r-none-eabihf.tar.xz=4c8c438e4ce34ff3e09dae7bb3777cfba15b6d82b66b1665cddd536eef79458e
+dist/2026-04-14/rust-std-beta-i586-unknown-linux-gnu.tar.gz=7b25c21325961de4a9e2eb9d0d597f89b84a0aad24aaf056d141c8bbe9a31c59
+dist/2026-04-14/rust-std-beta-i586-unknown-linux-gnu.tar.xz=60d7f231e43b8c4f19d910775f501ff422a715cdf2accfd7da1c5fed4608f722
+dist/2026-04-14/rust-std-beta-i586-unknown-linux-musl.tar.gz=66fdf2186dab3ab7ce4e8e80d9c06e1dec9443b1b346e13b41edbd1a1c0102f0
+dist/2026-04-14/rust-std-beta-i586-unknown-linux-musl.tar.xz=d84fb8a2e32ce007bb684a2c7343765f67308dba819c318a67f124ec4931a1f3
+dist/2026-04-14/rust-std-beta-i686-linux-android.tar.gz=1bcda5b307283fa1a09d068af8a34903b9dc8cf0a0e9df78c7cc6e9bd6d9c67d
+dist/2026-04-14/rust-std-beta-i686-linux-android.tar.xz=5c5b8cd75d90750dce6f712ce48a5b8ec36d8956a342a9bcccfb5a23c3735d6e
+dist/2026-04-14/rust-std-beta-i686-pc-windows-gnu.tar.gz=4667a8be20fcc3fc22d03fa61f7372ae7e481dc3410e55d0803102b4d8a5d8dd
+dist/2026-04-14/rust-std-beta-i686-pc-windows-gnu.tar.xz=b2e91eb407e0244e8d6261f21bd6c9dbac6e8b6b984eaf4cd5b0ed60a5e9f1b7
+dist/2026-04-14/rust-std-beta-i686-pc-windows-gnullvm.tar.gz=64888f2e06df70ad3e9946512dbdad7d4af33e6603de982daa1a240fafbe530b
+dist/2026-04-14/rust-std-beta-i686-pc-windows-gnullvm.tar.xz=71209cb50e94b17b3f935fd2218781d3674573f9bf106225895f3cdf81593670
+dist/2026-04-14/rust-std-beta-i686-pc-windows-msvc.tar.gz=0948bbf181985b79d1f5e6aa5f839f3d609b4c54fda4e29d421f84b71136e357
+dist/2026-04-14/rust-std-beta-i686-pc-windows-msvc.tar.xz=33a732cc6e7bf8aaabe2a178ac0bfa70e6d242f152a59a7878a924a0e8d8bf47
+dist/2026-04-14/rust-std-beta-i686-unknown-freebsd.tar.gz=1b797a89bc8a1c6bfcddc2c910244f4c50bf65f6d2ad10a02ed3b2433b177b77
+dist/2026-04-14/rust-std-beta-i686-unknown-freebsd.tar.xz=690cb307bf3370d0420b75e9b840c7650d2270aa7558cd32bc9f1e29498e9c3f
+dist/2026-04-14/rust-std-beta-i686-unknown-linux-gnu.tar.gz=87d824e3729b9563fc204ffe6802041cec062a5fa31900c584272999d791c501
+dist/2026-04-14/rust-std-beta-i686-unknown-linux-gnu.tar.xz=6a07723ee0fbdbc21f09471b00d041be3f840c988a63a174312854c3a0fcda10
+dist/2026-04-14/rust-std-beta-i686-unknown-linux-musl.tar.gz=0068d602b3b6bcd22ad055690c96a6defd909ea12dbb7a8c39474f33526b5981
+dist/2026-04-14/rust-std-beta-i686-unknown-linux-musl.tar.xz=eeb31d7361dae97764346f42ef57eb1b3dc1616d60c43f4bd42a76d50b1839c7
+dist/2026-04-14/rust-std-beta-i686-unknown-uefi.tar.gz=3f2183ec3e0a66602ac8b5f01a400affe85fa8f776e72911d777235a9c25a265
+dist/2026-04-14/rust-std-beta-i686-unknown-uefi.tar.xz=f37ea30acea8e74db40928e051d15d046758de864d87e90ae249b625d90cd5e3
+dist/2026-04-14/rust-std-beta-loongarch64-unknown-linux-gnu.tar.gz=67512594c23ee664f9d924d0487639d0a642018f27d943345cb00e0f5a8fa97a
+dist/2026-04-14/rust-std-beta-loongarch64-unknown-linux-gnu.tar.xz=43b724a9bd522900c7f658217ce48d02ea7a8c89d8f5f3f51e7df02087405bef
+dist/2026-04-14/rust-std-beta-loongarch64-unknown-linux-musl.tar.gz=986c985e096ea86ed7b2d1a12130f526362dc28bc27d21b9bf642c06fdf7d036
+dist/2026-04-14/rust-std-beta-loongarch64-unknown-linux-musl.tar.xz=39f0c3ec23c6be8c573ea03dddad7b61aa84956ee774ad0d7049fac78dca9282
+dist/2026-04-14/rust-std-beta-loongarch64-unknown-none.tar.gz=57b90f6817daa0b28ea117219321a03f8ca9be26b3873d5bdeaa08f94caea8bc
+dist/2026-04-14/rust-std-beta-loongarch64-unknown-none.tar.xz=23e84ca4d43fc6f78bf473e181f09639061eae3020d1f4a1525a980967ba897e
+dist/2026-04-14/rust-std-beta-loongarch64-unknown-none-softfloat.tar.gz=0b95e470f9564a9899420efc641abfb7b46120f27eb277c0d8dcdef692815f6b
+dist/2026-04-14/rust-std-beta-loongarch64-unknown-none-softfloat.tar.xz=8923893c37f660aa08587bf9c06f796bbe4c8f469da33e9841f24697a65befb0
+dist/2026-04-14/rust-std-beta-nvptx64-nvidia-cuda.tar.gz=b4a7eadb59dfcdddfc882c59fc059b8ac968c5c45c66ad2504e0048a712a314d
+dist/2026-04-14/rust-std-beta-nvptx64-nvidia-cuda.tar.xz=ad408710eecf9353b3565d24cbce684b810265fac9324e96995eeeb6948f9fa4
+dist/2026-04-14/rust-std-beta-powerpc-unknown-linux-gnu.tar.gz=735d1b011f57704fb553be29ec5ec27703025dde6f4d9623fcee8e0ba60c13d4
+dist/2026-04-14/rust-std-beta-powerpc-unknown-linux-gnu.tar.xz=6a8ee3e6bfebe6f619ab33401da28385df423ab814c55c05d6eb156ce4903014
+dist/2026-04-14/rust-std-beta-powerpc64-unknown-linux-gnu.tar.gz=06a4273f82bcdcc301a8dbef9b3c9cd3dbf2f88b4c242e69c23b87cab201d990
+dist/2026-04-14/rust-std-beta-powerpc64-unknown-linux-gnu.tar.xz=8ca85e52af77b2f4aed7b5cf5bbe50ce5c233e86e82a9eb29bf2814202d1031f
+dist/2026-04-14/rust-std-beta-powerpc64-unknown-linux-musl.tar.gz=3b9d40c90eae335fae3ab7436484fc91802d2c6d0f94427a615ccd9781ffcf0c
+dist/2026-04-14/rust-std-beta-powerpc64-unknown-linux-musl.tar.xz=7f86fd52fb0c3290d2401d444c3687c9274abb69d707925c298cc319be46137a
+dist/2026-04-14/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.gz=e37d1cb29035269a9c5d15cf27e30fa8d81a44d393da65ea01dd73c8564d46fa
+dist/2026-04-14/rust-std-beta-powerpc64le-unknown-linux-gnu.tar.xz=bb73b66a977404ed1edca3e619505929e2c6170a06852c90e12a9417d50954f2
+dist/2026-04-14/rust-std-beta-powerpc64le-unknown-linux-musl.tar.gz=7ff24f319f4a0ada9cc1a38e4ac87049769e4d1dae617c7069b80591124060cb
+dist/2026-04-14/rust-std-beta-powerpc64le-unknown-linux-musl.tar.xz=c20fb415904b6d2bf8d689719a2c53ed134dc94b5a7a818bd612a4e9d7ca4450
+dist/2026-04-14/rust-std-beta-riscv32i-unknown-none-elf.tar.gz=3bf45887fe9517b57728e83cedd23bec736206ce3b6f3ad6ca647d6e2cbbe517
+dist/2026-04-14/rust-std-beta-riscv32i-unknown-none-elf.tar.xz=561b4b200f2f1f96be5e915c28a0d42c81f419f754efdb158935baab3066758c
+dist/2026-04-14/rust-std-beta-riscv32im-unknown-none-elf.tar.gz=c29a80ee52e8b07afb75f804b5b2a29127a45c2a1774c8fc1efd48fa5629e87f
+dist/2026-04-14/rust-std-beta-riscv32im-unknown-none-elf.tar.xz=0ff4d4e0d749c1e40aa7b59f9ee52b1594718a9bbf8d79b7627fe01e9bfa461e
+dist/2026-04-14/rust-std-beta-riscv32imac-unknown-none-elf.tar.gz=379fcac072950044871aacdda137e32fbf934976537ca2e49a23f718e8fdad9e
+dist/2026-04-14/rust-std-beta-riscv32imac-unknown-none-elf.tar.xz=64b9f736957ba67c3e0bd62bd5157fca4a788ad979e57dedaf2e601312353a9f
+dist/2026-04-14/rust-std-beta-riscv32imafc-unknown-none-elf.tar.gz=f8f97c8dc2a8c1729ea90320f0760d19be0929d57abcafaf3ec2733626067554
+dist/2026-04-14/rust-std-beta-riscv32imafc-unknown-none-elf.tar.xz=6339b9293a9fe88928716dd87604c018398ed678206353e8c1bc59ecbc211846
+dist/2026-04-14/rust-std-beta-riscv32imc-unknown-none-elf.tar.gz=89172756ad74df0ea7d7a03e63d44f83d5aa4a8fcecc3c6935ccf9138dfecf37
+dist/2026-04-14/rust-std-beta-riscv32imc-unknown-none-elf.tar.xz=5e87760598d9f4eb40bb664d12eff5f69832d4f8ecc97776c19ec2f592742943
+dist/2026-04-14/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.gz=148bba9bf536446383c80cf9bf866c2f882b37a7536de632b1cae77d6c4c6cd7
+dist/2026-04-14/rust-std-beta-riscv64a23-unknown-linux-gnu.tar.xz=5df62d006ace8216d4bf5da398fd11038c1180e355d09ba4aa5d135b9e87d643
+dist/2026-04-14/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.gz=69eb4a6ac52e8928e8ae3062a486cb487547720eccbc3c6d19b9f7cf261e4756
+dist/2026-04-14/rust-std-beta-riscv64gc-unknown-linux-gnu.tar.xz=03fe5f8bf31fdea6ae8c82eb7997581bd9e79f1faae924e02651b843877dea57
+dist/2026-04-14/rust-std-beta-riscv64gc-unknown-linux-musl.tar.gz=8c3c29f64aacf0ebaedbe1c4c5f5718b043833d23af8a9f5deb63844c3031870
+dist/2026-04-14/rust-std-beta-riscv64gc-unknown-linux-musl.tar.xz=dbd8aff208458242ee2b24240cb09f8489657775aaa2851bf3e4b7899665bb41
+dist/2026-04-14/rust-std-beta-riscv64gc-unknown-none-elf.tar.gz=29c2d5ae7991ba8c13a84182a463d49eff6883381a9e5d56b72620a307efeb72
+dist/2026-04-14/rust-std-beta-riscv64gc-unknown-none-elf.tar.xz=405f36827c61e88081ce530ccdf4cd10b04792ce147da969cddc49848c060ae8
+dist/2026-04-14/rust-std-beta-riscv64imac-unknown-none-elf.tar.gz=bd4fdb1540d9efc276705a6c6bb885a7b2eb2576a7d898d9652b2c76f9c4d3f7
+dist/2026-04-14/rust-std-beta-riscv64imac-unknown-none-elf.tar.xz=50ecd65092814939440809320ad26e1f513b69440f9fd096cbb98febb9d73613
+dist/2026-04-14/rust-std-beta-s390x-unknown-linux-gnu.tar.gz=c7347cd70f6e6043998f95778dd866e90d36e3869620f4911cec8c1fba8dd37e
+dist/2026-04-14/rust-std-beta-s390x-unknown-linux-gnu.tar.xz=3fb46ec1f8b524951d726777808d02eccb60d993ffc6dd9257eb123c2608e1df
+dist/2026-04-14/rust-std-beta-sparc64-unknown-linux-gnu.tar.gz=a21c41a777bc49c7fbe1a94db0bbd967da6dbf78ea6585e8caaa979910b3e2d2
+dist/2026-04-14/rust-std-beta-sparc64-unknown-linux-gnu.tar.xz=3087f50de1e9ded03eaaaf3b0dd6df496ddc1af850760e819fabc3cc8edc35bc
+dist/2026-04-14/rust-std-beta-sparcv9-sun-solaris.tar.gz=631e3bc0c65eb53e285068141a704dc6d3f332e03b5317d001d50eabe92040db
+dist/2026-04-14/rust-std-beta-sparcv9-sun-solaris.tar.xz=fbed5576340f2edb94a6e40e851c94d3f3cc20cdaf29210a6d9868efb7ad7047
+dist/2026-04-14/rust-std-beta-thumbv6m-none-eabi.tar.gz=b5b49246ea75b70be44f75f133b5769efb0bc7e837b2bb5e73e6a633a9a0d89f
+dist/2026-04-14/rust-std-beta-thumbv6m-none-eabi.tar.xz=c20183595eb818240f2d6ae5ac2f290545f336a79a13b3d0ff47d026e97324c8
+dist/2026-04-14/rust-std-beta-thumbv7em-none-eabi.tar.gz=2350814e9a23bc50ef752c030a91d193af1ebcb472c69bb86a2a8eca1df82fde
+dist/2026-04-14/rust-std-beta-thumbv7em-none-eabi.tar.xz=ee8bd68fff8785984394be950e5a2670fab6bc97fba0fe07fc8c6b0ea4a21c7b
+dist/2026-04-14/rust-std-beta-thumbv7em-none-eabihf.tar.gz=52b95f6490f605c705f51271c3a51670b93ef656dc0f362cf80c55a8dd6a4d6c
+dist/2026-04-14/rust-std-beta-thumbv7em-none-eabihf.tar.xz=6561a6492671fed31cde55f7cc9f26ceea264d39ea8956019b191950070aa2e8
+dist/2026-04-14/rust-std-beta-thumbv7m-none-eabi.tar.gz=25be4ca3b6a10305d4a2635097c8a7004a5c7559a09c50624bdc0b702217796e
+dist/2026-04-14/rust-std-beta-thumbv7m-none-eabi.tar.xz=5aa785888c25c28f9c8dcca2b2a997ee1d98cc4d48862a54d30899623166002a
+dist/2026-04-14/rust-std-beta-thumbv7neon-linux-androideabi.tar.gz=6a40fd7bcce8973a5d43beb7e0ad44f2642fb005f2390fb53a143d695345d0f6
+dist/2026-04-14/rust-std-beta-thumbv7neon-linux-androideabi.tar.xz=753dbd9da49cfa43c48e4517b6fa978fb2f9bdac3af44969d69257cfb7db69db
+dist/2026-04-14/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.gz=1d74c05b74148be14a7906898e388e2767087e9c7463470f4cd267d7af342e87
+dist/2026-04-14/rust-std-beta-thumbv7neon-unknown-linux-gnueabihf.tar.xz=7fc7ff79ba5f51588267f39c0818ff36b38a44a95aadc68313239305430cf9cc
+dist/2026-04-14/rust-std-beta-thumbv8m.base-none-eabi.tar.gz=676370ac7fe9e68008c5d34b551375b011b462caa1615b6742887c368c92fb74
+dist/2026-04-14/rust-std-beta-thumbv8m.base-none-eabi.tar.xz=bbd1fdc73a5fd3041a10a3d0a691ac6ad555b7e607728141561a87f6be445b71
+dist/2026-04-14/rust-std-beta-thumbv8m.main-none-eabi.tar.gz=4775806ee6bbc4a1b3dff3d69ee9e4bbc7f24fd5f69c8fae9b1c6492ebeac0df
+dist/2026-04-14/rust-std-beta-thumbv8m.main-none-eabi.tar.xz=83f2bd359159a9cee03d101dd81f072598f3d29e16d4ee51375fd8c6be3002a8
+dist/2026-04-14/rust-std-beta-thumbv8m.main-none-eabihf.tar.gz=0ee91403953c903c944a2095bf43712be9b8580ddc2027727cd2b9fd908d3cda
+dist/2026-04-14/rust-std-beta-thumbv8m.main-none-eabihf.tar.xz=19770040efed493c454a379c5867a559ab2aab077600179f965e6d55c00d8772
+dist/2026-04-14/rust-std-beta-wasm32-unknown-emscripten.tar.gz=17d72ddb5df498a29de994097171eb65f39e43142f9fea44c7c588a8cf7f8c89
+dist/2026-04-14/rust-std-beta-wasm32-unknown-emscripten.tar.xz=4fa5dba0405cc2bc8893de48ad0bbd47dc6b1b89897a522e5294aad405f9cb4c
+dist/2026-04-14/rust-std-beta-wasm32-unknown-unknown.tar.gz=9a214857ed14b5e99cd8a42ee597c3462f24903c5df5ed6ef18505403836fafd
+dist/2026-04-14/rust-std-beta-wasm32-unknown-unknown.tar.xz=4f8538320fa5d6a0be80b7b0cde55685e2a99f6fabae31588cb69b4664262382
+dist/2026-04-14/rust-std-beta-wasm32-wasip1.tar.gz=28ce59923c406c04da99e8042f99a3243f93dd48c4e8a7b0b48fab23a9fd4a4a
+dist/2026-04-14/rust-std-beta-wasm32-wasip1.tar.xz=dc4fc5da651395ca3d777e50fe8e756a593584848902a4bfc6a095db50ae5952
+dist/2026-04-14/rust-std-beta-wasm32-wasip1-threads.tar.gz=1e18820b7a3269c9ca89d54a2fb22c77b2803860802d9ab62085c1d28f5a70d8
+dist/2026-04-14/rust-std-beta-wasm32-wasip1-threads.tar.xz=f34935b5c8524549f6cf42d88e41f49a745149dcadf862da8b70e577af18d50b
+dist/2026-04-14/rust-std-beta-wasm32-wasip2.tar.gz=699eaba1de898d9c88bebdc2228846a53a2692ea9bcd1b53af90904f1fc905a5
+dist/2026-04-14/rust-std-beta-wasm32-wasip2.tar.xz=fbcb1d9aa12c31c26ccde00793bc3bc6d6dcc8ea2f5d42d29a9de1344a34d2dc
+dist/2026-04-14/rust-std-beta-wasm32v1-none.tar.gz=73ef93d8c72a79ff25062e8d4acee6145127edcf1d7fc2debc16d79846e931af
+dist/2026-04-14/rust-std-beta-wasm32v1-none.tar.xz=a7bd4d7ef9a6d22ba67e9f7bf2644e906ea13250e00c5799c6472433691f0540
+dist/2026-04-14/rust-std-beta-x86_64-apple-darwin.tar.gz=50c82762dba2482a5cb2d57760ed9741de19ef54b6bc23d2a8fcec01addb21c4
+dist/2026-04-14/rust-std-beta-x86_64-apple-darwin.tar.xz=57682df246caf478ba3a36a99a562276d9be91efcb43625f52f4c33efc4a24a2
+dist/2026-04-14/rust-std-beta-x86_64-apple-ios.tar.gz=40d1aeca1d258a3ba9030e718bff4d98974a1a1a9b7690c03f13771e4d9b2835
+dist/2026-04-14/rust-std-beta-x86_64-apple-ios.tar.xz=b47d2de0b8dc7374778f60f38ec4c51718cce2ce03d6b6d52f10cddd95d47e22
+dist/2026-04-14/rust-std-beta-x86_64-apple-ios-macabi.tar.gz=42819ce12cff11d91a384a7f7c16acb31e5ed0796dbf118dcc6f09fb49989896
+dist/2026-04-14/rust-std-beta-x86_64-apple-ios-macabi.tar.xz=44344c81123c8ff8ef719ec60bf5ef1cfe9f2c6f072fc3e6e68b67113008ae7a
+dist/2026-04-14/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.gz=9a9a50924691cd00640c4f548637a0d0f9c0cc49992d2a18e04829b4bd979533
+dist/2026-04-14/rust-std-beta-x86_64-fortanix-unknown-sgx.tar.xz=cf7cae05b5426a2e6005b2b58e4aeb25e7311bba8adf619ca47dc0123f098f46
+dist/2026-04-14/rust-std-beta-x86_64-linux-android.tar.gz=7d8cdf37883335691b9d03cf32c42eccfe218bc9423d6906be8c661852759f2c
+dist/2026-04-14/rust-std-beta-x86_64-linux-android.tar.xz=9d5b7d6c2ea90a3dea1fcd0819f22ec7f5b1bdf16c1e3bd92846f21cacdfdab7
+dist/2026-04-14/rust-std-beta-x86_64-pc-solaris.tar.gz=6f478f919242151b96db59f5d76d71183a0ce84fa6d00622d386f9d084d60961
+dist/2026-04-14/rust-std-beta-x86_64-pc-solaris.tar.xz=3028c3306991de15b2b3036a6cb890550ef207adda362c087359f439f48a93cc
+dist/2026-04-14/rust-std-beta-x86_64-pc-windows-gnu.tar.gz=5b43f65b66f87ca4fc7233265584ec1659978cd124419a08cde3d027c6d6bbdb
+dist/2026-04-14/rust-std-beta-x86_64-pc-windows-gnu.tar.xz=b260fead983056e8783a222ba79bf3226114ccacd580d6202a192508d29f1b33
+dist/2026-04-14/rust-std-beta-x86_64-pc-windows-gnullvm.tar.gz=f70153e96e4f488ee7e2ecf4d75dd4df4d9575026bf53106bf3d3bb9ba8bf3a7
+dist/2026-04-14/rust-std-beta-x86_64-pc-windows-gnullvm.tar.xz=65b5ad8f6e187acde0ecf5c19ab8e655c2cc8f0583305d718cc234c90971c836
+dist/2026-04-14/rust-std-beta-x86_64-pc-windows-msvc.tar.gz=58406c05ce0d5b3fb66eb9817fd15e9c395b09d5787e141a15ca78a68fb98304
+dist/2026-04-14/rust-std-beta-x86_64-pc-windows-msvc.tar.xz=868d2c22302fbec4fd0a2ba3487ab18fe42869a0220310282adc5b447c04719b
+dist/2026-04-14/rust-std-beta-x86_64-unknown-freebsd.tar.gz=f31ff0364cf1be7c402a14cc8ce405f80077beb8ca962818cc285824b8db40ad
+dist/2026-04-14/rust-std-beta-x86_64-unknown-freebsd.tar.xz=2e5675d3aad9dfdb4a1d75de9a400fa57e38b222d0719c3e52e8c289ca1047a6
+dist/2026-04-14/rust-std-beta-x86_64-unknown-fuchsia.tar.gz=2820e5e7cdde029a1174c400c83cc41469d380c02d8221361280d8bff814434b
+dist/2026-04-14/rust-std-beta-x86_64-unknown-fuchsia.tar.xz=e21ccec9aad3efabc99140f2a44fe9de1815eae4a58de385b2ce1d22ae7fab6f
+dist/2026-04-14/rust-std-beta-x86_64-unknown-illumos.tar.gz=bd5010155c3549a1a1bfa2b893feecf4a2793c5f816d1cb742a86f6358a65a81
+dist/2026-04-14/rust-std-beta-x86_64-unknown-illumos.tar.xz=ca1e90e5b466c94efd7a096f6fd2d374afcfeb84d8399720f05ed72017bb79c7
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnu.tar.gz=88f44c8abc2c0aa5c70ddea59dfbb89be53b5b85368176f56c076ab79174f8b7
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnu.tar.xz=fdd83dfeeeaf49f74e2e497130c21837890497f4c7d58c0a06c2ae58d1b027dd
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.gz=6eebf35f6a4ca2a3b6e9edbd14c8f744500d0099e5e4d15011db61baca5dac28
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnuasan.tar.xz=58bb277404b0411c874c8166998c5eb9e65ad62dfc6f3ba86afd73a0914130c2
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.gz=15b046a6e773c4320254f458c55086d89a3fdaab38b74b8d5114501586287299
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnumsan.tar.xz=ebf82cf26e6501fbcfd38bef06cd6f909511e153498b18396ecab0ebd1121406
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.gz=a38f891a40d4f1bdbe3bbf07aa110424ff2c5df9cc63563910011e87e467b5a5
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnutsan.tar.xz=f9757ff55c259b7ff1fcd492ec06d69553938f99f0eaa711278f3d1f3bac7c0a
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnux32.tar.gz=23a89fb8c8aacbfdc67e99413bed782c36a0cea5d2180a454da8b721aee11ae5
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-gnux32.tar.xz=08675069d43335aa0b0a4edbd65a976fb9d81b75da057fe88f95d7ba0f2a98cb
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-musl.tar.gz=3b0a9acfaba18dd71ffe8f2d2f370b2e6d4edcacaee2ff7df7024a233c2b1d32
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-musl.tar.xz=c6a1e40a41795fcab0f197eeabc053360f59c62c3e03f94cc11d903b796f61fc
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-ohos.tar.gz=4d51229b6c2f4d7401a8e857152b775ee1cad28a2979279c4e177fbdb36a30a2
+dist/2026-04-14/rust-std-beta-x86_64-unknown-linux-ohos.tar.xz=174154d57be317c14591c395921eaf84577d1940f7c8bac41511c382215db391
+dist/2026-04-14/rust-std-beta-x86_64-unknown-netbsd.tar.gz=d85c23928b7ce3c8712dae2219241ee087fcfa999a719624f4d1a71096304a6a
+dist/2026-04-14/rust-std-beta-x86_64-unknown-netbsd.tar.xz=4b8115444b5c858f36979b7c4a48e5d8c4a30ffa3dc1ddbeebb31260ddfa44c7
+dist/2026-04-14/rust-std-beta-x86_64-unknown-none.tar.gz=5d4e27304c962a66c43086a8fe8e97e76a582cefcf70ba7bb552b7497998081b
+dist/2026-04-14/rust-std-beta-x86_64-unknown-none.tar.xz=d58340f1ae3119ff10c63dec6cb6d75260a4f3f5439f18795f12e64d81414fa9
+dist/2026-04-14/rust-std-beta-x86_64-unknown-redox.tar.gz=1b0f178e222e70b2ef524a6148edc8e4097dad79e4c9bc74a1b91b68eea62b4f
+dist/2026-04-14/rust-std-beta-x86_64-unknown-redox.tar.xz=7545a14f2ce4a2358a850a6196061e70f98966e52122d9835666c09a1059e5ed
+dist/2026-04-14/rust-std-beta-x86_64-unknown-uefi.tar.gz=19ef7d625c8118c5dc283c57fdc07ae3d5a503bcb04d36156146ca919893c310
+dist/2026-04-14/rust-std-beta-x86_64-unknown-uefi.tar.xz=d79bd625887bdc6339e22fecc0711b9ff211c2531fa8e9a4e1e344468da8745f
+dist/2026-04-14/cargo-beta-aarch64-apple-darwin.tar.gz=213adf0915f775399a516647bd90e4f88cd25c4b2c95eeea441939cb4ecc677d
+dist/2026-04-14/cargo-beta-aarch64-apple-darwin.tar.xz=b1b5bee9c4f4791b91c40104f18c337ca280b4c322cf3b84178fdcc0f021948b
+dist/2026-04-14/cargo-beta-aarch64-pc-windows-gnullvm.tar.gz=ce484bc7863789505f68e2df118d5819621fdb52756fc0c5ad1ec6cc7139e249
+dist/2026-04-14/cargo-beta-aarch64-pc-windows-gnullvm.tar.xz=25b0600034fd9af3a7a1c09715525782fd4c821932359c2a1e539fa6718a17df
+dist/2026-04-14/cargo-beta-aarch64-pc-windows-msvc.tar.gz=f8b9669ec25f47ac98eac797d988dfa30c6d0e9f8506b4176c7fa57a4eb4fba0
+dist/2026-04-14/cargo-beta-aarch64-pc-windows-msvc.tar.xz=0c980f162ece80ed34fbc41a78d43f6a1486388d7b0e042b160c29186718470f
+dist/2026-04-14/cargo-beta-aarch64-unknown-linux-gnu.tar.gz=9c9a9c217ad3ffea38dd9868645e33b913de984e13b6fc5f06635ea45e47d57f
+dist/2026-04-14/cargo-beta-aarch64-unknown-linux-gnu.tar.xz=1ebfe88245ec5262f98676bee6b662b5988b6ef9f9eceb5deba88ab4f6adf498
+dist/2026-04-14/cargo-beta-aarch64-unknown-linux-musl.tar.gz=6132fda7de92ea586481f7caac8aabf900e76cc5e15e1c9cf1ec66d25ce2267a
+dist/2026-04-14/cargo-beta-aarch64-unknown-linux-musl.tar.xz=ba2a97b47df7a33eb77d66e3fb36a051e16d3b86e09ba9d7d430c71ad49970a2
+dist/2026-04-14/cargo-beta-aarch64-unknown-linux-ohos.tar.gz=f834b14156554d76f10ae7be9e67d39d88f3f86fd019a57560ac8d22a4fb4e2f
+dist/2026-04-14/cargo-beta-aarch64-unknown-linux-ohos.tar.xz=33065b9cf13e4f3bcae8b447a57bd91c1e7420f33f4a5f10768def727fb6ac01
+dist/2026-04-14/cargo-beta-arm-unknown-linux-gnueabi.tar.gz=32ec7cde4277b3eb8092fe7a316af3d53ff200f4e1cb4a679d0bed86781a3dd4
+dist/2026-04-14/cargo-beta-arm-unknown-linux-gnueabi.tar.xz=542428bf11f888825351a2330092d89e6e84ef64fc04e6f283a4d589f2f2dead
+dist/2026-04-14/cargo-beta-arm-unknown-linux-gnueabihf.tar.gz=5ffb33982db8438b6a70301ed62113aaff95762831dda734d70527a19aca98ac
+dist/2026-04-14/cargo-beta-arm-unknown-linux-gnueabihf.tar.xz=5df4b9b37067678f5b6082a9e8c78ced917a316e21abfa1558537cda8cb0a5d7
+dist/2026-04-14/cargo-beta-armv7-unknown-linux-gnueabihf.tar.gz=43cb17ecb56bd720c3149826aebd7eeda20a9a94fa6ddd421cacc1c26c593a4e
+dist/2026-04-14/cargo-beta-armv7-unknown-linux-gnueabihf.tar.xz=deaa36c83c4ea2debfb2ef764e8d7c3032ab78f3013ebc54ccd88bb14fa9a669
+dist/2026-04-14/cargo-beta-i686-pc-windows-gnu.tar.gz=60deced1cf0893e5041304d0b011a6c1ecb2607c73f832a07bdca51eca1db86f
+dist/2026-04-14/cargo-beta-i686-pc-windows-gnu.tar.xz=5f135deca4203757c494822f9cfcb309f014afc280855b759033b735277f5e88
+dist/2026-04-14/cargo-beta-i686-pc-windows-msvc.tar.gz=c3c180c8a2ae512b1114a10b0780436edd205ca0a0c4fbdea037f23dbed06a72
+dist/2026-04-14/cargo-beta-i686-pc-windows-msvc.tar.xz=9e5c5582ae00ef80426cb4d4de8dccf546395ddd30c67cd40f4ec477b7324ce7
+dist/2026-04-14/cargo-beta-i686-unknown-linux-gnu.tar.gz=588bba2636c67b505e8d2db45111ca23e37fde5473d33ba87d4f4a1cb69c4e85
+dist/2026-04-14/cargo-beta-i686-unknown-linux-gnu.tar.xz=0fc96483c3d372ea591bff13e06f3a0ecfb2ae2c611cc08ec3a2ba6158b12217
+dist/2026-04-14/cargo-beta-loongarch64-unknown-linux-gnu.tar.gz=57fec616e8429e94b8007539a1cba2d0d6352a7406157fb524b7293225fe9945
+dist/2026-04-14/cargo-beta-loongarch64-unknown-linux-gnu.tar.xz=854bc5862045d907f62ab4372ae8805c3decc3dbe97d688515fa2c8f65cefa29
+dist/2026-04-14/cargo-beta-loongarch64-unknown-linux-musl.tar.gz=ad3fb29c460353031f542d923cc0a8812c6bb4a9bba887dc6496479eb71aefe1
+dist/2026-04-14/cargo-beta-loongarch64-unknown-linux-musl.tar.xz=e8facd620a406bf3dbdbe5d76621f7fb560f13d86b52286564a25b0eb567dcef
+dist/2026-04-14/cargo-beta-powerpc-unknown-linux-gnu.tar.gz=2a86ea9a1c2a1a2503cd676b71c3576d3ab19a06abf07d36357daf90f2bf932d
+dist/2026-04-14/cargo-beta-powerpc-unknown-linux-gnu.tar.xz=7bf26293463c40551d53452d26753bb43e3731729f71090a2ec72474b75e8d5e
+dist/2026-04-14/cargo-beta-powerpc64-unknown-linux-gnu.tar.gz=1a9eb79a7ee2f4ec769a884ec253a8cf133fe58dbaed032248c9b6ad65d6f2f3
+dist/2026-04-14/cargo-beta-powerpc64-unknown-linux-gnu.tar.xz=a1dffc50cfb99386cd8a2896ccfa781b297cbf7949563cc84c6ff7c4fe1e4df6
+dist/2026-04-14/cargo-beta-powerpc64-unknown-linux-musl.tar.gz=aae0e1c8dfb0ebf5efa4fb8c2d8766dd6f0a97a92b401de288693198716df969
+dist/2026-04-14/cargo-beta-powerpc64-unknown-linux-musl.tar.xz=37725c9c02e32a98b9b0bf214c248757e5fed39e3ac70218a5fba7372e9df049
+dist/2026-04-14/cargo-beta-powerpc64le-unknown-linux-gnu.tar.gz=722430e82753479347676a6ac17930903fc2be8e11ef63a683a1289e0ff23d97
+dist/2026-04-14/cargo-beta-powerpc64le-unknown-linux-gnu.tar.xz=a2e7fee4d916323833c6f9af13da057a419b85a6bca89817dde79b8683f01a79
+dist/2026-04-14/cargo-beta-powerpc64le-unknown-linux-musl.tar.gz=931df7278f7718e96ea2585a5a39e436204686f32fb4a84fce55c689f918e9fe
+dist/2026-04-14/cargo-beta-powerpc64le-unknown-linux-musl.tar.xz=38de6ee97d0e830e9eb07551632179fd821385c3578070801c4ec290ba49952f
+dist/2026-04-14/cargo-beta-riscv64gc-unknown-linux-gnu.tar.gz=27f35cc8add94c5269d5228193a97d2400d1b36170426047275266f0ad93b762
+dist/2026-04-14/cargo-beta-riscv64gc-unknown-linux-gnu.tar.xz=f228ebbdf135314552ed9640dd19119c4b9d064a015e93f5ca489dcc6faff050
+dist/2026-04-14/cargo-beta-s390x-unknown-linux-gnu.tar.gz=6d95df12df479b04a276bad4f41f5ec2bfc9004ec6161a1fac8b9fe0771daf34
+dist/2026-04-14/cargo-beta-s390x-unknown-linux-gnu.tar.xz=fe3e88044788f3e85bb158271a0ec9b034c9818c896ac983e990a441a82a79f6
+dist/2026-04-14/cargo-beta-sparcv9-sun-solaris.tar.gz=0654f1574b4f48a4ce71ecfd353e6bedc260112891d4516fabc5335ddda227b1
+dist/2026-04-14/cargo-beta-sparcv9-sun-solaris.tar.xz=ac52160aceb03a6dbef33d3d02585533d39308e587a2c4a365f5b50000c09d53
+dist/2026-04-14/cargo-beta-x86_64-apple-darwin.tar.gz=3937531fbf60f4eb0a153543b65c4085e63fb0f7a24f9031b39efa3aaabbbbf9
+dist/2026-04-14/cargo-beta-x86_64-apple-darwin.tar.xz=55ded2e0e71ced8150c5aad0ed3ec803e61605cba72e3f6e3310d18adde88dc5
+dist/2026-04-14/cargo-beta-x86_64-pc-solaris.tar.gz=cf270a0fa52af2bc2dcfb5e4a4a53fb63ef4104c4ceeed4db2947aead6f43aca
+dist/2026-04-14/cargo-beta-x86_64-pc-solaris.tar.xz=a9e6be85459a60a23b71f60b8d3b36cc7b30f07c22ed11d4cc0e165cf0f11396
+dist/2026-04-14/cargo-beta-x86_64-pc-windows-gnu.tar.gz=1fccdb6f7a4e0ce9f8f874e7e40e346f1d8a12b483c577476eaf374ff5f68313
+dist/2026-04-14/cargo-beta-x86_64-pc-windows-gnu.tar.xz=81c0dbec9baefb620d51bc90f3974ef520686c3ca9479e1eb51fc75a08b66a5f
+dist/2026-04-14/cargo-beta-x86_64-pc-windows-gnullvm.tar.gz=2655f6e1570112c4b059641d41e9fdbfa162e1f353500acb6bbadf1597bd3e05
+dist/2026-04-14/cargo-beta-x86_64-pc-windows-gnullvm.tar.xz=de098a48e37880a82529fcece1bd696ca2333d9014565e1e6871d5fbd163c073
+dist/2026-04-14/cargo-beta-x86_64-pc-windows-msvc.tar.gz=f35f2076d05aad7e2c18741958c4e11ff6d684c123c3311a4b10d53cd8b5485b
+dist/2026-04-14/cargo-beta-x86_64-pc-windows-msvc.tar.xz=e2867131b82d110755209a81eff1ab178eb01c2b0db72b76bc9d3818b4e26bf1
+dist/2026-04-14/cargo-beta-x86_64-unknown-freebsd.tar.gz=28d105b9cd197d6f79dd0dc3ed641b00db411da99bc7458570928507e24d9fe1
+dist/2026-04-14/cargo-beta-x86_64-unknown-freebsd.tar.xz=b825bad21b29c0152c94bbf6d30e4b84ffb73e7669a786a91b4d01c25e0d26c6
+dist/2026-04-14/cargo-beta-x86_64-unknown-illumos.tar.gz=3760b75f3b6cfa2424a145548d70657accc3c53e55b1f4ecf9d5f1ff05c7f567
+dist/2026-04-14/cargo-beta-x86_64-unknown-illumos.tar.xz=c7edd008d2c0b288d4f3ca1d3e51510bc5fa181149f7c874e46875e1f646a6bc
+dist/2026-04-14/cargo-beta-x86_64-unknown-linux-gnu.tar.gz=ecc8fbb9a4423376f66096086c0b3a33747563dfc1e0221bb5ad00de2483e59f
+dist/2026-04-14/cargo-beta-x86_64-unknown-linux-gnu.tar.xz=d08610c85372207fe77e0e9d5b0d1550d693a34cd983a8fe3e608816b6a8f9a2
+dist/2026-04-14/cargo-beta-x86_64-unknown-linux-musl.tar.gz=348988e5348c6a4c6542e7be10468b31b02d2fb2ba230b95331bff4291324b29
+dist/2026-04-14/cargo-beta-x86_64-unknown-linux-musl.tar.xz=caaf97cfad81738cd18f62a4f32e03568f5879f452001b78483457525e4911f3
+dist/2026-04-14/cargo-beta-x86_64-unknown-netbsd.tar.gz=b11d6f71aa41d5a97ace1e6ef5f0e87fc334bedf7c5b666a0c6748b4b9850a83
+dist/2026-04-14/cargo-beta-x86_64-unknown-netbsd.tar.xz=d637902fc57d547bef7d020c0ee4e673ebaab557cd422eab5574db3fac46fb93
+dist/2026-04-14/clippy-beta-aarch64-apple-darwin.tar.gz=fdfc08f98f9fc6281dc7af4ea6ae00e713515fa7d25821fe6bfa4e4c0266b8ca
+dist/2026-04-14/clippy-beta-aarch64-apple-darwin.tar.xz=0c44e33c08f00ce950ec5490478cc1f18a4d55a2f6855410a7fb541659f4b0d8
+dist/2026-04-14/clippy-beta-aarch64-pc-windows-gnullvm.tar.gz=06da22269fef9e3fd5127b1089fdf96aae9c67ff6839d22f2bb8010f7046d68b
+dist/2026-04-14/clippy-beta-aarch64-pc-windows-gnullvm.tar.xz=6d92cae636ff0731b4aeeaa7e8abd8a0d6f41df23afd8d9bbac45d977cfa168f
+dist/2026-04-14/clippy-beta-aarch64-pc-windows-msvc.tar.gz=f1cbe38245fb1350662872743e06edf824f83b86af9cb775d8231c25428f1032
+dist/2026-04-14/clippy-beta-aarch64-pc-windows-msvc.tar.xz=06aaf155e5660a17a220eb99e29fe76e9e90c4d4864b556e9b2e0091bfc0563a
+dist/2026-04-14/clippy-beta-aarch64-unknown-linux-gnu.tar.gz=997b59820b2628d043076a6a6085dc99267ad3ed9a2e78b1b90c58a6e3a6fe35
+dist/2026-04-14/clippy-beta-aarch64-unknown-linux-gnu.tar.xz=584aab51a31eaa66001a69cdf95cf0003abd378631f5bf44731f35c7aa5a1195
+dist/2026-04-14/clippy-beta-aarch64-unknown-linux-musl.tar.gz=ed573079fc0e3e33bd297b0d76bc01e3f15dcbf83f8461a5f4b43836452867fa
+dist/2026-04-14/clippy-beta-aarch64-unknown-linux-musl.tar.xz=fe5762b039fd7decf8ce9163904e6293169ab235ac7551902a1d2fbf88ea520c
+dist/2026-04-14/clippy-beta-aarch64-unknown-linux-ohos.tar.gz=01337c1c5fc537d1c447a3bf17a44d3e37e319cffa1a52996dbed7fc6c05ac30
+dist/2026-04-14/clippy-beta-aarch64-unknown-linux-ohos.tar.xz=0f36a948f1472aaa6d2191b6295b996ab59e2bea2b64ce203f9e2d90b496189d
+dist/2026-04-14/clippy-beta-arm-unknown-linux-gnueabi.tar.gz=40a26ee6db3512212e2a57770f236976225088deacc9a339a8bab19a9f00cf6d
+dist/2026-04-14/clippy-beta-arm-unknown-linux-gnueabi.tar.xz=27fc628812f1265c637ceeef0b7cd39cede6d0d8e3cdbc8eadd3a360c4d8fd92
+dist/2026-04-14/clippy-beta-arm-unknown-linux-gnueabihf.tar.gz=3c9317e362605e3d2b6468e5564a7342384aab333479da48e32bd36996e96f76
+dist/2026-04-14/clippy-beta-arm-unknown-linux-gnueabihf.tar.xz=38291528c671589a84c1d73bdd08a1a25fea8e2b82f0493879b6f3b9581f3cf0
+dist/2026-04-14/clippy-beta-armv7-unknown-linux-gnueabihf.tar.gz=75ab9dad5a01f3ac1053fb0c8c308b0381c67c85615ec4f85b2e736a1e80e4b1
+dist/2026-04-14/clippy-beta-armv7-unknown-linux-gnueabihf.tar.xz=7d13b495206767a813f9011d317b5e447d23a8cde412a298b22624c2e907e98b
+dist/2026-04-14/clippy-beta-i686-pc-windows-gnu.tar.gz=d0de80d6858023f7192060c45f0bc20b594ecf980d352820939e7e3c07781c8c
+dist/2026-04-14/clippy-beta-i686-pc-windows-gnu.tar.xz=605dbe4cace24eaaefdded781d63e4c0fb7af4ad936b883348d3ab49e27f25fc
+dist/2026-04-14/clippy-beta-i686-pc-windows-msvc.tar.gz=6514ae9b9d0218b2699d7d14d8f1ccac841a28a61da6c2afd66584cbdfd8ffd4
+dist/2026-04-14/clippy-beta-i686-pc-windows-msvc.tar.xz=51793da4bde32228d9c0864cb3a321311e45d95f8a3dd0df9bbc92eea1301366
+dist/2026-04-14/clippy-beta-i686-unknown-linux-gnu.tar.gz=d8b9c4dce2d3d0b4e2aa3ff853d1fbeef272da7775588fead90d4375d1b16891
+dist/2026-04-14/clippy-beta-i686-unknown-linux-gnu.tar.xz=630996c9b6ecddaf72614f5455a94cd2a9a4421213e9984aaf0b55f1fd1c2ff2
+dist/2026-04-14/clippy-beta-loongarch64-unknown-linux-gnu.tar.gz=ad9645ffc7fdd42ed47f7ae975a2f3664b71776e1848e254f31303dd125403db
+dist/2026-04-14/clippy-beta-loongarch64-unknown-linux-gnu.tar.xz=195fc7cf769385dcc28a33ca0c529bd1a2a2f68b8e63e6b5a63257593eb85e94
+dist/2026-04-14/clippy-beta-loongarch64-unknown-linux-musl.tar.gz=996ed71e21cf46a41151a7929cde94baf0be95886a30449ba4f037376d4b2e89
+dist/2026-04-14/clippy-beta-loongarch64-unknown-linux-musl.tar.xz=07353278f796d7fb8195fddb9c6864f279817c9fc47797ec594658d44e02aa70
+dist/2026-04-14/clippy-beta-powerpc-unknown-linux-gnu.tar.gz=7730841926bda3faebfdfc8b556cc6ab536bc9ea63b915f5c26fcb7b623a6651
+dist/2026-04-14/clippy-beta-powerpc-unknown-linux-gnu.tar.xz=e7a7c37d7adcc0732b608efd73c080d322864992a3180bdb44b49375ec2fb6e3
+dist/2026-04-14/clippy-beta-powerpc64-unknown-linux-gnu.tar.gz=915aa0e233eefe2ed15eea8b1dccf23ea6540c3b8f917eb457bd4529a6ae4723
+dist/2026-04-14/clippy-beta-powerpc64-unknown-linux-gnu.tar.xz=eaea79157d9a9af8ff4ef361e3735a915dfccc508e8a3addf873666fe3191949
+dist/2026-04-14/clippy-beta-powerpc64-unknown-linux-musl.tar.gz=df714b07886cafe14c2a2fd095ab6cc0bf4d892f988549817947f4aa00b7ed13
+dist/2026-04-14/clippy-beta-powerpc64-unknown-linux-musl.tar.xz=66fef5a4671e3a86a12f749dcc36361b564a218f815f3c69f72baac8a89b11b2
+dist/2026-04-14/clippy-beta-powerpc64le-unknown-linux-gnu.tar.gz=6f39657ad070bf33f683cef5e3e19521c8c0c58012f6bb36f30f728d497e4c19
+dist/2026-04-14/clippy-beta-powerpc64le-unknown-linux-gnu.tar.xz=75f77ed2701ddf7b9c2c0fee5edd5e6e99b63b994522c132c5f4f1e01ce4328e
+dist/2026-04-14/clippy-beta-powerpc64le-unknown-linux-musl.tar.gz=6ea666b900910f65319e819948a9dd68340d73b399b45c903a8d712f6484746d
+dist/2026-04-14/clippy-beta-powerpc64le-unknown-linux-musl.tar.xz=6fc51ab9a2ec683106ce8064728ee89f795b0bbf2acbb1489ecaa094167b6e7a
+dist/2026-04-14/clippy-beta-riscv64gc-unknown-linux-gnu.tar.gz=820ff2d0aeab4e2863af6e6369f8420d024c691714dd0a9d1f2c7c46615501ca
+dist/2026-04-14/clippy-beta-riscv64gc-unknown-linux-gnu.tar.xz=3dd9a04d86dd975328b97137d5ac315f51736b7c72fe38c69fe9b306d28afb24
+dist/2026-04-14/clippy-beta-s390x-unknown-linux-gnu.tar.gz=08bee1014c5ef701574b1c03a41de7cedfa1ed01c5313526fb9d3c621559f957
+dist/2026-04-14/clippy-beta-s390x-unknown-linux-gnu.tar.xz=352b3f4c20087b3d331a7d758ffd0f7d37ae95c74c51a3adb497caed30b15e57
+dist/2026-04-14/clippy-beta-sparcv9-sun-solaris.tar.gz=967ab7ee344e265a24227ffc16da947499723f7108923d5a41eb1b6aec1565aa
+dist/2026-04-14/clippy-beta-sparcv9-sun-solaris.tar.xz=47304c45cf09fc4d79e1120b8800cd6f8660bb92dacf0a24dcf3d9488fecd978
+dist/2026-04-14/clippy-beta-x86_64-apple-darwin.tar.gz=dff3f80b3a32b592397e38694e698d6bf7b7e060b1d3c43474a8da706c6f1f14
+dist/2026-04-14/clippy-beta-x86_64-apple-darwin.tar.xz=2e5ec7a1f4e521712e73ee95fe8a3037319c4a1fb7f711786e342f09396cbbfc
+dist/2026-04-14/clippy-beta-x86_64-pc-solaris.tar.gz=d9b0a9f21f4f0f03e61870fca7aecd0fc77e2cda7307354eba8617c70b731628
+dist/2026-04-14/clippy-beta-x86_64-pc-solaris.tar.xz=c5b1ef728c858a5635e85e830900fb559f00bedf05f9e915b177dbceec02bb1d
+dist/2026-04-14/clippy-beta-x86_64-pc-windows-gnu.tar.gz=6e8c4fb6de025286e48cfbd6733a4da6e0a00932754f88d909323db4dc61f657
+dist/2026-04-14/clippy-beta-x86_64-pc-windows-gnu.tar.xz=b7d6838c62dd07d94adced58add5de7d2df5fdc5d208f8f6673e3f09f059880c
+dist/2026-04-14/clippy-beta-x86_64-pc-windows-gnullvm.tar.gz=d56b5dec0a95f17e2c5582aa34f8de45202c115e7b985d54325e4a59843e24b3
+dist/2026-04-14/clippy-beta-x86_64-pc-windows-gnullvm.tar.xz=137fd932794796421c95be2395ce79bd1dd1c4fb1b5c3f043c886ee99a113aef
+dist/2026-04-14/clippy-beta-x86_64-pc-windows-msvc.tar.gz=2bd3935f7ad29706c964250dfc46e324dc23de4366976918c4f7fa67887cdc15
+dist/2026-04-14/clippy-beta-x86_64-pc-windows-msvc.tar.xz=b1180408bacb681fa5be86fdd26b13ef4b09e60add0058de3b499ffd9d97f85b
+dist/2026-04-14/clippy-beta-x86_64-unknown-freebsd.tar.gz=3377d3e117613e3375321905d0bb2b4dfd1661ebc21efea10c203459ddca11ff
+dist/2026-04-14/clippy-beta-x86_64-unknown-freebsd.tar.xz=2767076c74035ce97a2a3748df99bc35a908015a50a389317bdf3c6c563dcfb7
+dist/2026-04-14/clippy-beta-x86_64-unknown-illumos.tar.gz=8da6742093b92af4eb0ad2e92ba74c0135c7274960ecc2ac67cbb9dabec9ea90
+dist/2026-04-14/clippy-beta-x86_64-unknown-illumos.tar.xz=7893063f13ae3b3804da9a76c2ef86d2b1f850cc8f7a21ab1d0713090f315de9
+dist/2026-04-14/clippy-beta-x86_64-unknown-linux-gnu.tar.gz=4b7e20a25c85c6387af23b07498c0305d78ffc9677f7f3f29fd6d688f49f6804
+dist/2026-04-14/clippy-beta-x86_64-unknown-linux-gnu.tar.xz=822b901903aec0c08fa19816d852fc1df0bd38358af9114703529ad0d3207ed1
+dist/2026-04-14/clippy-beta-x86_64-unknown-linux-musl.tar.gz=a54f5f0b0bef55b30b69b581c3ec878431900b1aebd105ade1009b68d8fc59e7
+dist/2026-04-14/clippy-beta-x86_64-unknown-linux-musl.tar.xz=a4ac345d6574e5676fcce0819d56a22b5f7e26a0cb17e9c78ae84c3868c92bf2
+dist/2026-04-14/clippy-beta-x86_64-unknown-netbsd.tar.gz=53408e1388d3978741702cfc6678b925afdbb8a746368c3bf55d02822b059e85
+dist/2026-04-14/clippy-beta-x86_64-unknown-netbsd.tar.xz=40fa8d9d3c146e0e8cf4ac59a4720ebfc84aacd7986b5bac6655c05d062bf745
+dist/2026-04-14/rust-beta-aarch64-pc-windows-gnullvm.msi=27c559058f6946ee7903b218eaf2fcb920ac9f68431e1f087cd88ce9b376029e
+dist/2026-04-14/rust-beta-aarch64-pc-windows-msvc.msi=c2288c1aec98c255c786860c8920a11e9c1c66af7585df6c4a4046cb78782fde
+dist/2026-04-14/rust-beta-i686-pc-windows-gnu.msi=c2043bde4fbcef4a696b0e64fa590fa8c59ef0c3240c40050e9c7a8c3a0b5dbd
+dist/2026-04-14/rust-beta-i686-pc-windows-msvc.msi=a59ee54ba0f2b365c2e2d309d788fbb6c7bfe73bfcc02032f757b68dff6a8c9c
+dist/2026-04-14/rust-beta-x86_64-pc-windows-gnu.msi=99d55a913842ea31b92546f7a4e94d418fbef38edccfa8f81ad3b32dd0ae796d
+dist/2026-04-14/rust-beta-x86_64-pc-windows-gnullvm.msi=5960a87ccbc894c0dfb6150efea9d6ee02a4174764f37a45a4a25712b7ef8550
+dist/2026-04-14/rust-beta-x86_64-pc-windows-msvc.msi=69facef2e9e21de88dd680993242995f774ced5ebf2c89cca1ee225942777833
+dist/2026-04-14/rust-beta-aarch64-apple-darwin.pkg=0b5c82f82bd01814050add207c3aed0db18f9c8e42060859227d74cd1911c2c4
+dist/2026-04-14/rust-beta-x86_64-apple-darwin.pkg=be21af65a60626a081308b98de96c21187009c3aa457e918caf37f75d17d76b5
+dist/2026-04-14/rustc-beta-src.tar.gz=bd594961759ac8a575f2bdfb803a7e223fbccb1bbac5cf87fe541cee7c96decb
+dist/2026-04-14/rustc-beta-src.tar.xz=202f45516b821164e617244725fbf014742dd00664ed11525e81f7ad0882f3a5
+dist/2026-04-14/rustfmt-nightly-aarch64-apple-darwin.tar.gz=4988e2b3c6ba0c18523b8bf980827d45d5d5d21cca50726a47c19203bc95e14f
+dist/2026-04-14/rustfmt-nightly-aarch64-apple-darwin.tar.xz=dacce0fa1c73685f979ee4cb5dd91824773f08408370ea74e719c171a044c8ed
+dist/2026-04-14/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.gz=532847f2799ba84e4049c1a984886370cf42f3d599ab7df28d3d6e7eca8fcd27
+dist/2026-04-14/rustfmt-nightly-aarch64-pc-windows-gnullvm.tar.xz=8abbd6f8803f214e8ed870de328822dac330051f5c0aafa5179c7eb48cb817fc
+dist/2026-04-14/rustfmt-nightly-aarch64-pc-windows-msvc.tar.gz=e83b58941e1a885043024e7c1841b84facfd2285b960c895881b1f23655d74d0
+dist/2026-04-14/rustfmt-nightly-aarch64-pc-windows-msvc.tar.xz=d2ff3bc238daa09ae041d88bf9a895ae4174f50757ebefadc50a90e5fe74098b
+dist/2026-04-14/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.gz=5a9a858ea2cbe6bfbee4eb48e819bc9e06732795883364105ff6187c551097cb
+dist/2026-04-14/rustfmt-nightly-aarch64-unknown-linux-gnu.tar.xz=269ccbdb5fa3aaad14a43b0d987626a34aac6676e98082661419cbe341ec6bec
+dist/2026-04-14/rustfmt-nightly-aarch64-unknown-linux-musl.tar.gz=fd4b5bc3ca04fff7324d3c9b478f4ea495d3f76237a4b605fc0611345188d049
+dist/2026-04-14/rustfmt-nightly-aarch64-unknown-linux-musl.tar.xz=7301952d391b41c022ab2c7a8ce6d336d7a08865cce07798aeb0ce122ac523dc
+dist/2026-04-14/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.gz=c65d5e893228d1ebc675cfe3f748592b585ada56f6325071d3548473094ba50c
+dist/2026-04-14/rustfmt-nightly-aarch64-unknown-linux-ohos.tar.xz=7e9a1f7d40f6eeba5b3ae18dd7038f3837e918df5e17ce13b60331bf5ea1b36b
+dist/2026-04-14/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.gz=65a223192828d09cd5d74aa36ef96d725c828d5dfca405a053c8c7a8925a0b03
+dist/2026-04-14/rustfmt-nightly-arm-unknown-linux-gnueabi.tar.xz=eb8dd1fd0e686add3dbae3e3f7cf94a356c103e3449cace417148e88a8f30b23
+dist/2026-04-14/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.gz=7a3fff9db4c2141ac743ae2edfa5b5ab08de588c56c4eff1bad28c3068792924
+dist/2026-04-14/rustfmt-nightly-arm-unknown-linux-gnueabihf.tar.xz=9fc87cce59f38e5397c7105ce2d48013b5e5e490c2fdfe610fa0278a297d3748
+dist/2026-04-14/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.gz=3ca8a9fa7acde741ece6bd8e7f30717b6315b4fa804ef153fa1913c95ca28c9d
+dist/2026-04-14/rustfmt-nightly-armv7-unknown-linux-gnueabihf.tar.xz=9c8a21411f6fea0caf3532e62fe6d0e54f2ad2280b56b202491fc562cd81b558
+dist/2026-04-14/rustfmt-nightly-i686-pc-windows-gnu.tar.gz=9fda7a3ce38f7e6ebaea9a5c0efb3c75079bfb202a8b03570e0a49a5b4fbf442
+dist/2026-04-14/rustfmt-nightly-i686-pc-windows-gnu.tar.xz=7c1853f533eef11a23d4c4618885528f6e22c0a48e60de0f552df90cfb9a1488
+dist/2026-04-14/rustfmt-nightly-i686-pc-windows-msvc.tar.gz=1f1907befe3fd07d33ad69afaa06358003074b4d8242e09a2b28185c676d9438
+dist/2026-04-14/rustfmt-nightly-i686-pc-windows-msvc.tar.xz=829e2618dd59669c2ba4ad56b58535c52a83eb49ec44a36c6ade93411aec244e
+dist/2026-04-14/rustfmt-nightly-i686-unknown-linux-gnu.tar.gz=e7a92c0c1bb0de3a05b61c7b1674170f9628d7e941f63e44a98e0e10d49cb427
+dist/2026-04-14/rustfmt-nightly-i686-unknown-linux-gnu.tar.xz=78c9c255cefc103e68f71212522ef8aed9ced49890b173bca8d08e74e6fcd3c7
+dist/2026-04-14/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.gz=033e48f2213258d4836a67b4e03882599272e227870d588d597455858fffd4d0
+dist/2026-04-14/rustfmt-nightly-loongarch64-unknown-linux-gnu.tar.xz=ece1e2a2375d4da3931ad65da0ce15dd8a21d224fd1c7d663e6575c5eefdb6f5
+dist/2026-04-14/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.gz=c63aced5a2243c8563021ccda76ad493120a9fc65b38e044d43c48a002d0181d
+dist/2026-04-14/rustfmt-nightly-loongarch64-unknown-linux-musl.tar.xz=f277ff7ed2574b7b348f2f52a83988035a6e52a949806ac70e8ad082ad1412fb
+dist/2026-04-14/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.gz=0050277d6fda982c243746a09b0aba02735bbb940864f9d910e54216665ed676
+dist/2026-04-14/rustfmt-nightly-powerpc-unknown-linux-gnu.tar.xz=f0702c9e3a203dcb35d2b68f2bbecfccd9bc9c3f558cc9265f20dbd9e1120825
+dist/2026-04-14/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.gz=d401f1d7ab50200ce67dc4cafe0691197183d7d57115e2838e14125be00c64e4
+dist/2026-04-14/rustfmt-nightly-powerpc64-unknown-linux-gnu.tar.xz=3ebabe3f3f5d8c70382d0bd25d6391eb7f903189b0ca16ff7377cb88e43c179a
+dist/2026-04-14/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.gz=65fe9a35de40d66fc4091e8ebb887395e5df510cae883b396ec11219961e5488
+dist/2026-04-14/rustfmt-nightly-powerpc64-unknown-linux-musl.tar.xz=929456f8a5ef40256242b0ebf0600c5bd41434e6f1bb538d08fd89ca1c58c175
+dist/2026-04-14/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.gz=edc55ab2314c81295776e2348672c9a5ff1c29161fe7379fc937479c2e36df98
+dist/2026-04-14/rustfmt-nightly-powerpc64le-unknown-linux-gnu.tar.xz=212a4ac158b0fd2fad5557e893fd1b0d97613f0695a3aee3133e3274cf646920
+dist/2026-04-14/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.gz=1f190928db5257cd20760a898b46463693aeb40ad5d2488c05ffe2e8221e4e18
+dist/2026-04-14/rustfmt-nightly-powerpc64le-unknown-linux-musl.tar.xz=53d26b847383e643ee9cdc331a6b7a29c7986b91a32f1580f0f640e644f175fb
+dist/2026-04-14/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.gz=eca26358c02964a2e9691a2aa83e66150e4f96364e418dedfe3466439a82d4eb
+dist/2026-04-14/rustfmt-nightly-riscv64gc-unknown-linux-gnu.tar.xz=bc37420bde24aed17be23ccd56c151fe66b48e6dc3dd705a6c3ffc6fb4276b37
+dist/2026-04-14/rustfmt-nightly-s390x-unknown-linux-gnu.tar.gz=133f46731c8f52ec0b5ed9683241a7a833bfa7477a072ae3a9e312bce26ec12e
+dist/2026-04-14/rustfmt-nightly-s390x-unknown-linux-gnu.tar.xz=9995837171346bcdfdda9718074f8374df276753eecd4031b586123af0ddfaf3
+dist/2026-04-14/rustfmt-nightly-sparcv9-sun-solaris.tar.gz=ef1f83580055a3cc717fed9af5240941c1477fe33fe1dfd9c3d049cc37180185
+dist/2026-04-14/rustfmt-nightly-sparcv9-sun-solaris.tar.xz=587af349e6c6cb0e25f23b0a2c087caf4ca413e731bfffe00dcadd77ea8c2212
+dist/2026-04-14/rustfmt-nightly-x86_64-apple-darwin.tar.gz=c10f72edd02d6792f706f769d27cf162abf9dc88eda0ed1fc9205bee14575177
+dist/2026-04-14/rustfmt-nightly-x86_64-apple-darwin.tar.xz=78ae63443d8edd4d4f5eba8d9611f2dde46936a1563be7128af82e9b5d4f730f
+dist/2026-04-14/rustfmt-nightly-x86_64-pc-solaris.tar.gz=0ac6f569443662279cd071353f01d9b6b41a2d6610971f35a4ecebe34b7d9c52
+dist/2026-04-14/rustfmt-nightly-x86_64-pc-solaris.tar.xz=3c6ccc0e763adca27b8faae4d8a8a851006d3fd7ef0671edc2573a90d3461757
+dist/2026-04-14/rustfmt-nightly-x86_64-pc-windows-gnu.tar.gz=12e61bd14af8a8acfeda678e7cb348f6537534fccea8b6866ab91f4621a0aae5
+dist/2026-04-14/rustfmt-nightly-x86_64-pc-windows-gnu.tar.xz=1b995011d7e89b730d6b77a27c46596788a188a2571dcb70ed28fa14a2052cec
+dist/2026-04-14/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.gz=bad8817ff2785961ec1bb79357657963ddbc1f3a8856aef93d8cfc459250e462
+dist/2026-04-14/rustfmt-nightly-x86_64-pc-windows-gnullvm.tar.xz=27a61211a0ce149bb502909fd828f99a3e9128f66c05194443f6e1e9b2e04586
+dist/2026-04-14/rustfmt-nightly-x86_64-pc-windows-msvc.tar.gz=885f882e2a5e66c05e348f3617ba90399da734e21e76b6933eee4f23a83ba9d2
+dist/2026-04-14/rustfmt-nightly-x86_64-pc-windows-msvc.tar.xz=afbbc1dd8cf74d92378287ab44e6e1af4f532894767dab00eba428228f3c6c66
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-freebsd.tar.gz=b928d87957ccdbedab31b1b6fa549f5c2958e9a811792b9c862469e3d8435fb8
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-freebsd.tar.xz=4c71a9a131e2a97b6bba902e97da1c6e953b435f6e322ea9508ee1f060293cc2
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-illumos.tar.gz=d12933f927b321fb4c579ec894e4372d14b33df9ac772df86824a1019925e042
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-illumos.tar.xz=91229ad6671f25d347453a49ef1b25971fc200985d7f4862457310e61deb1ada
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.gz=71acc8c0c52483725dcce94f5098c5a3d042f7faf478fcda60de2e809b2d642a
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-linux-gnu.tar.xz=333fc4731da2c724e70f9e60ece6ad932fd5eda912aa188149275dda1997c0b9
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-linux-musl.tar.gz=36eb2999e9d542f540b5ed9c9b7dfe62db95c43f168752f32efaa4f874a085c5
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-linux-musl.tar.xz=51e35060d731ef9b5917315915621a8b0e924d9c3dd8f346bfd32e20d17c4711
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-netbsd.tar.gz=8cd2a11a20148e96b8b030329d0830b3ee168d8c71d31eae4893d77a5e0fae6d
+dist/2026-04-14/rustfmt-nightly-x86_64-unknown-netbsd.tar.xz=1f2da033ccebd5e1f055019e9e6d0f6d3ce2fd57e46a08ff6a3357572050a234
+dist/2026-04-14/rustc-nightly-aarch64-apple-darwin.tar.gz=13a70dbb3aaf2a5296367832e92975d4a6636d944275de5b9cc1d4592a9b1805
+dist/2026-04-14/rustc-nightly-aarch64-apple-darwin.tar.xz=78f8b383c22eef6e27f9e2f2255af63eed306a96adfc851a305a6a33e11d1f2a
+dist/2026-04-14/rustc-nightly-aarch64-pc-windows-gnullvm.tar.gz=772b59c215cb8dec79bd3a537681c8b37051390e52d75986db8af5843c2f7341
+dist/2026-04-14/rustc-nightly-aarch64-pc-windows-gnullvm.tar.xz=d29721ff7624cd3df53ec69f78c9d8f75e24455b7dd2c0dd3dd1ca53f66b71e2
+dist/2026-04-14/rustc-nightly-aarch64-pc-windows-msvc.tar.gz=4f9cf47d1560dc516b63913e4e89c17d1b89b5c8cfa677ecd8fa538bfc4afe12
+dist/2026-04-14/rustc-nightly-aarch64-pc-windows-msvc.tar.xz=67fa760544169a924211457b5150f4bcef0b2e3deb717c67677b346edaad3f4e
+dist/2026-04-14/rustc-nightly-aarch64-unknown-linux-gnu.tar.gz=f51048b6622957f10a314a09889c8749234c8456b5c826958069a6856e0166fe
+dist/2026-04-14/rustc-nightly-aarch64-unknown-linux-gnu.tar.xz=2c22b92466453884f6afed1f6f733c982492f247e03740892d253930c66b6d45
+dist/2026-04-14/rustc-nightly-aarch64-unknown-linux-musl.tar.gz=d478bb6dc0af51fd4e7e007a825e09d26fdefe8d2eff251e8a055e67dc82830a
+dist/2026-04-14/rustc-nightly-aarch64-unknown-linux-musl.tar.xz=335947b16552795ec3c5f525b1bcb2b82c54bd0726146d3d8685f7b0202e8b4e
+dist/2026-04-14/rustc-nightly-aarch64-unknown-linux-ohos.tar.gz=3ac6ea0c484ca7c4b020a2b333cefdd01830fa1ba2d3fa8efbd911ca810bfa3c
+dist/2026-04-14/rustc-nightly-aarch64-unknown-linux-ohos.tar.xz=4125e5b0940f0859a3778b0cb441a8504c8276064e1b7413c174e5cecab05795
+dist/2026-04-14/rustc-nightly-arm-unknown-linux-gnueabi.tar.gz=e764a83c5818b6ec8c06a448bcba7d89e02b071a3e8666ddef61943e1b3c9952
+dist/2026-04-14/rustc-nightly-arm-unknown-linux-gnueabi.tar.xz=c2b69576d1fc1bf8e2803bbada5766af3dd388912f9609125d514e28d7898b09
+dist/2026-04-14/rustc-nightly-arm-unknown-linux-gnueabihf.tar.gz=909e94363fdc0f04e0e2fa43afce22f85626a89d6305f0e578d0c45ab1b41e2f
+dist/2026-04-14/rustc-nightly-arm-unknown-linux-gnueabihf.tar.xz=75581145a7bcd75e628bbb29f833b4faab31647bc2a846ac5a5403047974a594
+dist/2026-04-14/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.gz=e0fb27cd6686bb340754ce148eb99ea07d1b0a0cacdb47d555979159d3238bf3
+dist/2026-04-14/rustc-nightly-armv7-unknown-linux-gnueabihf.tar.xz=5f2dd01b77130d610ea5f0c964f8d90a556619a9ac8be27ca194ab3fb69548f0
+dist/2026-04-14/rustc-nightly-i686-pc-windows-gnu.tar.gz=a75f7a65711135059bbfa680d0e1008accdc01bedaa281de20f4a6243a8a9702
+dist/2026-04-14/rustc-nightly-i686-pc-windows-gnu.tar.xz=be1bcad0c88c3e1b513d316cb944d2d292dbc76fbf9e5f65e7932d45187ef6b0
+dist/2026-04-14/rustc-nightly-i686-pc-windows-msvc.tar.gz=a910ea7aba73b75b330b4fafbf519c708659f85e6cc76b2701f12b93619fb7d8
+dist/2026-04-14/rustc-nightly-i686-pc-windows-msvc.tar.xz=693e043882ebc1ebea21d65bfd1babc96bfe80a0d43f8ae2b9a70a9070683b33
+dist/2026-04-14/rustc-nightly-i686-unknown-linux-gnu.tar.gz=c1cd472c333178e1566687758a3e8026e6c686ec825c48730eb99a5133645fd4
+dist/2026-04-14/rustc-nightly-i686-unknown-linux-gnu.tar.xz=c30771464bbbcfa1ce7843644c461222e8c0ddd41a339af857d71e64929aca36
+dist/2026-04-14/rustc-nightly-loongarch64-unknown-linux-gnu.tar.gz=716ea63ccbf0578e96aa70909a4855f68c577da5c08874a10750e217df480966
+dist/2026-04-14/rustc-nightly-loongarch64-unknown-linux-gnu.tar.xz=f8d499e4777cbd664e12d475caa50728464ee3f430d1ce01ed13b6d23534ff70
+dist/2026-04-14/rustc-nightly-loongarch64-unknown-linux-musl.tar.gz=fca3a60606670897286d5ba99629051d79fb5f8a58c775eacd630e22f2f6c0c0
+dist/2026-04-14/rustc-nightly-loongarch64-unknown-linux-musl.tar.xz=29c2d67bf1cb3200821dbf50125b478b131a6a5c122c543770897716a5b5ba72
+dist/2026-04-14/rustc-nightly-powerpc-unknown-linux-gnu.tar.gz=dd15b14de18d033d47ca8329b61f1908f34de0255dfce43f5e215ae5274b1bdf
+dist/2026-04-14/rustc-nightly-powerpc-unknown-linux-gnu.tar.xz=3501229024c2474d887a8b0c6d7a06454209c472cd70884e6f90bd507d62e3af
+dist/2026-04-14/rustc-nightly-powerpc64-unknown-linux-gnu.tar.gz=799a80733eb84738fe79719177ffb17d81382369159393fb8c5b03f88650c406
+dist/2026-04-14/rustc-nightly-powerpc64-unknown-linux-gnu.tar.xz=6f3b41f9d936e70f1a2e617068a999f02c051f1e6211481c0630c9bbdf6e7f25
+dist/2026-04-14/rustc-nightly-powerpc64-unknown-linux-musl.tar.gz=1cc73dd3187a70c20d8e790fa56a2d6ecb278e4547fdf77e562fa22d69e2177a
+dist/2026-04-14/rustc-nightly-powerpc64-unknown-linux-musl.tar.xz=4da7e7cc44d8370c911969f8e35454f23a6284029ca6ebf81ab6ff6c100072f8
+dist/2026-04-14/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.gz=ef97408edbc38ab58f8e86261e53f60196790b186567bdff3924ad959d755976
+dist/2026-04-14/rustc-nightly-powerpc64le-unknown-linux-gnu.tar.xz=d3a3cb98454f10d0a27009a4a3bcc38d164a81ab592dbc722381f62654d309c7
+dist/2026-04-14/rustc-nightly-powerpc64le-unknown-linux-musl.tar.gz=d8f15c170e7a8bc856e28012eca5c45686f194f0c21e45de9008cf92170646d2
+dist/2026-04-14/rustc-nightly-powerpc64le-unknown-linux-musl.tar.xz=4e616a529c502fb4b445eb8d55cac1247c037a2e9800b614187a4a86936eb9b2
+dist/2026-04-14/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.gz=5162ebc9cfc3ff76226c0ed3d4a718939be4a74fca1aa5288e0dcddaab7fa7d3
+dist/2026-04-14/rustc-nightly-riscv64gc-unknown-linux-gnu.tar.xz=82879c0c9b55855204f3d6869aae565a5553b9cc281a97d427ce81101f1658ae
+dist/2026-04-14/rustc-nightly-s390x-unknown-linux-gnu.tar.gz=cc40c7d8d692719b7f3e5a8dd85272d42af4ce3f33528fa945b335d0639adeff
+dist/2026-04-14/rustc-nightly-s390x-unknown-linux-gnu.tar.xz=cd36435e1c3a8f888ee7fc531f5efc0e5a1d375b9df8e64efe977ae8a6f7b2b0
+dist/2026-04-14/rustc-nightly-sparcv9-sun-solaris.tar.gz=ddee30c3e11f137cc02679949c5e8b808d50f70090cf074d0eecbdeb3b9610e7
+dist/2026-04-14/rustc-nightly-sparcv9-sun-solaris.tar.xz=21fdb743e692f55bd0a66fb131cc5906f13adb023e51e1a29b385cde3a5932f5
+dist/2026-04-14/rustc-nightly-x86_64-apple-darwin.tar.gz=e391518e93bbc18fcf3e46360afe00ad1ea9f6798aec64124818a152715f922c
+dist/2026-04-14/rustc-nightly-x86_64-apple-darwin.tar.xz=14e16b07cf7c1d001568085eda8112a8a11c1736518eb743205f6b049b75b39f
+dist/2026-04-14/rustc-nightly-x86_64-pc-solaris.tar.gz=fa1ba81680171e30652b18923a67d9875500ec5a4a5ca2b9d58bfa0a6a605091
+dist/2026-04-14/rustc-nightly-x86_64-pc-solaris.tar.xz=8133fe568daca53cfc8b7d7dc5ff4451e82bbb68ed315c678cc00335323550fb
+dist/2026-04-14/rustc-nightly-x86_64-pc-windows-gnu.tar.gz=8011fcdcc2c893e6035fc57b1dd364ecdd8cd7e6a0aa4e283d12466c0e7c4dc6
+dist/2026-04-14/rustc-nightly-x86_64-pc-windows-gnu.tar.xz=5a6cefdf79ed1cd62ab6f9f72c2cba9096c0f4ee22639fd64cdf97b5370dd0d0
+dist/2026-04-14/rustc-nightly-x86_64-pc-windows-gnullvm.tar.gz=801f914fcd1b4b322b3aa5951b81b53a207ceee4ba097d8224c756de115643e5
+dist/2026-04-14/rustc-nightly-x86_64-pc-windows-gnullvm.tar.xz=3532130975072968bf35fdce94f98115de2d2a0cd5e25aed9c29162795f3a297
+dist/2026-04-14/rustc-nightly-x86_64-pc-windows-msvc.tar.gz=500703a85e38b7a4ce00e36655e931558ef23db4b32fd5c7bc676676c84c4faa
+dist/2026-04-14/rustc-nightly-x86_64-pc-windows-msvc.tar.xz=2bd9987d711b7e1206398b7a9d7d4352b5c917259728f1de223d57e61b5451f2
+dist/2026-04-14/rustc-nightly-x86_64-unknown-freebsd.tar.gz=ad67954b068b5e4c0390344b7821141a5586958ba40c93ba50b59f0f16579850
+dist/2026-04-14/rustc-nightly-x86_64-unknown-freebsd.tar.xz=2dc93c054383ad661700450419c0b634cb7f07d4785db1bf8282b418c30ced35
+dist/2026-04-14/rustc-nightly-x86_64-unknown-illumos.tar.gz=cdd1e60cdec961885d8257e326e9aa4fcad01e254de05d3d06c72f5ae8a6c968
+dist/2026-04-14/rustc-nightly-x86_64-unknown-illumos.tar.xz=fed43cb199d09a8bc21eff285fae0307fba8b75e9f94173d4016eee53e51c59b
+dist/2026-04-14/rustc-nightly-x86_64-unknown-linux-gnu.tar.gz=75ff840114825b1d828c478d77db5617f17329e8309868ba94cdfd994172ae52
+dist/2026-04-14/rustc-nightly-x86_64-unknown-linux-gnu.tar.xz=a54f0205c6b7068f54e424a5b923834e8222d28ddcfa7da677ce268e88ff2c52
+dist/2026-04-14/rustc-nightly-x86_64-unknown-linux-musl.tar.gz=43071bdad63347cf9deaa0b860ad9bc086323fa0cb4c5519f2246d39180586c2
+dist/2026-04-14/rustc-nightly-x86_64-unknown-linux-musl.tar.xz=d8ed67a9d66e9536827df84157770ff04fac04283afd4f2eff791cdf6a83a282
+dist/2026-04-14/rustc-nightly-x86_64-unknown-netbsd.tar.gz=8c16b7deaeacd2a2631a7ecc7338d47ac4bdecfa52f71ac70d7b93513fb0e2ed
+dist/2026-04-14/rustc-nightly-x86_64-unknown-netbsd.tar.xz=6c20270030613b1f2c98b33dd8310929558e6f58048e21f7a36423e50de0fc98
+dist/2026-04-14/rust-nightly-aarch64-pc-windows-gnullvm.msi=f78cc56f163c90311b025181a8e1db9dda59d58b3556968c0cdf3dbb4507097f
+dist/2026-04-14/rust-nightly-aarch64-pc-windows-msvc.msi=95550ae060542483ad774574b2fc8cb79a5f2f70a3b06bb82cbf5a40bc871757
+dist/2026-04-14/rust-nightly-i686-pc-windows-gnu.msi=97efc785c12cb0fdb6906456e4726d0eb2adbf85a4dacb2daa61f6a6319b036b
+dist/2026-04-14/rust-nightly-i686-pc-windows-msvc.msi=26a28eac06d0aa20aa226747ad8e1629552c2550b572a8c97a85cc2d1d8ea1db
+dist/2026-04-14/rust-nightly-x86_64-pc-windows-gnu.msi=01e35ac3cbfd26ccdffe93e9d2eea55381cc9b6faff8d65326bece13527fbbc9
+dist/2026-04-14/rust-nightly-x86_64-pc-windows-gnullvm.msi=8d0454333d8b187eaa6fd3a2275948999a2208f2b6a88706c2ace747b112a85f
+dist/2026-04-14/rust-nightly-x86_64-pc-windows-msvc.msi=72b999b71ccbbd63f0603640a0e6152d2ba2d285bf0879e5dab8f5576e5aeb9a
+dist/2026-04-14/rust-nightly-aarch64-apple-darwin.pkg=09cf7f8fb13d38435739546cf11e690fab6011a8aae6cb23661c839f7e1a5318
+dist/2026-04-14/rust-nightly-x86_64-apple-darwin.pkg=ad30ba52b79c11e3dc7e00f50fea9d411d37d52b44f1e6cc6fa320a81bfa8ea3
+dist/2026-04-14/rustc-nightly-src.tar.gz=57aa9382fbcf1cce748da037f94062404652d9f48514567a973322304e8c6975
+dist/2026-04-14/rustc-nightly-src.tar.xz=5ab46adda987bcc2bdf2335088c5c4114b80d8bdd657803ddb9b775e67743e67

src/tools/compiletest/src/directives.rs

@@ -185,8 +185,6 @@ pub(crate) struct TestProps {
     // If true, `rustfix` will only apply `MachineApplicable` suggestions.
     pub(crate) rustfix_only_machine_applicable: bool,
     pub(crate) assembly_output: Option<String>,
-    // If true, the test is expected to ICE
-    pub(crate) should_ice: bool,
     // If true, the stderr is expected to be different across bit-widths.
     pub(crate) stderr_per_bitwidth: bool,
     // The MIR opt to unit test, if any
@@ -220,7 +218,6 @@ mod directives {
     pub(crate) const COMPILE_FLAGS: &str = "compile-flags";
     pub(crate) const RUN_FLAGS: &str = "run-flags";
     pub(crate) const DOC_FLAGS: &str = "doc-flags";
-    pub(crate) const SHOULD_ICE: &str = "should-ice";
     pub(crate) const BUILD_AUX_DOCS: &str = "build-aux-docs";
     pub(crate) const UNIQUE_DOC_OUT_DIR: &str = "unique-doc-out-dir";
     pub(crate) const FORCE_HOST: &str = "force-host";
@@ -307,7 +304,6 @@ pub(crate) fn new() -> Self {
             run_rustfix: false,
             rustfix_only_machine_applicable: false,
             assembly_output: None,
-            should_ice: false,
             stderr_per_bitwidth: false,
             mir_unit_test: None,
             remap_src_base: false,
@@ -377,10 +373,6 @@ fn load_from(&mut self, testfile: &Utf8Path, test_revision: Option<&str>, config
             );
         }
 
-        if self.should_ice {
-            self.failure_status = Some(101);
-        }
-
         if config.mode == TestMode::Incremental {
             self.incremental = true;
         }

src/tools/compiletest/src/directives/directive_names.rs

@@ -286,7 +286,6 @@
     "rustc-env",
     "rustfix-only-machine-applicable",
     "should-fail",
-    "should-ice",
     "stderr-per-bitwidth",
     "test-mir-pass",
     "unique-doc-out-dir",

src/tools/compiletest/src/directives/handlers.rs

@@ -115,9 +115,6 @@ fn make_directive_handlers_map() -> HashMap<&'static str, Handler> {
                 props.pp_exact = config.parse_pp_exact(ln);
             }
         }),
-        handler(SHOULD_ICE, |config, ln, props| {
-            config.set_name_directive(ln, SHOULD_ICE, &mut props.should_ice);
-        }),
         handler(BUILD_AUX_DOCS, |config, ln, props| {
             config.set_name_directive(ln, BUILD_AUX_DOCS, &mut props.build_aux_docs);
         }),

src/tools/compiletest/src/runtest.rs

@@ -266,12 +266,6 @@ impl<'test> TestCx<'test> {
     /// Code executed for each revision in turn (or, if there are no
     /// revisions, exactly once, with revision == None).
     fn run_revision(&self) {
-        if self.props.should_ice
-            && self.config.mode != TestMode::Incremental
-            && self.config.mode != TestMode::Crashes
-        {
-            self.fatal("cannot use should-ice in a test that is not cfail");
-        }
         // Run the test multiple times if requested.
         // This is useful for catching flaky tests under the parallel frontend.
         for _ in 0..self.config.iteration_count {
@@ -672,16 +666,6 @@ fn check_regex_error_patterns(
         }
     }
 
-    fn check_no_compiler_crash(&self, proc_res: &ProcRes, should_ice: bool) {
-        match proc_res.status.code() {
-            Some(101) if !should_ice => {
-                self.fatal_proc_rec("compiler encountered internal error", proc_res)
-            }
-            None => self.fatal_proc_rec("compiler terminated by signal", proc_res),
-            _ => (),
-        }
-    }
-
     fn check_forbid_output(&self, output_to_check: &str, proc_res: &ProcRes) {
         for pat in &self.props.forbid_output {
             if output_to_check.contains(pat) {

src/tools/compiletest/src/runtest/codegen_units.rs

@@ -14,8 +14,6 @@ pub(super) fn run_codegen_units_test(&self) {
             self.fatal_proc_rec("compilation failed!", &proc_res);
         }
 
-        self.check_no_compiler_crash(&proc_res, self.props.should_ice);
-
         const PREFIX: &str = "MONO_ITEM ";
         const CGU_MARKER: &str = "@@";
 

src/tools/compiletest/src/runtest/incremental.rs

@@ -32,14 +32,8 @@ pub(super) fn run_incremental_test(&self) {
         }
 
         if revision.starts_with("cpass") {
-            if self.props.should_ice {
-                self.fatal("can only use should-ice in cfail tests");
-            }
             self.run_cpass_test();
         } else if revision.starts_with("rpass") {
-            if self.props.should_ice {
-                self.fatal("can only use should-ice in cfail tests");
-            }
             self.run_rpass_test();
         } else if revision.starts_with("cfail") {
             self.run_cfail_test();
@@ -84,16 +78,7 @@ fn run_cfail_test(&self) {
         let pm = self.pass_mode();
         let proc_res = self.compile_test(WillExecute::No, self.should_emit_metadata(pm));
         self.check_if_test_should_compile(Some(FailMode::Build), pm, &proc_res);
-        self.check_no_compiler_crash(&proc_res, self.props.should_ice);
-
         self.check_compiler_output_for_incr(&proc_res);
-
-        if self.props.should_ice {
-            match proc_res.status.code() {
-                Some(101) => (),
-                _ => self.fatal("expected ICE"),
-            }
-        }
     }
 
     fn check_compiler_output_for_incr(&self, proc_res: &ProcRes) {

tests/codegen-llvm/issues/issue-123712-str-to-lower-autovectorization.rs

@@ -19,5 +19,6 @@
 // CHECK-NEXT: [[C:%[0-9]]] = bitcast <16 x i1> [[B]] to i16
 #[no_mangle]
 pub fn lower_while_ascii(s: &str) -> (alloc::string::String, &str) {
-    alloc::str::convert_while_ascii(s, u8::to_ascii_lowercase)
+    // SAFETY: `to_ascii_lowercase` preserves ASCII bytes.
+    unsafe { alloc::str::convert_while_ascii(s, u8::to_ascii_lowercase) }
 }

tests/debuginfo/basic-stepping.rs

@@ -142,8 +142,8 @@
 fn main () {
     let a = (); // #break
     let b : [i32; 0] = [];
-    // FIXME(#97083): Should we be able to break on initialization of zero-sized types?
-    // FIXME(#97083): Right now the first breakable line is:
+    // The above lines initialize zero-sized types. That does not emit machine
+    // code, so the first breakable line is:
     let mut c = 27;
     let d = c = 99;
     let e = "hi bob";

tests/incremental/delayed_span_bug.rs

@@ -1,5 +1,5 @@
 //@ revisions: cfail1 cfail2
-//@ should-ice
+//@ failure-status: 101
 
 #![feature(rustc_attrs)]
 

tests/run-make/c-link-to-rust-va-list-fn/checkrust.rs

@@ -30,17 +30,17 @@ unsafe fn compare_c_str(ptr: *const c_char, val: &CStr) -> bool {
     continue_if!(ap.arg::<c_int>() == '4' as c_int);
     continue_if!(ap.arg::<c_int>() == ';' as c_int);
     continue_if!(ap.arg::<c_int>() == 0x32);
-    continue_if!(ap.arg::<c_int>() == 0x10000001);
+    continue_if!(ap.arg::<i32>() == 0x10000001);
     continue_if!(compare_c_str(ap.arg::<*const c_char>(), c"Valid!"));
     0
 }
 
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn check_list_2(mut ap: VaList) -> usize {
-    continue_if!(ap.arg::<c_double>() == 3.14f64);
+    continue_if!(ap.arg::<c_double>() == 3.14);
     continue_if!(ap.arg::<c_long>() == 12);
     continue_if!(ap.arg::<c_int>() == 'a' as c_int);
-    continue_if!(ap.arg::<c_double>() == 6.28f64);
+    continue_if!(ap.arg::<c_double>() == 6.28);
     continue_if!(compare_c_str(ap.arg::<*const c_char>(), c"Hello"));
     continue_if!(ap.arg::<c_int>() == 42);
     continue_if!(compare_c_str(ap.arg::<*const c_char>(), c"World"));
@@ -49,7 +49,7 @@ unsafe fn compare_c_str(ptr: *const c_char, val: &CStr) -> bool {
 
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn check_list_copy_0(mut ap: VaList) -> usize {
-    continue_if!(ap.arg::<c_double>() == 6.28f64);
+    continue_if!(ap.arg::<c_double>() == 6.28);
     continue_if!(ap.arg::<c_int>() == 16);
     continue_if!(ap.arg::<c_int>() == 'A' as c_int);
     continue_if!(compare_c_str(ap.arg::<*const c_char>(), c"Skip Me!"));
@@ -66,7 +66,7 @@ unsafe fn compare_c_str(ptr: *const c_char, val: &CStr) -> bool {
 
 #[unsafe(no_mangle)]
 pub unsafe extern "C" fn check_varargs_1(_: c_int, mut ap: ...) -> usize {
-    continue_if!(ap.arg::<c_double>() == 3.14f64);
+    continue_if!(ap.arg::<c_double>() == 3.14);
     continue_if!(ap.arg::<c_long>() == 12);
     continue_if!(ap.arg::<c_int>() == 'A' as c_int);
     continue_if!(ap.arg::<c_longlong>() == 1);
@@ -156,7 +156,7 @@ extern "C" fn run_test_variadic() -> usize {
 
 #[unsafe(no_mangle)]
 extern "C" fn run_test_va_list_by_value() -> usize {
-    unsafe extern "C" fn helper(mut ap: ...) -> usize {
+    unsafe extern "C" fn helper(ap: ...) -> usize {
         unsafe { test_va_list_by_value(ap) }
     }
 

tests/run-make/c-link-to-rust-va-list-fn/test.c

@@ -32,7 +32,7 @@ int test_rust(size_t (*fn)(va_list), ...) {
 int main(int argc, char* argv[]) {
     assert(test_rust(check_list_0, 0x01LL, 0x02, 0x03LL) == 0);
 
-    assert(test_rust(check_list_1, -1, 'A', '4', ';', 0x32, 0x10000001, "Valid!") == 0);
+    assert(test_rust(check_list_1, -1, 'A', '4', ';', 0x32, (int32_t)0x10000001, "Valid!") == 0);
 
     assert(test_rust(check_list_2, 3.14, 12l, 'a', 6.28, "Hello", 42, "World") == 0);
 

tests/rustdoc-gui/copy-path.goml

@@ -18,3 +18,19 @@ assert-size: ("#copy-path.clicked", {"width": |width|, "height": |height|})
 wait-for: "#copy-path:not(.clicked)"
 // We check that the size is still the same.
 assert-size: ("#copy-path:not(.clicked)", {"width": |width|, "height": |height|})
+
+// Check the path for a module.
+go-to: "file://" + |DOC_PATH| + "/test_docs/foreign_impl_order/index.html"
+click: "#copy-path"
+// We wait for the new text to appear.
+wait-for: "#copy-path.clicked"
+// We check that the clipboard value is the expected one.
+assert-clipboard: "test_docs::foreign_impl_order"
+
+// Check the path for the crate.
+go-to: "file://" + |DOC_PATH| + "/test_docs/index.html"
+click: "#copy-path"
+// We wait for the new text to appear.
+wait-for: "#copy-path.clicked"
+// We check that the clipboard value is the expected one.
+assert-clipboard: "test_docs"

tests/rustdoc-html/reexport/type-alias-reexport.rs

@@ -0,0 +1,34 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/154921>.
+// This test ensures that auto-generated and explicit `doc(cfg)` attributes are correctly
+// preserved for locally re-exported type aliases.
+
+//@ compile-flags: --cfg feature="foo"
+
+#![crate_name = "foo"]
+#![feature(doc_cfg)]
+
+mod inner {
+    #[cfg(feature = "foo")]
+    pub type One = u32;
+
+    #[doc(cfg(feature = "foo"))]
+    pub type Two = u32;
+}
+
+//@ has 'foo/index.html'
+// There should be two items in the type aliases table.
+//@ count - '//*[@class="item-table"]/dt' 2
+// Both of them should have the portability badge in the module index.
+//@ count - '//*[@class="item-table"]/dt/*[@class="stab portability"]' 2
+
+//@ has 'foo/type.One.html'
+// Check that the individual type page has the portability badge.
+//@ count - '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' 1
+//@ has - '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' 'foo'
+
+//@ has 'foo/type.Two.html'
+// Check the explicit doc(cfg) type page as well.
+//@ count - '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' 1
+//@ has - '//*[@id="main-content"]/*[@class="item-info"]/*[@class="stab portability"]' 'foo'
+
+pub use self::inner::{One, Two};

tests/rustdoc-html/unicode.rs

@@ -0,0 +1,10 @@
+#![crate_name = "unicode"]
+
+pub struct Foo;
+
+impl Foo {
+    //@ has unicode/struct.Foo.html //a/@href "#%C3%BA"
+    //@ !has unicode/struct.Foo.html //a/@href "#ú"
+    /// # ú
+    pub fn foo() {}
+}

tests/ui/borrowck/borrowck-for-loop-deref-pattern-assignment.stderr

@@ -8,8 +8,9 @@ LL |         num *= 2;
    |
 help: consider making this binding mutable
    |
-LL |     for &(mut num) num in nums {
-   |          +++++++++
+LL -     for &num in nums {
+LL +     for &(mut num) in nums {
+   |
 
 error: aborting due to 1 previous error
 

tests/ui/borrowck/borrowck_for_loop_pattern_assignment.rs

@@ -0,0 +1,9 @@
+//! regression test for <https://github.com/rust-lang/rust/issues/155030>
+
+fn main() {
+    let nums: [u32; 3] = [1, 2, 3];
+    for num in nums {
+        num *= 2; //~ ERROR cannot assign twice to immutable variable `num`
+        println!("{num}");
+    }
+}

tests/ui/borrowck/borrowck_for_loop_pattern_assignment.stderr

@@ -0,0 +1,16 @@
+error[E0384]: cannot assign twice to immutable variable `num`
+  --> $DIR/borrowck_for_loop_pattern_assignment.rs:6:9
+   |
+LL |     for num in nums {
+   |         --- first assignment to `num`
+LL |         num *= 2;
+   |         ^^^^^^^^ cannot assign twice to immutable variable
+   |
+help: consider making this binding mutable
+   |
+LL |     for mut num in nums {
+   |         +++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0384`.

tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.rs

@@ -9,6 +9,7 @@ fn foo(&self) {
         let _ = format!("{ x}"); //~ ERROR invalid format string: expected `}`, found `x`
         let _ = format!("{}", x); //~ ERROR cannot find value `x` in this scope [E0425]
         println!("{x}"); //~ ERROR cannot find value `x` in this scope [E0425]
+        let _ = {x}; //~ERROR cannot find value `x` in this scope [E0425]
     }
 }
 

tests/ui/resolve/suggestions/sugg-field-in-format-string-issue-141136.stderr

@@ -14,7 +14,10 @@ error[E0425]: cannot find value `x` in this scope
 LL |         let _ = format!("{x}");
    |                           ^
    |
-   = help: you might have meant to use the available field in a format string: `"{}", self.x`
+help: you might have meant to use the available field
+   |
+LL |         let _ = format!("{self.x}");
+   |                           +++++
 
 error[E0425]: cannot find value `x` in this scope
   --> $DIR/sugg-field-in-format-string-issue-141136.rs:8:27
@@ -22,7 +25,10 @@ error[E0425]: cannot find value `x` in this scope
 LL |         let _ = format!("{x }");
    |                           ^^
    |
-   = help: you might have meant to use the available field in a format string: `"{}", self.x`
+help: you might have meant to use the available field
+   |
+LL |         let _ = format!("{self.x }");
+   |                           +++++
 
 error[E0425]: cannot find value `x` in this scope
   --> $DIR/sugg-field-in-format-string-issue-141136.rs:10:31
@@ -41,8 +47,22 @@ error[E0425]: cannot find value `x` in this scope
 LL |         println!("{x}");
    |                    ^
    |
-   = help: you might have meant to use the available field in a format string: `"{}", self.x`
+help: you might have meant to use the available field
+   |
+LL |         println!("{self.x}");
+   |                    +++++
 
-error: aborting due to 5 previous errors
+error[E0425]: cannot find value `x` in this scope
+  --> $DIR/sugg-field-in-format-string-issue-141136.rs:12:18
+   |
+LL |         let _ = {x};
+   |                  ^
+   |
+help: you might have meant to use the available field
+   |
+LL |         let _ = {self.x};
+   |                  +++++
+
+error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0425`.

tests/ui/resolve/typo-suggestion-for-variable-with-name-similar-to-struct-field.stderr

@@ -34,7 +34,10 @@ error[E0425]: cannot find value `config` in this scope
 LL |         println!("{config}");
    |                    ^^^^^^
    |
-   = help: you might have meant to use the available field in a format string: `"{}", self.config`
+help: you might have meant to use the available field
+   |
+LL |         println!("{self.config}");
+   |                    +++++
 help: a local variable with a similar name exists
    |
 LL -         println!("{config}");

triagebot.toml

@@ -1451,6 +1451,12 @@ code; adding it needs t-lang approval.
 """
 cc = ["@rust-lang/wg-const-eval"]
 
+[mentions."compiler/rustc_attr_parsing/src/attributes/diagnostic"]
+message = "Some changes occurred to diagnostic attributes."
+cc = ["@mejrs"]
+[mentions."compiler/rustc_hir/src/attrs/diagnostic.rs"]
+message = "Some changes occurred to diagnostic attributes."
+cc = ["@mejrs"]
 
 # ------------------------------------------------------------------------------
 # PR assignments